c++: Fix null this pointer [PR 98624]

[gcc.git] / gcc / cp / module.cc

/* C++ modules.  Experimental!
   Copyright (C) 2017-2021 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.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

/* 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.  */

/* (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_EXPORT_P, DECL_MODULE_PURVIEW_P and DECL_MODULE_IMPORT_P.  The
   first indicates whether it is exported, the second whether it is in
   the module purview (as opposed to the global module fragment), and
   the third indicates whether it was an import into this TU or not.

   The more detailed flags are DECL_MODULE_PARTITION_P,
   DECL_MODULE_ENTITY_P & DECL_MODULE_PENDING_SPECIALIZATIONS_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.  DECL_MODULE_PENDING_SPECIALIZATIONS_P is set on a
   primary template, and indicates there are specializations that
   should be streamed in before trying to specialize this template.

   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).

Classes 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.   */

/* 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.  */
#define IS_EXPERIMENTAL(V) ((V) >= (1U << 20))
#define MODULE_MAJOR(V) ((V) / 10000)
#define MODULE_MINOR(V) ((V) % 10000)
#define EXPERIMENT(A,B) (IS_EXPERIMENTAL (MODULE_VERSION) ? (A) : (B))
#ifndef MODULE_VERSION
// Be sure you're ready!  Remove #error this before release!
#error "Shtopp! What are you doing? This is not ready yet."
#include "bversion.h"
#define MODULE_VERSION (BUILDING_GCC_MAJOR * 10000U + BUILDING_GCC_MINOR)
#elif !IS_EXPERIMENTAL (MODULE_VERSION)
#error "This is not the version I was looking for."
#endif

#define _DEFAULT_SOURCE 1 /* To get TZ field of struct tm, if available.  */
#include "config.h"
#define INCLUDE_STRING
#define INCLUDE_VECTOR
#include "system.h"
#include "coretypes.h"
#include "cp-tree.h"
#include "timevar.h"
#include "stringpool.h"
#include "dumpfile.h"
#include "bitmap.h"
#include "cgraph.h"
#include "tree-iterator.h"
#include "cpplib.h"
#include "mkdeps.h"
#include "incpath.h"
#include "libiberty.h"
#include "stor-layout.h"
#include "version.h"
#include "tree-diagnostic.h"
#include "toplev.h"
#include "opts.h"
#include "attribs.h"
#include "intl.h"
#include "langhooks.h"
/* This TU doesn't need or want to see the networking.  */
#define CODY_NETWORKING 0
#include "mapper-client.h"

#if 0 // 1 for testing no mmap
#define MAPPED_READING 0
#define MAPPED_WRITING 0
#else
#if HAVE_MMAP_FILE && _POSIX_MAPPED_FILES > 0
/* mmap, munmap.  */
#define MAPPED_READING 1
#if HAVE_SYSCONF && defined (_SC_PAGE_SIZE)
/* msync, sysconf (_SC_PAGE_SIZE), ftruncate  */
/* posix_fallocate used if available.  */
#define MAPPED_WRITING 1
#else
#define MAPPED_WRITING 0
#endif
#else
#define MAPPED_READING 0
#define MAPPED_WRITING 0
#endif
#endif

/* Some open(2) flag differences, what a colourful world it is!  */
#if defined (O_CLOEXEC)
// OK
#elif defined (_O_NOINHERIT)
/* Windows' _O_NOINHERIT matches O_CLOEXEC flag */
#define O_CLOEXEC _O_NOINHERIT
#else
#define O_CLOEXEC 0
#endif
#if defined (O_BINARY)
// Ok?
#elif defined (_O_BINARY)
/* Windows' open(2) call defaults to text!  */
#define O_BINARY _O_BINARY
#else
#define O_BINARY 0
#endif

static inline cpp_hashnode *cpp_node (tree id)
{
  return CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (id));
}
static inline tree identifier (cpp_hashnode *node)
{
  return HT_IDENT_TO_GCC_IDENT (HT_NODE (node));
}
static inline const_tree identifier (const cpp_hashnode *node)
{
  return identifier (const_cast <cpp_hashnode *> (node));
}

/* During duplicate detection we need to tell some comparators that
   these are equivalent.  */
tree map_context_from;
tree map_context_to;

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

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

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

/* Format a version for user consumption.  */

typedef char verstr_t[32];
static void
version2string (unsigned version, verstr_t &out)
{
  unsigned major = MODULE_MAJOR (version);
  unsigned minor = MODULE_MINOR (version);

  if (IS_EXPERIMENTAL (version))
    sprintf (out, "%04u/%02u/%02u-%02u:%02u%s",
             2000 + major / 10000, (major / 100) % 100, (major % 100),
             minor / 100, minor % 100,
             EXPERIMENT ("", " (experimental)"));
  else
    sprintf (out, "%u.%u", major, minor);
}

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

/* Traits to hash an arbitrary pointer.  Entries are not deletable,
   and removal is a noop (removal needed upon destruction).  */
template <typename T>
struct 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 (); }
};

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

/********************************************************************/
/* 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.   */

/* Variable length buffer.  */

class data {
public:
  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);
  };

public:
  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.  */

public:
  data ()
    :buffer (NULL), size (0), pos (0)
  {
  }
  ~data ()
  {
    /* Make sure the derived and/or using class know what they're
       doing.  */
    gcc_checking_assert (!buffer);
  }

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

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

public:
  static allocator simple_memory;
};

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

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

void
data::allocator::grow (data &obj, unsigned needed, bool exact)
{
  gcc_checking_assert (needed ? needed > obj.size : !obj.size);
  if (!needed)
    /* Pick a default size.  */
    needed = EXPERIMENT (100, 1000);

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

/* Free a buffer.  */

void
data::allocator::shrink (data &obj)
{
  shrink (obj.buffer);
  obj.buffer = NULL;
  obj.size = 0;
}

char *
data::allocator::grow (char *ptr, unsigned needed)
{
  return XRESIZEVAR (char, ptr, needed);
}

void
data::allocator::shrink (char *ptr)
{
  XDELETEVEC (ptr);
}

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

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

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

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

protected:
  unsigned calc_crc (unsigned) const;

protected:
  /* Finish bit packet.  Rewind the bytes not used.  */
  unsigned bit_flush ()
  {
    gcc_assert (bit_pos);
    unsigned bytes = (bit_pos + 7) / 8;
    unuse (4 - bytes);
    bit_pos = 0;
    bit_val = 0;
    return bytes;
  }
};

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

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

class elf_in;

/* Byte stream reader.  */

class bytes_in : public bytes {
  typedef bytes parent;

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

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

public:
  /* 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 * = NULL);
  /* 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;
  }

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

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

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

public:
  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];
  }

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

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

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

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

public:
  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_INT wi ();  /* Read a HOST_WIDE_INT.  */
  unsigned HOST_WIDE_INT wu (); /* Read an unsigned HOST_WIDE_INT.  */
  const char *str (size_t * = NULL); /* Read a string.  */
  const void *buf (size_t); /* Read a fixed-length buffer.  */
  cpp_hashnode *cpp_node (); /* Read a cpp node.  */
};

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

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

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

  return true;
}

class elf_out;

/* Byte stream writer.  */

class bytes_out : public bytes {
  typedef bytes parent;

public:
  allocator *memory;    /* Obtainer of memory.  */
  
public:
  bytes_out (allocator *memory)
    : parent (), memory (memory)
  {
  }
  ~bytes_out ()
  {
  }

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

public:
  void set_crc (unsigned *crc_ptr);

public:
  /* 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 = NULL);

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

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

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

public:
  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_INT); /* Write HOST_WIDE_INT.  */
  void wu (unsigned HOST_WIDE_INT);  /* 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_LEN (node));
  }
  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 */

public:
  /* Format a NUL-terminated raw string.  */
  void printf (const char *, ...) ATTRIBUTE_PRINTF_2;
  void print_time (const char *, const tm *, const char *);

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

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

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

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

void
bytes_out::set_crc (unsigned *crc_ptr)
{
  if (crc_ptr)
    {
      gcc_checking_assert (pos >= 4);

      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;
    }
}

/* Finish a set of bools.  */

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

void
bytes_in::bflush ()
{
  if (bit_pos)
    bit_flush ();
}

/* 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.  */

void
bytes_in::bfill ()
{
  bit_val = u32 ();
}

/* 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?  */

void
bytes_out::b (bool x)
{
  if (is_set != x)
    {
      is_set = x;
      spans[x]++;
    }
  lengths[x]++;
  bit_val |= unsigned (x) << bit_pos++;
  if (bit_pos == 32)
    {
      u32 (bit_val);
      lengths[2] += bit_flush ();
    }
}

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

/* 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.  */

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

unsigned
bytes_in::u32 ()
{
  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;
}

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

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

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

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

void
bytes_out::i (int v)
{
  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;
        }
    }
}

int
bytes_in::i ()
{
  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;
          if ((ptr = read (++bytes)))
            while (bytes--)
              v = (v << 8) | (*ptr++ & 0xff);
        }
      else if (v & 0x40)
        v |= -1 ^ 0x3f;
    }

  return v;
}

void
bytes_out::u (unsigned v)
{
  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;
        }
    }
}

unsigned
bytes_in::u ()
{
  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;
}

void
bytes_out::wi (HOST_WIDE_INT v)
{
  if (char *ptr = write (1))
    {
      if (v <= 0x3f && v >= -0x40)
        *ptr = v & 0x7f;
      else
        {
          unsigned bytes = 0;
          HOST_WIDE_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;
        }
    }
}

HOST_WIDE_INT
bytes_in::wi ()
{
  HOST_WIDE_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;
          if ((ptr = read (++bytes)))
            while (bytes--)
              v = (v << 8) | (*ptr++ & 0xff);
        }
      else if (v & 0x40)
        v |= -1 ^ 0x3f;
    }

  return v;
}

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

inline void
bytes_out::wu (unsigned HOST_WIDE_INT v)
{
  wi ((HOST_WIDE_INT) v);
}

inline unsigned HOST_WIDE_INT
bytes_in::wu ()
{
  return (unsigned HOST_WIDE_INT) wi ();
}

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

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

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

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

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

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

  return ptr;
}

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

void
bytes_out::str (const char *string, size_t len)
{
  z (len);
  if (len)
    {
      gcc_checking_assert (!string[len]);
      buf (string, len + 1);
    }
}

const char *
bytes_in::str (size_t *len_p)
{
  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 = NULL;
  if (len)
    {
      str = reinterpret_cast<const char *> (buf (len + 1));
      if (!str || str[len])
        {
          set_overrun ();
          str = NULL;
        }
    }
  return str ? str : "";
}

cpp_hashnode *
bytes_in::cpp_node ()
{
  size_t len;
  const char *s = str (&len);
  if (!len)
    return NULL;
  return ::cpp_node (get_identifier_with_length (s, len));
}

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

void
bytes_out::printf (const char *format, ...)
{
  va_list args;
  /* Exercise buffer expansion.  */
  size_t len = EXPERIMENT (10, 500);

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

void
bytes_out::print_time (const char *kind, const tm *time, const char *tz)
{
  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);
}

/* 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.   */

class elf {
protected:
  /* 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
#ifdef WORDS_BIGENDIAN
    ^ DATA2LSB ^ DATA2MSB
#endif
  };

public:
  /* 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.  */
  };

protected:
  /* 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 */
  };

protected:
  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.  */

public:
  /* 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
                         && !sectab.buffer && !strtab.buffer);
  }

public:
  /* 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;

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

/* Return error string.  */

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

  switch (err)
    {
    case 0:
      gcc_unreachable ();
    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);
    }
}

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

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

  return !get_error ();
}

/* ELROND reader.  */

class elf_in : public elf {
  typedef elf parent;

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

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

public:
  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)
  {
#if MAPPED_READING
    if (hdr.buffer && bytes.buffer >= hdr.buffer
        && bytes.buffer < hdr.buffer + hdr.pos)
      {
        char *buf = bytes.buffer;
        bytes.buffer = data::simple_memory.grow (NULL, bytes.size);
        memcpy (bytes.buffer, buf, bytes.size);
      }
#endif
  }
  /* If BYTES is not in SELF's mmapped area, free it.  SELF might be
     NULL. */
  static void release (elf_in *self ATTRIBUTE_UNUSED, bytes_in &bytes)
  {
#if MAPPED_READING
    if (!(self && self->hdr.buffer && bytes.buffer >= self->hdr.buffer
          && bytes.buffer < self->hdr.buffer + self->hdr.pos))
#endif
      data::simple_memory.shrink (bytes.buffer);
    bytes.buffer = NULL;
    bytes.size = 0;
  }

public:
  static void grow (data &data, unsigned needed)
  {
    gcc_checking_assert (!data.buffer);
#if !MAPPED_READING
    data.buffer = XNEWVEC (char, needed);
#endif
    data.size = needed;
  }
  static void shrink (data &data)
  {
#if !MAPPED_READING
    XDELETEVEC (data.buffer);
#endif
    data.buffer = NULL;
    data.size = 0;
  }

public:
  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 NULL;
  }
  unsigned get_section_limit () const
  {
    return sectab.size / sizeof (section);
  }

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

public:
  /* 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);

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

public:
  bool begin (location_t);
  bool end ()
  {
    release ();
#if MAPPED_READING
    if (hdr.buffer)
      munmap (hdr.buffer, hdr.pos);
    hdr.buffer = NULL;
#endif
    shrink (sectab);

    return parent::end ();
  }

public:
  /* 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];
  }
};

/* ELROND writer.  */

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

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

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

#if MAPPED_WRITING
private:
  void create_mapping (unsigned ext, bool extending = true);
  void remove_mapping ();
#endif

protected:
  using allocator::grow;
  virtual char *grow (char *, unsigned needed);
#if MAPPED_WRITING
  using allocator::shrink;
  virtual void shrink (char *);
#endif

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

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

public:
  /* 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);

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

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

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

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

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

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

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

bool
bytes_in::begin (location_t loc, elf_in *source, unsigned snum, const char *name)
{
  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;
}

/* Finish reading a section.  */

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

  src->shrink (*this);

  return !overrun;
}

/* Begin writing buffer.  */

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

/* 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.  */

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

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

  return sec_num;
}

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

void
elf_in::freeze ()
{
  gcc_checking_assert (!is_frozen ());
#if MAPPED_READING
  if (munmap (hdr.buffer, hdr.pos) < 0)
    set_error (errno);
#endif
  if (close (fd) < 0)
    set_error (errno);
  fd = -1;
}

bool
elf_in::defrost (const char *name)
{
  gcc_checking_assert (is_frozen ());
  struct stat stat;

  fd = open (name, O_RDONLY | O_CLOEXEC | O_BINARY);
  if (fd < 0 || fstat (fd, &stat) < 0)
    set_error (errno);
  else
    {
      bool ok = hdr.pos == unsigned (stat.st_size);
#ifndef HOST_LACKS_INODE_NUMBERS
      if (device != stat.st_dev
          || inode != stat.st_ino)
        ok = false;
#endif
      if (!ok)
        set_error (EMFILE);
#if MAPPED_READING
      if (ok)
        {
          char *mapping = reinterpret_cast<char *>
            (mmap (NULL, hdr.pos, PROT_READ, MAP_SHARED, fd, 0));
          if (mapping == MAP_FAILED)
          fail:
              set_error (errno);
          else
            {
              if (madvise (mapping, hdr.pos, MADV_RANDOM))
                goto fail;

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

  return !get_error ();
}

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

const char *
elf_in::read (data *data, unsigned pos, unsigned length)
{
#if MAPPED_READING
  if (pos + length > hdr.pos)
    {
      set_error (EINVAL);
      return NULL;
    }
#else
  if (pos != ~0u && lseek (fd, pos, SEEK_SET) < 0)
    {
      set_error (errno);
      return NULL;
    }
#endif
  grow (*data, length);
#if MAPPED_READING  
  data->buffer = hdr.buffer + pos;
#else
  if (::read (fd, data->buffer, data->size) != ssize_t (length))
    {
      set_error (errno);
      shrink (*data);
      return NULL;
    }
#endif

  return data->buffer;
}

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

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

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

unsigned
elf_in::find (const char *sname)
{
  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;
}

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

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

  struct stat stat;
  unsigned size = 0;
  if (!fstat (fd, &stat))
    {
#if !defined (HOST_LACKS_INODE_NUMBERS)
      device = stat.st_dev;
      inode = stat.st_ino;
#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);
    }

#if MAPPED_READING
  /* MAP_SHARED so that the file is backing store.  If someone else
     concurrently writes it, they're wrong.  */
  void *mapping = mmap (NULL, size, PROT_READ, MAP_SHARED, fd, 0);
  if (mapping == MAP_FAILED)
    {
    fail:
      set_error (errno);
      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_RANDOM))
    goto fail;

  hdr.buffer = (char *)mapping;
#else
  read (&hdr, 0, sizeof (header));
#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;
          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;

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

  return true;
}

/* Create a new mapping.  */

#if MAPPED_WRITING
void
elf_out::create_mapping (unsigned ext, bool extending)
{
#ifndef HAVE_POSIX_FALLOCATE
#define posix_fallocate(fd,off,len) ftruncate (fd, off + len)
#endif
  void *mapping = MAP_FAILED;
  if (extending && ext < 1024 * 1024)
    {
      if (!posix_fallocate (fd, offset, ext * 2))
        mapping = mmap (NULL, ext * 2, PROT_READ | PROT_WRITE,
                        MAP_SHARED, fd, offset);
      if (mapping != MAP_FAILED)
        ext *= 2;
    }
  if (mapping == MAP_FAILED)
    {
      if (!extending || !posix_fallocate (fd, offset, ext))
        mapping = mmap (NULL, ext, PROT_READ | PROT_WRITE,
                        MAP_SHARED, fd, offset);
      if (mapping == MAP_FAILED)
        {
          set_error (errno);
          mapping = NULL;
          ext = 0;
        }
    }
#undef posix_fallocate
  hdr.buffer = (char *)mapping;
  extent = ext;
}
#endif

/* Flush out the current mapping.  */

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

  hdr.buffer = NULL;
}
#endif

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

char *
elf_out::grow (char *data, unsigned needed)
{
  if (!data)
    {
      /* First allocation, check we're aligned.  */
      gcc_checking_assert (!(pos & (SECTION_ALIGN - 1)));
#if MAPPED_WRITING
      data = hdr.buffer + (pos - offset);
#endif
    }

#if MAPPED_WRITING
  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);

      remove_mapping ();

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

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

  return data;
}

#if MAPPED_WRITING
/* Shrinking is a NOP.  */
void
elf_out::shrink (char *)
{
}
#endif

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

unsigned
elf_out::strtab_write (const char *s, unsigned l)
{
  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;
}

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

void
elf_out::strtab_write (tree decl, int inner)
{
  tree ctx = CP_DECL_CONTEXT (decl);
  if (TYPE_P (ctx))
    ctx = TYPE_NAME (ctx);
  if (ctx != global_namespace)
    strtab_write (ctx, -1);

  tree name = DECL_NAME (decl);
  if (!name)
    name = DECL_ASSEMBLER_NAME_RAW (decl);
  strtab_write (IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));

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

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

unsigned
elf_out::name (tree ident)
{
  unsigned res = 0;
  if (ident)
    {
      bool existed;
      int *slot = &identtab.get_or_insert (ident, &existed);
      if (!existed)
        *slot = strtab_write (IDENTIFIER_POINTER (ident),
                              IDENTIFIER_LENGTH (ident) + 1);
      res = *slot;
    }
  return res;
}

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

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

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

unsigned
elf_out::qualified_name (tree decl, bool is_defn)
{
  gcc_checking_assert (DECL_P (decl) && decl != global_namespace);
  unsigned result = strtab.pos;

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

  return result;
}

/* 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.  */

unsigned
elf_out::add (unsigned type, unsigned name, unsigned off, unsigned size,
              unsigned flags)
{
  gcc_checking_assert (!(off & (SECTION_ALIGN - 1)));
  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);
}

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

unsigned
elf_out::write (const data &buffer)
{
#if MAPPED_WRITING
  /* 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)));
#else
  if (::write (fd, buffer.buffer, buffer.pos) != ssize_t (buffer.pos))
    {
      set_error (errno);
      return 0;
    }
#endif
  unsigned res = pos;
  pos += buffer.pos;

  if (unsigned padding = -pos & (SECTION_ALIGN - 1))
    {
#if !MAPPED_WRITING
      /* 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);
#endif
      pos += padding;
    }
  return res;
}

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

#if MAPPED_WRITING
unsigned
elf_out::write (const bytes_out &buf)
{
  gcc_checking_assert (buf.memory == this);
  /* A directly mapped buffer.  */
  gcc_checking_assert (buf.buffer - hdr.buffer >= 0
                       && buf.buffer - hdr.buffer + buf.size <= extent);
  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;
}
#endif

/* 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).  */

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

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

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

bool
elf_out::begin ()
{
  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);

#if MAPPED_WRITING
  /* Start a mapping.  */
  create_mapping (EXPERIMENT (page_size,
                              (32767 + page_size) & ~(page_size - 1)));
  if (!hdr.buffer)
    return false;
#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 ();
}

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

bool
elf_out::end ()
{
  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);

#if MAPPED_WRITING
      if (offset)
        {
          remove_mapping ();
          offset = 0;
          create_mapping ((sizeof (header) + page_size - 1) & ~(page_size - 1),
                          false);
        }
      unsigned length = pos;
#else
      if (lseek (fd, 0, SEEK_SET) < 0)
        set_error (errno);
#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);
        }

#if MAPPED_WRITING
      remove_mapping ();
      if (ftruncate (fd, length))
        set_error (errno);
#endif
    }

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

  return parent::end ();
}

/********************************************************************/

/* 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.   */

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

public:
  /* 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 it's imported
                           context.  */
    EK_DIRECT_HWM = EK_PARTIAL + 1,

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

private:
  /* 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.  */
  };

public:
  /* 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.  */

public:
  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.  */

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

public:
  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 ());
    discriminator = reinterpret_cast<uintptr_t> (name);
  }

private:
  template<unsigned I> void set_flag_bit ()
  {
    gcc_checking_assert (I < 2 || !is_binding ());
    discriminator |= 1u << I;
  }
  template<unsigned I> void clear_flag_bit ()
  {
    gcc_checking_assert (I < 2 || !is_binding ());
    discriminator &= ~(1u << I);
  }
  template<unsigned I> bool get_flag_bit () const
  {
    gcc_checking_assert (I < 2 || !is_binding ());
    return bool ((discriminator >> I) & 1);
  }
  
public:
  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;

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

public:
  bool is_member () const
  {
    return get_flag_bit<DB_IS_MEMBER_BIT> ();
  }
public:
  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> ();
  }

public:
  /* 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> ();
  }

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

public:
  tree get_entity () const
  {
    return entity;
  }
  tree get_name () const
  {
    gcc_checking_assert (is_binding ());
    return reinterpret_cast <tree> (discriminator);
  }

public:
  /* 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);
          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 ());
          h = iterative_hash_hashval_t (h, nh);
        }
      return h;
    }

    /* Empty via NULL.  */
    static inline void mark_empty (value_type &p) {p = NULL;}
    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 (); }

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

public:
  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 = NULL)
      : parent (size), chain (c), current (NULL), section (0),
        sneakoscope (false), reached_unreached (false)
    {
      worklist.create (size);
    }
    ~hash ()
    {
      worklist.release ();
    }

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

  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 ();
    bool finalize_dependencies ();
    vec<depset *> connect ();
  };

public:
  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 ());
      stack.release ();
    }

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

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

inline
depset::~depset ()
{
  deps.release ();
}

const char *
depset::entity_kind_name () const
{
  /* 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 < sizeof (names) / sizeof(names[0]));
  return names[kind];
}

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

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

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

  return binding;
}

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

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

  return r;
}

/* Values keyed to some unsigned integer.  This is not GTY'd, so if
   T is tree they must be reachable via some other path.  */

template<typename T>
class uintset {
public:
  unsigned key;  /* Entity index of the other entity.  */

  /* Payload.  */
  unsigned allocp2 : 5;  /* log(2) allocated pending  */
  unsigned num : 27;    /* Number of pending.  */

  /* Trailing array of values.   */
  T values[1];

public:
  /* Even with ctors, we're very pod-like.  */
  uintset (unsigned uid)
    : key (uid), allocp2 (0), num (0)
  {
  }
  /* Copy constructor, which is exciting because of the trailing
     array.  */
  uintset (const uintset *from)
  {
    size_t size = (offsetof (uintset, values)
                   + sizeof (uintset::values) * from->num);
    memmove (this, from, size);
    if (from->num)
      allocp2++;
  }

public:
  struct traits : delete_ptr_hash<uintset> {
    typedef unsigned compare_type;
    typedef typename delete_ptr_hash<uintset>::value_type value_type;

    /* Hash and equality for compare_type.  */
    inline static hashval_t hash (const compare_type k)
    {
      return hashval_t (k);
    }
    inline static hashval_t hash (const value_type v)
    {
      return hash (v->key);
    }

    inline static bool equal (const value_type v, const compare_type k)
    {
      return v->key == k;
    }
  };

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

  public:
    hash (size_t size)
      : parent (size)
    {
    }
    ~hash ()
    {
    }

  private:
    uintset **find_slot (key_t key, insert_option insert)
    {
      return this->find_slot_with_hash (key, traits::hash (key), insert);
    }

  public:
    uintset *get (key_t key, bool extract = false);
    bool add (key_t key, T value);
    uintset *create (key_t key, unsigned num, T init = 0);
  };
};

/* Add VALUE to KEY's uintset, creating it if necessary.  Returns true
   if we created the uintset.  */

template<typename T>
bool
uintset<T>::hash::add (typename uintset<T>::hash::key_t key, T value)
{
  uintset **slot = this->find_slot (key, INSERT);
  uintset *set = *slot;
  bool is_new = !set;

  if (is_new || set->num == (1u << set->allocp2))
    {
      if (set)
        {
          unsigned n = set->num * 2;
          size_t new_size = (offsetof (uintset, values)
                             + sizeof (uintset (0u).values) * n);
          uintset *new_set = new (::operator new (new_size)) uintset (set);
          delete set;
          set = new_set;
        }
      else
        set = new (::operator new (sizeof (*set))) uintset (key);
      *slot = set;
    }

  set->values[set->num++] = value;

  return is_new;
}

template<typename T>
uintset<T> *
uintset<T>::hash::create (typename uintset<T>::hash::key_t key, unsigned num,
                          T init)
{
  unsigned p2alloc = 0;
  for (unsigned v = num; v != 1; v = (v >> 1) | (v & 1))
    p2alloc++;

  size_t new_size = (offsetof (uintset, values)
                     + (sizeof (uintset (0u).values) << p2alloc));
  uintset *set = new (::operator new (new_size)) uintset (key);
  set->allocp2 = p2alloc;
  set->num = num;
  while (num--)
    set->values[num] = init;

  uintset **slot = this->find_slot (key, INSERT);
  gcc_checking_assert (!*slot);
  *slot = set;

  return set;
}

/* Locate KEY's uintset, potentially removing it from the hash table  */

template<typename T>
uintset<T> *
uintset<T>::hash::get (typename uintset<T>::hash::key_t key, bool extract)
{
  uintset *res = NULL;

  if (uintset **slot = this->find_slot (key, NO_INSERT))
    {
      res = *slot;
      if (extract)
        /* We need to remove the pendset without deleting it. */
        traits::mark_deleted (*slot);
    }

  return res;
}

/* Entities keyed to some other entity.  When we load the other
   entity, we mark it in some way to indicate there are further
   entities to load when you start looking inside it.  For instance
   template specializations are keyed to their most general template.
   When we instantiate that, we need to know all the partial
   specializations (to pick the right template), and all the known
   specializations (to avoid reinstantiating it, and/or whether it's
   extern).  The values split into two ranges.  If !MSB set, indices
   into the entity array.  If MSB set, an indirection to another
   pendset.  */

typedef uintset<unsigned> pendset;
static pendset::hash *pending_table;

/* Some entities are attached to another entitity for ODR purposes.
   For example, at namespace scope, 'inline auto var = []{};', that
   lambda is attached to 'var', and follows its ODRness.  */
typedef uintset<tree> attachset;
static attachset::hash *attached_table;

/********************************************************************/
/* 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.  */

/* Tree tags.  */
enum 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_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.  */
};

enum 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.  */
};

enum merge_kind
{
  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_attached,  /* Found by attachee & 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_type_tmpl_spec = MK_type_spec | MK_tmpl_tmpl_mask,

  MK_decl_spec = MK_template_mask | MK_tmpl_decl_mask,
  MK_decl_tmpl_spec = MK_decl_spec | MK_tmpl_tmpl_mask,

  MK_alias_spec = MK_decl_spec | MK_tmpl_alias_mask,

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

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

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

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

/* Mergeable entity location data.  */
struct 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), args (NULL_TREE),
     constraints (NULL_TREE)
  {
  }
};

struct duplicate_hash : nodel_ptr_hash<tree_node>
{
  inline static hashval_t hash (value_type decl)
  {
    if (TREE_CODE (decl) == TREE_BINFO)
      decl = TYPE_NAME (BINFO_TYPE (decl));
    return hashval_t (DECL_UID (decl));
  }
};

/* Hashmap of merged duplicates.  Usually decls, but can contain
   BINFOs.  */
typedef hash_map<tree,uintptr_t,
                 simple_hashmap_traits<duplicate_hash,uintptr_t> >
duplicate_hash_map;

/* 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. */
class trees_in : public bytes_in {
  typedef bytes_in parent;

private:
  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.  */

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

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

private:
  tree start (unsigned = 0);

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

private:
  /* 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 ();

private:
  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);

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

private:
  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);
public:
  bool add_indirects (tree);

public:
  /* Serialize various definitions. */
  bool read_definition (tree decl);
  
private:
  bool is_matching_decl (tree existing, tree decl);
  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);

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

private:
  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;
  }

public:
  bool is_duplicate (tree decl)
  {
    return find_duplicate (decl) != NULL;
  }
  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);

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

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

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

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

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

private:
  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;
#if CHECKING_P
  int importedness;             /* Checker that imports not occurring
                                   inappropriately.  */
#endif

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

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

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

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

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

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

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

private:
  walk_kind ref_node (tree);
public:
  int get_tag (tree);
  void set_importing (int i ATTRIBUTE_UNUSED)
  {
#if CHECKING_P
    importedness = i;
#endif
  }

private:
  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);

private:
  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);

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

public:
  void tree_node (tree);

private:
  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);
public:
  void add_indirects (tree);
  void fn_parms_init (tree);
  void tpl_header (tree decl, unsigned *tpl_levels);

public:
  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);

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

public:
  void decl_value (tree, depset *);

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

private:
  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);

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

private:
  static void assert_definition (tree);

public:
  static void instrument ();

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

/* Instrumentation counters.  */
unsigned trees_out::tree_val_count;
unsigned trees_out::decl_val_count;
unsigned trees_out::back_ref_count;
unsigned trees_out::null_count;

trees_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)
{
#if CHECKING_P
  importedness = 0;
#endif
}

trees_out::~trees_out ()
{
}

/********************************************************************/
/* 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.  */


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

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

/* 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.  */

class loc_spans {
public:
  /* 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.  */
  };

private:
  vec<span> *spans;

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

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

public:
  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);
  }

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

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

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

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

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

static loc_spans spans;

/********************************************************************/
/* Data needed by a module during the process of loading.  */
struct 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 = NULL;
      }
  }

 public:
  void release_macros ();

 public:
  void alloc_remap (unsigned size)
  {
    gcc_assert (!remap);
    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);
  }
};

slurping::slurping (elf_in *from)
  : remap (NULL), from (from),
    headers (BITMAP_GGC_ALLOC ()), macro_defs (), macro_tbl (),
    loc_deltas (0, 0),
    current (~0u), remaining (0), lru (0)
{
}

slurping::~slurping ()
{
  vec_free (remap);
  remap = NULL;
  release_macros ();
  close ();
}

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

/* Information about location maps used during writing.  */

struct location_map_info {
  range_t num_maps;

  unsigned max_range;
};

/* Flage for extensions that end up being streamed.  */

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

/********************************************************************/
struct module_state_config;

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

/* Increasing levels of directness (toplevel) of import.  */
enum 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.  */
};

/* State of a particular module. */

class 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;

  /* 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 call_init_p : 1; /* This module's global initializer needs
                           calling.  */
  /* Record extensions emitted or permitted.  */
  unsigned extensions : SE_BITS;
  /* 12 bits used, 4 bits remain  */

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

 public:
  void release ()
  {
    imports = exports = NULL;
    slurped ();
  }
  void slurped ()
  {
    delete slurp;
    slurp = NULL;
  }
  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 not a real module?  */
  bool is_rooted () const
  {
    return loc != UNKNOWN_LOCATION;
  }

 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 (elf_out *to, cpp_reader *);
  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, unsigned extensions);
  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 [], 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);

  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:
  void write_pendings (elf_out *to, vec<depset *> depsets,
                      depset::hash &, unsigned count, 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:
  location_map_info write_prepare_maps (module_state_config *);
  bool read_prepare_maps (const module_state_config *);

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

 private:
  void write_define (bytes_out &, const cpp_macro *, bool located = true);
  cpp_macro *read_define (bytes_in &, cpp_reader *, bool located = true) const;
  unsigned write_macros (elf_out *to, cpp_reader *, 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 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);
};

/* 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.  */

struct 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);
};

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

  module_p = header_p = interface_p = partition_p = false;

  directness = MD_NONE;
  exported_p = false;

  cmi_noted_p = false;
  call_init_p = false;

  partition_p = partition;

  extensions = 0;
  if (name && TREE_CODE (name) == STRING_CST)
    {
      header_p = true;

      const char *string = TREE_STRING_POINTER (name);
      gcc_checking_assert (string[0] == '.'
                           ? IS_DIR_SEPARATOR (string[1])
                           : IS_ABSOLUTE_PATH (string));
    }

  gcc_checking_assert (!(parent && header_p));
}

module_state::~module_state ()
{
  release ();
}

/* Hash module state.  */
static hashval_t
module_name_hash (const_tree name)
{
  if (TREE_CODE (name) == STRING_CST)
    return htab_hash_string (TREE_STRING_POINTER (name));
  else
    return IDENTIFIER_HASH_VALUE (name);
}

hashval_t
module_state_hash::hash (const value_type m)
{
  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);
}

/* Hash a name.  */
hashval_t
module_state_hash::hash (const compare_type &c)
{
  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);
}

bool
module_state_hash::equal (const value_type existing,
                          const compare_type &candidate)
{
  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) != STRING_CST
      || TREE_CODE (existing->name) != STRING_CST)
    return false;

  /* String equality.  */
  if (TREE_STRING_LENGTH (existing->name)
      == TREE_STRING_LENGTH (candidate.first)
      && !memcmp (TREE_STRING_POINTER (existing->name),
                  TREE_STRING_POINTER (candidate.first),
                  TREE_STRING_LENGTH (existing->name)))
    return true;

  return false;
}

/********************************************************************/
/* Global state */

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

/* CMI repository path and workspace.  */
static char *cmi_repo;
static size_t cmi_repo_length;
static char *cmi_path;
static size_t cmi_path_alloc;

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

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

/* Number of global init calls needed.  */
unsigned num_init_calls_needed = 0;

/* Global trees.  */
static 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> (NULL, 0)
  };
static GTY(()) vec<tree, va_gc> *fixed_trees;
static unsigned global_crc;

/* 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.  */
static unsigned lazy_lru;  /* LRU counter.  */
static unsigned lazy_open; /* Number of open modules */
static unsigned lazy_limit; /* Current limit of open modules.  */
static unsigned lazy_hard_limit; /* Hard limit on open modules.  */
/* 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.  */
#define LAZY_HEADROOM 15 /* File descriptor headroom.  */

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

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

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

/* 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.  */
static GTY(()) vec<tree, va_gc> *class_members;

/* 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.  */
static GTY(()) vec<tree, va_gc> *partial_specializations;

/********************************************************************/

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

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

/********************************************************************/
static tree
get_clone_target (tree decl)
{
  tree target;

  if (TREE_CODE (decl) == TEMPLATE_DECL)
    {
      tree res_orig = DECL_CLONED_FUNCTION (DECL_TEMPLATE_RESULT (decl));
      
      target = DECL_TI_TEMPLATE (res_orig);
    }
  else
    target = DECL_CLONED_FUNCTION (decl);

  gcc_checking_assert (DECL_MAYBE_IN_CHARGE_CDTOR_P (target));

  return target;
}

/* Like FOR_EACH_CLONE, but will walk cloned templates.  */
#define FOR_EVERY_CLONE(CLONE, FN)                      \
  if (!DECL_MAYBE_IN_CHARGE_CDTOR_P (FN));              \
  else                                                  \
    for (CLONE = DECL_CHAIN (FN);                       \
         CLONE && DECL_CLONED_FUNCTION_P (CLONE);       \
         CLONE = DECL_CHAIN (CLONE))

/* 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.  */

static tree
node_template_info (tree decl, int &use)
{
  tree ti = NULL_TREE;
  int use_tpl = -1;
  if (DECL_IMPLICIT_TYPEDEF_P (decl))
    {
      tree type = TREE_TYPE (decl);

      ti = TYPE_TEMPLATE_INFO (type);
      if (ti)
        {
          if (TYPE_LANG_SPECIFIC (type))
            use_tpl = CLASSTYPE_USE_TEMPLATE (type);
          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);
              if (TYPE_P (ctx))
                ctx = TYPE_NAME (ctx);
              node_template_info (ctx, use);
              use_tpl = use != 2 ? use : 0;
            }
        }
    }
  else if (DECL_LANG_SPECIFIC (decl)
           && (TREE_CODE (decl) == VAR_DECL
               || TREE_CODE (decl) == TYPE_DECL
               || TREE_CODE (decl) == FUNCTION_DECL
               || TREE_CODE (decl) == FIELD_DECL
               || TREE_CODE (decl) == TEMPLATE_DECL))
    {
      use_tpl = DECL_USE_TEMPLATE (decl);
      ti = DECL_TEMPLATE_INFO (decl);
    }

  use = use_tpl;
  return ti;
}

/* 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.  */

static unsigned
import_entity_index (tree decl, bool null_ok = false)
{
  if (unsigned *slot = entity_map->get (DECL_UID (decl)))
    return *slot;

  gcc_checking_assert (null_ok);
  return ~(~0u >> 1);
}

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

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

  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 ();
}


/********************************************************************/
/* A dumping machinery.  */

class dumper {
public:
  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.  */
  };

private:
  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.  */
  };

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

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

public:
  /* Change local indentation.  */
  void indent ()
  {
    if (dumps)
      dumps->indent++;
  }
  void outdent ()
  {
    if (dumps)
      {
        gcc_checking_assert (dumps->indent);
        dumps->indent--;
      }
  }

public:
  /* 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 *, ...);
};

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

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

unsigned
dumper::push (module_state *m)
{
  FILE *stream = NULL;
  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);
      size_t alloc = (offsetof (impl, stack)
                      + impl::stack_t::embedded_size (count));
      dumps = XRESIZEVAR (impl, 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 = NULL;

      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;
}

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

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

  gcc_checking_assert (dump () && !dumps->indent);
  if (module_state *m = dumps->stack[dumps->stack.length () - 1])
    {
      module_state *from = (dumps->stack.length () > 1
                            ? dumps->stack[dumps->stack.length () - 2] : NULL);
      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 = NULL;
    }
}

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

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

  if (t && TREE_CODE (t) == TREE_BINFO)
    t = BINFO_TYPE (t);

  if (t && TYPE_P (t))
    t = TYPE_NAME (t);

  if (t && DECL_P (t))
    {
      if (t == global_namespace || DECL_TEMPLATE_PARM_P (t))
        ;
      else if (tree ctx = DECL_CONTEXT (t))
        if (TREE_CODE (ctx) == 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)) == TEMPLATE_DECL
          && (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti)) == t))
        t = TI_TEMPLATE (ti);
      if (TREE_CODE (t) == TEMPLATE_DECL)
        fputs ("template ", stream);

      if (DECL_LANG_SPECIFIC (t) && DECL_MODULE_IMPORT_P (t))
        {
          /* 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) ? DECL_NAME (t)
        : HAS_DECL_ASSEMBLER_NAME_P (t) ? DECL_ASSEMBLER_NAME_RAW (t)
        : NULL_TREE;
    }
  else
    name = t;

  if (name)
    switch (TREE_CODE (name))
      {
      default:
        fputs ("#unnamed#", stream);
        break;

      case IDENTIFIER_NODE:
        fwrite (IDENTIFIER_POINTER (name), 1, IDENTIFIER_LENGTH (name), 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), 1,
                TREE_STRING_LENGTH (name) - (TREE_TYPE (name) != NULL_TREE),
                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));
      fputs ("<", stream);
      if (args)
        for (int ix = 0; ix != TREE_VEC_LENGTH (args); ix++)
          {
            if (ix)
              fputs (",", stream);
            nested_name (TREE_VEC_ELT (args, ix));
          }
      fputs (">", stream);
    }

  return true;
}

/* 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.  */

bool
dumper::operator () (const char *format, ...)
{
  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);
  while (const char *esc = strchr (format, '%'))
    {
      fwrite (format, 1, (size_t)(esc - format), dumps->stream);
      format = ++esc;
      switch (*format++)
        {
        default:
          gcc_unreachable ();

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

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

        case 'I': /* Identifier.  */
          {
            tree t = 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 *))
              {
                if (!m->is_rooted ())
                  str = "(detached)";
                else
                  str = m->get_flatname ();
              }
            fputs (str, dumps->stream);
          }
          break;

        case 'N': /* Name.  */
          {
            tree t = va_arg (args, tree);
            if (t && TREE_CODE (t) == OVERLOAD)
              t = OVL_FIRST (t);
            fputc ('\'', dumps->stream);
            dumps->nested_name (t);
            fputc ('\'', dumps->stream);
          }
          break;

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

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

        case 'S': /* Symbol name */
          {
            tree t = va_arg (args, tree);
            if (t && TYPE_P (t))
              t = TYPE_NAME (t);
            if (t && HAS_DECL_ASSEMBLER_NAME_P (t)
                && DECL_ASSEMBLER_NAME_SET_P (t))
              {
                fputc ('(', dumps->stream);
                fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t)),
                       dumps->stream);
                fputc (')', dumps->stream);
              }
          }
          break;

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

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

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

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

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

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

        case 's': /* String. */
          {
            const char *s = va_arg (args, char *);
            gcc_checking_assert (s);
            fputs (s, dumps->stream);
          }
          break;

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

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

struct note_def_cache_hasher : ggc_cache_ptr_hash<tree_node>
{
  static int keep_cache_entry (tree t)
  {
    if (!CHECKING_P)
      /* GTY is unfortunately not clever enough to conditionalize
         this.  */
      gcc_unreachable ();

    if (ggc_marked_p (t))
      return -1;

    unsigned n = dump.push (NULL);
    /* 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;
  }
};

/* 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.  */
typedef hash_table<note_def_cache_hasher> note_defs_table_t;
static GTY((cache)) note_defs_table_t *note_defs;

void
trees_in::assert_definition (tree decl ATTRIBUTE_UNUSED,
                             bool installing ATTRIBUTE_UNUSED)
{
#if CHECKING_P
  tree *slot = note_defs->find_slot (decl, installing ? INSERT : NO_INSERT);
  if (installing)
    {
      /* We must be inserting for the first time.  */
      gcc_assert (!*slot);
      *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)
                ? !slot
                : (slot
                   || !DECL_LANG_SPECIFIC (decl)
                   || !DECL_MODULE_PURVIEW_P (decl)
                   || (!DECL_MODULE_IMPORT_P (decl)
                       && header_module_p ())));

  if (TREE_CODE (decl) == TEMPLATE_DECL)
    gcc_assert (!note_defs->find_slot (DECL_TEMPLATE_RESULT (decl), NO_INSERT));
#endif
}

void
trees_out::assert_definition (tree decl ATTRIBUTE_UNUSED)
{
#if CHECKING_P
  tree *slot = note_defs->find_slot (decl, INSERT);
  gcc_assert (!*slot);
  *slot = decl;
  if (TREE_CODE (decl) == TEMPLATE_DECL)
    gcc_assert (!note_defs->find_slot (DECL_TEMPLATE_RESULT (decl), NO_INSERT));
#endif
}

/********************************************************************/
static bool
noisy_p ()
{
  if (quiet_flag)
    return false;

  pp_needs_newline (global_dc->printer) = true;
  diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL);

  return true;
}

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

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

  cmi_repo = NULL;
  cmi_repo_length = 0;

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

  size_t len = strlen (r);
  cmi_repo = XNEWVEC (char, len + 1);
  memcpy (cmi_repo, r, len + 1);
  
  if (len > 1 && IS_DIR_SEPARATOR (cmi_repo[len-1]))
    len--;
  if (len == 1 && cmi_repo[0] == '.')
    len--;
  cmi_repo[len] = 0;
  cmi_repo_length = len;
}

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

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

  if (cmi_repo_length && !IS_ABSOLUTE_PATH (to))
    {
      if (cmi_path_alloc < cmi_repo_length + len + 2)
        {
          XDELETEVEC (cmi_path);
          cmi_path_alloc = cmi_repo_length + len * 2 + 2;
          cmi_path = XNEWVEC (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;
}

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

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

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

static tree
friend_from_decl_list (tree frnd)
{
  tree res = frnd;

  if (TREE_CODE (frnd) != TEMPLATE_DECL)
    {
      tree tmpl = NULL_TREE;
      if (TYPE_P (frnd))
        {
          res = TYPE_NAME (frnd);
          if (CLASSTYPE_TEMPLATE_INFO (frnd))
            tmpl = CLASSTYPE_TI_TEMPLATE (frnd);
        }
      else if (DECL_TEMPLATE_INFO (frnd))
        {
          tmpl = DECL_TI_TEMPLATE (frnd);
          if (TREE_CODE (tmpl) != TEMPLATE_DECL)
            tmpl = NULL_TREE;
        }

      if (tmpl && DECL_TEMPLATE_RESULT (tmpl) == res)
        res = tmpl;
    }

  return res;
}

static tree
find_enum_member (tree ctx, tree name)
{
  for (tree values = TYPE_VALUES (ctx);
       values; values = TREE_CHAIN (values))
    if (DECL_NAME (TREE_VALUE (values)) == name)
      return TREE_VALUE (values);

  return NULL_TREE;
}

/********************************************************************/
/* Instrumentation gathered writing bytes.  */

void
bytes_out::instrument ()
{
  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]);
}

/* Instrumentation gathered writing trees.  */
void
trees_out::instrument ()
{
  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);
    }
}

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

void
trees_out::begin ()
{
  gcc_assert (!streaming_p () || !tree_map.elements ());

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

unsigned
trees_out::end (elf_out *sink, unsigned name, unsigned *crc_ptr)
{
  gcc_checking_assert (streaming_p ());

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

void
trees_out::end ()
{
  gcc_assert (!streaming_p ());

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

void
trees_out::mark_trees ()
{
  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);
      TREE_VISITED (val) = true;
    }

  ref_num = 0;
}

/* Unmark the trees we encountered  */

void
trees_out::unmark_trees ()
{
  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)
                           && (ref <= tag_backref || ref >= tag_fixed));
      TREE_VISITED (node) = false;
    }
}

/* 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.  */

void
trees_out::mark_by_value (tree decl)
{
  gcc_checking_assert (DECL_P (decl)
                       /* Enum consts are INTEGER_CSTS.  */
                       || TREE_CODE (decl) == INTEGER_CST
                       || TREE_CODE (decl) == TREE_BINFO);

  if (TREE_VISITED (decl))
    /* Must already be forced or fixed.  */
    gcc_checking_assert (*tree_map.get (decl) >= tag_value);
  else
    {
      bool existed = tree_map.put (decl, tag_value);
      gcc_checking_assert (!existed);
      TREE_VISITED (decl) = true;
    }
}

int
trees_out::get_tag (tree t)
{
  gcc_checking_assert (TREE_VISITED (t));
  return *tree_map.get (t);
}

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

int
trees_out::insert (tree t, walk_kind walk)
{
  gcc_checking_assert (walk != WK_normal || !TREE_VISITED (t));
  int tag = --ref_num;
  bool existed;
  int &slot = tree_map.get_or_insert (t, &existed);
  gcc_checking_assert (TREE_VISITED (t) == existed
                       && (!existed
                           || (walk == WK_value && slot == tag_value)));
  TREE_VISITED (t) = true;
  slot = tag;

  return tag;
}

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

int
trees_in::insert (tree t)
{
  gcc_checking_assert (t || get_overrun ());
  back_refs.safe_push (t);
  return -(int)back_refs.length ();
}

/* A chained set of decls.  */

void
trees_out::chained_decls (tree decls)
{
  for (; decls; decls = DECL_CHAIN (decls))
    {
      if (VAR_OR_FUNCTION_DECL_P (decls)
          && DECL_LOCAL_DECL_P (decls))
        {
          /* Make sure this is the first encounter, and mark for
             walk-by-value.  */
          gcc_checking_assert (!TREE_VISITED (decls)
                               && !DECL_TEMPLATE_INFO (decls));
          mark_by_value (decls);
        }
      tree_node (decls);
    }
  tree_node (NULL_TREE);
}

tree
trees_in::chained_decls ()
{
  tree decls = NULL_TREE;
  for (tree *chain = &decls;;)
    if (tree decl = tree_node ())
      {
        if (!DECL_P (decl) || DECL_CHAIN (decl))
          {
            set_overrun ();
            break;
          }
        *chain = decl;
        chain = &DECL_CHAIN (decl);
      }
    else
      break;

  return decls;
}

/* A vector of decls following DECL_CHAIN.  */

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

      for (tree decl = decls; decl; decl = DECL_CHAIN (decl))
        len++;
      u (len);
    }

  for (tree decl = decls; decl; decl = DECL_CHAIN (decl))
    {
      if (DECL_IMPLICIT_TYPEDEF_P (decl)
          && TYPE_NAME (TREE_TYPE (decl)) != decl)
        /* An anonynmous struct with a typedef name.  An odd thing to
           write.  */
        tree_node (NULL_TREE);
      else
        tree_node (decl);
    }
}

vec<tree, va_heap> *
trees_in::vec_chained_decls ()
{
  vec<tree, va_heap> *v = NULL;

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

      for (unsigned ix = 0; ix < len; ix++)
        {
          tree decl = tree_node ();
          if (decl && !DECL_P (decl))
            {
              set_overrun ();
              break;
            }
          v->quick_push (decl);
        }

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

  return v;
}

/* A vector of trees.  */

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

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

/* A vector of tree pairs.  */

void
trees_out::tree_pair_vec (vec<tree_pair_s, va_gc> *v)
{
  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);
      }
}

vec<tree_pair_s, va_gc> *
trees_in::tree_pair_vec ()
{
  vec<tree_pair_s, va_gc> *v = NULL;
  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;
}

void
trees_out::tree_list (tree list, bool has_purpose)
{
  for (; list; list = TREE_CHAIN (list))
    {
      gcc_checking_assert (TREE_VALUE (list));
      tree_node (TREE_VALUE (list));
      if (has_purpose)
        tree_node (TREE_PURPOSE (list));
    }
  tree_node (NULL_TREE);
}

tree
trees_in::tree_list (bool has_purpose)
{
  tree res = NULL_TREE;

  for (tree *chain = &res; tree value = tree_node ();
       chain = &TREE_CHAIN (*chain))
    {
      tree purpose = has_purpose ? tree_node () : NULL_TREE;
      *chain = build_tree_list (purpose, value);
    }

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

void
trees_out::start (tree t, bool code_streamed)
{
  if (TYPE_P (t))
    {
      enum tree_code code = TREE_CODE (t);
      gcc_checking_assert (TYPE_MAIN_VARIANT (t) == t);
      /* All these types are TYPE_NON_COMMON.  */
      gcc_checking_assert (code == RECORD_TYPE
                           || code == UNION_TYPE
                           || code == ENUMERAL_TYPE
                           || code == TEMPLATE_TYPE_PARM
                           || code == TEMPLATE_TEMPLATE_PARM
                           || code == BOUND_TEMPLATE_TEMPLATE_PARM);
    }

  if (!code_streamed)
    u (TREE_CODE (t));

  switch (TREE_CODE (t))
    {
    default:
      if (TREE_CODE_CLASS (TREE_CODE (t)) == tcc_vl_exp)
        u (VL_EXP_OPERAND_LENGTH (t));
      break;

    case INTEGER_CST:
      u (TREE_INT_CST_NUNITS (t));
      u (TREE_INT_CST_EXT_NUNITS (t));
      u (TREE_INT_CST_OFFSET_NUNITS (t));
      break;

    case OMP_CLAUSE:
      state->extensions |= SE_OPENMP;
      u (OMP_CLAUSE_CODE (t));
      break;

    case STRING_CST:
      str (TREE_STRING_POINTER (t), TREE_STRING_LENGTH (t));
      break;

    case VECTOR_CST:
      u (VECTOR_CST_LOG2_NPATTERNS (t));
      u (VECTOR_CST_NELTS_PER_PATTERN (t));
      break;

    case TREE_BINFO:
      u (BINFO_N_BASE_BINFOS (t));
      break;

    case TREE_VEC:
      u (TREE_VEC_LENGTH (t));
      break;

    case FIXED_CST:
    case POLY_INT_CST:
      gcc_unreachable (); /* 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 ();
      break;
    }
}

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

tree
trees_in::start (unsigned code)
{
  tree t = NULL_TREE;

  if (!code)
    code = u ();

  switch (code)
    {
    default:
      if (code >= MAX_TREE_CODES)
        {
        fail:
          set_overrun ();
          return NULL_TREE;
        }
      else if (TREE_CODE_CLASS (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) = u ();
      }
      break;

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

        unsigned omp_code = u ();
        t = build_omp_clause (UNKNOWN_LOCATION, 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;
}

/* 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.  */

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

void
trees_out::core_bools (tree t)
{
#define WB(X) (b (X))
  tree_code code = TREE_CODE (t);

  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) != 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 (DECL_CONTEXT (t)
              && TREE_CODE (DECL_CONTEXT (t)) != 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))
    {
      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))
    {
      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)
                  && !DECL_VAR_DECLARED_INLINE_P (t))
                is_external = true;
              break;

            case FUNCTION_DECL:
              if (TREE_PUBLIC (t)
                  && !DECL_DECLARED_INLINE_P (t))
                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);
    }

  if (CODE_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))
    {
      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);
    }
#undef WB
}

bool
trees_in::core_bools (tree t)
{
#define RB(X) ((X) = b ())
  tree_code code = TREE_CODE (t);

  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) != 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))
    {
      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))
    {
      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);
    }

  if (CODE_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))
    {
      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);
    }
#undef RB
  return !get_overrun ();
}

void
trees_out::lang_decl_bools (tree t)
{
#define WB(X) (b (X))
  const struct lang_decl *lang = DECL_LANG_SPECIFIC (t);

  WB (lang->u.base.language == lang_cplusplus);
  WB ((lang->u.base.use_template >> 0) & 1);
  WB ((lang->u.base.use_template >> 1) & 1);
  /* 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);
  WB (lang->u.base.module_purview_p);
  if (VAR_OR_FUNCTION_DECL_P (t))
    WB (lang->u.base.module_pending_p);
  switch (lang->u.base.selector)
    {
    default:
      gcc_unreachable ();

    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);
      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;
    }
#undef WB
}

bool
trees_in::lang_decl_bools (tree t)
{
#define RB(X) ((X) = b ())
  struct lang_decl *lang = DECL_LANG_SPECIFIC (t);

  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);
  if (VAR_OR_FUNCTION_DECL_P (t))
    RB (lang->u.base.module_pending_p);
  switch (lang->u.base.selector)
    {
    default:
      gcc_unreachable ();

    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;
    }
#undef RB
  return !get_overrun ();
}

void
trees_out::lang_type_bools (tree t)
{
#define WB(X) (b (X))
  const struct lang_type *lang = TYPE_LANG_SPECIFIC (t);

  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);
  // 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);
#undef WB
}

bool
trees_in::lang_type_bools (tree t)
{
#define RB(X) ((X) = b ())
  struct lang_type *lang = TYPE_LANG_SPECIFIC (t);

  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);
  gcc_assert (!lang->debug_requested);
  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);
#undef RB
  return !get_overrun ();
}

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

void
trees_out::core_vals (tree t)
{
#define WU(X) (u (X))
#define WT(X) (tree_node (X))
  tree_code code = TREE_CODE (t);

  /* First by shape of the tree.  */

  if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
    {
      /* Write this early, for better log information.  */
      WT (t->decl_minimal.name);
      if (!DECL_TEMPLATE_PARM_P (t))
        WT (t->decl_minimal.context);

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

  if (CODE_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));

      /* We only stream the main variant.  */
      gcc_checking_assert (TYPE_MAIN_VARIANT (t) == t);

      /* 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)))
        /* 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))
        {
          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))
    {
      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))
    {
      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))
    {
      /* Records and unions hold FIELDS, VFIELD & BINFO on these
         things.  */
      if (!RECORD_OR_UNION_CODE_P (code) && code != ENUMERAL_TYPE)
        {
          // FIXME: These are from tpl_parm_value's 'type' writing.
          // Perhaps it should just be doing them directly?
          gcc_checking_assert (code == TEMPLATE_TYPE_PARM
                               || code == TEMPLATE_TEMPLATE_PARM
                               || code == BOUND_TEMPLATE_TEMPLATE_PARM);
          gcc_checking_assert (!TYPE_CACHED_VALUES_P (t));
          WT (t->type_non_common.values);
          WT (t->type_non_common.maxval);
          WT (t->type_non_common.minval);
        }

      WT (t->type_non_common.lang_1);
    }

  if (CODE_CONTAINS_STRUCT (code, TS_EXP))
    {
      state->write_location (*this, t->exp.locus);

      /* Walk in forward order, as (for instance) REQUIRES_EXPR has a
         bunch of unscoped parms on its first operand.  It's safer to
         create those in order.  */
      bool vl = TREE_CODE_CLASS (code) == tcc_vl_exp;
      for (unsigned limit = (vl ? VL_EXP_OPERAND_LENGTH (t)
                             : TREE_OPERAND_LENGTH (t)),
             ix = unsigned (vl); ix != limit; ix++)
        WT (TREE_OPERAND (t, ix));
    }
  else
    /* The CODE_CONTAINS tables were inaccurate when I started.  */
    gcc_checking_assert (TREE_CODE_CLASS (code) != tcc_expression
                         && TREE_CODE_CLASS (code) != tcc_binary
                         && TREE_CODE_CLASS (code) != tcc_unary
                         && TREE_CODE_CLASS (code) != tcc_reference
                         && TREE_CODE_CLASS (code) != tcc_comparison
                         && TREE_CODE_CLASS (code) != tcc_statement
                         && TREE_CODE_CLASS (code) != tcc_vl_exp);

  /* Then by CODE.  Special cases and/or 1:1 tree shape
     correspondance. */
  switch (code)
    {
    default:
      break;

    case ARGUMENT_PACK_SELECT:  /* Transient during instantiation.  */
    case DEFERRED_PARSE:        /* Expanded upon completion of
                                   outermost class.  */
    case IDENTIFIER_NODE:       /* Streamed specially.  */
    case BINDING_VECTOR:                /* Only in namespace-scope symbol
                                   table.  */
    case SSA_NAME:
    case TRANSLATION_UNIT_DECL: /* There is only one, it is a
                                   global_tree.  */
    case USERDEF_LITERAL:       /* Expanded during parsing.  */
      gcc_unreachable (); /* Should never meet.  */

      /* Constants.  */
    case COMPLEX_CST:
      WT (TREE_REALPART (t));
      WT (TREE_IMAGPART (t));
      break;

    case FIXED_CST:
      gcc_unreachable (); /* Not supported in C++.  */

    case INTEGER_CST:
      if (streaming_p ())
        {
          unsigned num = TREE_INT_CST_EXT_NUNITS (t);
          for (unsigned ix = 0; ix != num; ix++)
            wu (TREE_INT_CST_ELT (t, ix));
        }
      break;

    case POLY_INT_CST:
      gcc_unreachable (); /* Not supported in C++.  */

    case REAL_CST:
      if (streaming_p ())
        buf (TREE_REAL_CST_PTR (t), sizeof (real_value));
      break;

    case STRING_CST:
      /* Streamed during start.  */
      break;

    case VECTOR_CST:
      for (unsigned ix = vector_cst_encoded_nelts (t); ix--;)
        WT (VECTOR_CST_ENCODED_ELT (t, ix));
      break;

      /* Decls.  */
    case VAR_DECL:
      if (DECL_CONTEXT (t)
          && TREE_CODE (DECL_CONTEXT (t)) != FUNCTION_DECL)
        break;
      /* FALLTHROUGH  */

    case RESULT_DECL:
    case PARM_DECL:
      if (DECL_HAS_VALUE_EXPR_P (t))
        WT (DECL_VALUE_EXPR (t));
      /* FALLTHROUGH  */

    case CONST_DECL:
    case IMPORTED_DECL:
      WT (t->decl_common.initial);
      break;

    case FIELD_DECL:
      WT (t->field_decl.offset);
      WT (t->field_decl.bit_field_type);
      WT (t->field_decl.qualifier); /* bitfield unit.  */
      WT (t->field_decl.bit_offset);
      WT (t->field_decl.fcontext);
      WT (t->decl_common.initial);
      break;

    case LABEL_DECL:
      if (streaming_p ())
        {
          WU (t->label_decl.label_decl_uid);
          WU (t->label_decl.eh_landing_pad_nr);
        }
      break;

    case FUNCTION_DECL:
      if (streaming_p ())
        {
          /* Builtins can be streamed by value when a header declares
             them.  */
          WU (DECL_BUILT_IN_CLASS (t));
          if (DECL_BUILT_IN_CLASS (t) != NOT_BUILT_IN)
            WU (DECL_UNCHECKED_FUNCTION_CODE (t));
        }

      WT (t->function_decl.personality);
      WT (t->function_decl.function_specific_target);
      WT (t->function_decl.function_specific_optimization);
      WT (t->function_decl.vindex);
      break;

    case USING_DECL:
      /* USING_DECL_DECLS  */
      WT (t->decl_common.initial);
      /* FALLTHROUGH  */

    case TYPE_DECL:
      /* USING_DECL: USING_DECL_SCOPE  */
      /* TYPE_DECL: DECL_ORIGINAL_TYPE */
      WT (t->decl_non_common.result);
      break;

      /* Miscellaneous common nodes.  */
    case BLOCK:
      state->write_location (*this, t->block.locus);
      state->write_location (*this, t->block.end_locus);
      
      /* DECL_LOCAL_DECL_P decls are first encountered here and
         streamed by value.  */
      chained_decls (t->block.vars);
      /* nonlocalized_vars is a middle-end thing.  */
      WT (t->block.subblocks);
      WT (t->block.supercontext);
      // FIXME: As for decl's abstract_origin, does this introduce crosslinks?
      WT (t->block.abstract_origin);
      /* fragment_origin, fragment_chain are middle-end things.  */
      WT (t->block.chain);
      /* nonlocalized_vars, block_num & die are middle endy/debug
         things.  */
      break;

    case CALL_EXPR:
      if (streaming_p ())
        WU (t->base.u.ifn);
      break;

    case CONSTRUCTOR:
      {
        unsigned len = vec_safe_length (t->constructor.elts);
        if (streaming_p ())
          WU (len);
        if (len)
          for (unsigned ix = 0; ix != len; ix++)
            {
              const constructor_elt &elt = (*t->constructor.elts)[ix];

              WT (elt.index);
              WT (elt.value);
            }
      }
      break;

    case OMP_CLAUSE:
      {
        /* The ompcode is serialized in start.  */
        if (streaming_p ())
          WU (t->omp_clause.subcode.map_kind);
        state->write_location (*this, t->omp_clause.locus);

        unsigned len = omp_clause_num_ops[OMP_CLAUSE_CODE (t)];
        for (unsigned ix = 0; ix != len; ix++)
          WT (t->omp_clause.ops[ix]);
      }
      break;

    case STATEMENT_LIST:
      for (tree_stmt_iterator iter = tsi_start (t);
           !tsi_end_p (iter); tsi_next (&iter))
        if (tree stmt = tsi_stmt (iter))
          WT (stmt);
      WT (NULL_TREE);
      break;

    case OPTIMIZATION_NODE:
    case TARGET_OPTION_NODE:
      // FIXME: Our representation for these two nodes is a cache of
      // the resulting set of options.  Not a record of the options
      // that got changed by a particular attribute or pragma.  Should
      // we record that, or should we record the diff from the command
      // line options?  The latter seems the right behaviour, but is
      // (a) harder, and I guess could introduce strangeness if the
      // importer has set some incompatible set of optimization flags?
      gcc_unreachable ();
      break;

    case TREE_BINFO:
      {
        WT (t->binfo.common.chain);
        WT (t->binfo.offset);
        WT (t->binfo.inheritance);
        WT (t->binfo.vptr_field);

        WT (t->binfo.vtable);
        WT (t->binfo.virtuals);
        WT (t->binfo.vtt_subvtt);
        WT (t->binfo.vtt_vptr);

        tree_vec (BINFO_BASE_ACCESSES (t));
        unsigned num = vec_safe_length (BINFO_BASE_ACCESSES (t));
        for (unsigned ix = 0; ix != num; ix++)
          WT (BINFO_BASE_BINFO (t, ix));
      }
      break;

    case TREE_LIST:
      WT (t->list.purpose);
      WT (t->list.value);
      WT (t->list.common.chain);
      break;

    case TREE_VEC:
      for (unsigned ix = TREE_VEC_LENGTH (t); ix--;)
        WT (TREE_VEC_ELT (t, ix));
      /* We stash NON_DEFAULT_TEMPLATE_ARGS_COUNT on TREE_CHAIN!  */
      gcc_checking_assert (!t->type_common.common.chain
                           || (TREE_CODE (t->type_common.common.chain)
                               == INTEGER_CST));
      WT (t->type_common.common.chain);
      break;

      /* C++-specific nodes ...  */
    case BASELINK:
      WT (((lang_tree_node *)t)->baselink.binfo);
      WT (((lang_tree_node *)t)->baselink.functions);
      WT (((lang_tree_node *)t)->baselink.access_binfo);
      break;

    case CONSTRAINT_INFO:
      WT (((lang_tree_node *)t)->constraint_info.template_reqs);
      WT (((lang_tree_node *)t)->constraint_info.declarator_reqs);
      WT (((lang_tree_node *)t)->constraint_info.associated_constr);
      break;

    case DEFERRED_NOEXCEPT:
      WT (((lang_tree_node *)t)->deferred_noexcept.pattern);
      WT (((lang_tree_node *)t)->deferred_noexcept.args);
      break;

    case LAMBDA_EXPR:
      WT (((lang_tree_node *)t)->lambda_expression.capture_list);
      WT (((lang_tree_node *)t)->lambda_expression.this_capture);
      WT (((lang_tree_node *)t)->lambda_expression.extra_scope);
      /* pending_proxies is a parse-time thing.  */
      gcc_assert (!((lang_tree_node *)t)->lambda_expression.pending_proxies);
      state->write_location
        (*this, ((lang_tree_node *)t)->lambda_expression.locus);
      if (streaming_p ())
        {
          WU (((lang_tree_node *)t)->lambda_expression.default_capture_mode);
          WU (((lang_tree_node *)t)->lambda_expression.discriminator);
        }
      break;

    case OVERLOAD:
      WT (((lang_tree_node *)t)->overload.function);
      WT (t->common.chain);
      break;
      
    case PTRMEM_CST:
      WT (((lang_tree_node *)t)->ptrmem.member);
      break;

    case STATIC_ASSERT:
      WT (((lang_tree_node *)t)->static_assertion.condition);
      WT (((lang_tree_node *)t)->static_assertion.message);
      state->write_location
        (*this, ((lang_tree_node *)t)->static_assertion.location);
      break;

    case TEMPLATE_DECL:
      /* Streamed with the template_decl node itself.  */
      gcc_checking_assert
        (TREE_VISITED (((lang_tree_node *)t)->template_decl.arguments));
      gcc_checking_assert
        (TREE_VISITED (((lang_tree_node *)t)->template_decl.result)
         || dep_hash->find_dependency (t)->is_alias_tmpl_inst ());
      if (DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (t))
        WT (DECL_CHAIN (t));
      break;

    case TEMPLATE_INFO:
      {
        WT (((lang_tree_node *)t)->template_info.tmpl);
        WT (((lang_tree_node *)t)->template_info.args);

        const auto *ac = (((lang_tree_node *)t)
                          ->template_info.deferred_access_checks);
        unsigned len = vec_safe_length (ac);
        if (streaming_p ())
          u (len);
        if (len)
          {
            for (unsigned ix = 0; ix != len; ix++)
              {
                const auto &m = (*ac)[ix];
                WT (m.binfo);
                WT (m.decl);
                WT (m.diag_decl);
                state->write_location (*this, m.loc);
              }
          }
      }
      break;

    case TEMPLATE_PARM_INDEX:
      if (streaming_p ())
        {
          WU (((lang_tree_node *)t)->tpi.index);
          WU (((lang_tree_node *)t)->tpi.level);
          WU (((lang_tree_node *)t)->tpi.orig_level);
        }
      WT (((lang_tree_node *)t)->tpi.decl);
      /* TEMPLATE_PARM_DESCENDANTS (AKA TREE_CHAIN) is an internal
         cache, do not stream.  */
      break;
      
    case TRAIT_EXPR:
      WT (((lang_tree_node *)t)->trait_expression.type1);
      WT (((lang_tree_node *)t)->trait_expression.type2);
      if (streaming_p ())
        WU (((lang_tree_node *)t)->trait_expression.kind);
      break;
    }

  if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
    {
      /* We want to stream the type of a expression-like nodes /after/
         we've streamed the operands.  The type often contains (bits
         of the) types of the operands, and with things like decltype
         and noexcept in play, we really want to stream the decls
         defining the type before we try and stream the type on its
         own.  Otherwise we can find ourselves trying to read in a
         decl, when we're already partially reading in a component of
         its type.  And that's bad.  */
      tree type = t->typed.type;
      unsigned prec = 0;

      switch (code)
        {
        default:
          break;

        case TEMPLATE_DECL:
          /* We fill in the template's type separately.  */
          type = NULL_TREE;
          break;

        case TYPE_DECL:
          if (DECL_ORIGINAL_TYPE (t) && t == TYPE_NAME (type))
            /* This is a typedef.  We set its type separately.  */
            type = NULL_TREE;
          break;

        case ENUMERAL_TYPE:
          if (type && !ENUM_FIXED_UNDERLYING_TYPE_P (t))
            {
              /* Type is a restricted range integer type derived from the
                 integer_types.  Find the right one.  */
              prec = TYPE_PRECISION (type);
              tree name = DECL_NAME (TYPE_NAME (type));

              for (unsigned itk = itk_none; itk--;)
                if (integer_types[itk]
                    && DECL_NAME (TYPE_NAME (integer_types[itk])) == name)
                  {
                    type = integer_types[itk];
                    break;
                  }
              gcc_assert (type != t->typed.type);
            }
          break;
        }

      WT (type);
      if (prec && streaming_p ())
        WU (prec);
    }

#undef WT
#undef WU
}

// Streaming in a reference to a decl can cause that decl to be
// TREE_USED, which is the mark_used behaviour we need most of the
// time.  The trees_in::unused can be incremented to inhibit this,
// which is at least needed for vtables.

bool
trees_in::core_vals (tree t)
{
#define RU(X) ((X) = u ())
#define RUC(T,X) ((X) = T (u ()))
#define RT(X) ((X) = tree_node ())
#define RTU(X) ((X) = tree_node (true))
  tree_code code = TREE_CODE (t);

  /* First by tree shape.  */
  if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
    {
      RT (t->decl_minimal.name);
      if (!DECL_TEMPLATE_PARM_P (t))
        RT (t->decl_minimal.context);

      /* Don't zap the locus just yet, we don't record it correctly
         and thus lose all location information.  */
      t->decl_minimal.locus = state->read_location (*this);
    }

  if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
    {
      RT (t->type_common.name);
      RT (t->type_common.context);

      RT (t->type_common.main_variant);
      RT (t->type_common.canonical);

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

      RU (t->type_common.precision);
      RU (t->type_common.contains_placeholder_bits);
      RUC (machine_mode, t->type_common.mode);
      RU (t->type_common.align);

      if (!RECORD_OR_UNION_CODE_P (code))
        {
          RT (t->type_common.size);
          RT (t->type_common.size_unit);
        }
      RT (t->type_common.attributes);

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

  if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
    {
      RUC (machine_mode, t->decl_common.mode);
      RU (t->decl_common.off_align);
      RU (t->decl_common.align);

      if (code != TEMPLATE_DECL)
        {
          RT (t->decl_common.size);
          RT (t->decl_common.size_unit);
        }

      RT (t->decl_common.attributes);
      RT (t->decl_common.abstract_origin);
    }

  if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
    {
      RT (t->decl_with_vis.assembler_name);
      RUC (symbol_visibility, t->decl_with_vis.visibility);
    }

  if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
    {
      /* Records and unions hold FIELDS, VFIELD & BINFO on these
         things.  */
      if (!RECORD_OR_UNION_CODE_P (code) && code != ENUMERAL_TYPE)
        {
          /* This is not clobbering TYPE_CACHED_VALUES, because this
             is a type that doesn't have any.  */
          gcc_checking_assert (!TYPE_CACHED_VALUES_P (t));
          RT (t->type_non_common.values);
          RT (t->type_non_common.maxval);
          RT (t->type_non_common.minval);
        }

      RT (t->type_non_common.lang_1);
    }

  if (CODE_CONTAINS_STRUCT (code, TS_EXP))
    {
      t->exp.locus = state->read_location (*this);

      bool vl = TREE_CODE_CLASS (code) == tcc_vl_exp;
      for (unsigned limit = (vl ? VL_EXP_OPERAND_LENGTH (t)
                             : TREE_OPERAND_LENGTH (t)),
             ix = unsigned (vl); ix != limit; ix++)
        RTU (TREE_OPERAND (t, ix));
    }

  /* Then by CODE.  Special cases and/or 1:1 tree shape
     correspondance. */
  switch (code)
    {
    default:
      break;

    case ARGUMENT_PACK_SELECT:
    case DEFERRED_PARSE:
    case IDENTIFIER_NODE:
    case BINDING_VECTOR:
    case SSA_NAME:
    case TRANSLATION_UNIT_DECL:
    case USERDEF_LITERAL:
      return false; /* Should never meet.  */

      /* Constants.  */
    case COMPLEX_CST:
      RT (TREE_REALPART (t));
      RT (TREE_IMAGPART (t));
      break;

    case FIXED_CST:
      /* Not suported in C++.  */
      return false;

    case INTEGER_CST:
      {
        unsigned num = TREE_INT_CST_EXT_NUNITS (t);
        for (unsigned ix = 0; ix != num; ix++)
          TREE_INT_CST_ELT (t, ix) = wu ();
      }
      break;

    case POLY_INT_CST:
      /* Not suported in C++.  */
      return false;

    case REAL_CST:
      if (const void *bytes = buf (sizeof (real_value)))
        TREE_REAL_CST_PTR (t)
          = reinterpret_cast<real_value *> (memcpy (ggc_alloc<real_value> (),
                                                    bytes, sizeof (real_value)));
      break;

    case STRING_CST:
      /* Streamed during start.  */
      break;

    case VECTOR_CST:
      for (unsigned ix = vector_cst_encoded_nelts (t); ix--;)
        RT (VECTOR_CST_ENCODED_ELT (t, ix));
      break;

      /* Decls.  */
    case VAR_DECL:
      if (DECL_CONTEXT (t)
          && TREE_CODE (DECL_CONTEXT (t)) != FUNCTION_DECL)
        break;
      /* FALLTHROUGH  */

    case RESULT_DECL:
    case PARM_DECL:
      if (DECL_HAS_VALUE_EXPR_P (t))
        {
          /* The DECL_VALUE hash table is a cache, thus if we're
             reading a duplicate (which we end up discarding), the
             value expr will also be cleaned up at the next gc.  */
          tree val = tree_node ();
          SET_DECL_VALUE_EXPR (t, val);
        }
      /* FALLTHROUGH  */

    case CONST_DECL:
    case IMPORTED_DECL:
      RT (t->decl_common.initial);
      break;

    case FIELD_DECL:
      RT (t->field_decl.offset);
      RT (t->field_decl.bit_field_type);
      RT (t->field_decl.qualifier);
      RT (t->field_decl.bit_offset);
      RT (t->field_decl.fcontext);
      RT (t->decl_common.initial);
      break;

    case LABEL_DECL:
      RU (t->label_decl.label_decl_uid);
      RU (t->label_decl.eh_landing_pad_nr);
      break;
  
    case FUNCTION_DECL:
      {
        unsigned bltin = u ();
        t->function_decl.built_in_class = built_in_class (bltin);
        if (bltin != NOT_BUILT_IN)
          {
            bltin = u ();
            DECL_UNCHECKED_FUNCTION_CODE (t) = built_in_function (bltin);
          }

        RT (t->function_decl.personality);
        RT (t->function_decl.function_specific_target);
        RT (t->function_decl.function_specific_optimization);
        RT (t->function_decl.vindex);
      }
      break;

    case USING_DECL:
      /* USING_DECL_DECLS  */
      RT (t->decl_common.initial);
      /* FALLTHROUGH  */

    case TYPE_DECL:
      /* USING_DECL: USING_DECL_SCOPE  */
      /* TYPE_DECL: DECL_ORIGINAL_TYPE */
      RT (t->decl_non_common.result);
      break;

      /* Miscellaneous common nodes.  */
    case BLOCK:
      t->block.locus = state->read_location (*this);
      t->block.end_locus = state->read_location (*this);
      t->block.vars = chained_decls ();
      /* nonlocalized_vars is middle-end.  */
      RT (t->block.subblocks);
      RT (t->block.supercontext);
      RT (t->block.abstract_origin);
      /* fragment_origin, fragment_chain are middle-end.  */
      RT (t->block.chain);
      /* nonlocalized_vars, block_num, die are middle endy/debug
         things.  */
      break;

    case CALL_EXPR:
      RUC (internal_fn, t->base.u.ifn);
      break;

    case CONSTRUCTOR:
      if (unsigned len = u ())
        {
          vec_alloc (t->constructor.elts, len);
          for (unsigned ix = 0; ix != len; ix++)
            {
              constructor_elt elt;

              RT (elt.index);
              RTU (elt.value);
              t->constructor.elts->quick_push (elt);
            }
        }
      break;

    case OMP_CLAUSE:
      {
        RU (t->omp_clause.subcode.map_kind);
        t->omp_clause.locus = state->read_location (*this);

        unsigned len = omp_clause_num_ops[OMP_CLAUSE_CODE (t)];
        for (unsigned ix = 0; ix != len; ix++)
          RT (t->omp_clause.ops[ix]);
      }
      break;

    case STATEMENT_LIST:
      {
        tree_stmt_iterator iter = tsi_start (t);
        for (tree stmt; RT (stmt);)
          tsi_link_after (&iter, stmt, TSI_CONTINUE_LINKING);
      }
      break;

    case OPTIMIZATION_NODE:
    case TARGET_OPTION_NODE:
      /* Not yet implemented, see trees_out::core_vals.  */
      gcc_unreachable ();
      break;

    case TREE_BINFO:
      RT (t->binfo.common.chain);
      RT (t->binfo.offset);
      RT (t->binfo.inheritance);
      RT (t->binfo.vptr_field);

      /* Do not mark the vtables as USED in the address expressions
         here.  */
      unused++;
      RT (t->binfo.vtable);
      RT (t->binfo.virtuals);
      RT (t->binfo.vtt_subvtt);
      RT (t->binfo.vtt_vptr);
      unused--;

      BINFO_BASE_ACCESSES (t) = tree_vec ();
      if (!get_overrun ())
        {
          unsigned num = vec_safe_length (BINFO_BASE_ACCESSES (t));
          for (unsigned ix = 0; ix != num; ix++)
            BINFO_BASE_APPEND (t, tree_node ());
        }
      break;

    case TREE_LIST:
      RT (t->list.purpose);
      RT (t->list.value);
      RT (t->list.common.chain);
      break;

    case TREE_VEC:
      for (unsigned ix = TREE_VEC_LENGTH (t); ix--;)
        RT (TREE_VEC_ELT (t, ix));
      RT (t->type_common.common.chain);
      break;

      /* C++-specific nodes ...  */
    case BASELINK:
      RT (((lang_tree_node *)t)->baselink.binfo);
      RTU (((lang_tree_node *)t)->baselink.functions);
      RT (((lang_tree_node *)t)->baselink.access_binfo);
      break;

    case CONSTRAINT_INFO:
      RT (((lang_tree_node *)t)->constraint_info.template_reqs);
      RT (((lang_tree_node *)t)->constraint_info.declarator_reqs);
      RT (((lang_tree_node *)t)->constraint_info.associated_constr);
      break;

    case DEFERRED_NOEXCEPT:
      RT (((lang_tree_node *)t)->deferred_noexcept.pattern);
      RT (((lang_tree_node *)t)->deferred_noexcept.args);
      break;

    case LAMBDA_EXPR:
      RT (((lang_tree_node *)t)->lambda_expression.capture_list);
      RT (((lang_tree_node *)t)->lambda_expression.this_capture);
      RT (((lang_tree_node *)t)->lambda_expression.extra_scope);
      /* lambda_expression.pending_proxies is NULL  */
      ((lang_tree_node *)t)->lambda_expression.locus
        = state->read_location (*this);
      RUC (cp_lambda_default_capture_mode_type,
           ((lang_tree_node *)t)->lambda_expression.default_capture_mode);
      RU (((lang_tree_node *)t)->lambda_expression.discriminator);
      break;

    case OVERLOAD:
      RT (((lang_tree_node *)t)->overload.function);
      RT (t->common.chain);
      break;

    case PTRMEM_CST:
      RT (((lang_tree_node *)t)->ptrmem.member);
      break;

    case STATIC_ASSERT:
      RT (((lang_tree_node *)t)->static_assertion.condition);
      RT (((lang_tree_node *)t)->static_assertion.message);
      ((lang_tree_node *)t)->static_assertion.location
        = state->read_location (*this);
      break;

    case TEMPLATE_DECL:
      /* Streamed when reading the raw template decl itself.  */
      gcc_assert (((lang_tree_node *)t)->template_decl.arguments);
      gcc_assert (((lang_tree_node *)t)->template_decl.result);
      if (DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (t))
        RT (DECL_CHAIN (t));
      break;

    case TEMPLATE_INFO:
      RT (((lang_tree_node *)t)->template_info.tmpl);
      RT (((lang_tree_node *)t)->template_info.args);
      if (unsigned len = u ())
        {
          auto &ac = (((lang_tree_node *)t)
                      ->template_info.deferred_access_checks);
          vec_alloc (ac, len);
          for (unsigned ix = 0; ix != len; ix++)
            {
              deferred_access_check m;

              RT (m.binfo);
              RT (m.decl);
              RT (m.diag_decl);
              m.loc = state->read_location (*this);
              ac->quick_push (m);
            }
        }
      break;

    case TEMPLATE_PARM_INDEX:
      RU (((lang_tree_node *)t)->tpi.index);
      RU (((lang_tree_node *)t)->tpi.level);
      RU (((lang_tree_node *)t)->tpi.orig_level);
      RT (((lang_tree_node *)t)->tpi.decl);
      break;

    case TRAIT_EXPR:
      RT (((lang_tree_node *)t)->trait_expression.type1);
      RT (((lang_tree_node *)t)->trait_expression.type2);
      RUC (cp_trait_kind, ((lang_tree_node *)t)->trait_expression.kind);
      break;
    }

  if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
    {
      tree type = tree_node ();

      if (type && code == ENUMERAL_TYPE && !ENUM_FIXED_UNDERLYING_TYPE_P (t))
        {
          unsigned precision = u ();

          type = build_distinct_type_copy (type);
          TYPE_PRECISION (type) = precision;
          set_min_and_max_values_for_integral_type (type, precision,
                                                    TYPE_SIGN (type));
        }

      if (code != TEMPLATE_DECL)
        t->typed.type = type;
    }

#undef RT
#undef RM
#undef RU
  return !get_overrun ();
}

void
trees_out::lang_decl_vals (tree t)
{
  const struct lang_decl *lang = DECL_LANG_SPECIFIC (t);
#define WU(X) (u (X))
#define WT(X) (tree_node (X))
  /* Module index already written.  */
  switch (lang->u.base.selector)
    {
    default:
      gcc_unreachable ();

    case lds_fn:  /* lang_decl_fn.  */
      if (streaming_p ())
        {
          if (DECL_NAME (t) && IDENTIFIER_OVL_OP_P (DECL_NAME (t)))
            WU (lang->u.fn.ovl_op_code);
        }

      if (DECL_CLASS_SCOPE_P (t))
        WT (lang->u.fn.context);

      if (lang->u.fn.thunk_p)
        {
          /* The thunked-to function.  */
          WT (lang->u.fn.befriending_classes);
          if (streaming_p ())
            wi (lang->u.fn.u5.fixed_offset);
        }
      else
        WT (lang->u.fn.u5.cloned_function);

      if (FNDECL_USED_AUTO (t))
        WT (lang->u.fn.u.saved_auto_return_type);

      goto lds_min;

    case lds_decomp:  /* lang_decl_decomp.  */
      WT (lang->u.decomp.base);
      goto lds_min;

    case lds_min:  /* lang_decl_min.  */
    lds_min:
      WT (lang->u.min.template_info);
      {
        tree access = lang->u.min.access;

        /* DECL_ACCESS needs to be maintained by the definition of the
           (derived) class that changes the access.  The other users
           of DECL_ACCESS need to write it here.  */
        if (!DECL_THUNK_P (t)
            && (DECL_CONTEXT (t) && TYPE_P (DECL_CONTEXT (t))))
          access = NULL_TREE;

        WT (access);
      }
      break;

    case lds_ns:  /* lang_decl_ns.  */
      break;

    case lds_parm:  /* lang_decl_parm.  */
      if (streaming_p ())
        {
          WU (lang->u.parm.level);
          WU (lang->u.parm.index);
        }
      break;
    }
#undef WU
#undef WT
}

bool
trees_in::lang_decl_vals (tree t)
{
  struct lang_decl *lang = DECL_LANG_SPECIFIC (t);
#define RU(X) ((X) = u ())
#define RT(X) ((X) = tree_node ())

  /* Module index already read.  */
  switch (lang->u.base.selector)
    {
    default:
      gcc_unreachable ();

    case lds_fn:  /* lang_decl_fn.  */
      if (DECL_NAME (t) && IDENTIFIER_OVL_OP_P (DECL_NAME (t)))
        {
          unsigned code = u ();

          /* Check consistency.  */
          if (code >= OVL_OP_MAX
              || (ovl_op_info[IDENTIFIER_ASSIGN_OP_P (DECL_NAME (t))][code]
                  .ovl_op_code) == OVL_OP_ERROR_MARK)
            set_overrun ();
          else
            lang->u.fn.ovl_op_code = code;
        }

      if (DECL_CLASS_SCOPE_P (t))
        RT (lang->u.fn.context);

      if (lang->u.fn.thunk_p)
        {
          RT (lang->u.fn.befriending_classes);
          lang->u.fn.u5.fixed_offset = wi ();
        }
      else
        RT (lang->u.fn.u5.cloned_function);

      if (FNDECL_USED_AUTO (t))
        RT (lang->u.fn.u.saved_auto_return_type);
      goto lds_min;

    case lds_decomp:  /* lang_decl_decomp.  */
      RT (lang->u.decomp.base);
      goto lds_min;

    case lds_min:  /* lang_decl_min.  */
    lds_min:
      RT (lang->u.min.template_info);
      RT (lang->u.min.access);
      break;

    case lds_ns:  /* lang_decl_ns.  */
      break;

    case lds_parm:  /* lang_decl_parm.  */
      RU (lang->u.parm.level);
      RU (lang->u.parm.index);
      break;
    }
#undef RU
#undef RT
  return !get_overrun ();
}

/* Most of the value contents of lang_type is streamed in
   define_class.  */

void
trees_out::lang_type_vals (tree t)
{
  const struct lang_type *lang = TYPE_LANG_SPECIFIC (t);
#define WU(X) (u (X))
#define WT(X) (tree_node (X))
  if (streaming_p ())
    WU (lang->align);
#undef WU
#undef WT
}

bool
trees_in::lang_type_vals (tree t)
{
  struct lang_type *lang = TYPE_LANG_SPECIFIC (t);
#define RU(X) ((X) = u ())
#define RT(X) ((X) = tree_node ())
  RU (lang->align);
#undef RU
#undef RT
  return !get_overrun ();
}

/* Write out the bools of T, including information about any
   LANG_SPECIFIC information.  Including allocation of any lang
   specific object.  */

void
trees_out::tree_node_bools (tree t)
{
  gcc_checking_assert (streaming_p ());

  /* We should never stream a namespace.  */
  gcc_checking_assert (TREE_CODE (t) != NAMESPACE_DECL
                       || DECL_NAMESPACE_ALIAS (t));

  core_bools (t);

  switch (TREE_CODE_CLASS (TREE_CODE (t)))
    {
    case tcc_declaration:
      {
        bool specific = DECL_LANG_SPECIFIC (t) != NULL;
        b (specific);
        if (specific && VAR_P (t))
          b (DECL_DECOMPOSITION_P (t));
        if (specific)
          lang_decl_bools (t);
      }
      break;

    case tcc_type:
      {
        bool specific = (TYPE_MAIN_VARIANT (t) == t
                         && TYPE_LANG_SPECIFIC (t) != NULL);
        gcc_assert (TYPE_LANG_SPECIFIC (t)
                    == TYPE_LANG_SPECIFIC (TYPE_MAIN_VARIANT (t)));

        b (specific);
        if (specific)
          lang_type_bools (t);
      }
      break;

    default:
      break;
    }

  bflush ();
}

bool
trees_in::tree_node_bools (tree t)
{
  bool ok = core_bools (t);

  if (ok)
    switch (TREE_CODE_CLASS (TREE_CODE (t)))
      {
      case tcc_declaration:
        if (b ())
          {
            bool decomp = VAR_P (t) && b ();

            ok = maybe_add_lang_decl_raw (t, decomp);
            if (ok)
              ok = lang_decl_bools (t);
        }
        break;

      case tcc_type:
        if (b ())
          {
            ok = maybe_add_lang_type_raw (t);
            if (ok)
              ok = lang_type_bools (t);
          }
        break;

      default:
        break;
      }

  bflush ();
  if (!ok || get_overrun ())
    return false;

  return true;
}


/* Write out the lang-specifc vals of node T.  */

void
trees_out::lang_vals (tree t)
{
  switch (TREE_CODE_CLASS (TREE_CODE (t)))
    {
    case tcc_declaration:
      if (DECL_LANG_SPECIFIC (t))
        lang_decl_vals (t);
      break;

    case tcc_type:
      if (TYPE_MAIN_VARIANT (t) == t && TYPE_LANG_SPECIFIC (t))
        lang_type_vals (t);
      break;

    default:
      break;
    }
}

bool
trees_in::lang_vals (tree t)
{
  bool ok = true;

  switch (TREE_CODE_CLASS (TREE_CODE (t)))
    {
    case tcc_declaration:
      if (DECL_LANG_SPECIFIC (t))
        ok = lang_decl_vals (t);
      break;

    case tcc_type:
      if (TYPE_LANG_SPECIFIC (t))
        ok = lang_type_vals (t);
      else
        TYPE_LANG_SPECIFIC (t) = TYPE_LANG_SPECIFIC (TYPE_MAIN_VARIANT (t));
      break;

    default:
      break;
    }

  return ok;
}

/* Write out the value fields of node T.  */

void
trees_out::tree_node_vals (tree t)
{
  core_vals (t);
  lang_vals (t);
}

bool
trees_in::tree_node_vals (tree t)
{
  bool ok = core_vals (t);
  if (ok)
    ok = lang_vals (t);

  return ok;
}


/* If T is a back reference, fixed reference or NULL, write out it's
   code and return WK_none.  Otherwise return WK_value if we must write
   by value, or WK_normal otherwise.  */

walk_kind
trees_out::ref_node (tree t)
{
  if (!t)
    {
      if (streaming_p ())
        {
          /* NULL_TREE -> tt_null.  */
          null_count++;
          i (tt_null);
        }
      return WK_none;
    }

  if (!TREE_VISITED (t))
    return WK_normal;

  /* An already-visited tree.  It must be in the map.  */
  int val = get_tag (t);

  if (val == tag_value)
    /* An entry we should walk into.  */
    return WK_value;

  const char *kind;

  if (val <= tag_backref)
    {
      /* Back reference -> -ve number  */
      if (streaming_p ())
        i (val);
      kind = "backref";
    }
  else if (val >= tag_fixed)
    {
      /* Fixed reference -> tt_fixed */
      val -= tag_fixed;
      if (streaming_p ())
        i (tt_fixed), u (val);
      kind = "fixed";
    }

  if (streaming_p ())
    {
      back_ref_count++;
      dump (dumper::TREE)
        && dump ("Wrote %s:%d %C:%N%S", kind, val, TREE_CODE (t), t, t);
    }
  return WK_none;
}

tree
trees_in::back_ref (int tag)
{
  tree res = NULL_TREE;

  if (tag < 0 && unsigned (~tag) < back_refs.length ())
    res = back_refs[~tag];

  if (!res
      /* Checking TREE_CODE is a dereference, so we know this is not a
         wild pointer.  Checking the code provides evidence we've not
         corrupted something.  */
      || TREE_CODE (res) >= MAX_TREE_CODES)
    set_overrun ();
  else
    dump (dumper::TREE) && dump ("Read backref:%d found %C:%N%S", tag,
                                 TREE_CODE (res), res, res);
  return res;
}

unsigned
trees_out::add_indirect_tpl_parms (tree parms)
{
  unsigned len = 0;
  for (; parms; parms = TREE_CHAIN (parms), len++)
    {
      if (TREE_VISITED (parms))
        break;

      int tag = insert (parms);
      if (streaming_p ())
        dump (dumper::TREE)
          && dump ("Indirect:%d template's parameter %u %C:%N",
                   tag, len, TREE_CODE (parms), parms);
    }

  if (streaming_p ())
    u (len);

  return len;
}

unsigned
trees_in::add_indirect_tpl_parms (tree parms)
{
  unsigned len = u ();
  for (unsigned ix = 0; ix != len; parms = TREE_CHAIN (parms), ix++)
    {
      int tag = insert (parms);
      dump (dumper::TREE)
        && dump ("Indirect:%d template's parameter %u %C:%N",
                 tag, ix, TREE_CODE (parms), parms);
    }

  return len;
}

/* We've just found DECL by name.  Insert nodes that come with it, but
   cannot be found by name, so we'll not accidentally walk into them.  */

void
trees_out::add_indirects (tree decl)
{
  unsigned count = 0;

  // FIXME:OPTIMIZATION We'll eventually want default fn parms of
  // templates and perhaps default template parms too.  The former can
  // be referenced from instantiations (as they are lazily
  // instantiated).  Also (deferred?) exception specifications of
  // templates.  See the note about PARM_DECLs in trees_out::decl_node.
  tree inner = decl;
  if (TREE_CODE (decl) == TEMPLATE_DECL)
    {
      count += add_indirect_tpl_parms (DECL_TEMPLATE_PARMS (decl));

      inner = DECL_TEMPLATE_RESULT (decl);
      int tag = insert (inner);
      if (streaming_p ())
        dump (dumper::TREE)
          && dump ("Indirect:%d template's result %C:%N",
                   tag, TREE_CODE (inner), inner);
      count++;
    }

  if (TREE_CODE (inner) == TYPE_DECL)
    {
      /* Make sure the type is in the map too.  Otherwise we get
         different RECORD_TYPEs for the same type, and things go
         south.  */
      tree type = TREE_TYPE (inner);
      gcc_checking_assert (DECL_ORIGINAL_TYPE (inner)
                           || TYPE_NAME (type) == inner);
      int tag = insert (type);
      if (streaming_p ())
        dump (dumper::TREE) && dump ("Indirect:%d decl's type %C:%N", tag,
                                     TREE_CODE (type), type);
      count++;
    }

  if (streaming_p ())
    {
      u (count);
      dump (dumper::TREE) && dump ("Inserted %u indirects", count);
    }
}

bool
trees_in::add_indirects (tree decl)
{
  unsigned count = 0;
            
  tree inner = decl;
  if (TREE_CODE (inner) == TEMPLATE_DECL)
    {
      count += add_indirect_tpl_parms (DECL_TEMPLATE_PARMS (decl));

      inner = DECL_TEMPLATE_RESULT (decl);
      int tag = insert (inner);
      dump (dumper::TREE)
        && dump ("Indirect:%d templates's result %C:%N", tag,
                 TREE_CODE (inner), inner);
      count++;
    }

  if (TREE_CODE (inner) == TYPE_DECL)
    {
      tree type = TREE_TYPE (inner);
      gcc_checking_assert (DECL_ORIGINAL_TYPE (inner)
                           || TYPE_NAME (type) == inner);
      int tag = insert (type);
      dump (dumper::TREE)
        && dump ("Indirect:%d decl's type %C:%N", tag, TREE_CODE (type), type);
      count++;
    }

  dump (dumper::TREE) && dump ("Inserted %u indirects", count);
  return count == u ();
}

/* Stream a template parameter.  There are 4.5 kinds of parameter:
   a) Template - TEMPLATE_DECL->TYPE_DECL->TEMPLATE_TEMPLATE_PARM
        TEMPLATE_TYPE_PARM_INDEX TPI
   b) Type - TYPE_DECL->TEMPLATE_TYPE_PARM TEMPLATE_TYPE_PARM_INDEX TPI
   c.1) NonTYPE - PARM_DECL DECL_INITIAL TPI We meet this first
   c.2) NonTYPE - CONST_DECL DECL_INITIAL Same TPI
   d) BoundTemplate - TYPE_DECL->BOUND_TEMPLATE_TEMPLATE_PARM
       TEMPLATE_TYPE_PARM_INDEX->TPI
       TEMPLATE_TEMPLATE_PARM_INFO->TEMPLATE_INFO

   All of these point to a TEMPLATE_PARM_INDEX, and #B also has a TEMPLATE_INFO
*/

void
trees_out::tpl_parm_value (tree parm)
{
  gcc_checking_assert (DECL_P (parm) && DECL_TEMPLATE_PARM_P (parm));

  int parm_tag = insert (parm);
  if (streaming_p ())
    {
      i (tt_tpl_parm);
      dump (dumper::TREE) && dump ("Writing template parm:%d %C:%N",
                                   parm_tag, TREE_CODE (parm), parm);
      start (parm);
      tree_node_bools (parm);
    }

  tree inner = parm;
  if (TREE_CODE (inner) == TEMPLATE_DECL)
    {
      inner = DECL_TEMPLATE_RESULT (inner);
      int inner_tag = insert (inner);
      if (streaming_p ())
        {
          dump (dumper::TREE) && dump ("Writing inner template parm:%d %C:%N",
                                       inner_tag, TREE_CODE (inner), inner);
          start (inner);
          tree_node_bools (inner);
        }
    }

  tree type = NULL_TREE;
  if (TREE_CODE (inner) == TYPE_DECL)
    {
      type = TREE_TYPE (inner);
      int type_tag = insert (type);
      if (streaming_p ())
        {
          dump (dumper::TREE) && dump ("Writing template parm type:%d %C:%N",
                                       type_tag, TREE_CODE (type), type);
          start (type);
          tree_node_bools (type);
        }
    }

  if (inner != parm)
    {
      /* This is a template-template parameter.  */
      unsigned tpl_levels = 0;
      tpl_header (parm, &tpl_levels);
      tpl_parms_fini (parm, tpl_levels);
    }

  tree_node_vals (parm);
  if (inner != parm)
    tree_node_vals (inner);
  if (type)
    {
      tree_node_vals (type);
      if (DECL_NAME (inner) == auto_identifier
          || DECL_NAME (inner) == decltype_auto_identifier)
        {
          /* Placeholder auto.  */
          tree_node (DECL_INITIAL (inner));
          tree_node (DECL_SIZE_UNIT (inner));
        }
    }

  if (streaming_p ())
    dump (dumper::TREE) && dump ("Wrote template parm:%d %C:%N",
                                 parm_tag, TREE_CODE (parm), parm);
}

tree
trees_in::tpl_parm_value ()
{
  tree parm = start ();
  if (!parm || !tree_node_bools (parm))
    return NULL_TREE;

  int parm_tag = insert (parm);
  dump (dumper::TREE) && dump ("Reading template parm:%d %C:%N",
                               parm_tag, TREE_CODE (parm), parm);

  tree inner = parm;
  if (TREE_CODE (inner) == TEMPLATE_DECL)
    {
      inner = start ();
      if (!inner || !tree_node_bools (inner))
        return NULL_TREE;
      int inner_tag = insert (inner);
      dump (dumper::TREE) && dump ("Reading inner template parm:%d %C:%N",
                                   inner_tag, TREE_CODE (inner), inner);
      DECL_TEMPLATE_RESULT (parm) = inner;
    }

  tree type = NULL_TREE;
  if (TREE_CODE (inner) == TYPE_DECL)
    {
      type = start ();
      if (!type || !tree_node_bools (type))
        return NULL_TREE;
      int type_tag = insert (type);
      dump (dumper::TREE) && dump ("Reading template parm type:%d %C:%N",
                                   type_tag, TREE_CODE (type), type);

      TREE_TYPE (inner) = TREE_TYPE (parm) = type;
      TYPE_NAME (type) = parm;
    }

  if (inner != parm)
    {
      /* A template template parameter.  */
      unsigned tpl_levels = 0;
      tpl_header (parm, &tpl_levels);
      tpl_parms_fini (parm, tpl_levels);
    }

  tree_node_vals (parm);
  if (inner != parm)
    tree_node_vals (inner);
  if (type)
    {
      tree_node_vals (type);
      if (DECL_NAME (inner) == auto_identifier
          || DECL_NAME (inner) == decltype_auto_identifier)
        {
          /* Placeholder auto.  */
          DECL_INITIAL (inner) = tree_node ();
          DECL_SIZE_UNIT (inner) = tree_node ();
        }
      if (TYPE_CANONICAL (type))
        {
          gcc_checking_assert (TYPE_CANONICAL (type) == type);
          TYPE_CANONICAL (type) = canonical_type_parameter (type);
        }
    }

  dump (dumper::TREE) && dump ("Read template parm:%d %C:%N",
                               parm_tag, TREE_CODE (parm), parm);

  return parm;
}

void
trees_out::install_entity (tree decl, depset *dep)
{
  gcc_checking_assert (streaming_p ());
  
  /* Write the entity index, so we can insert it as soon as we
     know this is new.  */
  u (dep ? dep->cluster + 1 : 0);
  if (CHECKING_P && dep)
    {
      /* Add it to the entity map, such that we can tell it is
         part of us.  */
      bool existed;
      unsigned *slot = &entity_map->get_or_insert
        (DECL_UID (decl), &existed);
      if (existed)
        /* If it existed, it should match.  */
        gcc_checking_assert (decl == (*entity_ary)[*slot]);
      *slot = ~dep->cluster;
    }
}

bool
trees_in::install_entity (tree decl)
{
  unsigned entity_index = u ();
  if (!entity_index)
    return false;

  if (entity_index > state->entity_num)
    {
      set_overrun ();
      return false;
    }

  /* Insert the real decl into the entity ary.  */
  unsigned ident = state->entity_lwm + entity_index - 1;
  binding_slot &elt = (*entity_ary)[ident];

  /* See module_state::read_pendings for how this got set.  */
  int pending = elt.get_lazy () & 3;

  elt = decl;

  /* And into the entity map, if it's not already there.  */
  if (!DECL_LANG_SPECIFIC (decl)
      || !DECL_MODULE_ENTITY_P (decl))
    {
      retrofit_lang_decl (decl);
      DECL_MODULE_ENTITY_P (decl) = true;

      /* Insert into the entity hash (it cannot already be there).  */
      bool existed;
      unsigned &slot = entity_map->get_or_insert (DECL_UID (decl), &existed);
      gcc_checking_assert (!existed);
      slot = ident;
    }
  else if (pending != 0)
    {
      unsigned key_ident = import_entity_index (decl);
      if (pending & 1)
        if (!pending_table->add (key_ident, ~ident))
          pending &= ~1;

      if (pending & 2)
        if (!pending_table->add (~key_ident, ~ident))
          pending &= ~2;
    }

  if (pending & 1)
    DECL_MODULE_PENDING_SPECIALIZATIONS_P (decl) = true;

  if (pending & 2)
    {
      DECL_MODULE_PENDING_MEMBERS_P (decl) = true;
      gcc_checking_assert (TREE_CODE (decl) != TEMPLATE_DECL);
    }

  return true;
}

static bool has_definition (tree decl);

/* DECL is a decl node that must be written by value.  DEP is the
   decl's depset.  */

void
trees_out::decl_value (tree decl, depset *dep)
{
  /* We should not be writing clones or template parms.  */
  gcc_checking_assert (DECL_P (decl)
                       && !DECL_CLONED_FUNCTION_P (decl)
                       && !DECL_TEMPLATE_PARM_P (decl));

  /* We should never be writing non-typedef ptrmemfuncs by value.  */
  gcc_checking_assert (TREE_CODE (decl) != TYPE_DECL
                       || DECL_ORIGINAL_TYPE (decl)
                       || !TYPE_PTRMEMFUNC_P (TREE_TYPE (decl)));

  merge_kind mk = get_merge_kind (decl, dep);

  if (CHECKING_P)
    {
      /* Never start in the middle of a template.  */
      int use_tpl = -1;
      if (tree ti = node_template_info (decl, use_tpl))
        gcc_checking_assert (TREE_CODE (TI_TEMPLATE (ti)) == OVERLOAD
                             || TREE_CODE (TI_TEMPLATE (ti)) == FIELD_DECL
                             || (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti))
                                 != decl));
    }

  if (streaming_p ())
    {
      /* A new node -> tt_decl.  */
      decl_val_count++;
      i (tt_decl);
      u (mk);
      start (decl);

      if (mk != MK_unique)
        {
          if (!(mk & MK_template_mask) && !state->is_header ())
            {
              /* Tell the importer whether this is a global module entity,
                 or a module entity.  This bool merges into the next block
                 of bools.  Sneaky.  */
              tree o = get_originating_module_decl (decl);
              bool is_mod = false;

              if (dep && dep->is_alias_tmpl_inst ())
                /* Alias template instantiations are templatey, but
                   found by name.  */
                is_mod = false;
              else if (DECL_LANG_SPECIFIC (o) && DECL_MODULE_PURVIEW_P (o))
                is_mod = true;
              b (is_mod);
            }
          b (dep && dep->has_defn ());
        }
      tree_node_bools (decl);
    }

  int tag = insert (decl, WK_value);
  if (streaming_p ())
    dump (dumper::TREE)
      && dump ("Writing %s:%d %C:%N%S", merge_kind_name[mk], tag,
               TREE_CODE (decl), decl, decl);

  tree inner = decl;
  int inner_tag = 0;
  if (TREE_CODE (decl) == TEMPLATE_DECL)
    {
      if (dep && dep->is_alias_tmpl_inst ())
        inner = NULL_TREE;
      else
        {
          inner = DECL_TEMPLATE_RESULT (decl);
          inner_tag = insert (inner, WK_value);
        }

      if (streaming_p ())
        {
          int code = inner ? TREE_CODE (inner) : 0;
          u (code);
          if (inner)
            {
              start (inner, true);
              tree_node_bools (inner);
              dump (dumper::TREE)
                && dump ("Writing %s:%d %C:%N%S", merge_kind_name[mk], inner_tag,
                         TREE_CODE (inner), inner, inner);
            }
        }
    }

  tree type = NULL_TREE;
  int type_tag = 0;
  tree stub_decl = NULL_TREE;
  int stub_tag = 0;
  if (inner && TREE_CODE (inner) == TYPE_DECL)
    {
      type = TREE_TYPE (inner);
      bool has_type = (type == TYPE_MAIN_VARIANT (type)
                       && TYPE_NAME (type) == inner);

      if (streaming_p ())
        u (has_type ? TREE_CODE (type) : 0);

      if (has_type)
        {
          type_tag = insert (type, WK_value);
          if (streaming_p ())
            {
              start (type, true);
              tree_node_bools (type);
              dump (dumper::TREE)
                && dump ("Writing type:%d %C:%N", type_tag,
                         TREE_CODE (type), type);
            }

          stub_decl = TYPE_STUB_DECL (type);
          bool has_stub = inner != stub_decl;
          if (streaming_p ())
            u (has_stub ? TREE_CODE (stub_decl) : 0);
          if (has_stub)
            {
              stub_tag = insert (stub_decl);
              if (streaming_p ())
                {
                  start (stub_decl, true);
                  tree_node_bools (stub_decl);
                  dump (dumper::TREE)
                    && dump ("Writing stub_decl:%d %C:%N", stub_tag,
                             TREE_CODE (stub_decl), stub_decl);
                }
            }
          else
            stub_decl = NULL_TREE;
        }
      else
        /* Regular typedef.  */
        type = NULL_TREE;
    }

  /* Stream the container, we want it correctly canonicalized before
     we start emitting keys for this decl.  */
  tree container = decl_container (decl);

  unsigned tpl_levels = 0;
  if (decl != inner)
    tpl_header (decl, &tpl_levels);
  if (inner && TREE_CODE (inner) == FUNCTION_DECL)
    fn_parms_init (inner);

  /* Now write out the merging information, and then really
     install the tag values.  */
  key_mergeable (tag, mk, decl, inner, container, dep);

  if (streaming_p ())
    dump (dumper::MERGE)
      && dump ("Wrote:%d's %s merge key %C:%N", tag,
               merge_kind_name[mk], TREE_CODE (decl), decl);

  if (inner && TREE_CODE (inner) == FUNCTION_DECL)
    fn_parms_fini (inner);

  if (!is_key_order ())
    tree_node_vals (decl);

  if (inner_tag)
    {
      if (!is_key_order ())
        tree_node_vals (inner);
      tpl_parms_fini (decl, tpl_levels);
    }
  else if (!inner)
    {
      /* A template alias instantiation.  */
      inner = DECL_TEMPLATE_RESULT (decl);
      if (!is_key_order ())
        tree_node (inner);
      if (streaming_p ())
        dump (dumper::TREE)
          && dump ("Wrote(%d) alias template %C:%N",
                   get_tag (inner), TREE_CODE (inner), inner);
      inner = NULL_TREE;
    }

  if (type && !is_key_order ())
    {
      tree_node_vals (type);
      if (stub_decl)
        tree_node_vals (stub_decl);
    }

  if (!is_key_order ())
    tree_node (get_constraints (decl));

  if (streaming_p ())
    {
      /* Do not stray outside this section.  */
      gcc_checking_assert (!dep || dep->section == dep_hash->section);

      /* Write the entity index, so we can insert it as soon as we
         know this is new.  */
      install_entity (decl, dep);
    }

  if (inner
      && VAR_OR_FUNCTION_DECL_P (inner)
      && DECL_LANG_SPECIFIC (inner)
      && DECL_MODULE_ATTACHMENTS_P (inner)
      && !is_key_order ())
    {
      /* Stream the attached entities.  */
      attachset *set = attached_table->get (DECL_UID (inner));
      unsigned num = set->num;
      if (streaming_p ())
        u (num);
      for (unsigned ix = 0; ix != num; ix++)
        {
          tree attached = set->values[ix];
          tree_node (attached);
          if (streaming_p ())
            dump (dumper::MERGE)
              && dump ("Written %d[%u] attached decl %N", tag, ix, attached);
        }
    }

  bool is_typedef = (!type && inner
                     && TREE_CODE (inner) == TYPE_DECL
                     && DECL_ORIGINAL_TYPE (inner)
                     && TYPE_NAME (TREE_TYPE (inner)) == inner);
  if (is_typedef)
    {
      /* A typedef type.  */
      int type_tag = insert (TREE_TYPE (inner));
      if (streaming_p ())
        dump (dumper::TREE)
          && dump ("Cloned:%d typedef %C:%N", type_tag,
                   TREE_CODE (TREE_TYPE (inner)), TREE_TYPE (inner));
    }

  if (streaming_p () && DECL_MAYBE_IN_CHARGE_CDTOR_P (decl))
    {
      bool cloned_p
        = (DECL_CHAIN (decl) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl)));
      bool needs_vtt_parm_p
        = (cloned_p && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (decl)));
      bool omit_inherited_parms_p
        = (cloned_p && DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
           && base_ctor_omit_inherited_parms (decl));
      unsigned flags = (int (cloned_p) << 0
                        | int (needs_vtt_parm_p) << 1
                        | int (omit_inherited_parms_p) << 2);
      u (flags);
      dump (dumper::TREE) && dump ("CDTOR %N is %scloned",
                                   decl, cloned_p ? "" : "not ");
    }

  if (streaming_p ())
    dump (dumper::TREE) && dump ("Written decl:%d %C:%N", tag,
                                 TREE_CODE (decl), decl);

  if (!inner || NAMESPACE_SCOPE_P (inner))
    gcc_checking_assert (!inner
                         || !dep == (VAR_OR_FUNCTION_DECL_P (inner)
                                     && DECL_LOCAL_DECL_P (inner)));
  else if ((TREE_CODE (inner) == TYPE_DECL
            && TYPE_NAME (TREE_TYPE (inner)) == inner
            && !is_typedef)
           || TREE_CODE (inner) == FUNCTION_DECL)
    {
      bool write_defn = !dep && has_definition (decl);
      if (streaming_p ())
        u (write_defn);
      if (write_defn)
        write_definition (decl);
    }
}

tree
trees_in::decl_value ()
{
  int tag = 0;
  bool is_mod = false;
  bool has_defn = false;
  unsigned mk_u = u ();
  if (mk_u >= MK_hwm || !merge_kind_name[mk_u])
    {
      set_overrun ();
      return NULL_TREE;
    }

  unsigned saved_unused = unused;
  unused = 0;
  
  merge_kind mk = merge_kind (mk_u);

  tree decl = start ();
  if (decl)
    {
      if (mk != MK_unique)
        {
          if (!(mk & MK_template_mask) && !state->is_header ())
            /* See note in trees_out about where this bool is sequenced.  */
            is_mod = b ();

          has_defn = b ();
        }

      if (!tree_node_bools (decl))
        decl = NULL_TREE;
    }
  
  /* Insert into map.  */
  tag = insert (decl);
  if (decl)
    dump (dumper::TREE)
      && dump ("Reading:%d %C", tag, TREE_CODE (decl));

  tree inner = decl;
  int inner_tag = 0;
  if (decl && TREE_CODE (decl) == TEMPLATE_DECL)
    {
      int code = u ();
      if (!code)
        {
          inner = NULL_TREE;
          DECL_TEMPLATE_RESULT (decl) = error_mark_node;
        }
      else
        {
          inner = start (code);
          if (inner && tree_node_bools (inner))
            DECL_TEMPLATE_RESULT (decl) = inner;
          else
            decl = NULL_TREE;

          inner_tag = insert (inner);
          if (decl)
            dump (dumper::TREE)
              && dump ("Reading:%d %C", inner_tag, TREE_CODE (inner));
        }
    }

  tree type = NULL_TREE;
  int type_tag = 0;
  tree stub_decl = NULL_TREE;
  int stub_tag = 0;
  if (decl && inner && TREE_CODE (inner) == TYPE_DECL)
    {
      if (unsigned type_code = u ())
        {
          type = start (type_code);
          if (type && tree_node_bools (type))
            {
              TREE_TYPE (inner) = type;
              TYPE_NAME (type) = inner;
            }
          else
            decl = NULL_TREE;

          type_tag = insert (type);
          if (decl)
            dump (dumper::TREE)
              && dump ("Reading type:%d %C", type_tag, TREE_CODE (type));

          if (unsigned stub_code = u ())
            {
              stub_decl = start (stub_code);
              if (stub_decl && tree_node_bools (stub_decl))
                {
                  TREE_TYPE (stub_decl) = type;
                  TYPE_STUB_DECL (type) = stub_decl;
                }
              else
                decl = NULL_TREE;

              stub_tag = insert (stub_decl);
              if (decl)
                dump (dumper::TREE)
                  && dump ("Reading stub_decl:%d %C", stub_tag,
                           TREE_CODE (stub_decl));
            }
        }
    }

  if (!decl)
    {
    bail:
      if (inner_tag != 0)
        back_refs[~inner_tag] = NULL_TREE;
      if (type_tag != 0)
        back_refs[~type_tag] = NULL_TREE;
      if (stub_tag != 0)
        back_refs[~stub_tag] = NULL_TREE;
      if (tag != 0)
        back_refs[~tag] = NULL_TREE;
      set_overrun ();
      /* Bail.  */
      unused = saved_unused;
      return NULL_TREE;
    }

  /* Read the container, to ensure it's already been streamed in.  */
  tree container = decl_container ();
  unsigned tpl_levels = 0;

  /* Figure out if this decl is already known about.  */
  int parm_tag = 0;

  if (decl != inner)
    if (!tpl_header (decl, &tpl_levels))
      goto bail;
  if (inner && TREE_CODE (inner) == FUNCTION_DECL)
    parm_tag = fn_parms_init (inner);

  tree existing = key_mergeable (tag, mk, decl, inner, type, container, is_mod);
  tree existing_inner = existing;
  if (existing)
    {
      if (existing == error_mark_node)
        goto bail;

      if (TREE_CODE (STRIP_TEMPLATE (existing)) == TYPE_DECL)
        {
          tree etype = TREE_TYPE (existing);
          if (TYPE_LANG_SPECIFIC (etype)
              && COMPLETE_TYPE_P (etype)
              && !CLASSTYPE_MEMBER_VEC (etype))
            /* Give it a member vec, we're likely gonna be looking
               inside it.  */
            set_class_bindings (etype, -1);
        }

      /* Install the existing decl into the back ref array.  */
      register_duplicate (decl, existing);
      back_refs[~tag] = existing;
      if (inner_tag != 0)
        {
          existing_inner = DECL_TEMPLATE_RESULT (existing);
          back_refs[~inner_tag] = existing_inner;
        }

      if (type_tag != 0)
        {
          tree existing_type = TREE_TYPE (existing);
          back_refs[~type_tag] = existing_type;
          if (stub_tag != 0)
            back_refs[~stub_tag] = TYPE_STUB_DECL (existing_type);
        }
    }

  if (parm_tag)
    fn_parms_fini (parm_tag, inner, existing_inner, has_defn);

  if (!tree_node_vals (decl))
    goto bail;

  if (inner_tag)
    {
      gcc_checking_assert (DECL_TEMPLATE_RESULT (decl) == inner);

      if (!tree_node_vals (inner))
        goto bail;

      if (!tpl_parms_fini (decl, tpl_levels))
        goto bail;
    }
  else if (!inner)
    {
      inner = tree_node ();
      DECL_TEMPLATE_RESULT (decl) = inner;
      TREE_TYPE (decl) = TREE_TYPE (inner);
      dump (dumper::TREE)
        && dump ("Read alias template %C:%N", TREE_CODE (inner), inner);
      inner = NULL_TREE;
    }

  if (type && (!tree_node_vals (type)
               || (stub_decl && !tree_node_vals (stub_decl))))
    goto bail;

  tree constraints = tree_node ();

  dump (dumper::TREE) && dump ("Read:%d %C:%N", tag, TREE_CODE (decl), decl);

  /* Regular typedefs will have a NULL TREE_TYPE at this point.  */
  bool is_typedef = (!type && inner
                     && TREE_CODE (inner) == TYPE_DECL
                     && DECL_ORIGINAL_TYPE (inner)
                     && !TREE_TYPE (inner));
  if (is_typedef)
    {
      /* Frob it to be ready for cloning.  */
      TREE_TYPE (inner) = DECL_ORIGINAL_TYPE (inner);
      DECL_ORIGINAL_TYPE (inner) = NULL_TREE;
    }

  existing = back_refs[~tag];
  bool installed = install_entity (existing);
  bool is_new = existing == decl;

  if (inner
      && VAR_OR_FUNCTION_DECL_P (inner)
      && DECL_LANG_SPECIFIC (inner)
      && DECL_MODULE_ATTACHMENTS_P (inner))
    {
      /* Read and maybe install the attached entities.  */
      attachset *set
        = attached_table->get (DECL_UID (STRIP_TEMPLATE (existing)));
      unsigned num = u ();
      if (!is_new == !set)
        set_overrun ();
      if (is_new)
        set = attached_table->create (DECL_UID (inner), num, NULL_TREE);
      for (unsigned ix = 0; !get_overrun () && ix != num; ix++)
        {
          tree attached = tree_node ();
          dump (dumper::MERGE)
            && dump ("Read %d[%u] %s attached decl %N", tag, ix,
                     is_new ? "new" : "matched", attached);
          if (is_new)
            set->values[ix] = attached;
          else if (set->values[ix] != attached)
            set_overrun ();
        }
    }

  if (is_new)
    {
      /* A newly discovered node.  */
      if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
        /* Mark this identifier as naming a virtual function --
           lookup_overrides relies on this optimization.  */
        IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = true;

      if (installed)
        {
          /* Mark the entity as imported and add it to the entity
             array and map.  */
          retrofit_lang_decl (decl);
          DECL_MODULE_IMPORT_P (decl) = true;
          if (inner_tag)
            {
              retrofit_lang_decl (inner);
              DECL_MODULE_IMPORT_P (inner) = true;
            }
        }

      if (constraints)
        set_constraints (decl, constraints);

      if (TREE_CODE (decl) == INTEGER_CST && !TREE_OVERFLOW (decl))
        {
          decl = cache_integer_cst (decl, true);
          back_refs[~tag] = decl;
        }

      if (is_typedef)
        set_underlying_type (inner);

      if (inner_tag)
        /* Set the TEMPLATE_DECL's type.  */
        TREE_TYPE (decl) = TREE_TYPE (inner);

      /* The late insertion of an alias here or an implicit member
         (next block), is ok, because we ensured that all imports were
         loaded up before we started this cluster.  Thus an insertion
         from some other import cannot have happened between the
         merged insertion above and these insertions down here.  */
      if (mk == MK_alias_spec)
        {
          /* Insert into type table.  */
          tree ti = DECL_TEMPLATE_INFO (inner);
          spec_entry elt = 
            {TI_TEMPLATE (ti), TI_ARGS (ti), TREE_TYPE (inner)};
          tree texist = match_mergeable_specialization (false, &elt);
          if (texist)
            set_overrun ();
        }

      if (DECL_ARTIFICIAL (decl)
          && TREE_CODE (decl) == FUNCTION_DECL
          && !DECL_TEMPLATE_INFO (decl)
          && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
          && TYPE_SIZE (DECL_CONTEXT (decl))
          && !DECL_THUNK_P (decl))
        /* A new implicit member function, when the class is
           complete.  This means the importee declared it, and
           we must now add it to the class.  Note that implicit
           member fns of template instantiations do not themselves
           look like templates.  */
        if (!install_implicit_member (inner))
          set_overrun ();
    }
  else
    {
      /* DECL is the to-be-discarded decl.  Its internal pointers will
         be to the EXISTING's structure.  Frob it to point to its
         own other structures, so loading its definition will alter
         it, and not the existing decl.  */
      dump (dumper::MERGE) && dump ("Deduping %N", existing);

      if (inner_tag)
        DECL_TEMPLATE_RESULT (decl) = inner;

      if (type)
        {
          /* Point at the to-be-discarded type & decl.  */
          TYPE_NAME (type) = inner;
          TREE_TYPE (inner) = type;

          TYPE_STUB_DECL (type) = stub_decl ? stub_decl : inner;
          if (stub_decl)
            TREE_TYPE (stub_decl) = type;
        }

      if (inner_tag)
        /* Set the TEMPLATE_DECL's type.  */
        TREE_TYPE (decl) = TREE_TYPE (inner);

      if (!is_matching_decl (existing, decl))
        unmatched_duplicate (existing);

      /* And our result is the existing node.  */
      decl = existing;
    }

  if (is_typedef)
    {
      /* Insert the type into the array now.  */
      tag = insert (TREE_TYPE (decl));
      dump (dumper::TREE)
        && dump ("Cloned:%d typedef %C:%N",
                 tag, TREE_CODE (TREE_TYPE (decl)), TREE_TYPE (decl));
    }

  unused = saved_unused;

  if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl))
    {
      unsigned flags = u ();

      if (is_new)
        {
          bool cloned_p = flags & 1;
          dump (dumper::TREE) && dump ("CDTOR %N is %scloned",
                                       decl, cloned_p ? "" : "not ");
          if (cloned_p)
            build_cdtor_clones (decl, flags & 2, flags & 4,
                                /* Update the member vec, if there is
                                   one (we're in a different cluster
                                   to the class defn).  */
                                CLASSTYPE_MEMBER_VEC (DECL_CONTEXT (decl)));
        }
    }

  if (inner
      && !NAMESPACE_SCOPE_P (inner)
      && ((TREE_CODE (inner) == TYPE_DECL
           && TYPE_NAME (TREE_TYPE (inner)) == inner
           && !is_typedef)
          || TREE_CODE (inner) == FUNCTION_DECL)
      && u ())
    read_definition (decl);

  return decl;
}

/* DECL is an unnameable member of CTX.  Return a suitable identifying
   index.  */

static unsigned
get_field_ident (tree ctx, tree decl)
{
  gcc_checking_assert (TREE_CODE (decl) == USING_DECL
                       || !DECL_NAME (decl)
                       || IDENTIFIER_ANON_P (DECL_NAME (decl)));

  unsigned ix = 0;
  for (tree fields = TYPE_FIELDS (ctx);
       fields; fields = DECL_CHAIN (fields))
    {
      if (fields == decl)
        return ix;

      if (DECL_CONTEXT (fields) == ctx
          && (TREE_CODE (fields) == USING_DECL
              || (TREE_CODE (fields) == FIELD_DECL
                  && (!DECL_NAME (fields)
                      || IDENTIFIER_ANON_P (DECL_NAME (fields))))))
        /* Count this field.  */
        ix++;
    }
  gcc_unreachable ();
}

static tree
lookup_field_ident (tree ctx, unsigned ix)
{
  for (tree fields = TYPE_FIELDS (ctx);
       fields; fields = DECL_CHAIN (fields))
    if (DECL_CONTEXT (fields) == ctx
        && (TREE_CODE (fields) == USING_DECL
            || (TREE_CODE (fields) == FIELD_DECL
                && (!DECL_NAME (fields)
                    || IDENTIFIER_ANON_P (DECL_NAME (fields))))))
      if (!ix--)
        return fields;

  return NULL_TREE;
}

/* Reference DECL.  REF indicates the walk kind we are performing.
   Return true if we should write this decl by value.  */

bool
trees_out::decl_node (tree decl, walk_kind ref)
{
  gcc_checking_assert (DECL_P (decl) && !DECL_TEMPLATE_PARM_P (decl)
                       && DECL_CONTEXT (decl));

  if (ref == WK_value)
    {
      depset *dep = dep_hash->find_dependency (decl);
      decl_value (decl, dep);
      return false;
    }

  switch (TREE_CODE (decl))
    {
    default:
      break;

    case FUNCTION_DECL:
      gcc_checking_assert (!DECL_LOCAL_DECL_P (decl));
      break;

    case RESULT_DECL:
      /* Unlike PARM_DECLs, RESULT_DECLs are only generated and
         referenced when we're inside the function itself.  */
      return true;

    case PARM_DECL:
      {
        if (streaming_p ())
          i (tt_parm);
        tree_node (DECL_CONTEXT (decl));
        if (streaming_p ())
          {
            /* That must have put this in the map.  */
            walk_kind ref = ref_node (decl);
            if (ref != WK_none)
              // FIXME:OPTIMIZATION We can wander into bits of the
              // template this was instantiated from.  For instance
              // deferred noexcept and default parms.  Currently we'll
              // end up cloning those bits of tree.  It would be nice
              // to reference those specific nodes.  I think putting
              // those things in the map when we reference their
              // template by name.  See the note in add_indirects.
              return true;

            dump (dumper::TREE)
              && dump ("Wrote %s reference %N",
                       TREE_CODE (decl) == PARM_DECL ? "parameter" : "result",
                       decl);
          }
      }
      return false;

    case IMPORTED_DECL:
      /* This describes a USING_DECL to the ME's debug machinery.  It
         originates from the fortran FE, and has nothing to do with
         C++ modules.  */
      return true;

    case LABEL_DECL:
      return true;

    case CONST_DECL:
      {
        /* If I end up cloning enum decls, implementing C++20 using
           E::v, this will need tweaking.   */
        if (streaming_p ())
          i (tt_enum_decl);
        tree ctx = DECL_CONTEXT (decl);
        gcc_checking_assert (TREE_CODE (ctx) == ENUMERAL_TYPE);
        tree_node (ctx);
        tree_node (DECL_NAME (decl));

        int tag = insert (decl);
        if (streaming_p ())
          dump (dumper::TREE)
            && dump ("Wrote enum decl:%d %C:%N", tag, TREE_CODE (decl), decl);
        return false;
      }
      break;

    case USING_DECL:
      if (TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
        break;
      /* FALLTHROUGH  */

    case FIELD_DECL:
      {
        if (streaming_p ())
          i (tt_data_member);

        tree ctx = DECL_CONTEXT (decl);
        tree_node (ctx);

        tree name = NULL_TREE;

        if (TREE_CODE (decl) == USING_DECL)
          ;
        else
          {
            name = DECL_NAME (decl);
            if (name && IDENTIFIER_ANON_P (name))
              name = NULL_TREE;
          }

        tree_node (name);
        if (!name && streaming_p ())
          {
            unsigned ix = get_field_ident (ctx, decl);
            u (ix);
          }

        int tag = insert (decl);
        if (streaming_p ())
          dump (dumper::TREE)
            && dump ("Wrote member:%d %C:%N", tag, TREE_CODE (decl), decl);
        return false;
      }
      break;

    case VAR_DECL:
      gcc_checking_assert (!DECL_LOCAL_DECL_P (decl));
      if (DECL_VTABLE_OR_VTT_P (decl))
        {
          /* VTT or VTABLE, they are all on the vtables list.  */
          tree ctx = CP_DECL_CONTEXT (decl);
          tree vtable = CLASSTYPE_VTABLES (ctx);
          for (unsigned ix = 0; ; vtable = DECL_CHAIN (vtable), ix++)
            if (vtable == decl)
              {
                gcc_checking_assert (DECL_VIRTUAL_P (decl));
                if (streaming_p ())
                  {
                    u (tt_vtable);
                    u (ix);
                    dump (dumper::TREE)
                      && dump ("Writing vtable %N[%u]", ctx, ix);
                  }
                tree_node (ctx);
                return false;
              }
          gcc_unreachable ();
        }

      if (DECL_TINFO_P (decl))
        {
        tinfo:
          /* A typeinfo, tt_tinfo_typedef or tt_tinfo_var.  */
          bool is_var = TREE_CODE (decl) == VAR_DECL;
          tree type = TREE_TYPE (decl);
          unsigned ix = get_pseudo_tinfo_index (type);
          if (streaming_p ())
            {
              i (is_var ? tt_tinfo_var : tt_tinfo_typedef);
              u (ix);
            }

          if (is_var)
            {
              /* We also need the type it is for and mangled name, so
                 the reader doesn't need to complete the type (which
                 would break section ordering).  The type it is for is
                 stashed on the name's TREE_TYPE.  */
              tree name = DECL_NAME (decl);
              tree_node (name);
              type = TREE_TYPE (name);
              tree_node (type);
            }

          int tag = insert (decl);
          if (streaming_p ())
            dump (dumper::TREE)
              && dump ("Wrote tinfo_%s:%d %u %N", is_var ? "var" : "type",
                       tag, ix, type);

          if (!is_var)
            {
              tag = insert (type);
              if (streaming_p ())
                dump (dumper::TREE)
                  && dump ("Wrote tinfo_type:%d %u %N", tag, ix, type);
            }
          return false;
        }
      break;

    case TYPE_DECL:
      if (DECL_TINFO_P (decl))
        goto tinfo;
      break;
    }

  if (DECL_THUNK_P (decl))
    {
      /* Thunks are similar to binfos -- write the thunked-to decl and
         then thunk-specific key info.  */
      if (streaming_p ())
        {
          i (tt_thunk);
          i (THUNK_FIXED_OFFSET (decl));
        }

      tree target = decl;
      while (DECL_THUNK_P (target))
        target = THUNK_TARGET (target);
      tree_node (target);
      tree_node (THUNK_VIRTUAL_OFFSET (decl));
      int tag = insert (decl);
      if (streaming_p ())
        dump (dumper::TREE)
          && dump ("Wrote:%d thunk %N to %N", tag, DECL_NAME (decl), target);
      return false;
    }

  if (DECL_CLONED_FUNCTION_P (decl))
    {
      tree target = get_clone_target (decl);
      if (streaming_p ())
        i (tt_clone_ref);

      tree_node (target);
      tree_node (DECL_NAME (decl));
      int tag = insert (decl);
      if (streaming_p ())
        dump (dumper::TREE)
          && dump ("Wrote:%d clone %N of %N", tag, DECL_NAME (decl), target);
      return false;
    }

  /* Everything left should be a thing that is in the entity table.
     Mostly things that can be defined outside of their (original
     declaration) context.  */
  gcc_checking_assert (TREE_CODE (decl) == TEMPLATE_DECL
                       || TREE_CODE (decl) == VAR_DECL
                       || TREE_CODE (decl) == FUNCTION_DECL
                       || TREE_CODE (decl) == TYPE_DECL
                       || TREE_CODE (decl) == USING_DECL
                       || TREE_CODE (decl) == CONCEPT_DECL
                       || TREE_CODE (decl) == NAMESPACE_DECL);

  int use_tpl = -1;
  tree ti = node_template_info (decl, use_tpl);
  tree tpl = NULL_TREE;

  /* If this is the TEMPLATE_DECL_RESULT of a TEMPLATE_DECL, get the
     TEMPLATE_DECL.  Note TI_TEMPLATE is not a TEMPLATE_DECL for
     (some) friends, so we need to check that.  */
  // FIXME: Should local friend template specializations be by value?
  // They don't get idents so we'll never know they're imported, but I
  // think we can only reach them from the TU that defines the
  // befriending class?
  if (ti && TREE_CODE (TI_TEMPLATE (ti)) == TEMPLATE_DECL
      && DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti)) == decl)
    {
      tpl = TI_TEMPLATE (ti);
    partial_template:
      if (streaming_p ())
        {
          i (tt_template);
          dump (dumper::TREE)
            && dump ("Writing implicit template %C:%N%S",
                     TREE_CODE (tpl), tpl, tpl);
        }
      tree_node (tpl);

      /* Streaming TPL caused us to visit DECL and maybe its type.  */
      gcc_checking_assert (TREE_VISITED (decl));
      if (DECL_IMPLICIT_TYPEDEF_P (decl))
        gcc_checking_assert (TREE_VISITED (TREE_TYPE (decl)));
      return false;
    }

  tree ctx = CP_DECL_CONTEXT (decl);
  depset *dep = NULL;
  if (streaming_p ())
    dep = dep_hash->find_dependency (decl);
  else if (TREE_CODE (ctx) != FUNCTION_DECL
           || TREE_CODE (decl) == TEMPLATE_DECL
           || (dep_hash->sneakoscope && DECL_IMPLICIT_TYPEDEF_P (decl))
           || (DECL_LANG_SPECIFIC (decl)
               && DECL_MODULE_IMPORT_P (decl)))
    dep = dep_hash->add_dependency (decl,
                                    TREE_CODE (decl) == NAMESPACE_DECL
                                    && !DECL_NAMESPACE_ALIAS (decl)
                                    ? depset::EK_NAMESPACE : depset::EK_DECL);

  if (!dep)
    {
      /* Some internal entity of context.  Do by value.  */
      decl_value (decl, NULL);
      return false;
    }

  if (dep->get_entity_kind () == depset::EK_REDIRECT)
    {
      /* The DECL_TEMPLATE_RESULT of a partial specialization.
         Write the partial specialization's template.  */
      depset *redirect = dep->deps[0];
      gcc_checking_assert (redirect->get_entity_kind () == depset::EK_PARTIAL);
      tpl = redirect->get_entity ();
      goto partial_template;
    }

  if (streaming_p ())
    {
      /* Locate the entity.  */
      unsigned index = dep->cluster;
      unsigned import = 0;

      if (dep->is_import ())
        import = dep->section;
      else if (CHECKING_P)
        /* It should be what we put there.  */
        gcc_checking_assert (index == ~import_entity_index (decl));

#if CHECKING_P
      if (importedness)
        gcc_assert (!import == (importedness < 0));
#endif
      i (tt_entity);
      u (import);
      u (index);
    }

  int tag = insert (decl);
  if (streaming_p () && dump (dumper::TREE))
    {
      char const *kind = "import";
      module_state *from = (*modules)[0];
      if (dep->is_import ())
        /* Rediscover the unremapped index.  */
        from = import_entity_module (import_entity_index (decl));
      else
        {
          tree o = get_originating_module_decl (decl);
          kind = (DECL_LANG_SPECIFIC (o) && DECL_MODULE_PURVIEW_P (o)
                  ? "purview" : "GMF");
        }
      dump ("Wrote %s:%d %C:%N@%M", kind,
            tag, TREE_CODE (decl), decl, from);
    }

  add_indirects (decl);

  return false;
}

void
trees_out::type_node (tree type)
{
  gcc_assert (TYPE_P (type));

  tree root = (TYPE_NAME (type)
               ? TREE_TYPE (TYPE_NAME (type)) : TYPE_MAIN_VARIANT (type));

  if (type != root)
    {
      if (streaming_p ())
        i (tt_variant_type);
      tree_node (root);

      int flags = -1;

      if (TREE_CODE (type) == FUNCTION_TYPE
          || TREE_CODE (type) == METHOD_TYPE)
        {
          int quals = type_memfn_quals (type);
          int rquals = type_memfn_rqual (type);
          tree raises = TYPE_RAISES_EXCEPTIONS (type);
          bool late = TYPE_HAS_LATE_RETURN_TYPE (type);

          if (raises != TYPE_RAISES_EXCEPTIONS (root)
              || rquals != type_memfn_rqual (root)
              || quals != type_memfn_quals (root)
              || late != TYPE_HAS_LATE_RETURN_TYPE (root))
            flags = rquals | (int (late) << 2) | (quals << 3);
        }
      else
        {
          if (TYPE_USER_ALIGN (type))
            flags = exact_log2 (TYPE_ALIGN (type));
        }

      if (streaming_p ())
        i (flags);

      if (flags < 0)
        ;
      else if (TREE_CODE (type) == FUNCTION_TYPE
               || TREE_CODE (type) == METHOD_TYPE)
        {
          tree raises = TYPE_RAISES_EXCEPTIONS (type);
          if (raises == TYPE_RAISES_EXCEPTIONS (root))
            raises = error_mark_node;
          tree_node (raises);
        }

      tree_node (TYPE_ATTRIBUTES (type));

      if (streaming_p ())
        {
          /* Qualifiers.  */
          int rquals = cp_type_quals (root);
          int quals = cp_type_quals (type);
          if (quals == rquals)
            quals = -1;
          i (quals);
        }

      if (ref_node (type) != WK_none)
        {
          int tag = insert (type);
          if (streaming_p ())
            {
              i (0);
              dump (dumper::TREE)
                && dump ("Wrote:%d variant type %C", tag, TREE_CODE (type));
            }
        }
      return;
    }

  if (tree name = TYPE_NAME (type))
    if ((TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
        || DECL_TEMPLATE_PARM_P (name)
        || TREE_CODE (type) == RECORD_TYPE
        || TREE_CODE (type) == UNION_TYPE
        || TREE_CODE (type) == ENUMERAL_TYPE)
      {
        /* We can meet template parms that we didn't meet in the
           tpl_parms walk, because we're referring to a derived type
           that was previously constructed from equivalent template
           parms. */
        if (streaming_p ())
          {
            i (tt_typedef_type);
            dump (dumper::TREE)
              && dump ("Writing %stypedef %C:%N",
                       DECL_IMPLICIT_TYPEDEF_P (name) ? "implicit " : "",
                       TREE_CODE (name), name);
          }
        tree_node (name);
        if (streaming_p ())
          dump (dumper::TREE) && dump ("Wrote typedef %C:%N%S",
                                       TREE_CODE (name), name, name);
        gcc_checking_assert (TREE_VISITED (type));
        return;
      }

  if (TYPE_PTRMEMFUNC_P (type))
    {
      /* This is a distinct type node, masquerading as a structure. */
      tree fn_type = TYPE_PTRMEMFUNC_FN_TYPE (type);
      if (streaming_p ())
        i (tt_ptrmem_type);
      tree_node (fn_type);
      int tag = insert (type);
      if (streaming_p ())
        dump (dumper::TREE) && dump ("Written:%d ptrmem type", tag);
      return;
    }

  if (streaming_p ())
    {
      u (tt_derived_type);
      u (TREE_CODE (type));
    }

  tree_node (TREE_TYPE (type));
  switch (TREE_CODE (type))
    {
    default:
      /* We should never meet a type here that is indescribable in
         terms of other types.  */
      gcc_unreachable ();

    case ARRAY_TYPE:
      tree_node (TYPE_DOMAIN (type));
      if (streaming_p ())
        /* Dependent arrays are constructed with TYPE_DEPENENT_P
           already set.  */
        u (TYPE_DEPENDENT_P (type));
      break;

    case COMPLEX_TYPE:
      /* No additional data.  */
      break;

    case BOOLEAN_TYPE:
      /* A non-standard boolean type.  */
      if (streaming_p ())
        u (TYPE_PRECISION (type));
      break;

    case INTEGER_TYPE:
      if (TREE_TYPE (type))
        {
          /* A range type (representing an array domain).  */
          tree_node (TYPE_MIN_VALUE (type));
          tree_node (TYPE_MAX_VALUE (type));
        }
      else
        {
          /* A new integral type (representing a bitfield).  */
          if (streaming_p ())
            {
              unsigned prec = TYPE_PRECISION (type);
              bool unsigned_p = TYPE_UNSIGNED (type);

              u ((prec << 1) | unsigned_p);
            }
        }
      break;

    case METHOD_TYPE:
    case FUNCTION_TYPE:
      {
        gcc_checking_assert (type_memfn_rqual (type) == REF_QUAL_NONE);

        tree arg_types = TYPE_ARG_TYPES (type);
        if (TREE_CODE (type) == METHOD_TYPE)
          {
            tree_node (TREE_TYPE (TREE_VALUE (arg_types)));
            arg_types = TREE_CHAIN (arg_types);
          }
        tree_node (arg_types);
      }
      break;

    case OFFSET_TYPE:
      tree_node (TYPE_OFFSET_BASETYPE (type));
      break;

    case POINTER_TYPE:
      /* No additional data.  */
      break;

    case REFERENCE_TYPE:
      if (streaming_p ())
        u (TYPE_REF_IS_RVALUE (type));
      break;

    case DECLTYPE_TYPE:
    case TYPEOF_TYPE:
    case UNDERLYING_TYPE:
      tree_node (TYPE_VALUES_RAW (type));
      if (TREE_CODE (type) == DECLTYPE_TYPE)
        /* We stash a whole bunch of things into decltype's
           flags.  */
        if (streaming_p ())
          tree_node_bools (type);
      break;

    case TYPE_ARGUMENT_PACK:
      /* No additional data.  */
      break;

    case TYPE_PACK_EXPANSION:
      if (streaming_p ())
        u (PACK_EXPANSION_LOCAL_P (type));
      tree_node (PACK_EXPANSION_PARAMETER_PACKS (type));
      break;

    case TYPENAME_TYPE:
      {
        tree_node (TYPE_CONTEXT (type));
        tree_node (DECL_NAME (TYPE_NAME (type)));
        tree_node (TYPENAME_TYPE_FULLNAME (type));
        if (streaming_p ())
          {
            enum tag_types tag_type = none_type;
            if (TYPENAME_IS_ENUM_P (type))
              tag_type = enum_type;
            else if (TYPENAME_IS_CLASS_P (type))
              tag_type = class_type;
            u (int (tag_type));
          }
        }
      break;

    case UNBOUND_CLASS_TEMPLATE:
      {
        tree decl = TYPE_NAME (type);
        tree_node (DECL_CONTEXT (decl));
        tree_node (DECL_NAME (decl));
        tree_node (DECL_TEMPLATE_PARMS (decl));
      }
      break;

    case VECTOR_TYPE:
      if (streaming_p ())
        {
          poly_uint64 nunits = TYPE_VECTOR_SUBPARTS (type);
          /* to_constant asserts that only coeff[0] is of interest.  */
          wu (static_cast<unsigned HOST_WIDE_INT> (nunits.to_constant ()));
        }
      break;
    }

  /* We may have met the type during emitting the above.  */
  if (ref_node (type) != WK_none)
    {
      int tag = insert (type);
      if (streaming_p ())
        {
          i (0);
          dump (dumper::TREE)
            && dump ("Wrote:%d derived type %C", tag, TREE_CODE (type));
        }
    }

  return;
}

/* T is (mostly*) a non-mergeable node that must be written by value.
   The mergeable case is a BINFO, which are as-if DECLSs.   */

void
trees_out::tree_value (tree t)
{
  /* We should never be writing a type by value.  tree_type should
     have streamed it, or we're going via its TYPE_DECL.  */
  gcc_checking_assert (!TYPE_P (t));

  if (DECL_P (t))
    /* No template, type, var or function, except anonymous
       non-context vars.  */
    gcc_checking_assert ((TREE_CODE (t) != TEMPLATE_DECL
                          && TREE_CODE (t) != TYPE_DECL
                          && (TREE_CODE (t) != VAR_DECL
                              || (!DECL_NAME (t) && !DECL_CONTEXT (t)))
                          && TREE_CODE (t) != FUNCTION_DECL));

  if (streaming_p ())
    {
      /* A new node -> tt_node.  */
      tree_val_count++;
      i (tt_node);
      start (t);
      tree_node_bools (t);
    }

  if  (TREE_CODE (t) == TREE_BINFO)
    /* Binfos are decl-like and need merging information.  */
    binfo_mergeable (t);

  int tag = insert (t, WK_value);
  if (streaming_p ())
    dump (dumper::TREE)
      && dump ("Writing tree:%d %C:%N", tag, TREE_CODE (t), t);

  tree_node_vals (t);

  if (streaming_p ())
    dump (dumper::TREE) && dump ("Written tree:%d %C:%N", tag, TREE_CODE (t), t);
}

tree
trees_in::tree_value ()
{
  tree t = start ();
  if (!t || !tree_node_bools (t))
    return NULL_TREE;

  tree existing = t;
  if (TREE_CODE (t) == TREE_BINFO)
    {
      tree type;
      unsigned ix = binfo_mergeable (&type);
      if (TYPE_BINFO (type))
        {
          /* We already have a definition, this must be a duplicate.  */
          dump (dumper::MERGE)
            && dump ("Deduping binfo %N[%u]", type, ix);
          existing = TYPE_BINFO (type);
          while (existing && ix)
            existing = TREE_CHAIN (existing);
          if (existing)
            register_duplicate (t, existing);
          else
            /* Error, mismatch -- diagnose in read_class_def's
               checking.  */
            existing = t;
        }
    }

  /* Insert into map.  */
  int tag = insert (existing);
  dump (dumper::TREE)
    && dump ("Reading tree:%d %C", tag, TREE_CODE (t));

  if (!tree_node_vals (t))
    {
      back_refs[~tag] = NULL_TREE;
      set_overrun ();
      /* Bail.  */
      return NULL_TREE;
    }

  dump (dumper::TREE) && dump ("Read tree:%d %C:%N", tag, TREE_CODE (t), t);

  if (TREE_CODE (existing) == INTEGER_CST && !TREE_OVERFLOW (existing))
    {
      existing = cache_integer_cst (t, true);
      back_refs[~tag] = existing;
    }

  return existing;
}

/* Stream out tree node T.  We automatically create local back
   references, which is essentially a single pass lisp
   self-referential structure pretty-printer.  */

void
trees_out::tree_node (tree t)
{
  dump.indent ();
  walk_kind ref = ref_node (t);
  if (ref == WK_none)
    goto done;

  if (ref != WK_normal)
    goto skip_normal;

  if (TREE_CODE (t) == IDENTIFIER_NODE)
    {
      /* An identifier node -> tt_id, tt_conv_id, tt_anon_id, tt_lambda_id.  */
      int code = tt_id;
      if (IDENTIFIER_ANON_P (t))
        code = IDENTIFIER_LAMBDA_P (t) ? tt_lambda_id : tt_anon_id;
      else if (IDENTIFIER_CONV_OP_P (t))
        code = tt_conv_id;

      if (streaming_p ())
        i (code);

      if (code == tt_conv_id)
        {
          tree type = TREE_TYPE (t);
          gcc_checking_assert (type || t == conv_op_identifier);
          tree_node (type);
        }
      else if (code == tt_id && streaming_p ())
        str (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));

      int tag = insert (t);
      if (streaming_p ())
        {
          /* We know the ordering of the 4 id tags.  */
          static const char *const kinds[] = 
            {"", "conv_op ", "anon ", "lambda "};
          dump (dumper::TREE)
            && dump ("Written:%d %sidentifier:%N", tag,
                     kinds[code - tt_id],
                     code == tt_conv_id ? TREE_TYPE (t) : t);
        }
      goto done;
    }

  if (TREE_CODE (t) == TREE_BINFO)
    {
      /* A BINFO -> tt_binfo.
         We must do this by reference.  We stream the binfo tree
         itself when streaming its owning RECORD_TYPE.  That we got
         here means the dominating type is not in this SCC.  */
      if (streaming_p ())
        i (tt_binfo);
      binfo_mergeable (t);
      gcc_checking_assert (!TREE_VISITED (t));
      int tag = insert (t);
      if (streaming_p ())
        dump (dumper::TREE) && dump ("Inserting binfo:%d %N", tag, t);
      goto done;
    }

  if (TREE_CODE (t) == INTEGER_CST
      && !TREE_OVERFLOW (t)
      && TREE_CODE (TREE_TYPE (t)) == ENUMERAL_TYPE)
    {
      /* An integral constant of enumeral type.  See if it matches one
         of the enumeration values.  */
      for (tree values = TYPE_VALUES (TREE_TYPE (t));
           values; values = TREE_CHAIN (values))
        {
          tree decl = TREE_VALUE (values);
          if (tree_int_cst_equal (DECL_INITIAL (decl), t))
            {
              if (streaming_p ())
                u (tt_enum_value);
              tree_node (decl);
              dump (dumper::TREE) && dump ("Written enum value %N", decl);
              goto done;
            }
        }
      /* It didn't match.  We'll write it a an explicit INTEGER_CST
         node.  */
    }

  if (TYPE_P (t))
    {
      type_node (t);
      goto done;
    }

  if (DECL_P (t))
    {
      if (DECL_TEMPLATE_PARM_P (t))
        {
          tpl_parm_value (t);
          goto done;
        }

      if (!DECL_CONTEXT (t))
        {
          /* There are a few cases of decls with no context.  We'll write
             these by value, but first assert they are cases we expect.  */
          gcc_checking_assert (ref == WK_normal);
          switch (TREE_CODE (t))
            {
            default: gcc_unreachable ();

            case LABEL_DECL:
              /* CASE_LABEL_EXPRs contain uncontexted LABEL_DECLs.  */
              gcc_checking_assert (!DECL_NAME (t));
              break;

            case VAR_DECL:
              /* AGGR_INIT_EXPRs cons up anonymous uncontexted VAR_DECLs.  */
              gcc_checking_assert (!DECL_NAME (t)
                                   && DECL_ARTIFICIAL (t));
              break;

            case PARM_DECL:
              /* REQUIRES_EXPRs have a tree list of uncontexted
                 PARM_DECLS.  It'd be nice if they had a
                 distinguishing flag to double check.  */
              break;
            }
          goto by_value;
        }
    }

 skip_normal:
  if (DECL_P (t) && !decl_node (t, ref))
    goto done;

  /* Otherwise by value */
 by_value:
  tree_value (t);

 done:
  /* And, breath out.  */
  dump.outdent ();
}

/* Stream in a tree node.  */

tree
trees_in::tree_node (bool is_use)
{
  if (get_overrun ())
    return NULL_TREE;

  dump.indent ();
  int tag = i ();
  tree res = NULL_TREE;
  switch (tag)
    {
    default:
      /* backref, pull it out of the map.  */
      res = back_ref (tag);
      break;

    case tt_null:
      /* NULL_TREE.  */
      break;

    case tt_fixed:
      /* A fixed ref, find it in the fixed_ref array.   */
      {
        unsigned fix = u ();
        if (fix < (*fixed_trees).length ())
          {
            res = (*fixed_trees)[fix];
            dump (dumper::TREE) && dump ("Read fixed:%u %C:%N%S", fix,
                                         TREE_CODE (res), res, res);
          }

        if (!res)
          set_overrun ();
      }
      break;

    case tt_parm:
      {
        tree fn = tree_node ();
        if (fn && TREE_CODE (fn) == FUNCTION_DECL)
          res = tree_node ();
        if (res)
          dump (dumper::TREE)
            && dump ("Read %s reference %N",
                     TREE_CODE (res) == PARM_DECL ? "parameter" : "result",
                     res);
      }
      break;

    case tt_node:
      /* A new node.  Stream it in.  */
      res = tree_value ();
      break;

    case tt_decl:
      /* A new decl.  Stream it in.  */
      res = decl_value ();
      break;

    case tt_tpl_parm:
      /* A template parameter.  Stream it in.  */
      res = tpl_parm_value ();
      break;

    case tt_id:
      /* An identifier node.  */
      {
        size_t l;
        const char *chars = str (&l);
        res = get_identifier_with_length (chars, l);
        int tag = insert (res);
        dump (dumper::TREE)
          && dump ("Read identifier:%d %N", tag, res);
      }
      break;

    case tt_conv_id:
      /* A conversion operator.  Get the type and recreate the
         identifier.  */
      {
        tree type = tree_node ();
        if (!get_overrun ())
          {
            res = type ? make_conv_op_name (type) : conv_op_identifier;
            int tag = insert (res);
            dump (dumper::TREE)
              && dump ("Created conv_op:%d %S for %N", tag, res, type);
          }
      }
      break;

    case tt_anon_id:
    case tt_lambda_id:
      /* An anonymous or lambda id.  */
      {
        res = make_anon_name ();
        if (tag == tt_lambda_id)
          IDENTIFIER_LAMBDA_P (res) = true;
        int tag = insert (res);
        dump (dumper::TREE)
          && dump ("Read %s identifier:%d %N",
                   IDENTIFIER_LAMBDA_P (res) ? "lambda" : "anon", tag, res);
      }
      break;

    case tt_typedef_type:
      res = tree_node ();
      if (res)
        {
          dump (dumper::TREE)
            && dump ("Read %stypedef %C:%N",
                     DECL_IMPLICIT_TYPEDEF_P (res) ? "implicit " : "",
                     TREE_CODE (res), res);
          res = TREE_TYPE (res);
        }
      break;

    case tt_derived_type:
      /* A type derived from some other type.  */
      {
        enum tree_code code = tree_code (u ());
        res = tree_node ();

        switch (code)
          {
          default:
            set_overrun ();
            break;

          case ARRAY_TYPE:
            {
              tree domain = tree_node ();
              int dep = u ();
              if (!get_overrun ())
                res = build_cplus_array_type (res, domain, dep);
            }
            break;

          case COMPLEX_TYPE:
            if (!get_overrun ())
              res = build_complex_type (res);
            break;

          case BOOLEAN_TYPE:
            {
              unsigned precision = u ();
              if (!get_overrun ())
                res = build_nonstandard_boolean_type (precision);
            }
            break;

          case INTEGER_TYPE:
            if (res)
              {
                /* A range type (representing an array domain).  */
                tree min = tree_node ();
                tree max = tree_node ();

                if (!get_overrun ())
                  res = build_range_type (res, min, max);
              }
            else
              {
                /* A new integral type (representing a bitfield).  */
                unsigned enc = u ();
                if (!get_overrun ())
                  res = build_nonstandard_integer_type (enc >> 1, enc & 1);
              }
            break;

          case FUNCTION_TYPE:
          case METHOD_TYPE:
            {
              tree klass =  code == METHOD_TYPE ? tree_node () : NULL_TREE;
              tree args = tree_node ();
              if (!get_overrun ())
                {
                  if (klass)
                    res = build_method_type_directly (klass, res, args);
                  else
                    res = build_function_type (res, args);
                }
            }
            break;

          case OFFSET_TYPE:
            {
              tree base = tree_node ();
              if (!get_overrun ())
                res = build_offset_type (base, res);
            }
            break;

          case POINTER_TYPE:
            if (!get_overrun ())
              res = build_pointer_type (res);
            break;

          case REFERENCE_TYPE:
            {
              bool rval = bool (u ());
              if (!get_overrun ())
                res = cp_build_reference_type (res, rval);
            }
            break;

          case DECLTYPE_TYPE:
          case TYPEOF_TYPE:
          case UNDERLYING_TYPE:
            {
              tree expr = tree_node ();
              if (!get_overrun ())
                {
                  res = cxx_make_type (code);
                  TYPE_VALUES_RAW (res) = expr;
                  if (code == DECLTYPE_TYPE)
                    tree_node_bools (res);
                  SET_TYPE_STRUCTURAL_EQUALITY (res);
                }
            }
            break;

          case TYPE_ARGUMENT_PACK:
            if (!get_overrun ())
              {
                tree pack = cxx_make_type (TYPE_ARGUMENT_PACK);
                SET_ARGUMENT_PACK_ARGS (pack, res);
                res = pack;
              }
            break;

          case TYPE_PACK_EXPANSION:
            {
              bool local = u ();
              tree param_packs = tree_node ();
              if (!get_overrun ())
                {
                  tree expn = cxx_make_type (TYPE_PACK_EXPANSION);
                  SET_TYPE_STRUCTURAL_EQUALITY (expn);
                  SET_PACK_EXPANSION_PATTERN (expn, res);
                  PACK_EXPANSION_PARAMETER_PACKS (expn) = param_packs;
                  PACK_EXPANSION_LOCAL_P (expn) = local;
                  res = expn;
                }
            }
            break;

          case TYPENAME_TYPE:
            {
              tree ctx = tree_node ();
              tree name = tree_node ();
              tree fullname = tree_node ();
              enum tag_types tag_type = tag_types (u ());

              if (!get_overrun ())
                res = build_typename_type (ctx, name, fullname, tag_type);
            }
            break;

          case UNBOUND_CLASS_TEMPLATE:
            {
              tree ctx = tree_node ();
              tree name = tree_node ();
              tree parms = tree_node ();

              if (!get_overrun ())
                res = make_unbound_class_template_raw (ctx, name, parms);
            }
            break;

          case VECTOR_TYPE:
            {
              unsigned HOST_WIDE_INT nunits = wu ();
              if (!get_overrun ())
                res = build_vector_type (res, static_cast<poly_int64> (nunits));
            }
            break;
          }

        int tag = i ();
        if (!tag)
          {
            tag = insert (res);
            if (res)
              dump (dumper::TREE)
                && dump ("Created:%d derived type %C", tag, code);
          }
        else
          res = back_ref (tag);
      }
      break;

    case tt_variant_type:
      /* Variant of some type.  */
      {
        res = tree_node ();
        int flags = i ();
        if (get_overrun ())
          ;
        else if (flags < 0)
          /* No change.  */;
        else if (TREE_CODE (res) == FUNCTION_TYPE
                 || TREE_CODE (res) == METHOD_TYPE)
          {
            cp_ref_qualifier rqual = cp_ref_qualifier (flags & 3);
            bool late = (flags >> 2) & 1;
            cp_cv_quals quals = cp_cv_quals (flags >> 3);

            tree raises = tree_node ();
            if (raises == error_mark_node)
              raises = TYPE_RAISES_EXCEPTIONS (res);

            res = build_cp_fntype_variant (res, rqual, raises, late);
            if (TREE_CODE (res) == FUNCTION_TYPE)
              res = apply_memfn_quals (res, quals, rqual);
          }
        else
          {
            res = build_aligned_type (res, 1u << flags);
            TYPE_USER_ALIGN (res) = true;
          }

        if (tree attribs = tree_node ())
          res = cp_build_type_attribute_variant (res, attribs);

        int quals = i ();
        if (quals >= 0 && !get_overrun ())
          res = cp_build_qualified_type (res, quals);

        int tag = i ();
        if (!tag)
          {
            tag = insert (res);
            if (res)
              dump (dumper::TREE)
                && dump ("Created:%d variant type %C", tag, TREE_CODE (res));
          }
        else
          res = back_ref (tag);
      }
      break;

    case tt_tinfo_var:
    case tt_tinfo_typedef:
      /* A tinfo var or typedef.  */
      {
        bool is_var = tag == tt_tinfo_var;
        unsigned ix = u ();
        tree type = NULL_TREE;

        if (is_var)
          {
            tree name = tree_node ();
            type = tree_node ();

            if (!get_overrun ())
              res = get_tinfo_decl_direct (type, name, int (ix));
          }
        else
          {
            if (!get_overrun ())
              {
                type = get_pseudo_tinfo_type (ix);
                res = TYPE_NAME (type);
              }
          }
        if (res)
          {
            int tag = insert (res);
            dump (dumper::TREE)
              && dump ("Created tinfo_%s:%d %S:%u for %N",
                       is_var ? "var" : "decl", tag, res, ix, type);
            if (!is_var)
              {
                tag = insert (type);
                dump (dumper::TREE)
                  && dump ("Created tinfo_type:%d %u %N", tag, ix, type);
              }
          }
      }
      break;

    case tt_ptrmem_type:
      /* A pointer to member function.  */
      {
        tree type = tree_node ();
        if (type && TREE_CODE (type) == POINTER_TYPE
            && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
          {
            res = build_ptrmemfunc_type (type);
            int tag = insert (res);
            dump (dumper::TREE) && dump ("Created:%d ptrmem type", tag);
          }
        else
          set_overrun ();
      }
      break;

    case tt_enum_value:
      /* An enum const value.  */
      {
        if (tree decl = tree_node ())
          {
            dump (dumper::TREE) && dump ("Read enum value %N", decl);
            res = DECL_INITIAL (decl);
          }

        if (!res)
          set_overrun ();
      }
      break;

    case tt_enum_decl:
      /* An enum decl.  */
      {
        tree ctx = tree_node ();
        tree name = tree_node ();

        if (!get_overrun ()
            && TREE_CODE (ctx) == ENUMERAL_TYPE)
          res = find_enum_member (ctx, name);

        if (!res)
          set_overrun ();
        else
          {
            int tag = insert (res);
            dump (dumper::TREE)
              && dump ("Read enum decl:%d %C:%N", tag, TREE_CODE (res), res);
          }
      }
      break;

    case tt_data_member:
      /* A data member.  */
      {
        tree ctx = tree_node ();
        tree name = tree_node ();

        if (!get_overrun ()
            && RECORD_OR_UNION_TYPE_P (ctx))
          {
            if (name)
              res = lookup_class_binding (ctx, name);
            else
              res = lookup_field_ident (ctx, u ());

            if (!res
                || TREE_CODE (res) != FIELD_DECL
                || DECL_CONTEXT (res) != ctx)
              res = NULL_TREE;
          }

        if (!res)
          set_overrun ();
        else
          {
            int tag = insert (res);
            dump (dumper::TREE)
              && dump ("Read member:%d %C:%N", tag, TREE_CODE (res), res);
          }
      }
      break;

    case tt_binfo:
      /* A BINFO.  Walk the tree of the dominating type.  */
      {
        tree type;
        unsigned ix = binfo_mergeable (&type);
        if (type)
          {
            res = TYPE_BINFO (type);
            for (; ix && res; res = TREE_CHAIN (res))
              ix--;
            if (!res)
              set_overrun ();
          }

        if (get_overrun ())
          break;

        /* Insert binfo into backreferences.  */
        tag = insert (res);
        dump (dumper::TREE) && dump ("Read binfo:%d %N", tag, res);
      }
      break;

    case tt_vtable:
      {
        unsigned ix = u ();
        tree ctx = tree_node ();
        dump (dumper::TREE) && dump ("Reading vtable %N[%u]", ctx, ix);
        if (TREE_CODE (ctx) == RECORD_TYPE && TYPE_LANG_SPECIFIC (ctx))
          for (res = CLASSTYPE_VTABLES (ctx); res; res = DECL_CHAIN (res))
            if (!ix--)
              break;
        if (!res)
          set_overrun ();
      }
      break;

    case tt_thunk:
      {
        int fixed = i ();
        tree target = tree_node ();
        tree virt = tree_node ();

        for (tree thunk = DECL_THUNKS (target);
             thunk; thunk = DECL_CHAIN (thunk))
          if (THUNK_FIXED_OFFSET (thunk) == fixed
              && !THUNK_VIRTUAL_OFFSET (thunk) == !virt
              && (!virt
                  || tree_int_cst_equal (virt, THUNK_VIRTUAL_OFFSET (thunk))))
            {
              res = thunk;
              break;
            }

        int tag = insert (res);
        if (res)
          dump (dumper::TREE)
            && dump ("Read:%d thunk %N to %N", tag, DECL_NAME (res), target);
        else
          set_overrun ();
      }
      break;

    case tt_clone_ref:
      {
        tree target = tree_node ();
        tree name = tree_node ();

        if (DECL_P (target) && DECL_MAYBE_IN_CHARGE_CDTOR_P (target))
          {
            tree clone;
            FOR_EVERY_CLONE (clone, target)
              if (DECL_NAME (clone) == name)
                {
                  res = clone;
                  break;
                }
          }

        if (!res)
          set_overrun ();
        int tag = insert (res);
        if (res)
          dump (dumper::TREE)
            && dump ("Read:%d clone %N of %N", tag, DECL_NAME (res), target);
        else
          set_overrun ();
       }
      break;

    case tt_entity:
      /* Index into the entity table.  Perhaps not loaded yet!  */
      {
        unsigned origin = state->slurp->remap_module (u ());
        unsigned ident = u ();
        module_state *from = (*modules)[origin];

        if (!origin || ident >= from->entity_num)
          set_overrun ();
        if (!get_overrun ())
          {
            binding_slot *slot = &(*entity_ary)[from->entity_lwm + ident];
            if (slot->is_lazy ())
              if (!from->lazy_load (ident, slot))
                set_overrun ();
            res = *slot;
          }

        if (res)
          {
            const char *kind = (origin != state->mod ? "Imported" : "Named");
            int tag = insert (res);
            dump (dumper::TREE)
              && dump ("%s:%d %C:%N@%M", kind, tag, TREE_CODE (res),
                       res, (*modules)[origin]);

            if (!add_indirects (res))
              {
                set_overrun ();
                res = NULL_TREE;
              }
          }
      }
      break;

    case tt_template:
      /* A template.  */
      if (tree tpl = tree_node ())
        {
          res = DECL_TEMPLATE_RESULT (tpl);
          dump (dumper::TREE)
            && dump ("Read template %C:%N", TREE_CODE (res), res);
        }
      break;
    }

  if (is_use && !unused && res && DECL_P (res) && !TREE_USED (res))
    {
      /* Mark decl used as mark_used does -- we cannot call
         mark_used in the middle of streaming, we only need a subset
         of its functionality.   */
      TREE_USED (res) = true;

      /* And for structured bindings also the underlying decl.  */
      if (DECL_DECOMPOSITION_P (res) && DECL_DECOMP_BASE (res))
        TREE_USED (DECL_DECOMP_BASE (res)) = true;

      if (DECL_CLONED_FUNCTION_P (res))
        TREE_USED (DECL_CLONED_FUNCTION (res)) = true;
    }

  dump.outdent ();
  return res;
}

void
trees_out::tpl_parms (tree parms, unsigned &tpl_levels)
{
  if (!parms)
    return;

  if (TREE_VISITED (parms))
    {
      ref_node (parms);
      return;
    }

  tpl_parms (TREE_CHAIN (parms), tpl_levels);

  tree vec = TREE_VALUE (parms);
  unsigned len = TREE_VEC_LENGTH (vec);
  /* Depth.  */
  int tag = insert (parms);
  if (streaming_p ())
    {
      i (len + 1);
      dump (dumper::TREE)
        && dump ("Writing template parms:%d level:%N length:%d",
                 tag, TREE_PURPOSE (parms), len);
    }
  tree_node (TREE_PURPOSE (parms));

  for (unsigned ix = 0; ix != len; ix++)
    {
      tree parm = TREE_VEC_ELT (vec, ix);
      tree decl = TREE_VALUE (parm);

      gcc_checking_assert (DECL_TEMPLATE_PARM_P (decl));
      if (CHECKING_P)
        switch (TREE_CODE (decl))
          {
          default: gcc_unreachable ();

          case TEMPLATE_DECL:
            gcc_assert ((TREE_CODE (TREE_TYPE (decl)) == TEMPLATE_TEMPLATE_PARM)
                        && (TREE_CODE (DECL_TEMPLATE_RESULT (decl)) == TYPE_DECL)
                        && (TYPE_NAME (TREE_TYPE (decl)) == decl));
            break;

          case TYPE_DECL:
            gcc_assert ((TREE_CODE (TREE_TYPE (decl)) == TEMPLATE_TYPE_PARM)
                        && (TYPE_NAME (TREE_TYPE (decl)) == decl));
            break;

          case PARM_DECL:
            gcc_assert ((TREE_CODE (DECL_INITIAL (decl)) == TEMPLATE_PARM_INDEX)
                        && (TREE_CODE (TEMPLATE_PARM_DECL (DECL_INITIAL (decl)))
                            == CONST_DECL)
                        && (DECL_TEMPLATE_PARM_P
                            (TEMPLATE_PARM_DECL (DECL_INITIAL (decl)))));
            break;
          }

      tree_node (decl);
      tree_node (TEMPLATE_PARM_CONSTRAINTS (parm));
    }

  tpl_levels++;
}

tree
trees_in::tpl_parms (unsigned &tpl_levels)
{
  tree parms = NULL_TREE;

  while (int len = i ())
    {
      if (len < 0)
        {
          parms = back_ref (len);
          continue;
        }

      len -= 1;
      parms = tree_cons (NULL_TREE, NULL_TREE, parms);
      int tag = insert (parms);
      TREE_PURPOSE (parms) = tree_node ();

      dump (dumper::TREE)
        && dump ("Reading template parms:%d level:%N length:%d",
                 tag, TREE_PURPOSE (parms), len);

      tree vec = make_tree_vec (len);
      for (int ix = 0; ix != len; ix++)
        {
          tree decl = tree_node ();
          if (!decl)
            return NULL_TREE;

          tree parm = build_tree_list (NULL, decl);
          TEMPLATE_PARM_CONSTRAINTS (parm) = tree_node ();

          TREE_VEC_ELT (vec, ix) = parm;
        }

      TREE_VALUE (parms) = vec;
      tpl_levels++;
    }

  return parms;
}

void
trees_out::tpl_parms_fini (tree tmpl, unsigned tpl_levels)
{
  for (tree parms = DECL_TEMPLATE_PARMS (tmpl);
       tpl_levels--; parms = TREE_CHAIN (parms))
    {
      tree vec = TREE_VALUE (parms);

      tree_node (TREE_TYPE (vec));
      tree dflt = error_mark_node;
      for (unsigned ix = TREE_VEC_LENGTH (vec); ix--;)
        {
          tree parm = TREE_VEC_ELT (vec, ix);
          if (dflt)
            {
              dflt = TREE_PURPOSE (parm);
              tree_node (dflt);
            }

          if (streaming_p ())
            {
              tree decl = TREE_VALUE (parm);
              if (TREE_CODE (decl) == TEMPLATE_DECL)
                {
                  tree ctx = DECL_CONTEXT (decl);
                  tree inner = DECL_TEMPLATE_RESULT (decl);
                  tree tpi = (TREE_CODE (inner) == TYPE_DECL
                              ? TEMPLATE_TYPE_PARM_INDEX (TREE_TYPE (decl))
                              : DECL_INITIAL (inner));
                  bool original = (TEMPLATE_PARM_LEVEL (tpi)
                                   == TEMPLATE_PARM_ORIG_LEVEL (tpi));
                  /* Original template template parms have a context
                     of their owning template.  Reduced ones do not.  */
                  gcc_checking_assert (original ? ctx == tmpl : !ctx);
                }
            }
        }
    }
}

bool
trees_in::tpl_parms_fini (tree tmpl, unsigned tpl_levels)
{
  for (tree parms = DECL_TEMPLATE_PARMS (tmpl);
       tpl_levels--; parms = TREE_CHAIN (parms))
    {
      tree vec = TREE_VALUE (parms);
      tree dflt = error_mark_node;

      TREE_TYPE (vec) = tree_node ();
      for (unsigned ix = TREE_VEC_LENGTH (vec); ix--;)
        {
          tree parm = TREE_VEC_ELT (vec, ix);
          if (dflt)
            {
              dflt = tree_node ();
              if (get_overrun ())
                return false;
              TREE_PURPOSE (parm) = dflt;
            }

          tree decl = TREE_VALUE (parm);
          if (TREE_CODE (decl) == TEMPLATE_DECL)
            {
              tree inner = DECL_TEMPLATE_RESULT (decl);
              tree tpi = (TREE_CODE (inner) == TYPE_DECL
                          ? TEMPLATE_TYPE_PARM_INDEX (TREE_TYPE (decl))
                          : DECL_INITIAL (inner));
              bool original = (TEMPLATE_PARM_LEVEL (tpi)
                               == TEMPLATE_PARM_ORIG_LEVEL (tpi));
              /* Original template template parms have a context
                 of their owning template.  Reduced ones do not.  */
              if (original)
                DECL_CONTEXT (decl) = tmpl;
            }
        }
    }
  return true;
}

/* PARMS is a LIST, one node per level.
   TREE_VALUE is a TREE_VEC of parm info for that level.
   each ELT is a TREE_LIST
   TREE_VALUE is PARM_DECL, TYPE_DECL or TEMPLATE_DECL
   TREE_PURPOSE is the default value.  */

void
trees_out::tpl_header (tree tpl, unsigned *tpl_levels)
{
  tree parms = DECL_TEMPLATE_PARMS (tpl);
  tpl_parms (parms, *tpl_levels);

  /* Mark end.  */
  if (streaming_p ())
    u (0);

  if (*tpl_levels)
    tree_node (TEMPLATE_PARMS_CONSTRAINTS (parms));
}

bool
trees_in::tpl_header (tree tpl, unsigned *tpl_levels)
{
  tree parms = tpl_parms (*tpl_levels);
  if (!parms)
    return false;

  DECL_TEMPLATE_PARMS (tpl) = parms;

  if (*tpl_levels)
    TEMPLATE_PARMS_CONSTRAINTS (parms) = tree_node ();

  return true;
}

/* Stream skeleton parm nodes, with their flags, type & parm indices.
   All the parms will have consecutive tags.  */

void
trees_out::fn_parms_init (tree fn)
{
  /* First init them.  */
  int base_tag = ref_num - 1;
  int ix = 0;
  for (tree parm = DECL_ARGUMENTS (fn);
       parm; parm = DECL_CHAIN (parm), ix++)
    {
      if (streaming_p ())
        {
          start (parm);
          tree_node_bools (parm);
        }
      int tag = insert (parm);
      gcc_checking_assert (base_tag - ix == tag);
    }
  /* Mark the end.  */
  if (streaming_p ())
    u (0);

  /* Now stream their contents.  */
  ix = 0;
  for (tree parm = DECL_ARGUMENTS (fn);
       parm; parm = DECL_CHAIN (parm), ix++)
    {
      if (streaming_p ())
        dump (dumper::TREE)
          && dump ("Writing parm:%d %u (%N) of %N",
                   base_tag - ix, ix, parm, fn);
      tree_node_vals (parm);
    }
}

/* Build skeleton parm nodes, read their flags, type & parm indices.  */

int
trees_in::fn_parms_init (tree fn)
{
  int base_tag = ~(int)back_refs.length ();

  tree *parm_ptr = &DECL_ARGUMENTS (fn);
  int ix = 0;
  for (; int code = u (); ix++)
    {
      tree parm = start (code);
      if (!tree_node_bools (parm))
        return 0;

      int tag = insert (parm);
      gcc_checking_assert (base_tag - ix == tag);
      *parm_ptr = parm;
      parm_ptr = &DECL_CHAIN (parm);
    }

  ix = 0;
  for (tree parm = DECL_ARGUMENTS (fn);
       parm; parm = DECL_CHAIN (parm), ix++)
    {
      dump (dumper::TREE)
        && dump ("Reading parm:%d %u (%N) of %N",
                 base_tag - ix, ix, parm, fn);
      if (!tree_node_vals (parm))
        return 0;
    }

  return base_tag;
}

/* Read the remaining parm node data.  Replace with existing (if
   non-null) in the map.  */

void
trees_in::fn_parms_fini (int tag, tree fn, tree existing, bool is_defn)
{
  tree existing_parm = existing ? DECL_ARGUMENTS (existing) : NULL_TREE;
  tree parms = DECL_ARGUMENTS (fn);
  unsigned ix = 0;
  for (tree parm = parms; parm; parm = DECL_CHAIN (parm), ix++)
    {
      if (existing_parm)
        {
          if (is_defn && !DECL_SAVED_TREE (existing))
            {
              /* If we're about to become the definition, set the
                 names of the parms from us.  */
              DECL_NAME (existing_parm) = DECL_NAME (parm);
              DECL_SOURCE_LOCATION (existing_parm) = DECL_SOURCE_LOCATION (parm);
            }

          back_refs[~tag] = existing_parm;
          existing_parm = DECL_CHAIN (existing_parm);
        }
      tag--;
    }
}

/* DEP is the depset of some decl we're streaming by value.  Determine
   the merging behaviour.  */

merge_kind
trees_out::get_merge_kind (tree decl, depset *dep)
{
  if (!dep)
    {
      if (VAR_OR_FUNCTION_DECL_P (decl))
        {
          /* Any var or function with template info should have DEP.  */
          gcc_checking_assert (!DECL_LANG_SPECIFIC (decl)
                               || !DECL_TEMPLATE_INFO (decl));
          if (DECL_LOCAL_DECL_P (decl))
            return MK_unique;
        }

      /* Either unique, or some member of a class that cannot have an
         out-of-class definition.  For instance a FIELD_DECL.  */
      tree ctx = CP_DECL_CONTEXT (decl);
      if (TREE_CODE (ctx) == FUNCTION_DECL)
        {
          /* USING_DECLs cannot have DECL_TEMPLATE_INFO -- this isn't
             permitting them to have one.   */
          gcc_checking_assert (TREE_CODE (decl) == USING_DECL
                               || !DECL_LANG_SPECIFIC (decl)
                               || !DECL_TEMPLATE_INFO (decl));

          return MK_unique;
        }

      if (TREE_CODE (decl) == TEMPLATE_DECL
          && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl))
        return MK_local_friend;

      gcc_checking_assert (TYPE_P (ctx));
      if (TREE_CODE (decl) == USING_DECL)
        return MK_field;

      if (TREE_CODE (decl) == FIELD_DECL)
        {
          if (DECL_NAME (decl))
            {
              /* Anonymous FIELD_DECLs have a NULL name.  */
              gcc_checking_assert (!IDENTIFIER_ANON_P (DECL_NAME (decl)));
              return MK_named;
            }

          if (!DECL_NAME (decl)
              && !RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl))
              && !DECL_BIT_FIELD_REPRESENTATIVE (decl))
            {
              /* The underlying storage unit for a bitfield.  We do not
                 need to dedup it, because it's only reachable through
                 the bitfields it represents.  And those are deduped.  */
              // FIXME: Is that assertion correct -- do we ever fish it
              // out and put it in an expr?
              gcc_checking_assert ((TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
                                    ? TREE_CODE (TREE_TYPE (TREE_TYPE (decl)))
                                    : TREE_CODE (TREE_TYPE (decl)))
                                   == INTEGER_TYPE);
              return MK_unique;
            }

          return MK_field;
        }

      if (TREE_CODE (decl) == CONST_DECL)
        return MK_named;

      if (TREE_CODE (decl) == VAR_DECL
          && DECL_VTABLE_OR_VTT_P (decl))
        return MK_vtable;

      if (DECL_THUNK_P (decl))
        /* Thunks are unique-enough, because they're only referenced
           from the vtable.  And that's either new (so we want the
           thunks), or it's a duplicate (so it will be dropped).  */
        return MK_unique;

      /* There should be no other cases.  */
      gcc_unreachable ();
    }

  gcc_checking_assert (TREE_CODE (decl) != FIELD_DECL
                       && TREE_CODE (decl) != USING_DECL
                       && TREE_CODE (decl) != CONST_DECL);

  if (is_key_order ())
    {
      /* When doing the mergeablilty graph, there's an indirection to
         the actual depset.  */
      gcc_assert (dep->is_special ());
      dep = dep->deps[0];
    }

  gcc_checking_assert (decl == dep->get_entity ());

  merge_kind mk = MK_named;
  switch (dep->get_entity_kind ())
    {
    default:
      gcc_unreachable ();

    case depset::EK_PARTIAL:
      mk = MK_partial;
      break;

    case depset::EK_DECL:
      {
        tree ctx = CP_DECL_CONTEXT (decl);

        switch (TREE_CODE (ctx))
          {
          default:
            gcc_unreachable ();

          case FUNCTION_DECL:
            // FIXME: This can occur for (a) voldemorty TYPE_DECLS
            // (which are returned from a function), or (b)
            // block-scope class definitions in template functions.
            // These are as unique as the containing function.  While
            // on read-back we can discover if the CTX was a
            // duplicate, we don't have a mechanism to get from the
            // existing CTX to the existing version of this decl.
            gcc_checking_assert
              (DECL_IMPLICIT_TYPEDEF_P (STRIP_TEMPLATE (decl)));

            mk = MK_unique;
            break;

          case RECORD_TYPE:
          case UNION_TYPE:
            if (DECL_NAME (decl) == as_base_identifier)
              mk = MK_as_base;
            else if (IDENTIFIER_ANON_P (DECL_NAME (decl)))
              mk = MK_field;
            break;

          case NAMESPACE_DECL:
            if (DECL_IMPLICIT_TYPEDEF_P (STRIP_TEMPLATE (decl))
                && LAMBDA_TYPE_P (TREE_TYPE (decl)))
              if (tree scope
                  = LAMBDA_EXPR_EXTRA_SCOPE (CLASSTYPE_LAMBDA_EXPR
                                             (TREE_TYPE (decl))))
                if (TREE_CODE (scope) == VAR_DECL
                    && DECL_MODULE_ATTACHMENTS_P (scope))
                  {
                    mk = MK_attached;
                    break;
                  }

            if (TREE_CODE (decl) == TEMPLATE_DECL
                && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl))
              mk = MK_local_friend;
            else if (IDENTIFIER_ANON_P (DECL_NAME (decl)))
              {
                if (DECL_IMPLICIT_TYPEDEF_P (decl)
                    && UNSCOPED_ENUM_P (TREE_TYPE (decl))
                    && TYPE_VALUES (TREE_TYPE (decl)))
                  /* Keyed by first enum value, and underlying type.  */
                  mk = MK_enum;
                else
                  /* No way to merge it, it is an ODR land-mine.  */
                  mk = MK_unique;
              }
          }
      }
      break;

    case depset::EK_SPECIALIZATION:
      {
        gcc_checking_assert (dep->is_special ());
        spec_entry *entry = reinterpret_cast <spec_entry *> (dep->deps[0]);

        if (TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
          /* An block-scope classes of templates are themselves
             templates.  */
          gcc_checking_assert (DECL_IMPLICIT_TYPEDEF_P (decl));

        if (dep->is_friend_spec ())
          mk = MK_friend_spec;
        else if (dep->is_type_spec ())
          mk = MK_type_spec;
        else if (dep->is_alias ())
          mk = MK_alias_spec;
        else
          mk = MK_decl_spec;

        if (TREE_CODE (decl) == TEMPLATE_DECL)
          {
            tree res = DECL_TEMPLATE_RESULT (decl);
            if (!(mk & MK_tmpl_decl_mask))
              res = TREE_TYPE (res);

            if (res == entry->spec)
              /* We check we can get back to the template during
                 streaming.  */
              mk = merge_kind (mk | MK_tmpl_tmpl_mask);
          }
      }
      break;
    }

  return mk;
}


/* The container of DECL -- not necessarily its context!  */

tree
trees_out::decl_container (tree decl)
{
  int use_tpl;
  tree tpl = NULL_TREE;
  if (tree template_info = node_template_info (decl, use_tpl))
    tpl = TI_TEMPLATE (template_info);
  if (tpl == decl)
    tpl = nullptr;

  /* Stream the template we're instantiated from.  */
  tree_node (tpl);

  tree container = NULL_TREE;
  if (TREE_CODE (decl) == TEMPLATE_DECL
      && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl))
    container = DECL_CHAIN (decl);
  else
    container = CP_DECL_CONTEXT (decl);

  if (TYPE_P (container))
    container = TYPE_NAME (container);

  tree_node (container);

  return container;
}

tree
trees_in::decl_container ()
{
  /* The maybe-template.  */
  (void)tree_node ();

  tree container = tree_node ();

  return container;
}

/* Write out key information about a mergeable DEP.  Does not write
   the contents of DEP itself.  The context has already been
   written.  The container has already been streamed.  */

void
trees_out::key_mergeable (int tag, merge_kind mk, tree decl, tree inner,
                          tree container, depset *dep)
{
  if (dep && is_key_order ())
    {
      gcc_checking_assert (dep->is_special ());
      dep = dep->deps[0];
    }

  if (streaming_p ())
    dump (dumper::MERGE)
      && dump ("Writing:%d's %s merge key (%s) %C:%N", tag, merge_kind_name[mk],
               dep ? dep->entity_kind_name () : "contained",
               TREE_CODE (decl), decl);

  /* Now write the locating information. */
  if (mk & MK_template_mask)
    {
      /* Specializations are located via their originating template,
         and the set of template args they specialize.  */
      gcc_checking_assert (dep && dep->is_special ());
      spec_entry *entry = reinterpret_cast <spec_entry *> (dep->deps[0]);

      tree_node (entry->tmpl);
      tree_node (entry->args);
      if (streaming_p ())
        u (get_mergeable_specialization_flags (entry->tmpl, decl));
      if (mk & MK_tmpl_decl_mask)
        if (flag_concepts && TREE_CODE (inner) == VAR_DECL)
          {
            /* Variable template partial specializations might need
               constraints (see spec_hasher::equal).  It's simpler to
               write NULL when we don't need them.  */
            tree constraints = NULL_TREE;

            if (uses_template_parms (entry->args))
              constraints = get_constraints (inner);
            tree_node (constraints);
          }

      if (CHECKING_P)
        {
          /* Make sure we can locate the decl.  */
          tree existing = match_mergeable_specialization
            (bool (mk & MK_tmpl_decl_mask), entry, false);

          gcc_assert (existing);
          if (mk & MK_tmpl_decl_mask)
            {
              if (mk & MK_tmpl_alias_mask)
                /* It should be in both tables.  */
                gcc_assert (match_mergeable_specialization (false, entry, false)
                            == TREE_TYPE (existing));
              else if (mk & MK_tmpl_tmpl_mask)
                if (tree ti = DECL_TEMPLATE_INFO (existing))
                  existing = TI_TEMPLATE (ti);
            }
          else
            {
              if (!(mk & MK_tmpl_tmpl_mask))
                existing = TYPE_NAME (existing);
              else if (tree ti = CLASSTYPE_TEMPLATE_INFO (existing))
                existing = TI_TEMPLATE (ti);
            }

          /* The walkabout should have found ourselves.  */
          gcc_assert (existing == decl);
        }
    }
  else if (mk != MK_unique)
    {
      merge_key key;
      tree name = DECL_NAME (decl);

      switch (mk)
        {
        default:
          gcc_unreachable ();

        case MK_named:
        case MK_friend_spec:
          if (IDENTIFIER_CONV_OP_P (name))
            name = conv_op_identifier;

          if (inner && TREE_CODE (inner) == FUNCTION_DECL)
            {
              /* Functions are distinguished by parameter types.  */
              tree fn_type = TREE_TYPE (inner);

              key.ref_q = type_memfn_rqual (fn_type);
              key.args = TYPE_ARG_TYPES (fn_type);

              if (tree reqs = get_constraints (inner))
                {
                  if (cxx_dialect < cxx20)
                    reqs = CI_ASSOCIATED_CONSTRAINTS (reqs);
                  else
                    reqs = CI_DECLARATOR_REQS (reqs);
                  key.constraints = reqs;
                }

              if (IDENTIFIER_CONV_OP_P (name)
                  || (decl != inner
                      && !(name == fun_identifier
                           /* In case the user names something _FUN  */
                           && LAMBDA_TYPE_P (DECL_CONTEXT (inner)))))
                /* And a function template, or conversion operator needs
                   the return type.  Except for the _FUN thunk of a
                   generic lambda, which has a recursive decl_type'd
                   return type.  */
                // FIXME: What if the return type is a voldemort?
                key.ret = fndecl_declared_return_type (inner);
            }

          if (mk == MK_friend_spec)
            {
              gcc_checking_assert (dep && dep->is_special ());
              spec_entry *entry = reinterpret_cast <spec_entry *> (dep->deps[0]);

              tree_node (entry->tmpl);
              tree_node (entry->args);
              if (streaming_p ())
                u (get_mergeable_specialization_flags (entry->tmpl, decl));
            }
          break;

        case MK_field:
          {
            unsigned ix = 0;
            if (TREE_CODE (inner) != FIELD_DECL)
              name = NULL_TREE;
            else
              gcc_checking_assert (!name || !IDENTIFIER_ANON_P (name));

            for (tree field = TYPE_FIELDS (TREE_TYPE (container));
                 ; field = DECL_CHAIN (field))
              {
                tree finner = STRIP_TEMPLATE (field);
                if (TREE_CODE (finner) == TREE_CODE (inner))
                  {
                    if (finner == inner)
                      break;
                    ix++;
                  }
              }
            key.index = ix;
          }
          break;

        case MK_vtable:
          {
            tree vtable = CLASSTYPE_VTABLES (TREE_TYPE (container));
            for (unsigned ix = 0; ; vtable = DECL_CHAIN (vtable), ix++)
              if (vtable == decl)
                {
                  key.index = ix;
                  break;
                }
            name = NULL_TREE;
          }
          break;

        case MK_as_base:
          gcc_checking_assert
            (decl == TYPE_NAME (CLASSTYPE_AS_BASE (TREE_TYPE (container))));
          break;

        case MK_local_friend:
          {
            /* Find by index on the class's DECL_LIST  */
            unsigned ix = 0;
            for (tree decls = CLASSTYPE_DECL_LIST (TREE_CHAIN (decl));
                 decls; decls = TREE_CHAIN (decls))
              if (!TREE_PURPOSE (decls))
                {
                  tree frnd = friend_from_decl_list (TREE_VALUE (decls));
                  if (frnd == decl)
                    break;
                  ix++;
                }
            key.index = ix;
            name = NULL_TREE;
          }
          break;

        case MK_enum:
          {
            /* Anonymous enums are located by their first identifier,
               and underlying type.  */
            tree type = TREE_TYPE (decl);

            gcc_checking_assert (UNSCOPED_ENUM_P (type));
            /* Using the type name drops the bit precision we might
               have been using on the enum.  */
            key.ret = TYPE_NAME (ENUM_UNDERLYING_TYPE (type));
            if (tree values = TYPE_VALUES (type))
              name = DECL_NAME (TREE_VALUE (values));
          }
          break;

        case MK_attached:
          {
            gcc_checking_assert (LAMBDA_TYPE_P (TREE_TYPE (inner)));
            tree scope = LAMBDA_EXPR_EXTRA_SCOPE (CLASSTYPE_LAMBDA_EXPR
                                                  (TREE_TYPE (inner)));
            gcc_checking_assert (TREE_CODE (scope) == VAR_DECL);
            attachset *root = attached_table->get (DECL_UID (scope));
            unsigned ix = root->num;
            /* If we don't find it, we'll write a really big number
               that the reader will ignore.  */
            while (ix--)
              if (root->values[ix] == inner)
                break;

            /* Use the attached-to decl as the 'name'.  */
            name = scope;
            key.index = ix;
          }
          break;

        case MK_partial:
          {
            key.constraints = get_constraints (inner);
            key.ret = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (inner));
            key.args = CLASSTYPE_TI_ARGS (TREE_TYPE (inner));
          }
          break;
        }

      tree_node (name);
      if (streaming_p ())
        {
          unsigned code = (key.ref_q << 0) | (key.index << 2);
          u (code);
        }

      if (mk == MK_enum)
        tree_node (key.ret);
      else if (mk == MK_partial
               || (mk == MK_named && inner
                   && TREE_CODE (inner) == FUNCTION_DECL))
        {
          tree_node (key.ret);
          tree arg = key.args;
          if (mk == MK_named)
            while (arg && arg != void_list_node)
              {
                tree_node (TREE_VALUE (arg));
                arg = TREE_CHAIN (arg);
              }
          tree_node (arg);
          tree_node (key.constraints);
        }
    }
}

/* DECL is a new declaration that may be duplicated in OVL.  Use RET &
   ARGS to find its clone, or NULL.  If DECL's DECL_NAME is NULL, this
   has been found by a proxy.  It will be an enum type located by it's
   first member.

   We're conservative with matches, so ambiguous decls will be
   registered as different, then lead to a lookup error if the two
   modules are both visible.  Perhaps we want to do something similar
   to duplicate decls to get ODR errors on loading?  We already have
   some special casing for namespaces.  */

static tree
check_mergeable_decl (merge_kind mk, tree decl, tree ovl, merge_key const &key)
{
  tree found = NULL_TREE;
  for (ovl_iterator iter (ovl); !found && iter; ++iter)
    {
      tree match = *iter;

      tree d_inner = decl;
      tree m_inner = match;

    again:
      if (TREE_CODE (d_inner) != TREE_CODE (m_inner))
        {
          if (TREE_CODE (match) == NAMESPACE_DECL
              && !DECL_NAMESPACE_ALIAS (match))
            /* Namespaces are never overloaded.  */
            found = match;

          continue;
        }

      switch (TREE_CODE (d_inner))
        {
        case TEMPLATE_DECL:
          if (template_heads_equivalent_p (d_inner, m_inner))
            {
              d_inner = DECL_TEMPLATE_RESULT (d_inner);
              m_inner = DECL_TEMPLATE_RESULT (m_inner);
              if (d_inner == error_mark_node
                  && TYPE_DECL_ALIAS_P (m_inner))
                {
                  found = match;
                  break;
                }
              goto again;
            }
          break;

        case FUNCTION_DECL:
          map_context_from = d_inner;
          map_context_to = m_inner;
          if (tree m_type = TREE_TYPE (m_inner))
            if ((!key.ret
                 || same_type_p (key.ret, fndecl_declared_return_type (m_inner)))
                && type_memfn_rqual (m_type) == key.ref_q
                && compparms (key.args, TYPE_ARG_TYPES (m_type))
                /* Reject if old is a "C" builtin and new is not "C".
                   Matches decls_match behaviour.  */
                && (!DECL_IS_UNDECLARED_BUILTIN (m_inner)
                    || !DECL_EXTERN_C_P (m_inner)
                    || DECL_EXTERN_C_P (d_inner)))
              {
                tree m_reqs = get_constraints (m_inner);
                if (m_reqs)
                  {
                    if (cxx_dialect < cxx20)
                      m_reqs = CI_ASSOCIATED_CONSTRAINTS (m_reqs);
                    else
                      m_reqs = CI_DECLARATOR_REQS (m_reqs);
                  }

                if (cp_tree_equal (key.constraints, m_reqs))
                  found = match;
              }
          map_context_from = map_context_to = NULL_TREE;
          break;

        case TYPE_DECL:
          if (DECL_IMPLICIT_TYPEDEF_P (d_inner)
              == DECL_IMPLICIT_TYPEDEF_P (m_inner))
            {
              if (!IDENTIFIER_ANON_P (DECL_NAME (m_inner)))
                return match;
              else if (mk == MK_enum
                       && (TYPE_NAME (ENUM_UNDERLYING_TYPE (TREE_TYPE (m_inner)))
                           == key.ret))
                found = match;
            }
          break;

        default:
          found = match;
          break;
        }
    }

  return found;
}

/* DECL, INNER & TYPE are a skeleton set of nodes for a decl.  Only
   the bools have been filled in.  Read its merging key and merge it.
   Returns the existing decl if there is one.  */

tree
trees_in::key_mergeable (int tag, merge_kind mk, tree decl, tree inner,
                         tree type, tree container, bool is_mod)
{
  const char *kind = "new";
  tree existing = NULL_TREE;

  if (mk & MK_template_mask)
    {
      spec_entry spec;
      spec.tmpl = tree_node ();
      spec.args = tree_node ();
      unsigned flags = u ();

      DECL_NAME (decl) = DECL_NAME (spec.tmpl);
      DECL_CONTEXT (decl) = DECL_CONTEXT (spec.tmpl);
      DECL_NAME (inner) = DECL_NAME (decl);
      DECL_CONTEXT (inner) = DECL_CONTEXT (decl);

      spec.spec = decl;
      if (mk & MK_tmpl_tmpl_mask)
        {
          if (inner == decl)
            return error_mark_node;
          spec.spec = inner;
        }
      tree constr = NULL_TREE;
      bool is_decl = mk & MK_tmpl_decl_mask;
      if (is_decl)
        {
          if (flag_concepts && TREE_CODE (inner) == VAR_DECL)
            {
              constr = tree_node ();
              if (constr)
                set_constraints (inner, constr);
            }
        }
      else
        {
          if (mk == MK_type_spec && inner != decl)
            return error_mark_node;
          spec.spec = type;
        }
      existing = match_mergeable_specialization (is_decl, &spec);
      if (constr)
        /* We'll add these back later, if this is the new decl.  */
        remove_constraints (inner);

      if (!existing)
        add_mergeable_specialization (spec.tmpl, spec.args, decl, flags);
      else if (mk & MK_tmpl_decl_mask)
        {
          /* A declaration specialization.  */
          if (mk & MK_tmpl_tmpl_mask)
            if (tree ti = DECL_TEMPLATE_INFO (existing))
              {
                tree tmpl = TI_TEMPLATE (ti);
                if (DECL_TEMPLATE_RESULT (tmpl) == existing)
                  existing = tmpl;
              }
        }
      else
        {
          /* A type specialization.  */
          if (!(mk & MK_tmpl_tmpl_mask))
            existing = TYPE_NAME (existing);
          else if (tree ti = CLASSTYPE_TEMPLATE_INFO (existing))
            {
              tree tmpl = TI_TEMPLATE (ti);
              if (DECL_TEMPLATE_RESULT (tmpl) == TYPE_NAME (existing))
                existing = tmpl;
            }
        }
    }
  else if (mk == MK_unique)
    kind = "unique";
  else
    {
      tree name = tree_node ();

      merge_key key;
      unsigned code = u ();
      key.ref_q = cp_ref_qualifier ((code >> 0) & 3);
      key.index = code >> 2;

      if (mk == MK_enum)
        key.ret = tree_node ();
      else if (mk == MK_partial
               || ((mk == MK_named || mk == MK_friend_spec)
                   && inner && TREE_CODE (inner) == FUNCTION_DECL))
        {
          key.ret = tree_node ();
          tree arg, *arg_ptr = &key.args;
          while ((arg = tree_node ())
                 && arg != void_list_node
                 && mk != MK_partial)
            {
              *arg_ptr = tree_cons (NULL_TREE, arg, NULL_TREE);
              arg_ptr = &TREE_CHAIN (*arg_ptr);
            }
          *arg_ptr = arg;
          key.constraints = tree_node ();
        }

      if (get_overrun ())
        return error_mark_node;

      if (mk < MK_indirect_lwm)
        {
          DECL_NAME (decl) = name;
          DECL_CONTEXT (decl) = FROB_CONTEXT (container);
        }
      if (inner)
        {
          DECL_NAME (inner) = DECL_NAME (decl);
          DECL_CONTEXT (inner) = DECL_CONTEXT (decl);
        }

      if (mk == MK_partial)
        {
          for (tree spec = DECL_TEMPLATE_SPECIALIZATIONS (key.ret);
               spec; spec = TREE_CHAIN (spec))
            {
              tree tmpl = TREE_VALUE (spec);
              if (template_args_equal (key.args,
                                       CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)))
                  && cp_tree_equal (key.constraints,
                                    get_constraints
                                    (DECL_TEMPLATE_RESULT (tmpl))))
                {
                  existing = tmpl;
                  break;
                }
            }
          if (!existing)
            add_mergeable_specialization (key.ret, key.args, decl, 2);
        }
      else
        switch (TREE_CODE (container))
          {
          default:
            gcc_unreachable ();

          case NAMESPACE_DECL:
            if (mk == MK_attached)
              {
                if (DECL_LANG_SPECIFIC (name)
                    && VAR_OR_FUNCTION_DECL_P (name)
                    && DECL_MODULE_ATTACHMENTS_P (name))
                  if (attachset *set = attached_table->get (DECL_UID (name)))
                    if (key.index < set->num)
                      {
                        existing = set->values[key.index];
                        if (existing)
                          {
                            gcc_checking_assert
                              (DECL_IMPLICIT_TYPEDEF_P (existing));
                            if (inner != decl)
                              existing
                                = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (existing));
                          }
                      }
              }
            else if (is_mod && !(state->is_module () || state->is_partition ()))
              kind = "unique";
            else
              {
                gcc_checking_assert (mk == MK_named || mk == MK_enum);
                tree mvec;
                tree *vslot = mergeable_namespace_slots (container, name,
                                                         !is_mod, &mvec);
                existing = check_mergeable_decl (mk, decl, *vslot, key);
                if (!existing)
                  add_mergeable_namespace_entity (vslot, decl);
                else
                  {
                    /* Note that we now have duplicates to deal with in
                       name lookup.  */
                    if (is_mod)
                      BINDING_VECTOR_PARTITION_DUPS_P (mvec) = true;
                    else
                      BINDING_VECTOR_GLOBAL_DUPS_P (mvec) = true;
                  }
              }
            break;

          case FUNCTION_DECL:
            // FIXME: What about a voldemort? how do we find what it
            // duplicates? Do we have to number vmorts relative to
            // their containing function?  But how would that work
            // when matching an in-TU declaration?
            kind = "unique";
            break;

          case TYPE_DECL:
            if (is_mod && !(state->is_module () || state->is_partition ())
                /* Implicit member functions can come from
                   anywhere.  */
                && !(DECL_ARTIFICIAL (decl)
                     && TREE_CODE (decl) == FUNCTION_DECL
                     && !DECL_THUNK_P (decl)))
              kind = "unique";
            else
              {
                tree ctx = TREE_TYPE (container);

                /* For some reason templated enumeral types are not marked
                   as COMPLETE_TYPE_P, even though they have members.
                   This may well be a bug elsewhere.  */
                if (TREE_CODE (ctx) == ENUMERAL_TYPE)
                  existing = find_enum_member (ctx, name);
                else if (COMPLETE_TYPE_P (ctx))
                  {
                    switch (mk)
                      {
                      default:
                        gcc_unreachable ();

                      case MK_named:
                        existing = lookup_class_binding (ctx, name);
                        if (existing)
                          {
                            tree inner = decl;
                            if (TREE_CODE (inner) == TEMPLATE_DECL
                                && !DECL_MEMBER_TEMPLATE_P (inner))
                              inner = DECL_TEMPLATE_RESULT (inner);

                            existing = check_mergeable_decl
                              (mk, inner, existing, key);
                            
                            if (!existing && DECL_ALIAS_TEMPLATE_P (decl))
                              {} // FIXME: Insert into specialization
                            // tables, we'll need the arguments for that!
                          }
                        break;

                      case MK_field:
                        {
                          unsigned ix = key.index;
                          for (tree field = TYPE_FIELDS (ctx);
                               field; field = DECL_CHAIN (field))
                            {
                              tree finner = STRIP_TEMPLATE (field);
                              if (TREE_CODE (finner) == TREE_CODE (inner))
                                if (!ix--)
                                  {
                                    existing = field;
                                    break;
                                  }
                            }
                        }
                        break;

                      case MK_vtable:
                        {
                          unsigned ix = key.index;
                          for (tree vtable = CLASSTYPE_VTABLES (ctx);
                               vtable; vtable = DECL_CHAIN (vtable))
                            if (!ix--)
                              {
                                existing = vtable;
                                break;
                              }
                        }
                        break;

                      case MK_as_base:
                        {
                          tree as_base = CLASSTYPE_AS_BASE (ctx);
                          if (as_base && as_base != ctx)
                            existing = TYPE_NAME (as_base);
                        }
                        break;

                      case MK_local_friend:
                        {
                          unsigned ix = key.index;
                          for (tree decls = CLASSTYPE_DECL_LIST (ctx);
                               decls; decls = TREE_CHAIN (decls))
                            if (!TREE_PURPOSE (decls) && !ix--)
                              {
                                existing
                                  = friend_from_decl_list (TREE_VALUE (decls));
                                break;
                              }
                        }
                        break;
                      }

                    if (existing && mk < MK_indirect_lwm && mk != MK_partial
                        && TREE_CODE (decl) == TEMPLATE_DECL
                        && !DECL_MEMBER_TEMPLATE_P (decl))
                      {
                        tree ti;
                        if (DECL_IMPLICIT_TYPEDEF_P (existing))
                          ti = TYPE_TEMPLATE_INFO (TREE_TYPE (existing));
                        else
                          ti = DECL_TEMPLATE_INFO (existing);
                        existing = TI_TEMPLATE (ti);
                      }
                  }
              }
          }

      if (mk == MK_friend_spec)
        {
          spec_entry spec;
          spec.tmpl = tree_node ();
          spec.args = tree_node ();
          spec.spec = decl;
          unsigned flags = u ();

          tree e = match_mergeable_specialization (true, &spec);
          if (!e)
            add_mergeable_specialization (spec.tmpl, spec.args,
                                          existing ? existing : decl, flags);
          else if (e != existing)
            set_overrun ();
        }
    }

  dump (dumper::MERGE)
    && dump ("Read:%d's %s merge key (%s) %C:%N", tag, merge_kind_name[mk],
             existing ? "matched" : kind, TREE_CODE (decl), decl);

  return existing;
}

void
trees_out::binfo_mergeable (tree binfo)
{
  tree dom = binfo;
  while (tree parent = BINFO_INHERITANCE_CHAIN (dom))
    dom = parent;
  tree type = BINFO_TYPE (dom);
  gcc_checking_assert (TYPE_BINFO (type) == dom);
  tree_node (type);
  if (streaming_p ())
    {
      unsigned ix = 0;
      for (; dom != binfo; dom = TREE_CHAIN (dom))
        ix++;
      u (ix);
    }
}

unsigned
trees_in::binfo_mergeable (tree *type)
{
  *type = tree_node ();
  return u ();
}

/* DECL is a just streamed mergeable decl that should match EXISTING.  Check
   it does and issue an appropriate diagnostic if not.  Merge any
   bits from DECL to EXISTING.  This is stricter matching than
   decls_match, because we can rely on ODR-sameness, and we cannot use
   decls_match because it can cause instantiations of constraints.  */

bool
trees_in::is_matching_decl (tree existing, tree decl)
{
  // FIXME: We should probably do some duplicate decl-like stuff here
  // (beware, default parms should be the same?)  Can we just call
  // duplicate_decls and teach it how to handle the module-specific
  // permitted/required duplications?

  // We know at this point that the decls have matched by key, so we
  // can elide some of the checking
  gcc_checking_assert (TREE_CODE (existing) == TREE_CODE (decl));

  tree inner = decl;
  if (TREE_CODE (decl) == TEMPLATE_DECL)
    {
      inner = DECL_TEMPLATE_RESULT (decl);
      gcc_checking_assert (TREE_CODE (DECL_TEMPLATE_RESULT (existing))
                           == TREE_CODE (inner));
    }

  gcc_checking_assert (!map_context_from);
  /* This mapping requres the new decl on the lhs and the existing
     entity on the rhs of the comparitors below.  */
  map_context_from = inner;
  map_context_to = STRIP_TEMPLATE (existing);

  if (TREE_CODE (inner) == FUNCTION_DECL)
    {
      tree e_ret = fndecl_declared_return_type (existing);
      tree d_ret = fndecl_declared_return_type (decl);

      if (decl != inner && DECL_NAME (inner) == fun_identifier
          && LAMBDA_TYPE_P (DECL_CONTEXT (inner)))
        /* This has a recursive type that will compare different.  */;
      else if (!same_type_p (d_ret, e_ret))
        goto mismatch;

      tree e_type = TREE_TYPE (existing);
      tree d_type = TREE_TYPE (decl);

      if (DECL_EXTERN_C_P (decl) != DECL_EXTERN_C_P (existing))
        goto mismatch;

      for (tree e_args = TYPE_ARG_TYPES (e_type),
             d_args = TYPE_ARG_TYPES (d_type);
           e_args != d_args && (e_args || d_args);
           e_args = TREE_CHAIN (e_args), d_args = TREE_CHAIN (d_args))
        {
          if (!(e_args && d_args))
            goto mismatch;

          if (!same_type_p (TREE_VALUE (d_args), TREE_VALUE (e_args)))
            goto mismatch;

          // FIXME: Check default values
        }

      /* If EXISTING has an undeduced or uninstantiated exception
         specification, but DECL does not, propagate the exception
         specification.  Otherwise we end up asserting or trying to
         instantiate it in the middle of loading.   */
      tree e_spec = TYPE_RAISES_EXCEPTIONS (e_type);
      tree d_spec = TYPE_RAISES_EXCEPTIONS (d_type);
      if (DEFERRED_NOEXCEPT_SPEC_P (e_spec))
        {
          if (!DEFERRED_NOEXCEPT_SPEC_P (d_spec)
              || (UNEVALUATED_NOEXCEPT_SPEC_P (e_spec)
                  && !UNEVALUATED_NOEXCEPT_SPEC_P (d_spec)))
            {
              dump (dumper::MERGE)
                && dump ("Propagating instantiated noexcept to %N", existing);
              TREE_TYPE (existing) = d_type;

              /* Propagate to existing clones.  */
              tree clone;
              FOR_EACH_CLONE (clone, existing)
                {
                  if (TREE_TYPE (clone) == e_type)
                    TREE_TYPE (clone) = d_type;
                  else
                    TREE_TYPE (clone)
                      = build_exception_variant (TREE_TYPE (clone), d_spec);
                }
            }
        }
      else if (!DEFERRED_NOEXCEPT_SPEC_P (d_spec)
               && !comp_except_specs (d_spec, e_spec, ce_type))
        goto mismatch;
    }
  /* Using cp_tree_equal because we can meet TYPE_ARGUMENT_PACKs
     here. I suspect the entities that directly do that are things
     that shouldn't go to duplicate_decls (FIELD_DECLs etc).   */
  else if (!cp_tree_equal (TREE_TYPE (decl), TREE_TYPE (existing)))
    {
    mismatch:
      map_context_from = map_context_to = NULL_TREE;
      if (DECL_IS_UNDECLARED_BUILTIN (existing))
        /* Just like duplicate_decls, presum the user knows what
           they're doing in overriding a builtin.   */
        TREE_TYPE (existing) = TREE_TYPE (decl);
      else
        {
          // FIXME:QOI Might be template specialization from a module,
          // not necessarily global module
          error_at (DECL_SOURCE_LOCATION (decl),
                    "conflicting global module declaration %#qD", decl);
          inform (DECL_SOURCE_LOCATION (existing),
                  "existing declaration %#qD", existing);
          return false;
        }
    }

  map_context_from = map_context_to = NULL_TREE;

  if (DECL_IS_UNDECLARED_BUILTIN (existing)
      && !DECL_IS_UNDECLARED_BUILTIN (decl))
    {
      /* We're matching a builtin that the user has yet to declare.
         We are the one!  This is very much duplicate-decl
         shenanigans. */
      DECL_SOURCE_LOCATION (existing) = DECL_SOURCE_LOCATION (decl);
      if (TREE_CODE (decl) != TYPE_DECL)
        {
          /* Propagate exceptions etc.  */
          TREE_TYPE (existing) = TREE_TYPE (decl);
          TREE_NOTHROW (existing) = TREE_NOTHROW (decl);
        }
      /* This is actually an import! */
      DECL_MODULE_IMPORT_P (existing) = true;

      /* Yay, sliced!  */
      existing->base = decl->base;

      if (TREE_CODE (decl) == FUNCTION_DECL)
        {
          /* Ew :(  */
          memcpy (&existing->decl_common.size,
                  &decl->decl_common.size,
                  (offsetof (tree_decl_common, pt_uid)
                   - offsetof (tree_decl_common, size)));
          auto bltin_class = DECL_BUILT_IN_CLASS (decl);
          existing->function_decl.built_in_class = bltin_class;
          auto fncode = DECL_UNCHECKED_FUNCTION_CODE (decl);
          DECL_UNCHECKED_FUNCTION_CODE (existing) = fncode;
          if (existing->function_decl.built_in_class == BUILT_IN_NORMAL)
            {
              if (builtin_decl_explicit_p (built_in_function (fncode)))
                switch (fncode)
                  {
                  case BUILT_IN_STPCPY:
                    set_builtin_decl_implicit_p
                      (built_in_function (fncode), true);
                    break;
                  default:
                    set_builtin_decl_declared_p
                      (built_in_function (fncode), true);
                    break;
                  }
              copy_attributes_to_builtin (decl);
            }
        }
    }

  if (VAR_OR_FUNCTION_DECL_P (decl)
      && DECL_TEMPLATE_INSTANTIATED (decl))
    /* Don't instantiate again!  */
    DECL_TEMPLATE_INSTANTIATED (existing) = true;

  tree e_inner = inner == decl ? existing : DECL_TEMPLATE_RESULT (existing);

  if (TREE_CODE (inner) == FUNCTION_DECL
      && DECL_DECLARED_INLINE_P (inner))
    DECL_DECLARED_INLINE_P (e_inner) = true;
  if (!DECL_EXTERNAL (inner))
    DECL_EXTERNAL (e_inner) = false;

  // FIXME: Check default tmpl and fn parms here

  return true;
}

/* FN is an implicit member function that we've discovered is new to
   the class.  Add it to the TYPE_FIELDS chain and the method vector.
   Reset the appropriate classtype lazy flag.   */

bool
trees_in::install_implicit_member (tree fn)
{
  tree ctx = DECL_CONTEXT (fn);
  tree name = DECL_NAME (fn);
  /* We know these are synthesized, so the set of expected prototypes
     is quite restricted.  We're not validating correctness, just
     distinguishing beteeen the small set of possibilities.  */
  tree parm_type = TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (fn));
  if (IDENTIFIER_CTOR_P (name))
    {
      if (CLASSTYPE_LAZY_DEFAULT_CTOR (ctx)
          && VOID_TYPE_P (parm_type))
        CLASSTYPE_LAZY_DEFAULT_CTOR (ctx) = false;
      else if (!TYPE_REF_P (parm_type))
        return false;
      else if (CLASSTYPE_LAZY_COPY_CTOR (ctx)
               && !TYPE_REF_IS_RVALUE (parm_type))
        CLASSTYPE_LAZY_COPY_CTOR (ctx) = false;
      else if (CLASSTYPE_LAZY_MOVE_CTOR (ctx))
        CLASSTYPE_LAZY_MOVE_CTOR (ctx) = false;
      else
        return false;
    }
  else if (IDENTIFIER_DTOR_P (name))
    {
      if (CLASSTYPE_LAZY_DESTRUCTOR (ctx))
        CLASSTYPE_LAZY_DESTRUCTOR (ctx) = false;
      else
        return false;
      if (DECL_VIRTUAL_P (fn))
        /* A virtual dtor should have been created when the class
           became complete.  */
        return false;
    }
  else if (name == assign_op_identifier)
    {
      if (!TYPE_REF_P (parm_type))
        return false;
      else if (CLASSTYPE_LAZY_COPY_ASSIGN (ctx)
               && !TYPE_REF_IS_RVALUE (parm_type))
        CLASSTYPE_LAZY_COPY_ASSIGN (ctx) = false;
      else if (CLASSTYPE_LAZY_MOVE_ASSIGN (ctx))
        CLASSTYPE_LAZY_MOVE_ASSIGN (ctx) = false;
      else
        return false;
    }
  else
    return false;

  dump (dumper::MERGE) && dump ("Adding implicit member %N", fn);

  DECL_CHAIN (fn) = TYPE_FIELDS (ctx);
  TYPE_FIELDS (ctx) = fn;

  add_method (ctx, fn, false);

    /* Propagate TYPE_FIELDS.  */
  fixup_type_variants (ctx);

  return true;
}

/* Return non-zero if DECL has a definition that would be interesting to
   write out.  */

static bool
has_definition (tree decl)
{
  bool is_tmpl = TREE_CODE (decl) == TEMPLATE_DECL;
  if (is_tmpl)
    decl = DECL_TEMPLATE_RESULT (decl);

  switch (TREE_CODE (decl))
    {
    default:
      break;

    case FUNCTION_DECL:
      if (!DECL_SAVED_TREE (decl))
        /* Not defined.  */
        break;

      if (DECL_DECLARED_INLINE_P (decl))
        return true;

      if (DECL_THIS_STATIC (decl)
          && (header_module_p ()
              || (!DECL_LANG_SPECIFIC (decl) || !DECL_MODULE_PURVIEW_P (decl))))
        /* GM static function.  */
        return true;

      if (DECL_TEMPLATE_INFO (decl))
        {
          int use_tpl = DECL_USE_TEMPLATE (decl);

          // FIXME: Partial specializations have definitions too.
          if (use_tpl < 2)
            return true;
        }
      break;

    case TYPE_DECL:
      {
        tree type = TREE_TYPE (decl);
        if (type == TYPE_MAIN_VARIANT (type)
            && decl == TYPE_NAME (type)
            && (TREE_CODE (type) == ENUMERAL_TYPE
                ? TYPE_VALUES (type) : TYPE_FIELDS (type)))
          return true;
      }
      break;

    case VAR_DECL:
      if (DECL_LANG_SPECIFIC (decl)
          && DECL_TEMPLATE_INFO (decl)
          && DECL_USE_TEMPLATE (decl) < 2)
        return DECL_INITIAL (decl);
      else
        {
          if (!DECL_INITIALIZED_P (decl))
            return false;

          if (header_module_p ()
              || (!DECL_LANG_SPECIFIC (decl) || !DECL_MODULE_PURVIEW_P (decl)))
            /* GM static variable.  */
            return true;

          if (!TREE_CONSTANT (decl))
            return false;

          return true;
        }
      break;

    case CONCEPT_DECL:
      if (DECL_INITIAL (decl))
        return true;

      break;
    }

  return false;
}

uintptr_t *
trees_in::find_duplicate (tree existing)
{
  if (!duplicates)
    return NULL;

  return duplicates->get (existing);
}

/* We're starting to read a duplicate DECL.  EXISTING is the already
   known node.  */

void
trees_in::register_duplicate (tree decl, tree existing)
{
  if (!duplicates)
    duplicates = new duplicate_hash_map (40);

  bool existed;
  uintptr_t &slot = duplicates->get_or_insert (existing, &existed);
  gcc_checking_assert (!existed);
  slot = reinterpret_cast<uintptr_t> (decl);
}

/* We've read a definition of MAYBE_EXISTING.  If not a duplicate,
   return MAYBE_EXISTING (into which the definition should be
   installed).  Otherwise return NULL if already known bad, or the
   duplicate we read (for ODR checking, or extracting addtional merge
   information).  */

tree
trees_in::odr_duplicate (tree maybe_existing, bool has_defn)
{
  tree res = NULL_TREE;

  if (uintptr_t *dup = find_duplicate (maybe_existing))
    {
      if (!(*dup & 1))
        res = reinterpret_cast<tree> (*dup);
    }
  else
    res = maybe_existing;

  assert_definition (maybe_existing, res && !has_defn);

  // FIXME: We probably need to return the template, so that the
  // template header can be checked?
  return res ? STRIP_TEMPLATE (res) : NULL_TREE;
}

/* The following writer functions rely on the current behaviour of
   depset::hash::add_dependency making the decl and defn depset nodes
   depend on eachother.  That way we don't have to worry about seeding
   the tree map with named decls that cannot be looked up by name (I.e
   template and function parms).  We know the decl and definition will
   be in the same cluster, which is what we want.  */

void
trees_out::write_function_def (tree decl)
{
  tree_node (DECL_RESULT (decl));
  tree_node (DECL_INITIAL (decl));
  tree_node (DECL_SAVED_TREE (decl));
  tree_node (DECL_FRIEND_CONTEXT (decl));

  constexpr_fundef *cexpr = retrieve_constexpr_fundef (decl);
  int tag = 0;
  if (cexpr)
    {
      if (cexpr->result == error_mark_node)
        /* We'll stream the RESULT_DECL naturally during the
           serialization.  We never need to fish it back again, so
           that's ok.  */
        tag = 0;
      else
        tag = insert (cexpr->result);
    }
  if (streaming_p ())
    {
      i (tag);
      if (tag)
        dump (dumper::TREE)
          && dump ("Constexpr:%d result %N", tag, cexpr->result);
    }
  if (tag)
    {
      unsigned ix = 0;
      for (tree parm = cexpr->parms; parm; parm = DECL_CHAIN (parm), ix++)
        {
          tag = insert (parm);
          if (streaming_p ())
            dump (dumper::TREE)
              && dump ("Constexpr:%d parm:%u %N", tag, ix, parm);
        }
      tree_node (cexpr->body);
    }

  if (streaming_p ())
    {
      unsigned flags = 0;

      if (DECL_NOT_REALLY_EXTERN (decl))
        flags |= 1;

      u (flags);
    }
}

void
trees_out::mark_function_def (tree)
{
}

bool
trees_in::read_function_def (tree decl, tree maybe_template)
{
  dump () && dump ("Reading function definition %N", decl);
  tree result = tree_node ();
  tree initial = tree_node ();
  tree saved = tree_node ();
  tree context = tree_node ();
  constexpr_fundef cexpr;

  tree maybe_dup = odr_duplicate (maybe_template, DECL_SAVED_TREE (decl));
  bool installing = maybe_dup && !DECL_SAVED_TREE (decl);

  if (maybe_dup)
    for (auto parm = DECL_ARGUMENTS (maybe_dup); parm; parm = DECL_CHAIN (parm))
      DECL_CONTEXT (parm) = decl;

  if (int wtag = i ())
    {
      int tag = 1;
      cexpr.result = error_mark_node;

      cexpr.result = copy_decl (result);
      tag = insert (cexpr.result);

      if (wtag != tag)
        set_overrun ();
      dump (dumper::TREE)
        && dump ("Constexpr:%d result %N", tag, cexpr.result);

      cexpr.parms = NULL_TREE;
      tree *chain = &cexpr.parms;
      unsigned ix = 0;
      for (tree parm = DECL_ARGUMENTS (maybe_dup ? maybe_dup : decl);
           parm; parm = DECL_CHAIN (parm), ix++)
        {
          tree p = copy_decl (parm);
          tag = insert (p);
          dump (dumper::TREE)
            && dump ("Constexpr:%d parm:%u %N", tag, ix, p);
          *chain = p;
          chain = &DECL_CHAIN (p);
        }
      cexpr.body = tree_node ();
      cexpr.decl = decl;
    }
  else
    cexpr.decl = NULL_TREE;

  unsigned flags = u ();

  if (get_overrun ())
    return NULL_TREE;

  if (installing)
    {
      DECL_NOT_REALLY_EXTERN (decl) = flags & 1;
      DECL_RESULT (decl) = result;
      DECL_INITIAL (decl) = initial;
      DECL_SAVED_TREE (decl) = saved;
      if (maybe_dup)
        DECL_ARGUMENTS (decl) = DECL_ARGUMENTS (maybe_dup);

      if (context)
        SET_DECL_FRIEND_CONTEXT (decl, context);
      if (cexpr.decl)
        register_constexpr_fundef (cexpr);
      post_process (maybe_template);
    }
  else if (maybe_dup)
    {
      // FIXME:QOI Check matching defn
    }
  
  return true;
}

/* Also for CONCEPT_DECLs.  */

void
trees_out::write_var_def (tree decl)
{
  tree init = DECL_INITIAL (decl);
  tree_node (init);
  if (!init)
    {
      tree dyn_init = NULL_TREE;

      if (DECL_NONTRIVIALLY_INITIALIZED_P (decl))
        {
          dyn_init = value_member (decl,
                                   CP_DECL_THREAD_LOCAL_P (decl)
                                   ? tls_aggregates : static_aggregates);
          gcc_checking_assert (dyn_init);
          /* Mark it so write_inits knows this is needed.  */
          TREE_LANG_FLAG_0 (dyn_init) = true;
          dyn_init = TREE_PURPOSE (dyn_init);
        }
      tree_node (dyn_init);
    }
}

void
trees_out::mark_var_def (tree)
{
}

bool
trees_in::read_var_def (tree decl, tree maybe_template)
{
  /* Do not mark the virtual table entries as used.  */
  bool vtable = TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl);
  unused += vtable;
  tree init = tree_node ();
  tree dyn_init = init ? NULL_TREE : tree_node ();
  unused -= vtable;

  if (get_overrun ())
    return false;

  bool initialized = (VAR_P (decl) ? bool (DECL_INITIALIZED_P (decl))
                      : bool (DECL_INITIAL (decl)));
  tree maybe_dup = odr_duplicate (maybe_template, initialized);
  bool installing = maybe_dup && !initialized;
  if (installing)
    {
      if (DECL_EXTERNAL (decl))
        DECL_NOT_REALLY_EXTERN (decl) = true;
      if (VAR_P (decl))
        DECL_INITIALIZED_P (decl) = true;
      DECL_INITIAL (decl) = init;
      if (!dyn_init)
        ;
      else if (CP_DECL_THREAD_LOCAL_P (decl))
        tls_aggregates = tree_cons (dyn_init, decl, tls_aggregates);
      else
        static_aggregates = tree_cons (dyn_init, decl, static_aggregates);
    }
  else if (maybe_dup)
    {
      // FIXME:QOI Check matching defn
    }

  return true;
}

/* If MEMBER doesn't have an independent life outside the class,
   return it (or it's TEMPLATE_DECL).  Otherwise NULL.  */

static tree
member_owned_by_class (tree member)
{
  gcc_assert (DECL_P (member));

  /* Clones are owned by their origin.  */
  if (DECL_CLONED_FUNCTION_P (member))
    return NULL;

  if (TREE_CODE (member) == FIELD_DECL)
    /* FIELD_DECLS can have template info in some cases.  We always
       want the FIELD_DECL though, as there's never a TEMPLATE_DECL
       wrapping them.  */
    return member;

  int use_tpl = -1;
  if (tree ti = node_template_info (member, use_tpl))
    {
      // FIXME: Don't bail on things that CANNOT have their own
      // template header.  No, make sure they're in the same cluster.
      if (use_tpl > 0)
        return NULL_TREE;

      if (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti)) == member)
        member = TI_TEMPLATE (ti);
    }
  return member;
}

void
trees_out::write_class_def (tree defn)
{
  gcc_assert (DECL_P (defn));
  if (streaming_p ())
    dump () && dump ("Writing class definition %N", defn);

  tree type = TREE_TYPE (defn);
  tree_node (TYPE_SIZE (type));
  tree_node (TYPE_SIZE_UNIT (type));
  tree_node (TYPE_VFIELD (type));
  tree_node (TYPE_BINFO (type));

  vec_chained_decls (TYPE_FIELDS (type));

  /* Every class but __as_base has a type-specific.  */
  gcc_checking_assert (!TYPE_LANG_SPECIFIC (type) == IS_FAKE_BASE_TYPE (type));

  if (TYPE_LANG_SPECIFIC (type))
    {
      {
        vec<tree, va_gc> *v = CLASSTYPE_MEMBER_VEC (type);
        if (!v)
          {
            gcc_checking_assert (!streaming_p ());
            /* Force a class vector.  */
            v = set_class_bindings (type, -1);
            gcc_checking_assert (v);
          }

        unsigned len = v->length ();
        if (streaming_p ())
          u (len);
        for (unsigned ix = 0; ix != len; ix++)
          {
            tree m = (*v)[ix];
            if (TREE_CODE (m) == TYPE_DECL
                && DECL_ARTIFICIAL (m)
                && TYPE_STUB_DECL (TREE_TYPE (m)) == m)
              /* This is a using-decl for a type, or an anonymous
                 struct (maybe with a typedef name).  Write the type.  */
              m = TREE_TYPE (m);
            tree_node (m);
          }
      }
      tree_node (CLASSTYPE_LAMBDA_EXPR (type));

      /* TYPE_CONTAINS_VPTR_P looks at the vbase vector, which the
         reader won't know at this point.  */
      int has_vptr = TYPE_CONTAINS_VPTR_P (type);

      if (streaming_p ())
        {
          unsigned nvbases = vec_safe_length (CLASSTYPE_VBASECLASSES (type));
          u (nvbases);
          i (has_vptr);
        }

      if (has_vptr)
        {
          tree_vec (CLASSTYPE_PURE_VIRTUALS (type));
          tree_pair_vec (CLASSTYPE_VCALL_INDICES (type));
          tree_node (CLASSTYPE_KEY_METHOD (type));
        }
    }

  if (TYPE_LANG_SPECIFIC (type))
    {
      tree_node (CLASSTYPE_PRIMARY_BINFO (type));

      tree as_base = CLASSTYPE_AS_BASE (type);
      if (as_base)
        as_base = TYPE_NAME (as_base);
      tree_node (as_base);

      /* Write the vtables.  */
      tree vtables = CLASSTYPE_VTABLES (type);
      vec_chained_decls (vtables);
      for (; vtables; vtables = TREE_CHAIN (vtables))
        write_definition (vtables);

      /* Write the friend classes.  */
      tree_list (CLASSTYPE_FRIEND_CLASSES (type), false);

      /* Write the friend functions.  */
      for (tree friends = DECL_FRIENDLIST (defn);
           friends; friends = TREE_CHAIN (friends))
        {
          /* Name of these friends.  */
          tree_node (TREE_PURPOSE (friends));
          tree_list (TREE_VALUE (friends), false);
        }
      /* End of friend fns.  */
      tree_node (NULL_TREE);

      /* Write the decl list.  */
      tree_list (CLASSTYPE_DECL_LIST (type), true);

      if (TYPE_CONTAINS_VPTR_P (type))
        {
          /* Write the thunks.  */
          for (tree decls = TYPE_FIELDS (type);
               decls; decls = DECL_CHAIN (decls))
            if (TREE_CODE (decls) == FUNCTION_DECL
                && DECL_VIRTUAL_P (decls)
                && DECL_THUNKS (decls))
              {
                tree_node (decls);
                /* Thunks are always unique, so chaining is ok.  */
                chained_decls (DECL_THUNKS (decls));
              }
          tree_node (NULL_TREE);
        }
    }
}

void
trees_out::mark_class_member (tree member, bool do_defn)
{
  gcc_assert (DECL_P (member));

  member = member_owned_by_class (member);
  if (member)
    mark_declaration (member, do_defn && has_definition (member));
}

void
trees_out::mark_class_def (tree defn)
{
  gcc_assert (DECL_P (defn));
  tree type = TREE_TYPE (defn);
  /* Mark the class members that are not type-decls and cannot have
     independent definitions.  */
  for (tree member = TYPE_FIELDS (type); member; member = DECL_CHAIN (member))
    if (TREE_CODE (member) == FIELD_DECL
        || TREE_CODE (member) == USING_DECL
        /* A cloned enum-decl from 'using enum unrelated;'   */
        || (TREE_CODE (member) == CONST_DECL
            && DECL_CONTEXT (member) == type))
      {
        mark_class_member (member);
        if (TREE_CODE (member) == FIELD_DECL)
          if (tree repr = DECL_BIT_FIELD_REPRESENTATIVE (member))
            mark_declaration (repr, false);
      }

  /* Mark the binfo hierarchy.  */
  for (tree child = TYPE_BINFO (type); child; child = TREE_CHAIN (child))
    mark_by_value (child);

  if (TYPE_LANG_SPECIFIC (type))
    {
      for (tree vtable = CLASSTYPE_VTABLES (type);
           vtable; vtable = TREE_CHAIN (vtable))
        mark_declaration (vtable, true);

      if (TYPE_CONTAINS_VPTR_P (type))
        /* Mark the thunks, they belong to the class definition,
           /not/ the thunked-to function.  */
        for (tree decls = TYPE_FIELDS (type);
             decls; decls = DECL_CHAIN (decls))
          if (TREE_CODE (decls) == FUNCTION_DECL)
            for (tree thunks = DECL_THUNKS (decls);
                 thunks; thunks = DECL_CHAIN (thunks))
              mark_declaration (thunks, false);
    }
}

/* Nop sorting, needed for resorting the member vec.  */

static void
nop (void *, void *)
{
}

bool
trees_in::read_class_def (tree defn, tree maybe_template)
{
  gcc_assert (DECL_P (defn));
  dump () && dump ("Reading class definition %N", defn);
  tree type = TREE_TYPE (defn);
  tree size = tree_node ();
  tree size_unit = tree_node ();
  tree vfield = tree_node ();
  tree binfo = tree_node ();
  vec<tree, va_gc> *vbase_vec = NULL;
  vec<tree, va_gc> *member_vec = NULL;
  vec<tree, va_gc> *pure_virts = NULL;
  vec<tree_pair_s, va_gc> *vcall_indices = NULL;
  tree key_method = NULL_TREE;
  tree lambda = NULL_TREE;

  /* Read the fields.  */
  vec<tree, va_heap> *fields = vec_chained_decls ();

  if (TYPE_LANG_SPECIFIC (type))
    {
      if (unsigned len = u ())
        {
          vec_alloc (member_vec, len);
          for (unsigned ix = 0; ix != len; ix++)
            {
              tree m = tree_node ();
              if (get_overrun ())
                break;
              if (TYPE_P (m))
                m = TYPE_STUB_DECL (m);
              member_vec->quick_push (m);
            }
        }
      lambda = tree_node ();

      if (!get_overrun ())
        {
          unsigned nvbases = u ();
          if (nvbases)
            {
              vec_alloc (vbase_vec, nvbases);
              for (tree child = binfo; child; child = TREE_CHAIN (child))
                if (BINFO_VIRTUAL_P (child))
                  vbase_vec->quick_push (child);
            }
        }

      if (!get_overrun ())
        {
          int has_vptr = i ();
          if (has_vptr)
            {
              pure_virts = tree_vec ();
              vcall_indices = tree_pair_vec ();
              key_method = tree_node ();
            }
        }
    }

  tree maybe_dup = odr_duplicate (maybe_template, TYPE_SIZE (type));
  bool installing = maybe_dup && !TYPE_SIZE (type);
  if (installing)
    {
      if (DECL_EXTERNAL (defn) && TYPE_LANG_SPECIFIC (type))
        {
          /* We don't deal with not-really-extern, because, for a
             module you want the import to be the interface, and for a
             header-unit, you're doing it wrong.  */
          CLASSTYPE_INTERFACE_UNKNOWN (type) = false;
          CLASSTYPE_INTERFACE_ONLY (type) = true;
        }

      if (maybe_dup != defn)
        {
          // FIXME: This is needed on other defns too, almost
          // duplicate-decl like?  See is_matching_decl too.
          /* Copy flags from the duplicate.  */
          tree type_dup = TREE_TYPE (maybe_dup);

          /* Core pieces.  */
          TYPE_MODE_RAW (type) = TYPE_MODE_RAW (type_dup);
          SET_DECL_MODE (defn, DECL_MODE (maybe_dup));
          TREE_ADDRESSABLE (type) = TREE_ADDRESSABLE (type_dup);
          DECL_SIZE (defn) = DECL_SIZE (maybe_dup);
          DECL_SIZE_UNIT (defn) = DECL_SIZE_UNIT (maybe_dup);
          DECL_ALIGN_RAW (defn) = DECL_ALIGN_RAW (maybe_dup);
          DECL_WARN_IF_NOT_ALIGN_RAW (defn)
            = DECL_WARN_IF_NOT_ALIGN_RAW (maybe_dup);
          DECL_USER_ALIGN (defn) = DECL_USER_ALIGN (maybe_dup);

          /* C++ pieces.  */
          TYPE_POLYMORPHIC_P (type) = TYPE_POLYMORPHIC_P (type_dup);
          TYPE_HAS_USER_CONSTRUCTOR (type)
            = TYPE_HAS_USER_CONSTRUCTOR (type_dup);
          TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
            = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type_dup);

          if (auto ls = TYPE_LANG_SPECIFIC (type_dup))
            {
              if (TYPE_LANG_SPECIFIC (type))
                {
                  CLASSTYPE_BEFRIENDING_CLASSES (type_dup)
                    = CLASSTYPE_BEFRIENDING_CLASSES (type);
                  CLASSTYPE_TYPEINFO_VAR (type_dup)
                    = CLASSTYPE_TYPEINFO_VAR (type);
                }
              for (tree v = type; v; v = TYPE_NEXT_VARIANT (v))
                TYPE_LANG_SPECIFIC (v) = ls;
            }
        }

      TYPE_SIZE (type) = size;
      TYPE_SIZE_UNIT (type) = size_unit;

      if (fields)
        {
          tree *chain = &TYPE_FIELDS (type);
          unsigned len = fields->length ();
          for (unsigned ix = 0; ix != len; ix++)
            {
              tree decl = (*fields)[ix];

              if (!decl)
                {
                  /* An anonymous struct with typedef name.  */
                  tree tdef = (*fields)[ix+1];
                  decl = TYPE_STUB_DECL (TREE_TYPE (tdef));
                  gcc_checking_assert (IDENTIFIER_ANON_P (DECL_NAME (decl))
                                       && decl != tdef);
                }

              gcc_checking_assert (!*chain == !DECL_CLONED_FUNCTION_P (decl));
              *chain = decl;
              chain = &DECL_CHAIN (decl);

              if (TREE_CODE (decl) == USING_DECL
                  && TREE_CODE (USING_DECL_SCOPE (decl)) == RECORD_TYPE)
                {
                  /* Reconstruct DECL_ACCESS.  */
                  tree decls = USING_DECL_DECLS (decl);
                  tree access = declared_access (decl);

                  for (ovl_iterator iter (decls); iter; ++iter)
                    {
                      tree d = *iter;

                      retrofit_lang_decl (d);
                      tree list = DECL_ACCESS (d);

                      if (!purpose_member (type, list))
                        DECL_ACCESS (d) = tree_cons (type, access, list);
                    }
                }
            }
        }

      TYPE_VFIELD (type) = vfield;
      TYPE_BINFO (type) = binfo;

      if (TYPE_LANG_SPECIFIC (type))
        {
          CLASSTYPE_LAMBDA_EXPR (type) = lambda;

          CLASSTYPE_MEMBER_VEC (type) = member_vec;
          CLASSTYPE_PURE_VIRTUALS (type) = pure_virts;
          CLASSTYPE_VCALL_INDICES (type) = vcall_indices;

          CLASSTYPE_KEY_METHOD (type) = key_method;

          CLASSTYPE_VBASECLASSES (type) = vbase_vec;

          /* Resort the member vector.  */
          resort_type_member_vec (member_vec, NULL, nop, NULL);
        }
    }
  else if (maybe_dup)
    {
      // FIXME:QOI Check matching defn
    }

  if (TYPE_LANG_SPECIFIC (type))
    {
      tree primary = tree_node ();
      tree as_base = tree_node ();

      if (as_base)
        as_base = TREE_TYPE (as_base);

      /* Read the vtables.  */
      vec<tree, va_heap> *vtables = vec_chained_decls ();
      if (vtables)
        {
          unsigned len = vtables->length ();
          for (unsigned ix = 0; ix != len; ix++)
            {
              tree vtable = (*vtables)[ix];
              read_var_def (vtable, vtable);
            }
        }

      tree friend_classes = tree_list (false);
      tree friend_functions = NULL_TREE;
      for (tree *chain = &friend_functions;
           tree name = tree_node (); chain = &TREE_CHAIN (*chain))
        {
          tree val = tree_list (false);
          *chain = build_tree_list (name, val);
        }
      tree decl_list = tree_list (true);

      if (installing)
        {
          CLASSTYPE_PRIMARY_BINFO (type) = primary;
          CLASSTYPE_AS_BASE (type) = as_base;

          if (vtables)
            {
              if (!CLASSTYPE_KEY_METHOD (type)
                  /* Sneaky user may have defined it inline
                     out-of-class.  */
                  || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (type)))
                vec_safe_push (keyed_classes, type);
              unsigned len = vtables->length ();
              tree *chain = &CLASSTYPE_VTABLES (type);
              for (unsigned ix = 0; ix != len; ix++)
                {
                  tree vtable = (*vtables)[ix];
                  gcc_checking_assert (!*chain);
                  *chain = vtable;
                  chain = &DECL_CHAIN (vtable);
                }
            }
          CLASSTYPE_FRIEND_CLASSES (type) = friend_classes;
          DECL_FRIENDLIST (defn) = friend_functions;
          CLASSTYPE_DECL_LIST (type) = decl_list;

          for (; friend_classes; friend_classes = TREE_CHAIN (friend_classes))
            {
              tree f = TREE_VALUE (friend_classes);

              if (TYPE_P (f))
                {
                  CLASSTYPE_BEFRIENDING_CLASSES (f)
                    = tree_cons (NULL_TREE, type,
                                 CLASSTYPE_BEFRIENDING_CLASSES (f));
                  dump () && dump ("Class %N befriending %C:%N",
                                   type, TREE_CODE (f), f);
                }
            }

          for (; friend_functions;
               friend_functions = TREE_CHAIN (friend_functions))
            for (tree friend_decls = TREE_VALUE (friend_functions);
                 friend_decls; friend_decls = TREE_CHAIN (friend_decls))
              {
                tree f = TREE_VALUE (friend_decls);
                
                DECL_BEFRIENDING_CLASSES (f)
                  = tree_cons (NULL_TREE, type, DECL_BEFRIENDING_CLASSES (f));
                dump () && dump ("Class %N befriending %C:%N",
                                 type, TREE_CODE (f), f);
              }
        }

      if (TYPE_CONTAINS_VPTR_P (type))
        /* Read and install the thunks.  */
        while (tree vfunc = tree_node ())
          {
            tree thunks = chained_decls ();
            if (installing)
              SET_DECL_THUNKS (vfunc, thunks);
          }

      vec_free (vtables);
    }

  /* Propagate to all variants.  */
  if (installing)
    fixup_type_variants (type);

  /* IS_FAKE_BASE_TYPE is inaccurate at this point, because if this is
     the fake base, we've not hooked it into the containing class's
     data structure yet.  Fortunately it has a unique name.  */
  if (installing
      && DECL_NAME (defn) != as_base_identifier
      && (!CLASSTYPE_TEMPLATE_INFO (type)
          || !uses_template_parms (TI_ARGS (CLASSTYPE_TEMPLATE_INFO (type)))))
    /* Emit debug info.  It'd be nice to know if the interface TU
       already emitted this.  */
    rest_of_type_compilation (type, !LOCAL_CLASS_P (type));

  vec_free (fields);

  return !get_overrun ();
}

void
trees_out::write_enum_def (tree decl)
{
  tree type = TREE_TYPE (decl);

  tree_node (TYPE_VALUES (type));
  tree_node (TYPE_MIN_VALUE (type));
  tree_node (TYPE_MAX_VALUE (type));
}

void
trees_out::mark_enum_def (tree decl)
{
  tree type = TREE_TYPE (decl);

  for (tree values = TYPE_VALUES (type); values; values = TREE_CHAIN (values))
    {
      tree cst = TREE_VALUE (values);
      mark_by_value (cst);
      /* We must mark the init to avoid circularity in tt_enum_int.  */
      if (tree init = DECL_INITIAL (cst))
        if (TREE_CODE (init) == INTEGER_CST)
          mark_by_value (init);
    }
}

bool
trees_in::read_enum_def (tree defn, tree maybe_template)
{
  tree type = TREE_TYPE (defn);
  tree values = tree_node ();
  tree min = tree_node ();
  tree max = tree_node ();

  if (get_overrun ())
    return false;

  tree maybe_dup = odr_duplicate (maybe_template, TYPE_VALUES (type));
  bool installing = maybe_dup && !TYPE_VALUES (type);

  if (installing)
    {
      TYPE_VALUES (type) = values;
      TYPE_MIN_VALUE (type) = min;
      TYPE_MAX_VALUE (type) = max;

      rest_of_type_compilation (type, DECL_NAMESPACE_SCOPE_P (defn));
    }
  else if (maybe_dup)
    {
      tree known = TYPE_VALUES (type);
      for (; known && values;
           known = TREE_CHAIN (known), values = TREE_CHAIN (values))
        {
          tree known_decl = TREE_VALUE (known);
          tree new_decl = TREE_VALUE (values);

          if (DECL_NAME (known_decl) != DECL_NAME (new_decl))
            goto bad;
              
          new_decl = maybe_duplicate (new_decl);

          if (!cp_tree_equal (DECL_INITIAL (known_decl),
                              DECL_INITIAL (new_decl)))
            goto bad;
        }

      if (known || values)
        goto bad;

      if (!cp_tree_equal (TYPE_MIN_VALUE (type), min)
          || !cp_tree_equal (TYPE_MAX_VALUE (type), max))
        {
        bad:;
          error_at (DECL_SOURCE_LOCATION (maybe_dup),
                    "definition of %qD does not match", maybe_dup);
          inform (DECL_SOURCE_LOCATION (defn),
                  "existing definition %qD", defn);

          tree known_decl = NULL_TREE, new_decl = NULL_TREE;

          if (known)
            known_decl = TREE_VALUE (known);
          if (values)
            new_decl = maybe_duplicate (TREE_VALUE (values));

          if (known_decl && new_decl)
            {
              inform (DECL_SOURCE_LOCATION (new_decl),
                      "... this enumerator %qD", new_decl);
              inform (DECL_SOURCE_LOCATION (known_decl),
                      "enumerator %qD does not match ...", known_decl);
            }
          else if (known_decl || new_decl)
            {
              tree extra = known_decl ? known_decl : new_decl;
              inform (DECL_SOURCE_LOCATION (extra),
                      "additional enumerators beginning with %qD", extra);
            }
          else
            inform (DECL_SOURCE_LOCATION (maybe_dup),
                    "enumeration range differs");

          /* Mark it bad.  */
          unmatched_duplicate (maybe_template);
        }
    }

  return true;
}

/* Write out the body of DECL.  See above circularity note.  */

void
trees_out::write_definition (tree decl)
{
  if (streaming_p ())
    {
      assert_definition (decl);
      dump ()
        && dump ("Writing definition %C:%N", TREE_CODE (decl), decl);
    }
  else
    dump (dumper::DEPEND)
      && dump ("Depending definition %C:%N", TREE_CODE (decl), decl);

 again:
  switch (TREE_CODE (decl))
    {
    default:
      gcc_unreachable ();

    case TEMPLATE_DECL:
      decl = DECL_TEMPLATE_RESULT (decl);
      goto again;

    case FUNCTION_DECL:
      write_function_def (decl);
      break;

    case TYPE_DECL:
      {
        tree type = TREE_TYPE (decl);
        gcc_assert (TYPE_MAIN_VARIANT (type) == type
                    && TYPE_NAME (type) == decl);
        if (TREE_CODE (type) == ENUMERAL_TYPE)
          write_enum_def (decl);
        else
          write_class_def (decl);
      }
      break;

    case VAR_DECL:
    case CONCEPT_DECL:
      write_var_def (decl);
      break;
    }
}

/* Mark a declaration for by-value walking.  If DO_DEFN is true, mark
   its body too.  */

void
trees_out::mark_declaration (tree decl, bool do_defn)
{
  mark_by_value (decl);

  if (TREE_CODE (decl) == TEMPLATE_DECL)
    decl = DECL_TEMPLATE_RESULT (decl);

  if (!do_defn)
    return;

  switch (TREE_CODE (decl))
    {
    default:
      gcc_unreachable ();

    case FUNCTION_DECL:
      mark_function_def (decl);
      break;

    case TYPE_DECL:
      {
        tree type = TREE_TYPE (decl);
        gcc_assert (TYPE_MAIN_VARIANT (type) == type
                    && TYPE_NAME (type) == decl);
        if (TREE_CODE (type) == ENUMERAL_TYPE)
          mark_enum_def (decl);
        else
          mark_class_def (decl);
      }
      break;

    case VAR_DECL:
    case CONCEPT_DECL:
      mark_var_def (decl);
      break;
    }
}

/* Read in the body of DECL.  See above circularity note.  */

bool
trees_in::read_definition (tree decl)
{
  dump () && dump ("Reading definition %C %N", TREE_CODE (decl), decl);

  tree maybe_template = decl;

 again:
  switch (TREE_CODE (decl))
    {
    default:
      break;

    case TEMPLATE_DECL:
      decl = DECL_TEMPLATE_RESULT (decl);
      goto again;

    case FUNCTION_DECL:
      return read_function_def (decl, maybe_template);

    case TYPE_DECL:
      {
        tree type = TREE_TYPE (decl);
        gcc_assert (TYPE_MAIN_VARIANT (type) == type
                    && TYPE_NAME (type) == decl);
        if (TREE_CODE (type) == ENUMERAL_TYPE)
          return read_enum_def (decl, maybe_template);
        else
          return read_class_def (decl, maybe_template);
      }
      break;

    case VAR_DECL:
    case CONCEPT_DECL:
      return read_var_def (decl, maybe_template);
    }

  return false;
}

/* Lookup an maybe insert a slot for depset for KEY.  */

depset **
depset::hash::entity_slot (tree entity, bool insert)
{
  traits::compare_type key (entity, NULL);
  depset **slot = find_slot_with_hash (key, traits::hash (key),
                                       insert ? INSERT : NO_INSERT);

  return slot;
}

depset **
depset::hash::binding_slot (tree ctx, tree name, bool insert)
{
  traits::compare_type key (ctx, name);
  depset **slot = find_slot_with_hash (key, traits::hash (key),
                                       insert ? INSERT : NO_INSERT);

  return slot;
}

depset *
depset::hash::find_dependency (tree decl)
{
  depset **slot = entity_slot (decl, false);

  return slot ? *slot : NULL;
}

depset *
depset::hash::find_binding (tree ctx, tree name)
{
  depset **slot = binding_slot (ctx, name, false);

  return slot ? *slot : NULL;
}

/* DECL is a newly discovered dependency.  Create the depset, if it
   doesn't already exist.  Add it to the worklist if so.

   DECL will be an OVL_USING_P OVERLOAD, if it's from a binding that's
   a using decl.

   We do not have to worry about adding the same dependency more than
   once.  First it's harmless, but secondly the TREE_VISITED marking
   prevents us wanting to do it anyway.  */

depset *
depset::hash::make_dependency (tree decl, entity_kind ek)
{
  /* Make sure we're being told consistent information.  */
  gcc_checking_assert ((ek == EK_NAMESPACE)
                       == (TREE_CODE (decl) == NAMESPACE_DECL
                           && !DECL_NAMESPACE_ALIAS (decl)));
  gcc_checking_assert (ek != EK_BINDING && ek != EK_REDIRECT);
  gcc_checking_assert (TREE_CODE (decl) != FIELD_DECL
                       && (TREE_CODE (decl) != USING_DECL
                           || TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL));
  gcc_checking_assert (!is_key_order ());
  if (ek == EK_USING)
    gcc_checking_assert (TREE_CODE (decl) == OVERLOAD);

  if (TREE_CODE (decl) == TEMPLATE_DECL)
    {
      /* The template should have copied these from its result decl.  */
      tree res = DECL_TEMPLATE_RESULT (decl);

      gcc_checking_assert (DECL_MODULE_EXPORT_P (decl)
                           == DECL_MODULE_EXPORT_P (res));
      if (DECL_LANG_SPECIFIC (res))
        {
          gcc_checking_assert (DECL_MODULE_PURVIEW_P (decl)
                               == DECL_MODULE_PURVIEW_P (res));
          gcc_checking_assert ((DECL_MODULE_IMPORT_P (decl)
                                == DECL_MODULE_IMPORT_P (res)));
        }
    }

  depset **slot = entity_slot (decl, true);
  depset *dep = *slot;
  bool for_binding = ek == EK_FOR_BINDING;

  if (!dep)
    {
      if (DECL_IMPLICIT_TYPEDEF_P (decl)
          /* ... not an enum, for instance.  */
          && RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl))
          && TYPE_LANG_SPECIFIC (TREE_TYPE (decl))
          && CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)) == 2)
        {
          /* A partial or explicit specialization. Partial
             specializations might not be in the hash table, because
             there can be multiple differently-constrained variants.

             template<typename T> class silly;
             template<typename T> requires true class silly {};

             We need to find them, insert their TEMPLATE_DECL in the
             dep_hash, and then convert the dep we just found into a
             redirect.  */

          tree ti = TYPE_TEMPLATE_INFO (TREE_TYPE (decl));
          tree tmpl = TI_TEMPLATE (ti);
          tree partial = NULL_TREE;
          for (tree spec = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
               spec; spec = TREE_CHAIN (spec))
            if (DECL_TEMPLATE_RESULT (TREE_VALUE (spec)) == decl)
              {
                partial = TREE_VALUE (spec);
                break;
              }

          if (partial)
            {
              /* Eagerly create an empty redirect.  The following
                 make_dependency call could cause hash reallocation,
                 and invalidate slot's value.  */
              depset *redirect = make_entity (decl, EK_REDIRECT);

              /* Redirects are never reached -- always snap to their target.  */
              redirect->set_flag_bit<DB_UNREACHED_BIT> ();

              *slot = redirect;

              depset *tmpl_dep = make_dependency (partial, EK_PARTIAL);
              gcc_checking_assert (tmpl_dep->get_entity_kind () == EK_PARTIAL);

              redirect->deps.safe_push (tmpl_dep);

              return redirect;
            }
        }

      bool has_def = ek != EK_USING && has_definition (decl);
      if (ek > EK_BINDING)
        ek = EK_DECL;

      /* The only OVERLOADS we should see are USING decls from
         bindings.  */
      *slot = dep = make_entity (decl, ek, has_def);

      if (TREE_CODE (decl) == TEMPLATE_DECL)
        {
          if (DECL_ALIAS_TEMPLATE_P (decl) && DECL_TEMPLATE_INFO (decl))
            dep->set_flag_bit<DB_ALIAS_TMPL_INST_BIT> ();
          else if (CHECKING_P)
            /* The template_result should otherwise not be in the
               table, or be an empty redirect (created above).  */
            if (auto *eslot = entity_slot (DECL_TEMPLATE_RESULT (decl), false))
              gcc_checking_assert ((*eslot)->get_entity_kind () == EK_REDIRECT
                                   && !(*eslot)->deps.length ());
        }

      if (ek != EK_USING
          && DECL_LANG_SPECIFIC (decl)
          && DECL_MODULE_IMPORT_P (decl))
        {
          /* Store the module number and index in cluster/section, so
             we don't have to look them up again.  */
          unsigned index = import_entity_index (decl);
          module_state *from = import_entity_module (index);
          /* Remap will be zero for imports from partitions, which we
             want to treat as-if declared in this TU.  */
          if (from->remap)
            {
              dep->cluster = index - from->entity_lwm;
              dep->section = from->remap;
              dep->set_flag_bit<DB_IMPORTED_BIT> ();
            }
        }

      if (ek == EK_DECL
          && !dep->is_import ()
          && TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
          && !(TREE_CODE (decl) == TEMPLATE_DECL
               && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl)))
        {
          tree ctx = CP_DECL_CONTEXT (decl);
          tree not_tmpl = STRIP_TEMPLATE (decl);

          if (!TREE_PUBLIC (ctx))
            /* Member of internal namespace.  */
            dep->set_flag_bit<DB_IS_INTERNAL_BIT> ();
          else if (VAR_OR_FUNCTION_DECL_P (not_tmpl)
                   && DECL_THIS_STATIC (not_tmpl))
            {
              /* An internal decl.  This is ok in a GM entity.  */
              if (!(header_module_p ()
                    || !DECL_LANG_SPECIFIC (not_tmpl)
                    || !DECL_MODULE_PURVIEW_P (not_tmpl)))
                dep->set_flag_bit<DB_IS_INTERNAL_BIT> ();
            }

        }

      if (!dep->is_import ())
        worklist.safe_push (dep);
    }

  dump (dumper::DEPEND)
    && dump ("%s on %s %C:%N found",
             ek == EK_REDIRECT ? "Redirect"
             : for_binding ? "Binding" : "Dependency",
             dep->entity_kind_name (), TREE_CODE (decl), decl);

  return dep;
}

/* DEP is a newly discovered dependency.  Append it to current's
   depset.  */

void
depset::hash::add_dependency (depset *dep)
{
  gcc_checking_assert (current && !is_key_order ());
  current->deps.safe_push (dep);

  if (dep->is_internal () && !current->is_internal ())
    current->set_flag_bit<DB_REFS_INTERNAL_BIT> ();

  if (current->get_entity_kind () == EK_USING
      && DECL_IMPLICIT_TYPEDEF_P (dep->get_entity ())
      && TREE_CODE (TREE_TYPE (dep->get_entity ())) == ENUMERAL_TYPE)
    {
      /* CURRENT is an unwrapped using-decl and DECL is an enum's
         implicit typedef.  Is CURRENT a member of the enum?  */
      tree c_decl = OVL_FUNCTION (current->get_entity ());

      if (TREE_CODE (c_decl) == CONST_DECL
          && (current->deps[0]->get_entity ()
              == CP_DECL_CONTEXT (dep->get_entity ())))
        /* Make DECL depend on CURRENT.  */
        dep->deps.safe_push (current);
    }

  if (dep->is_unreached ())
    {
      /* The dependency is reachable now.  */
      reached_unreached = true;
      dep->clear_flag_bit<DB_UNREACHED_BIT> ();
      dump (dumper::DEPEND)
        && dump ("Reaching unreached %s %C:%N", dep->entity_kind_name (),
                 TREE_CODE (dep->get_entity ()), dep->get_entity ());
    }
}

depset *
depset::hash::add_dependency (tree decl, entity_kind ek)
{
  depset *dep;

  if (is_key_order ())
    {
      dep = find_dependency (decl);
      if (dep)
        {
          current->deps.safe_push (dep);
          dump (dumper::MERGE)
            && dump ("Key dependency on %s %C:%N found",
                     dep->entity_kind_name (), TREE_CODE (decl), decl);
        }
      else
        {
          /* It's not a mergeable decl, look for it in the original
             table.  */
          dep = chain->find_dependency (decl);
          gcc_checking_assert (dep);
        }
    }
  else
    {
      dep = make_dependency (decl, ek);
      if (dep->get_entity_kind () != EK_REDIRECT)
        add_dependency (dep);
    }

  return dep;
}

void
depset::hash::add_namespace_context (depset *dep, tree ns)
{
  depset *ns_dep = make_dependency (ns, depset::EK_NAMESPACE);
  dep->deps.safe_push (ns_dep);

  /* Mark it as special if imported so we don't walk connect when
     SCCing.  */
  if (!dep->is_binding () && ns_dep->is_import ())
    dep->set_special ();
}

struct add_binding_data
{
  tree ns;
  bitmap partitions;
  depset *binding;
  depset::hash *hash;
  bool met_namespace;
};

bool
depset::hash::add_binding_entity (tree decl, WMB_Flags flags, void *data_)
{
  auto data = static_cast <add_binding_data *> (data_);

  if (TREE_CODE (decl) != NAMESPACE_DECL || DECL_NAMESPACE_ALIAS (decl))
    {
      tree inner = decl;

      if (TREE_CODE (inner) == CONST_DECL
          && TREE_CODE (DECL_CONTEXT (inner)) == ENUMERAL_TYPE)
        inner = TYPE_NAME (DECL_CONTEXT (inner));
      else if (TREE_CODE (inner) == TEMPLATE_DECL)
        inner = DECL_TEMPLATE_RESULT (inner);

      if (!DECL_LANG_SPECIFIC (inner) || !DECL_MODULE_PURVIEW_P (inner))
        /* Ignore global module fragment entities.  */
        return false;

      if (VAR_OR_FUNCTION_DECL_P (inner)
          && DECL_THIS_STATIC (inner))
        {
          if (!header_module_p ())
            /* Ignore internal-linkage entitites.  */
            return false;
        }

      if ((TREE_CODE (decl) == VAR_DECL
           || TREE_CODE (decl) == TYPE_DECL)
          && DECL_TINFO_P (decl))
        /* Ignore TINFO things.  */
        return false;

      if (!(flags & WMB_Using) && CP_DECL_CONTEXT (decl) != data->ns)
        {
          /* A using that lost its wrapper or an unscoped enum
             constant.  */
          flags = WMB_Flags (flags | WMB_Using);
          if (DECL_MODULE_EXPORT_P (TREE_CODE (decl) == CONST_DECL
                                    ? TYPE_NAME (TREE_TYPE (decl))
                                    : STRIP_TEMPLATE (decl)))
            flags = WMB_Flags (flags | WMB_Export);
        }

      if (!data->binding)
        /* No binding to check.  */;
      else if (flags & WMB_Using)
        {
          /* Look in the binding to see if we already have this
             using.  */
          for (unsigned ix = data->binding->deps.length (); --ix;)
            {
              depset *d = data->binding->deps[ix];
              if (d->get_entity_kind () == EK_USING
                  && OVL_FUNCTION (d->get_entity ()) == decl)
                {
                  if (!(flags & WMB_Hidden))
                    d->clear_hidden_binding ();
                  if (flags & WMB_Export)
                    OVL_EXPORT_P (d->get_entity ()) = true;
                  return false;
                }
            }
        }
      else if (flags & WMB_Dups)
        {
          /* Look in the binding to see if we already have this decl.  */
          for (unsigned ix = data->binding->deps.length (); --ix;)
            {
              depset *d = data->binding->deps[ix];
              if (d->get_entity () == decl)
                {
                  if (!(flags & WMB_Hidden))
                    d->clear_hidden_binding ();
                  return false;
                }
            }
        }

      /* We're adding something.  */
      if (!data->binding)
        {
          data->binding = make_binding (data->ns, DECL_NAME (decl));
          data->hash->add_namespace_context (data->binding, data->ns);

          depset **slot = data->hash->binding_slot (data->ns,
                                                    DECL_NAME (decl), true);
          gcc_checking_assert (!*slot);
          *slot = data->binding;
        }

      if (flags & WMB_Using)
        {
          decl = ovl_make (decl, NULL_TREE);
          if (flags & WMB_Export)
            OVL_EXPORT_P (decl) = true;
        }

      depset *dep = data->hash->make_dependency
        (decl, flags & WMB_Using ? EK_USING : EK_FOR_BINDING);
      if (flags & WMB_Hidden)
        dep->set_hidden_binding ();
      data->binding->deps.safe_push (dep);
      /* Binding and contents are mutually dependent.  */
      dep->deps.safe_push (data->binding);

      return true;
    }
  else if (DECL_NAME (decl) && !data->met_namespace)
    {
      /* Namespace, walk exactly once.  */
      gcc_checking_assert (TREE_PUBLIC (decl));
      data->met_namespace = true;
      if (data->hash->add_namespace_entities (decl, data->partitions)
          || DECL_MODULE_EXPORT_P (decl))
        {
          data->hash->make_dependency (decl, depset::EK_NAMESPACE);
          return true;
        }
    }

  return false;
}

/* Recursively find all the namespace bindings of NS.
   Add a depset for every binding that contains an export or
   module-linkage entity.  Add a defining depset for every such decl
   that we need to write a definition.  Such defining depsets depend
   on the binding depset.  Returns true if we contain something
   explicitly exported.  */

bool
depset::hash::add_namespace_entities (tree ns, bitmap partitions)
{
  dump () && dump ("Looking for writables in %N", ns);
  dump.indent ();

  unsigned count = 0;
  add_binding_data data;
  data.ns = ns;
  data.partitions = partitions;
  data.hash = this;

  hash_table<named_decl_hash>::iterator end
    (DECL_NAMESPACE_BINDINGS (ns)->end ());
  for (hash_table<named_decl_hash>::iterator iter
         (DECL_NAMESPACE_BINDINGS (ns)->begin ()); iter != end; ++iter)
    {
      data.binding = nullptr;
      data.met_namespace = false;
      if (walk_module_binding (*iter, partitions, add_binding_entity, &data))
        count++;
    }

  if (count)
    dump () && dump ("Found %u entries", count);
  dump.outdent ();

  return count != 0;
}

void
depset::hash::add_partial_entities (vec<tree, va_gc> *partial_classes)
{
  for (unsigned ix = 0; ix != partial_classes->length (); ix++)
    {
      tree inner = (*partial_classes)[ix];

      depset *dep = make_dependency (inner, depset::EK_DECL);

      if (dep->get_entity_kind () == depset::EK_REDIRECT)
        /* We should have recorded the template as a partial
           specialization.  */
        gcc_checking_assert (dep->deps[0]->get_entity_kind ()
                             == depset::EK_PARTIAL);
      else
        /* It was an explicit specialization, not a partial one.  */
        gcc_checking_assert (dep->get_entity_kind ()
                             == depset::EK_SPECIALIZATION);
    }
}

/* Add the members of imported classes that we defined in this TU.
   This will also include lazily created implicit member function
   declarations.  (All others will be definitions.)  */

void
depset::hash::add_class_entities (vec<tree, va_gc> *class_members)
{
  for (unsigned ix = 0; ix != class_members->length (); ix++)
    {
      tree defn = (*class_members)[ix];
      depset *dep = make_dependency (defn, EK_INNER_DECL);

      if (dep->get_entity_kind () == EK_REDIRECT)
        dep = dep->deps[0];

      /* Only non-instantiations need marking as members.  */
      if (dep->get_entity_kind () == EK_DECL)
        dep->set_flag_bit <DB_IS_MEMBER_BIT> ();
    }
}

/* We add the partial & explicit specializations, and the explicit
   instantiations.  */

static void
specialization_add (bool decl_p, spec_entry *entry, void *data_)
{
  vec<spec_entry *> *data = reinterpret_cast <vec<spec_entry *> *> (data_);

  if (!decl_p)
    {
      /* We exclusively use decls to locate things.  Make sure there's
         no mismatch between the two specialization tables we keep.
         pt.c optimizes instantiation lookup using a complicated
         heuristic.  We don't attempt to replicate that algorithm, but
         observe its behaviour and reproduce it upon read back.  */

       gcc_checking_assert (DECL_ALIAS_TEMPLATE_P (entry->tmpl)
                           || TREE_CODE (entry->spec) == ENUMERAL_TYPE
                           || DECL_CLASS_TEMPLATE_P (entry->tmpl));

       /* Only alias templates can appear in both tables (and
          if they're in the type table they must also be in the decl table).  */
       gcc_checking_assert
         (!match_mergeable_specialization (true, entry, false)
          == (decl_p || !DECL_ALIAS_TEMPLATE_P (entry->tmpl)));
    }
  else if (VAR_OR_FUNCTION_DECL_P (entry->spec))
    gcc_checking_assert (!DECL_LOCAL_DECL_P (entry->spec));

  data->safe_push (entry);
}

/* Arbitrary stable comparison.  */

static int
specialization_cmp (const void *a_, const void *b_)
{
  const spec_entry *ea = *reinterpret_cast<const spec_entry *const *> (a_);
  const spec_entry *eb = *reinterpret_cast<const spec_entry *const *> (b_);

  if (ea == eb)
    return 0;

  tree a = ea->spec;
  tree b = eb->spec;
  if (TYPE_P (a))
    {
      a = TYPE_NAME (a);
      b = TYPE_NAME (b);
    }

  if (a == b)
    /* This can happen with friend specializations.  Just order by
       entry address.  See note in depset_cmp.  */
    return ea < eb ? -1 : +1;

  return DECL_UID (a) < DECL_UID (b) ? -1 : +1;
}

/* We add all kinds of specialializations.  Implicit specializations
   should only streamed and walked if they are reachable from
   elsewhere.  Hence the UNREACHED flag.  This is making the
   assumption that it is cheaper to reinstantiate them on demand
   elsewhere, rather than stream them in when we instantiate their
   general template.  Also, if we do stream them, we can only do that
   if they are not internal (which they can become if they themselves
   touch an internal entity?).  */

void
depset::hash::add_specializations (bool decl_p)
{
  vec<spec_entry *> data;
  data.create (100);
  walk_specializations (decl_p, specialization_add, &data);
  data.qsort (specialization_cmp);
  while (data.length ())
    {
      spec_entry *entry = data.pop ();
      tree spec = entry->spec;
      int use_tpl = 0;
      bool is_alias = false;
      bool is_friend = false;

      if (decl_p && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (entry->tmpl))
        /* A friend of a template.  This is keyed to the
           instantiation.  */
        is_friend = true;

      if (!decl_p && DECL_ALIAS_TEMPLATE_P (entry->tmpl))
        {
          spec = TYPE_NAME (spec);
          is_alias = true;
        }

      if (decl_p || is_alias)
        {
          if (tree ti = DECL_TEMPLATE_INFO (spec))
            {
              tree tmpl = TI_TEMPLATE (ti);

              use_tpl = DECL_USE_TEMPLATE (spec);
              if (spec == DECL_TEMPLATE_RESULT (tmpl))
                {
                  spec = tmpl;
                  gcc_checking_assert (DECL_USE_TEMPLATE (spec) == use_tpl);
                }
              else if (is_friend)
                {
                  if (TI_TEMPLATE (ti) != entry->tmpl
                      || !template_args_equal (TI_ARGS (ti), entry->tmpl))
                    goto template_friend;
                }
            }
          else
            {
            template_friend:;
              gcc_checking_assert (is_friend);
              /* This is a friend of a template class, but not the one
                 that generated entry->spec itself (i.e. it's an
                 equivalent clone).  We do not need to record
                 this.  */
              continue;
            }
        }
      else
        {
          if (TREE_CODE (spec) == ENUMERAL_TYPE)
            {
              tree ctx = DECL_CONTEXT (TYPE_NAME (spec));

              if (TYPE_P (ctx))
                use_tpl = CLASSTYPE_USE_TEMPLATE (ctx);
              else
                use_tpl = DECL_USE_TEMPLATE (ctx);
            }
          else
            use_tpl = CLASSTYPE_USE_TEMPLATE (spec);

          tree ti = TYPE_TEMPLATE_INFO (spec);
          tree tmpl = TI_TEMPLATE (ti);

          spec = TYPE_NAME (spec);
          if (spec == DECL_TEMPLATE_RESULT (tmpl))
            {
              spec = tmpl;
              use_tpl = DECL_USE_TEMPLATE (spec);
            }
        }

      bool needs_reaching = false;
      if (use_tpl == 1)
        /* Implicit instantiations only walked if we reach them.  */
        needs_reaching = true;
      else if (!DECL_LANG_SPECIFIC (spec)
               || !DECL_MODULE_PURVIEW_P (spec))
        /* Likewise, GMF explicit or partial specializations.  */
        needs_reaching = true;

#if false && CHECKING_P
      /* The instantiation isn't always on
         DECL_TEMPLATE_INSTANTIATIONS, */
      // FIXME: we probably need to remember this information?
      /* Verify the specialization is on the
         DECL_TEMPLATE_INSTANTIATIONS of the template.  */
      for (tree cons = DECL_TEMPLATE_INSTANTIATIONS (entry->tmpl);
           cons; cons = TREE_CHAIN (cons))
        if (TREE_VALUE (cons) == entry->spec)
          {
            gcc_assert (entry->args == TREE_PURPOSE (cons));
            goto have_spec;
          }
      gcc_unreachable ();
    have_spec:;
#endif

      depset *dep = make_dependency (spec, depset::EK_SPECIALIZATION);
      if (dep->is_special ())
        {
          /* An already located specialization, this must be the TYPE
             corresponding to an alias_decl we found in the decl
             table.  */
          spec_entry *other = reinterpret_cast <spec_entry *> (dep->deps[0]);
          gcc_checking_assert (!decl_p && is_alias && !dep->is_type_spec ());
          gcc_checking_assert (other->tmpl == entry->tmpl
                               && template_args_equal (other->args, entry->args)
                               && TREE_TYPE (other->spec) == entry->spec);
          dep->set_flag_bit<DB_ALIAS_SPEC_BIT> ();
        }
      else
        {
          gcc_checking_assert (decl_p || !is_alias);
          if (dep->get_entity_kind () == depset::EK_REDIRECT)
            dep = dep->deps[0];
          else if (dep->get_entity_kind () == depset::EK_SPECIALIZATION)
            {
              dep->set_special ();
              dep->deps.safe_push (reinterpret_cast<depset *> (entry));
              if (!decl_p)
                dep->set_flag_bit<DB_TYPE_SPEC_BIT> ();
            }

          if (needs_reaching)
            dep->set_flag_bit<DB_UNREACHED_BIT> ();
          if (is_friend)
            dep->set_flag_bit<DB_FRIEND_SPEC_BIT> ();
        }
    }
  data.release ();
}

/* Add a depset into the mergeable hash.  */

void
depset::hash::add_mergeable (depset *mergeable)
{
  gcc_checking_assert (is_key_order ());
  entity_kind ek = mergeable->get_entity_kind ();
  tree decl = mergeable->get_entity ();
  gcc_checking_assert (ek < EK_DIRECT_HWM);

  depset **slot = entity_slot (decl, true);
  gcc_checking_assert (!*slot);
  depset *dep = make_entity (decl, ek);
  *slot = dep;

  worklist.safe_push (dep);

  /* So we can locate the mergeable depset this depset refers to,
     mark the first dep.  */
  dep->set_special ();
  dep->deps.safe_push (mergeable);
}

/* Iteratively find dependencies.  During the walk we may find more
   entries on the same binding that need walking.  */

void
depset::hash::find_dependencies ()
{
  trees_out walker (NULL, NULL, *this);
  vec<depset *> unreached;
  unreached.create (worklist.length ());

  for (;;)
    {
      reached_unreached = false;
      while (worklist.length ())
        {
          depset *item = worklist.pop ();

          gcc_checking_assert (!item->is_binding ());
          if (item->is_unreached ())
            unreached.quick_push (item);
          else
            {
              current = item;
              tree decl = current->get_entity ();
              dump (is_key_order () ? dumper::MERGE : dumper::DEPEND)
                && dump ("Dependencies of %s %C:%N",
                         is_key_order () ? "key-order"
                         : current->entity_kind_name (), TREE_CODE (decl), decl);
              dump.indent ();
              walker.begin ();
              if (current->get_entity_kind () == EK_USING)
                walker.tree_node (OVL_FUNCTION (decl));
              else if (TREE_VISITED (decl))
                /* A global tree.  */;
              else if (TREE_CODE (decl) == NAMESPACE_DECL
                       && !DECL_NAMESPACE_ALIAS (decl))
                add_namespace_context (current, CP_DECL_CONTEXT (decl));
              else
                {
                  walker.mark_declaration (decl, current->has_defn ());

                  // FIXME: Perhaps p1815 makes this redundant? Or at
                  // least simplifies it.  Voldemort types are only
                  // ever emissable when containing (inline) function
                  // definition is emitted?
                  /* Turn the Sneakoscope on when depending the decl.  */
                  sneakoscope = true;
                  walker.decl_value (decl, current);
                  sneakoscope = false;
                  if (current->has_defn ())
                    walker.write_definition (decl);
                }
              walker.end ();

              if (!walker.is_key_order ()
                  && TREE_CODE (decl) == TEMPLATE_DECL
                  && !DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl))
                /* Mark all the explicit & partial specializations as
                   reachable.  */
                for (tree cons = DECL_TEMPLATE_INSTANTIATIONS (decl);
                     cons; cons = TREE_CHAIN (cons))
                  {
                    tree spec = TREE_VALUE (cons);
                    if (TYPE_P (spec))
                      spec = TYPE_NAME (spec);
                    int use_tpl;
                    node_template_info (spec, use_tpl);
                    if (use_tpl & 2)
                      {
                        depset *spec_dep = find_dependency (spec);
                        if (spec_dep->get_entity_kind () == EK_REDIRECT)
                          spec_dep = spec_dep->deps[0];
                        if (spec_dep->is_unreached ())
                          {
                            reached_unreached = true;
                            spec_dep->clear_flag_bit<DB_UNREACHED_BIT> ();
                            dump (dumper::DEPEND)
                              && dump ("Reaching unreached specialization"
                                       " %C:%N", TREE_CODE (spec), spec);
                          }
                      }
                  }

              dump.outdent ();
              current = NULL;
            }
        }

      if (!reached_unreached)
        break;

      /* It's possible the we reached the unreached before we
         processed it in the above loop, so we'll be doing this an
         extra time.  However, to avoid that we have to do some
         bit shuffling that also involves a scan of the list.
         Swings & roundabouts I guess.  */
      std::swap (worklist, unreached);
    }

  unreached.release ();
}

/* Compare two entries of a single binding.  TYPE_DECL before
   non-exported before exported.  */

static int
binding_cmp (const void *a_, const void *b_)
{
  depset *a = *(depset *const *)a_;
  depset *b = *(depset *const *)b_;

  tree a_ent = a->get_entity ();
  tree b_ent = b->get_entity ();
  gcc_checking_assert (a_ent != b_ent
                       && !a->is_binding ()
                       && !b->is_binding ());

  /* Implicit typedefs come first.  */
  bool a_implicit = DECL_IMPLICIT_TYPEDEF_P (a_ent);
  bool b_implicit = DECL_IMPLICIT_TYPEDEF_P (b_ent);
  if (a_implicit || b_implicit)
    {
      /* A binding with two implicit type decls?  That's unpossible!  */
      gcc_checking_assert (!(a_implicit && b_implicit));
      return a_implicit ? -1 : +1;  /* Implicit first.  */
    }

  /* Hidden before non-hidden.  */
  bool a_hidden = a->is_hidden ();
  bool b_hidden = b->is_hidden ();
  if (a_hidden != b_hidden)
    return a_hidden ? -1 : +1;

  bool a_using = a->get_entity_kind () == depset::EK_USING;
  bool a_export;
  if (a_using)
    {
      a_export = OVL_EXPORT_P (a_ent);
      a_ent = OVL_FUNCTION (a_ent);
    }
  else
    a_export = DECL_MODULE_EXPORT_P (TREE_CODE (a_ent) == CONST_DECL
                                     ? TYPE_NAME (TREE_TYPE (a_ent))
                                     : STRIP_TEMPLATE (a_ent));
  
  bool b_using = b->get_entity_kind () == depset::EK_USING;
  bool b_export;
  if (b_using)
    {
      b_export = OVL_EXPORT_P (b_ent);
      b_ent = OVL_FUNCTION (b_ent);
    }
  else
    b_export = DECL_MODULE_EXPORT_P (TREE_CODE (b_ent) == CONST_DECL
                                     ? TYPE_NAME (TREE_TYPE (b_ent))
                                     : STRIP_TEMPLATE (b_ent));

  /* Non-exports before exports.  */
  if (a_export != b_export)
    return a_export ? +1 : -1;

  /* At this point we don't care, but want a stable sort.  */

  if (a_using != b_using)
    /* using first.  */
    return a_using? -1 : +1;

  return DECL_UID (a_ent) < DECL_UID (b_ent) ? -1 : +1;
}

/* Sort the bindings, issue errors about bad internal refs.  */

bool
depset::hash::finalize_dependencies ()
{
  bool ok = true;
  depset::hash::iterator end (this->end ());
  for (depset::hash::iterator iter (begin ()); iter != end; ++iter)
    {
      depset *dep = *iter;
      if (dep->is_binding ())
        {
          /* Keep the containing namespace dep first.  */
          gcc_checking_assert (dep->deps.length () > 1
                               && (dep->deps[0]->get_entity_kind ()
                                   == EK_NAMESPACE)
                               && (dep->deps[0]->get_entity ()
                                   == dep->get_entity ()));
          if (dep->deps.length () > 2)
            gcc_qsort (&dep->deps[1], dep->deps.length () - 1,
                       sizeof (dep->deps[1]), binding_cmp);
        }
      else if (dep->refs_internal ())
        {
          for (unsigned ix = dep->deps.length (); ix--;)
            {
              depset *rdep = dep->deps[ix];
              if (rdep->is_internal ())
                {
                  // FIXME:QOI Better location information?  We're
                  // losing, so it doesn't matter about efficiency
                  tree decl = dep->get_entity ();
                  error_at (DECL_SOURCE_LOCATION (decl),
                            "%q#D references internal linkage entity %q#D",
                            decl, rdep->get_entity ());
                  break;
                }
            }
          ok = false;
        }
    }

  return ok;
}

/* Core of TARJAN's algorithm to find Strongly Connected Components
   within a graph.  See https://en.wikipedia.org/wiki/
   Tarjan%27s_strongly_connected_components_algorithm for details.

   We use depset::section as lowlink.  Completed nodes have
   depset::cluster containing the cluster number, with the top
   bit set.

   A useful property is that the output vector is a reverse
   topological sort of the resulting DAG.  In our case that means
   dependent SCCs are found before their dependers.  We make use of
   that property.  */

void
depset::tarjan::connect (depset *v)
{
  gcc_checking_assert (v->is_binding ()
                       || !(v->is_unreached () || v->is_import ()));

  v->cluster = v->section = ++index;
  stack.safe_push (v);

  /* Walk all our dependencies, ignore a first marked slot  */
  for (unsigned ix = v->is_special (); ix != v->deps.length (); ix++)
    {
      depset *dep = v->deps[ix];

      if (dep->is_binding () || !dep->is_import ())
        {
          unsigned lwm = dep->cluster;

          if (!dep->cluster)
            {
              /* A new node.  Connect it.  */
              connect (dep);
              lwm = dep->section;
            }

          if (dep->section && v->section > lwm)
            v->section = lwm;
        }
    }

  if (v->section == v->cluster)
    {
      /* Root of a new SCC.  Push all the members onto the result list. */
      unsigned num = v->cluster;
      depset *p;
      do
        {
          p = stack.pop ();
          p->cluster = num;
          p->section = 0;
          result.quick_push (p);
        }
      while (p != v);
    }
}

/* Compare two depsets.  The specific ordering is unimportant, we're
   just trying to get consistency.  */

static int
depset_cmp (const void *a_, const void *b_)
{
  depset *a = *(depset *const *)a_;
  depset *b = *(depset *const *)b_;

  depset::entity_kind a_kind = a->get_entity_kind ();
  depset::entity_kind b_kind = b->get_entity_kind ();

  if  (a_kind != b_kind)
    /* Different entity kinds, order by that.  */
    return a_kind < b_kind ? -1 : +1;
  
  tree a_decl = a->get_entity ();
  tree b_decl = b->get_entity ();
  if (a_kind == depset::EK_USING)
    {
      /* If one is a using, the other must be too.  */
      a_decl = OVL_FUNCTION (a_decl);
      b_decl = OVL_FUNCTION (b_decl);
    }

  if (a_decl != b_decl)
    /* Different entities, order by their UID.  */
    return DECL_UID (a_decl) < DECL_UID (b_decl) ? -1 : +1;

  if (a_kind == depset::EK_BINDING)
    {
      /* Both are bindings.  Order by identifier hash.  */
      gcc_checking_assert (a->get_name () != b->get_name ());
      return (IDENTIFIER_HASH_VALUE (a->get_name ())
              < IDENTIFIER_HASH_VALUE (b->get_name ())
              ? -1 : +1);
    }

  /* They are the same decl.  This can happen with two using decls
     pointing to the same target.  The best we can aim for is
     consistently telling qsort how to order them.  Hopefully we'll
     never have to debug a case that depends on this.  Oh, who am I
     kidding?  Good luck.  */
  gcc_checking_assert (a_kind == depset::EK_USING);

  /* Order by depset address.  Not the best, but it is something.  */
  return a < b ? -1 : +1;
}

/* Sort the clusters in SCC such that those that depend on one another
   are placed later.   */

// FIXME: I am not convinced this is needed and, if needed,
// sufficient.  We emit the decls in this order but that emission
// could walk into later decls (from the body of the decl, or default
// arg-like things).  Why doesn't that walk do the right thing?  And
// if it DTRT why do we need to sort here -- won't things naturally
// work?  I think part of the issue is that when we're going to refer
// to an entity by name, and that entity is in the same cluster as us,
// we need to actually walk that entity, if we've not already walked
// it.
static void
sort_cluster (depset::hash *original, depset *scc[], unsigned size)
{
  depset::hash table (size, original);

  dump.indent ();

  /* Place bindings last, usings before that.  It's not strictly
     necessary, but it does make things neater.  Says Mr OCD.  */
  unsigned bind_lwm = size;
  unsigned use_lwm = size;
  for (unsigned ix = 0; ix != use_lwm;)
    {
      depset *dep = scc[ix];
      switch (dep->get_entity_kind ())
        {
        case depset::EK_BINDING:
          /* Move to end.  No increment.  Notice this could be moving
             a using decl, which we'll then move again.  */
          if (--bind_lwm != ix)
            {
              scc[ix] = scc[bind_lwm];
              scc[bind_lwm] = dep;
            }
          if (use_lwm > bind_lwm)
            {
              use_lwm--;
              break;
            }
          /* We must have copied a using, so move it too.  */
          dep = scc[ix];
          gcc_checking_assert (dep->get_entity_kind () == depset::EK_USING);
          /* FALLTHROUGH  */

        case depset::EK_USING:
          if (--use_lwm != ix)
            {
              scc[ix] = scc[use_lwm];
              scc[use_lwm] = dep;
            }
          break;

        case depset::EK_DECL:
        case depset::EK_SPECIALIZATION:
        case depset::EK_PARTIAL:
          table.add_mergeable (dep);
          ix++;
          break;

        default:
          gcc_unreachable ();
        }
    }

  gcc_checking_assert (use_lwm <= bind_lwm);
  dump (dumper::MERGE) && dump ("Ordering %u/%u depsets", use_lwm, size);

  table.find_dependencies ();

  vec<depset *> order = table.connect ();
  gcc_checking_assert (order.length () == use_lwm);

  /* Now rewrite entries [0,lwm), in the dependency order we
     discovered.  Usually each entity is in its own cluster.  Rarely,
     we can get multi-entity clusters, in which case all but one must
     only be reached from within the cluster.  This happens for
     something like:

     template<typename T>
     auto Foo (const T &arg) -> TPL<decltype (arg)>;

     The instantiation of TPL will be in the specialization table, and
     refer to Foo via arg.  But we can only get to that specialization
     from Foo's declaration, so we only need to treat Foo as mergable
     (We'll do structural comparison of TPL<decltype (arg)>).

     Finding the single cluster entry dep is very tricky and
     expensive.  Let's just not do that.  It's harmless in this case
     anyway. */
  unsigned pos = 0;
  unsigned cluster = ~0u;
  for (unsigned ix = 0; ix != order.length (); ix++)
    {
      gcc_checking_assert (order[ix]->is_special ());
      depset *dep = order[ix]->deps[0];
      scc[pos++] = dep;
      dump (dumper::MERGE)
        && dump ("Mergeable %u is %N%s", ix, dep->get_entity (),
                 order[ix]->cluster == cluster ? " (tight)" : "");
      cluster = order[ix]->cluster;
    }

  gcc_checking_assert (pos == use_lwm);

  order.release ();
  dump (dumper::MERGE) && dump ("Ordered %u keys", pos);
  dump.outdent ();
}

/* Reduce graph to SCCS clusters.  SCCS will be populated with the
   depsets in dependency order.  Each depset's CLUSTER field contains
   its cluster number.  Each SCC has a unique cluster number, and are
   contiguous in SCCS. Cluster numbers are otherwise arbitrary.  */

vec<depset *>
depset::hash::connect ()
{
  tarjan connector (size ());
  vec<depset *> deps;
  deps.create (size ());
  iterator end (this->end ());
  for (iterator iter (begin ()); iter != end; ++iter)
    {
      depset *item = *iter;

      entity_kind kind = item->get_entity_kind ();
      if (kind == EK_BINDING
          || !(kind == EK_REDIRECT
               || item->is_unreached ()
               || item->is_import ()))
        deps.quick_push (item);
    }

  /* Iteration over the hash table is an unspecified ordering.  While
     that has advantages, it causes 2 problems.  Firstly repeatable
     builds are tricky.  Secondly creating testcases that check
     dependencies are correct by making sure a bad ordering would
     happen if that was wrong.  */
  deps.qsort (depset_cmp);

  while (deps.length ())
    {
      depset *v = deps.pop ();
      dump (dumper::CLUSTER) &&
        (v->is_binding ()
         ? dump ("Connecting binding %P", v->get_entity (), v->get_name ())
         : dump ("Connecting %s %s %C:%N",
                 is_key_order () ? "key-order"
                 : !v->has_defn () ? "declaration" : "definition",
                 v->entity_kind_name (), TREE_CODE (v->get_entity ()),
                 v->get_entity ()));
      if (!v->cluster)
        connector.connect (v);
    }

  deps.release ();
  return connector.result;
}

/* Load the entities referred to by this pendset.  */

static bool
pendset_lazy_load (pendset *pendings, bool specializations_p)
{
  bool ok = true;

  for (unsigned ix = 0; ok && ix != pendings->num; ix++)
    {
      unsigned index = pendings->values[ix];
      if (index & ~(~0u >> 1))
        {
          /* An indirection.  */
          if (specializations_p)
            index = ~index;
          pendset *other = pending_table->get (index, true);
          if (!pendset_lazy_load (other, specializations_p))
            ok = false;
        }
      else
        {
          module_state *module = import_entity_module (index);
          binding_slot *slot = &(*entity_ary)[index];
          if (!slot->is_lazy ())
            dump () && dump ("Specialiation %M[%u] already loaded",
                             module, index - module->entity_lwm);
          else if (!module->lazy_load (index - module->entity_lwm, slot))
            ok = false;
        }
    }

  /* We own set, so delete it now.  */
  delete pendings;

  return ok;
}

/* Initialize location spans.  */

void
loc_spans::init (const line_maps *lmaps, const line_map_ordinary *map)
{
  gcc_checking_assert (!init_p ());
  spans = new vec<span> ();
  spans->reserve (20);

  span interval;
  interval.ordinary.first = 0;
  interval.macro.second = MAX_LOCATION_T + 1;
  interval.ordinary_delta = interval.macro_delta = 0;

  /* A span for reserved fixed locs.  */
  interval.ordinary.second
    = MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (line_table, 0));
  interval.macro.first = interval.macro.second;
  dump (dumper::LOCATION)
    && dump ("Fixed span %u ordinary:[%u,%u) macro:[%u,%u)", spans->length (),
             interval.ordinary.first, interval.ordinary.second,
             interval.macro.first, interval.macro.second);
  spans->quick_push (interval);

  /* A span for command line & forced headers.  */
  interval.ordinary.first = interval.ordinary.second;
  interval.macro.second = interval.macro.first;
  if (map)
    {
      interval.ordinary.second = map->start_location;
      interval.macro.first = LINEMAPS_MACRO_LOWEST_LOCATION (lmaps);
    }
  dump (dumper::LOCATION)
    && dump ("Pre span %u ordinary:[%u,%u) macro:[%u,%u)", spans->length (),
             interval.ordinary.first, interval.ordinary.second,
             interval.macro.first, interval.macro.second);
  spans->quick_push (interval);
  
  /* Start an interval for the main file.  */
  interval.ordinary.first = interval.ordinary.second;
  interval.macro.second = interval.macro.first;
  dump (dumper::LOCATION)
    && dump ("Main span %u ordinary:[%u,*) macro:[*,%u)", spans->length (),
             interval.ordinary.first, interval.macro.second);
  spans->quick_push (interval);
}

/* Reopen the span, if we want the about-to-be-inserted set of maps to
   be propagated in our own location table.  I.e. we are the primary
   interface and we're importing a partition.  */

bool
loc_spans::maybe_propagate (module_state *import,
                            location_t loc = UNKNOWN_LOCATION)
{
  bool opened = (module_interface_p () && !module_partition_p ()
                 && import->is_partition ());
  if (opened)
    open (loc);
  return opened;
}

/* Open a new linemap interval.  The just-created ordinary map is the
   first map of the interval.  */

void
loc_spans::open (location_t hwm = UNKNOWN_LOCATION)
{
  if (hwm == UNKNOWN_LOCATION)
    hwm = MAP_START_LOCATION (LINEMAPS_LAST_ORDINARY_MAP (line_table));

  span interval;
  interval.ordinary.first = interval.ordinary.second = hwm;
  interval.macro.first = interval.macro.second
    = LINEMAPS_MACRO_LOWEST_LOCATION (line_table);
  interval.ordinary_delta = interval.macro_delta = 0;
  dump (dumper::LOCATION)
    && dump ("Opening span %u ordinary:[%u,... macro:...,%u)",
             spans->length (), interval.ordinary.first,
             interval.macro.second);
  spans->safe_push (interval);
}

/* Close out the current linemap interval.  The last maps are within
   the interval.  */

void
loc_spans::close ()
{
  span &interval = spans->last ();

  interval.ordinary.second
    = ((line_table->highest_location + (1 << line_table->default_range_bits))
       & ~((1u << line_table->default_range_bits) - 1));
  interval.macro.first = LINEMAPS_MACRO_LOWEST_LOCATION (line_table);
  dump (dumper::LOCATION)
    && dump ("Closing span %u ordinary:[%u,%u) macro:[%u,%u)",
             spans->length () - 1,
             interval.ordinary.first,interval.ordinary.second,
             interval.macro.first, interval.macro.second);
}

/* Given an ordinary location LOC, return the lmap_interval it resides
   in.  NULL if it is not in an interval.  */

const loc_spans::span *
loc_spans::ordinary (location_t loc)
{
  unsigned len = spans->length ();
  unsigned pos = 0;
  while (len)
    {
      unsigned half = len / 2;
      const span &probe = (*spans)[pos + half];
      if (loc < probe.ordinary.first)
        len = half;
      else if (loc < probe.ordinary.second)
        return &probe;
      else
        {
          pos += half + 1;
          len = len - (half + 1);
        }
    }
  return NULL;
}

/* Likewise, given a macro location LOC, return the lmap interval it
   resides in.   */

const loc_spans::span *
loc_spans::macro (location_t loc)
{
  unsigned len = spans->length ();
  unsigned pos = 0;
  while (len)
    {
      unsigned half = len / 2;
      const span &probe = (*spans)[pos + half];
      if (loc >= probe.macro.second)
        len = half;
      else if (loc >= probe.macro.first)
        return &probe;
      else
        {
          pos += half + 1;
          len = len - (half + 1);
        }
    }
  return NULL;
}

/* Return the ordinary location closest to FROM.  */

static location_t
ordinary_loc_of (line_maps *lmaps, location_t from)
{
  while (!IS_ORDINARY_LOC (from))
    {
      if (IS_ADHOC_LOC (from))
        from = get_location_from_adhoc_loc (lmaps, from);
      if (IS_MACRO_LOC (from))
        {
          /* Find the ordinary location nearest FROM.  */
          const line_map *map = linemap_lookup (lmaps, from);
          const line_map_macro *mac_map = linemap_check_macro (map);
          from = MACRO_MAP_EXPANSION_POINT_LOCATION (mac_map);
        }
    }
  return from;
}

static module_state **
get_module_slot (tree name, module_state *parent, bool partition, bool insert)
{
  module_state_hash::compare_type ct (name, uintptr_t (parent) | partition);
  hashval_t hv = module_state_hash::hash (ct);

  return modules_hash->find_slot_with_hash (ct, hv, insert ? INSERT : NO_INSERT);
}

static module_state *
get_primary (module_state *parent)
{
  while (parent->is_partition ())
    parent = parent->parent;

  if (!parent->name)
    // Implementation unit has null name
    parent = parent->parent;

  return parent;
}

/* Find or create module NAME & PARENT in the hash table.  */

module_state *
get_module (tree name, module_state *parent, bool partition)
{
  if (partition)
    {
      if (!parent)
        parent = get_primary ((*modules)[0]);

      if (!parent->is_partition () && !parent->flatname)
        parent->set_flatname ();
    }

  module_state **slot = get_module_slot (name, parent, partition, true);
  module_state *state = *slot;
  if (!state)
    {
      state = (new (ggc_alloc<module_state> ())
               module_state (name, parent, partition));
      *slot = state;
    }
  return state;
}

/* Process string name PTR into a module_state.  */

static module_state *
get_module (const char *ptr)
{
  if (ptr[0] == '.' ? IS_DIR_SEPARATOR (ptr[1]) : IS_ABSOLUTE_PATH (ptr))
    /* A header name.  */
    return get_module (build_string (strlen (ptr), ptr));

  bool partition = false;
  module_state *mod = NULL;

  for (const char *probe = ptr;; probe++)
    if (!*probe || *probe == '.' || *probe == ':')
      {
        if (probe == ptr)
          return NULL;

        mod = get_module (get_identifier_with_length (ptr, probe - ptr),
                          mod, partition);
        ptr = probe;
        if (*ptr == ':')
          {
            if (partition)
              return NULL;
            partition = true;
          }

        if (!*ptr++)
          break;
      }
    else if (!(ISALPHA (*probe) || *probe == '_'
               || (probe != ptr && ISDIGIT (*probe))))
      return NULL;

  return mod;
}

/* Create a new mapper connecting to OPTION.  */

module_client *
make_mapper (location_t loc)
{
  timevar_start (TV_MODULE_MAPPER);
  const char *option = module_mapper_name;
  if (!option)
    option = getenv ("CXX_MODULE_MAPPER");

  mapper = module_client::open_module_client
    (loc, option, &set_cmi_repo,
     (save_decoded_options[0].opt_index == OPT_SPECIAL_program_name)
     && save_decoded_options[0].arg != progname
     ? save_decoded_options[0].arg : nullptr);

  timevar_stop (TV_MODULE_MAPPER);

  return mapper;
}

/* If THIS is the current purview, issue an import error and return false.  */

bool
module_state::check_not_purview (location_t from)
{
  module_state *imp = (*modules)[0];
  if (imp && !imp->name)
    imp = imp->parent;
  if (imp == this)
    {
      /* Cannot import the current module.  */
      error_at (from, "cannot import module in its own purview");
      inform (loc, "module %qs declared here", get_flatname ());
      return false;
    }
  return true;
}

/* Module name substitutions.  */
static vec<module_state *,va_heap> substs;

void
module_state::mangle (bool include_partition)
{
  if (subst)
    mangle_module_substitution (subst - 1);
  else
    {
      if (parent)
        parent->mangle (include_partition);
      if (include_partition || !is_partition ())
        {
          char p = 0;
          // Partitions are significant for global initializer functions
          if (is_partition () && !parent->is_partition ())
            p = 'P';
          substs.safe_push (this);
          subst = substs.length ();
          mangle_identifier (p, name);
        }
    }
}

void
mangle_module (int mod, bool include_partition)
{
  module_state *imp = (*modules)[mod];

  if (!imp->name)
    /* Set when importing the primary module interface.  */
    imp = imp->parent;

  imp->mangle (include_partition);
}

/* Clean up substitutions.  */
void
mangle_module_fini ()
{
  while (substs.length ())
    substs.pop ()->subst = 0;
}

/* Announce WHAT about the module.  */

void
module_state::announce (const char *what) const
{
  if (noisy_p ())
    {
      fprintf (stderr, " %s:%s", what, get_flatname ());
      fflush (stderr);
    }
}

/* A human-readable README section.  The contents of this section to
   not contribute to the CRC, so the contents can change per
   compilation.  That allows us to embed CWD, hostname, build time and
   what not.  It is a STRTAB that may be extracted with:
     readelf -pgnu.c++.README $(module).gcm */

void
module_state::write_readme (elf_out *to, cpp_reader *reader,
                            const char *dialect, unsigned extensions)
{
  bytes_out readme (to);

  readme.begin (false);

  readme.printf ("GNU C++ %smodule%s%s",
                 is_header () ? "header " : is_partition () ? "" : "primary ",
                 is_header () ? ""
                 : is_interface () ? " interface" : " implementation",
                 is_partition () ? " partition" : "");

  /* Compiler's version.  */
  readme.printf ("compiler: %s", version_string);

  /* Module format version.  */
  verstr_t string;
  version2string (MODULE_VERSION, string);
  readme.printf ("version: %s", string);

  /* Module information.  */
  readme.printf ("module: %s", get_flatname ());
  readme.printf ("source: %s", main_input_filename);
  readme.printf ("dialect: %s", dialect);
  if (extensions)
    readme.printf ("extensions: %s",
                   extensions & SE_OPENMP ? "-fopenmp" : "");

  /* The following fields could be expected to change between
     otherwise identical compilations.  Consider a distributed build
     system.  We should have a way of overriding that.  */
  if (char *cwd = getcwd (NULL, 0))
    {
      readme.printf ("cwd: %s", cwd);
      free (cwd);
    }
  readme.printf ("repository: %s", cmi_repo ? cmi_repo : ".");
#if NETWORKING
  {
    char hostname[64];
    if (!gethostname (hostname, sizeof (hostname)))
      readme.printf ("host: %s", hostname);
  }
#endif
  {
    /* This of course will change!  */
    time_t stampy;
    auto kind = cpp_get_date (reader, &stampy);
    if (kind != CPP_time_kind::UNKNOWN)
      {
        struct tm *time;

        time = gmtime (&stampy);
        readme.print_time ("build", time, "UTC");

        if (kind == CPP_time_kind::DYNAMIC)
          {
            time = localtime (&stampy);
            readme.print_time ("local", time,
#if defined (__USE_MISC) || defined (__USE_BSD) /* Is there a better way?  */
                               time->tm_zone
#else
                               ""
#endif
                               );
          }
      }
  }

  /* Its direct imports.  */
  for (unsigned ix = 1; ix < modules->length (); ix++)
    {
      module_state *state = (*modules)[ix];

      if (state->is_direct ())
        readme.printf ("%s: %s %s", state->exported_p ? "export" : "import",
                       state->get_flatname (), state->filename);
    }

  readme.end (to, to->name (MOD_SNAME_PFX ".README"), NULL);
}

/* Sort environment var names in reverse order.  */

static int
env_var_cmp (const void *a_, const void *b_)
{
  const unsigned char *a = *(const unsigned char *const *)a_;
  const unsigned char *b = *(const unsigned char *const *)b_;

  for (unsigned ix = 0; ; ix++)
    {
      bool a_end = !a[ix] || a[ix] == '=';
      if (a[ix] == b[ix])
        {
          if (a_end)
            break;
        }
      else
        {
          bool b_end = !b[ix] || b[ix] == '=';

          if (!a_end && !b_end)
            return a[ix] < b[ix] ? +1 : -1;
          if (a_end && b_end)
            break;
          return a_end ? +1 : -1;
        }
    }

  return 0;
}

/* Write the environment. It is a STRTAB that may be extracted with:
     readelf -pgnu.c++.ENV $(module).gcm */

void
module_state::write_env (elf_out *to)
{
  vec<const char *> vars;
  vars.create (20);

  extern char **environ;
  while (const char *var = environ[vars.length ()])
    vars.safe_push (var);
  vars.qsort (env_var_cmp);

  bytes_out env (to);
  env.begin (false);
  while (vars.length ())
    env.printf ("%s", vars.pop ());
  env.end (to, to->name (MOD_SNAME_PFX ".ENV"), NULL);

  vars.release ();
}

/* Write the direct or indirect imports.
   u:N
   {
     u:index
     s:name
     u32:crc
     s:filename (direct)
     u:exported (direct)
   } imports[N]
 */

void
module_state::write_imports (bytes_out &sec, bool direct)
{
  unsigned count = 0;

  for (unsigned ix = 1; ix < modules->length (); ix++)
    {
      module_state *imp = (*modules)[ix];

      if (imp->remap && imp->is_direct () == direct)
        count++;
    }

  gcc_assert (!direct || count);

  sec.u (count);
  for (unsigned ix = 1; ix < modules->length (); ix++)
    {
      module_state *imp = (*modules)[ix];

      if (imp->remap && imp->is_direct () == direct)
        {
          dump () && dump ("Writing %simport:%u->%u %M (crc=%x)",
                           !direct ? "indirect "
                           : imp->exported_p ? "exported " : "",
                           ix, imp->remap, imp, imp->crc);
          sec.u (imp->remap);
          sec.str (imp->get_flatname ());
          sec.u32 (imp->crc);
          if (direct)
            {
              write_location (sec, imp->imported_from ());
              sec.str (imp->filename);
              int exportedness = 0;
              if (imp->exported_p)
                exportedness = +1;
              else if (!imp->is_purview_direct ())
                exportedness = -1;
              sec.i (exportedness);
            }
        }
    }
}

/* READER, LMAPS  != NULL == direct imports,
   == NUL == indirect imports.  */

unsigned
module_state::read_imports (bytes_in &sec, cpp_reader *reader, line_maps *lmaps)
{
  unsigned count = sec.u ();
  unsigned loaded = 0;

  while (count--)
    {
      unsigned ix = sec.u ();
      if (ix >= slurp->remap->length () || !ix || (*slurp->remap)[ix])
        {
          sec.set_overrun ();
          break;
        }

      const char *name = sec.str (NULL);
      module_state *imp = get_module (name);
      unsigned crc = sec.u32 ();
      int exportedness = 0;

      /* If the import is a partition, it must be the same primary
         module as this TU.  */
      if (imp && imp->is_partition () &&
          (!named_module_p ()
           || (get_primary ((*modules)[0]) != get_primary (imp))))
        imp = NULL;

      if (!imp)
        sec.set_overrun ();
      if (sec.get_overrun ())
        break;

      if (lmaps)
        {
          /* A direct import, maybe load it.  */
          location_t floc = read_location (sec);
          const char *fname = sec.str (NULL);
          exportedness = sec.i ();

          if (sec.get_overrun ())
            break;

          if (!imp->check_not_purview (loc))
            continue;

          if (imp->loadedness == ML_NONE)
            {
              imp->loc = floc;
              imp->crc = crc;
              if (!imp->get_flatname ())
                imp->set_flatname ();

              unsigned n = dump.push (imp);

              if (!imp->filename && fname)
                imp->filename = xstrdup (fname);

              if (imp->is_partition ())
                dump () && dump ("Importing elided partition %M", imp);

              if (!imp->do_import (reader, false))
                imp = NULL;
              dump.pop (n);
              if (!imp)
                continue;
            }

          if (is_partition ())
            {
              if (!imp->is_direct ())
                imp->directness = MD_PARTITION_DIRECT;
              if (exportedness > 0)
                imp->exported_p = true;
            }
        }
      else
        {
          /* An indirect import, find it, it should already be here.  */
          if (imp->loadedness == ML_NONE)
            {
              error_at (loc, "indirect import %qs is not already loaded", name);
              continue;
            }
        }

      if (imp->crc != crc)
        error_at (loc, "import %qs has CRC mismatch", imp->get_flatname ());

      (*slurp->remap)[ix] = (imp->mod << 1) | (lmaps != NULL);

      if (lmaps && exportedness >= 0)
        set_import (imp, bool (exportedness));
      dump () && dump ("Found %simport:%u %M->%u", !lmaps ? "indirect "
                       : exportedness > 0 ? "exported "
                       : exportedness < 0 ? "gmf" : "", ix, imp,
                       imp->mod);
      loaded++;
    }

  return loaded;
}

/* Write the import table to MOD_SNAME_PFX.imp.  */

void
module_state::write_imports (elf_out *to, unsigned *crc_ptr)
{
  dump () && dump ("Writing imports");
  dump.indent ();

  bytes_out sec (to);
  sec.begin ();

  write_imports (sec, true);
  write_imports (sec, false);

  sec.end (to, to->name (MOD_SNAME_PFX ".imp"), crc_ptr);
  dump.outdent ();
}

bool
module_state::read_imports (cpp_reader *reader, line_maps *lmaps)
{
  bytes_in sec;

  if (!sec.begin (loc, from (), MOD_SNAME_PFX ".imp"))
    return false;

  dump () && dump ("Reading %u imports", slurp->remap->length () - 1);
  dump.indent ();

  /* Read the imports.  */
  unsigned direct = read_imports (sec, reader, lmaps);
  unsigned indirect = read_imports (sec, NULL, NULL);
  if (direct + indirect + 1 != slurp->remap->length ())
    from ()->set_error (elf::E_BAD_IMPORT);

  dump.outdent ();
  if (!sec.end (from ()))
    return false;
  return true;
}

/* We're the primary module interface, but have partitions.  Document
   them so that non-partition module implementation units know which
   have already been loaded.  */

void
module_state::write_partitions (elf_out *to, unsigned count, unsigned *crc_ptr)
{
  dump () && dump ("Writing %u elided partitions", count);
  dump.indent ();

  bytes_out sec (to);
  sec.begin ();

  for (unsigned ix = 1; ix != modules->length (); ix++)
    {
      module_state *imp = (*modules)[ix];
      if (imp->is_partition ())
        {
          dump () && dump ("Writing elided partition %M (crc=%x)",
                           imp, imp->crc);
          sec.str (imp->get_flatname ());
          sec.u32 (imp->crc);
          write_location (sec, imp->is_direct ()
                          ? imp->imported_from () : UNKNOWN_LOCATION);
          sec.str (imp->filename);
        }
    }

  sec.end (to, to->name (MOD_SNAME_PFX ".prt"), crc_ptr);
  dump.outdent ();
}

bool
module_state::read_partitions (unsigned count)
{
  bytes_in sec;
  if (!sec.begin (loc, from (), MOD_SNAME_PFX ".prt"))
    return false;

  dump () && dump ("Reading %u elided partitions", count);
  dump.indent ();

  while (count--)
    {
      const char *name = sec.str (NULL);
      unsigned crc = sec.u32 ();
      location_t floc = read_location (sec);
      const char *fname = sec.str (NULL);

      if (sec.get_overrun ())
        break;

      dump () && dump ("Reading elided partition %s (crc=%x)", name, crc);

      module_state *imp = get_module (name);
      if (!imp || !imp->is_partition () || imp->is_rooted ()
          || get_primary (imp) != this)
        {
          sec.set_overrun ();
          break;
        }

      /* Attach the partition without loading it.  We'll have to load
         for real if it's indirectly imported.  */
      imp->loc = floc;
      imp->crc = crc;
      if (!imp->filename && fname[0])
        imp->filename = xstrdup (fname);
    }

  dump.outdent ();
  if (!sec.end (from ()))
    return false;
  return true;
}

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

/* Data for config reading and writing.  */
struct module_state_config {
  const char *dialect_str;
  unsigned num_imports;
  unsigned num_partitions;
  unsigned ordinary_locs;
  unsigned macro_locs;
  unsigned ordinary_loc_align;

public:
  module_state_config ()
    :dialect_str (get_dialect ()),
     num_imports (0), num_partitions (0),
     ordinary_locs (0), macro_locs (0), ordinary_loc_align (0)
  {
  }

  static void release ()
  {
    XDELETEVEC (dialect);
    dialect = NULL;
  }

private:
  static const char *get_dialect ();
  static char *dialect;
};

char *module_state_config::dialect;

/* Generate a string of the significant compilation options.
   Generally assume the user knows what they're doing, in the same way
   that object files can be mixed.  */

const char *
module_state_config::get_dialect ()
{
  if (!dialect)
    dialect = concat (get_cxx_dialect_name (cxx_dialect),
                      /* C++ implies these, only show if disabled.  */
                      flag_exceptions ? "" : "/no-exceptions",
                      flag_rtti ? "" : "/no-rtti",
                      flag_new_inheriting_ctors ? "" : "/old-inheriting-ctors",
                      /* C++ 20 implies concepts.  */
                      cxx_dialect < cxx20 && flag_concepts ? "/concepts" : "",
                      flag_coroutines ? "/coroutines" : "",
                      flag_module_implicit_inline ? "/implicit-inline" : "",
                      NULL);

  return dialect;
}

/* Contents of a cluster.  */
enum cluster_tag {
  ct_decl,      /* A decl.  */
  ct_defn,      /* A definition.  */
  ct_bind,      /* A binding.  */
  ct_hwm
};

/* Binding modifiers.  */
enum ct_bind_flags
{
  cbf_export = 0x1,     /* An exported decl.  */
  cbf_hidden = 0x2,     /* A hidden (friend) decl.  */
  cbf_using = 0x4,      /* A using decl.  */
  cbf_wrapped = 0x8,    /* ... that is wrapped.  */
};

/* Write the cluster of depsets in SCC[0-SIZE).  */

unsigned
module_state::write_cluster (elf_out *to, depset *scc[], unsigned size,
                             depset::hash &table, unsigned *counts,
                             unsigned *crc_ptr)
{
  dump () && dump ("Writing section:%u %u depsets", table.section, size);
  dump.indent ();

  trees_out sec (to, this, table, table.section);
  sec.begin ();

  /* Determine entity numbers, mark for writing.   */
  dump (dumper::CLUSTER) && dump ("Cluster members:") && (dump.indent (), true);
  for (unsigned ix = 0; ix != size; ix++)
    {
      depset *b = scc[ix];

      switch (b->get_entity_kind ())
        {
        default:
          gcc_unreachable ();

        case depset::EK_BINDING:
          dump (dumper::CLUSTER)
            && dump ("[%u]=%s %P", ix, b->entity_kind_name (),
                     b->get_entity (), b->get_name ());
          for (unsigned jx = b->deps.length (); jx--;)
            {
              depset *dep = b->deps[jx];
              if (jx)
                gcc_checking_assert (dep->get_entity_kind () == depset::EK_USING
                                     || TREE_VISITED (dep->get_entity ()));
              else
                gcc_checking_assert (dep->get_entity_kind ()
                                     == depset::EK_NAMESPACE
                                     && dep->get_entity () == b->get_entity ());
            }
          break;

        case depset::EK_DECL:
          if (b->is_member ())
            {
            case depset::EK_SPECIALIZATION:  /* Yowzer! */
            case depset::EK_PARTIAL:  /* Hey, let's do it again! */
              counts[MSC_pendings]++;
            }
          b->cluster = counts[MSC_entities]++;
          sec.mark_declaration (b->get_entity (), b->has_defn ());
          /* FALLTHROUGH  */

        case depset::EK_USING:
          gcc_checking_assert (!b->is_import ()
                               && !b->is_unreached ());
          dump (dumper::CLUSTER)
            && dump ("[%u]=%s %s %N", ix, b->entity_kind_name (),
                     b->has_defn () ? "definition" : "declaration",
                     b->get_entity ());
          break;
        }
    }
  dump (dumper::CLUSTER) && (dump.outdent (), true);

  /* Ensure every imported decl is referenced before we start
     streaming.  This ensures that we never encounter the
     situation where this cluster instantiates some implicit
     member that importing some other decl causes to be
     instantiated.  */
  sec.set_importing (+1);
  for (unsigned ix = 0; ix != size; ix++)
    {
      depset *b = scc[ix];
      for (unsigned jx = (b->get_entity_kind () == depset::EK_BINDING
                          || b->is_special ()) ? 1 : 0;
           jx != b->deps.length (); jx++)
        {
          depset *dep = b->deps[jx];

          if (!dep->is_binding ()
              && dep->is_import () && !TREE_VISITED (dep->get_entity ()))
            {
              tree import = dep->get_entity ();

              sec.tree_node (import);
              dump (dumper::CLUSTER) && dump ("Seeded import %N", import);
            }
        }
    }
  sec.tree_node (NULL_TREE);
  /* We're done importing now.  */
  sec.set_importing (-1);

  /* Write non-definitions.  */
  for (unsigned ix = 0; ix != size; ix++)
    {
      depset *b = scc[ix];
      tree decl = b->get_entity ();
      switch (b->get_entity_kind ())
        {
        default:
          gcc_unreachable ();
          break;

        case depset::EK_BINDING:
          {
            gcc_assert (TREE_CODE (decl) == NAMESPACE_DECL);
            dump () && dump ("Depset:%u binding %C:%P", ix, TREE_CODE (decl),
                             decl, b->get_name ());
            sec.u (ct_bind);
            sec.tree_node (decl);
            sec.tree_node (b->get_name ());

            /* Write in reverse order, so reading will see the exports
               first, thus building the overload chain will be
               optimized.  */
            for (unsigned jx = b->deps.length (); --jx;)
              {
                depset *dep = b->deps[jx];
                tree bound = dep->get_entity ();
                unsigned flags = 0;
                if (dep->get_entity_kind () == depset::EK_USING)
                  {
                    tree ovl = bound;
                    bound = OVL_FUNCTION (bound);
                    if (!(TREE_CODE (bound) == CONST_DECL
                          && UNSCOPED_ENUM_P (TREE_TYPE (bound))
                          && decl == TYPE_NAME (TREE_TYPE (bound))))
                      {
                        /* An unscope enumerator in its enumeration's
                           scope is not a using.  */
                        flags |= cbf_using;
                        if (OVL_USING_P (ovl))
                          flags |= cbf_wrapped;
                      }
                    if (OVL_EXPORT_P (ovl))
                      flags |= cbf_export;
                  }
                else
                  {
                    /* An implicit typedef must be at one.  */
                    gcc_assert (!DECL_IMPLICIT_TYPEDEF_P (bound) || jx == 1);
                    if (dep->is_hidden ())
                      flags |= cbf_hidden;
                    else if (DECL_MODULE_EXPORT_P (STRIP_TEMPLATE (bound)))
                      flags |= cbf_export;
                  }

                gcc_checking_assert (DECL_P (bound));

                sec.i (flags);
                sec.tree_node (bound);
              }

            /* Terminate the list.  */
            sec.i (-1);
          }
          break;

        case depset::EK_USING:
          dump () && dump ("Depset:%u %s %C:%N", ix, b->entity_kind_name (),
                           TREE_CODE (decl), decl);
          break;

        case depset::EK_SPECIALIZATION:
        case depset::EK_PARTIAL:
        case depset::EK_DECL:
          dump () && dump ("Depset:%u %s entity:%u %C:%N", ix,
                           b->entity_kind_name (), b->cluster,
                           TREE_CODE (decl), decl);

          sec.u (ct_decl);
          sec.tree_node (decl);

          dump () && dump ("Wrote declaration entity:%u %C:%N",
                           b->cluster, TREE_CODE (decl), decl);
          break;
        }
    }

  depset *namer = NULL;

  /* Write out definitions  */
  for (unsigned ix = 0; ix != size; ix++)
    {
      depset *b = scc[ix];
      tree decl = b->get_entity ();
      switch (b->get_entity_kind ())
        {
        default:
          break;

        case depset::EK_SPECIALIZATION:
        case depset::EK_PARTIAL:
        case depset::EK_DECL:
          if (!namer)
            namer = b;

          if (b->has_defn ())
            {
              sec.u (ct_defn);
              sec.tree_node (decl);
              dump () && dump ("Writing definition %N", decl);
              sec.write_definition (decl);

              if (!namer->has_defn ())
                namer = b;
            }
          break;
        }
    }

  /* We don't find the section by name.  Use depset's decl's name for
     human friendliness.  */
  unsigned name = 0;
  tree naming_decl = NULL_TREE;
  if (namer)
    {
      naming_decl = namer->get_entity ();
      if (namer->get_entity_kind () == depset::EK_USING)
        /* This unfortunately names the section from the target of the
           using decl.  But the name is only a guide, so Do Not Care.  */
        naming_decl = OVL_FUNCTION (naming_decl);
      if (DECL_IMPLICIT_TYPEDEF_P (naming_decl))
        /* Lose any anonymousness.  */
        naming_decl = TYPE_NAME (TREE_TYPE (naming_decl));
      name = to->qualified_name (naming_decl, namer->has_defn ());
    }

  unsigned bytes = sec.pos;
  unsigned snum = sec.end (to, name, crc_ptr);

  for (unsigned ix = size; ix--;)
    gcc_checking_assert (scc[ix]->section == snum);

  dump.outdent ();
  dump () && dump ("Wrote section:%u named-by:%N", table.section, naming_decl);

  return bytes;
}

/* Read a cluster from section SNUM.  */

bool
module_state::read_cluster (unsigned snum)
{
  trees_in sec (this);

  if (!sec.begin (loc, from (), snum))
    return false;

  dump () && dump ("Reading section:%u", snum);
  dump.indent ();

  /* We care about structural equality.  */
  comparing_specializations++;

  /* First seed the imports.  */
  while (tree import = sec.tree_node ())
    dump (dumper::CLUSTER) && dump ("Seeded import %N", import);

  while (!sec.get_overrun () && sec.more_p ())
    {
      unsigned ct = sec.u ();
      switch (ct)
        {
        default:
          sec.set_overrun ();
          break;

        case ct_bind:
          /* A set of namespace bindings.  */
          {
            tree ns = sec.tree_node ();
            tree name = sec.tree_node ();
            tree decls = NULL_TREE;
            tree visible = NULL_TREE;
            tree type = NULL_TREE;
            bool dedup = false;

            /* We rely on the bindings being in the reverse order of
               the resulting overload set.  */
            for (;;)
              {
                int flags = sec.i ();
                if (flags < 0)
                  break;

                if ((flags & cbf_hidden)
                    && (flags & (cbf_using | cbf_export)))
                  sec.set_overrun ();

                tree decl = sec.tree_node ();
                if (sec.get_overrun ())
                  break;

                if (decls && TREE_CODE (decl) == TYPE_DECL)
                  {
                    /* Stat hack.  */
                    if (type || !DECL_IMPLICIT_TYPEDEF_P (decl))
                      sec.set_overrun ();
                    type = decl;
                  }
                else
                  {
                    if (decls
                        || (flags & (cbf_hidden | cbf_wrapped))
                        || DECL_FUNCTION_TEMPLATE_P (decl))
                      {
                        decls = ovl_make (decl, decls);
                        if (flags & cbf_using)
                          {
                            dedup = true;
                            OVL_USING_P (decls) = true;
                            if (flags & cbf_export)
                              OVL_EXPORT_P (decls) = true;
                          }

                        if (flags & cbf_hidden)
                          OVL_HIDDEN_P (decls) = true;
                        else if (dedup)
                          OVL_DEDUP_P (decls) = true;
                      }
                    else
                      decls = decl;

                    if (flags & cbf_export
                        || (!(flags & cbf_hidden)
                            && (is_module () || is_partition ())))
                      visible = decls;
                  }
              }

            if (!decls)
              sec.set_overrun ();

            if (sec.get_overrun ())
              break; /* Bail.  */

            dump () && dump ("Binding of %P", ns, name);
            if (!set_module_binding (ns, name, mod,
                                     is_header () ? -1
                                     : is_module () || is_partition () ? 1
                                     : 0,
                                     decls, type, visible))
              sec.set_overrun ();

            if (type
                && CP_DECL_CONTEXT (type) == ns
                && !sec.is_duplicate (type))
              add_module_decl (ns, name, type);

            for (ovl_iterator iter (decls); iter; ++iter)
              if (!iter.using_p ())
                {
                  tree decl = *iter;
                  if (CP_DECL_CONTEXT (decl) == ns
                      && !sec.is_duplicate (decl))
                    add_module_decl (ns, name, decl);
                }
          }
          break;

        case ct_decl:
          /* A decl.  */
          {
            tree decl = sec.tree_node ();
            dump () && dump ("Read declaration of %N", decl);
          }
          break;

        case ct_defn:
          {
            tree decl = sec.tree_node ();
            dump () && dump ("Reading definition of %N", decl);
            sec.read_definition (decl);
          }
          break;
        }
    }

  /* When lazy loading is in effect, we can be in the middle of
     parsing or instantiating a function.  Save it away.
     push_function_context does too much work.   */
  tree old_cfd = current_function_decl;
  struct function *old_cfun = cfun;
  while (tree decl = sec.post_process ())
    {
      bool abstract = false;
      if (TREE_CODE (decl) == TEMPLATE_DECL)
        {
          abstract = true;
          decl = DECL_TEMPLATE_RESULT (decl);
        }

      current_function_decl = decl;
      allocate_struct_function (decl, abstract);
      cfun->language = ggc_cleared_alloc<language_function> ();
      cfun->language->base.x_stmt_tree.stmts_are_full_exprs_p = 1;

      if (abstract)
        ;
      else if (DECL_ABSTRACT_P (decl))
        {
          bool cloned = maybe_clone_body (decl);
          if (!cloned)
            from ()->set_error ();
        }
      else
        {
          bool aggr = aggregate_value_p (DECL_RESULT (decl), decl);
#ifdef PCC_STATIC_STRUCT_RETURN
          cfun->returns_pcc_struct = aggr;
#endif
          cfun->returns_struct = aggr;

          if (DECL_COMDAT (decl))
            // FIXME: Comdat grouping?
            comdat_linkage (decl);
          note_vague_linkage_fn (decl);
          cgraph_node::finalize_function (decl, true);
        }

    }
  /* Look, function.c's interface to cfun does too much for us, we
     just need to restore the old value.  I do not want to go
     redesigning that API right now.  */
#undef cfun
  cfun = old_cfun;
  current_function_decl = old_cfd;
  comparing_specializations--;

  dump.outdent ();
  dump () && dump ("Read section:%u", snum);

  loaded_clusters++;

  if (!sec.end (from ()))
    return false;

  return true;
}

void
module_state::write_namespace (bytes_out &sec, depset *dep)
{
  unsigned ns_num = dep->cluster;
  unsigned ns_import = 0;

  if (dep->is_import ())
    ns_import = dep->section;
  else if (dep->get_entity () != global_namespace)
    ns_num++;

  sec.u (ns_import);
  sec.u (ns_num);
}

tree
module_state::read_namespace (bytes_in &sec)
{
  unsigned ns_import = sec.u ();
  unsigned ns_num = sec.u ();
  tree ns = NULL_TREE;

  if (ns_import || ns_num)
    {
      if (!ns_import)
        ns_num--;

      if (unsigned origin = slurp->remap_module (ns_import))
        {
          module_state *from = (*modules)[origin];
          if (ns_num < from->entity_num)
            {
              binding_slot &slot = (*entity_ary)[from->entity_lwm + ns_num];

              if (!slot.is_lazy ())
                ns = slot;
            }
        }
      else
        sec.set_overrun ();
    }
  else
    ns = global_namespace;

  return ns;
}

/* SPACES is a sorted vector of namespaces.  Write out the namespaces
   to MOD_SNAME_PFX.nms section.   */

void
module_state::write_namespaces (elf_out *to, vec<depset *> spaces,
                                unsigned num, unsigned *crc_p)
{
  dump () && dump ("Writing namespaces");
  dump.indent ();

  bytes_out sec (to);
  sec.begin ();

  for (unsigned ix = 0; ix != num; ix++)
    {
      depset *b = spaces[ix];
      tree ns = b->get_entity ();

      gcc_checking_assert (TREE_CODE (ns) == NAMESPACE_DECL);

      bool export_p = DECL_MODULE_EXPORT_P (ns);
      bool inline_p = DECL_NAMESPACE_INLINE_P (ns);
      bool public_p = TREE_PUBLIC (ns);

      /* We should only be naming public namespaces, or our own
         private ones.  Internal linkage ones never get to be written
         out -- because that means something erroneously referred to a
         member.  However, Davis Herring's paper probably changes that
         by permitting them to be written out, but then an error if on
         touches them.  (Certain cases cannot be detected until that
         point.)  */ 
      gcc_checking_assert (public_p || !DECL_MODULE_IMPORT_P (ns));
      unsigned flags = 0;
      if (export_p)
        flags |= 1;
      if (inline_p)
        flags |= 2;
      if (public_p)
        flags |= 4;
      dump () && dump ("Writing namespace:%u %N%s%s%s",
                       b->cluster, ns, export_p ? ", export" : "",
                       public_p ? ", public" : "",
                       inline_p ? ", inline" : "");
      sec.u (b->cluster);
      sec.u (to->name (DECL_NAME (ns)));
      write_namespace (sec, b->deps[0]);

      /* Don't use bools, because this can be near the end of the
         section, and it won't save anything anyway.  */
      sec.u (flags);
      write_location (sec, DECL_SOURCE_LOCATION (ns));
    }

  sec.end (to, to->name (MOD_SNAME_PFX ".nms"), crc_p);
  dump.outdent ();
}

/* Read the namespace hierarchy from MOD_SNAME_PFX.namespace.  Fill in
   SPACES from that data.  */

bool
module_state::read_namespaces (unsigned num)
{
  bytes_in sec;

  if (!sec.begin (loc, from (), MOD_SNAME_PFX ".nms"))
    return false;

  dump () && dump ("Reading namespaces");
  dump.indent ();

  for (unsigned ix = 0; ix != num; ix++)
    {
      unsigned entity_index = sec.u ();
      unsigned name = sec.u ();

      tree parent = read_namespace (sec);

      /* See comment in write_namespace about why not bits.  */
      unsigned flags = sec.u ();
      location_t src_loc = read_location (sec);

      if (entity_index >= entity_num || !parent)
        sec.set_overrun ();
      if (sec.get_overrun ())
        break;

      tree id = name ? get_identifier (from ()->name (name)) : NULL_TREE;
      bool public_p = flags & 4;
      bool inline_p = flags & 2;
      bool export_p = flags & 1;

      dump () && dump ("Read namespace:%u %P%s%s%s",
                       entity_index, parent, id, export_p ? ", export" : "",
                       public_p ? ", public" : "",
                       inline_p ? ", inline" : "");
      bool visible_p = (export_p
                        || (public_p && (is_partition () || is_module ())));
      tree inner = add_imported_namespace (parent, id, mod,
                                           src_loc, visible_p, inline_p);
      if (export_p && is_partition ())
        DECL_MODULE_EXPORT_P (inner) = true;

      /* Install the namespace.  */
      (*entity_ary)[entity_lwm + entity_index] = inner;
      if (DECL_MODULE_IMPORT_P (inner))
        {
          bool existed;
          unsigned *slot = &entity_map->get_or_insert
            (DECL_UID (inner), &existed);
          if (existed)
            /* If it existed, it should match.  */
            gcc_checking_assert (inner == (*entity_ary)[*slot]);
          else
            *slot = entity_lwm + entity_index;
        }
    }
  dump.outdent ();
  if (!sec.end (from ()))
    return false;
  return true;
}

/* Write the binding TABLE to MOD_SNAME_PFX.bnd   */

unsigned
module_state::write_bindings (elf_out *to, vec<depset *> sccs, unsigned *crc_p)
{
  dump () && dump ("Writing binding table");
  dump.indent ();

  unsigned num = 0;
  bytes_out sec (to);
  sec.begin ();

  for (unsigned ix = 0; ix != sccs.length (); ix++)
    {
      depset *b = sccs[ix];
      if (b->is_binding ())
        {
          tree ns = b->get_entity ();
          dump () && dump ("Bindings %P section:%u", ns, b->get_name (),
                           b->section);
          sec.u (to->name (b->get_name ()));
          write_namespace (sec, b->deps[0]);
          sec.u (b->section);
          num++;
        }
    }

  sec.end (to, to->name (MOD_SNAME_PFX ".bnd"), crc_p);
  dump.outdent ();

  return num;
}

/* Read the binding table from MOD_SNAME_PFX.bind.  */

bool
module_state::read_bindings (unsigned num, unsigned lwm, unsigned hwm)
{
  bytes_in sec;

  if (!sec.begin (loc, from (), MOD_SNAME_PFX ".bnd"))
    return false;

  dump () && dump ("Reading binding table");
  dump.indent ();
  for (; !sec.get_overrun () && num--;)
    {
      const char *name = from ()->name (sec.u ());
      tree ns = read_namespace (sec);
      unsigned snum = sec.u ();

      if (!ns || !name || (snum - lwm) >= (hwm - lwm))
        sec.set_overrun ();
      if (!sec.get_overrun ())
        {
          tree id = get_identifier (name);
          dump () && dump ("Bindings %P section:%u", ns, id, snum);
          if (mod && !import_module_binding (ns, id, mod, snum))
            break;
        }
    }

  dump.outdent ();
  if (!sec.end (from ()))
    return false;
  return true;
}

/* Write the entity table to MOD_SNAME_PFX.ent

   Each entry is a section number.  */

void
module_state::write_entities (elf_out *to, vec<depset *> depsets,
                              unsigned count, unsigned *crc_p)
{
  dump () && dump ("Writing entities");
  dump.indent ();

  bytes_out sec (to);
  sec.begin ();

  unsigned current = 0;
  for (unsigned ix = 0; ix < depsets.length (); ix++)
    {
      depset *d = depsets[ix];

      switch (d->get_entity_kind ())
        {
        default:
          break;

        case depset::EK_NAMESPACE:
          if (!d->is_import () && d->get_entity () != global_namespace)
            {
              gcc_checking_assert (d->cluster == current);
              current++;
              sec.u (0);
            }
          break;

        case depset::EK_DECL:
        case depset::EK_SPECIALIZATION:
        case depset::EK_PARTIAL:
          gcc_checking_assert (!d->is_unreached ()
                               && !d->is_import ()
                               && d->cluster == current
                               && d->section);
          current++;
          sec.u (d->section);
          break;
        }
    }
  gcc_assert (count == current);
  sec.end (to, to->name (MOD_SNAME_PFX ".ent"), crc_p);
  dump.outdent ();
}

bool
module_state::read_entities (unsigned count, unsigned lwm, unsigned hwm)
{
  trees_in sec (this);

  if (!sec.begin (loc, from (), MOD_SNAME_PFX ".ent"))
    return false;

  dump () && dump ("Reading entities");
  dump.indent ();

  vec_safe_reserve (entity_ary, count);
  unsigned ix;
  for (ix = 0; ix != count; ix++)
    {
      unsigned snum = sec.u ();
      if (snum && (snum - lwm) >= (hwm - lwm))
        sec.set_overrun ();
      if (sec.get_overrun ())
        break;

      binding_slot slot;
      slot.u.binding = NULL_TREE;
      if (snum)
        slot.set_lazy (snum << 2);
      entity_ary->quick_push (slot);
    }
  entity_num = ix;

  dump.outdent ();
  if (!sec.end (from ()))
    return false;
  return true;
}

/* Write the pending table to MOD_SNAME_PFX.pnd

   Specializations & partials are keyed to their primary template.
   Members are keyed to their context.

   For specializations & partials, primary templates are keyed to the
   (namespace name) of their originating decl (because that's the only
   handle we have).  */

void
module_state::write_pendings (elf_out *to, vec<depset *> depsets,
                              depset::hash &table,
                              unsigned count, unsigned *crc_p)
{
  dump () && dump ("Writing %u pendings", count);
  dump.indent ();

  trees_out sec (to, this, table);
  sec.begin ();

  for (unsigned ix = 0; ix < depsets.length (); ix++)
    {
      depset *d = depsets[ix];
      depset::entity_kind kind = d->get_entity_kind ();
      tree key = NULL_TREE;
      bool is_spec = false;
      

      if (kind == depset::EK_SPECIALIZATION)
        {
          is_spec = true;
          key = reinterpret_cast <spec_entry *> (d->deps[0])->tmpl;
        }
      else if (kind == depset::EK_PARTIAL)
        {
          is_spec = true;
          key = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (d->get_entity ()));
        }
      else if (kind == depset::EK_DECL && d->is_member ())
        {
          tree ctx = DECL_CONTEXT (d->get_entity ());
          key = TYPE_NAME (ctx);
          if (tree ti = CLASSTYPE_TEMPLATE_INFO (ctx))
            if (DECL_TEMPLATE_RESULT (TI_TEMPLATE (ti)) == key)
              key = TI_TEMPLATE (ti);
        }

      // FIXME:OPTIMIZATION More than likely when there is one pending
      // member, there will be others.  All written in the same
      // section and keyed to the same class.  We only need to record
      // one of them.  The same is not true for specializations

      if (key)
        {
          gcc_checking_assert (!d->is_import ());

          {
            /* Key the entity to its key.  */
            depset *key_dep = table.find_dependency (key);
            if (key_dep->get_entity_kind () == depset::EK_REDIRECT)
              key_dep = key_dep->deps[0];
            unsigned key_origin
              = key_dep->is_import () ? key_dep->section : 0;
            sec.u (key_origin);
            sec.u (key_dep->cluster);
            sec.u (d->cluster);
            dump () && dump ("%s %N entity:%u keyed to %M[%u] %N",
                             is_spec ? "Specialization" : "Member",
                             d->get_entity (),
                             d->cluster, (*modules)[key_origin],
                             key_dep->cluster, key);
          }

          if (is_spec)
            {
              /* Key the general template to the originating decl.  */
              tree origin = get_originating_module_decl (key);
              sec.tree_node (CP_DECL_CONTEXT (origin));
              sec.tree_node (DECL_NAME (origin));

              unsigned origin_ident = import_entity_index (origin);
              module_state *origin_from = this;
              if (!(origin_ident & ~(~0u>>1)))
                origin_from = import_entity_module (origin_ident);
              sec.u (origin_from->remap);
            }
          else
            sec.tree_node (NULL);
          count--;
        }
      }
  gcc_assert (!count);
  sec.end (to, to->name (MOD_SNAME_PFX ".pnd"), crc_p);
  dump.outdent ();
}

bool
module_state::read_pendings (unsigned count)
{
  trees_in sec (this);

  if (!sec.begin (loc, from (), MOD_SNAME_PFX ".pnd"))
    return false;

  dump () && dump ("Reading %u pendings", count);
  dump.indent ();

  for (unsigned ix = 0; ix != count; ix++)
    {
      unsigned key_origin = slurp->remap_module (sec.u ());
      unsigned key_index = sec.u ();
      unsigned ent_index = sec.u ();
      module_state *from = (*modules)[key_origin];
      tree ns = sec.tree_node ();

      if (!key_origin
          || key_index >= from->entity_num || ent_index >= entity_num
          || (ns && TREE_CODE (ns) != NAMESPACE_DECL))
        sec.set_overrun ();

      if (sec.get_overrun ())
        break;

      bool loaded = false;
      dump () && dump ("%s keyed to %M[%u] entity:%u",
                       ns ? "Specialization" : "Member",
                       from, key_index, ent_index);
      unsigned key_ident = from->entity_lwm + key_index;
      if (pending_table->add (ns ? key_ident : ~key_ident,
                              ent_index + entity_lwm))
        {
          binding_slot &slot = (*entity_ary)[key_ident];
          if (slot.is_lazy ())
            slot.or_lazy (ns ? 1 : 2);
          else
            {
              tree key = slot;

              loaded = true;
              if (ns)
                {
                  if (key && TREE_CODE (key) == TEMPLATE_DECL)
                    DECL_MODULE_PENDING_SPECIALIZATIONS_P (key) = true;
                  else
                    sec.set_overrun ();
                }
              else
                {
                  if (key && TREE_CODE (key) == TYPE_DECL)
                    DECL_MODULE_PENDING_MEMBERS_P (key) = true;
                  else
                    sec.set_overrun ();
                }
            }
        }

      if (ns)
        {
          /* We also need to mark the namespace binding of the
             originating template, so we know to set its pending
             specializations flag, when we load it.  */
          tree name = sec.tree_node ();
          unsigned origin = slurp->remap_module (sec.u ());
          if (!origin || !name || TREE_CODE (name) != IDENTIFIER_NODE)
            sec.set_overrun ();
          if (sec.get_overrun ())
            break;

          module_state *origin_from = (*modules)[origin];
          if (!loaded
              && (origin_from->is_header ()
                  || (origin_from->is_partition ()
                      || origin_from->is_module ())))
            note_pending_specializations (ns, name, origin_from->is_header ());
        }
    }

  dump.outdent ();
  if (!sec.end (from ()))
    return false;
  return true;
}

/* Return true if module MOD cares about lazy specializations keyed to
   possibly duplicated entity bindings.  */

bool
lazy_specializations_p (unsigned mod, bool header_p, bool partition_p)
{
  module_state *module = (*modules)[mod];

  if (module->is_header ())
    return header_p;

  if (module->is_module () || module->is_partition ())
    return partition_p;

  return false;
}

/* Read & write locations.  */
enum loc_kind {
  LK_ORDINARY,
  LK_MACRO,
  LK_IMPORT_ORDINARY,
  LK_IMPORT_MACRO,
  LK_ADHOC,
  LK_RESERVED,
};

static const module_state *
module_for_ordinary_loc (location_t loc)
{
  unsigned pos = 1;
  unsigned len = modules->length () - pos;

  while (len)
    {
      unsigned half = len / 2;
      module_state *probe = (*modules)[pos + half];
      if (loc < probe->ordinary_locs.first)
        len = half;
      else if (loc < probe->ordinary_locs.second)
        return probe;
      else
        {
          pos += half + 1;
          len = len - (half + 1);
        }
    }

  return NULL;
}

static const module_state *
module_for_macro_loc (location_t loc)
{
  unsigned pos = 1;
  unsigned len = modules->length () - pos;

  while (len)
    {
      unsigned half = len / 2;
      module_state *probe = (*modules)[pos + half];
      if (loc >= probe->macro_locs.second)
        len = half;
      else if (loc >= probe->macro_locs.first)
        return probe;
      else
        {
          pos += half + 1;
          len = len - (half + 1);
        }
    }

  return NULL;
}

location_t
module_state::imported_from () const
{
  location_t from = loc;
  line_map_ordinary const *fmap
    = linemap_check_ordinary (linemap_lookup (line_table, from));

  if (MAP_MODULE_P (fmap))
    from = linemap_included_from (fmap);

  return from;
}

/* If we're not streaming, record that we need location LOC.
   Otherwise stream it.  */

void
module_state::write_location (bytes_out &sec, location_t loc)
{
  if (!sec.streaming_p ())
    /* This is where we should note we use this location.  See comment
       about write_ordinary_maps.  */
    return;

  if (loc < RESERVED_LOCATION_COUNT)
    {
      dump (dumper::LOCATION) && dump ("Reserved location %u", unsigned (loc));
      sec.u (LK_RESERVED + loc);
    }
  else if (IS_ADHOC_LOC (loc))
    {
      dump (dumper::LOCATION) && dump ("Adhoc location");
      sec.u (LK_ADHOC);
      location_t locus = get_location_from_adhoc_loc (line_table, loc);
      write_location (sec, locus);
      source_range range = get_range_from_loc (line_table, loc);
      if (range.m_start == locus)
        /* Compress.  */
        range.m_start = UNKNOWN_LOCATION;
      write_location (sec, range.m_start);
      write_location (sec, range.m_finish);
    }
  else if (IS_MACRO_LOC (loc))
    {
      if (const loc_spans::span *span = spans.macro (loc))
        {
          unsigned off = MAX_LOCATION_T - loc;

          off -= span->macro_delta;

          sec.u (LK_MACRO);
          sec.u (off);
          dump (dumper::LOCATION)
            && dump ("Macro location %u output %u", loc, off);
        }
      else if (const module_state *import = module_for_macro_loc (loc))
        {
          unsigned off = import->macro_locs.second - loc - 1;
          sec.u (LK_IMPORT_MACRO);
          sec.u (import->remap);
          sec.u (off);
          dump (dumper::LOCATION)
            && dump ("Imported macro location %u output %u:%u",
                     loc, import->remap, off);
        }
      else
        gcc_unreachable ();
    }
  else if (IS_ORDINARY_LOC (loc))
    {
      if (const loc_spans::span *span = spans.ordinary (loc))
        {
          unsigned off = loc;

          off += span->ordinary_delta;
          sec.u (LK_ORDINARY);
          sec.u (off);

          dump (dumper::LOCATION)
            && dump ("Ordinary location %u output %u", loc, off);
        }
      else if (const module_state *import = module_for_ordinary_loc (loc))
        {
          unsigned off = loc - import->ordinary_locs.first;
          sec.u (LK_IMPORT_ORDINARY);
          sec.u (import->remap);
          sec.u (off);
          dump (dumper::LOCATION)
            && dump ("Imported ordinary location %u output %u:%u",
                     import->remap, import->remap, off);
        }
      else
        gcc_unreachable ();
    }
  else
    gcc_unreachable ();
}

location_t
module_state::read_location (bytes_in &sec) const
{
  location_t locus = UNKNOWN_LOCATION;
  unsigned kind = sec.u ();
  switch (kind)
     {
    default:
      {
        if (kind < LK_RESERVED + RESERVED_LOCATION_COUNT)
          locus = location_t (kind - LK_RESERVED);
        else
          sec.set_overrun ();
        dump (dumper::LOCATION)
          && dump ("Reserved location %u", unsigned (locus));
      }
      break;

     case LK_ADHOC:
      {
        dump (dumper::LOCATION) && dump ("Adhoc location");
        locus = read_location (sec);
        source_range range;
        range.m_start = read_location (sec);
        if (range.m_start == UNKNOWN_LOCATION)
          range.m_start = locus;
        range.m_finish = read_location (sec);
        if (locus != loc && range.m_start != loc && range.m_finish != loc)
          locus = get_combined_adhoc_loc (line_table, locus, range, NULL);
      }
      break;

    case LK_MACRO:
      {
        unsigned off = sec.u ();

        if (macro_locs.first)
          {
            location_t adjusted = MAX_LOCATION_T - off;
            adjusted -= slurp->loc_deltas.second;
            if (adjusted < macro_locs.first)
              sec.set_overrun ();
            else if (adjusted < macro_locs.second)
              locus = adjusted;
            else
              sec.set_overrun ();
          }
        else
          locus = loc;
        dump (dumper::LOCATION)
          && dump ("Macro %u becoming %u", off, locus);
      }
      break;

    case LK_ORDINARY:
      {
        unsigned off = sec.u ();
        if (ordinary_locs.second)
          {
            location_t adjusted = off;

            adjusted += slurp->loc_deltas.first;
            if (adjusted >= ordinary_locs.second)
              sec.set_overrun ();
            else if (adjusted >= ordinary_locs.first)
              locus = adjusted;
            else if (adjusted < spans.main_start ())
              locus = off;
          }
        else
          locus = loc;

        dump (dumper::LOCATION)
          && dump ("Ordinary location %u becoming %u", off, locus);
      }
      break;

     case LK_IMPORT_MACRO:
     case LK_IMPORT_ORDINARY:
       {
         unsigned mod = sec.u ();
         unsigned off = sec.u ();
         const module_state *import = NULL;

         if (!mod && !slurp->remap)
           /* This is an early read of a partition location during the
              read of our ordinary location map.  */
           import = this;
         else
           {
             mod = slurp->remap_module (mod);
             if (!mod)
               sec.set_overrun ();
             else
               import = (*modules)[mod];
           }

         if (import)
           {
             if (kind == LK_IMPORT_MACRO)
               {
                 if (!import->macro_locs.first)
                   locus = import->loc;
                 else if (off < import->macro_locs.second - macro_locs.first)
                   locus = import->macro_locs.second - off - 1;
                 else
                   sec.set_overrun ();
               }
             else
               {
                 if (!import->ordinary_locs.second)
                   locus = import->loc;
                 else if (off < (import->ordinary_locs.second
                            - import->ordinary_locs.first))
                   locus = import->ordinary_locs.first + off;
                 else
                   sec.set_overrun ();
               }
           }
       }
       break;
    }

  return locus;
}

/* Prepare the span adjustments.  */

// FIXME:QOI I do not prune the unreachable locations.  Modules with
// textually-large GMFs could well cause us to run out of locations.
// Regular single-file modules could also be affected.  We should
// determine which locations we need to represent, so that we do not
// grab more locations than necessary.  An example is in
// write_macro_maps where we work around macro expansions that are not
// covering any locations -- the macro expands to nothing.  Perhaps we
// should decompose locations so that we can have a more graceful
// degradation upon running out?

location_map_info
module_state::write_prepare_maps (module_state_config *)
{
  dump () && dump ("Preparing locations");
  dump.indent ();

  dump () && dump ("Reserved locations [%u,%u) macro [%u,%u)",
                   spans[loc_spans::SPAN_RESERVED].ordinary.first,
                   spans[loc_spans::SPAN_RESERVED].ordinary.second,
                   spans[loc_spans::SPAN_RESERVED].macro.first,
                   spans[loc_spans::SPAN_RESERVED].macro.second);

  location_map_info info;

  info.num_maps.first = info.num_maps.second = 0;

  /* Figure the alignment of ordinary location spans.  */
  unsigned max_range = 0;
  for (unsigned ix = loc_spans::SPAN_FIRST; ix != spans.length (); ix++)
    {
      loc_spans::span &span = spans[ix];
      line_map_ordinary const *omap
        = linemap_check_ordinary (linemap_lookup (line_table,
                                                  span.ordinary.first));

      /* We should exactly match up.  */
      gcc_checking_assert (MAP_START_LOCATION (omap) == span.ordinary.first);

      line_map_ordinary const *fmap = omap;
      for (; MAP_START_LOCATION (omap) < span.ordinary.second; omap++)
        {
          /* We should never find a module linemap in an interval.  */
          gcc_checking_assert (!MAP_MODULE_P (omap));

          if (max_range < omap->m_range_bits)
            max_range = omap->m_range_bits;
        }

      unsigned count = omap - fmap;
      info.num_maps.first += count;

      if (span.macro.first != span.macro.second)
        {
          count = linemap_lookup_macro_index (line_table, span.macro.first) + 1;
          count -= linemap_lookup_macro_index (line_table,
                                               span.macro.second - 1);
          dump (dumper::LOCATION) && dump ("Span:%u %u macro maps", ix, count);
          info.num_maps.second += count;
        }
    }

  /* Adjust the maps.  Ordinary ones ascend, and we must maintain
     alignment.  Macro ones descend, but are unaligned.  */
  location_t ord_off = spans[loc_spans::SPAN_FIRST].ordinary.first;
  location_t mac_off = spans[loc_spans::SPAN_FIRST].macro.second;
  location_t range_mask = (1u << max_range) - 1;

  dump () && dump ("Ordinary maps range bits:%u, preserve:%x, zero:%u",
                   max_range, ord_off & range_mask, ord_off & ~range_mask);

  for (unsigned ix = loc_spans::SPAN_FIRST; ix != spans.length (); ix++)
    {
      loc_spans::span &span = spans[ix];

      span.macro_delta = mac_off - span.macro.second;
      mac_off -= span.macro.second - span.macro.first;
      dump () && dump ("Macro span:%u [%u,%u):%u->%d(%u)", ix,
                       span.macro.first, span.macro.second,
                       span.macro.second - span.macro.first,
                       span.macro_delta, span.macro.first + span.macro_delta);

      line_map_ordinary const *omap
        = linemap_check_ordinary (linemap_lookup (line_table,
                                                  span.ordinary.first));
      location_t base = MAP_START_LOCATION (omap);

      /* Preserve the low MAX_RANGE bits of base by incrementing ORD_OFF.  */
      unsigned low_bits = base & range_mask;
      if ((ord_off & range_mask) > low_bits)
        low_bits += range_mask + 1;
      ord_off = (ord_off & ~range_mask) + low_bits;
      span.ordinary_delta = ord_off - base;

      for (; MAP_START_LOCATION (omap) < span.ordinary.second; omap++)
        {
          location_t start_loc = MAP_START_LOCATION (omap);
          unsigned to = start_loc + span.ordinary_delta;
          location_t end_loc = MAP_START_LOCATION (omap + 1);
          
          dump () && dump ("Ordinary span:%u [%u,%u):%u->%d(%u)", ix, start_loc,
                           end_loc, end_loc - start_loc,
                           span.ordinary_delta, to);

          /* There should be no change in the low order bits.  */
          gcc_checking_assert (((start_loc ^ to) & range_mask) == 0);
        }
      /* The ending serialized value.  */
      ord_off = span.ordinary.second + span.ordinary_delta;
    }

  dump () && dump ("Ordinary hwm:%u macro lwm:%u", ord_off, mac_off);

  dump.outdent ();

  info.max_range = max_range;

  return info;
}

bool
module_state::read_prepare_maps (const module_state_config *cfg)
{
  location_t ordinary = line_table->highest_location + 1;
  ordinary = ((ordinary + (1u << cfg->ordinary_loc_align))
              & ~((1u << cfg->ordinary_loc_align) - 1));
  ordinary += cfg->ordinary_locs;

  location_t macro = LINEMAPS_MACRO_LOWEST_LOCATION (line_table);
  macro -= cfg->macro_locs;

  if (ordinary < LINE_MAP_MAX_LOCATION_WITH_COLS
      && macro >= LINE_MAP_MAX_LOCATION)
    /* OK, we have enough locations.  */
    return true;

  ordinary_locs.first = ordinary_locs.second = 0;
  macro_locs.first = macro_locs.second = 0;

  static bool informed = false;
  if (!informed)
    {
      /* Just give the notice once.  */
      informed = true;
      inform (loc, "unable to represent further imported source locations");
    }

  return false;
}

/* Write the location maps.  This also determines the shifts for the
   location spans.  */

void
module_state::write_ordinary_maps (elf_out *to, location_map_info &info,
                                   module_state_config *cfg, bool has_partitions,
                                   unsigned *crc_p)
{
  dump () && dump ("Writing ordinary location maps");
  dump.indent ();

  vec<const char *> filenames;
  filenames.create (20);

  /* Determine the unique filenames.  */
  // FIXME:QOI We should find the set of filenames when working out
  // which locations we actually need.  See write_prepare_maps.
  for (unsigned ix = loc_spans::SPAN_FIRST; ix != spans.length (); ix++)
    {
      loc_spans::span &span = spans[ix];
      line_map_ordinary const *omap
        = linemap_check_ordinary (linemap_lookup (line_table,
                                                  span.ordinary.first));

      /* We should exactly match up.  */
      gcc_checking_assert (MAP_START_LOCATION (omap) == span.ordinary.first);

      for (; MAP_START_LOCATION (omap) < span.ordinary.second; omap++)
        {
          const char *fname = ORDINARY_MAP_FILE_NAME (omap);

          /* We should never find a module linemap in an interval.  */
          gcc_checking_assert (!MAP_MODULE_P (omap));

          /* We expect very few filenames, so just an array.  */
          for (unsigned jx = filenames.length (); jx--;)
            {
              const char *name = filenames[jx];
              if (0 == strcmp (name, fname))
                {
                  /* Reset the linemap's name, because for things like
                     preprocessed input we could have multple
                     instances of the same name, and we'd rather not
                     percolate that.  */
                  const_cast<line_map_ordinary *> (omap)->to_file = name;
                  fname = NULL;
                  break;
                }
            }
          if (fname)
            filenames.safe_push (fname);
        }
    }

  bytes_out sec (to);
  sec.begin ();

  /* Write the filenames.  */
  unsigned len = filenames.length ();
  sec.u (len);
  dump () && dump ("%u source file names", len);
  for (unsigned ix = 0; ix != len; ix++)
    {
      const char *fname = filenames[ix];
      dump (dumper::LOCATION) && dump ("Source file[%u]=%s", ix, fname);
      sec.str (fname);
    }

  location_t offset = spans[loc_spans::SPAN_FIRST].ordinary.first;
  location_t range_mask = (1u << info.max_range) - 1;

  dump () && dump ("Ordinary maps:%u, range bits:%u, preserve:%x, zero:%u",
                   info.num_maps.first, info.max_range, offset & range_mask,
                   offset & ~range_mask);
  sec.u (info.num_maps.first);  /* Num maps.  */
  sec.u (info.max_range);               /* Maximum range bits  */
  sec.u (offset & range_mask);  /* Bits to preserve.  */
  sec.u (offset & ~range_mask);

  for (unsigned ix = loc_spans::SPAN_FIRST; ix != spans.length (); ix++)
    {
      loc_spans::span &span = spans[ix];
      line_map_ordinary const *omap
        = linemap_check_ordinary (linemap_lookup (line_table,
                                                  span.ordinary.first));
      for (; MAP_START_LOCATION (omap) < span.ordinary.second; omap++)
        {
          location_t start_loc = MAP_START_LOCATION (omap);
          unsigned to = start_loc + span.ordinary_delta;

          dump (dumper::LOCATION)
            && dump ("Span:%u ordinary [%u,%u)->%u", ix, start_loc,
                     MAP_START_LOCATION (omap + 1), to);

          /* There should be no change in the low order bits.  */
          gcc_checking_assert (((start_loc ^ to) & range_mask) == 0);
          sec.u (to);

          /* Making accessors just for here, seems excessive.  */
          sec.u (omap->reason);
          sec.u (omap->sysp);
          sec.u (omap->m_range_bits);
          sec.u (omap->m_column_and_range_bits - omap->m_range_bits);

          const char *fname = ORDINARY_MAP_FILE_NAME (omap);
          for (unsigned ix = 0; ix != filenames.length (); ix++)
            if (filenames[ix] == fname)
              {
                sec.u (ix);
                break;
              }
          sec.u (ORDINARY_MAP_STARTING_LINE_NUMBER (omap));

          /* Write the included from location, which means reading it
             while reading in the ordinary maps.  So we'd better not
             be getting ahead of ourselves.  */
          location_t from = linemap_included_from (omap);
          gcc_checking_assert (from < MAP_START_LOCATION (omap));
          if (from != UNKNOWN_LOCATION && has_partitions)
            {
              /* A partition's span will have a from pointing at a
                 MODULE_INC.  Find that map's from.  */
              line_map_ordinary const *fmap
                = linemap_check_ordinary (linemap_lookup (line_table, from));
              if (MAP_MODULE_P (fmap))
                from = linemap_included_from (fmap);
            }
          write_location (sec, from);
        }
      /* The ending serialized value.  */
      offset = MAP_START_LOCATION (omap) + span.ordinary_delta;
    }
  dump () && dump ("Ordinary location hwm:%u", offset);
  sec.u (offset);

  // Record number of locations and alignment.
  cfg->ordinary_loc_align = info.max_range;
  cfg->ordinary_locs = offset;

  filenames.release ();

  sec.end (to, to->name (MOD_SNAME_PFX ".olm"), crc_p);
  dump.outdent ();
}

void
module_state::write_macro_maps (elf_out *to, location_map_info &info,
                                module_state_config *cfg, unsigned *crc_p)
{
  dump () && dump ("Writing macro location maps");
  dump.indent ();

  bytes_out sec (to);
  sec.begin ();

  dump () && dump ("Macro maps:%u", info.num_maps.second);
  sec.u (info.num_maps.second);

  location_t offset = spans[loc_spans::SPAN_FIRST].macro.second;
  sec.u (offset);

  unsigned macro_num = 0;
  for (unsigned ix = loc_spans::SPAN_FIRST; ix != spans.length (); ix++)
    {
      loc_spans::span &span = spans[ix];
      if (span.macro.first == span.macro.second)
        continue;

      for (unsigned first
             = linemap_lookup_macro_index (line_table, span.macro.second - 1);
           first < LINEMAPS_MACRO_USED (line_table);
           first++)
        {
          line_map_macro const *mmap
            = LINEMAPS_MACRO_MAP_AT (line_table, first);
          location_t start_loc = MAP_START_LOCATION (mmap);
          if (start_loc < span.macro.first)
            break;
          if (macro_num == info.num_maps.second)
            {
              /* We're ending on an empty macro expansion.  The
                 preprocessor doesn't prune such things.  */
              // FIXME:QOI This is an example of the non-pruning of
              // locations.  See write_prepare_maps.
              gcc_checking_assert (!mmap->n_tokens);
              continue;
            }

          sec.u (offset);
          sec.u (mmap->n_tokens);
          sec.cpp_node (mmap->macro);
          write_location (sec, mmap->expansion);
          const location_t *locs = mmap->macro_locations;
          /* There are lots of identical runs.  */
          location_t prev = UNKNOWN_LOCATION;
          unsigned count = 0;
          unsigned runs = 0;
          for (unsigned jx = mmap->n_tokens * 2; jx--;)
            {
              location_t tok_loc = locs[jx];
              if (tok_loc == prev)
                {
                  count++;
                  continue;
                }
              runs++;
              sec.u (count);
              count = 1;
              prev = tok_loc;
              write_location (sec, tok_loc);
            }
          sec.u (count);
          dump (dumper::LOCATION)
            && dump ("Span:%u macro:%u %I %u/%u*2 locations [%u,%u)->%u",
                     ix, macro_num, identifier (mmap->macro),
                     runs, mmap->n_tokens,
                     start_loc, start_loc + mmap->n_tokens,
                     start_loc + span.macro_delta);
          macro_num++;
          offset -= mmap->n_tokens;
          gcc_checking_assert (offset == start_loc + span.macro_delta);
        }
    }
  dump () && dump ("Macro location lwm:%u", offset);
  sec.u (offset);
  gcc_assert (macro_num == info.num_maps.second);

  cfg->macro_locs = MAX_LOCATION_T + 1 - offset;

  sec.end (to, to->name (MOD_SNAME_PFX ".mlm"), crc_p);
  dump.outdent ();
}

bool
module_state::read_ordinary_maps ()
{
  bytes_in sec;

  if (!sec.begin (loc, from (), MOD_SNAME_PFX ".olm"))
    return false;
  dump () && dump ("Reading ordinary location maps");
  dump.indent ();

  /* Read the filename table.  */
  unsigned len = sec.u ();
  dump () && dump ("%u source file names", len);
  vec<const char *> filenames;
  filenames.create (len);
  for (unsigned ix = 0; ix != len; ix++)
    {
      size_t l;
      const char *buf = sec.str (&l);
      char *fname = XNEWVEC (char, l + 1);
      memcpy (fname, buf, l + 1);
      dump (dumper::LOCATION) && dump ("Source file[%u]=%s", ix, fname);
      /* We leak these names into the line-map table.  But it
         doesn't own them.  */
      filenames.quick_push (fname);
    }

  unsigned num_ordinary = sec.u (); 
  unsigned max_range = sec.u ();
  unsigned low_bits = sec.u ();
  location_t zero = sec.u ();
  location_t range_mask = (1u << max_range) - 1;

  dump () && dump ("Ordinary maps:%u, range bits:%u, preserve:%x, zero:%u",
                   num_ordinary, max_range, low_bits, zero);

  location_t offset = line_table->highest_location + 1;
  /* Ensure offset doesn't go backwards at the start.  */
  if ((offset & range_mask) > low_bits)
    offset += range_mask + 1;
  offset = (offset & ~range_mask);

  bool propagated = spans.maybe_propagate (this, offset + low_bits);

  line_map_ordinary *maps = static_cast<line_map_ordinary *>
    (line_map_new_raw (line_table, false, num_ordinary));

  location_t lwm = offset;
  slurp->loc_deltas.first = offset - zero;
  ordinary_locs.first = zero + low_bits + slurp->loc_deltas.first;
  dump () && dump ("Ordinary loc delta %d", slurp->loc_deltas.first);

  for (unsigned ix = 0; ix != num_ordinary && !sec.get_overrun (); ix++)
    {
      line_map_ordinary *map = &maps[ix];
      unsigned hwm = sec.u ();

      /* Record the current HWM so that the below read_location is
         ok.  */
      ordinary_locs.second = hwm + slurp->loc_deltas.first;
      map->start_location = hwm + (offset - zero);
      if (map->start_location < lwm)
        sec.set_overrun ();
      lwm = map->start_location;
      dump (dumper::LOCATION) && dump ("Map:%u %u->%u", ix, hwm, lwm);
      map->reason = lc_reason (sec.u ());
      map->sysp = sec.u ();
      map->m_range_bits = sec.u ();
      map->m_column_and_range_bits = map->m_range_bits + sec.u ();

      unsigned fnum = sec.u ();
      map->to_file = (fnum < filenames.length () ? filenames[fnum] : "");
      map->to_line = sec.u ();

      /* Root the outermost map at our location.  */
      location_t from = read_location (sec);
      map->included_from = from != UNKNOWN_LOCATION ? from : loc;
    }

  location_t hwm = sec.u ();
  ordinary_locs.second = hwm + slurp->loc_deltas.first;

  /* highest_location is the one handed out, not the next one to
     hand out.  */
  line_table->highest_location = ordinary_locs.second - 1;

  if (line_table->highest_location >= LINE_MAP_MAX_LOCATION_WITH_COLS)
    /* We shouldn't run out of locations, as we checked before
       starting.  */
    sec.set_overrun ();
  dump () && dump ("Ordinary location hwm:%u", ordinary_locs.second);

  if (propagated)
    spans.close ();

  filenames.release ();
  
  dump.outdent ();
  if (!sec.end (from ()))
    return false;

  return true;
}

bool
module_state::read_macro_maps ()
{
  bytes_in sec;

  if (!sec.begin (loc, from (), MOD_SNAME_PFX ".mlm"))
    return false;
  dump () && dump ("Reading macro location maps");
  dump.indent ();

  unsigned num_macros = sec.u ();
  location_t zero = sec.u ();
  dump () && dump ("Macro maps:%u zero:%u", num_macros, zero);

  bool propagated = spans.maybe_propagate (this);

  location_t offset = LINEMAPS_MACRO_LOWEST_LOCATION (line_table);
  slurp->loc_deltas.second = zero - offset;
  macro_locs.second = zero - slurp->loc_deltas.second;
  dump () && dump ("Macro loc delta %d", slurp->loc_deltas.second);

  for (unsigned ix = 0; ix != num_macros && !sec.get_overrun (); ix++)
    {
      unsigned lwm = sec.u ();
      /* Record the current LWM so that the below read_location is
         ok.  */
      macro_locs.first = lwm - slurp->loc_deltas.second;

      unsigned n_tokens = sec.u ();
      cpp_hashnode *node = sec.cpp_node ();
      location_t exp_loc = read_location (sec);

      const line_map_macro *macro
        = linemap_enter_macro (line_table, node, exp_loc, n_tokens);
      if (!macro)
        /* We shouldn't run out of locations, as we checked that we
           had enough before starting.  */
        break;

      location_t *locs = macro->macro_locations;
      location_t tok_loc = UNKNOWN_LOCATION;
      unsigned count = sec.u ();
      unsigned runs = 0;
      for (unsigned jx = macro->n_tokens * 2; jx-- && !sec.get_overrun ();)
        {
          while (!count-- && !sec.get_overrun ())
            {
              runs++;
              tok_loc = read_location (sec);
              count = sec.u ();
            }
          locs[jx] = tok_loc;
        }
      if (count)
        sec.set_overrun ();
      dump (dumper::LOCATION)
        && dump ("Macro:%u %I %u/%u*2 locations [%u,%u)",
                 ix, identifier (node), runs, n_tokens,
                 MAP_START_LOCATION (macro),
                 MAP_START_LOCATION (macro) + n_tokens);
    }
  location_t lwm = sec.u ();
  macro_locs.first = lwm - slurp->loc_deltas.second;

  dump () && dump ("Macro location lwm:%u", macro_locs.first);

  if (propagated)
    spans.close ();

  dump.outdent ();
  if (!sec.end (from ()))
    return false;

  return true;
}

/* Serialize the definition of MACRO.  */

void
module_state::write_define (bytes_out &sec, const cpp_macro *macro, bool located)
{
  sec.u (macro->count);

  sec.b (macro->fun_like);
  sec.b (macro->variadic);
  sec.b (macro->syshdr);
  sec.bflush ();

  if (located)
    write_location (sec, macro->line);
  if (macro->fun_like)
    {
      sec.u (macro->paramc);
      const cpp_hashnode *const *parms = macro->parm.params;
      for (unsigned ix = 0; ix != macro->paramc; ix++)
        sec.cpp_node (parms[ix]);
    }

  unsigned len = 0;
  for (unsigned ix = 0; ix != macro->count; ix++)
    {
      const cpp_token *token = &macro->exp.tokens[ix];
      if (located)
        write_location (sec, token->src_loc);
      sec.u (token->type);
      sec.u (token->flags);
      switch (cpp_token_val_index (token))
        {
        default:
          gcc_unreachable ();

        case CPP_TOKEN_FLD_ARG_NO:
          /* An argument reference.  */
          sec.u (token->val.macro_arg.arg_no);
          sec.cpp_node (token->val.macro_arg.spelling);
          break;

        case CPP_TOKEN_FLD_NODE:
          /* An identifier.  */
          sec.cpp_node (token->val.node.node);
          if (token->val.node.spelling == token->val.node.node)
            /* The spelling will usually be the same.  so optimize
               that.  */
            sec.str (NULL, 0);
          else
            sec.cpp_node (token->val.node.spelling);
          break;

        case CPP_TOKEN_FLD_NONE:
          break;

        case CPP_TOKEN_FLD_STR:
          /* A string, number or comment.  Not always NUL terminated,
             we stream out in a single contatenation with embedded
             NULs as that's a safe default.  */
          len += token->val.str.len + 1;
          sec.u (token->val.str.len);
          break;

        case CPP_TOKEN_FLD_SOURCE:
        case CPP_TOKEN_FLD_TOKEN_NO:
        case CPP_TOKEN_FLD_PRAGMA:
          /* These do not occur inside a macro itself.  */
          gcc_unreachable ();
        }
    }

  if (len)
    {
      char *ptr = reinterpret_cast<char *> (sec.buf (len));
      len = 0;
      for (unsigned ix = 0; ix != macro->count; ix++)
        {
          const cpp_token *token = &macro->exp.tokens[ix];
          if (cpp_token_val_index (token) == CPP_TOKEN_FLD_STR)
            {
              memcpy (ptr + len, token->val.str.text,
                      token->val.str.len);
              len += token->val.str.len;
              ptr[len++] = 0;
            }
        }
    }
}

/* Read a macro definition.  */

cpp_macro *
module_state::read_define (bytes_in &sec, cpp_reader *reader, bool located) const
{
  unsigned count = sec.u ();
  /* We rely on knowing cpp_reader's hash table is ident_hash, and
     it's subobject allocator is stringpool_ggc_alloc and that is just
     a wrapper for ggc_alloc_atomic.  */
  cpp_macro *macro
    = (cpp_macro *)ggc_alloc_atomic (sizeof (cpp_macro)
                                     + sizeof (cpp_token) * (count - !!count));
  memset (macro, 0, sizeof (cpp_macro) + sizeof (cpp_token) * (count - !!count));

  macro->count = count;
  macro->kind = cmk_macro;
  macro->imported_p = true;

  macro->fun_like = sec.b ();
  macro->variadic = sec.b ();
  macro->syshdr = sec.b ();
  sec.bflush ();

  macro->line = located ? read_location (sec) : loc;

  if (macro->fun_like)
    {
      unsigned paramc = sec.u ();
      cpp_hashnode **params
        = (cpp_hashnode **)ggc_alloc_atomic (sizeof (cpp_hashnode *) * paramc);
      macro->paramc = paramc;
      macro->parm.params = params;
      for (unsigned ix = 0; ix != paramc; ix++)
        params[ix] = sec.cpp_node ();
    }

  unsigned len = 0;
  for (unsigned ix = 0; ix != count && !sec.get_overrun (); ix++)
    {
      cpp_token *token = &macro->exp.tokens[ix];
      token->src_loc = located ? read_location (sec) : loc;
      token->type = cpp_ttype (sec.u ());
      token->flags = sec.u ();
      switch (cpp_token_val_index (token))
        {
        default:
          sec.set_overrun ();
          break;

        case CPP_TOKEN_FLD_ARG_NO:
          /* An argument reference.  */
          {
            unsigned arg_no = sec.u ();
            if (arg_no - 1 >= macro->paramc)
              sec.set_overrun ();
            token->val.macro_arg.arg_no = arg_no;
            token->val.macro_arg.spelling = sec.cpp_node ();
          }
          break;

        case CPP_TOKEN_FLD_NODE:
          /* An identifier.  */
          token->val.node.node = sec.cpp_node ();
          token->val.node.spelling = sec.cpp_node ();
          if (!token->val.node.spelling)
            token->val.node.spelling = token->val.node.node;
          break;

        case CPP_TOKEN_FLD_NONE:
          break;

        case CPP_TOKEN_FLD_STR:
          /* A string, number or comment.  */
          token->val.str.len = sec.u ();
          len += token->val.str.len + 1;
          break;
        }
    }

  if (len)
    if (const char *ptr = reinterpret_cast<const char *> (sec.buf (len)))
      {
        /* There should be a final NUL.  */
        if (ptr[len-1])
          sec.set_overrun ();
        /* cpp_alloc_token_string will add a final NUL.  */
        const unsigned char *buf
          = cpp_alloc_token_string (reader, (const unsigned char *)ptr, len - 1);
        len = 0;
        for (unsigned ix = 0; ix != count && !sec.get_overrun (); ix++)
          {
            cpp_token *token = &macro->exp.tokens[ix];
            if (cpp_token_val_index (token) == CPP_TOKEN_FLD_STR)
              {
                token->val.str.text = buf + len;
                len += token->val.str.len;
                if (buf[len++])
                  sec.set_overrun ();
              }
          }
      }

  if (sec.get_overrun ())
    return NULL;
  return macro;
}

/* Exported macro data.  */
struct macro_export {
  cpp_macro *def;
  location_t undef_loc;

  macro_export ()
    :def (NULL), undef_loc (UNKNOWN_LOCATION)
  {
  }
};

/* Imported macro data.  */
class macro_import {
public:
  struct slot {
#if defined (WORDS_BIGENDIAN) && SIZEOF_VOID_P == 8
    int offset;
#endif
    /* We need to ensure we don't use the LSB for representation, as
       that's the union discriminator below.  */
    unsigned bits;

#if !(defined (WORDS_BIGENDIAN) && SIZEOF_VOID_P == 8)
    int offset;
#endif

  public:
    enum Layout {
      L_DEF = 1,
      L_UNDEF = 2,
      L_BOTH = 3,
      L_MODULE_SHIFT = 2
    };

  public:
    /* Not a regular ctor, because we put it in a union, and that's
       not allowed in C++ 98.  */
    static slot ctor (unsigned module, unsigned defness)
    {
      gcc_checking_assert (defness);
      slot s;
      s.bits = defness | (module << L_MODULE_SHIFT);
      s.offset = -1;
      return s;
    }

  public:
    unsigned get_defness () const
    {
      return bits & L_BOTH;
    }
    unsigned get_module () const
    {
      return bits >> L_MODULE_SHIFT;
    }
    void become_undef ()
    {
      bits &= ~unsigned (L_DEF);
      bits |= unsigned (L_UNDEF);
    }
  };

private:
  typedef vec<slot, va_heap, vl_embed> ary_t;
  union either {
    /* Discriminated by bits 0|1 != 0.  The expected case is that
       there will be exactly one slot per macro, hence the effort of
       packing that.  */
    ary_t *ary;
    slot single;
  } u;

public:
  macro_import ()
  {
    u.ary = NULL;
  }

private:
  bool single_p () const
  {
    return u.single.bits & slot::L_BOTH;
  }
  bool occupied_p () const
  {
    return u.ary != NULL;
  }

public:
  unsigned length () const
  {
    gcc_checking_assert (occupied_p ());
    return single_p () ? 1 : u.ary->length ();
  }
  slot &operator[] (unsigned ix)
  {
    gcc_checking_assert (occupied_p ());
    if (single_p ())
      {
        gcc_checking_assert (!ix);
        return u.single;
      }
    else
      return (*u.ary)[ix];
  }

public:
  slot &exported ();
  slot &append (unsigned module, unsigned defness);
};

/* O is a new import to append to the list for.  If we're an empty
   set, initialize us.  */

macro_import::slot &
macro_import::append (unsigned module, unsigned defness)
{
  if (!occupied_p ())
    {
      u.single = slot::ctor (module, defness);
      return u.single;
    }
  else
    {
      bool single = single_p ();
      ary_t *m = single ? NULL : u.ary;
      vec_safe_reserve (m, 1 + single);
      if (single)
        m->quick_push (u.single);
      u.ary = m;
      return *u.ary->quick_push (slot::ctor (module, defness));
    }
}

/* We're going to export something.  Make sure the first import slot
   is us.  */

macro_import::slot &
macro_import::exported ()
{
  if (occupied_p () && !(*this)[0].get_module ())
    {
      slot &res = (*this)[0];
      res.bits |= slot::L_DEF;
      return res;
    }

  slot *a = &append (0, slot::L_DEF);
  if (!single_p ())
    {
      slot &f = (*this)[0];
      std::swap (f, *a);
      a = &f;
    }
  return *a;
}

/* The import (&exported) macros.  cpp_hasnode's deferred field
   indexes this array (offset by 1, so zero means 'not present'.  */

static vec<macro_import, va_heap, vl_embed> *macro_imports;

/* The exported macros.  A macro_import slot's zeroth element's offset
   indexes this array.  If the zeroth slot is not for module zero,
   there is no export.  */

static vec<macro_export, va_heap, vl_embed> *macro_exports;

/* The reachable set of header imports from this TU.  */

static GTY(()) bitmap headers;

/* Get the (possibly empty) macro imports for NODE.  */

static macro_import &
get_macro_imports (cpp_hashnode *node)
{
  if (node->deferred)
    return (*macro_imports)[node->deferred - 1];

  vec_safe_reserve (macro_imports, 1);
  node->deferred = macro_imports->length () + 1;
  return *vec_safe_push (macro_imports, macro_import ());
}

/* Get the macro export for export EXP of NODE.  */

static macro_export &
get_macro_export (macro_import::slot &slot)
{
  if (slot.offset >= 0)
    return (*macro_exports)[slot.offset];

  vec_safe_reserve (macro_exports, 1);
  slot.offset = macro_exports->length ();
  return *macro_exports->quick_push (macro_export ());
}

/* If NODE is an exportable macro, add it to the export set.  */

static int
maybe_add_macro (cpp_reader *, cpp_hashnode *node, void *data_)
{
  bool exporting = false;

  if (cpp_user_macro_p (node))
    if (cpp_macro *macro = node->value.macro)
      /* Ignore imported, builtins, command line and forced header macros.  */
      if (!macro->imported_p
          && !macro->lazy && macro->line >= spans.main_start ())
        {
          gcc_checking_assert (macro->kind == cmk_macro);
          /* I don't want to deal with this corner case, that I suspect is
             a devil's advocate reading of the standard.  */
          gcc_checking_assert (!macro->extra_tokens);

          macro_import::slot &slot = get_macro_imports (node).exported ();
          macro_export &exp = get_macro_export (slot);
          exp.def = macro;
          exporting = true;
        }

  if (!exporting && node->deferred)
    {
      macro_import &imports = (*macro_imports)[node->deferred - 1];
      macro_import::slot &slot = imports[0];
      if (!slot.get_module ())
        {
          gcc_checking_assert (slot.get_defness ());
          exporting = true;
        }
    }

  if (exporting)
    static_cast<vec<cpp_hashnode *> *> (data_)->safe_push (node);

  return 1; /* Don't stop.  */
}

/* Order cpp_hashnodes A_ and B_ by their exported macro locations.  */

static int
macro_loc_cmp (const void *a_, const void *b_)
{
  const cpp_hashnode *node_a = *(const cpp_hashnode *const *)a_;
  macro_import &import_a = (*macro_imports)[node_a->deferred - 1];
  const macro_export &export_a = (*macro_exports)[import_a[0].offset];
  location_t loc_a = export_a.def ? export_a.def->line : export_a.undef_loc;

  const cpp_hashnode *node_b = *(const cpp_hashnode *const *)b_;
  macro_import &import_b = (*macro_imports)[node_b->deferred - 1];
  const macro_export &export_b = (*macro_exports)[import_b[0].offset];
  location_t loc_b = export_b.def ? export_b.def->line : export_b.undef_loc;

  if (loc_a < loc_b)
    return +1;
  else if (loc_a > loc_b)
    return -1;
  else
    return 0;
}

/* Write out the exported defines.  This is two sections, one
   containing the definitions, the other a table of node names.  */

unsigned
module_state::write_macros (elf_out *to, cpp_reader *reader, unsigned *crc_p)
{
  dump () && dump ("Writing macros");
  dump.indent ();

  vec<cpp_hashnode *> macros;
  macros.create (100);
  cpp_forall_identifiers (reader, maybe_add_macro, &macros);

  dump (dumper::MACRO) && dump ("No more than %u macros", macros.length ());

  macros.qsort (macro_loc_cmp);

  /* Write the defs */
  bytes_out sec (to);
  sec.begin ();

  unsigned count = 0;
  for (unsigned ix = macros.length (); ix--;)
    {
      cpp_hashnode *node = macros[ix];
      macro_import::slot &slot = (*macro_imports)[node->deferred - 1][0];
      gcc_assert (!slot.get_module () && slot.get_defness ());

      macro_export &mac = (*macro_exports)[slot.offset];
      gcc_assert (!!(slot.get_defness () & macro_import::slot::L_UNDEF)
                  == (mac.undef_loc != UNKNOWN_LOCATION)
                  && !!(slot.get_defness () & macro_import::slot::L_DEF)
                  == (mac.def != NULL));

      if (IDENTIFIER_KEYWORD_P (identifier (node)))
        {
          warning_at (mac.def->line, 0,
                      "not exporting %<#define %E%> as it is a keyword",
                      identifier (node));
          slot.offset = 0;
          continue;
        }

      count++;
      slot.offset = sec.pos;
      dump (dumper::MACRO)
        && dump ("Writing macro %s%s%s %I at %u",
                 slot.get_defness () & macro_import::slot::L_UNDEF
                 ? "#undef" : "",
                 slot.get_defness () == macro_import::slot::L_BOTH
                 ? " & " : "",
                 slot.get_defness () & macro_import::slot::L_DEF
                 ? "#define" : "",
                 identifier (node), slot.offset);
      if (mac.undef_loc != UNKNOWN_LOCATION)
        write_location (sec, mac.undef_loc);
      if (mac.def)
        write_define (sec, mac.def);
    }
  sec.end (to, to->name (MOD_SNAME_PFX ".def"), crc_p);

  if (count)
    {
      /* Write the table.  */
      bytes_out sec (to);
      sec.begin ();
      sec.u (count);

      for (unsigned ix = macros.length (); ix--;)
        {
          const cpp_hashnode *node = macros[ix];
          macro_import::slot &slot = (*macro_imports)[node->deferred - 1][0];

          if (slot.offset)
            {
              sec.cpp_node (node);
              sec.u (slot.get_defness ());
              sec.u (slot.offset);
            }
        }
      sec.end (to, to->name (MOD_SNAME_PFX ".mac"), crc_p);
    }

  macros.release ();
  dump.outdent ();
  return count;
}

bool
module_state::read_macros ()
{
  /* Get the def section.  */
  if (!slurp->macro_defs.begin (loc, from (), MOD_SNAME_PFX ".def"))
    return false;

  /* Get the tbl section, if there are defs. */
  if (slurp->macro_defs.more_p ()
      && !slurp->macro_tbl.begin (loc, from (), MOD_SNAME_PFX ".mac"))
    return false;

  return true;
}

/* Install the macro name table.  */

void
module_state::install_macros ()
{
  bytes_in &sec = slurp->macro_tbl;
  if (!sec.size)
    return;

  dump () && dump ("Reading macro table %M", this);
  dump.indent ();

  unsigned count = sec.u ();
  dump () && dump ("%u macros", count);
  while (count--)
    {
      cpp_hashnode *node = sec.cpp_node ();
      macro_import &imp = get_macro_imports (node);
      unsigned flags = sec.u () & macro_import::slot::L_BOTH;
      if (!flags)
        sec.set_overrun ();

      if (sec.get_overrun ())
        break;

      macro_import::slot &slot = imp.append (mod, flags);
      slot.offset = sec.u ();

      dump (dumper::MACRO)
        && dump ("Read %s macro %s%s%s %I at %u",
                 imp.length () > 1 ? "add" : "new",
                 flags & macro_import::slot::L_UNDEF ? "#undef" : "",
                 flags == macro_import::slot::L_BOTH ? " & " : "",
                 flags & macro_import::slot::L_DEF ? "#define" : "",
                 identifier (node), slot.offset);

      /* We'll leak an imported definition's TOKEN_FLD_STR's data
         here.  But that only happens when we've had to resolve the
         deferred macro before this import -- why are you doing
         that?  */
      if (cpp_macro *cur = cpp_set_deferred_macro (node))
        if (!cur->imported_p)
          {
            macro_import::slot &slot = imp.exported ();
            macro_export &exp = get_macro_export (slot);
            exp.def = cur;
            dump (dumper::MACRO)
              && dump ("Saving current #define %I", identifier (node));
          }
    }

  /* We're now done with the table.  */
  elf_in::release (slurp->from, sec);

  dump.outdent ();
}

/* Import the transitive macros.  */

void
module_state::import_macros ()
{
  bitmap_ior_into (headers, slurp->headers);

  bitmap_iterator bititer;
  unsigned bitnum;
  EXECUTE_IF_SET_IN_BITMAP (slurp->headers, 0, bitnum, bititer)
    (*modules)[bitnum]->install_macros ();
}

/* NODE is being undefined at LOC.  Record it in the export table, if
   necessary.  */

void
module_state::undef_macro (cpp_reader *, location_t loc, cpp_hashnode *node)
{
  if (!node->deferred)
    /* The macro is not imported, so our undef is irrelevant.  */
    return;

  unsigned n = dump.push (NULL);

  macro_import::slot &slot = (*macro_imports)[node->deferred - 1].exported ();
  macro_export &exp = get_macro_export (slot);

  exp.undef_loc = loc;
  slot.become_undef ();
  exp.def = NULL;

  dump (dumper::MACRO) && dump ("Recording macro #undef %I", identifier (node));

  dump.pop (n);
}

/* NODE is a deferred macro node.  Determine the definition and return
   it, with NULL if undefined.  May issue diagnostics.

   This can leak memory, when merging declarations -- the string
   contents (TOKEN_FLD_STR) of each definition are allocated in
   unreclaimable cpp objstack.  Only one will win.  However, I do not
   expect this to be common -- mostly macros have a single point of
   definition.  Perhaps we could restore the objstack to its position
   after the first imported definition (if that wins)?  The macros
   themselves are GC'd.  */

cpp_macro *
module_state::deferred_macro (cpp_reader *reader, location_t loc,
                              cpp_hashnode *node)
{
  macro_import &imports = (*macro_imports)[node->deferred - 1];

  unsigned n = dump.push (NULL);
  dump (dumper::MACRO) && dump ("Deferred macro %I", identifier (node));

  bitmap visible (BITMAP_GGC_ALLOC ());

  if (!((imports[0].get_defness () & macro_import::slot::L_UNDEF)
        && !imports[0].get_module ()))
    {
      /* Calculate the set of visible header imports.  */
      bitmap_copy (visible, headers);
      for (unsigned ix = imports.length (); ix--;)
        {
          const macro_import::slot &slot = imports[ix];
          unsigned mod = slot.get_module ();
          if ((slot.get_defness () & macro_import::slot::L_UNDEF)
              && bitmap_bit_p (visible, mod))
            {
              bitmap arg = mod ? (*modules)[mod]->slurp->headers : headers;
              bitmap_and_compl_into (visible, arg);
              bitmap_set_bit (visible, mod);
            }
        }
    }
  bitmap_set_bit (visible, 0);

  /* Now find the macros that are still visible.  */
  bool failed = false;
  cpp_macro *def = NULL;
  vec<macro_export> defs;
  defs.create (imports.length ());
  for (unsigned ix = imports.length (); ix--;)
    {
      const macro_import::slot &slot = imports[ix];
      unsigned mod = slot.get_module ();
      if (bitmap_bit_p (visible, mod))
        {
          macro_export *pushed = NULL;
          if (mod)
            {
              const module_state *imp = (*modules)[mod];
              bytes_in &sec = imp->slurp->macro_defs;
              if (!sec.get_overrun ())
                {
                  dump (dumper::MACRO)
                    && dump ("Reading macro %s%s%s %I module %M at %u",
                             slot.get_defness () & macro_import::slot::L_UNDEF
                             ? "#undef" : "",
                             slot.get_defness () == macro_import::slot::L_BOTH
                             ? " & " : "",
                             slot.get_defness () & macro_import::slot::L_DEF
                             ? "#define" : "",
                             identifier (node), imp, slot.offset);
                  sec.random_access (slot.offset);

                  macro_export exp;
                  if (slot.get_defness () & macro_import::slot::L_UNDEF)
                    exp.undef_loc = imp->read_location (sec);
                  if (slot.get_defness () & macro_import::slot::L_DEF)
                    exp.def = imp->read_define (sec, reader);
                  if (sec.get_overrun ())
                    error_at (loc, "macro definitions of %qE corrupted",
                              imp->name);
                  else
                    pushed = defs.quick_push (exp);
                }
            }
          else
            pushed = defs.quick_push ((*macro_exports)[slot.offset]);
          if (pushed && pushed->def)
            {
              if (!def)
                def = pushed->def;
              else if (cpp_compare_macros (def, pushed->def))
                failed = true;
            }
        }
    }

  if (failed)
    {
      /* If LOC is the first loc, this is the end of file check, which
         is a warning.  */
      if (loc == MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (line_table, 0)))
        warning_at (loc, OPT_Winvalid_imported_macros,
                    "inconsistent imported macro definition %qE",
                    identifier (node));
      else
        error_at (loc, "inconsistent imported macro definition %qE",
                  identifier (node));
      for (unsigned ix = defs.length (); ix--;)
        {
          macro_export &exp = defs[ix];
          if (exp.undef_loc)
            inform (exp.undef_loc, "%<#undef %E%>", identifier (node));
          if (exp.def)
            inform (exp.def->line, "%<#define %s%>",
                    cpp_macro_definition (reader, node, exp.def));
        }
      def = NULL;
    }

  defs.release ();

  dump.pop (n);

  return def;
}

/* Stream the static aggregates.  Sadly some headers (ahem:
   iostream) contain static vars, and rely on them to run global
   ctors.  */
unsigned
module_state::write_inits (elf_out *to, depset::hash &table, unsigned *crc_ptr)
{
  if (!static_aggregates && !tls_aggregates)
    return 0;

  dump () && dump ("Writing initializers");
  dump.indent ();

  static_aggregates = nreverse (static_aggregates);
  tls_aggregates = nreverse (tls_aggregates);

  unsigned count = 0;
  trees_out sec (to, this, table, ~0u);
  sec.begin ();

  tree list = static_aggregates;
  for (int passes = 0; passes != 2; passes++)
    {
      for (tree init = list; init; init = TREE_CHAIN (init), count++)
        if (TREE_LANG_FLAG_0 (init))
          {
            tree decl = TREE_VALUE (init);

            dump ("Initializer:%u for %N", count, decl);
            sec.tree_node (decl);
          }

      list = tls_aggregates;
    }
  
  sec.end (to, to->name (MOD_SNAME_PFX ".ini"), crc_ptr);
  dump.outdent ();

  return count;
}

bool
module_state::read_inits (unsigned count)
{
  trees_in sec (this);
  if (!sec.begin (loc, from (), from ()->find (MOD_SNAME_PFX ".ini")))
    return false;
  dump () && dump ("Reading %u initializers", count);
  dump.indent ();

  for (unsigned ix = 0; ix != count; ix++)
    {
      /* Merely referencing the decl causes its initializer to be read
         and added to the correct list.  */
      tree decl = sec.tree_node ();

      if (sec.get_overrun ())
        break;
      if (decl)
        dump ("Initializer:%u for %N", count, decl);
    }
  dump.outdent ();
  if (!sec.end (from ()))
    return false;  
  return true;
}

void
module_state::write_counts (elf_out *to, unsigned counts[MSC_HWM],
                            unsigned *crc_ptr)
{
  bytes_out cfg (to);

  cfg.begin ();

  for (unsigned ix = MSC_HWM; ix--;)
    cfg.u (counts[ix]);

  if (dump ())
    {
      dump ("Cluster sections are [%u,%u)",
            counts[MSC_sec_lwm], counts[MSC_sec_hwm]);
      dump ("Bindings %u", counts[MSC_bindings]);
      dump ("Pendings %u", counts[MSC_pendings]);
      dump ("Entities %u", counts[MSC_entities]);
      dump ("Namespaces %u", counts[MSC_namespaces]);
      dump ("Macros %u", counts[MSC_macros]);
      dump ("Initializers %u", counts[MSC_inits]);
    }

  cfg.end (to, to->name (MOD_SNAME_PFX ".cnt"), crc_ptr);
}

bool
module_state::read_counts (unsigned counts[MSC_HWM])
{
  bytes_in cfg;

  if (!cfg.begin (loc, from (), MOD_SNAME_PFX ".cnt"))
    return false;

  for (unsigned ix = MSC_HWM; ix--;)
    counts[ix] = cfg.u ();

  if (dump ())
    {
      dump ("Declaration sections are [%u,%u)",
            counts[MSC_sec_lwm], counts[MSC_sec_hwm]);
      dump ("Bindings %u", counts[MSC_bindings]);
      dump ("Pendings %u", counts[MSC_pendings]);
      dump ("Entities %u", counts[MSC_entities]);
      dump ("Namespaces %u", counts[MSC_namespaces]);
      dump ("Macros %u", counts[MSC_macros]);
      dump ("Initializers %u", counts[MSC_inits]);
    }

  return cfg.end (from ());
}

/* Tool configuration:  MOD_SNAME_PFX .config

   This is data that confirms current state (or fails).  */

void
module_state::write_config (elf_out *to, module_state_config &config,
                            unsigned inner_crc)
{
  bytes_out cfg (to);

  cfg.begin ();

  /* Write version and inner crc as u32 values, for easier
     debug inspection.  */
  dump () && dump ("Writing version=%V, inner_crc=%x",
                   MODULE_VERSION, inner_crc);
  cfg.u32 (unsigned (MODULE_VERSION));
  cfg.u32 (inner_crc);

  cfg.u (to->name (is_header () ? "" : get_flatname ()));

  /* Configuration. */
  dump () && dump ("Writing target='%s', host='%s'",
                   TARGET_MACHINE, HOST_MACHINE);
  unsigned target = to->name (TARGET_MACHINE);
  unsigned host = (!strcmp (TARGET_MACHINE, HOST_MACHINE)
                   ? target : to->name (HOST_MACHINE));
  cfg.u (target);
  cfg.u (host);

  cfg.str (config.dialect_str);
  cfg.u (extensions);

  /* Global tree information.  We write the globals crc separately,
     rather than mix it directly into the overall crc, as it is used
     to ensure data match between instances of the compiler, not
     integrity of the file.  */
  dump () && dump ("Writing globals=%u, crc=%x",
                   fixed_trees->length (), global_crc);
  cfg.u (fixed_trees->length ());
  cfg.u32 (global_crc);

  if (is_partition ())
    cfg.u (is_interface ());

  cfg.u (config.num_imports);
  cfg.u (config.num_partitions);

  cfg.u (config.ordinary_locs);
  cfg.u (config.macro_locs);
  cfg.u (config.ordinary_loc_align);  

  /* Now generate CRC, we'll have incorporated the inner CRC because
     of its serialization above.  */
  cfg.end (to, to->name (MOD_SNAME_PFX ".cfg"), &crc);
  dump () && dump ("Writing CRC=%x", crc);
}

void
module_state::note_cmi_name ()
{
  if (!cmi_noted_p && filename)
    {
      cmi_noted_p = true;
      inform (loc, "compiled module file is %qs",
              maybe_add_cmi_prefix (filename));
    }
}

bool
module_state::read_config (module_state_config &config)
{
  bytes_in cfg;

  if (!cfg.begin (loc, from (), MOD_SNAME_PFX ".cfg"))
    return false;

  /* Check version.  */
  unsigned my_ver = MODULE_VERSION;
  unsigned their_ver = cfg.u32 ();
  dump () && dump  (my_ver == their_ver ? "Version %V"
                    : "Expecting %V found %V", my_ver, their_ver);
  if (their_ver != my_ver)
    {
      /* The compiler versions differ.  Close enough? */
      verstr_t my_string, their_string;

      version2string (my_ver, my_string);
      version2string (their_ver, their_string);

      /* Reject when either is non-experimental or when experimental
         major versions differ.  */
      bool reject_p = ((!IS_EXPERIMENTAL (my_ver)
                        || !IS_EXPERIMENTAL (their_ver)
                        || MODULE_MAJOR (my_ver) != MODULE_MAJOR (their_ver))
                       /* The 'I know what I'm doing' switch.  */
                       && !flag_module_version_ignore);
      bool inform_p = true;
      if (reject_p)
        {
          cfg.set_overrun ();
          error_at (loc, "compiled module is %sversion %s",
                    IS_EXPERIMENTAL (their_ver) ? "experimental " : "",
                    their_string);
        }
      else
        inform_p = warning_at (loc, 0, "compiled module is %sversion %s",
                             IS_EXPERIMENTAL (their_ver) ? "experimental " : "",
                             their_string);

      if (inform_p)
        {
          inform (loc, "compiler is %sversion %s%s%s",
                  IS_EXPERIMENTAL (my_ver) ? "experimental " : "",
                  my_string,
                  reject_p ? "" : flag_module_version_ignore
                  ? ", be it on your own head!" : ", close enough?",
                  reject_p ? "" : " \xc2\xaf\\_(\xe3\x83\x84)_/\xc2\xaf");
          note_cmi_name ();
        }

      if (reject_p)
        goto done;
    }

  /*  We wrote the inner crc merely to merge it, so simply read it
      back and forget it.  */
  cfg.u32 ();

  /* Check module name.  */
  {
    const char *their_name = from ()->name (cfg.u ());
    const char *our_name = "";

    if (!is_header ())
      our_name = get_flatname ();

    /* Header units can be aliased, so name checking is
       inappropriate.  */
    if (0 != strcmp (their_name, our_name))
      {
        error_at (loc,
                  their_name[0] && our_name[0] ? G_("module %qs found")
                  : their_name[0]
                  ? G_("header module expected, module %qs found")
                  : G_("module %qs expected, header module found"),
                  their_name[0] ? their_name : our_name);
        cfg.set_overrun ();
        goto done;
      }
  }

  /* Check the CRC after the above sanity checks, so that the user is
     clued in.  */
  {
    unsigned e_crc = crc;
    crc = cfg.get_crc ();
    dump () && dump ("Reading CRC=%x", crc);
    if (!is_direct () && crc != e_crc)
      {
        error_at (loc, "module %qs CRC mismatch", get_flatname ());
        cfg.set_overrun ();
        goto done;
      }
  }

  /* Check target & host.  */
  {
    const char *their_target = from ()->name (cfg.u ());
    const char *their_host = from ()->name (cfg.u ());
    dump () && dump ("Read target='%s', host='%s'", their_target, their_host);
    if (strcmp (their_target, TARGET_MACHINE)
        || strcmp (their_host, HOST_MACHINE))
      {
        error_at (loc, "target & host is %qs:%qs, expected %qs:%qs",
                  their_target, TARGET_MACHINE, their_host, HOST_MACHINE);
        cfg.set_overrun ();
        goto done;
      }
  }

  /* Check compilation dialect.  This must match.  */
  {
    const char *their_dialect = cfg.str ();
    if (strcmp (their_dialect, config.dialect_str))
      {
        error_at (loc, "language dialect differs %qs, expected %qs",
                  their_dialect, config.dialect_str);
        cfg.set_overrun ();
        goto done;
      }
  }

  /* Check for extensions.  If they set any, we must have them set
     too.  */
  {
    unsigned ext = cfg.u ();
    unsigned allowed = (flag_openmp ? SE_OPENMP : 0);

    if (unsigned bad = ext & ~allowed)
      {
        if (bad & SE_OPENMP)
          error_at (loc, "module contains OpenMP, use %<-fopenmp%> to enable");
        cfg.set_overrun ();
        goto done;
      }
    extensions = ext;
  }

  /* Check global trees.  */
  {
    unsigned their_fixed_length = cfg.u ();
    unsigned their_fixed_crc = cfg.u32 ();
    dump () && dump ("Read globals=%u, crc=%x",
                     their_fixed_length, their_fixed_crc);
    if (!flag_preprocess_only
        && (their_fixed_length != fixed_trees->length ()
            || their_fixed_crc != global_crc))
      {
        error_at (loc, "fixed tree mismatch");
        cfg.set_overrun ();
        goto done;
      }
  }

  /* All non-partitions are interfaces.  */
  interface_p = !is_partition () || cfg.u ();

  config.num_imports = cfg.u ();
  config.num_partitions = cfg.u ();

  config.ordinary_locs = cfg.u ();
  config.macro_locs = cfg.u ();
  config.ordinary_loc_align = cfg.u ();

 done:
  return cfg.end (from ());
}

/* Use ELROND format to record the following sections:
     qualified-names        : binding value(s)
     MOD_SNAME_PFX.README   : human readable, strings
     MOD_SNAME_PFX.ENV      : environment strings, strings
     MOD_SNAME_PFX.nms      : namespace hierarchy
     MOD_SNAME_PFX.bnd      : binding table
     MOD_SNAME_PFX.spc      : specialization table
     MOD_SNAME_PFX.imp      : import table
     MOD_SNAME_PFX.ent      : entity table
     MOD_SNAME_PFX.prt      : partitions table
     MOD_SNAME_PFX.olm      : ordinary line maps
     MOD_SNAME_PFX.mlm      : macro line maps
     MOD_SNAME_PFX.def      : macro definitions
     MOD_SNAME_PFX.mac      : macro index
     MOD_SNAME_PFX.ini      : inits
     MOD_SNAME_PFX.cnt      : counts
     MOD_SNAME_PFX.cfg      : config data
*/

void
module_state::write (elf_out *to, cpp_reader *reader)
{
  /* Figure out remapped module numbers, which might elide
     partitions.  */
  bitmap partitions = NULL;
  if (!is_header () && !is_partition ())
    partitions = BITMAP_GGC_ALLOC ();

  unsigned mod_hwm = 1;
  for (unsigned ix = 1; ix != modules->length (); ix++)
    {
      module_state *imp = (*modules)[ix];

      /* Promote any non-partition direct import from a partition, unless
         we're a partition.  */
      if (!is_partition () && !imp->is_partition ()
          && imp->is_partition_direct ())
        imp->directness = MD_PURVIEW_DIRECT;

      /* Write any import that is not a partition, unless we're a
         partition.  */
      if (!partitions || !imp->is_partition ())
        imp->remap = mod_hwm++;
      else
        {
          dump () && dump ("Partition %M %u", imp, ix);
          bitmap_set_bit (partitions, ix);
          imp->remap = 0;
          /* All interface partitions must be exported.  */
          if (imp->is_interface () && !bitmap_bit_p (exports, imp->mod))
            {
              error_at (imp->loc, "interface partition is not exported");
              bitmap_set_bit (exports, imp->mod);
            }

          /* All the partition entities should have been loaded when
             loading the partition.  */
          if (CHECKING_P)
            for (unsigned jx = 0; jx != imp->entity_num; jx++)
              {
                binding_slot *slot = &(*entity_ary)[imp->entity_lwm + jx];
                gcc_checking_assert (!slot->is_lazy ());
              }
        }
    }

  if (partitions && bitmap_empty_p (partitions))
    /* No partitions present.  */
    partitions = nullptr;

  /* Find the set of decls we must write out.  */
  depset::hash table (DECL_NAMESPACE_BINDINGS (global_namespace)->size () * 8);
  /* Add the specializations before the writables, so that we can
     detect injected friend specializations.  */
  table.add_specializations (true);
  table.add_specializations (false);
  if (partial_specializations)
    {
      table.add_partial_entities (partial_specializations);
      partial_specializations = NULL;
    }
  table.add_namespace_entities (global_namespace, partitions);
  if (class_members)
    {
      table.add_class_entities (class_members);
      class_members = NULL;
    }

  /* Now join everything up.  */
  table.find_dependencies ();

  if (!table.finalize_dependencies ())
    {
      to->set_error ();
      return;
    }

#if CHECKING_P
  /* We're done verifying at-most once reading, reset to verify
     at-most once writing.  */
  note_defs = note_defs_table_t::create_ggc (1000);
#endif

  /* Determine Strongy Connected Components.  */
  vec<depset *> sccs = table.connect ();

  unsigned crc = 0;
  module_state_config config;
  location_map_info map_info = write_prepare_maps (&config);
  unsigned counts[MSC_HWM];

  config.num_imports = mod_hwm;
  config.num_partitions = modules->length () - mod_hwm;
  memset (counts, 0, sizeof (counts));

  /* depset::cluster is the cluster number,
     depset::section is unspecified scratch value.

     The following loops make use of the tarjan property that
     dependencies will be earlier in the SCCS array.  */

  /* This first loop determines the number of depsets in each SCC, and
     also the number of namespaces we're dealing with.  During the
     loop, the meaning of a couple of depset fields now change:

     depset::cluster -> size_of cluster, if first of cluster & !namespace
     depset::section -> section number of cluster (if !namespace). */

  unsigned n_spaces = 0;
  counts[MSC_sec_lwm] = counts[MSC_sec_hwm] = to->get_section_limit ();
  for (unsigned size, ix = 0; ix < sccs.length (); ix += size)
    {
      depset **base = &sccs[ix];

      if (base[0]->get_entity_kind () == depset::EK_NAMESPACE)
        {
          n_spaces++;
          size = 1;
        }
      else
        {
          /* Count the members in this cluster.  */
          for (size = 1; ix + size < sccs.length (); size++)
            if (base[size]->cluster != base[0]->cluster)
              break;

          for (unsigned jx = 0; jx != size; jx++)
            {
              /* Set the section number.  */
              base[jx]->cluster = ~(~0u >> 1); /* A bad value.  */
              base[jx]->section = counts[MSC_sec_hwm];
            }

          /* Save the size in the first member's cluster slot.  */
          base[0]->cluster = size;

          counts[MSC_sec_hwm]++;
        }
    }

  /* Write the clusters.  Namespace decls are put in the spaces array.
     The meaning of depset::cluster changes to provide the
     unnamed-decl count of the depset's decl (and remains zero for
     non-decls and non-unnamed).  */
  unsigned bytes = 0;
  vec<depset *> spaces;
  spaces.create (n_spaces);

  for (unsigned size, ix = 0; ix < sccs.length (); ix += size)
    {
      depset **base = &sccs[ix];

      if (base[0]->get_entity_kind () == depset::EK_NAMESPACE)
        {
          tree decl = base[0]->get_entity ();
          if (decl == global_namespace)
            base[0]->cluster = 0;
          else if (!base[0]->is_import ())
            {
              base[0]->cluster = counts[MSC_entities]++;
              spaces.quick_push (base[0]);
              counts[MSC_namespaces]++;
              if (CHECKING_P)
                {
                  /* Add it to the entity map, such that we can tell it is
                     part of us.  */
                  bool existed;
                  unsigned *slot = &entity_map->get_or_insert
                    (DECL_UID (decl), &existed);
                  if (existed)
                    /* It must have come from a partition.  */
                    gcc_checking_assert
                      (import_entity_module (*slot)->is_partition ());
                  *slot = ~base[0]->cluster;
                }
              dump (dumper::CLUSTER) && dump ("Cluster namespace %N", decl);
            }
          size = 1;
        }
      else
        {
          size = base[0]->cluster;

          /* Cluster is now used to number entities.  */
          base[0]->cluster = ~(~0u >> 1); /* A bad value.  */

          sort_cluster (&table, base, size);

          /* Record the section for consistency checking during stream
             out -- we don't want to start writing decls in different
             sections.  */
          table.section = base[0]->section;
          bytes += write_cluster (to, base, size, table, counts, &crc);
          table.section = 0;
        }
    }

  /* We'd better have written as many sections and found as many
     namespaces as we predicted.  */
  gcc_assert (counts[MSC_sec_hwm] == to->get_section_limit ()
              && spaces.length () == counts[MSC_namespaces]);

  /* Write the entitites.  None happens if we contain namespaces or
     nothing. */
  if (counts[MSC_entities])
    write_entities (to, sccs, counts[MSC_entities], &crc);

  /* Write the namespaces.  */
  if (counts[MSC_namespaces])
    write_namespaces (to, spaces, counts[MSC_namespaces], &crc);

  /* Write the bindings themselves.  */
  counts[MSC_bindings] = write_bindings (to, sccs, &crc);

  /* Write the unnamed.  */
  if (counts[MSC_pendings])
    write_pendings (to, sccs, table, counts[MSC_pendings], &crc);

  /* Write the import table.  */
  if (config.num_imports > 1)
    write_imports (to, &crc);

  /* Write elided partition table.  */
  if (config.num_partitions)
    write_partitions (to, config.num_partitions, &crc);

  /* Write the line maps.  */
  write_ordinary_maps (to, map_info, &config, config.num_partitions, &crc);
  write_macro_maps (to, map_info, &config, &crc);

  if (is_header ())
    {
      counts[MSC_macros] = write_macros (to, reader, &crc);
      counts[MSC_inits] = write_inits (to, table, &crc);
    }

  unsigned clusters = counts[MSC_sec_hwm] - counts[MSC_sec_lwm];
  dump () && dump ("Wrote %u clusters, average %u bytes/cluster",
                   clusters, (bytes + clusters / 2) / (clusters + !clusters));

  write_counts (to, counts, &crc);

  /* And finish up.  */
  write_config (to, config, crc);

  spaces.release ();
  sccs.release ();

  /* Human-readable info.  */
  write_readme (to, reader, config.dialect_str, extensions);

  // FIXME:QOI:  Have a command line switch to control more detailed
  // information (which might leak data you do not want to leak).
  // Perhaps (some of) the write_readme contents should also be
  // so-controlled.
  if (false)
    write_env (to);

  trees_out::instrument ();
  dump () && dump ("Wrote %u sections", to->get_section_limit ());
}

/* Initial read of a CMI.  Checks config, loads up imports and line
   maps.  */

bool
module_state::read_initial (cpp_reader *reader)
{
  module_state_config config;
  bool ok = true;

  if (ok && !from ()->begin (loc))
    ok = false;

  if (ok && !read_config (config))
    ok = false;

  bool have_locs = ok && read_prepare_maps (&config);

  /* Ordinary maps before the imports.  */
  if (have_locs && !read_ordinary_maps ())
    ok = false;

  /* Allocate the REMAP vector.  */
  slurp->alloc_remap (config.num_imports);

  if (ok)
    {
      /* Read the import table.  Decrement current to stop this CMI
         from being evicted during the import. */
      slurp->current--;
      if (config.num_imports > 1 && !read_imports (reader, line_table))
        ok = false;
      slurp->current++;
    }

  /* Read the elided partition table, if we're the primary partition.  */
  if (ok && config.num_partitions && is_module ()
      && !read_partitions (config.num_partitions))
    ok = false;

  /* Determine the module's number.  */
  gcc_checking_assert (mod == MODULE_UNKNOWN);
  gcc_checking_assert (this != (*modules)[0]);

  /* We'll run out of other resources before we run out of module
     indices.  */
  mod = modules->length ();
  vec_safe_push (modules, this);

  /* We always import and export ourselves. */
  bitmap_set_bit (imports, mod);
  bitmap_set_bit (exports, mod);

  if (ok)
    (*slurp->remap)[0] = mod << 1;
  dump () && dump ("Assigning %M module number %u", this, mod);

  /* We should not have been frozen during the importing done by
     read_config.  */
  gcc_assert (!from ()->is_frozen ());

  /* Macro maps after the imports.  */
  if (ok && have_locs && !read_macro_maps ())
    ok = false;

  gcc_assert (slurp->current == ~0u);
  return ok;
}

/* Read a preprocessor state.  */

bool
module_state::read_preprocessor (bool outermost)
{
  gcc_checking_assert (is_header () && slurp
                       && slurp->remap_module (0) == mod);

  if (loadedness == ML_PREPROCESSOR)
    return !(from () && from ()->get_error ());

  bool ok = true;

  /* Read direct header imports.  */
  unsigned len = slurp->remap->length ();
  for (unsigned ix = 1; ok && ix != len; ix++)
    {
      unsigned map = (*slurp->remap)[ix];
      if (map & 1)
        {
          module_state *import = (*modules)[map >> 1];
          if (import->is_header ())
            {
              ok = import->read_preprocessor (false);
              bitmap_ior_into (slurp->headers, import->slurp->headers);
            }
        }
    }

  /* Record as a direct header.  */
  if (ok)
    bitmap_set_bit (slurp->headers, mod);

  if (ok && !read_macros ())
    ok = false;

  loadedness = ML_PREPROCESSOR;
  announce ("macros");

  if (flag_preprocess_only)
    /* We're done with the string table.  */
    from ()->release ();

  return check_read (outermost, ok);
}

static unsigned lazy_snum;

static bool
recursive_lazy (unsigned snum = ~0u)
{
  if (lazy_snum)
    {
      error_at (input_location, "recursive lazy load");
      return true;
    }

  lazy_snum = snum;
  return false;
}

/* Read language state.  */

bool
module_state::read_language (bool outermost)
{
  gcc_checking_assert (!lazy_snum);

  if (loadedness == ML_LANGUAGE)
    return !(slurp && from () && from ()->get_error ());

  gcc_checking_assert (slurp && slurp->current == ~0u
                       && slurp->remap_module (0) == mod);

  bool ok = true;

  /* Read direct imports.  */
  unsigned len = slurp->remap->length ();
  for (unsigned ix = 1; ok && ix != len; ix++)
    {
      unsigned map = (*slurp->remap)[ix];
      if (map & 1)
        {
          module_state *import = (*modules)[map >> 1];
          if (!import->read_language (false))
            ok = false;
        }
    }

  unsigned counts[MSC_HWM];

  if (ok && !read_counts (counts))
    ok = false;

  function_depth++; /* Prevent unexpected GCs.  */

  /* Read the entity table.  */
  entity_lwm = vec_safe_length (entity_ary);
  if (ok && counts[MSC_entities]
      && !read_entities (counts[MSC_entities],
                         counts[MSC_sec_lwm], counts[MSC_sec_hwm]))
    ok = false;

  /* Read the namespace hierarchy. */
  if (ok && counts[MSC_namespaces]
      && !read_namespaces (counts[MSC_namespaces]))
    ok = false;

  if (ok && !read_bindings (counts[MSC_bindings],
                            counts[MSC_sec_lwm], counts[MSC_sec_hwm]))
    ok = false;

  /* And unnamed.  */
  if (ok && counts[MSC_pendings] && !read_pendings (counts[MSC_pendings]))
    ok = false;

  if (ok)
    {
      slurp->remaining = counts[MSC_sec_hwm] - counts[MSC_sec_lwm];
      available_clusters += counts[MSC_sec_hwm] - counts[MSC_sec_lwm];
    }

  if (!flag_module_lazy
      || (is_partition ()
          && module_interface_p ()
          && !module_partition_p ()))
    {
      /* Read the sections in forward order, so that dependencies are read
         first.  See note about tarjan_connect.  */
      ggc_collect ();

      lazy_snum = ~0u;

      unsigned hwm = counts[MSC_sec_hwm];
      for (unsigned ix = counts[MSC_sec_lwm]; ok && ix != hwm; ix++)
        {
          if (!load_section (ix, NULL))
            {
              ok = false;
              break;
            }
          ggc_collect ();
        }

      lazy_snum = 0;

      if (ok && CHECKING_P)
        for (unsigned ix = 0; ix != entity_num; ix++)
          gcc_assert (!(*entity_ary)[ix + entity_lwm].is_lazy ());
    }

  // If the import is a header-unit, we need to register initializers
  // of any static objects it contains (looking at you _Ioinit).
  // Notice, the ordering of these initializers will be that of a
  // dynamic initializer at this point in the current TU.  (Other
  // instances of these objects in other TUs will be initialized as
  // part of that TU's global initializers.)
  if (ok && counts[MSC_inits] && !read_inits (counts[MSC_inits]))
    ok = false;

  function_depth--;
  
  announce (flag_module_lazy ? "lazy" : "imported");
  loadedness = ML_LANGUAGE;

  gcc_assert (slurp->current == ~0u);

  /* We're done with the string table.  */
  from ()->release ();

  return check_read (outermost, ok);
}

bool
module_state::maybe_defrost ()
{
  bool ok = true;
  if (from ()->is_frozen ())
    {
      if (lazy_open >= lazy_limit)
        freeze_an_elf ();
      dump () && dump ("Defrosting '%s'", filename);
      ok = from ()->defrost (maybe_add_cmi_prefix (filename));
      lazy_open++;
    }

  return ok;
}

/* Load section SNUM, dealing with laziness.  It doesn't matter if we
   have multiple concurrent loads, because we do not use TREE_VISITED
   when reading back in.  */

bool
module_state::load_section (unsigned snum, binding_slot *mslot)
{
  if (from ()->get_error ())
    return false;

  if (snum >= slurp->current)
    from ()->set_error (elf::E_BAD_LAZY);
  else if (maybe_defrost ())
    {
      unsigned old_current = slurp->current;
      slurp->current = snum;
      slurp->lru = 0;  /* Do not swap out.  */
      slurp->remaining--;
      read_cluster (snum);
      slurp->lru = ++lazy_lru;
      slurp->current = old_current;
    }
  
  if (mslot && mslot->is_lazy ())
    {
      /* Oops, the section didn't set this slot.  */
      from ()->set_error (elf::E_BAD_DATA);
      *mslot = NULL_TREE;
    }

  bool ok = !from ()->get_error ();
  if (!ok)
    {
      error_at (loc, "failed to read compiled module cluster %u: %s",
                snum, from ()->get_error (filename));
      note_cmi_name ();
    }

  maybe_completed_reading ();

  return ok;
}

void
module_state::maybe_completed_reading ()
{
  if (loadedness == ML_LANGUAGE && slurp->current == ~0u && !slurp->remaining)
    {
      lazy_open--;
      /* We no longer need the macros, all tokenizing has been done.  */
      slurp->release_macros ();

      from ()->end ();
      slurp->close ();
      slurped ();
    }
}

/* After a reading operation, make sure things are still ok.  If not,
   emit an error and clean up.  */

bool
module_state::check_read (bool outermost, bool ok)
{
  gcc_checking_assert (!outermost || slurp->current == ~0u);

  if (!ok)
    from ()->set_error ();

  if (int e = from ()->get_error ())
    {
      error_at (loc, "failed to read compiled module: %s",
                from ()->get_error (filename));
      note_cmi_name ();

      if (e == EMFILE
          || e == ENFILE
#if MAPPED_READING
          || e == ENOMEM
#endif
          || false)
        inform (loc, "consider using %<-fno-module-lazy%>,"
                " increasing %<-param-lazy-modules=%u%> value,"
                " or increasing the per-process file descriptor limit",
                param_lazy_modules);
      else if (e == ENOENT)
        inform (loc, "imports must be built before being imported");

      if (outermost)
        fatal_error (loc, "returning to the gate for a mechanical issue");

      ok = false;
    }

  maybe_completed_reading ();

  return ok;
}

/* Return the IDENTIFIER_NODE naming module IX.  This is the name
   including dots.  */

char const *
module_name (unsigned ix, bool header_ok)
{
  if (modules)
    {
      module_state *imp = (*modules)[ix];

      if (ix && !imp->name)
        imp = imp->parent;

      if (header_ok || !imp->is_header ())
        return imp->get_flatname ();
    }

  return NULL;
}

/* Return the bitmap describing what modules are imported.  Remember,
   we always import ourselves.  */

bitmap
get_import_bitmap ()
{
  return (*modules)[0]->imports;
}

/* Return the visible imports and path of instantiation for an
   instantiation at TINST.  If TINST is nullptr, we're not in an
   instantiation, and thus will return the visible imports of the
   current TU (and NULL *PATH_MAP_P).   We cache the information on
   the tinst level itself.  */

static bitmap
path_of_instantiation (tinst_level *tinst,  bitmap *path_map_p)
{
  gcc_checking_assert (modules_p ());

  if (!tinst)
    {
      /* Not inside an instantiation, just the regular case.  */
      *path_map_p = nullptr;
      return get_import_bitmap ();
    }

  if (!tinst->path)
    {
      /* Calculate.  */
      bitmap visible = path_of_instantiation (tinst->next, path_map_p);
      bitmap path_map = *path_map_p;

      if (!path_map)
        {
          path_map = BITMAP_GGC_ALLOC ();
          bitmap_set_bit (path_map, 0);
        }

      tree decl = tinst->tldcl;
      if (TREE_CODE (decl) == TREE_LIST)
        decl = TREE_PURPOSE (decl);
      if (TYPE_P (decl))
        decl = TYPE_NAME (decl);

      if (unsigned mod = get_originating_module (decl))
        if (!bitmap_bit_p (path_map, mod))
          {
            /* This is brand new information!  */
            bitmap new_path = BITMAP_GGC_ALLOC ();
            bitmap_copy (new_path, path_map);
            bitmap_set_bit (new_path, mod);
            path_map = new_path;

            bitmap imports = (*modules)[mod]->imports;
            if (bitmap_intersect_compl_p (imports, visible))
              {
                /* IMPORTS contains additional modules to VISIBLE.  */
                bitmap new_visible = BITMAP_GGC_ALLOC ();

                bitmap_ior (new_visible, visible, imports);
                visible = new_visible;
              }
          }

      tinst->path = path_map;
      tinst->visible = visible;
    }

  *path_map_p = tinst->path;
  return tinst->visible;
}

/* Return the bitmap describing what modules are visible along the
   path of instantiation.  If we're not an instantiation, this will be
   the visible imports of the TU.  *PATH_MAP_P is filled in with the
   modules owning the instantiation path -- we see the module-linkage
   entities of those modules.  */

bitmap
visible_instantiation_path (bitmap *path_map_p)
{
  if (!modules_p ())
    return NULL;

  return path_of_instantiation (current_instantiation (), path_map_p);
}

/* We've just directly imported IMPORT.  Update our import/export
   bitmaps.  IS_EXPORT is true if we're reexporting the OTHER.  */

void
module_state::set_import (module_state const *import, bool is_export)
{
  gcc_checking_assert (this != import);

  /* We see IMPORT's exports (which includes IMPORT).  If IMPORT is
     the primary interface or a partition we'll see its imports.  */
  bitmap_ior_into (imports, import->is_module () || import->is_partition ()
                   ? import->imports : import->exports);

  if (is_export)
    /* We'll export OTHER's exports.  */
    bitmap_ior_into (exports, import->exports);
}

/* Return the declaring entity of DECL.  That is the decl determining
   how to decorate DECL with module information.  Returns NULL_TREE if
   it's the global module.  */

tree
get_originating_module_decl (tree decl)
{
  /* An enumeration constant.  */
  if (TREE_CODE (decl) == CONST_DECL
      && DECL_CONTEXT (decl)
      && (TREE_CODE (DECL_CONTEXT (decl)) == ENUMERAL_TYPE))
    decl = TYPE_NAME (DECL_CONTEXT (decl));
  else if (TREE_CODE (decl) == FIELD_DECL
           || TREE_CODE (decl) == USING_DECL)
    {
      decl = DECL_CONTEXT (decl);
      if (TREE_CODE (decl) != FUNCTION_DECL)
        decl = TYPE_NAME (decl);
    }

  gcc_checking_assert (TREE_CODE (decl) == TEMPLATE_DECL
                       || TREE_CODE (decl) == FUNCTION_DECL
                       || TREE_CODE (decl) == TYPE_DECL
                       || TREE_CODE (decl) == VAR_DECL
                       || TREE_CODE (decl) == CONCEPT_DECL
                       || TREE_CODE (decl) == NAMESPACE_DECL);

  for (;;)
    {
      /* Uninstantiated template friends are owned by the befriending
         class -- not their context.  */
      if (TREE_CODE (decl) == TEMPLATE_DECL
          && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl))
        decl = TYPE_NAME (DECL_CHAIN (decl));

      int use;
      if (tree ti = node_template_info (decl, use))
        {
          decl = TI_TEMPLATE (ti);
          if (TREE_CODE (decl) != TEMPLATE_DECL)
            {
              /* A friend template specialization.  */
              gcc_checking_assert (OVL_P (decl));
              return global_namespace;
            }
        }
      else
        {
          tree ctx = CP_DECL_CONTEXT (decl);
          if (TREE_CODE (ctx) == NAMESPACE_DECL)
            break;

          if (TYPE_P (ctx))
            {
              ctx = TYPE_NAME (ctx);
              if (!ctx)
                {
                  /* Some kind of internal type.  */
                  gcc_checking_assert (DECL_ARTIFICIAL (decl));
                  return global_namespace;
                }
            }
          decl = ctx;
        }
    }

  return decl;
}

int
get_originating_module (tree decl, bool for_mangle)
{
  tree owner = get_originating_module_decl (decl);

  if (!DECL_LANG_SPECIFIC (owner))
    return for_mangle ? -1 : 0;

  if (for_mangle
      && (DECL_MODULE_EXPORT_P (owner) || !DECL_MODULE_PURVIEW_P (owner)))
    return -1;

  if (!DECL_MODULE_IMPORT_P (owner))
    return 0;

  return get_importing_module (owner);
}

unsigned
get_importing_module (tree decl, bool flexible)
{
  unsigned index = import_entity_index (decl, flexible);
  if (index == ~(~0u >> 1))
    return -1;
  module_state *module = import_entity_module (index);

  return module->mod;
}

/* Is it permissible to redeclare DECL.  */

bool
module_may_redeclare (tree decl)
{
  module_state *me = (*modules)[0];
  module_state *them = me;
  if (DECL_LANG_SPECIFIC (decl) && DECL_MODULE_IMPORT_P (decl))
    {
      /* We can be given the TEMPLATE_RESULT.  We want the
         TEMPLATE_DECL.  */
      int use_tpl = -1;
      if (tree ti = node_template_info (decl, use_tpl))
        {
          tree tmpl = TI_TEMPLATE (ti);
          if (DECL_TEMPLATE_RESULT (tmpl) == decl)
            decl = tmpl;
          // FIXME: What about partial specializations?  We need to
          // look at the specialization list in that case.  Unless our
          // caller's given us the right thing.  An alternative would
          // be to put both the template and the result into the
          // entity hash, but that seems expensive?
        }
      unsigned index = import_entity_index (decl);
      them = import_entity_module (index);
    }

  if (them->is_header ())
    {
      if (!header_module_p ())
        return !module_purview_p ();

      if (DECL_SOURCE_LOCATION (decl) == BUILTINS_LOCATION)
        /* This is a builtin, being declared in header-unit.  We
           now need to mark it as an export.  */
        DECL_MODULE_EXPORT_P (decl) = true;

      /* If it came from a header, it's in the global module.  */
      return true;
    }

  if (me == them)
    return ((DECL_LANG_SPECIFIC (decl) && DECL_MODULE_PURVIEW_P (decl))
            == module_purview_p ());

  if (!me->name)
    me = me->parent;

  /* We can't have found a GMF entity from a named module.  */
  gcc_checking_assert (DECL_LANG_SPECIFIC (decl)
                       && DECL_MODULE_PURVIEW_P (decl));

  return me && get_primary (them) == get_primary (me);
}

/* DECL is being created by this TU.  Record it came from here.  We
   record module purview, so we can see if partial or explicit
   specialization needs to be written out, even though its purviewness
   comes from the most general template.  */

void
set_instantiating_module (tree decl)
{
  gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
              || TREE_CODE (decl) == VAR_DECL
              || TREE_CODE (decl) == TYPE_DECL
              || TREE_CODE (decl) == CONCEPT_DECL
              || TREE_CODE (decl) == TEMPLATE_DECL
              || (TREE_CODE (decl) == NAMESPACE_DECL
                  && DECL_NAMESPACE_ALIAS (decl)));

  if (!modules_p ())
    return;

  if (!DECL_LANG_SPECIFIC (decl) && module_purview_p ())
    retrofit_lang_decl (decl);
  if (DECL_LANG_SPECIFIC (decl))
    {
      DECL_MODULE_PURVIEW_P (decl) = module_purview_p ();
      /* If this was imported, we'll still be in the entity_hash.  */
      DECL_MODULE_IMPORT_P (decl) = false;
      if (TREE_CODE (decl) == TEMPLATE_DECL)
        {
          tree res = DECL_TEMPLATE_RESULT (decl);
          retrofit_lang_decl (res);
          DECL_MODULE_PURVIEW_P (res) = DECL_MODULE_PURVIEW_P (decl);
          DECL_MODULE_IMPORT_P (res) = false;
        }
    }
}

/* If DECL is a class member, whose class is not defined in this TU
   (it was imported), remember this decl.  */

void
set_defining_module (tree decl)
{
  gcc_checking_assert (!DECL_LANG_SPECIFIC (decl)
                       || !DECL_MODULE_IMPORT_P (decl));

  if (module_has_cmi_p ())
    {
      tree ctx = DECL_CONTEXT (decl);
      if (ctx
          && (TREE_CODE (ctx) == RECORD_TYPE || TREE_CODE (ctx) == UNION_TYPE)
          && DECL_LANG_SPECIFIC (TYPE_NAME (ctx))
          && DECL_MODULE_IMPORT_P (TYPE_NAME (ctx)))
        {
          /* This entity's context is from an import.  We may need to
             record this entity to make sure we emit it in the CMI.
             Template specializations are in the template hash tables,
             so we don't need to record them here as well.  */
          int use_tpl = -1;
          tree ti = node_template_info (decl, use_tpl);
          if (use_tpl <= 0)
            {
              if (ti)
                {
                  gcc_checking_assert (!use_tpl);
                  /* Get to the TEMPLATE_DECL.  */
                  decl = TI_TEMPLATE (ti);
                }

              /* Record it on the class_members list.  */
              vec_safe_push (class_members, decl);
            }
        }
      else if (DECL_IMPLICIT_TYPEDEF_P (decl)
               && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
        /* This is a partial or explicit specialization.  */
        vec_safe_push (partial_specializations, decl);
    }
}

void
set_originating_module (tree decl, bool friend_p ATTRIBUTE_UNUSED)
{
  set_instantiating_module (decl);

  if (TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
    return;

  gcc_checking_assert (friend_p || decl == get_originating_module_decl (decl));

  if (!module_exporting_p ())
    return;

  // FIXME: Check ill-formed linkage
  DECL_MODULE_EXPORT_P (decl) = true;
}

/* DECL is attached to ROOT for odr purposes.  */

void
maybe_attach_decl (tree ctx, tree decl)
{
  if (!modules_p ())
    return;

  // FIXME: For now just deal with lambdas attached to var decls.
  // This might be sufficient?
  if (TREE_CODE (ctx) != VAR_DECL)
    return;

  gcc_checking_assert (DECL_NAMESPACE_SCOPE_P (ctx));

 if (!attached_table)
    attached_table = new attachset::hash (EXPERIMENT (1, 400));

  if (attached_table->add (DECL_UID (ctx), decl))
    {
      retrofit_lang_decl (ctx);
      DECL_MODULE_ATTACHMENTS_P (ctx) = true;
    }
}

/* Create the flat name string.  It is simplest to have it handy.  */

void
module_state::set_flatname ()
{
  gcc_checking_assert (!flatname);
  if (parent)
    {
      auto_vec<tree,5> ids;
      size_t len = 0;
      char const *primary = NULL;
      size_t pfx_len = 0;

      for (module_state *probe = this;
           probe;
           probe = probe->parent)
        if (is_partition () && !probe->is_partition ())
          {
            primary = probe->get_flatname ();
            pfx_len = strlen (primary);
            break;
          }
        else
          {
            ids.safe_push (probe->name);
            len += IDENTIFIER_LENGTH (probe->name) + 1;
          }

      char *flat = XNEWVEC (char, pfx_len + len + is_partition ());
      flatname = flat;

      if (primary)
        {
          memcpy (flat, primary, pfx_len);
          flat += pfx_len;
          *flat++ = ':';
        }

      for (unsigned len = 0; ids.length ();)
        {
          if (len)
            flat[len++] = '.';
          tree elt = ids.pop ();
          unsigned l = IDENTIFIER_LENGTH (elt);
          memcpy (flat + len, IDENTIFIER_POINTER (elt), l + 1);
          len += l;
        }
    }
  else if (is_header ())
    flatname = TREE_STRING_POINTER (name);
  else
    flatname = IDENTIFIER_POINTER (name);
}

/* Read the CMI file for a module.  */

bool
module_state::do_import (cpp_reader *reader, bool outermost)
{
  gcc_assert (global_namespace == current_scope () && loadedness == ML_NONE);

  loc = linemap_module_loc (line_table, loc, get_flatname ());

  if (lazy_open >= lazy_limit)
    freeze_an_elf ();

  int fd = -1;
  int e = ENOENT;
  if (filename)
    {
      const char *file = maybe_add_cmi_prefix (filename);
      dump () && dump ("CMI is %s", file);
      fd = open (file, O_RDONLY | O_CLOEXEC | O_BINARY);
      e = errno;
    }

  gcc_checking_assert (!slurp);
  slurp = new slurping (new elf_in (fd, e));

  bool ok = true;
  if (!from ()->get_error ())
    {
      announce ("importing");
      loadedness = ML_CONFIG;
      lazy_open++;
      ok = read_initial (reader);
      slurp->lru = ++lazy_lru;
    }

  gcc_assert (slurp->current == ~0u);

  return check_read (outermost, ok);
}

/* Attempt to increase the file descriptor limit.  */

static bool
try_increase_lazy (unsigned want)
{
  gcc_checking_assert (lazy_open >= lazy_limit);

  /* If we're increasing, saturate at hard limit.  */
  if (want > lazy_hard_limit && lazy_limit < lazy_hard_limit)
    want = lazy_hard_limit;

#if HAVE_SETRLIMIT
  if ((!lazy_limit || !param_lazy_modules)
      && lazy_hard_limit
      && want <= lazy_hard_limit)
    {
      struct rlimit rlimit;
      rlimit.rlim_cur = want + LAZY_HEADROOM;
      rlimit.rlim_max = lazy_hard_limit + LAZY_HEADROOM;
      if (!setrlimit (RLIMIT_NOFILE, &rlimit))
        lazy_limit = want;
    }
#endif

  return lazy_open < lazy_limit;
}

/* Pick a victim module to freeze its reader.  */

void
module_state::freeze_an_elf ()
{
  if (try_increase_lazy (lazy_open * 2))
    return;

  module_state *victim = NULL;
  for (unsigned ix = modules->length (); ix--;)
    {
      module_state *candidate = (*modules)[ix];
      if (candidate && candidate->slurp && candidate->slurp->lru
          && candidate->from ()->is_freezable ()
          && (!victim || victim->slurp->lru > candidate->slurp->lru))
        victim = candidate;
    }

  if (victim)
    {
      dump () && dump ("Freezing '%s'", victim->filename);
      if (victim->slurp->macro_defs.size)
        /* Save the macro definitions to a buffer.  */
        victim->from ()->preserve (victim->slurp->macro_defs);
      if (victim->slurp->macro_tbl.size)
        /* Save the macro definitions to a buffer.  */
        victim->from ()->preserve (victim->slurp->macro_tbl);
      victim->from ()->freeze ();
      lazy_open--;
    }
  else
    dump () && dump ("No module available for freezing");
}

/* Load the lazy slot *MSLOT, INDEX'th slot of the module.  */

bool
module_state::lazy_load (unsigned index, binding_slot *mslot)
{
  unsigned n = dump.push (this);

  gcc_checking_assert (function_depth);

  unsigned cookie = mslot->get_lazy ();
  unsigned snum = cookie >> 2;
  dump () && dump ("Loading entity %M[%u] section:%u", this, index, snum);

  bool ok = load_section (snum, mslot);
 
  dump.pop (n);

  return ok;
}

/* Load MOD's binding for NS::ID into *MSLOT.  *MSLOT contains the
   lazy cookie.  OUTER is true if this is the outermost lazy, (used
   for diagnostics).  */

void
lazy_load_binding (unsigned mod, tree ns, tree id, binding_slot *mslot)
{
  int count = errorcount + warningcount;

  timevar_start (TV_MODULE_IMPORT);

  /* Stop GC happening, even in outermost loads (because our caller
     could well be building up a lookup set).  */
  function_depth++;

  gcc_checking_assert (mod);
  module_state *module = (*modules)[mod];
  unsigned n = dump.push (module);

  unsigned snum = mslot->get_lazy ();
  dump () && dump ("Lazily binding %P@%N section:%u", ns, id,
                   module->name, snum);

  bool ok = !recursive_lazy (snum);
  if (ok)
    {
      ok = module->load_section (snum, mslot);
      lazy_snum = 0;
    }

  dump.pop (n);

  function_depth--;

  timevar_stop (TV_MODULE_IMPORT);

  if (!ok)
    fatal_error (input_location,
                 module->is_header ()
                 ? G_("failed to load binding %<%E%s%E%>")
                 : G_("failed to load binding %<%E%s%E@%s%>"),
                 ns, &"::"[ns == global_namespace ? 2 : 0], id,
                 module->get_flatname ());

  if (count != errorcount + warningcount)
    inform (input_location,
            module->is_header ()
            ? G_("during load of binding %<%E%s%E%>")
            : G_("during load of binding %<%E%s%E@%s%>"),
            ns, &"::"[ns == global_namespace ? 2 : 0], id,
            module->get_flatname ());
}

/* Load any pending specializations of TMPL.  Called just before
   instantiating TMPL.  */

void
lazy_load_specializations (tree tmpl)
{
  gcc_checking_assert (DECL_MODULE_PENDING_SPECIALIZATIONS_P (tmpl)
                       && DECL_MODULE_ENTITY_P (tmpl));

  int count = errorcount + warningcount;

  timevar_start (TV_MODULE_IMPORT);
  bool ok = !recursive_lazy ();
  if (ok)
    {
      unsigned ident = import_entity_index (tmpl);
      if (pendset *set = pending_table->get (ident, true))
        {
          function_depth++; /* Prevent GC */
          unsigned n = dump.push (NULL);
          dump ()
            && dump ("Reading %u pending specializations keyed to %M[%u] %N",
                     set->num, import_entity_module (ident),
                     ident - import_entity_module (ident)->entity_lwm, tmpl);
          if (!pendset_lazy_load (set, true))
            ok = false;
          dump.pop (n);

          function_depth--;
        }
      lazy_snum = 0;
    }

  timevar_stop (TV_MODULE_IMPORT);

  if (!ok)
    fatal_error (input_location, "failed to load specializations keyed to %qD",
                 tmpl);

  if (count != errorcount + warningcount)
    inform (input_location,
            "during load of specializations keyed to %qD", tmpl);
}

void
lazy_load_members (tree decl)
{
  gcc_checking_assert (DECL_MODULE_PENDING_MEMBERS_P (decl));
  if (!DECL_MODULE_ENTITY_P (decl))
    {
      // FIXME: I can't help feeling that DECL_TEMPLATE_RESULT should
      // be inserted into the entity map, or perhaps have the same
      // DECL_UID as the template, so I don't have to do this dance
      // here and elsewhere.  It also simplifies when DECL is a
      // partial specialization.  (also noted elsewhere as an issue)
      tree ti = CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl));
      tree tmpl = TI_TEMPLATE (ti);
      gcc_checking_assert (DECL_TEMPLATE_RESULT (tmpl) == decl);
      decl = tmpl;
    }

  timevar_start (TV_MODULE_IMPORT);
  unsigned ident = import_entity_index (decl);
  if (pendset *set = pending_table->get (~ident, true))
    {
      function_depth++; /* Prevent GC */
      unsigned n = dump.push (NULL);
      dump () && dump ("Reading %u pending members keyed to %M[%u] %N",
                       set->num, import_entity_module (ident),
                       ident - import_entity_module (ident)->entity_lwm, decl);
      pendset_lazy_load (set, false);
      dump.pop (n);

      function_depth--;
    }
  timevar_stop (TV_MODULE_IMPORT);
}

static void
direct_import (module_state *import, cpp_reader *reader)
{
  timevar_start (TV_MODULE_IMPORT);
  unsigned n = dump.push (import);

  gcc_checking_assert (import->is_direct () && import->is_rooted ());
  if (import->loadedness == ML_NONE)
    if (!import->do_import (reader, true))
      gcc_unreachable ();

  if (import->loadedness < ML_LANGUAGE)
    {
      if (!attached_table)
        attached_table = new attachset::hash (EXPERIMENT (1, 400));
      import->read_language (true);
    }

  (*modules)[0]->set_import (import, import->exported_p);

  dump.pop (n);
  timevar_stop (TV_MODULE_IMPORT);
}

/* Import module IMPORT.  */

void
import_module (module_state *import, location_t from_loc, bool exporting_p,
               tree, cpp_reader *reader)
{
  if (!import->check_not_purview (from_loc))
    return;

  if (!import->is_header () && current_lang_depth ())
    /* Only header units should appear inside language
       specifications.  The std doesn't specify this, but I think
       that's an error in resolving US 033, because language linkage
       is also our escape clause to getting things into the global
       module, so we don't want to confuse things by having to think
       about whether 'extern "C++" { import foo; }' puts foo's
       contents into the global module all of a sudden.  */
    warning (0, "import of named module %qs inside language-linkage block",
             import->get_flatname ());

  if (exporting_p || module_exporting_p ())
    import->exported_p = true;

  if (import->loadedness != ML_NONE)
    {
      from_loc = ordinary_loc_of (line_table, from_loc);
      linemap_module_reparent (line_table, import->loc, from_loc);
    }
  gcc_checking_assert (!import->module_p);
  gcc_checking_assert (import->is_direct () && import->is_rooted ());

  direct_import (import, reader);
}

/* Declare the name of the current module to be NAME.  EXPORTING_p is
   true if this TU is the exporting module unit.  */

void
declare_module (module_state *module, location_t from_loc, bool exporting_p,
                tree, cpp_reader *reader)
{
  gcc_assert (global_namespace == current_scope ());

  module_state *current = (*modules)[0];
  if (module_purview_p () || module->loadedness != ML_NONE)
    {
      error_at (from_loc, module_purview_p ()
                ? G_("module already declared")
                : G_("module already imported"));
      if (module_purview_p ())
        module = current;
      inform (module->loc, module_purview_p ()
              ? G_("module %qs declared here")
              : G_("module %qs imported here"),
              module->get_flatname ());
      return;
    }

  gcc_checking_assert (module->module_p);
  gcc_checking_assert (module->is_direct () && module->is_rooted ());

  /* Yer a module, 'arry.  */
  module_kind &= ~MK_GLOBAL;
  module_kind |= MK_MODULE;

  if (module->is_partition () || exporting_p)
    {
      gcc_checking_assert (module->get_flatname ());

      if (module->is_partition ())
        module_kind |= MK_PARTITION;

      if (exporting_p)
        {
          module->interface_p = true;
          module_kind |= MK_INTERFACE;
        }

      if (module->is_header ())
        module_kind |= MK_GLOBAL | MK_EXPORTING;

      /* Copy the importing information we may have already done.  We
         do not need to separate out the imports that only happen in
         the GMF, inspite of what the literal wording of the std
         might imply.  See p2191, the core list had a discussion
         where the module implementors agreed that the GMF of a named
         module is invisible to importers.  */
      module->imports = current->imports;

      module->mod = 0;
      (*modules)[0] = module;
    }
  else
    {
      module->interface_p = true;
      current->parent = module; /* So mangler knows module identity. */
      direct_import (module, reader);
    }
}

/* +1, we're the primary or a partition.  Therefore emitting a
   globally-callable idemportent initializer function.
   -1, we have direct imports.  Therefore emitting calls to their
   initializers.  */

int
module_initializer_kind ()
{
  int result = 0;

  if (module_has_cmi_p () && !header_module_p ())
    result = +1;
  else if (num_init_calls_needed)
    result = -1;

  return result;
}

/* Emit calls to each direct import's global initializer.  Including
   direct imports of directly imported header units.  The initializers
   of (static) entities in header units will be called by their
   importing modules (for the instance contained within that), or by
   the current TU (for the instances we've brought in).  Of course
   such header unit behaviour is evil, but iostream went through that
   door some time ago.  */

void
module_add_import_initializers ()
{
  unsigned calls = 0;
  if (modules)
    {
      tree fntype = build_function_type (void_type_node, void_list_node);
      releasing_vec args;  // There are no args

      for (unsigned ix = modules->length (); --ix;)
        {
          module_state *import = (*modules)[ix];
          if (import->call_init_p)
            {
              tree name = mangle_module_global_init (ix);
              tree fndecl = build_lang_decl (FUNCTION_DECL, name, fntype);

              DECL_CONTEXT (fndecl) = FROB_CONTEXT (global_namespace);
              SET_DECL_ASSEMBLER_NAME (fndecl, name);
              TREE_PUBLIC (fndecl) = true;
              determine_visibility (fndecl);

              tree call = cp_build_function_call_vec (fndecl, &args,
                                                      tf_warning_or_error);
              finish_expr_stmt (call);
              
              calls++;
            }
        }
    }

  gcc_checking_assert (calls == num_init_calls_needed);
}

/* NAME & LEN are a preprocessed header name, possibly including the
   surrounding "" or <> characters.  Return the raw string name of the
   module to which it refers.  This will be an absolute path, or begin
   with ./, so it is immediately distinguishable from a (non-header
   unit) module name.  If READER is non-null, ask the preprocessor to
   locate the header to which it refers using the appropriate include
   path.  Note that we do never do \ processing of the string, as that
   matches the preprocessor's behaviour.  */

static const char *
canonicalize_header_name (cpp_reader *reader, location_t loc, bool unquoted,
                          const char *str, size_t &len_r)
{
  size_t len = len_r;
  static char *buf = 0;
  static size_t alloc = 0;

  if (!unquoted)
    {
      gcc_checking_assert (len >= 2
                           && ((reader && str[0] == '<' && str[len-1] == '>')
                               || (str[0] == '"' && str[len-1] == '"')));
      str += 1;
      len -= 2;
    }

  if (reader)
    {
      gcc_assert (!unquoted);

      if (len >= alloc)
        {
          alloc = len + 1;
          buf = XRESIZEVEC (char, buf, alloc);
        }
      memcpy (buf, str, len);
      buf[len] = 0;

      if (const char *hdr
          = cpp_find_header_unit (reader, buf, str[-1] == '<', loc))
        {
          len = strlen (hdr);
          str = hdr;
        }
      else
        str = buf;
    }

  if (!(str[0] == '.' ? IS_DIR_SEPARATOR (str[1]) : IS_ABSOLUTE_PATH (str)))
    {
      /* Prepend './'  */
      if (len + 3 > alloc)
        {
          alloc = len + 3;
          buf = XRESIZEVEC (char, buf, alloc);
        }

      buf[0] = '.';
      buf[1] = DIR_SEPARATOR;
      memmove (buf + 2, str, len);
      len += 2;
      buf[len] = 0;
      str = buf;
    }

  len_r = len;
  return str;
}

/* Set the CMI name from a cody packet.  Issue an error if
   ill-formed.  */

void module_state::set_filename (const Cody::Packet &packet)
{
  gcc_checking_assert (!filename);
  if (packet.GetCode () == Cody::Client::PC_PATHNAME)
    filename = xstrdup (packet.GetString ().c_str ());
  else
    {
      gcc_checking_assert (packet.GetCode () == Cody::Client::PC_ERROR);
      error_at (loc, "unknown Compiled Module Interface: %s",
                packet.GetString ().c_str ());
    }
}

/* Figure out whether to treat HEADER as an include or an import.  */

static char *
maybe_translate_include (cpp_reader *reader, line_maps *lmaps, location_t loc,
                         const char *path)
{
  if (!modules_p ())
    {
      /* Turn off.  */
      cpp_get_callbacks (reader)->translate_include = NULL;
      return nullptr;
    }

  if (!spans.init_p ())
    /* Before the main file, don't divert.  */
    return nullptr;

  dump.push (NULL);

  dump () && dump ("Checking include translation '%s'", path);
  auto *mapper = get_mapper (cpp_main_loc (reader));

  size_t len = strlen (path);
  path = canonicalize_header_name (NULL, loc, true, path, len);
  auto packet = mapper->IncludeTranslate (path, Cody::Flags::None, len);
  int xlate = false;
  if (packet.GetCode () == Cody::Client::PC_BOOL)
    xlate = -int (packet.GetInteger ());
  else if (packet.GetCode () == Cody::Client::PC_PATHNAME)
    {
      /* Record the CMI name for when we do the import.  */
      module_state *import = get_module (build_string (len, path));
      import->set_filename (packet);
      xlate = +1;
    }
  else
    {
      gcc_checking_assert (packet.GetCode () == Cody::Client::PC_ERROR);
      error_at (loc, "cannot determine %<#include%> translation of %s: %s",
                path, packet.GetString ().c_str ());
    }

  bool note = false;
  if (note_include_translate_yes && xlate > 1)
    note = true;
  else if (note_include_translate_no && xlate == 0)
    note = true;
  else if (note_includes)
    {
      /* We do not expect the note_includes vector to be large, so O(N)
         iteration.  */
      for (unsigned ix = note_includes->length (); !note && ix--;)
        {
          const char *hdr = (*note_includes)[ix];
          size_t hdr_len = strlen (hdr);
          if ((hdr_len == len
               || (hdr_len < len && IS_DIR_SEPARATOR (path[len - hdr_len - 1])))
              && !memcmp (hdr, path + len - hdr_len, hdr_len))
            note = true;
        }
    }

  if (note)
    inform (loc, xlate
            ? G_("include %qs translated to import")
            : G_("include %qs processed textually") , path);

  dump () && dump (xlate ? "Translating include to import"
                   : "Keeping include as include");
  dump.pop (0);

  if (!(xlate > 0))
    return nullptr;
  
  /* Create the translation text.  */
  loc = ordinary_loc_of (lmaps, loc);
  const line_map_ordinary *map
    = linemap_check_ordinary (linemap_lookup (lmaps, loc));
  unsigned col = SOURCE_COLUMN (map, loc);
  col -= (col != 0); /* Columns are 1-based.  */

  unsigned alloc = len + col + 60;
  char *res = XNEWVEC (char, alloc);

  strcpy (res, "__import");
  unsigned actual = 8;
  if (col > actual)
    {
      /* Pad out so the filename appears at the same position.  */
      memset (res + actual, ' ', col - actual);
      actual = col;
    }
  /* No need to encode characters, that's not how header names are
     handled.  */
  actual += snprintf (res + actual, alloc - actual,
                      "\"%s\" [[__translated]];\n", path);
  gcc_checking_assert (actual < alloc);

  /* cpplib will delete the buffer.  */
  return res;
}

static void
begin_header_unit (cpp_reader *reader)
{
  /* Set the module header name from the main_input_filename.  */
  const char *main = main_input_filename;
  size_t len = strlen (main);
  main = canonicalize_header_name (NULL, 0, true, main, len);
  module_state *module = get_module (build_string (len, main));

  preprocess_module (module, cpp_main_loc (reader), false, false, true, reader);
}

/* We've just properly entered the main source file.  I.e. after the
   command line, builtins and forced headers.  Record the line map and
   location of this map.  Note we may be called more than once.  The
   first call sticks.  */

void
module_begin_main_file (cpp_reader *reader, line_maps *lmaps,
                       const line_map_ordinary *map)
{
  gcc_checking_assert (lmaps == line_table);
  if (modules_p () && !spans.init_p ())
    {
      unsigned n = dump.push (NULL);
      spans.init (lmaps, map);
      dump.pop (n);
      if (flag_header_unit && !cpp_get_options (reader)->preprocessed)
        {
          /* Tell the preprocessor this is an include file.  */
          cpp_retrofit_as_include (reader);
          begin_header_unit (reader);
        }
    }
}

/* We've just lexed a module-specific control line for MODULE.  Mark
   the module as a direct import, and possibly load up its macro
   state.  Returns the primary module, if this is a module
   declaration.  */
/* Perhaps we should offer a preprocessing mode where we read the
   directives from the header unit, rather than require the header's
   CMI.  */

module_state *
preprocess_module (module_state *module, location_t from_loc,
                   bool in_purview, bool is_import, bool is_export,
                   cpp_reader *reader)
{
  if (!is_import)
    {
      if (module->loc)
        /* It's already been mentioned, so ignore its module-ness.  */
        is_import = true;
      else
        {
          /* Record it is the module.  */
          module->module_p = true;
          if (is_export)
            {
              module->exported_p = true;
              module->interface_p = true;
            }
        }
    }

  if (module->directness < MD_DIRECT + in_purview)
    {
      /* Mark as a direct import.  */
      module->directness = module_directness (MD_DIRECT + in_purview);

      /* Set the location to be most informative for users.  */
      from_loc = ordinary_loc_of (line_table, from_loc);
      if (module->loadedness != ML_NONE)
        linemap_module_reparent (line_table, module->loc, from_loc);
      else
        {
          module->loc = from_loc;
          if (!module->flatname)
            module->set_flatname ();
        }
    }

  if (is_import
      && !module->is_module () && module->is_header ()
      && module->loadedness < ML_PREPROCESSOR
      && (!cpp_get_options (reader)->preprocessed
          || cpp_get_options (reader)->directives_only))
    {
      timevar_start (TV_MODULE_IMPORT);
      unsigned n = dump.push (module);

      if (module->loadedness == ML_NONE)
        {
          unsigned pre_hwm = 0;

          /* Preserve the state of the line-map.  */
          pre_hwm = LINEMAPS_ORDINARY_USED (line_table);
          /* We only need to close the span, if we're going to emit a
             CMI.  But that's a little tricky -- our token scanner
             needs to be smarter -- and this isn't much state.
             Remember, we've not parsed anything at this point, so
             our module state flags are inadequate.  */
          spans.maybe_init ();
          spans.close ();

          if (!module->filename)
            {
              auto *mapper = get_mapper (cpp_main_loc (reader));
              auto packet = mapper->ModuleImport (module->get_flatname ());
              module->set_filename (packet);
            }
          module->do_import (reader, true);

          /* Restore the line-map state.  */
          linemap_module_restore (line_table, pre_hwm);
          spans.open ();
        }

      if (module->loadedness < ML_PREPROCESSOR)
        if (module->read_preprocessor (true))
          module->import_macros ();

      dump.pop (n);
      timevar_stop (TV_MODULE_IMPORT);
    }

  return is_import ? NULL : get_primary (module);
}

/* We've completed phase-4 translation.  Emit any dependency
   information for the not-yet-loaded direct imports, and fill in
   their file names.  We'll have already loaded up the direct header
   unit wavefront.  */

void
preprocessed_module (cpp_reader *reader)
{
  auto *mapper = get_mapper (cpp_main_loc (reader));

  spans.maybe_init ();
  spans.close ();

  /* Stupid GTY doesn't grok a typedef here.  And using type = is, too
     modern.  */
#define iterator hash_table<module_state_hash>::iterator
  /* using iterator = hash_table<module_state_hash>::iterator;  */

  /* Walk the module hash, asking for the names of all unknown
     direct imports and informing of an export (if that's what we
     are).  Notice these are emitted even when preprocessing as they
     inform the server of dependency edges.  */
  timevar_start (TV_MODULE_MAPPER);

  dump.push (NULL);
  dump () && dump ("Resolving direct import names");

  if (!flag_preprocess_only
      || bool (mapper->get_flags () & Cody::Flags::NameOnly)
      || cpp_get_deps (reader))
    {
      mapper->Cork ();
      iterator end = modules_hash->end ();
      for (iterator iter = modules_hash->begin (); iter != end; ++iter)
        {
          module_state *module = *iter;
          if (module->is_direct () && !module->filename)
            {
              Cody::Flags flags
                = (flag_preprocess_only ? Cody::Flags::None
                   : Cody::Flags::NameOnly);

              if (module->module_p
                  && (module->is_partition () || module->exported_p))
                mapper->ModuleExport (module->get_flatname (), flags);
              else
                mapper->ModuleImport (module->get_flatname (), flags);
            }
        }

      auto response = mapper->Uncork ();
      auto r_iter = response.begin ();
      for (iterator iter = modules_hash->begin (); iter != end; ++iter)
        {
          module_state *module = *iter;

          if (module->is_direct () && !module->filename)
            {
              Cody::Packet const &p = *r_iter;
              ++r_iter;

              module->set_filename (p);
            }
        }
    }

  dump.pop (0);

  timevar_stop (TV_MODULE_MAPPER);

  if (mkdeps *deps = cpp_get_deps (reader))
    {
      /* Walk the module hash, informing the dependency machinery.  */
      iterator end = modules_hash->end ();
      for (iterator iter = modules_hash->begin (); iter != end; ++iter)
        {
          module_state *module = *iter;

          if (module->is_direct ())
            {
              if (module->is_module ()
                  && (module->is_interface () || module->is_partition ()))
                deps_add_module_target (deps, module->get_flatname (),
                                        maybe_add_cmi_prefix (module->filename),
                                        module->is_header());
              else
                deps_add_module_dep (deps, module->get_flatname ());
            }
        }
    }

  if (flag_header_unit && !flag_preprocess_only)
    {
      iterator end = modules_hash->end ();
      for (iterator iter = modules_hash->begin (); iter != end; ++iter)
        {
          module_state *module = *iter;
          if (module->is_module ())
            {
              declare_module (module, cpp_main_loc (reader), true, NULL, reader);
              break;
            }
        }
    }
#undef iterator
}

/* VAL is a global tree, add it to the global vec if it is
   interesting.  Add some of its targets, if they too are
   interesting.  We do not add identifiers, as they can be re-found
   via the identifier hash table.  There is a cost to the number of
   global trees.  */

static int
maybe_add_global (tree val, unsigned &crc)
{
  int v = 0;

  if (val && !(identifier_p (val) || TREE_VISITED (val)))
    {
      TREE_VISITED (val) = true;
      crc = crc32_unsigned (crc, fixed_trees->length ());
      vec_safe_push (fixed_trees, val);
      v++;

      if (CODE_CONTAINS_STRUCT (TREE_CODE (val), TS_TYPED))
        v += maybe_add_global (TREE_TYPE (val), crc);
      if (CODE_CONTAINS_STRUCT (TREE_CODE (val), TS_TYPE_COMMON))
        v += maybe_add_global (TYPE_NAME (val), crc);
    }

  return v;
}

/* Initialize module state.  Create the hash table, determine the
   global trees.  Create the module for current TU.  */

void
init_modules (cpp_reader *reader)
{
  /* PCH should not be reachable because of lang-specs, but the
     user could have overriden that.  */
  if (pch_file)
    fatal_error (input_location,
                 "C++ modules are incompatible with precompiled headers");

  if (cpp_get_options (reader)->traditional)
    fatal_error (input_location,
                 "C++ modules are incompatible with traditional preprocessing");

  if (flag_preprocess_only)
    {
      cpp_options *cpp_opts = cpp_get_options (reader);
      if (flag_no_output
          || (cpp_opts->deps.style != DEPS_NONE
              && !cpp_opts->deps.need_preprocessor_output))
        {
          warning (0, flag_dump_macros == 'M'
                   ? G_("macro debug output may be incomplete with modules")
                   : G_("module dependencies require preprocessing"));
          if (cpp_opts->deps.style != DEPS_NONE)
            inform (input_location, "you should use the %<-%s%> option",
                    cpp_opts->deps.style == DEPS_SYSTEM ? "MD" : "MMD");
        }
    }

  /* :: is always exported.  */
  DECL_MODULE_EXPORT_P (global_namespace) = true;

  modules_hash = hash_table<module_state_hash>::create_ggc (31);
  vec_safe_reserve (modules, 20);

  /* Create module for current TU.  */
  module_state *current
    = new (ggc_alloc<module_state> ()) module_state (NULL_TREE, NULL, false);
  current->mod = 0;
  bitmap_set_bit (current->imports, 0);
  modules->quick_push (current);

  gcc_checking_assert (!fixed_trees);

  headers = BITMAP_GGC_ALLOC ();

  if (note_includes)
    for (unsigned ix = 0; ix != note_includes->length (); ix++)
      {
        const char *hdr = (*note_includes)[ix];
        size_t len = strlen (hdr);

        bool system = hdr[0] == '<';
        bool user = hdr[0] == '"';
        bool delimed = system || user;

        if (len <= (delimed ? 2 : 0)
            || (delimed && hdr[len-1] != (system ? '>' : '"')))
          error ("invalid header name %qs", hdr);

        hdr = canonicalize_header_name (delimed ? reader : NULL,
                                        0, !delimed, hdr, len);
        char *path = XNEWVEC (char, len + 1);
        memcpy (path, hdr, len);
        path[len+1] = 0;

        (*note_includes)[ix] = path;
      }

  dump.push (NULL);

  /* Determine lazy handle bound.  */
  {
    unsigned limit = 1000;
#if HAVE_GETRLIMIT
    struct rlimit rlimit;
    if (!getrlimit (RLIMIT_NOFILE, &rlimit))
      {
        lazy_hard_limit = (rlimit.rlim_max < 1000000
                           ? unsigned (rlimit.rlim_max) : 1000000);
        lazy_hard_limit = (lazy_hard_limit > LAZY_HEADROOM
                           ? lazy_hard_limit - LAZY_HEADROOM : 0);
        if (rlimit.rlim_cur < limit)
          limit = unsigned (rlimit.rlim_cur);
      }
#endif
    limit = limit > LAZY_HEADROOM ? limit - LAZY_HEADROOM : 1;

    if (unsigned parm = param_lazy_modules)
      {
        if (parm <= limit || !lazy_hard_limit || !try_increase_lazy (parm))
          lazy_limit = parm;
      }
    else
      lazy_limit = limit;
  }

  if (dump ())
    {
      verstr_t ver;
      version2string (MODULE_VERSION, ver);
      dump ("Source: %s", main_input_filename);
      dump ("Compiler: %s", version_string);
      dump ("Modules: %s", ver);
      dump ("Checking: %s",
#if CHECKING_P
            "checking"
#elif ENABLE_ASSERT_CHECKING
            "asserting"
#else
            "release"
#endif
            );
      dump ("Compiled by: "
#ifdef __GNUC__
            "GCC %d.%d, %s", __GNUC__, __GNUC_MINOR__,
#ifdef __OPTIMIZE__
            "optimizing"
#else
            "not optimizing"
#endif
#else
            "not GCC"
#endif
            );
      dump ("Reading: %s", MAPPED_READING ? "mmap" : "fileio");
      dump ("Writing: %s", MAPPED_WRITING ? "mmap" : "fileio");
      dump ("Lazy limit: %u", lazy_limit);
      dump ("Lazy hard limit: %u", lazy_hard_limit);
      dump ("");
    }

  /* Construct the global tree array.  This is an array of unique
     global trees (& types).  Do this now, rather than lazily, as
     some global trees are lazily created and we don't want that to
     mess with our syndrome of fixed trees.  */
  unsigned crc = 0;
  vec_alloc (fixed_trees, 200);

  dump () && dump ("+Creating globals");
  /* Insert the TRANSLATION_UNIT_DECL.  */
  TREE_VISITED (DECL_CONTEXT (global_namespace)) = true;
  fixed_trees->quick_push (DECL_CONTEXT (global_namespace));
  for (unsigned jx = 0; global_tree_arys[jx].first; jx++)
    {
      const tree *ptr = global_tree_arys[jx].first;
      unsigned limit = global_tree_arys[jx].second;

      for (unsigned ix = 0; ix != limit; ix++, ptr++)
        {
          !(ix & 31) && dump ("") && dump ("+\t%u:%u:", jx, ix);
          unsigned v = maybe_add_global (*ptr, crc);
          dump () && dump ("+%u", v);
        }
    }
  global_crc = crc32_unsigned (crc, fixed_trees->length ());
  dump ("") && dump ("Created %u unique globals, crc=%x",
                     fixed_trees->length (), global_crc);
  for (unsigned ix = fixed_trees->length (); ix--;)
    TREE_VISITED ((*fixed_trees)[ix]) = false;

  dump.pop (0);

  if (!flag_module_lazy)
    /* Get the mapper now, if we're not being lazy.  */
    get_mapper (cpp_main_loc (reader));

  if (!flag_preprocess_only)
    {
      pending_table = new pendset::hash (EXPERIMENT (1, 400));

      entity_map = new entity_map_t (EXPERIMENT (1, 400));
      vec_safe_reserve (entity_ary, EXPERIMENT (1, 400));
    }

#if CHECKING_P
  note_defs = note_defs_table_t::create_ggc (1000);
#endif

  if (flag_header_unit && cpp_get_options (reader)->preprocessed)
    begin_header_unit (reader);

  /* Collect here to make sure things are tagged correctly (when
     aggressively GC'd).  */
  ggc_collect ();
}

/* If NODE is a deferred macro, load it.  */

static int
load_macros (cpp_reader *reader, cpp_hashnode *node, void *)
{
  location_t main_loc
    = MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (line_table, 0));

  if (cpp_user_macro_p (node)
      && !node->value.macro)
    {
      cpp_macro *macro = cpp_get_deferred_macro (reader, node, main_loc);
      dump () && dump ("Loaded macro #%s %I",
                       macro ? "define" : "undef", identifier (node));
    }

  return 1;
}

/* At the end of tokenizing, we no longer need the macro tables of
   imports.  But the user might have requested some checking.  */

void
maybe_check_all_macros (cpp_reader *reader)
{
  if (!warn_imported_macros)
    return;

  /* Force loading of any remaining deferred macros.  This will
     produce diagnostics if they are ill-formed.  */
  unsigned n = dump.push (NULL);
  cpp_forall_identifiers (reader, load_macros, NULL);
  dump.pop (n);
}

/* Write the CMI, if we're a module interface.  */

void
finish_module_processing (cpp_reader *reader)
{
  if (header_module_p ())
    module_kind &= ~MK_EXPORTING;

  if (!modules || !(*modules)[0]->name)
    {
      if (flag_module_only)
        warning (0, "%<-fmodule-only%> used for non-interface");
    }
  else if (!flag_syntax_only)
    {
      int fd = -1;
      int e = ENOENT;

      timevar_start (TV_MODULE_EXPORT);

      /* Force a valid but empty line map at the end.  This simplifies
         the line table preparation and writing logic.  */
      linemap_add (line_table, LC_ENTER, false, "", 0);

      /* We write to a tmpname, and then atomically rename.  */
      const char *path = NULL;
      char *tmp_name = NULL;
      module_state *state = (*modules)[0];

      unsigned n = dump.push (state);
      state->announce ("creating");
      if (state->filename)
        {
          size_t len = 0;
          path = maybe_add_cmi_prefix (state->filename, &len);
          tmp_name = XNEWVEC (char, len + 3);
          memcpy (tmp_name, path, len);
          strcpy (&tmp_name[len], "~");

          if (!errorcount)
            for (unsigned again = 2; ; again--)
              {
                fd = open (tmp_name,
                           O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC | O_BINARY,
                           S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
                e = errno;
                if (fd >= 0 || !again || e != ENOENT)
                  break;
                create_dirs (tmp_name);
              }
          dump () && dump ("CMI is %s", path);
        }

      if (errorcount)
        warning_at (state->loc, 0, "not writing module %qs due to errors",
                    state->get_flatname ());
      else
        {
          elf_out to (fd, e);
          if (to.begin ())
            {
              auto loc = input_location;
              /* So crashes finger point the module decl.  */
              input_location = state->loc;
              state->write (&to, reader);
              input_location = loc;
            }
          if (to.end ())
            {
              /* Some OS's do not replace NEWNAME if it already
                 exists.  This'll have a race condition in erroneous
                 concurrent builds.  */
              unlink (path);
              if (rename (tmp_name, path))
                {
                  dump () && dump ("Rename ('%s','%s') errno=%u", errno);
                  to.set_error (errno);
                }
            }

          if (to.get_error ())
            {
              error_at (state->loc, "failed to write compiled module: %s",
                        to.get_error (state->filename));
              state->note_cmi_name ();
            }
        }

      if (!errorcount)
        {
          auto *mapper = get_mapper (cpp_main_loc (reader));

          mapper->ModuleCompiled (state->get_flatname ());
        }
      else if (path)
        {
          /* We failed, attempt to erase all evidence we even tried.  */
          unlink (tmp_name);
          unlink (path);
          XDELETEVEC (tmp_name);
        }

      dump.pop (n);
      timevar_stop (TV_MODULE_EXPORT);

      ggc_collect ();
    }

  if (modules)
    {
      unsigned n = dump.push (NULL);
      dump () && dump ("Imported %u modules", modules->length () - 1);
      dump () && dump ("Containing %u clusters", available_clusters);
      dump () && dump ("Loaded %u clusters (%u%%)", loaded_clusters,
                       (loaded_clusters * 100 + available_clusters / 2) /
                       (available_clusters + !available_clusters));
      dump.pop (n);
    }

  if (modules && !header_module_p ())
    {
      /* Determine call_init_p.  We need the same bitmap allocation
         scheme as for the imports member.  */
      function_depth++; /* Disable GC.  */
      bitmap indirect_imports (BITMAP_GGC_ALLOC ());

      /* Because indirect imports are before their direct import, and
         we're scanning the array backwards, we only need one pass!  */
      for (unsigned ix = modules->length (); --ix;)
        {
          module_state *import = (*modules)[ix];

          if (!import->is_header ()
              && !bitmap_bit_p (indirect_imports, ix))
            {
              /* Everything this imports is therefore indirectly
                 imported.  */
              bitmap_ior_into (indirect_imports, import->imports);
              /* We don't have to worry about the self-import bit,
                 because of the single pass.  */

              import->call_init_p = true;
              num_init_calls_needed++;
            }
        }
      function_depth--;
    }
}

void
fini_modules ()
{
  /* We're done with the macro tables now.  */
  vec_free (macro_exports);
  vec_free (macro_imports);
  headers = NULL;

  /* We're now done with everything but the module names.  */
  set_cmi_repo (NULL);
  if (mapper)
    {
      timevar_start (TV_MODULE_MAPPER);
      module_client::close_module_client (0, mapper);
      mapper = nullptr;
      timevar_stop (TV_MODULE_MAPPER);
    }
  module_state_config::release ();

#if CHECKING_P
  note_defs = NULL;
#endif

  if (modules)
    for (unsigned ix = modules->length (); --ix;)
      if (module_state *state = (*modules)[ix])
        state->release ();

  /* No need to lookup modules anymore.  */
  modules_hash = NULL;

  /* Or entity array.  We still need the entity map to find import numbers.  */
  delete entity_ary;
  entity_ary = NULL;

  /* Or remember any pending entities.  */
  delete pending_table;
  pending_table = NULL;

  /* Or any attachments -- Let it go!  */
  delete attached_table;
  attached_table = NULL;

  /* Allow a GC, we've possibly made much data unreachable.  */
  ggc_collect ();
}

/* If CODE is a module option, handle it & return true.  Otherwise
   return false.  For unknown reasons I cannot get the option
   generation machinery to set fmodule-mapper or -fmodule-header to
   make a string type option variable.  */

bool
handle_module_option (unsigned code, const char *str, int)
{
  auto hdr = CMS_header;

  switch (opt_code (code))
    {
    case OPT_fmodule_mapper_:
      module_mapper_name = str;
      return true;

    case OPT_fmodule_header_:
      {
        if (!strcmp (str, "user"))
          hdr = CMS_user;
        else if (!strcmp (str, "system"))
          hdr = CMS_system;
        else
          error ("unknown header kind %qs", str);
      }
      /* Fallthrough.  */

    case OPT_fmodule_header:
      flag_header_unit = hdr;
      flag_modules = 1;
      return true;

    case OPT_flang_info_include_translate_:
      vec_safe_push (note_includes, str);
      return true;

    default:
      return false;
    }
}

/* Set preprocessor callbacks and options for modules.  */

void
module_preprocess_options (cpp_reader *reader)
{
  gcc_checking_assert (!lang_hooks.preprocess_undef);
  if (modules_p ())
    {
      auto *cb = cpp_get_callbacks (reader);
      
      cb->translate_include = maybe_translate_include;
      cb->user_deferred_macro = module_state::deferred_macro;
      if (flag_header_unit)
        {
          /* If the preprocessor hook is already in use, that
             implementation will call the undef langhook.  */
          if (cb->undef)
            lang_hooks.preprocess_undef = module_state::undef_macro;
          else
            cb->undef = module_state::undef_macro;
        }
      auto *opt = cpp_get_options (reader);
      opt->module_directives = true;
      opt->main_search = cpp_main_search (flag_header_unit);
    }
}

#include "gt-cp-module.h"