On Tue, 27 Feb 2024, Patrick Palka wrote:

> On Fri, 16 Feb 2024, Patrick Palka wrote:
> 
> > On Thu, 15 Feb 2024, Patrick Palka wrote:
> > 
> > > Bootstrapped and regtested on x86_64-pc-linux-gnu, does this look
> > > OK for trunk?
> > > 
> > > -- >8 --
> > > 
> > > One would expect consecutive calls to bytes_in/out::b for streaming
> > > adjacent bits, as we do for tree flag streaming, to at least be
> > > optimized by the compiler into individual bit operations using
> > > statically known bit positions (and ideally merged into larger sized
> > > reads/writes).
> > > 
> > > Unfortunately this doesn't happen because the compiler has trouble
> > > tracking the values of this->bit_pos and this->bit_val across such
> > > calls, likely because the compiler doesn't know 'this' and so it's
> > > treated as global memory.  This means for each consecutive bit stream
> > > operation, bit_pos and bit_val are loaded from memory, checked if
> > > buffering is needed, and finally the bit is extracted from bit_val
> > > according to the (unknown) bit_pos, even though relative to the previous
> > > operation (if we didn't need to buffer) bit_val is unchanged and bit_pos
> > > is just 1 larger.  This ends up being quite slow, with tree_node_bools
> > > taking 10% of time when streaming in parts of the std module.
> > > 
> > > This patch optimizes this by making tracking of bit_pos and bit_val
> > > easier for the compiler.  Rather than bit_pos and bit_val being members
> > > of the (effectively global) bytes_in/out objects, this patch factors out
> > > the bit streaming code/state into separate classes bits_in/out that get
> > > constructed locally as needed for bit streaming.  Since these objects
> > > are now clearly local, the compiler can more easily track their values.
> > > 
> > > And since bit streaming is intended to be batched it's natural for these
> > > new classes to be RAII-enabled such that the bit stream is flushed upon
> > > destruction.
> > > 
> > > In order to make the most of this improved tracking of bit position,
> > > this patch changes parts where we conditionally stream a tree flag
> > > to unconditionally stream (the flag or a dummy value).  That way
> > > the number of bits streamed and the respective bit positions are as
> > > statically known as reasonably possible.  In lang_decl_bools and
> > > lang_type_bools we flush the current bit buffer at the start so that
> > > subsequent bit positions are statically known.  And in core bools, we
> > > can add explicit early exits utilizing invariants that the compiler
> > > can't figure out itself (e.g. a tree code can't have both TS_TYPE_COMMON
> > > and TS_DECL_COMMON, and if a tree code doesn't have TS_DECL_COMMON then
> > > it doesn't have TS_DECL_WITH_VIS).  Finally if we're streaming fewer
> > > than 4 bits, it's more space efficient to stream them as individual
> > > bytes rather than as packed bits (due to the 32-bit buffer).
> > 
> > Oops, this last sentence is wrong.  Although the size of the bit buffer
> > is 32 bits, upon flushing we rewind unused bytes within the buffer,
> > which means streaming 2-8 bits ends up using only one byte not all four.
> > So v2 below undoes this pessimization.
> > 
> > > This patch also moves the definitions of the relevant streaming classes
> > > into anonymous namespaces so that the compiler can make more informed
> > > decisions about inlining their member functions.
> > > 
> > > After this patch, compile time for a simple Hello World using the std
> > > module is reduced by 7% with a release compiler.  The on-disk size of
> > > the std module increases by 0.7% (presumably due to the extra flushing
> > > done in lang_decl_bools and lang_type_bools).
> > 
> > The on-disk std module now only grows 0.4% instead of 0.7%.
> > 
> > > 
> > > The bit stream out performance isn't improved as much as the stream in
> > > due to the spans/lengths instrumentation performed on stream out (which
> > > probably should be e.g. removed for release builds?)
> > 
> > -- >8 --
> > 
> > gcc/cp/ChangeLog:
> > 
> >     * module.cc: Update comment about classes defined.
> >     (class data): Enclose in an anonymous namespace.
> >     (data::calc_crc): Moved from bytes::calc_crc.
> >     (class bytes): Remove.  Move bit_flush to namespace scope.
> >     (class bytes_in): Enclose in an anonymous namespace.  Inherit
> >     directly from data and adjust accordingly.  Move b and bflush
> >     members to bits_in.
> >     (class bytes_out): As above.  Remove is_set static data member.
> >     (bit_flush): Moved from class bytes.
> >     (struct bits_in): Define.
> >     (struct bits_out): Define.
> >     (bytes_out::bflush): Moved to bits_out/in.
> >     (bytes_in::bflush): Likewise
> >     (bytes_in::bfill): Removed.
> >     (bytes_out::b): Moved to bits_out/in.
> >     (bytes_in::b): Likewise.
> >     (class trees_in): Enclose in an anonymous namespace.
> >     (class trees_out): Enclose in an anonymous namespace.
> >     (trees_out::core_bools): Add bits_out/in parameter and use it.
> >     Unconditionally stream a bit for public_flag.  Add early exits
> >     as appropriate.
> >     (trees_out::core_bools): Likewise.
> >     (trees_out::lang_decl_bools): Add bits_out/in parameter and use
> >     it.  Flush the current bit buffer at the start.  Unconditionally
> >     stream a bit for module_keyed_decls_p.
> >     (trees_in::lang_decl_bools): Likewise.
> >     (trees_out::lang_type_bools): Add bits_out/in parameter and use
> >     it.  Flush the current bit buffer at the start.
> >     (trees_in::lang_type_bools): Likewise.
> >     (trees_out::tree_node_bools): Construct a bits_out object and
> >     use/pass it.
> >     (trees_in::tree_node_bools): Likewise.
> >     (trees_out::decl_value): Likewise.
> >     (trees_in::decl_value): Likewise.
> >     (module_state::write_define): Likewise.
> >     (module_state::read_define): Likewise.
> 
> Ping.

Ping.

> 
> > ---
> >  gcc/cp/module.cc | 418 ++++++++++++++++++++++++++---------------------
> >  1 file changed, 231 insertions(+), 187 deletions(-)
> > 
> > diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc
> > index 0291d456ff5..2ecee007e8a 100644
> > --- a/gcc/cp/module.cc
> > +++ b/gcc/cp/module.cc
> > @@ -153,9 +153,11 @@ Classes used:
> >  
> >     data - buffer
> >  
> > -   bytes - data streamer
> > -   bytes_in : bytes - scalar reader
> > -   bytes_out : bytes - scalar writer
> > +   bytes_in - scalar reader
> > +   bytes_out - scalar writer
> > +
> > +   bits_in - bit stream reader
> > +   bits_out - bit stream writer
> >  
> >     elf - ELROND format
> >     elf_in : elf - ELROND reader
> > @@ -346,6 +348,7 @@ typedef hash_map<void *,signed,ptr_int_traits> 
> > ptr_int_hash_map;
> >  
> >  /* Variable length buffer.  */
> >  
> > +namespace {
> >  class data {
> >  public:
> >    class allocator {
> > @@ -393,6 +396,8 @@ protected:
> >      return res;
> >    }
> >  
> > +  unsigned calc_crc (unsigned) const;
> > +
> >  public:
> >    void unuse (unsigned count)
> >    {
> > @@ -402,6 +407,7 @@ public:
> >  public:
> >    static allocator simple_memory;
> >  };
> > +} // anon namespace
> >  
> >  /* The simple data allocator.  */
> >  data::allocator data::simple_memory;
> > @@ -447,46 +453,11 @@ 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
> > +data::calc_crc (unsigned l) const
> >  {
> >    return crc32 (0, (unsigned char *)buffer + 4, l - 4);
> >  }
> > @@ -495,8 +466,9 @@ class elf_in;
> >  
> >  /* Byte stream reader.  */
> >  
> > -class bytes_in : public bytes {
> > -  typedef bytes parent;
> > +namespace {
> > +class bytes_in : public data {
> > +  typedef data parent;
> >  
> >  protected:
> >    bool overrun;  /* Sticky read-too-much flag.  */
> > @@ -531,7 +503,6 @@ public:
> >      if (offset > size)
> >        set_overrun ();
> >      pos = offset;
> > -    bit_pos = bit_val = 0;
> >    }
> >  
> >  public:
> > @@ -573,14 +544,7 @@ 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 c () ATTRIBUTE_UNUSED;               /* Read a char.  */
> >    int i ();                /* Read a signed int.  */
> >    unsigned u ();   /* Read an unsigned int.  */
> >    size_t z ();             /* Read a size_t.  */
> > @@ -590,6 +554,7 @@ public:
> >    const void *buf (size_t); /* Read a fixed-length buffer.  */
> >    cpp_hashnode *cpp_node (); /* Read a cpp node.  */
> >  };
> > +} // anon namespace
> >  
> >  /* Verify the buffer's CRC is correct.  */
> >  
> > @@ -610,8 +575,9 @@ class elf_out;
> >  
> >  /* Byte stream writer.  */
> >  
> > -class bytes_out : public bytes {
> > -  typedef bytes parent;
> > +namespace {
> > +class bytes_out : public data {
> > +  typedef data parent;
> >  
> >  public:
> >    allocator *memory;       /* Obtainer of memory.  */
> > @@ -659,11 +625,7 @@ 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 c (unsigned char) ATTRIBUTE_UNUSED; /* Write unsigned char.  */
> >    void i (int);            /* Write signed int.  */
> >    void u (unsigned);       /* Write unsigned int.  */
> >    void z (size_t s);       /* Write size_t.  */
> > @@ -694,13 +656,126 @@ protected:
> >    /* Instrumentation.  */
> >    static unsigned spans[4];
> >    static unsigned lengths[4];
> > -  static int is_set;
> > +  friend struct bits_out;
> >  };
> > +} // anon namespace
> > +
> > +/* Finish bit packet.  Rewind the bytes not used.  */
> > +static unsigned
> > +bit_flush (data& bits, uint32_t& bit_val, unsigned& bit_pos)
> > +{
> > +  gcc_assert (bit_pos);
> > +  unsigned bytes = (bit_pos + 7) / 8;
> > +  bits.unuse (4 - bytes);
> > +  bit_pos = 0;
> > +  bit_val = 0;
> > +  return bytes;
> > +}
> > +
> > +/* Bit stream reader (RAII-enabled).  Bools are packed into bytes.  You
> > +   cannot mix bools and non-bools.  Use bflush to flush the current stream
> > +   of bools on demand.  Upon destruction bflush is called.
> > +
> > +   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.  */
> > +
> > +namespace {
> > +struct bits_in {
> > +  bytes_in& in;
> > +  uint32_t bit_val = 0;
> > +  unsigned bit_pos = 0;
> > +
> > +  bits_in (bytes_in& in)
> > +    : in (in)
> > +  { }
> > +
> > +  ~bits_in ()
> > +  {
> > +    bflush ();
> > +  }
> > +
> > +  bits_in(const bits_in&) = delete;
> > +  bits_in& operator=(const bits_in&) = delete;
> > +
> > +  /* Completed a block of bools.  */
> > +  void bflush ()
> > +  {
> > +    if (bit_pos)
> > +      bit_flush (in, bit_val, bit_pos);
> > +  }
> > +
> > +  /* Read one bit.  */
> > +  bool b ()
> > +  {
> > +    if (!bit_pos)
> > +      bit_val = in.u32 ();
> > +    bool x = (bit_val >> bit_pos) & 1;
> > +    bit_pos = (bit_pos + 1) % 32;
> > +    return x;
> > +  }
> > +};
> > +} // anon namespace
> > +
> > +/* Bit stream writer (RAII-enabled), counterpart to bits_in.  */
> > +
> > +namespace {
> > +struct bits_out {
> > +  bytes_out& out;
> > +  uint32_t bit_val = 0;
> > +  unsigned bit_pos = 0;
> > +  char is_set = -1;
> > +
> > +  bits_out (bytes_out& out)
> > +    : out (out)
> > +  { }
> > +
> > +  ~bits_out ()
> > +  {
> > +    bflush ();
> > +  }
> > +
> > +  bits_out(const bits_out&) = delete;
> > +  bits_out& operator=(const bits_out&) = delete;
> > +
> > +  /* Completed a block of bools.  */
> > +  void bflush ()
> > +  {
> > +    if (bit_pos)
> > +      {
> > +   out.u32 (bit_val);
> > +   out.lengths[2] += bit_flush (out, bit_val, bit_pos);
> > +      }
> > +    out.spans[2]++;
> > +    is_set = -1;
> > +  }
> > +
> > +  /* Write one bit.
> > +
> > +     It may be worth optimizing for most bools being zero.  Some kind of
> > +     run-length encoding?  */
> > +  void b (bool x)
> > +  {
> > +    if (is_set != x)
> > +      {
> > +   is_set = x;
> > +   out.spans[x]++;
> > +      }
> > +    out.lengths[x]++;
> > +    bit_val |= unsigned (x) << bit_pos++;
> > +    if (bit_pos == 32)
> > +      {
> > +   out.u32 (bit_val);
> > +   out.lengths[2] += bit_flush (out, bit_val, bit_pos);
> > +      }
> > +  }
> > +};
> > +} // anon namespace
> >  
> >  /* 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.  */
> > @@ -723,73 +798,6 @@ bytes_out::set_crc (unsigned *crc_ptr)
> >      }
> >  }
> >  
> > -/* 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
> > @@ -2846,6 +2854,7 @@ struct post_process_data {
> >     read trees with TREE_VISITED.  Thus it's quite safe to have
> >     multiple concurrent readers.  Which is good, because lazy
> >     loading. */
> > +namespace {
> >  class trees_in : public bytes_in {
> >    typedef bytes_in parent;
> >  
> > @@ -2870,15 +2879,15 @@ private:
> >  
> >  public:
> >    /* Needed for binfo writing  */
> > -  bool core_bools (tree);
> > +  bool core_bools (tree, bits_in&);
> >  
> >  private:
> >    /* Stream tree_core, lang_decl_specific and lang_type_specific
> >       bits.  */
> >    bool core_vals (tree);
> > -  bool lang_type_bools (tree);
> > +  bool lang_type_bools (tree, bits_in&);
> >    bool lang_type_vals (tree);
> > -  bool lang_decl_bools (tree);
> > +  bool lang_decl_bools (tree, bits_in&);
> >    bool lang_decl_vals (tree);
> >    bool lang_vals (tree);
> >    bool tree_node_bools (tree);
> > @@ -2965,6 +2974,7 @@ private:
> >  private:
> >    void assert_definition (tree, bool installing);
> >  };
> > +} // anon namespace
> >  
> >  trees_in::trees_in (module_state *state)
> >    :parent (), state (state), unused (0)
> > @@ -2982,6 +2992,7 @@ trees_in::~trees_in ()
> >  }
> >  
> >  /* Tree stream writer.  */
> > +namespace {
> >  class trees_out : public bytes_out {
> >    typedef bytes_out parent;
> >  
> > @@ -3043,11 +3054,11 @@ public:
> >    }
> >  
> >  private:
> > -  void core_bools (tree);
> > +  void core_bools (tree, bits_out&);
> >    void core_vals (tree);
> > -  void lang_type_bools (tree);
> > +  void lang_type_bools (tree, bits_out&);
> >    void lang_type_vals (tree);
> > -  void lang_decl_bools (tree);
> > +  void lang_decl_bools (tree, bits_out&);
> >    void lang_decl_vals (tree);
> >    void lang_vals (tree);
> >    void tree_node_bools (tree);
> > @@ -3126,6 +3137,7 @@ private:
> >    static unsigned back_ref_count;
> >    static unsigned null_count;
> >  };
> > +} // anon namespace
> >  
> >  /* Instrumentation counters.  */
> >  unsigned trees_out::tree_val_count;
> > @@ -5292,9 +5304,9 @@ trees_in::start (unsigned code)
> >  /* Read & write the core boolean flags.  */
> >  
> >  void
> > -trees_out::core_bools (tree t)
> > +trees_out::core_bools (tree t, bits_out& bits)
> >  {
> > -#define WB(X) (b (X))
> > +#define WB(X) (bits.b (X))
> >    tree_code code = TREE_CODE (t);
> >  
> >    WB (t->base.side_effects_flag);
> > @@ -5314,6 +5326,8 @@ trees_out::core_bools (tree t)
> >    if (TREE_CODE_CLASS (code) != tcc_type)
> >      /* This is TYPE_CACHED_VALUES_P for types.  */
> >      WB (t->base.public_flag);
> > +  else
> > +    WB (false);
> >    WB (t->base.private_flag);
> >    WB (t->base.protected_flag);
> >    WB (t->base.deprecated_flag);
> > @@ -5327,7 +5341,7 @@ trees_out::core_bools (tree t)
> >      case TARGET_MEM_REF:
> >      case TREE_VEC:
> >        /* These use different base.u fields.  */
> > -      break;
> > +      return;
> >  
> >      default:
> >        WB (t->base.u.bits.lang_flag_0);
> > @@ -5359,7 +5373,7 @@ trees_out::core_bools (tree t)
> >        break;
> >      }
> >  
> > -  if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
> > +  if (TREE_CODE_CLASS (code) == tcc_type)
> >      {
> >        WB (t->type_common.no_force_blk_flag);
> >        WB (t->type_common.needs_constructing_flag);
> > @@ -5374,7 +5388,10 @@ trees_out::core_bools (tree t)
> >        WB (t->type_common.lang_flag_5);
> >        WB (t->type_common.lang_flag_6);
> >        WB (t->type_common.typeless_storage);
> > +      return;
> >      }
> > +  else if (TREE_CODE_CLASS (code) != tcc_declaration)
> > +    return;
> >  
> >    if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
> >      {
> > @@ -5439,6 +5456,8 @@ trees_out::core_bools (tree t)
> >        WB (t->decl_common.decl_nonshareable_flag);
> >        WB (t->decl_common.decl_not_flexarray);
> >      }
> > +  else
> > +    return;
> >  
> >    if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
> >      {
> > @@ -5459,6 +5478,8 @@ trees_out::core_bools (tree t)
> >        WB (t->decl_with_vis.final);
> >        WB (t->decl_with_vis.regdecl_flag);
> >      }
> > +  else
> > +    return;
> >  
> >    if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
> >      {
> > @@ -5489,9 +5510,10 @@ trees_out::core_bools (tree t)
> >  }
> >  
> >  bool
> > -trees_in::core_bools (tree t)
> > +trees_in::core_bools (tree t, bits_in& bits)
> >  {
> > -#define RB(X) ((X) = b ())
> > +#define RB(X) ((X) = bits.b ())
> > +
> >    tree_code code = TREE_CODE (t);
> >  
> >    RB (t->base.side_effects_flag);
> > @@ -5507,6 +5529,8 @@ trees_in::core_bools (tree t)
> >    RB (t->base.static_flag);
> >    if (TREE_CODE_CLASS (code) != tcc_type)
> >      RB (t->base.public_flag);
> > +  else
> > +    bits.b ();
> >    RB (t->base.private_flag);
> >    RB (t->base.protected_flag);
> >    RB (t->base.deprecated_flag);
> > @@ -5520,7 +5544,7 @@ trees_in::core_bools (tree t)
> >      case TARGET_MEM_REF:
> >      case TREE_VEC:
> >        /* These use different base.u fields.  */
> > -      break;
> > +      goto done;
> >  
> >      default:
> >        RB (t->base.u.bits.lang_flag_0);
> > @@ -5539,7 +5563,7 @@ trees_in::core_bools (tree t)
> >        break;
> >      }
> >  
> > -  if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
> > +  if (TREE_CODE_CLASS (code) == tcc_type)
> >      {
> >        RB (t->type_common.no_force_blk_flag);
> >        RB (t->type_common.needs_constructing_flag);
> > @@ -5554,7 +5578,10 @@ trees_in::core_bools (tree t)
> >        RB (t->type_common.lang_flag_5);
> >        RB (t->type_common.lang_flag_6);
> >        RB (t->type_common.typeless_storage);
> > +      goto done;
> >      }
> > +  else if (TREE_CODE_CLASS (code) != tcc_declaration)
> > +    goto done;
> >  
> >    if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
> >      {
> > @@ -5584,6 +5611,8 @@ trees_in::core_bools (tree t)
> >        RB (t->decl_common.decl_nonshareable_flag);
> >        RB (t->decl_common.decl_not_flexarray);
> >      }
> > +  else
> > +    goto done;
> >  
> >    if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
> >      {
> > @@ -5604,6 +5633,8 @@ trees_in::core_bools (tree t)
> >        RB (t->decl_with_vis.final);
> >        RB (t->decl_with_vis.regdecl_flag);
> >      }
> > +  else
> > +    goto done;
> >  
> >    if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
> >      {
> > @@ -5627,20 +5658,22 @@ trees_in::core_bools (tree t)
> >  
> >        /* decl_type is a (misnamed) 2 bit discriminator.     */
> >        unsigned kind = 0;
> > -      kind |= unsigned (b ()) << 0;
> > -      kind |= unsigned (b ()) << 1;
> > +      kind |= unsigned (bits.b ()) << 0;
> > +      kind |= unsigned (bits.b ()) << 1;
> >        t->function_decl.decl_type = function_decl_type (kind);
> >      }
> >  #undef RB
> > +done:
> >    return !get_overrun ();
> >  }
> >  
> >  void
> > -trees_out::lang_decl_bools (tree t)
> > +trees_out::lang_decl_bools (tree t, bits_out& bits)
> >  {
> > -#define WB(X) (b (X))
> > +#define WB(X) (bits.b (X))
> >    const struct lang_decl *lang = DECL_LANG_SPECIFIC (t);
> >  
> > +  bits.bflush ();
> >    WB (lang->u.base.language == lang_cplusplus);
> >    WB ((lang->u.base.use_template >> 0) & 1);
> >    WB ((lang->u.base.use_template >> 1) & 1);
> > @@ -5664,6 +5697,8 @@ trees_out::lang_decl_bools (tree t)
> >    WB (lang->u.base.module_attach_p);
> >    if (VAR_OR_FUNCTION_DECL_P (t))
> >      WB (lang->u.base.module_keyed_decls_p);
> > +  else
> > +    WB (false);
> >    switch (lang->u.base.selector)
> >      {
> >      default:
> > @@ -5714,15 +5749,16 @@ trees_out::lang_decl_bools (tree t)
> >  }
> >  
> >  bool
> > -trees_in::lang_decl_bools (tree t)
> > +trees_in::lang_decl_bools (tree t, bits_in& bits)
> >  {
> > -#define RB(X) ((X) = b ())
> > +#define RB(X) ((X) = bits.b ())
> >    struct lang_decl *lang = DECL_LANG_SPECIFIC (t);
> >  
> > -  lang->u.base.language = b () ? lang_cplusplus : lang_c;
> > +  bits.bflush ();
> > +  lang->u.base.language = bits.b () ? lang_cplusplus : lang_c;
> >    unsigned v;
> > -  v = b () << 0;
> > -  v |= b () << 1;
> > +  v = bits.b () << 0;
> > +  v |= bits.b () << 1;
> >    lang->u.base.use_template = v;
> >    /* lang->u.base.not_really_extern is not streamed.  */
> >    RB (lang->u.base.initialized_in_class);
> > @@ -5738,6 +5774,8 @@ trees_in::lang_decl_bools (tree t)
> >    RB (lang->u.base.module_attach_p);
> >    if (VAR_OR_FUNCTION_DECL_P (t))
> >      RB (lang->u.base.module_keyed_decls_p);
> > +  else
> > +    bits.b ();
> >    switch (lang->u.base.selector)
> >      {
> >      default:
> > @@ -5786,11 +5824,12 @@ trees_in::lang_decl_bools (tree t)
> >  }
> >  
> >  void
> > -trees_out::lang_type_bools (tree t)
> > +trees_out::lang_type_bools (tree t, bits_out& bits)
> >  {
> > -#define WB(X) (b (X))
> > +#define WB(X) (bits.b (X))
> >    const struct lang_type *lang = TYPE_LANG_SPECIFIC (t);
> >  
> > +  bits.bflush ();
> >    WB (lang->has_type_conversion);
> >    WB (lang->has_copy_ctor);
> >    WB (lang->has_default_ctor);
> > @@ -5852,11 +5891,12 @@ trees_out::lang_type_bools (tree t)
> >  }
> >  
> >  bool
> > -trees_in::lang_type_bools (tree t)
> > +trees_in::lang_type_bools (tree t, bits_in& bits)
> >  {
> > -#define RB(X) ((X) = b ())
> > +#define RB(X) ((X) = bits.b ())
> >    struct lang_type *lang = TYPE_LANG_SPECIFIC (t);
> >  
> > +  bits.bflush ();
> >    RB (lang->has_type_conversion);
> >    RB (lang->has_copy_ctor);
> >    RB (lang->has_default_ctor);
> > @@ -5864,8 +5904,8 @@ trees_in::lang_type_bools (tree t)
> >    RB (lang->ref_needs_init);
> >    RB (lang->has_const_copy_assign);
> >    unsigned v;
> > -  v = b () << 0;
> > -  v |= b () << 1;
> > +  v = bits.b () << 0;
> > +  v |= bits.b () << 1;
> >    lang->use_template = v;
> >  
> >    RB (lang->has_mutable);
> > @@ -5877,8 +5917,8 @@ trees_in::lang_type_bools (tree t)
> >    RB (lang->has_new);
> >    RB (lang->has_array_new);
> >  
> > -  v = b () << 0;
> > -  v |= b () << 1;
> > +  v = bits.b () << 0;
> > +  v |= bits.b () << 1;
> >    lang->gets_delete = v;
> >    RB (lang->interface_only);
> >    RB (lang->interface_unknown);
> > @@ -7106,18 +7146,19 @@ trees_out::tree_node_bools (tree t)
> >    gcc_checking_assert (TREE_CODE (t) != NAMESPACE_DECL
> >                    || DECL_NAMESPACE_ALIAS (t));
> >  
> > -  core_bools (t);
> > +  bits_out bits (*this);
> > +  core_bools (t, bits);
> >  
> >    switch (TREE_CODE_CLASS (TREE_CODE (t)))
> >      {
> >      case tcc_declaration:
> >        {
> >     bool specific = DECL_LANG_SPECIFIC (t) != NULL;
> > -   b (specific);
> > +   bits.b (specific);
> >     if (specific && VAR_P (t))
> > -     b (DECL_DECOMPOSITION_P (t));
> > +     bits.b (DECL_DECOMPOSITION_P (t));
> >     if (specific)
> > -     lang_decl_bools (t);
> > +     lang_decl_bools (t, bits);
> >        }
> >        break;
> >  
> > @@ -7128,9 +7169,9 @@ trees_out::tree_node_bools (tree t)
> >     gcc_assert (TYPE_LANG_SPECIFIC (t)
> >                 == TYPE_LANG_SPECIFIC (TYPE_MAIN_VARIANT (t)));
> >  
> > -   b (specific);
> > +   bits.b (specific);
> >     if (specific)
> > -     lang_type_bools (t);
> > +     lang_type_bools (t, bits);
> >        }
> >        break;
> >  
> > @@ -7138,34 +7179,35 @@ trees_out::tree_node_bools (tree t)
> >        break;
> >      }
> >  
> > -  bflush ();
> > +  bits.bflush ();
> >  }
> >  
> >  bool
> >  trees_in::tree_node_bools (tree t)
> >  {
> > -  bool ok = core_bools (t);
> > +  bits_in bits (*this);
> > +  bool ok = core_bools (t, bits);
> >  
> >    if (ok)
> >      switch (TREE_CODE_CLASS (TREE_CODE (t)))
> >        {
> >        case tcc_declaration:
> > -   if (b ())
> > +   if (bits.b ())
> >       {
> > -       bool decomp = VAR_P (t) && b ();
> > +       bool decomp = VAR_P (t) && bits.b ();
> >  
> >         ok = maybe_add_lang_decl_raw (t, decomp);
> >         if (ok)
> > -         ok = lang_decl_bools (t);
> > -   }
> > +         ok = lang_decl_bools (t, bits);
> > +     }
> >     break;
> >  
> >        case tcc_type:
> > -   if (b ())
> > +   if (bits.b ())
> >       {
> >         ok = maybe_add_lang_type_raw (t);
> >         if (ok)
> > -         ok = lang_type_bools (t);
> > +         ok = lang_type_bools (t, bits);
> >       }
> >     break;
> >  
> > @@ -7173,7 +7215,7 @@ trees_in::tree_node_bools (tree t)
> >     break;
> >        }
> >  
> > -  bflush ();
> > +  bits.bflush ();
> >    if (!ok || get_overrun ())
> >      return false;
> >  
> > @@ -7696,11 +7738,11 @@ trees_out::decl_value (tree decl, depset *dep)
> >  
> >        if (mk != MK_unique)
> >     {
> > +     bits_out bits (*this);
> >       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.  */
> > +            or a module entity.  */
> >           tree o = get_originating_module_decl (decl);
> >           bool is_attached = false;
> >  
> > @@ -7709,9 +7751,9 @@ trees_out::decl_value (tree decl, depset *dep)
> >               && DECL_MODULE_ATTACH_P (not_tmpl))
> >             is_attached = true;
> >  
> > -         b (is_attached);
> > +         bits.b (is_attached);
> >         }
> > -     b (dep && dep->has_defn ());
> > +     bits.b (dep && dep->has_defn ());
> >     }
> >        tree_node_bools (decl);
> >      }
> > @@ -7981,11 +8023,11 @@ trees_in::decl_value ()
> >      {
> >        if (mk != MK_unique)
> >     {
> > +     bits_in bits (*this);
> >       if (!(mk & MK_template_mask) && !state->is_header ())
> > -       /* See note in trees_out about where this bool is sequenced.  */
> > -       is_attached = b ();
> > +       is_attached = bits.b ();
> >  
> > -     has_defn = b ();
> > +     has_defn = bits.b ();
> >     }
> >  
> >        if (!tree_node_bools (decl))
> > @@ -16682,10 +16724,11 @@ module_state::write_define (bytes_out &sec, const 
> > cpp_macro *macro)
> >  {
> >    sec.u (macro->count);
> >  
> > -  sec.b (macro->fun_like);
> > -  sec.b (macro->variadic);
> > -  sec.b (macro->syshdr);
> > -  sec.bflush ();
> > +  bits_out bits (sec);
> > +  bits.b (macro->fun_like);
> > +  bits.b (macro->variadic);
> > +  bits.b (macro->syshdr);
> > +  bits.bflush ();
> >  
> >    write_location (sec, macro->line);
> >    if (macro->fun_like)
> > @@ -16780,10 +16823,11 @@ module_state::read_define (bytes_in &sec, 
> > cpp_reader *reader) const
> >    macro->kind = cmk_macro;
> >    macro->imported_p = true;
> >  
> > -  macro->fun_like = sec.b ();
> > -  macro->variadic = sec.b ();
> > -  macro->syshdr = sec.b ();
> > -  sec.bflush ();
> > +  bits_in bits (sec);
> > +  macro->fun_like = bits.b ();
> > +  macro->variadic = bits.b ();
> > +  macro->syshdr = bits.b ();
> > +  bits.bflush ();
> >  
> >    macro->line = read_location (sec);
> >  
> > -- 
> > 2.44.0.rc1.15.g4fc51f00ef
> > 
> > 
> 

Reply via email to