From 33ed2f727a3a37abf2a1e0e9735f71d4ea693f11 Mon Sep 17 00:00:00 2001 From: George Hazan Date: Wed, 14 Sep 2022 07:12:15 -0700 Subject: protobuf headers & libs --- .../protobuf/generated_message_tctable_decl.h | 312 +++++++++++++++++++++ 1 file changed, 312 insertions(+) create mode 100644 include/google/protobuf/generated_message_tctable_decl.h (limited to 'include/google/protobuf/generated_message_tctable_decl.h') diff --git a/include/google/protobuf/generated_message_tctable_decl.h b/include/google/protobuf/generated_message_tctable_decl.h new file mode 100644 index 0000000000..b1bb1def70 --- /dev/null +++ b/include/google/protobuf/generated_message_tctable_decl.h @@ -0,0 +1,312 @@ +// 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 +#include +#include +#include + +#include +#include + +// Must come last: +#include + +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 + TagType coded_tag() const { + return static_cast(data); + } + uint8_t hasbit_idx() const { return static_cast(data >> 16); } + uint8_t aux_idx() const { return static_cast(data >> 24); } + uint16_t offset() const { return static_cast(data >> 48); } + + // 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(data); } + uint32_t entry_offset() const { return static_cast(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 + +// 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: + TailCallParseFunc target; + // Field data used during parse: + TcFieldData bits; + }; + // There is always at least one table entry. + const FastFieldEntry* fast_entry(size_t idx) const { + return reinterpret_cast(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(reinterpret_cast(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 + 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( + reinterpret_cast(this) + field_entries_offset); + } + + // Auxiliary entries for field types that need extra information. + union FieldAux { + constexpr FieldAux() : message_default(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(msg) {} + 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 MessageLite* message_default; + }; + const FieldAux* field_aux(uint32_t idx) const { + return reinterpret_cast(reinterpret_cast(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(reinterpret_cast(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 +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 + fast_entries; + + // Just big enough to find all the field entries. + std::array field_lookup_table; + // Entries for all fields: + std::array field_entries; + std::array aux_entries; + std::array 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 is valid. +// However, different implementations have different sizeof(std::array). +// Skipping the member makes offset computations portable. +template +struct TcParseTable { + TcParseTableBase header; + std::array + fast_entries; + std::array field_lookup_table; + std::array field_entries; + std::array field_names; +}; + +// Partial specialization: if there are no fields at all, then we can save space +// by skipping the field numbers and entries. +template +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 fast_entries; + std::array field_lookup_table; + std::array field_names; +}; + +static_assert(std::is_standard_layout>::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 + +#endif // GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_DECL_H__ -- cgit v1.2.3