src/google/protobuf/generated_message_tctable_decl.h - third_party/github/protocolbuffers/protobuf - Git at Google

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 // This file contains declarations needed in generated headers for messages
 // that use tail-call table parsing. Everything in this file is for internal
 // use only.

 #ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_DECL_H__
 #define GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_DECL_H__

 #include <array>
 #include <atomic>
 #include <cstddef>
 #include <cstdint>
 #include <type_traits>

 #include "google/protobuf/message_lite.h"
 #include "google/protobuf/parse_context.h"

 // Must come last:
 #include "google/protobuf/port_def.inc"

 namespace google {
 namespace protobuf {
 namespace internal {

 // Additional information about this field:
 struct TcFieldData {
   constexpr TcFieldData() : data(0) {}

   // Fast table entry constructor:
   constexpr TcFieldData(uint16_t coded_tag, uint8_t hasbit_idx, uint8_t aux_idx,
                         uint16_t offset)
       : data(uint64_t{offset} << 48 |      //
              uint64_t{aux_idx} << 24 |     //
              uint64_t{hasbit_idx} << 16 |  //
              uint64_t{coded_tag}) {}

   // Fields used in fast table parsing:
   //
   //     Bit:
   //     +-----------+-------------------+
   //     |63    ..     32|31     ..     0|
   //     +---------------+---------------+
   //     :   .   :   .   :   . 16|=======| [16] coded_tag()
   //     :   .   :   .   : 24|===|   .   : [ 8] hasbit_idx()
   //     :   .   :   . 32|===|   :   .   : [ 8] aux_idx()
   //     :   . 48:---.---:   .   :   .   : [16] (unused)
   //     |=======|   .   :   .   :   .   : [16] offset()
   //     +-----------+-------------------+
   //     |63    ..     32|31     ..     0|
   //     +---------------+---------------+

   template <typename TagType = uint16_t>
   TagType coded_tag() const {
     return static_cast<TagType>(data);
   }
   uint8_t hasbit_idx() const { return static_cast<uint8_t>(data >> 16); }
   uint8_t aux_idx() const { return static_cast<uint8_t>(data >> 24); }
   uint16_t offset() const { return static_cast<uint16_t>(data >> 48); }

   // Constructor for special entries that do not represent a field.
   //  - End group: `nonfield_info` is the decoded tag.
   constexpr TcFieldData(uint16_t coded_tag, uint16_t nonfield_info)
       : data(uint64_t{nonfield_info} << 16 |  //
              uint64_t{coded_tag}) {}

   // Fields used in non-field entries
   //
   //     Bit:
   //     +-----------+-------------------+
   //     |63    ..     32|31     ..     0|
   //     +---------------+---------------+
   //     :   .   :   .   :   . 16|=======| [16] coded_tag()
   //     :   .   :   . 32|=======|   .   : [16] decoded_tag()
   //     :---.---:---.---:   .   :   .   : [32] (unused)
   //     +-----------+-------------------+
   //     |63    ..     32|31     ..     0|
   //     +---------------+---------------+

   uint16_t decoded_tag() const { return static_cast<uint16_t>(data >> 16); }

   // Fields used in mini table parsing:
   //
   //     Bit:
   //     +-----------+-------------------+
   //     |63    ..     32|31     ..     0|
   //     +---------------+---------------+
   //     :   .   :   .   |===============| [32] tag() (decoded)
   //     |===============|   .   :   .   : [32] entry_offset()
   //     +-----------+-------------------+
   //     |63    ..     32|31     ..     0|
   //     +---------------+---------------+

   uint32_t tag() const { return static_cast<uint32_t>(data); }
   uint32_t entry_offset() const { return static_cast<uint32_t>(data >> 32); }

   // Fields used for passing unknown enum values to the generic fallback:
   //     Bit:
   //     +-----------+-------------------+
   //     |63    ..     32|31     ..     0|
   //     +---------------+---------------+
   //     :   .   :   .   |===============| [32] tag() (decoded)
   //     |===============|   .   :   .   : [32] unknown_enum_value()
   //     +-----------+-------------------+
   //     |63    ..     32|31     ..     0|
   //     +---------------+---------------+
   int32_t unknown_enum_value() const {
     return static_cast<int32_t>(data >> 32);
   }

   uint64_t data;
 };

 struct TcParseTableBase;

 // TailCallParseFunc is the function pointer type used in the tailcall table.
 typedef const char* (*TailCallParseFunc)(PROTOBUF_TC_PARAM_DECL);

 namespace field_layout {
 struct Offset {
   uint32_t off;
 };
 }  // namespace field_layout

 #if defined(_MSC_VER) && !defined(_WIN64)
 #pragma warning(push)
 // TcParseTableBase is intentionally overaligned on 32 bit targets.
 #pragma warning(disable : 4324)
 #endif

 struct FieldAuxDefaultMessage {};

 // Base class for message-level table with info for the tail-call parser.
 struct alignas(uint64_t) TcParseTableBase {
   // Common attributes for message layout:
   uint16_t has_bits_offset;
   uint16_t extension_offset;
   uint32_t extension_range_low;
   uint32_t extension_range_high;
   uint32_t max_field_number;
   uint8_t fast_idx_mask;
   uint16_t lookup_table_offset;
   uint32_t skipmap32;
   uint32_t field_entries_offset;
   uint16_t num_field_entries;

   uint16_t num_aux_entries;
   uint32_t aux_offset;

   const MessageLite* default_instance;

   // Handler for fields which are not handled by table dispatch.
   TailCallParseFunc fallback;

   // This constructor exactly follows the field layout, so it's technically
   // not necessary.  However, it makes it much much easier to add or re-arrange
   // fields, because it can be overloaded with an additional constructor,
   // temporarily allowing both old and new protocol buffer headers to be
   // compiled.
   constexpr TcParseTableBase(
       uint16_t has_bits_offset, uint16_t extension_offset,
       uint32_t extension_range_low, uint32_t extension_range_high,
       uint32_t max_field_number, uint8_t fast_idx_mask,
       uint16_t lookup_table_offset, uint32_t skipmap32,
       uint32_t field_entries_offset, uint16_t num_field_entries,
       uint16_t num_aux_entries, uint32_t aux_offset,
       const MessageLite* default_instance, TailCallParseFunc fallback)
       : has_bits_offset(has_bits_offset),
         extension_offset(extension_offset),
         extension_range_low(extension_range_low),
         extension_range_high(extension_range_high),
         max_field_number(max_field_number),
         fast_idx_mask(fast_idx_mask),
         lookup_table_offset(lookup_table_offset),
         skipmap32(skipmap32),
         field_entries_offset(field_entries_offset),
         num_field_entries(num_field_entries),
         num_aux_entries(num_aux_entries),
         aux_offset(aux_offset),
         default_instance(default_instance),
         fallback(fallback) {}

   // Table entry for fast-path tailcall dispatch handling.
   struct FastFieldEntry {
     // Target function for dispatch:
     mutable std::atomic<TailCallParseFunc> target_atomic;

     // Field data used during parse:
     TcFieldData bits;

     // Default initializes this instance with undefined values.
     FastFieldEntry() = default;

     // Constant initializes this instance
     constexpr FastFieldEntry(TailCallParseFunc func, TcFieldData bits)
         : target_atomic(func), bits(bits) {}

     // FastFieldEntry is copy-able and assignable, which is intended
     // mainly for testing and debugging purposes.
     FastFieldEntry(const FastFieldEntry& rhs) noexcept
         : FastFieldEntry(rhs.target(), rhs.bits) {}
     FastFieldEntry& operator=(const FastFieldEntry& rhs) noexcept {
       SetTarget(rhs.target());
       bits = rhs.bits;
       return *this;
     }

     // Protocol buffer code should use these relaxed accessors.
     TailCallParseFunc target() const {
       return target_atomic.load(std::memory_order_relaxed);
     }
     void SetTarget(TailCallParseFunc func) const {
       return target_atomic.store(func, std::memory_order_relaxed);
     }
   };
   // There is always at least one table entry.
   const FastFieldEntry* fast_entry(size_t idx) const {
     return reinterpret_cast<const FastFieldEntry*>(this + 1) + idx;
   }
   FastFieldEntry* fast_entry(size_t idx) {
     return reinterpret_cast<FastFieldEntry*>(this + 1) + idx;
   }

   // Returns a begin iterator (pointer) to the start of the field lookup table.
   const uint16_t* field_lookup_begin() const {
     return reinterpret_cast<const uint16_t*>(reinterpret_cast<uintptr_t>(this) +
                                              lookup_table_offset);
   }
   uint16_t* field_lookup_begin() {
     return reinterpret_cast<uint16_t*>(reinterpret_cast<uintptr_t>(this) +
                                        lookup_table_offset);
   }

   // Field entry for all fields.
   struct FieldEntry {
     uint32_t offset;     // offset in the message object
     int32_t has_idx;     // has-bit index, relative to the message object
     uint16_t aux_idx;    // index for `field_aux`.
     uint16_t type_card;  // `FieldType` and `Cardinality` (see _impl.h)
   };

   // Returns a begin iterator (pointer) to the start of the field entries array.
   const FieldEntry* field_entries_begin() const {
     return reinterpret_cast<const FieldEntry*>(
         reinterpret_cast<uintptr_t>(this) + field_entries_offset);
   }
   FieldEntry* field_entries_begin() {
     return reinterpret_cast<FieldEntry*>(reinterpret_cast<uintptr_t>(this) +
                                          field_entries_offset);
   }

   // Auxiliary entries for field types that need extra information.
   union FieldAux {
     constexpr FieldAux() : message_default_p(nullptr) {}
     constexpr FieldAux(bool (*enum_validator)(int))
         : enum_validator(enum_validator) {}
     constexpr FieldAux(field_layout::Offset off) : offset(off.off) {}
     constexpr FieldAux(int16_t range_start, uint16_t range_length)
         : enum_range{range_start, range_length} {}
     constexpr FieldAux(const MessageLite* msg) : message_default_p(msg) {}
     constexpr FieldAux(FieldAuxDefaultMessage, const void* msg)
         : message_default_p(msg) {}
     constexpr FieldAux(const TcParseTableBase* table) : table(table) {}
     constexpr FieldAux(LazyEagerVerifyFnType verify_func)
         : verify_func(verify_func) {}
     bool (*enum_validator)(int);
     struct {
       int16_t start;    // minimum enum number (if it fits)
       uint16_t length;  // length of range (i.e., max = start + length - 1)
     } enum_range;
     uint32_t offset;
     const void* message_default_p;
     const TcParseTableBase* table;
     LazyEagerVerifyFnType verify_func;

     const MessageLite* message_default() const {
       return static_cast<const MessageLite*>(message_default_p);
     }
     const MessageLite* message_default_weak() const {
       return *static_cast<const MessageLite* const*>(message_default_p);
     }
   };
   const FieldAux* field_aux(uint32_t idx) const {
     return reinterpret_cast<const FieldAux*>(reinterpret_cast<uintptr_t>(this) +
                                              aux_offset) +
            idx;
   }
   FieldAux* field_aux(uint32_t idx) {
     return reinterpret_cast<FieldAux*>(reinterpret_cast<uintptr_t>(this) +
                                        aux_offset) +
            idx;
   }
   const FieldAux* field_aux(const FieldEntry* entry) const {
     return field_aux(entry->aux_idx);
   }

   // Field name data
   const char* name_data() const {
     return reinterpret_cast<const char*>(reinterpret_cast<uintptr_t>(this) +
                                          aux_offset +
                                          num_aux_entries * sizeof(FieldAux));
   }
   char* name_data() {
     return reinterpret_cast<char*>(reinterpret_cast<uintptr_t>(this) +
                                    aux_offset +
                                    num_aux_entries * sizeof(FieldAux));
   }
 };

 #if defined(_MSC_VER) && !defined(_WIN64)
 #pragma warning(pop)
 #endif

 static_assert(sizeof(TcParseTableBase::FastFieldEntry) <= 16,
               "Fast field entry is too big.");
 static_assert(sizeof(TcParseTableBase::FieldEntry) <= 16,
               "Field entry is too big.");

 template <size_t kFastTableSizeLog2, size_t kNumFieldEntries = 0,
           size_t kNumFieldAux = 0, size_t kNameTableSize = 0,
           size_t kFieldLookupSize = 2>
 struct TcParseTable {
   TcParseTableBase header;

   // Entries for each field.
   //
   // Fields are indexed by the lowest bits of their field number. The field
   // number is masked to fit inside the table. Note that the parsing logic
   // generally calls `TailCallParseTableBase::fast_entry()` instead of accessing
   // this field directly.
   std::array<TcParseTableBase::FastFieldEntry, (1 << kFastTableSizeLog2)>
       fast_entries;

   // Just big enough to find all the field entries.
   std::array<uint16_t, kFieldLookupSize> field_lookup_table;
   // Entries for all fields:
   std::array<TcParseTableBase::FieldEntry, kNumFieldEntries> field_entries;
   std::array<TcParseTableBase::FieldAux, kNumFieldAux> aux_entries;
   std::array<char, kNameTableSize == 0 ? 1 : kNameTableSize> field_names;
 };

 // Partial specialization: if there are no aux entries, there will be no array.
 // In C++, arrays cannot have length 0, but (C++11) std::array<T, 0> is valid.
 // However, different implementations have different sizeof(std::array<T, 0>).
 // Skipping the member makes offset computations portable.
 template <size_t kFastTableSizeLog2, size_t kNumFieldEntries,
           size_t kNameTableSize, size_t kFieldLookupSize>
 struct TcParseTable<kFastTableSizeLog2, kNumFieldEntries, 0, kNameTableSize,
                     kFieldLookupSize> {
   TcParseTableBase header;
   std::array<TcParseTableBase::FastFieldEntry, (1 << kFastTableSizeLog2)>
       fast_entries;
   std::array<uint16_t, kFieldLookupSize> field_lookup_table;
   std::array<TcParseTableBase::FieldEntry, kNumFieldEntries> field_entries;
   std::array<char, kNameTableSize == 0 ? 1 : kNameTableSize> field_names;
 };

 // Partial specialization: if there are no fields at all, then we can save space
 // by skipping the field numbers and entries.
 template <size_t kNameTableSize, size_t kFieldLookupSize>
 struct TcParseTable<0, 0, 0, kNameTableSize, kFieldLookupSize> {
   TcParseTableBase header;
   // N.B.: the fast entries are sized by log2, so 2**0 fields = 1 entry.
   // The fast parsing loop will always use this entry, so it must be present.
   std::array<TcParseTableBase::FastFieldEntry, 1> fast_entries;
   std::array<uint16_t, kFieldLookupSize> field_lookup_table;
   std::array<char, kNameTableSize == 0 ? 1 : kNameTableSize> field_names;
 };

 static_assert(std::is_standard_layout<TcParseTable<1>>::value,
               "TcParseTable must be standard layout.");

 static_assert(offsetof(TcParseTable<1>, fast_entries) ==
                   sizeof(TcParseTableBase),
               "Table entries must be laid out after TcParseTableBase.");

 }  // namespace internal
 }  // namespace protobuf
 }  // namespace google

 #include "google/protobuf/port_undef.inc"

 #endif  // GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_DECL_H__
	// Protocol Buffers - Google's data interchange format
	// Copyright 2008 Google Inc. All rights reserved.
	// https://developers.google.com/protocol-buffers/
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are
	// met:
	//
	// * Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// * Redistributions in binary form must reproduce the above
	// copyright notice, this list of conditions and the following disclaimer
	// in the documentation and/or other materials provided with the
	// distribution.
	// * Neither the name of Google Inc. nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	// This file contains declarations needed in generated headers for messages
	// that use tail-call table parsing. Everything in this file is for internal
	// use only.

	#ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_DECL_H__
	#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_DECL_H__

	#include <array>
	#include <atomic>
	#include <cstddef>
	#include <cstdint>
	#include <type_traits>

	#include "google/protobuf/message_lite.h"
	#include "google/protobuf/parse_context.h"

	// Must come last:
	#include "google/protobuf/port_def.inc"

	namespace google {
	namespace protobuf {
	namespace internal {

	// Additional information about this field:
	struct TcFieldData {
	constexpr TcFieldData() : data(0) {}

	// Fast table entry constructor:
	constexpr TcFieldData(uint16_t coded_tag, uint8_t hasbit_idx, uint8_t aux_idx,
	uint16_t offset)
	: data(uint64_t{offset} << 48 \| //
	uint64_t{aux_idx} << 24 \| //
	uint64_t{hasbit_idx} << 16 \| //
	uint64_t{coded_tag}) {}

	// Fields used in fast table parsing:
	//
	// Bit:
	// +-----------+-------------------+
	// \|63 .. 32\|31 .. 0\|
	// +---------------+---------------+
	// : . : . : . 16\|=======\| [16] coded_tag()
	// : . : . : 24\|===\| . : [ 8] hasbit_idx()
	// : . : . 32\|===\| : . : [ 8] aux_idx()
	// : . 48:---.---: . : . : [16] (unused)
	// \|=======\| . : . : . : [16] offset()
	// +-----------+-------------------+
	// \|63 .. 32\|31 .. 0\|
	// +---------------+---------------+

	template <typename TagType = uint16_t>
	TagType coded_tag() const {
	return static_cast<TagType>(data);
	}
	uint8_t hasbit_idx() const { return static_cast<uint8_t>(data >> 16); }
	uint8_t aux_idx() const { return static_cast<uint8_t>(data >> 24); }
	uint16_t offset() const { return static_cast<uint16_t>(data >> 48); }

	// Constructor for special entries that do not represent a field.
	// - End group: `nonfield_info` is the decoded tag.
	constexpr TcFieldData(uint16_t coded_tag, uint16_t nonfield_info)
	: data(uint64_t{nonfield_info} << 16 \| //
	uint64_t{coded_tag}) {}

	// Fields used in non-field entries
	//
	// Bit:
	// +-----------+-------------------+
	// \|63 .. 32\|31 .. 0\|
	// +---------------+---------------+
	// : . : . : . 16\|=======\| [16] coded_tag()
	// : . : . 32\|=======\| . : [16] decoded_tag()
	// :---.---:---.---: . : . : [32] (unused)
	// +-----------+-------------------+
	// \|63 .. 32\|31 .. 0\|
	// +---------------+---------------+

	uint16_t decoded_tag() const { return static_cast<uint16_t>(data >> 16); }

	// Fields used in mini table parsing:
	//
	// Bit:
	// +-----------+-------------------+
	// \|63 .. 32\|31 .. 0\|
	// +---------------+---------------+
	// : . : . \|===============\| [32] tag() (decoded)
	// \|===============\| . : . : [32] entry_offset()
	// +-----------+-------------------+
	// \|63 .. 32\|31 .. 0\|
	// +---------------+---------------+

	uint32_t tag() const { return static_cast<uint32_t>(data); }
	uint32_t entry_offset() const { return static_cast<uint32_t>(data >> 32); }

	// Fields used for passing unknown enum values to the generic fallback:
	// Bit:
	// +-----------+-------------------+
	// \|63 .. 32\|31 .. 0\|
	// +---------------+---------------+
	// : . : . \|===============\| [32] tag() (decoded)
	// \|===============\| . : . : [32] unknown_enum_value()
	// +-----------+-------------------+
	// \|63 .. 32\|31 .. 0\|
	// +---------------+---------------+
	int32_t unknown_enum_value() const {
	return static_cast<int32_t>(data >> 32);
	}

	uint64_t data;
	};

	struct TcParseTableBase;

	// TailCallParseFunc is the function pointer type used in the tailcall table.
	typedef const char* (*TailCallParseFunc)(PROTOBUF_TC_PARAM_DECL);

	namespace field_layout {
	struct Offset {
	uint32_t off;
	};
	} // namespace field_layout

	#if defined(_MSC_VER) && !defined(_WIN64)
	#pragma warning(push)
	// TcParseTableBase is intentionally overaligned on 32 bit targets.
	#pragma warning(disable : 4324)
	#endif

	struct FieldAuxDefaultMessage {};

	// Base class for message-level table with info for the tail-call parser.
	struct alignas(uint64_t) TcParseTableBase {
	// Common attributes for message layout:
	uint16_t has_bits_offset;
	uint16_t extension_offset;
	uint32_t extension_range_low;
	uint32_t extension_range_high;
	uint32_t max_field_number;
	uint8_t fast_idx_mask;
	uint16_t lookup_table_offset;
	uint32_t skipmap32;
	uint32_t field_entries_offset;
	uint16_t num_field_entries;

	uint16_t num_aux_entries;
	uint32_t aux_offset;

	const MessageLite* default_instance;

	// Handler for fields which are not handled by table dispatch.
	TailCallParseFunc fallback;

	// This constructor exactly follows the field layout, so it's technically
	// not necessary. However, it makes it much much easier to add or re-arrange
	// fields, because it can be overloaded with an additional constructor,
	// temporarily allowing both old and new protocol buffer headers to be
	// compiled.
	constexpr TcParseTableBase(
	uint16_t has_bits_offset, uint16_t extension_offset,
	uint32_t extension_range_low, uint32_t extension_range_high,
	uint32_t max_field_number, uint8_t fast_idx_mask,
	uint16_t lookup_table_offset, uint32_t skipmap32,
	uint32_t field_entries_offset, uint16_t num_field_entries,
	uint16_t num_aux_entries, uint32_t aux_offset,
	const MessageLite* default_instance, TailCallParseFunc fallback)
	: has_bits_offset(has_bits_offset),
	extension_offset(extension_offset),
	extension_range_low(extension_range_low),
	extension_range_high(extension_range_high),
	max_field_number(max_field_number),
	fast_idx_mask(fast_idx_mask),
	lookup_table_offset(lookup_table_offset),
	skipmap32(skipmap32),
	field_entries_offset(field_entries_offset),
	num_field_entries(num_field_entries),
	num_aux_entries(num_aux_entries),
	aux_offset(aux_offset),
	default_instance(default_instance),
	fallback(fallback) {}

	// Table entry for fast-path tailcall dispatch handling.
	struct FastFieldEntry {
	// Target function for dispatch:
	mutable std::atomic<TailCallParseFunc> target_atomic;

	// Field data used during parse:
	TcFieldData bits;

	// Default initializes this instance with undefined values.
	FastFieldEntry() = default;

	// Constant initializes this instance
	constexpr FastFieldEntry(TailCallParseFunc func, TcFieldData bits)
	: target_atomic(func), bits(bits) {}

	// FastFieldEntry is copy-able and assignable, which is intended
	// mainly for testing and debugging purposes.
	FastFieldEntry(const FastFieldEntry& rhs) noexcept
	: FastFieldEntry(rhs.target(), rhs.bits) {}
	FastFieldEntry& operator=(const FastFieldEntry& rhs) noexcept {
	SetTarget(rhs.target());
	bits = rhs.bits;
	return *this;
	}

	// Protocol buffer code should use these relaxed accessors.
	TailCallParseFunc target() const {
	return target_atomic.load(std::memory_order_relaxed);
	}
	void SetTarget(TailCallParseFunc func) const {
	return target_atomic.store(func, std::memory_order_relaxed);
	}
	};
	// There is always at least one table entry.
	const FastFieldEntry* fast_entry(size_t idx) const {
	return reinterpret_cast<const FastFieldEntry*>(this + 1) + idx;
	}
	FastFieldEntry* fast_entry(size_t idx) {
	return reinterpret_cast<FastFieldEntry*>(this + 1) + idx;
	}

	// Returns a begin iterator (pointer) to the start of the field lookup table.
	const uint16_t* field_lookup_begin() const {
	return reinterpret_cast<const uint16_t*>(reinterpret_cast<uintptr_t>(this) +
	lookup_table_offset);
	}
	uint16_t* field_lookup_begin() {
	return reinterpret_cast<uint16_t*>(reinterpret_cast<uintptr_t>(this) +
	lookup_table_offset);
	}

	// Field entry for all fields.
	struct FieldEntry {
	uint32_t offset; // offset in the message object
	int32_t has_idx; // has-bit index, relative to the message object
	uint16_t aux_idx; // index for `field_aux`.
	uint16_t type_card; // `FieldType` and `Cardinality` (see _impl.h)
	};

	// Returns a begin iterator (pointer) to the start of the field entries array.
	const FieldEntry* field_entries_begin() const {
	return reinterpret_cast<const FieldEntry*>(
	reinterpret_cast<uintptr_t>(this) + field_entries_offset);
	}
	FieldEntry* field_entries_begin() {
	return reinterpret_cast<FieldEntry*>(reinterpret_cast<uintptr_t>(this) +
	field_entries_offset);
	}

	// Auxiliary entries for field types that need extra information.
	union FieldAux {
	constexpr FieldAux() : message_default_p(nullptr) {}
	constexpr FieldAux(bool (*enum_validator)(int))
	: enum_validator(enum_validator) {}
	constexpr FieldAux(field_layout::Offset off) : offset(off.off) {}
	constexpr FieldAux(int16_t range_start, uint16_t range_length)
	: enum_range{range_start, range_length} {}
	constexpr FieldAux(const MessageLite* msg) : message_default_p(msg) {}
	constexpr FieldAux(FieldAuxDefaultMessage, const void* msg)
	: message_default_p(msg) {}
	constexpr FieldAux(const TcParseTableBase* table) : table(table) {}
	constexpr FieldAux(LazyEagerVerifyFnType verify_func)
	: verify_func(verify_func) {}
	bool (*enum_validator)(int);
	struct {
	int16_t start; // minimum enum number (if it fits)
	uint16_t length; // length of range (i.e., max = start + length - 1)
	} enum_range;
	uint32_t offset;
	const void* message_default_p;
	const TcParseTableBase* table;
	LazyEagerVerifyFnType verify_func;

	const MessageLite* message_default() const {
	return static_cast<const MessageLite*>(message_default_p);
	}
	const MessageLite* message_default_weak() const {
	return static_cast<const MessageLite const*>(message_default_p);
	}
	};
	const FieldAux* field_aux(uint32_t idx) const {
	return reinterpret_cast<const FieldAux*>(reinterpret_cast<uintptr_t>(this) +
	aux_offset) +
	idx;
	}
	FieldAux* field_aux(uint32_t idx) {
	return reinterpret_cast<FieldAux*>(reinterpret_cast<uintptr_t>(this) +
	aux_offset) +
	idx;
	}
	const FieldAux* field_aux(const FieldEntry* entry) const {
	return field_aux(entry->aux_idx);
	}

	// Field name data
	const char* name_data() const {
	return reinterpret_cast<const char*>(reinterpret_cast<uintptr_t>(this) +
	aux_offset +
	num_aux_entries * sizeof(FieldAux));
	}
	char* name_data() {
	return reinterpret_cast<char*>(reinterpret_cast<uintptr_t>(this) +
	aux_offset +
	num_aux_entries * sizeof(FieldAux));
	}
	};

	#if defined(_MSC_VER) && !defined(_WIN64)
	#pragma warning(pop)
	#endif

	static_assert(sizeof(TcParseTableBase::FastFieldEntry) <= 16,
	"Fast field entry is too big.");
	static_assert(sizeof(TcParseTableBase::FieldEntry) <= 16,
	"Field entry is too big.");

	template <size_t kFastTableSizeLog2, size_t kNumFieldEntries = 0,
	size_t kNumFieldAux = 0, size_t kNameTableSize = 0,
	size_t kFieldLookupSize = 2>
	struct TcParseTable {
	TcParseTableBase header;

	// Entries for each field.
	//
	// Fields are indexed by the lowest bits of their field number. The field
	// number is masked to fit inside the table. Note that the parsing logic
	// generally calls `TailCallParseTableBase::fast_entry()` instead of accessing
	// this field directly.
	std::array<TcParseTableBase::FastFieldEntry, (1 << kFastTableSizeLog2)>
	fast_entries;

	// Just big enough to find all the field entries.
	std::array<uint16_t, kFieldLookupSize> field_lookup_table;
	// Entries for all fields:
	std::array<TcParseTableBase::FieldEntry, kNumFieldEntries> field_entries;
	std::array<TcParseTableBase::FieldAux, kNumFieldAux> aux_entries;
	std::array<char, kNameTableSize == 0 ? 1 : kNameTableSize> field_names;
	};

	// Partial specialization: if there are no aux entries, there will be no array.
	// In C++, arrays cannot have length 0, but (C++11) std::array<T, 0> is valid.
	// However, different implementations have different sizeof(std::array<T, 0>).
	// Skipping the member makes offset computations portable.
	template <size_t kFastTableSizeLog2, size_t kNumFieldEntries,
	size_t kNameTableSize, size_t kFieldLookupSize>
	struct TcParseTable<kFastTableSizeLog2, kNumFieldEntries, 0, kNameTableSize,
	kFieldLookupSize> {
	TcParseTableBase header;
	std::array<TcParseTableBase::FastFieldEntry, (1 << kFastTableSizeLog2)>
	fast_entries;
	std::array<uint16_t, kFieldLookupSize> field_lookup_table;
	std::array<TcParseTableBase::FieldEntry, kNumFieldEntries> field_entries;
	std::array<char, kNameTableSize == 0 ? 1 : kNameTableSize> field_names;
	};

	// Partial specialization: if there are no fields at all, then we can save space
	// by skipping the field numbers and entries.
	template <size_t kNameTableSize, size_t kFieldLookupSize>
	struct TcParseTable<0, 0, 0, kNameTableSize, kFieldLookupSize> {
	TcParseTableBase header;
	// N.B.: the fast entries are sized by log2, so 2**0 fields = 1 entry.
	// The fast parsing loop will always use this entry, so it must be present.
	std::array<TcParseTableBase::FastFieldEntry, 1> fast_entries;
	std::array<uint16_t, kFieldLookupSize> field_lookup_table;
	std::array<char, kNameTableSize == 0 ? 1 : kNameTableSize> field_names;
	};

	static_assert(std::is_standard_layout<TcParseTable<1>>::value,
	"TcParseTable must be standard layout.");

	static_assert(offsetof(TcParseTable<1>, fast_entries) ==
	sizeof(TcParseTableBase),
	"Table entries must be laid out after TcParseTableBase.");

	} // namespace internal
	} // namespace protobuf
	} // namespace google

	#include "google/protobuf/port_undef.inc"

	#endif // GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_DECL_H__