R5Reloaded/r5sdk
1
0
Fork 0
mirror of https://github.com/Mauler125/r5sdk.git synced 2025-02-09 19:15:03 +01:00
Code Issues Packages Projects Releases Wiki Activity
r5sdk/r5dev/thirdparty/protobuf/compiler/cpp/message.cc
Kawe Mazidjatari 188cbf8359 Update protobuf to latest 
Updated to v21.12.
2023-01-26 03:15:10 +01:00

4447 lines
154 KiB
C++
Raw Blame History

// 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.
// Author: kenton@google.com (Kenton Varda)
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <thirdparty/protobuf/compiler/cpp/message.h>
#include <algorithm>
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <unordered_map>
#include <utility>
#include <vector>
#include <thirdparty/protobuf/stubs/common.h>
#include <thirdparty/protobuf/io/coded_stream.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/descriptor.h>
#include <thirdparty/protobuf/generated_message_util.h>
#include <thirdparty/protobuf/map_entry_lite.h>
#include <thirdparty/protobuf/wire_format.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/stubs/stringprintf.h>
#include <thirdparty/protobuf/stubs/substitute.h>
#include <thirdparty/protobuf/compiler/cpp/enum.h>
#include <thirdparty/protobuf/compiler/cpp/extension.h>
#include <thirdparty/protobuf/compiler/cpp/field.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/compiler/cpp/padding_optimizer.h>
#include <thirdparty/protobuf/compiler/cpp/parse_function_generator.h>
#include <thirdparty/protobuf/descriptor.pb.h>
#include <thirdparty/protobuf/stubs/hash.h>
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
namespace google {
namespace protobuf {
namespace compiler {
namespace cpp {
using internal::WireFormat;
using internal::WireFormatLite;
namespace {
static constexpr int kNoHasbit = -1;
// Create an expression that evaluates to
// "for all i, (_has_bits_[i] & masks[i]) == masks[i]"
// masks is allowed to be shorter than _has_bits_, but at least one element of
// masks must be non-zero.
std::string ConditionalToCheckBitmasks(
const std::vector<uint32_t>& masks, bool return_success = true,
StringPiece has_bits_var = "_impl_._has_bits_") {
std::vector<std::string> parts;
for (int i = 0; i < masks.size(); i++) {
if (masks[i] == 0) continue;
std::string m = StrCat("0x", strings::Hex(masks[i], strings::ZERO_PAD_8));
// Each xor evaluates to 0 if the expected bits are present.
parts.push_back(
StrCat("((", has_bits_var, "[", i, "] & ", m, ") ^ ", m, ")"));
}
GOOGLE_CHECK(!parts.empty());
// If we have multiple parts, each expected to be 0, then bitwise-or them.
std::string result =
parts.size() == 1
? parts[0]
: StrCat("(", Join(parts, "\n | "), ")");
return result + (return_success ? " == 0" : " != 0");
}
void PrintPresenceCheck(const Formatter& format, const FieldDescriptor* field,
const std::vector<int>& has_bit_indices,
io::Printer* printer, int* cached_has_word_index) {
if (!field->options().weak()) {
int has_bit_index = has_bit_indices[field->index()];
if (*cached_has_word_index != (has_bit_index / 32)) {
*cached_has_word_index = (has_bit_index / 32);
format("cached_has_bits = $has_bits$[$1$];\n", *cached_has_word_index);
}
const std::string mask =
StrCat(strings::Hex(1u << (has_bit_index % 32), strings::ZERO_PAD_8));
format("if (cached_has_bits & 0x$1$u) {\n", mask);
} else {
format("if (has_$1$()) {\n", FieldName(field));
}
format.Indent();
}
struct FieldOrderingByNumber {
inline bool operator()(const FieldDescriptor* a,
const FieldDescriptor* b) const {
return a->number() < b->number();
}
};
// Sort the fields of the given Descriptor by number into a new[]'d array
// and return it.
std::vector<const FieldDescriptor*> SortFieldsByNumber(
const Descriptor* descriptor) {
std::vector<const FieldDescriptor*> fields(descriptor->field_count());
for (int i = 0; i < descriptor->field_count(); i++) {
fields[i] = descriptor->field(i);
}
std::sort(fields.begin(), fields.end(), FieldOrderingByNumber());
return fields;
}
// Functor for sorting extension ranges by their "start" field number.
struct ExtensionRangeSorter {
bool operator()(const Descriptor::ExtensionRange* left,
const Descriptor::ExtensionRange* right) const {
return left->start < right->start;
}
};
bool IsPOD(const FieldDescriptor* field) {
if (field->is_repeated() || field->is_extension()) return false;
switch (field->cpp_type()) {
case FieldDescriptor::CPPTYPE_ENUM:
case FieldDescriptor::CPPTYPE_INT32:
case FieldDescriptor::CPPTYPE_INT64:
case FieldDescriptor::CPPTYPE_UINT32:
case FieldDescriptor::CPPTYPE_UINT64:
case FieldDescriptor::CPPTYPE_FLOAT:
case FieldDescriptor::CPPTYPE_DOUBLE:
case FieldDescriptor::CPPTYPE_BOOL:
return true;
case FieldDescriptor::CPPTYPE_STRING:
return false;
default:
return false;
}
}
// Helper for the code that emits the SharedCtor() and InternalSwap() methods.
// Anything that is a POD or a "normal" message (represented by a pointer) can
// be manipulated as raw bytes.
bool CanBeManipulatedAsRawBytes(const FieldDescriptor* field,
const Options& options,
MessageSCCAnalyzer* scc_analyzer) {
bool ret = CanInitializeByZeroing(field);
// Non-repeated, non-lazy message fields are simply raw pointers, so we can
// swap them or use memset to initialize these in SharedCtor. We cannot use
// this in Clear, as we need to potentially delete the existing value.
ret =
ret || (!field->is_repeated() && !IsLazy(field, options, scc_analyzer) &&
field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE);
return ret;
}
bool StrContains(const std::string& haystack, const std::string& needle) {
return haystack.find(needle) != std::string::npos;
}
// Finds runs of fields for which `predicate` is true.
// RunMap maps from fields that start each run to the number of fields in that
// run. This is optimized for the common case that there are very few runs in
// a message and that most of the eligible fields appear together.
using RunMap = std::unordered_map<const FieldDescriptor*, size_t>;
RunMap FindRuns(const std::vector<const FieldDescriptor*>& fields,
const std::function<bool(const FieldDescriptor*)>& predicate) {
RunMap runs;
const FieldDescriptor* last_start = nullptr;
for (auto field : fields) {
if (predicate(field)) {
if (last_start == nullptr) {
last_start = field;
}
runs[last_start]++;
} else {
last_start = nullptr;
}
}
return runs;
}
// Emits an if-statement with a condition that evaluates to true if |field| is
// considered non-default (will be sent over the wire), for message types
// without true field presence. Should only be called if
// !HasHasbit(field).
bool EmitFieldNonDefaultCondition(io::Printer* printer,
const std::string& prefix,
const FieldDescriptor* field) {
GOOGLE_CHECK(!HasHasbit(field));
Formatter format(printer);
format.Set("prefix", prefix);
format.Set("name", FieldName(field));
// Merge and serialize semantics: primitive fields are merged/serialized only
// if non-zero (numeric) or non-empty (string).
if (!field->is_repeated() && !field->containing_oneof()) {
if (field->cpp_type() == FieldDescriptor::CPPTYPE_STRING) {
format("if (!$prefix$_internal_$name$().empty()) {\n");
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
// Message fields still have has_$name$() methods.
format("if ($prefix$_internal_has_$name$()) {\n");
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_FLOAT) {
format(
"static_assert(sizeof(uint32_t) == sizeof(float), \"Code assumes "
"uint32_t and float are the same size.\");\n"
"float tmp_$name$ = $prefix$_internal_$name$();\n"
"uint32_t raw_$name$;\n"
"memcpy(&raw_$name$, &tmp_$name$, sizeof(tmp_$name$));\n"
"if (raw_$name$ != 0) {\n");
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_DOUBLE) {
format(
"static_assert(sizeof(uint64_t) == sizeof(double), \"Code assumes "
"uint64_t and double are the same size.\");\n"
"double tmp_$name$ = $prefix$_internal_$name$();\n"
"uint64_t raw_$name$;\n"
"memcpy(&raw_$name$, &tmp_$name$, sizeof(tmp_$name$));\n"
"if (raw_$name$ != 0) {\n");
} else {
format("if ($prefix$_internal_$name$() != 0) {\n");
}
format.Indent();
return true;
} else if (field->real_containing_oneof()) {
format("if (_internal_has_$name$()) {\n");
format.Indent();
return true;
}
return false;
}
// Does the given field have a has_$name$() method?
bool HasHasMethod(const FieldDescriptor* field) {
if (!IsProto3(field->file())) {
// In proto1/proto2, every field has a has_$name$() method.
return true;
}
// For message types without true field presence, only fields with a message
// type or inside an one-of have a has_$name$() method.
return field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE ||
field->has_optional_keyword() || field->real_containing_oneof();
}
// Collects map entry message type information.
void CollectMapInfo(const Options& options, const Descriptor* descriptor,
std::map<std::string, std::string>* variables) {
GOOGLE_CHECK(IsMapEntryMessage(descriptor));
std::map<std::string, std::string>& vars = *variables;
const FieldDescriptor* key = descriptor->map_key();
const FieldDescriptor* val = descriptor->map_value();
vars["key_cpp"] = PrimitiveTypeName(options, key->cpp_type());
switch (val->cpp_type()) {
case FieldDescriptor::CPPTYPE_MESSAGE:
vars["val_cpp"] = FieldMessageTypeName(val, options);
break;
case FieldDescriptor::CPPTYPE_ENUM:
vars["val_cpp"] = ClassName(val->enum_type(), true);
break;
default:
vars["val_cpp"] = PrimitiveTypeName(options, val->cpp_type());
}
vars["key_wire_type"] =
"TYPE_" + ToUpper(DeclaredTypeMethodName(key->type()));
vars["val_wire_type"] =
"TYPE_" + ToUpper(DeclaredTypeMethodName(val->type()));
}
// Does the given field have a private (internal helper only) has_$name$()
// method?
bool HasPrivateHasMethod(const FieldDescriptor* field) {
// Only for oneofs in message types with no field presence. has_$name$(),
// based on the oneof case, is still useful internally for generated code.
return IsProto3(field->file()) && field->real_containing_oneof();
}
// TODO(ckennelly): Cull these exclusions if/when these protos do not have
// their methods overridden by subclasses.
bool ShouldMarkClassAsFinal(const Descriptor* descriptor,
const Options& options) {
return true;
}
// Returns true to make the message serialize in order, decided by the following
// factors in the order of precedence.
// --options().message_set_wire_format() == true
// --the message is in the allowlist (true)
// --GOOGLE_PROTOBUF_SHUFFLE_SERIALIZE is defined (false)
// --a ranage of message names that are allowed to stay in order (true)
bool ShouldSerializeInOrder(const Descriptor* descriptor,
const Options& options) {
return true;
}
bool IsCrossFileMapField(const FieldDescriptor* field) {
if (!field->is_map()) {
return false;
}
const Descriptor* d = field->message_type();
const FieldDescriptor* value = d->FindFieldByNumber(2);
return IsCrossFileMessage(value);
}
bool IsCrossFileMaybeMap(const FieldDescriptor* field) {
if (IsCrossFileMapField(field)) {
return true;
}
return IsCrossFileMessage(field);
}
bool IsRequired(const std::vector<const FieldDescriptor*>& v) {
return v.front()->is_required();
}
bool HasNonSplitOptionalString(const Descriptor* desc, const Options& options) {
for (const auto* field : FieldRange(desc)) {
if (IsString(field, options) && !field->is_repeated() &&
!field->real_containing_oneof() && !ShouldSplit(field, options)) {
return true;
}
}
return false;
}
// Collects neighboring fields based on a given criteria (equivalent predicate).
template <typename Predicate>
std::vector<std::vector<const FieldDescriptor*>> CollectFields(
const std::vector<const FieldDescriptor*>& fields,
const Predicate& equivalent) {
std::vector<std::vector<const FieldDescriptor*>> chunks;
for (auto field : fields) {
if (chunks.empty() || !equivalent(chunks.back().back(), field)) {
chunks.emplace_back();
}
chunks.back().push_back(field);
}
return chunks;
}
// Returns a bit mask based on has_bit index of "fields" that are typically on
// the same chunk. It is used in a group presence check where _has_bits_ is
// masked to tell if any thing in "fields" is present.
uint32_t GenChunkMask(const std::vector<const FieldDescriptor*>& fields,
const std::vector<int>& has_bit_indices) {
GOOGLE_CHECK(!fields.empty());
int first_index_offset = has_bit_indices[fields.front()->index()] / 32;
uint32_t chunk_mask = 0;
for (auto field : fields) {
// "index" defines where in the _has_bits_ the field appears.
int index = has_bit_indices[field->index()];
GOOGLE_CHECK_EQ(first_index_offset, index / 32);
chunk_mask |= static_cast<uint32_t>(1) << (index % 32);
}
GOOGLE_CHECK_NE(0, chunk_mask);
return chunk_mask;
}
// Return the number of bits set in n, a non-negative integer.
static int popcnt(uint32_t n) {
int result = 0;
while (n != 0) {
result += (n & 1);
n = n / 2;
}
return result;
}
// For a run of cold chunks, opens and closes an external if statement that
// checks multiple has_bits words to skip bulk of cold fields.
class ColdChunkSkipper {
public:
ColdChunkSkipper(
const Descriptor* descriptor, const Options& options,
const std::vector<std::vector<const FieldDescriptor*>>& chunks,
const std::vector<int>& has_bit_indices, const double cold_threshold)
: chunks_(chunks),
has_bit_indices_(has_bit_indices),
access_info_map_(options.access_info_map),
cold_threshold_(cold_threshold) {
SetCommonVars(options, &variables_);
SetCommonMessageDataVariables(descriptor, &variables_);
}
// May open an external if check for a batch of cold fields. "from" is the
// prefix to _has_bits_ to allow MergeFrom to use "from._has_bits_".
// Otherwise, it should be "".
void OnStartChunk(int chunk, int cached_has_word_index,
const std::string& from, io::Printer* printer);
bool OnEndChunk(int chunk, io::Printer* printer);
private:
bool IsColdChunk(int chunk);
int HasbitWord(int chunk, int offset) {
return has_bit_indices_[chunks_[chunk][offset]->index()] / 32;
}
const std::vector<std::vector<const FieldDescriptor*>>& chunks_;
const std::vector<int>& has_bit_indices_;
const AccessInfoMap* access_info_map_;
const double cold_threshold_;
std::map<std::string, std::string> variables_;
int limit_chunk_ = -1;
};
// Tuning parameters for ColdChunkSkipper.
const double kColdRatio = 0.005;
bool ColdChunkSkipper::IsColdChunk(int chunk) {
// Mark this variable as used until it is actually used
(void)cold_threshold_;
return false;
}
void ColdChunkSkipper::OnStartChunk(int chunk, int cached_has_word_index,
const std::string& from,
io::Printer* printer) {
Formatter format(printer, variables_);
if (!access_info_map_) {
return;
} else if (chunk < limit_chunk_) {
// We are already inside a run of cold chunks.
return;
} else if (!IsColdChunk(chunk)) {
// We can't start a run of cold chunks.
return;
}
// Find the end of consecutive cold chunks.
limit_chunk_ = chunk;
while (limit_chunk_ < chunks_.size() && IsColdChunk(limit_chunk_)) {
limit_chunk_++;
}
if (limit_chunk_ <= chunk + 1) {
// Require at least two chunks to emit external has_bit checks.
limit_chunk_ = -1;
return;
}
// Emit has_bit check for each has_bit_dword index.
format("if (PROTOBUF_PREDICT_FALSE(");
int first_word = HasbitWord(chunk, 0);
while (chunk < limit_chunk_) {
uint32_t mask = 0;
int this_word = HasbitWord(chunk, 0);
// Generate mask for chunks on the same word.
for (; chunk < limit_chunk_ && HasbitWord(chunk, 0) == this_word; chunk++) {
for (auto field : chunks_[chunk]) {
int hasbit_index = has_bit_indices_[field->index()];
// Fields on a chunk must be in the same word.
GOOGLE_CHECK_EQ(this_word, hasbit_index / 32);
mask |= 1 << (hasbit_index % 32);
}
}
if (this_word != first_word) {
format(" ||\n ");
}
format.Set("mask", strings::Hex(mask, strings::ZERO_PAD_8));
if (this_word == cached_has_word_index) {
format("(cached_has_bits & 0x$mask$u) != 0");
} else {
format("($1$_impl_._has_bits_[$2$] & 0x$mask$u) != 0", from, this_word);
}
}
format(")) {\n");
format.Indent();
}
bool ColdChunkSkipper::OnEndChunk(int chunk, io::Printer* printer) {
Formatter format(printer, variables_);
if (chunk != limit_chunk_ - 1) {
return false;
}
format.Outdent();
format("}\n");
return true;
}
void MaySetAnnotationVariable(const Options& options,
StringPiece annotation_name,
StringPiece injector_template_prefix,
StringPiece injector_template_suffix,
std::map<std::string, std::string>* variables) {
if (options.field_listener_options.forbidden_field_listener_events.count(
std::string(annotation_name)))
return;
(*variables)[StrCat("annotate_", annotation_name)] = strings::Substitute(
StrCat(injector_template_prefix, injector_template_suffix),
(*variables)["classtype"]);
}
void GenerateExtensionAnnotations(
const Descriptor* descriptor, const Options& options,
std::map<std::string, std::string>* variables) {
const std::map<std::string, std::string> accessor_annotations_to_hooks = {
{"annotate_extension_has", "OnHasExtension"},
{"annotate_extension_clear", "OnClearExtension"},
{"annotate_extension_repeated_size", "OnExtensionSize"},
{"annotate_extension_get", "OnGetExtension"},
{"annotate_extension_mutable", "OnMutableExtension"},
{"annotate_extension_set", "OnSetExtension"},
{"annotate_extension_release", "OnReleaseExtension"},
{"annotate_repeated_extension_get", "OnGetExtension"},
{"annotate_repeated_extension_mutable", "OnMutableExtension"},
{"annotate_repeated_extension_set", "OnSetExtension"},
{"annotate_repeated_extension_add", "OnAddExtension"},
{"annotate_repeated_extension_add_mutable", "OnAddMutableExtension"},
{"annotate_repeated_extension_list", "OnListExtension"},
{"annotate_repeated_extension_list_mutable", "OnMutableListExtension"},
};
for (const auto& annotation : accessor_annotations_to_hooks) {
(*variables)[annotation.first] = "";
}
if (!HasTracker(descriptor, options)) {
return;
}
StringPiece tracker = (*variables)["tracker"];
StringPiece extensions = (*variables)["extensions"];
for (const auto& annotation : accessor_annotations_to_hooks) {
const std::string& annotation_name = annotation.first;
const std::string& listener_call = annotation.second;
if (!StrContains(annotation_name, "repeated") &&
!StrContains(annotation_name, "size") &&
!StrContains(annotation_name, "clear")) {
// Primitive fields accessors.
// "Has" is here as users calling "has" on a repeated field is a mistake.
(*variables)[annotation_name] = StrCat(
" ", tracker, ".", listener_call,
"(this, id.number(), _proto_TypeTraits::GetPtr(id.number(), ",
extensions, ", id.default_value_ref()));");
} else if (StrContains(annotation_name, "repeated") &&
!StrContains(annotation_name, "list") &&
!StrContains(annotation_name, "size")) {
// Repeated index accessors.
std::string str_index = "index";
if (StrContains(annotation_name, "add")) {
str_index = StrCat(extensions, ".ExtensionSize(id.number()) - 1");
}
(*variables)[annotation_name] =
StrCat(" ", tracker, ".", listener_call,
"(this, id.number(), "
"_proto_TypeTraits::GetPtr(id.number(), ",
extensions, ", ", str_index, "));");
} else if (StrContains(annotation_name, "list") ||
StrContains(annotation_name, "size")) {
// Repeated full accessors.
(*variables)[annotation_name] = StrCat(
" ", tracker, ".", listener_call,
"(this, id.number(), _proto_TypeTraits::GetRepeatedPtr(id.number(), ",
extensions, "));");
} else {
// Generic accessors such as "clear".
// TODO(b/190614678): Generalize clear from both repeated and non repeated
// calls, currently their underlying memory interfaces are very different.
// Or think of removing clear callback as no usages are needed and no
// memory exist after calling clear().
}
}
}
} // anonymous namespace
// ===================================================================
MessageGenerator::MessageGenerator(
const Descriptor* descriptor,
const std::map<std::string, std::string>& vars, int index_in_file_messages,
const Options& options, MessageSCCAnalyzer* scc_analyzer)
: descriptor_(descriptor),
index_in_file_messages_(index_in_file_messages),
classname_(ClassName(descriptor, false)),
options_(options),
field_generators_(descriptor, options, scc_analyzer),
max_has_bit_index_(0),
max_inlined_string_index_(0),
num_weak_fields_(0),
scc_analyzer_(scc_analyzer),
variables_(vars) {
if (!message_layout_helper_) {
message_layout_helper_.reset(new PaddingOptimizer());
}
SetCommonMessageDataVariables(descriptor, &variables_);
// Variables that apply to this class
variables_["classname"] = classname_;
variables_["classtype"] = QualifiedClassName(descriptor_, options);
variables_["full_name"] = descriptor_->full_name();
variables_["superclass"] = SuperClassName(descriptor_, options_);
variables_["annotate_serialize"] = "";
variables_["annotate_deserialize"] = "";
variables_["annotate_reflection"] = "";
variables_["annotate_bytesize"] = "";
variables_["annotate_mergefrom"] = "";
if (HasTracker(descriptor_, options_)) {
const std::string injector_template =
StrCat(" ", variables_["tracker"], ".");
MaySetAnnotationVariable(options, "serialize", injector_template,
"OnSerialize(this);\n", &variables_);
MaySetAnnotationVariable(options, "deserialize", injector_template,
"OnDeserialize(this);\n", &variables_);
// TODO(danilak): Ideally annotate_reflection should not exist and we need
// to annotate all reflective calls on our own, however, as this is a cause
// for side effects, i.e. reading values dynamically, we want the users know
// that dynamic access can happen.
MaySetAnnotationVariable(options, "reflection", injector_template,
"OnGetMetadata();\n", &variables_);
MaySetAnnotationVariable(options, "bytesize", injector_template,
"OnByteSize(this);\n", &variables_);
MaySetAnnotationVariable(options, "mergefrom", injector_template,
"OnMergeFrom(_this, &from);\n", &variables_);
}
GenerateExtensionAnnotations(descriptor_, options_, &variables_);
SetUnknownFieldsVariable(descriptor_, options_, &variables_);
// Compute optimized field order to be used for layout and initialization
// purposes.
for (auto field : FieldRange(descriptor_)) {
if (IsFieldStripped(field, options_)) {
continue;
}
if (IsWeak(field, options_)) {
num_weak_fields_++;
} else if (!field->real_containing_oneof()) {
optimized_order_.push_back(field);
}
}
message_layout_helper_->OptimizeLayout(&optimized_order_, options_,
scc_analyzer_);
// This message has hasbits iff one or more fields need one.
for (auto field : optimized_order_) {
if (HasHasbit(field)) {
if (has_bit_indices_.empty()) {
has_bit_indices_.resize(descriptor_->field_count(), kNoHasbit);
}
has_bit_indices_[field->index()] = max_has_bit_index_++;
}
if (IsStringInlined(field, options_)) {
if (inlined_string_indices_.empty()) {
inlined_string_indices_.resize(descriptor_->field_count(), kNoHasbit);
// The bitset[0] is for arena dtor tracking. Donating states start from
// bitset[1];
max_inlined_string_index_++;
}
inlined_string_indices_[field->index()] = max_inlined_string_index_++;
}
}
if (!has_bit_indices_.empty()) {
field_generators_.SetHasBitIndices(has_bit_indices_);
}
if (!inlined_string_indices_.empty()) {
field_generators_.SetInlinedStringIndices(inlined_string_indices_);
}
num_required_fields_ = 0;
for (int i = 0; i < descriptor->field_count(); i++) {
if (descriptor->field(i)->is_required()) {
++num_required_fields_;
}
}
parse_function_generator_.reset(new ParseFunctionGenerator(
descriptor_, max_has_bit_index_, has_bit_indices_,
inlined_string_indices_, options_, scc_analyzer_, variables_));
}
MessageGenerator::~MessageGenerator() = default;
size_t MessageGenerator::HasBitsSize() const {
return (max_has_bit_index_ + 31) / 32;
}
size_t MessageGenerator::InlinedStringDonatedSize() const {
return (max_inlined_string_index_ + 31) / 32;
}
int MessageGenerator::HasBitIndex(const FieldDescriptor* field) const {
return has_bit_indices_.empty() ? kNoHasbit
: has_bit_indices_[field->index()];
}
int MessageGenerator::HasByteIndex(const FieldDescriptor* field) const {
int hasbit = HasBitIndex(field);
return hasbit == kNoHasbit ? kNoHasbit : hasbit / 8;
}
int MessageGenerator::HasWordIndex(const FieldDescriptor* field) const {
int hasbit = HasBitIndex(field);
return hasbit == kNoHasbit ? kNoHasbit : hasbit / 32;
}
void MessageGenerator::AddGenerators(
std::vector<std::unique_ptr<EnumGenerator>>* enum_generators,
std::vector<std::unique_ptr<ExtensionGenerator>>* extension_generators) {
for (int i = 0; i < descriptor_->enum_type_count(); i++) {
enum_generators->emplace_back(
new EnumGenerator(descriptor_->enum_type(i), variables_, options_));
enum_generators_.push_back(enum_generators->back().get());
}
for (int i = 0; i < descriptor_->extension_count(); i++) {
extension_generators->emplace_back(new ExtensionGenerator(
descriptor_->extension(i), options_, scc_analyzer_));
extension_generators_.push_back(extension_generators->back().get());
}
}
void MessageGenerator::GenerateFieldAccessorDeclarations(io::Printer* printer) {
Formatter format(printer, variables_);
// optimized_fields_ does not contain fields where
// field->real_containing_oneof()
// so we need to iterate over those as well.
//
// We place the non-oneof fields in optimized_order_, as that controls the
// order of the _has_bits_ entries and we want GDB's pretty printers to be
// able to infer these indices from the k[FIELDNAME]FieldNumber order.
std::vector<const FieldDescriptor*> ordered_fields;
ordered_fields.reserve(descriptor_->field_count());
ordered_fields.insert(ordered_fields.begin(), optimized_order_.begin(),
optimized_order_.end());
for (auto field : FieldRange(descriptor_)) {
if (!field->real_containing_oneof() && !field->options().weak() &&
!IsFieldStripped(field, options_)) {
continue;
}
ordered_fields.push_back(field);
}
if (!ordered_fields.empty()) {
format("enum : int {\n");
for (auto field : ordered_fields) {
Formatter::SaveState save(&format);
std::map<std::string, std::string> vars;
SetCommonFieldVariables(field, &vars, options_);
format.AddMap(vars);
format(" ${1$$2$$}$ = $number$,\n", field, FieldConstantName(field));
}
format("};\n");
}
for (auto field : ordered_fields) {
PrintFieldComment(format, field);
Formatter::SaveState save(&format);
std::map<std::string, std::string> vars;
SetCommonFieldVariables(field, &vars, options_);
format.AddMap(vars);
if (field->is_repeated()) {
format("$deprecated_attr$int ${1$$name$_size$}$() const$2$\n", field,
!IsFieldStripped(field, options_) ? ";" : " {__builtin_trap();}");
if (!IsFieldStripped(field, options_)) {
format(
"private:\n"
"int ${1$_internal_$name$_size$}$() const;\n"
"public:\n",
field);
}
} else if (HasHasMethod(field)) {
format("$deprecated_attr$bool ${1$has_$name$$}$() const$2$\n", field,
!IsFieldStripped(field, options_) ? ";" : " {__builtin_trap();}");
if (!IsFieldStripped(field, options_)) {
format(
"private:\n"
"bool _internal_has_$name$() const;\n"
"public:\n");
}
} else if (HasPrivateHasMethod(field)) {
if (!IsFieldStripped(field, options_)) {
format(
"private:\n"
"bool ${1$_internal_has_$name$$}$() const;\n"
"public:\n",
field);
}
}
format("$deprecated_attr$void ${1$clear_$name$$}$()$2$\n", field,
!IsFieldStripped(field, options_) ? ";" : "{__builtin_trap();}");
// Generate type-specific accessor declarations.
field_generators_.get(field).GenerateAccessorDeclarations(printer);
format("\n");
}
if (descriptor_->extension_range_count() > 0) {
// Generate accessors for extensions.
// We use "_proto_TypeTraits" as a type name below because "TypeTraits"
// causes problems if the class has a nested message or enum type with that
// name and "_TypeTraits" is technically reserved for the C++ library since
// it starts with an underscore followed by a capital letter.
//
// For similar reason, we use "_field_type" and "_is_packed" as parameter
// names below, so that "field_type" and "is_packed" can be used as field
// names.
format(R"(
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline bool HasExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id) const {
$annotate_extension_has$
return $extensions$.Has(id.number());
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline void ClearExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id) {
$extensions$.ClearExtension(id.number());
$annotate_extension_clear$
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline int ExtensionSize(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id) const {
$annotate_extension_repeated_size$
return $extensions$.ExtensionSize(id.number());
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id) const {
$annotate_extension_get$
return _proto_TypeTraits::Get(id.number(), $extensions$,
id.default_value());
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id) {
$annotate_extension_mutable$
return _proto_TypeTraits::Mutable(id.number(), _field_type,
&$extensions$);
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline void SetExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id,
typename _proto_TypeTraits::Singular::ConstType value) {
_proto_TypeTraits::Set(id.number(), _field_type, value, &$extensions$);
$annotate_extension_set$
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline void SetAllocatedExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id,
typename _proto_TypeTraits::Singular::MutableType value) {
_proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
&$extensions$);
$annotate_extension_set$
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline void UnsafeArenaSetAllocatedExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id,
typename _proto_TypeTraits::Singular::MutableType value) {
_proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
value, &$extensions$);
$annotate_extension_set$
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
PROTOBUF_NODISCARD inline
typename _proto_TypeTraits::Singular::MutableType
ReleaseExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id) {
$annotate_extension_release$
return _proto_TypeTraits::Release(id.number(), _field_type,
&$extensions$);
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline typename _proto_TypeTraits::Singular::MutableType
UnsafeArenaReleaseExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id) {
$annotate_extension_release$
return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
&$extensions$);
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id,
int index) const {
$annotate_repeated_extension_get$
return _proto_TypeTraits::Get(id.number(), $extensions$, index);
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id,
int index) {
$annotate_repeated_extension_mutable$
return _proto_TypeTraits::Mutable(id.number(), index, &$extensions$);
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline void SetExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id,
int index, typename _proto_TypeTraits::Repeated::ConstType value) {
_proto_TypeTraits::Set(id.number(), index, value, &$extensions$);
$annotate_repeated_extension_set$
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id) {
typename _proto_TypeTraits::Repeated::MutableType to_add =
_proto_TypeTraits::Add(id.number(), _field_type, &$extensions$);
$annotate_repeated_extension_add_mutable$
return to_add;
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline void AddExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id,
typename _proto_TypeTraits::Repeated::ConstType value) {
_proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
&$extensions$);
$annotate_repeated_extension_add$
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
GetRepeatedExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id) const {
$annotate_repeated_extension_list$
return _proto_TypeTraits::GetRepeated(id.number(), $extensions$);
}
template <typename _proto_TypeTraits,
::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
bool _is_packed>
inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
MutableRepeatedExtension(
const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
$classname$, _proto_TypeTraits, _field_type, _is_packed>& id) {
$annotate_repeated_extension_list_mutable$
return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
_is_packed, &$extensions$);
}
)");
// Generate MessageSet specific APIs for proto2 MessageSet.
// For testing purposes we don't check for bridge.MessageSet, so
// we don't use IsProto2MessageSet
if (descriptor_->options().message_set_wire_format() &&
!options_.opensource_runtime && !options_.lite_implicit_weak_fields) {
// Special-case MessageSet
format("GOOGLE_PROTOBUF_EXTENSION_MESSAGE_SET_ACCESSORS($classname$)\n");
}
}
for (auto oneof : OneOfRange(descriptor_)) {
Formatter::SaveState saver(&format);
format.Set("oneof_name", oneof->name());
format.Set("camel_oneof_name", UnderscoresToCamelCase(oneof->name(), true));
format(
"void ${1$clear_$oneof_name$$}$();\n"
"$camel_oneof_name$Case $oneof_name$_case() const;\n",
oneof);
}
}
void MessageGenerator::GenerateSingularFieldHasBits(
const FieldDescriptor* field, Formatter format) {
if (IsFieldStripped(field, options_)) {
format(
"inline bool $classname$::has_$name$() const { "
"__builtin_trap(); }\n");
return;
}
if (field->options().weak()) {
format(
"inline bool $classname$::has_$name$() const {\n"
"$annotate_has$"
" return $weak_field_map$.Has($number$);\n"
"}\n");
return;
}
if (HasHasbit(field)) {
int has_bit_index = HasBitIndex(field);
GOOGLE_CHECK_NE(has_bit_index, kNoHasbit);
format.Set("has_array_index", has_bit_index / 32);
format.Set("has_mask",
strings::Hex(1u << (has_bit_index % 32), strings::ZERO_PAD_8));
format(
"inline bool $classname$::_internal_has_$name$() const {\n"
" bool value = "
"($has_bits$[$has_array_index$] & 0x$has_mask$u) != 0;\n");
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
!IsLazy(field, options_, scc_analyzer_)) {
// We maintain the invariant that for a submessage x, has_x() returning
// true implies that x_ is not null. By giving this information to the
// compiler, we allow it to eliminate unnecessary null checks later on.
format(" PROTOBUF_ASSUME(!value || $field$ != nullptr);\n");
}
format(
" return value;\n"
"}\n"
"inline bool $classname$::has_$name$() const {\n"
"$annotate_has$"
" return _internal_has_$name$();\n"
"}\n");
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
// Message fields have a has_$name$() method.
if (IsLazy(field, options_, scc_analyzer_)) {
format(
"inline bool $classname$::_internal_has_$name$() const {\n"
" return !$field$.IsCleared();\n"
"}\n");
} else {
format(
"inline bool $classname$::_internal_has_$name$() const {\n"
" return this != internal_default_instance() "
"&& $field$ != nullptr;\n"
"}\n");
}
format(
"inline bool $classname$::has_$name$() const {\n"
"$annotate_has$"
" return _internal_has_$name$();\n"
"}\n");
}
}
void MessageGenerator::GenerateOneofHasBits(io::Printer* printer) {
Formatter format(printer, variables_);
for (auto oneof : OneOfRange(descriptor_)) {
format.Set("oneof_name", oneof->name());
format.Set("oneof_index", oneof->index());
format.Set("cap_oneof_name", ToUpper(oneof->name()));
format(
"inline bool $classname$::has_$oneof_name$() const {\n"
" return $oneof_name$_case() != $cap_oneof_name$_NOT_SET;\n"
"}\n"
"inline void $classname$::clear_has_$oneof_name$() {\n"
" $oneof_case$[$oneof_index$] = $cap_oneof_name$_NOT_SET;\n"
"}\n");
}
}
void MessageGenerator::GenerateOneofMemberHasBits(const FieldDescriptor* field,
const Formatter& format) {
if (IsFieldStripped(field, options_)) {
if (HasHasMethod(field)) {
format(
"inline bool $classname$::has_$name$() const { "
"__builtin_trap(); }\n");
}
format(
"inline void $classname$::set_has_$name$() { __builtin_trap(); "
"}\n");
return;
}
// Singular field in a oneof
// N.B.: Without field presence, we do not use has-bits or generate
// has_$name$() methods, but oneofs still have set_has_$name$().
// Oneofs also have has_$name$() but only as a private helper
// method, so that generated code is slightly cleaner (vs. comparing
// _oneof_case_[index] against a constant everywhere).
//
// If has_$name$() is private, there is no need to add an internal accessor.
// Only annotate public accessors.
if (HasHasMethod(field)) {
format(
"inline bool $classname$::_internal_has_$name$() const {\n"
" return $oneof_name$_case() == k$field_name$;\n"
"}\n"
"inline bool $classname$::has_$name$() const {\n"
"$annotate_has$"
" return _internal_has_$name$();\n"
"}\n");
} else if (HasPrivateHasMethod(field)) {
format(
"inline bool $classname$::_internal_has_$name$() const {\n"
" return $oneof_name$_case() == k$field_name$;\n"
"}\n");
}
// set_has_$name$() for oneof fields is always private; hence should not be
// annotated.
format(
"inline void $classname$::set_has_$name$() {\n"
" $oneof_case$[$oneof_index$] = k$field_name$;\n"
"}\n");
}
void MessageGenerator::GenerateFieldClear(const FieldDescriptor* field,
bool is_inline, Formatter format) {
if (IsFieldStripped(field, options_)) {
format("void $classname$::clear_$name$() { __builtin_trap(); }\n");
return;
}
// Generate clear_$name$().
if (is_inline) {
format("inline ");
}
format("void $classname$::clear_$name$() {\n");
format.Indent();
if (field->real_containing_oneof()) {
// Clear this field only if it is the active field in this oneof,
// otherwise ignore
format("if (_internal_has_$name$()) {\n");
format.Indent();
field_generators_.get(field).GenerateClearingCode(format.printer());
format("clear_has_$oneof_name$();\n");
format.Outdent();
format("}\n");
} else {
if (ShouldSplit(field, options_)) {
format("if (IsSplitMessageDefault()) return;\n");
}
field_generators_.get(field).GenerateClearingCode(format.printer());
if (HasHasbit(field)) {
int has_bit_index = HasBitIndex(field);
format.Set("has_array_index", has_bit_index / 32);
format.Set("has_mask",
strings::Hex(1u << (has_bit_index % 32), strings::ZERO_PAD_8));
format("$has_bits$[$has_array_index$] &= ~0x$has_mask$u;\n");
}
}
format("$annotate_clear$");
format.Outdent();
format("}\n");
}
void MessageGenerator::GenerateFieldAccessorDefinitions(io::Printer* printer) {
Formatter format(printer, variables_);
format("// $classname$\n\n");
for (auto field : FieldRange(descriptor_)) {
PrintFieldComment(format, field);
if (IsFieldStripped(field, options_)) {
continue;
}
std::map<std::string, std::string> vars;
SetCommonFieldVariables(field, &vars, options_);
Formatter::SaveState saver(&format);
format.AddMap(vars);
// Generate has_$name$() or $name$_size().
if (field->is_repeated()) {
if (IsFieldStripped(field, options_)) {
format(
"inline int $classname$::$name$_size() const { "
"__builtin_trap(); }\n");
} else {
format(
"inline int $classname$::_internal_$name$_size() const {\n"
" return $field$$1$.size();\n"
"}\n"
"inline int $classname$::$name$_size() const {\n"
"$annotate_size$"
" return _internal_$name$_size();\n"
"}\n",
IsImplicitWeakField(field, options_, scc_analyzer_) &&
field->message_type()
? ".weak"
: "");
}
} else if (field->real_containing_oneof()) {
format.Set("field_name", UnderscoresToCamelCase(field->name(), true));
format.Set("oneof_name", field->containing_oneof()->name());
format.Set("oneof_index",
StrCat(field->containing_oneof()->index()));
GenerateOneofMemberHasBits(field, format);
} else {
// Singular field.
GenerateSingularFieldHasBits(field, format);
}
if (!IsCrossFileMaybeMap(field)) {
GenerateFieldClear(field, true, format);
}
// Generate type-specific accessors.
if (!IsFieldStripped(field, options_)) {
field_generators_.get(field).GenerateInlineAccessorDefinitions(printer);
}
format("\n");
}
// Generate has_$name$() and clear_has_$name$() functions for oneofs.
GenerateOneofHasBits(printer);
}
void MessageGenerator::GenerateClassDefinition(io::Printer* printer) {
Formatter format(printer, variables_);
format.Set("class_final",
ShouldMarkClassAsFinal(descriptor_, options_) ? "final" : "");
if (IsMapEntryMessage(descriptor_)) {
std::map<std::string, std::string> vars;
CollectMapInfo(options_, descriptor_, &vars);
vars["lite"] =
HasDescriptorMethods(descriptor_->file(), options_) ? "" : "Lite";
format.AddMap(vars);
format(
"class $classname$ : public "
"::$proto_ns$::internal::MapEntry$lite$<$classname$, \n"
" $key_cpp$, $val_cpp$,\n"
" ::$proto_ns$::internal::WireFormatLite::$key_wire_type$,\n"
" ::$proto_ns$::internal::WireFormatLite::$val_wire_type$> {\n"
"public:\n"
" typedef ::$proto_ns$::internal::MapEntry$lite$<$classname$, \n"
" $key_cpp$, $val_cpp$,\n"
" ::$proto_ns$::internal::WireFormatLite::$key_wire_type$,\n"
" ::$proto_ns$::internal::WireFormatLite::$val_wire_type$> "
"SuperType;\n"
" $classname$();\n"
" explicit PROTOBUF_CONSTEXPR $classname$(\n"
" ::$proto_ns$::internal::ConstantInitialized);\n"
" explicit $classname$(::$proto_ns$::Arena* arena);\n"
" void MergeFrom(const $classname$& other);\n"
" static const $classname$* internal_default_instance() { return "
"reinterpret_cast<const "
"$classname$*>(&_$classname$_default_instance_); }\n");
auto utf8_check = GetUtf8CheckMode(descriptor_->field(0), options_);
if (descriptor_->field(0)->type() == FieldDescriptor::TYPE_STRING &&
utf8_check != Utf8CheckMode::kNone) {
if (utf8_check == Utf8CheckMode::kStrict) {
format(
" static bool ValidateKey(std::string* s) {\n"
" return ::$proto_ns$::internal::WireFormatLite::"
"VerifyUtf8String(s->data(), static_cast<int>(s->size()), "
"::$proto_ns$::internal::WireFormatLite::PARSE, \"$1$\");\n"
" }\n",
descriptor_->field(0)->full_name());
} else {
GOOGLE_CHECK(utf8_check == Utf8CheckMode::kVerify);
format(
" static bool ValidateKey(std::string* s) {\n"
"#ifndef NDEBUG\n"
" ::$proto_ns$::internal::WireFormatLite::VerifyUtf8String(\n"
" s->data(), static_cast<int>(s->size()), "
"::$proto_ns$::internal::"
"WireFormatLite::PARSE, \"$1$\");\n"
"#else\n"
" (void) s;\n"
"#endif\n"
" return true;\n"
" }\n",
descriptor_->field(0)->full_name());
}
} else {
format(" static bool ValidateKey(void*) { return true; }\n");
}
if (descriptor_->field(1)->type() == FieldDescriptor::TYPE_STRING &&
utf8_check != Utf8CheckMode::kNone) {
if (utf8_check == Utf8CheckMode::kStrict) {
format(
" static bool ValidateValue(std::string* s) {\n"
" return ::$proto_ns$::internal::WireFormatLite::"
"VerifyUtf8String(s->data(), static_cast<int>(s->size()), "
"::$proto_ns$::internal::WireFormatLite::PARSE, \"$1$\");\n"
" }\n",
descriptor_->field(1)->full_name());
} else {
GOOGLE_CHECK(utf8_check == Utf8CheckMode::kVerify);
format(
" static bool ValidateValue(std::string* s) {\n"
"#ifndef NDEBUG\n"
" ::$proto_ns$::internal::WireFormatLite::VerifyUtf8String(\n"
" s->data(), static_cast<int>(s->size()), "
"::$proto_ns$::internal::"
"WireFormatLite::PARSE, \"$1$\");\n"
"#else\n"
" (void) s;\n"
"#endif\n"
" return true;\n"
" }\n",
descriptor_->field(1)->full_name());
}
} else {
format(" static bool ValidateValue(void*) { return true; }\n");
}
if (HasDescriptorMethods(descriptor_->file(), options_)) {
format(
" using ::$proto_ns$::Message::MergeFrom;\n"
""
" ::$proto_ns$::Metadata GetMetadata() const final;\n");
}
format(
" friend struct ::$tablename$;\n"
"};\n");
return;
}
format(
"class $dllexport_decl $${1$$classname$$}$$ class_final$ :\n"
" public $superclass$ /* @@protoc_insertion_point("
"class_definition:$full_name$) */ {\n",
descriptor_);
format(" public:\n");
format.Indent();
if (EnableMessageOwnedArena(descriptor_, options_)) {
format(
"inline $classname$() : $classname$("
"::$proto_ns$::Arena::InternalCreateMessageOwnedArena(), true) {}\n");
} else if (EnableMessageOwnedArenaTrial(descriptor_, options_)) {
format(
"inline $classname$() : $classname$(InMoaTrial() ? "
"::$proto_ns$::Arena::InternalCreateMessageOwnedArena() : nullptr, "
"InMoaTrial()) {}\n");
} else {
format("inline $classname$() : $classname$(nullptr) {}\n");
}
if (!HasSimpleBaseClass(descriptor_, options_)) {
format("~$classname$() override;\n");
}
format(
"explicit PROTOBUF_CONSTEXPR "
"$classname$(::$proto_ns$::internal::ConstantInitialized);\n"
"\n"
"$classname$(const $classname$& from);\n"
"$classname$($classname$&& from) noexcept\n"
" : $classname$() {\n"
" *this = ::std::move(from);\n"
"}\n"
"\n"
"inline $classname$& operator=(const $classname$& from) {\n"
" CopyFrom(from);\n"
" return *this;\n"
"}\n"
"inline $classname$& operator=($classname$&& from) noexcept {\n"
" if (this == &from) return *this;\n"
" if (GetOwningArena() == from.GetOwningArena()\n"
"#ifdef PROTOBUF_FORCE_COPY_IN_MOVE\n"
" && GetOwningArena() != nullptr\n"
"#endif // !PROTOBUF_FORCE_COPY_IN_MOVE\n"
" ) {\n"
" InternalSwap(&from);\n"
" } else {\n"
" CopyFrom(from);\n"
" }\n"
" return *this;\n"
"}\n"
"\n");
if (PublicUnknownFieldsAccessors(descriptor_)) {
format(
"inline const $unknown_fields_type$& unknown_fields() const {\n"
" return $unknown_fields$;\n"
"}\n"
"inline $unknown_fields_type$* mutable_unknown_fields() {\n"
" return $mutable_unknown_fields$;\n"
"}\n"
"\n");
}
// Only generate this member if it's not disabled.
if (HasDescriptorMethods(descriptor_->file(), options_) &&
!descriptor_->options().no_standard_descriptor_accessor()) {
format(
"static const ::$proto_ns$::Descriptor* descriptor() {\n"
" return GetDescriptor();\n"
"}\n");
}
if (HasDescriptorMethods(descriptor_->file(), options_)) {
// These shadow non-static methods of the same names in Message. We
// redefine them here because calls directly on the generated class can be
// statically analyzed -- we know what descriptor types are being requested.
// It also avoids a vtable dispatch.
//
// We would eventually like to eliminate the methods in Message, and having
// this separate also lets us track calls to the base class methods
// separately.
format(
"static const ::$proto_ns$::Descriptor* GetDescriptor() {\n"
" return default_instance().GetMetadata().descriptor;\n"
"}\n"
"static const ::$proto_ns$::Reflection* GetReflection() {\n"
" return default_instance().GetMetadata().reflection;\n"
"}\n");
}
format(
"static const $classname$& default_instance() {\n"
" return *internal_default_instance();\n"
"}\n");
// Generate enum values for every field in oneofs. One list is generated for
// each oneof with an additional *_NOT_SET value.
for (auto oneof : OneOfRange(descriptor_)) {
format("enum $1$Case {\n", UnderscoresToCamelCase(oneof->name(), true));
format.Indent();
for (auto field : FieldRange(oneof)) {
format("$1$ = $2$,\n", OneofCaseConstantName(field), // 1
field->number()); // 2
}
format("$1$_NOT_SET = 0,\n", ToUpper(oneof->name()));
format.Outdent();
format(
"};\n"
"\n");
}
// TODO(gerbens) make this private, while still granting other protos access.
format(
"static inline const $classname$* internal_default_instance() {\n"
" return reinterpret_cast<const $classname$*>(\n"
" &_$classname$_default_instance_);\n"
"}\n"
"static constexpr int kIndexInFileMessages =\n"
" $1$;\n"
"\n",
index_in_file_messages_);
if (IsAnyMessage(descriptor_, options_)) {
format(
"// implements Any -----------------------------------------------\n"
"\n");
if (HasDescriptorMethods(descriptor_->file(), options_)) {
format(
"bool PackFrom(const ::$proto_ns$::Message& message) {\n"
" $DCHK$_NE(&message, this);\n"
" return $any_metadata$.PackFrom(GetArena(), message);\n"
"}\n"
"bool PackFrom(const ::$proto_ns$::Message& message,\n"
" ::PROTOBUF_NAMESPACE_ID::ConstStringParam "
"type_url_prefix) {\n"
" $DCHK$_NE(&message, this);\n"
" return $any_metadata$.PackFrom(GetArena(), message, "
"type_url_prefix);\n"
"}\n"
"bool UnpackTo(::$proto_ns$::Message* message) const {\n"
" return $any_metadata$.UnpackTo(message);\n"
"}\n"
"static bool GetAnyFieldDescriptors(\n"
" const ::$proto_ns$::Message& message,\n"
" const ::$proto_ns$::FieldDescriptor** type_url_field,\n"
" const ::$proto_ns$::FieldDescriptor** value_field);\n"
"template <typename T, class = typename std::enable_if<"
"!std::is_convertible<T, const ::$proto_ns$::Message&>"
"::value>::type>\n"
"bool PackFrom(const T& message) {\n"
" return $any_metadata$.PackFrom<T>(GetArena(), message);\n"
"}\n"
"template <typename T, class = typename std::enable_if<"
"!std::is_convertible<T, const ::$proto_ns$::Message&>"
"::value>::type>\n"
"bool PackFrom(const T& message,\n"
" ::PROTOBUF_NAMESPACE_ID::ConstStringParam "
"type_url_prefix) {\n"
" return $any_metadata$.PackFrom<T>(GetArena(), message, "
"type_url_prefix);"
"}\n"
"template <typename T, class = typename std::enable_if<"
"!std::is_convertible<T, const ::$proto_ns$::Message&>"
"::value>::type>\n"
"bool UnpackTo(T* message) const {\n"
" return $any_metadata$.UnpackTo<T>(message);\n"
"}\n");
} else {
format(
"template <typename T>\n"
"bool PackFrom(const T& message) {\n"
" return $any_metadata$.PackFrom(GetArena(), message);\n"
"}\n"
"template <typename T>\n"
"bool PackFrom(const T& message,\n"
" ::PROTOBUF_NAMESPACE_ID::ConstStringParam "
"type_url_prefix) {\n"
" return $any_metadata$.PackFrom(GetArena(), message, "
"type_url_prefix);\n"
"}\n"
"template <typename T>\n"
"bool UnpackTo(T* message) const {\n"
" return $any_metadata$.UnpackTo(message);\n"
"}\n");
}
format(
"template<typename T> bool Is() const {\n"
" return $any_metadata$.Is<T>();\n"
"}\n"
"static bool ParseAnyTypeUrl(::PROTOBUF_NAMESPACE_ID::ConstStringParam "
"type_url,\n"
" std::string* full_type_name);\n");
}
format(
"friend void swap($classname$& a, $classname$& b) {\n"
" a.Swap(&b);\n"
"}\n"
"inline void Swap($classname$* other) {\n"
" if (other == this) return;\n"
"#ifdef PROTOBUF_FORCE_COPY_IN_SWAP\n"
" if (GetOwningArena() != nullptr &&\n"
" GetOwningArena() == other->GetOwningArena()) {\n "
"#else // PROTOBUF_FORCE_COPY_IN_SWAP\n"
" if (GetOwningArena() == other->GetOwningArena()) {\n"
"#endif // !PROTOBUF_FORCE_COPY_IN_SWAP\n"
" InternalSwap(other);\n"
" } else {\n"
" ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);\n"
" }\n"
"}\n"
"void UnsafeArenaSwap($classname$* other) {\n"
" if (other == this) return;\n"
" $DCHK$(GetOwningArena() == other->GetOwningArena());\n"
" InternalSwap(other);\n"
"}\n");
format(
"\n"
"// implements Message ----------------------------------------------\n"
"\n"
"$classname$* New(::$proto_ns$::Arena* arena = nullptr) const final {\n"
" return CreateMaybeMessage<$classname$>(arena);\n"
"}\n");
// For instances that derive from Message (rather than MessageLite), some
// methods are virtual and should be marked as final.
format.Set("full_final", HasDescriptorMethods(descriptor_->file(), options_)
? "final"
: "");
if (HasGeneratedMethods(descriptor_->file(), options_)) {
if (HasDescriptorMethods(descriptor_->file(), options_)) {
if (!HasSimpleBaseClass(descriptor_, options_)) {
format(
// Use Message's built-in MergeFrom and CopyFrom when the passed-in
// argument is a generic Message instance, and only define the
// custom MergeFrom and CopyFrom instances when the source of the
// merge/copy is known to be the same class as the destination.
"using $superclass$::CopyFrom;\n"
"void CopyFrom(const $classname$& from);\n"
""
"using $superclass$::MergeFrom;\n"
"void MergeFrom("
" const $classname$& from) {\n"
" $classname$::MergeImpl(*this, from);\n"
"}\n"
"private:\n"
"static void MergeImpl(::$proto_ns$::Message& to_msg, const "
"::$proto_ns$::Message& from_msg);\n"
"public:\n");
} else {
format(
"using $superclass$::CopyFrom;\n"
"inline void CopyFrom(const $classname$& from) {\n"
" $superclass$::CopyImpl(*this, from);\n"
"}\n"
""
"using $superclass$::MergeFrom;\n"
"void MergeFrom(const $classname$& from) {\n"
" $superclass$::MergeImpl(*this, from);\n"
"}\n"
"public:\n");
}
} else {
format(
"void CheckTypeAndMergeFrom(const ::$proto_ns$::MessageLite& from)"
" final;\n"
"void CopyFrom(const $classname$& from);\n"
"void MergeFrom(const $classname$& from);\n");
}
if (!HasSimpleBaseClass(descriptor_, options_)) {
format(
"PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;\n"
"bool IsInitialized() const final;\n"
"\n"
"size_t ByteSizeLong() const final;\n");
parse_function_generator_->GenerateMethodDecls(printer);
format(
"$uint8$* _InternalSerialize(\n"
" $uint8$* target, ::$proto_ns$::io::EpsCopyOutputStream* stream) "
"const final;\n");
}
}
if (options_.field_listener_options.inject_field_listener_events) {
format("static constexpr int _kInternalFieldNumber = $1$;\n",
descriptor_->field_count());
}
if (!HasSimpleBaseClass(descriptor_, options_)) {
format(
"int GetCachedSize() const final { return "
"$cached_size$.Get(); }"
"\n\nprivate:\n"
"void SharedCtor(::$proto_ns$::Arena* arena, bool is_message_owned);\n"
"void SharedDtor();\n"
"void SetCachedSize(int size) const$ full_final$;\n"
"void InternalSwap($classname$* other);\n");
}
format(
// Friend AnyMetadata so that it can call this FullMessageName() method.
"\nprivate:\n"
"friend class ::$proto_ns$::internal::AnyMetadata;\n"
"static $1$ FullMessageName() {\n"
" return \"$full_name$\";\n"
"}\n",
options_.opensource_runtime ? "::PROTOBUF_NAMESPACE_ID::StringPiece"
: "::StringPiece");
format(
// TODO(gerbens) Make this private! Currently people are deriving from
// protos to give access to this constructor, breaking the invariants
// we rely on.
"protected:\n"
"explicit $classname$(::$proto_ns$::Arena* arena,\n"
" bool is_message_owned = false);\n");
switch (NeedsArenaDestructor()) {
case ArenaDtorNeeds::kOnDemand:
format(
"private:\n"
"static void ArenaDtor(void* object);\n"
"inline void OnDemandRegisterArenaDtor(::$proto_ns$::Arena* arena) "
"override {\n"
" if (arena == nullptr || ($inlined_string_donated_array$[0] & "
"0x1u) "
"== "
"0) {\n"
" return;\n"
" }\n"
" $inlined_string_donated_array$[0] &= 0xFFFFFFFEu;\n"
" arena->OwnCustomDestructor(this, &$classname$::ArenaDtor);\n"
"}\n");
break;
case ArenaDtorNeeds::kRequired:
format(
"private:\n"
"static void ArenaDtor(void* object);\n");
break;
case ArenaDtorNeeds::kNone:
break;
}
format(
"public:\n"
"\n");
if (HasDescriptorMethods(descriptor_->file(), options_)) {
if (HasGeneratedMethods(descriptor_->file(), options_)) {
format(
"static const ClassData _class_data_;\n"
"const ::$proto_ns$::Message::ClassData*"
"GetClassData() const final;\n"
"\n");
}
format(
"::$proto_ns$::Metadata GetMetadata() const final;\n"
"\n");
} else {
format(
"std::string GetTypeName() const final;\n"
"\n");
}
if (ShouldSplit(descriptor_, options_)) {
format(
"private:\n"
"inline bool IsSplitMessageDefault() const {\n"
" return $split$ == reinterpret_cast<Impl_::Split*>(&$1$);\n"
"}\n"
"PROTOBUF_NOINLINE void PrepareSplitMessageForWrite();\n"
"public:\n",
DefaultInstanceName(descriptor_, options_, /*split=*/true));
}
format(
"// nested types ----------------------------------------------------\n"
"\n");
// Import all nested message classes into this class's scope with typedefs.
for (int i = 0; i < descriptor_->nested_type_count(); i++) {
const Descriptor* nested_type = descriptor_->nested_type(i);
if (!IsMapEntryMessage(nested_type)) {
format.Set("nested_full_name", ClassName(nested_type, false));
format.Set("nested_name", ResolveKeyword(nested_type->name()));
format("typedef ${1$$nested_full_name$$}$ ${1$$nested_name$$}$;\n",
nested_type);
}
}
if (descriptor_->nested_type_count() > 0) {
format("\n");
}
// Import all nested enums and their values into this class's scope with
// typedefs and constants.
for (int i = 0; i < descriptor_->enum_type_count(); i++) {
enum_generators_[i]->GenerateSymbolImports(printer);
format("\n");
}
format(
"// accessors -------------------------------------------------------\n"
"\n");
// Generate accessor methods for all fields.
GenerateFieldAccessorDeclarations(printer);
// Declare extension identifiers.
for (int i = 0; i < descriptor_->extension_count(); i++) {
extension_generators_[i]->GenerateDeclaration(printer);
}
format("// @@protoc_insertion_point(class_scope:$full_name$)\n");
// Generate private members.
format.Outdent();
format(" private:\n");
format.Indent();
// TODO(seongkim): Remove hack to track field access and remove this class.
format("class _Internal;\n");
for (auto field : FieldRange(descriptor_)) {
// set_has_***() generated in all oneofs.
if (!field->is_repeated() && !field->options().weak() &&
field->real_containing_oneof()) {
format("void set_has_$1$();\n", FieldName(field));
}
}
format("\n");
// Generate oneof function declarations
for (auto oneof : OneOfRange(descriptor_)) {
format(
"inline bool has_$1$() const;\n"
"inline void clear_has_$1$();\n\n",
oneof->name());
}
if (HasGeneratedMethods(descriptor_->file(), options_) &&
!descriptor_->options().message_set_wire_format() &&
num_required_fields_ > 1) {
format(
"// helper for ByteSizeLong()\n"
"size_t RequiredFieldsByteSizeFallback() const;\n\n");
}
if (HasGeneratedMethods(descriptor_->file(), options_)) {
parse_function_generator_->GenerateDataDecls(printer);
}
// Prepare decls for _cached_size_ and _has_bits_. Their position in the
// output will be determined later.
bool need_to_emit_cached_size = !HasSimpleBaseClass(descriptor_, options_);
const std::string cached_size_decl =
"mutable ::$proto_ns$::internal::CachedSize _cached_size_;\n";
const size_t sizeof_has_bits = HasBitsSize();
const std::string has_bits_decl =
sizeof_has_bits == 0 ? ""
: StrCat("::$proto_ns$::internal::HasBits<",
sizeof_has_bits, "> _has_bits_;\n");
format(
"template <typename T> friend class "
"::$proto_ns$::Arena::InternalHelper;\n"
"typedef void InternalArenaConstructable_;\n"
"typedef void DestructorSkippable_;\n");
// To minimize padding, data members are divided into three sections:
// (1) members assumed to align to 8 bytes
// (2) members corresponding to message fields, re-ordered to optimize
// alignment.
// (3) members assumed to align to 4 bytes.
format("struct Impl_ {\n");
format.Indent();
// Members assumed to align to 8 bytes:
if (descriptor_->extension_range_count() > 0) {
format(
"::$proto_ns$::internal::ExtensionSet _extensions_;\n"
"\n");
}
if (HasTracker(descriptor_, options_)) {
format("static ::$proto_ns$::AccessListener<$1$> _tracker_;\n",
ClassName(descriptor_));
}
// Generate _inlined_string_donated_ for inlined string type.
// TODO(congliu): To avoid affecting the locality of `_has_bits_`, should this
// be below or above `_has_bits_`?
if (!inlined_string_indices_.empty()) {
format("::$proto_ns$::internal::HasBits<$1$> _inlined_string_donated_;\n",
InlinedStringDonatedSize());
}
if (!has_bit_indices_.empty()) {
// _has_bits_ is frequently accessed, so to reduce code size and improve
// speed, it should be close to the start of the object. Placing
// _cached_size_ together with _has_bits_ improves cache locality despite
// potential alignment padding.
format(has_bits_decl.c_str());
if (need_to_emit_cached_size) {
format(cached_size_decl.c_str());
need_to_emit_cached_size = false;
}
}
// Field members:
// Emit some private and static members
for (auto field : optimized_order_) {
const FieldGenerator& generator = field_generators_.get(field);
generator.GenerateStaticMembers(printer);
if (!ShouldSplit(field, options_)) {
generator.GeneratePrivateMembers(printer);
}
}
if (ShouldSplit(descriptor_, options_)) {
format("struct Split {\n");
format.Indent();
for (auto field : optimized_order_) {
if (!ShouldSplit(field, options_)) continue;
const FieldGenerator& generator = field_generators_.get(field);
generator.GeneratePrivateMembers(printer);
}
format.Outdent();
format(
" typedef void InternalArenaConstructable_;\n"
" typedef void DestructorSkippable_;\n"
"};\n"
"Split* _split_;\n");
}
// For each oneof generate a union
for (auto oneof : OneOfRange(descriptor_)) {
std::string camel_oneof_name = UnderscoresToCamelCase(oneof->name(), true);
format("union $1$Union {\n", camel_oneof_name);
format.Indent();
format(
// explicit empty constructor is needed when union contains
// ArenaStringPtr members for string fields.
"constexpr $1$Union() : _constinit_{} {}\n"
" ::$proto_ns$::internal::ConstantInitialized _constinit_;\n",
camel_oneof_name);
for (auto field : FieldRange(oneof)) {
if (!IsFieldStripped(field, options_)) {
field_generators_.get(field).GeneratePrivateMembers(printer);
}
}
format.Outdent();
format("} $1$_;\n", oneof->name());
for (auto field : FieldRange(oneof)) {
if (!IsFieldStripped(field, options_)) {
field_generators_.get(field).GenerateStaticMembers(printer);
}
}
}
// Members assumed to align to 4 bytes:
if (need_to_emit_cached_size) {
format(cached_size_decl.c_str());
need_to_emit_cached_size = false;
}
// Generate _oneof_case_.
if (descriptor_->real_oneof_decl_count() > 0) {
format(
"$uint32$ _oneof_case_[$1$];\n"
"\n",
descriptor_->real_oneof_decl_count());
}
if (num_weak_fields_) {
format("::$proto_ns$::internal::WeakFieldMap _weak_field_map_;\n");
}
// Generate _any_metadata_ for the Any type.
if (IsAnyMessage(descriptor_, options_)) {
format("::$proto_ns$::internal::AnyMetadata _any_metadata_;\n");
}
format.Outdent();
format("};\n");
// Only create the _impl_ field if it contains data.
if (HasImplData(descriptor_, options_)) {
format("union { Impl_ _impl_; };\n");
}
if (ShouldSplit(descriptor_, options_)) {
format(
"static Impl_::Split* CreateSplitMessage("
"::$proto_ns$::Arena* arena);\n");
format("friend struct $1$;\n",
DefaultInstanceType(descriptor_, options_, /*split=*/true));
}
// The TableStruct struct needs access to the private parts, in order to
// construct the offsets of all members.
format("friend struct ::$tablename$;\n");
format.Outdent();
format("};");
GOOGLE_DCHECK(!need_to_emit_cached_size);
} // NOLINT(readability/fn_size)
void MessageGenerator::GenerateInlineMethods(io::Printer* printer) {
if (IsMapEntryMessage(descriptor_)) return;
GenerateFieldAccessorDefinitions(printer);
// Generate oneof_case() functions.
for (auto oneof : OneOfRange(descriptor_)) {
Formatter format(printer, variables_);
format.Set("camel_oneof_name", UnderscoresToCamelCase(oneof->name(), true));
format.Set("oneof_name", oneof->name());
format.Set("oneof_index", oneof->index());
format(
"inline $classname$::$camel_oneof_name$Case $classname$::"
"${1$$oneof_name$_case$}$() const {\n"
" return $classname$::$camel_oneof_name$Case("
"$oneof_case$[$oneof_index$]);\n"
"}\n",
oneof);
}
}
void MessageGenerator::GenerateSchema(io::Printer* printer, int offset,
int has_offset) {
Formatter format(printer, variables_);
has_offset = !has_bit_indices_.empty() || IsMapEntryMessage(descriptor_)
? offset + has_offset
: -1;
int inlined_string_indices_offset;
if (inlined_string_indices_.empty()) {
inlined_string_indices_offset = -1;
} else {
GOOGLE_DCHECK_NE(has_offset, -1);
GOOGLE_DCHECK(!IsMapEntryMessage(descriptor_));
inlined_string_indices_offset = has_offset + has_bit_indices_.size();
}
format("{ $1$, $2$, $3$, sizeof($classtype$)},\n", offset, has_offset,
inlined_string_indices_offset);
}
void MessageGenerator::GenerateClassMethods(io::Printer* printer) {
Formatter format(printer, variables_);
if (IsMapEntryMessage(descriptor_)) {
format(
"$classname$::$classname$() {}\n"
"$classname$::$classname$(::$proto_ns$::Arena* arena)\n"
" : SuperType(arena) {}\n"
"void $classname$::MergeFrom(const $classname$& other) {\n"
" MergeFromInternal(other);\n"
"}\n");
if (HasDescriptorMethods(descriptor_->file(), options_)) {
if (!descriptor_->options().map_entry()) {
format(
"::$proto_ns$::Metadata $classname$::GetMetadata() const {\n"
"$annotate_reflection$"
" return ::_pbi::AssignDescriptors(\n"
" &$desc_table$_getter, &$desc_table$_once,\n"
" $file_level_metadata$[$1$]);\n"
"}\n",
index_in_file_messages_);
} else {
format(
"::$proto_ns$::Metadata $classname$::GetMetadata() const {\n"
" return ::_pbi::AssignDescriptors(\n"
" &$desc_table$_getter, &$desc_table$_once,\n"
" $file_level_metadata$[$1$]);\n"
"}\n",
index_in_file_messages_);
}
}
return;
}
if (IsAnyMessage(descriptor_, options_)) {
if (HasDescriptorMethods(descriptor_->file(), options_)) {
format(
"bool $classname$::GetAnyFieldDescriptors(\n"
" const ::$proto_ns$::Message& message,\n"
" const ::$proto_ns$::FieldDescriptor** type_url_field,\n"
" const ::$proto_ns$::FieldDescriptor** value_field) {\n"
" return ::_pbi::GetAnyFieldDescriptors(\n"
" message, type_url_field, value_field);\n"
"}\n");
}
format(
"bool $classname$::ParseAnyTypeUrl(\n"
" ::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url,\n"
" std::string* full_type_name) {\n"
" return ::_pbi::ParseAnyTypeUrl(type_url, full_type_name);\n"
"}\n"
"\n");
}
format(
"class $classname$::_Internal {\n"
" public:\n");
format.Indent();
if (!has_bit_indices_.empty()) {
format(
"using HasBits = "
"decltype(std::declval<$classname$>().$has_bits$);\n");
}
for (auto field : FieldRange(descriptor_)) {
field_generators_.get(field).GenerateInternalAccessorDeclarations(printer);
if (IsFieldStripped(field, options_)) {
continue;
}
if (HasHasbit(field)) {
int has_bit_index = HasBitIndex(field);
GOOGLE_CHECK_NE(has_bit_index, kNoHasbit) << field->full_name();
format(
"static void set_has_$1$(HasBits* has_bits) {\n"
" (*has_bits)[$2$] |= $3$u;\n"
"}\n",
FieldName(field), has_bit_index / 32, (1u << (has_bit_index % 32)));
}
}
if (num_required_fields_ > 0) {
const std::vector<uint32_t> masks_for_has_bits = RequiredFieldsBitMask();
format(
"static bool MissingRequiredFields(const HasBits& has_bits) "
"{\n"
" return $1$;\n"
"}\n",
ConditionalToCheckBitmasks(masks_for_has_bits, false, "has_bits"));
}
format.Outdent();
format("};\n\n");
for (auto field : FieldRange(descriptor_)) {
if (!IsFieldStripped(field, options_)) {
field_generators_.get(field).GenerateInternalAccessorDefinitions(
printer);
}
}
// Generate non-inline field definitions.
for (auto field : FieldRange(descriptor_)) {
if (IsFieldStripped(field, options_)) {
continue;
}
field_generators_.get(field).GenerateNonInlineAccessorDefinitions(printer);
if (IsCrossFileMaybeMap(field)) {
Formatter::SaveState saver(&format);
std::map<std::string, std::string> vars;
SetCommonFieldVariables(field, &vars, options_);
if (field->real_containing_oneof()) {
SetCommonOneofFieldVariables(field, &vars);
}
format.AddMap(vars);
GenerateFieldClear(field, false, format);
}
}
GenerateStructors(printer);
format("\n");
if (descriptor_->real_oneof_decl_count() > 0) {
GenerateOneofClear(printer);
format("\n");
}
if (HasGeneratedMethods(descriptor_->file(), options_)) {
GenerateClear(printer);
format("\n");
if (!HasSimpleBaseClass(descriptor_, options_)) {
parse_function_generator_->GenerateMethodImpls(printer);
format("\n");
parse_function_generator_->GenerateDataDefinitions(printer);
}
GenerateSerializeWithCachedSizesToArray(printer);
format("\n");
GenerateByteSize(printer);
format("\n");
GenerateMergeFrom(printer);
format("\n");
GenerateClassSpecificMergeImpl(printer);
format("\n");
GenerateCopyFrom(printer);
format("\n");
GenerateIsInitialized(printer);
format("\n");
}
if (ShouldSplit(descriptor_, options_)) {
format(
"void $classname$::PrepareSplitMessageForWrite() {\n"
" if (IsSplitMessageDefault()) {\n"
" $split$ = CreateSplitMessage(GetArenaForAllocation());\n"
" }\n"
"}\n");
}
GenerateVerify(printer);
GenerateSwap(printer);
format("\n");
if (HasDescriptorMethods(descriptor_->file(), options_)) {
if (!descriptor_->options().map_entry()) {
format(
"::$proto_ns$::Metadata $classname$::GetMetadata() const {\n"
"$annotate_reflection$"
" return ::_pbi::AssignDescriptors(\n"
" &$desc_table$_getter, &$desc_table$_once,\n"
" $file_level_metadata$[$1$]);\n"
"}\n",
index_in_file_messages_);
} else {
format(
"::$proto_ns$::Metadata $classname$::GetMetadata() const {\n"
" return ::_pbi::AssignDescriptors(\n"
" &$desc_table$_getter, &$desc_table$_once,\n"
" $file_level_metadata$[$1$]);\n"
"}\n",
index_in_file_messages_);
}
} else {
format(
"std::string $classname$::GetTypeName() const {\n"
" return \"$full_name$\";\n"
"}\n"
"\n");
}
if (HasTracker(descriptor_, options_)) {
format(
"::$proto_ns$::AccessListener<$classtype$> "
"$1$::$tracker$(&FullMessageName);\n",
ClassName(descriptor_));
}
}
std::pair<size_t, size_t> MessageGenerator::GenerateOffsets(
io::Printer* printer) {
Formatter format(printer, variables_);
if (!has_bit_indices_.empty() || IsMapEntryMessage(descriptor_)) {
format("PROTOBUF_FIELD_OFFSET($classtype$, $has_bits$),\n");
} else {
format("~0u, // no _has_bits_\n");
}
format("PROTOBUF_FIELD_OFFSET($classtype$, _internal_metadata_),\n");
if (descriptor_->extension_range_count() > 0) {
format("PROTOBUF_FIELD_OFFSET($classtype$, $extensions$),\n");
} else {
format("~0u, // no _extensions_\n");
}
if (descriptor_->real_oneof_decl_count() > 0) {
format("PROTOBUF_FIELD_OFFSET($classtype$, $oneof_case$[0]),\n");
} else {
format("~0u, // no _oneof_case_\n");
}
if (num_weak_fields_ > 0) {
format("PROTOBUF_FIELD_OFFSET($classtype$, $weak_field_map$),\n");
} else {
format("~0u, // no _weak_field_map_\n");
}
if (!inlined_string_indices_.empty()) {
format(
"PROTOBUF_FIELD_OFFSET($classtype$, "
"$inlined_string_donated_array$),\n");
} else {
format("~0u, // no _inlined_string_donated_\n");
}
const int kNumGenericOffsets = 6; // the number of fixed offsets above
const size_t offsets = kNumGenericOffsets + descriptor_->field_count() +
descriptor_->real_oneof_decl_count();
size_t entries = offsets;
for (auto field : FieldRange(descriptor_)) {
if (IsFieldStripped(field, options_)) {
format("~0u, // stripped\n");
continue;
}
// TODO(sbenza): We should not have an entry in the offset table for fields
// that do not use them.
if (field->options().weak() || field->real_containing_oneof()) {
// Mark the field to prevent unintentional access through reflection.
// Don't use the top bit because that is for unused fields.
format("::_pbi::kInvalidFieldOffsetTag");
} else {
format("PROTOBUF_FIELD_OFFSET($classtype$$1$, $2$)",
ShouldSplit(field, options_) ? "::Impl_::Split" : "",
ShouldSplit(field, options_)
? FieldName(field) + "_"
: FieldMemberName(field, /*cold=*/false));
}
// Some information about a field is in the pdproto profile. The profile is
// only available at compile time. So we embed such information in the
// offset of the field, so that the information is available when
// reflectively accessing the field at run time.
//
// Embed whether the field is eagerly verified lazy or inlined string to the
// LSB of the offset.
if (IsEagerlyVerifiedLazy(field, options_, scc_analyzer_)) {
format(" | 0x1u // eagerly verified lazy\n");
} else if (IsStringInlined(field, options_)) {
format(" | 0x1u // inlined\n");
}
format(",\n");
}
int count = 0;
for (auto oneof : OneOfRange(descriptor_)) {
format("PROTOBUF_FIELD_OFFSET($classtype$, _impl_.$1$_),\n", oneof->name());
count++;
}
GOOGLE_CHECK_EQ(count, descriptor_->real_oneof_decl_count());
if (IsMapEntryMessage(descriptor_)) {
entries += 2;
format(
"0,\n"
"1,\n");
} else if (!has_bit_indices_.empty()) {
entries += has_bit_indices_.size();
for (int i = 0; i < has_bit_indices_.size(); i++) {
const std::string index =
has_bit_indices_[i] >= 0 ? StrCat(has_bit_indices_[i]) : "~0u";
format("$1$,\n", index);
}
}
if (!inlined_string_indices_.empty()) {
entries += inlined_string_indices_.size();
for (int inlined_string_index : inlined_string_indices_) {
const std::string index =
inlined_string_index >= 0
? StrCat(inlined_string_index, ", // inlined_string_index")
: "~0u,";
format("$1$\n", index);
}
}
return std::make_pair(entries, offsets);
}
void MessageGenerator::GenerateSharedConstructorCode(io::Printer* printer) {
if (HasSimpleBaseClass(descriptor_, options_)) return;
Formatter format(printer, variables_);
format(
"inline void $classname$::SharedCtor(\n"
" ::_pb::Arena* arena, bool is_message_owned) {\n"
" (void)arena;\n"
" (void)is_message_owned;\n");
format.Indent();
// Impl_ _impl_.
format("new (&_impl_) Impl_{");
format.Indent();
const char* field_sep = " ";
const auto put_sep = [&] {
format("\n$1$ ", field_sep);
field_sep = ",";
};
// Note: any fields without move/copy constructors can't be explicitly
// aggregate initialized pre-C++17.
if (descriptor_->extension_range_count() > 0) {
put_sep();
format("/*decltype($extensions$)*/{::_pbi::ArenaInitialized(), arena}");
}
if (!inlined_string_indices_.empty()) {
put_sep();
format("decltype($inlined_string_donated_array$){}");
}
bool need_to_emit_cached_size = !HasSimpleBaseClass(descriptor_, options_);
if (!has_bit_indices_.empty()) {
put_sep();
format("decltype($has_bits$){}");
if (need_to_emit_cached_size) {
put_sep();
format("/*decltype($cached_size$)*/{}");
need_to_emit_cached_size = false;
}
}
// Initialize member variables with arena constructor.
for (auto field : optimized_order_) {
GOOGLE_DCHECK(!IsFieldStripped(field, options_));
if (ShouldSplit(field, options_)) {
continue;
}
put_sep();
field_generators_.get(field).GenerateAggregateInitializer(printer);
}
if (ShouldSplit(descriptor_, options_)) {
put_sep();
format("decltype($split$){reinterpret_cast<Impl_::Split*>(&$1$)}",
DefaultInstanceName(descriptor_, options_, /*split=*/true));
}
for (auto oneof : OneOfRange(descriptor_)) {
put_sep();
format("decltype(_impl_.$1$_){}", oneof->name());
}
if (need_to_emit_cached_size) {
put_sep();
format("/*decltype($cached_size$)*/{}");
}
if (descriptor_->real_oneof_decl_count() != 0) {
put_sep();
format("/*decltype($oneof_case$)*/{}");
}
if (num_weak_fields_ > 0) {
put_sep();
format("decltype($weak_field_map$){arena}");
}
if (IsAnyMessage(descriptor_, options_)) {
put_sep();
// AnyMetadata has no move constructor.
format("/*decltype($any_metadata$)*/{&_impl_.type_url_, &_impl_.value_}");
}
format.Outdent();
format("\n};\n");
if (!inlined_string_indices_.empty()) {
// Donate inline string fields.
format.Indent();
// The last bit is the tracking bit for registering ArenaDtor. The bit is 1
// means ArenaDtor is not registered on construction, and on demand register
// is needed.
format("if (arena != nullptr) {\n");
if (NeedsArenaDestructor() == ArenaDtorNeeds::kOnDemand) {
format(
" if (!is_message_owned) {\n"
" $inlined_string_donated_array$[0] = ~0u;\n"
" } else {\n"
// We should not register ArenaDtor for MOA.
" $inlined_string_donated_array$[0] = 0xFFFFFFFEu;\n"
" }\n");
} else {
format(" $inlined_string_donated_array$[0] = 0xFFFFFFFEu;\n");
}
for (size_t i = 1; i < InlinedStringDonatedSize(); ++i) {
format(" $inlined_string_donated_array$[$1$] = ~0u;\n", i);
}
format("}\n");
format.Outdent();
}
for (const FieldDescriptor* field : optimized_order_) {
if (ShouldSplit(field, options_)) {
continue;
}
field_generators_.get(field).GenerateConstructorCode(printer);
}
for (auto oneof : OneOfRange(descriptor_)) {
format("clear_has_$1$();\n", oneof->name());
}
format.Outdent();
format("}\n\n");
}
void MessageGenerator::GenerateCreateSplitMessage(io::Printer* printer) {
Formatter format(printer, variables_);
format(
"$classname$::Impl_::Split* "
"$classname$::CreateSplitMessage(::$proto_ns$::Arena* arena) {\n");
format.Indent();
const char* field_sep = " ";
const auto put_sep = [&] {
format("\n$1$ ", field_sep);
field_sep = ",";
};
format(
"const size_t size = sizeof(Impl_::Split);\n"
"void* chunk = (arena == nullptr) ?\n"
" ::operator new(size) :\n"
" arena->AllocateAligned(size, alignof(Impl_::Split));\n"
"Impl_::Split* ptr = reinterpret_cast<Impl_::Split*>(chunk);\n"
"new (ptr) Impl_::Split{");
format.Indent();
for (const FieldDescriptor* field : optimized_order_) {
GOOGLE_DCHECK(!IsFieldStripped(field, options_));
if (ShouldSplit(field, options_)) {
put_sep();
field_generators_.get(field).GenerateAggregateInitializer(printer);
}
}
format.Outdent();
format("};\n");
for (const FieldDescriptor* field : optimized_order_) {
GOOGLE_DCHECK(!IsFieldStripped(field, options_));
if (ShouldSplit(field, options_)) {
field_generators_.get(field).GenerateCreateSplitMessageCode(printer);
}
}
format("return ptr;\n");
format.Outdent();
format("}\n");
}
void MessageGenerator::GenerateInitDefaultSplitInstance(io::Printer* printer) {
if (!ShouldSplit(descriptor_, options_)) return;
Formatter format(printer, variables_);
const char* field_sep = " ";
const auto put_sep = [&] {
format("\n$1$ ", field_sep);
field_sep = ",";
};
for (const auto* field : optimized_order_) {
if (ShouldSplit(field, options_)) {
put_sep();
field_generators_.get(field).GenerateConstexprAggregateInitializer(
printer);
}
}
}
void MessageGenerator::GenerateSharedDestructorCode(io::Printer* printer) {
if (HasSimpleBaseClass(descriptor_, options_)) return;
Formatter format(printer, variables_);
format("inline void $classname$::SharedDtor() {\n");
format.Indent();
format("$DCHK$(GetArenaForAllocation() == nullptr);\n");
if (descriptor_->extension_range_count() > 0) {
format("$extensions$.~ExtensionSet();\n");
}
// Write the destructors for each field except oneof members.
// optimized_order_ does not contain oneof fields.
for (auto field : optimized_order_) {
if (ShouldSplit(field, options_)) {
continue;
}
field_generators_.get(field).GenerateDestructorCode(printer);
}
if (ShouldSplit(descriptor_, options_)) {
format("if (!IsSplitMessageDefault()) {\n");
format.Indent();
format("auto* $cached_split_ptr$ = $split$;\n");
for (auto field : optimized_order_) {
if (ShouldSplit(field, options_)) {
field_generators_.get(field).GenerateDestructorCode(printer);
}
}
format("delete $cached_split_ptr$;\n");
format.Outdent();
format("}\n");
}
// Generate code to destruct oneofs. Clearing should do the work.
for (auto oneof : OneOfRange(descriptor_)) {
format(
"if (has_$1$()) {\n"
" clear_$1$();\n"
"}\n",
oneof->name());
}
if (num_weak_fields_) {
format("$weak_field_map$.ClearAll();\n");
}
if (IsAnyMessage(descriptor_, options_)) {
format("$any_metadata$.~AnyMetadata();\n");
}
format.Outdent();
format(
"}\n"
"\n");
}
ArenaDtorNeeds MessageGenerator::NeedsArenaDestructor() const {
if (HasSimpleBaseClass(descriptor_, options_)) return ArenaDtorNeeds::kNone;
ArenaDtorNeeds needs = ArenaDtorNeeds::kNone;
for (const auto* field : FieldRange(descriptor_)) {
if (IsFieldStripped(field, options_)) continue;
needs =
std::max(needs, field_generators_.get(field).NeedsArenaDestructor());
}
return needs;
}
void MessageGenerator::GenerateArenaDestructorCode(io::Printer* printer) {
GOOGLE_CHECK(NeedsArenaDestructor() > ArenaDtorNeeds::kNone);
Formatter format(printer, variables_);
// Generate the ArenaDtor() method. Track whether any fields actually produced
// code that needs to be called.
format("void $classname$::ArenaDtor(void* object) {\n");
format.Indent();
// This code is placed inside a static method, rather than an ordinary one,
// since that simplifies Arena's destructor list (ordinary function pointers
// rather than member function pointers). _this is the object being
// destructed.
format("$classname$* _this = reinterpret_cast< $classname$* >(object);\n");
// Process non-oneof fields first.
for (auto field : optimized_order_) {
if (IsFieldStripped(field, options_) || ShouldSplit(field, options_))
continue;
const FieldGenerator& fg = field_generators_.get(field);
fg.GenerateArenaDestructorCode(printer);
}
if (ShouldSplit(descriptor_, options_)) {
format("if (!_this->IsSplitMessageDefault()) {\n");
format.Indent();
for (auto field : optimized_order_) {
if (IsFieldStripped(field, options_) || !ShouldSplit(field, options_))
continue;
const FieldGenerator& fg = field_generators_.get(field);
fg.GenerateArenaDestructorCode(printer);
}
format.Outdent();
format("}\n");
}
// Process oneof fields.
for (auto oneof : OneOfRange(descriptor_)) {
for (auto field : FieldRange(oneof)) {
if (IsFieldStripped(field, options_)) continue;
field_generators_.get(field).GenerateArenaDestructorCode(printer);
}
}
format.Outdent();
format("}\n");
}
void MessageGenerator::GenerateConstexprConstructor(io::Printer* printer) {
Formatter format(printer, variables_);
if (IsMapEntryMessage(descriptor_) || !HasImplData(descriptor_, options_)) {
format(
"PROTOBUF_CONSTEXPR $classname$::$classname$(\n"
" ::_pbi::ConstantInitialized) {}\n");
return;
}
format(
"PROTOBUF_CONSTEXPR $classname$::$classname$(\n"
" ::_pbi::ConstantInitialized)");
bool need_to_emit_cached_size = !HasSimpleBaseClass(descriptor_, options_);
format(": _impl_{");
format.Indent();
const char* field_sep = " ";
const auto put_sep = [&] {
format("\n$1$ ", field_sep);
field_sep = ",";
};
if (descriptor_->extension_range_count() > 0) {
put_sep();
format("/*decltype($extensions$)*/{}");
}
if (!inlined_string_indices_.empty()) {
put_sep();
format("/*decltype($inlined_string_donated_array$)*/{}");
}
if (!has_bit_indices_.empty()) {
put_sep();
format("/*decltype($has_bits$)*/{}");
if (need_to_emit_cached_size) {
put_sep();
format("/*decltype($cached_size$)*/{}");
need_to_emit_cached_size = false;
}
}
for (auto field : optimized_order_) {
if (ShouldSplit(field, options_)) {
continue;
}
put_sep();
field_generators_.get(field).GenerateConstexprAggregateInitializer(
printer);
}
if (ShouldSplit(descriptor_, options_)) {
put_sep();
format("/*decltype($split$)*/&$1$._instance",
DefaultInstanceName(descriptor_, options_, /*split=*/true));
}
for (auto oneof : OneOfRange(descriptor_)) {
put_sep();
format("/*decltype(_impl_.$1$_)*/{}", oneof->name());
}
if (need_to_emit_cached_size) {
put_sep();
format("/*decltype($cached_size$)*/{}");
}
if (descriptor_->real_oneof_decl_count() != 0) {
put_sep();
format("/*decltype($oneof_case$)*/{}");
}
if (num_weak_fields_) {
put_sep();
format("/*decltype($weak_field_map$)*/{}");
}
if (IsAnyMessage(descriptor_, options_)) {
put_sep();
format(
"/*decltype($any_metadata$)*/{&_impl_.type_url_, "
"&_impl_.value_}");
}
format.Outdent();
format("} {}\n");
}
void MessageGenerator::GenerateCopyConstructorBody(io::Printer* printer) const {
Formatter format(printer, variables_);
const RunMap runs =
FindRuns(optimized_order_, [this](const FieldDescriptor* field) {
return IsPOD(field) && !ShouldSplit(field, options_);
});
std::string pod_template =
"::memcpy(&$first$, &from.$first$,\n"
" static_cast<size_t>(reinterpret_cast<char*>(&$last$) -\n"
" reinterpret_cast<char*>(&$first$)) + sizeof($last$));\n";
if (ShouldSplit(descriptor_, options_)) {
format("if (!from.IsSplitMessageDefault()) {\n");
format.Indent();
format("_this->PrepareSplitMessageForWrite();\n");
for (auto field : optimized_order_) {
if (ShouldSplit(field, options_)) {
field_generators_.get(field).GenerateCopyConstructorCode(printer);
}
}
format.Outdent();
format("}\n");
}
for (size_t i = 0; i < optimized_order_.size(); ++i) {
const FieldDescriptor* field = optimized_order_[i];
if (ShouldSplit(field, options_)) {
continue;
}
const auto it = runs.find(field);
// We only apply the memset technique to runs of more than one field, as
// assignment is better than memset for generated code clarity.
if (it != runs.end() && it->second > 1) {
// Use a memset, then skip run_length fields.
const size_t run_length = it->second;
const std::string first_field_name =
FieldMemberName(field, /*cold=*/false);
const std::string last_field_name =
FieldMemberName(optimized_order_[i + run_length - 1], /*cold=*/false);
format.Set("first", first_field_name);
format.Set("last", last_field_name);
format(pod_template.c_str());
i += run_length - 1;
// ++i at the top of the loop.
} else {
field_generators_.get(field).GenerateCopyConstructorCode(printer);
}
}
}
void MessageGenerator::GenerateStructors(io::Printer* printer) {
Formatter format(printer, variables_);
format(
"$classname$::$classname$(::$proto_ns$::Arena* arena,\n"
" bool is_message_owned)\n"
" : $1$(arena, is_message_owned) {\n",
SuperClassName(descriptor_, options_));
if (!HasSimpleBaseClass(descriptor_, options_)) {
format(" SharedCtor(arena, is_message_owned);\n");
if (NeedsArenaDestructor() == ArenaDtorNeeds::kRequired) {
format(
" if (arena != nullptr && !is_message_owned) {\n"
" arena->OwnCustomDestructor(this, &$classname$::ArenaDtor);\n"
" }\n");
}
}
format(
" // @@protoc_insertion_point(arena_constructor:$full_name$)\n"
"}\n");
std::map<std::string, std::string> vars;
SetUnknownFieldsVariable(descriptor_, options_, &vars);
format.AddMap(vars);
// Generate the copy constructor.
if (UsingImplicitWeakFields(descriptor_->file(), options_)) {
// If we are in lite mode and using implicit weak fields, we generate a
// one-liner copy constructor that delegates to MergeFrom. This saves some
// code size and also cuts down on the complexity of implicit weak fields.
// We might eventually want to do this for all lite protos.
format(
"$classname$::$classname$(const $classname$& from)\n"
" : $classname$() {\n"
" MergeFrom(from);\n"
"}\n");
} else {
format(
"$classname$::$classname$(const $classname$& from)\n"
" : $superclass$() {\n");
format.Indent();
format("$classname$* const _this = this; (void)_this;\n");
if (HasImplData(descriptor_, options_)) {
const char* field_sep = " ";
const auto put_sep = [&] {
format("\n$1$ ", field_sep);
field_sep = ",";
};
format("new (&_impl_) Impl_{");
format.Indent();
if (descriptor_->extension_range_count() > 0) {
put_sep();
format("/*decltype($extensions$)*/{}");
}
if (!inlined_string_indices_.empty()) {
// Do not copy inlined_string_donated_, because this is not an arena
// constructor.
put_sep();
format("decltype($inlined_string_donated_array$){}");
}
bool need_to_emit_cached_size =
!HasSimpleBaseClass(descriptor_, options_);
if (!has_bit_indices_.empty()) {
put_sep();
format("decltype($has_bits$){from.$has_bits$}");
if (need_to_emit_cached_size) {
put_sep();
format("/*decltype($cached_size$)*/{}");
need_to_emit_cached_size = false;
}
}
// Initialize member variables with arena constructor.
for (auto field : optimized_order_) {
if (ShouldSplit(field, options_)) {
continue;
}
put_sep();
field_generators_.get(field).GenerateCopyAggregateInitializer(printer);
}
if (ShouldSplit(descriptor_, options_)) {
put_sep();
format("decltype($split$){reinterpret_cast<Impl_::Split*>(&$1$)}",
DefaultInstanceName(descriptor_, options_, /*split=*/true));
}
for (auto oneof : OneOfRange(descriptor_)) {
put_sep();
format("decltype(_impl_.$1$_){}", oneof->name());
}
if (need_to_emit_cached_size) {
put_sep();
format("/*decltype($cached_size$)*/{}");
}
if (descriptor_->real_oneof_decl_count() != 0) {
put_sep();
format("/*decltype($oneof_case$)*/{}");
}
if (num_weak_fields_ > 0) {
put_sep();
format("decltype($weak_field_map$){from.$weak_field_map$}");
}
if (IsAnyMessage(descriptor_, options_)) {
put_sep();
format(
"/*decltype($any_metadata$)*/{&_impl_.type_url_, &_impl_.value_}");
}
format.Outdent();
format("};\n\n");
}
format(
"_internal_metadata_.MergeFrom<$unknown_fields_type$>(from._internal_"
"metadata_);\n");
if (descriptor_->extension_range_count() > 0) {
format(
"$extensions$.MergeFrom(internal_default_instance(), "
"from.$extensions$);\n");
}
GenerateCopyConstructorBody(printer);
// Copy oneof fields. Oneof field requires oneof case check.
for (auto oneof : OneOfRange(descriptor_)) {
format(
"clear_has_$1$();\n"
"switch (from.$1$_case()) {\n",
oneof->name());
format.Indent();
for (auto field : FieldRange(oneof)) {
format("case k$1$: {\n", UnderscoresToCamelCase(field->name(), true));
format.Indent();
if (!IsFieldStripped(field, options_)) {
field_generators_.get(field).GenerateMergingCode(printer);
}
format("break;\n");
format.Outdent();
format("}\n");
}
format(
"case $1$_NOT_SET: {\n"
" break;\n"
"}\n",
ToUpper(oneof->name()));
format.Outdent();
format("}\n");
}
format.Outdent();
format(
" // @@protoc_insertion_point(copy_constructor:$full_name$)\n"
"}\n"
"\n");
}
// Generate the shared constructor code.
GenerateSharedConstructorCode(printer);
if (ShouldSplit(descriptor_, options_)) {
GenerateCreateSplitMessage(printer);
}
// Generate the destructor.
if (!HasSimpleBaseClass(descriptor_, options_)) {
format(
"$classname$::~$classname$() {\n"
" // @@protoc_insertion_point(destructor:$full_name$)\n");
format(
" if (auto *arena = "
"_internal_metadata_.DeleteReturnArena<$unknown_fields_type$>()) {\n"
" (void)arena;\n");
if (NeedsArenaDestructor() > ArenaDtorNeeds::kNone) {
format(" ArenaDtor(this);\n");
}
format(
" return;\n"
" }\n");
format(
" SharedDtor();\n"
"}\n"
"\n");
} else {
// For messages using simple base classes, having no destructor
// allows our vtable to share the same destructor as every other
// message with a simple base class. This works only as long as
// we have no fields needing destruction, of course. (No strings
// or extensions)
}
// Generate the shared destructor code.
GenerateSharedDestructorCode(printer);
// Generate the arena-specific destructor code.
if (NeedsArenaDestructor() > ArenaDtorNeeds::kNone) {
GenerateArenaDestructorCode(printer);
}
if (!HasSimpleBaseClass(descriptor_, options_)) {
// Generate SetCachedSize.
format(
"void $classname$::SetCachedSize(int size) const {\n"
" $cached_size$.Set(size);\n"
"}\n");
}
}
void MessageGenerator::GenerateSourceInProto2Namespace(io::Printer* printer) {
Formatter format(printer, variables_);
format(
"template<> "
"PROTOBUF_NOINLINE $classtype$*\n"
"Arena::CreateMaybeMessage< $classtype$ >(Arena* arena) {\n"
" return Arena::CreateMessageInternal< $classtype$ >(arena);\n"
"}\n");
}
void MessageGenerator::GenerateClear(io::Printer* printer) {
if (HasSimpleBaseClass(descriptor_, options_)) return;
Formatter format(printer, variables_);
// The maximum number of bytes we will memset to zero without checking their
// hasbit to see if a zero-init is necessary.
const int kMaxUnconditionalPrimitiveBytesClear = 4;
format(
"void $classname$::Clear() {\n"
"// @@protoc_insertion_point(message_clear_start:$full_name$)\n");
format.Indent();
format(
// TODO(jwb): It would be better to avoid emitting this if it is not used,
// rather than emitting a workaround for the resulting warning.
"$uint32$ cached_has_bits = 0;\n"
"// Prevent compiler warnings about cached_has_bits being unused\n"
"(void) cached_has_bits;\n\n");
if (descriptor_->extension_range_count() > 0) {
format("$extensions$.Clear();\n");
}
// Collect fields into chunks. Each chunk may have an if() condition that
// checks all hasbits in the chunk and skips it if none are set.
int zero_init_bytes = 0;
for (const auto& field : optimized_order_) {
if (CanInitializeByZeroing(field)) {
zero_init_bytes += EstimateAlignmentSize(field);
}
}
bool merge_zero_init = zero_init_bytes > kMaxUnconditionalPrimitiveBytesClear;
int chunk_count = 0;
std::vector<std::vector<const FieldDescriptor*>> chunks = CollectFields(
optimized_order_,
[&](const FieldDescriptor* a, const FieldDescriptor* b) -> bool {
chunk_count++;
// This predicate guarantees that there is only a single zero-init
// (memset) per chunk, and if present it will be at the beginning.
bool same = HasByteIndex(a) == HasByteIndex(b) &&
a->is_repeated() == b->is_repeated() &&
ShouldSplit(a, options_) == ShouldSplit(b, options_) &&
(CanInitializeByZeroing(a) == CanInitializeByZeroing(b) ||
(CanInitializeByZeroing(a) &&
(chunk_count == 1 || merge_zero_init)));
if (!same) chunk_count = 0;
return same;
});
ColdChunkSkipper cold_skipper(descriptor_, options_, chunks, has_bit_indices_,
kColdRatio);
int cached_has_word_index = -1;
for (int chunk_index = 0; chunk_index < chunks.size(); chunk_index++) {
std::vector<const FieldDescriptor*>& chunk = chunks[chunk_index];
cold_skipper.OnStartChunk(chunk_index, cached_has_word_index, "", printer);
const FieldDescriptor* memset_start = nullptr;
const FieldDescriptor* memset_end = nullptr;
bool saw_non_zero_init = false;
bool chunk_is_cold = !chunk.empty() && ShouldSplit(chunk.front(), options_);
for (const auto& field : chunk) {
if (CanInitializeByZeroing(field)) {
GOOGLE_CHECK(!saw_non_zero_init);
if (!memset_start) memset_start = field;
memset_end = field;
} else {
saw_non_zero_init = true;
}
}
// Whether we wrap this chunk in:
// if (cached_has_bits & <chunk hasbits) { /* chunk. */ }
// We can omit the if() for chunk size 1, or if our fields do not have
// hasbits. I don't understand the rationale for the last part of the
// condition, but it matches the old logic.
const bool have_outer_if = HasBitIndex(chunk.front()) != kNoHasbit &&
chunk.size() > 1 &&
(memset_end != chunk.back() || merge_zero_init);
if (have_outer_if) {
// Emit an if() that will let us skip the whole chunk if none are set.
uint32_t chunk_mask = GenChunkMask(chunk, has_bit_indices_);
std::string chunk_mask_str =
StrCat(strings::Hex(chunk_mask, strings::ZERO_PAD_8));
// Check (up to) 8 has_bits at a time if we have more than one field in
// this chunk. Due to field layout ordering, we may check
// _has_bits_[last_chunk * 8 / 32] multiple times.
GOOGLE_DCHECK_LE(2, popcnt(chunk_mask));
GOOGLE_DCHECK_GE(8, popcnt(chunk_mask));
if (cached_has_word_index != HasWordIndex(chunk.front())) {
cached_has_word_index = HasWordIndex(chunk.front());
format("cached_has_bits = $has_bits$[$1$];\n", cached_has_word_index);
}
format("if (cached_has_bits & 0x$1$u) {\n", chunk_mask_str);
format.Indent();
}
if (chunk_is_cold) {
format("if (!IsSplitMessageDefault()) {\n");
format.Indent();
}
if (memset_start) {
if (memset_start == memset_end) {
// For clarity, do not memset a single field.
field_generators_.get(memset_start)
.GenerateMessageClearingCode(printer);
} else {
GOOGLE_CHECK_EQ(chunk_is_cold, ShouldSplit(memset_start, options_));
GOOGLE_CHECK_EQ(chunk_is_cold, ShouldSplit(memset_end, options_));
format(
"::memset(&$1$, 0, static_cast<size_t>(\n"
" reinterpret_cast<char*>(&$2$) -\n"
" reinterpret_cast<char*>(&$1$)) + sizeof($2$));\n",
FieldMemberName(memset_start, chunk_is_cold),
FieldMemberName(memset_end, chunk_is_cold));
}
}
// Clear all non-zero-initializable fields in the chunk.
for (const auto& field : chunk) {
if (CanInitializeByZeroing(field)) continue;
// It's faster to just overwrite primitive types, but we should only
// clear strings and messages if they were set.
//
// TODO(kenton): Let the CppFieldGenerator decide this somehow.
bool have_enclosing_if =
HasBitIndex(field) != kNoHasbit &&
(field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE ||
field->cpp_type() == FieldDescriptor::CPPTYPE_STRING);
if (have_enclosing_if) {
PrintPresenceCheck(format, field, has_bit_indices_, printer,
&cached_has_word_index);
}
field_generators_.get(field).GenerateMessageClearingCode(printer);
if (have_enclosing_if) {
format.Outdent();
format("}\n");
}
}
if (chunk_is_cold) {
format.Outdent();
format("}\n");
}
if (have_outer_if) {
format.Outdent();
format("}\n");
}
if (cold_skipper.OnEndChunk(chunk_index, printer)) {
// Reset here as it may have been updated in just closed if statement.
cached_has_word_index = -1;
}
}
// Step 4: Unions.
for (auto oneof : OneOfRange(descriptor_)) {
format("clear_$1$();\n", oneof->name());
}
if (num_weak_fields_) {
format("$weak_field_map$.ClearAll();\n");
}
// We don't clear donated status.
if (!has_bit_indices_.empty()) {
// Step 5: Everything else.
format("$has_bits$.Clear();\n");
}
std::map<std::string, std::string> vars;
SetUnknownFieldsVariable(descriptor_, options_, &vars);
format.AddMap(vars);
format("_internal_metadata_.Clear<$unknown_fields_type$>();\n");
format.Outdent();
format("}\n");
}
void MessageGenerator::GenerateOneofClear(io::Printer* printer) {
// Generated function clears the active field and union case (e.g. foo_case_).
int i = 0;
for (auto oneof : OneOfRange(descriptor_)) {
Formatter format(printer, variables_);
format.Set("oneofname", oneof->name());
format(
"void $classname$::clear_$oneofname$() {\n"
"// @@protoc_insertion_point(one_of_clear_start:$full_name$)\n");
format.Indent();
format("switch ($oneofname$_case()) {\n");
format.Indent();
for (auto field : FieldRange(oneof)) {
format("case k$1$: {\n", UnderscoresToCamelCase(field->name(), true));
format.Indent();
// We clear only allocated objects in oneofs
if (!IsStringOrMessage(field) || IsFieldStripped(field, options_)) {
format("// No need to clear\n");
} else {
field_generators_.get(field).GenerateClearingCode(printer);
}
format("break;\n");
format.Outdent();
format("}\n");
}
format(
"case $1$_NOT_SET: {\n"
" break;\n"
"}\n",
ToUpper(oneof->name()));
format.Outdent();
format(
"}\n"
"$oneof_case$[$1$] = $2$_NOT_SET;\n",
i, ToUpper(oneof->name()));
format.Outdent();
format(
"}\n"
"\n");
i++;
}
}
void MessageGenerator::GenerateSwap(io::Printer* printer) {
if (HasSimpleBaseClass(descriptor_, options_)) return;
Formatter format(printer, variables_);
format("void $classname$::InternalSwap($classname$* other) {\n");
format.Indent();
format("using std::swap;\n");
if (HasGeneratedMethods(descriptor_->file(), options_)) {
if (descriptor_->extension_range_count() > 0) {
format(
"$extensions$.InternalSwap(&other->$extensions$);"
"\n");
}
std::map<std::string, std::string> vars;
SetUnknownFieldsVariable(descriptor_, options_, &vars);
format.AddMap(vars);
if (HasNonSplitOptionalString(descriptor_, options_)) {
format(
"auto* lhs_arena = GetArenaForAllocation();\n"
"auto* rhs_arena = other->GetArenaForAllocation();\n");
}
format("_internal_metadata_.InternalSwap(&other->_internal_metadata_);\n");
if (!has_bit_indices_.empty()) {
for (int i = 0; i < HasBitsSize(); ++i) {
format("swap($has_bits$[$1$], other->$has_bits$[$1$]);\n", i);
}
}
// If possible, we swap several fields at once, including padding.
const RunMap runs =
FindRuns(optimized_order_, [this](const FieldDescriptor* field) {
return !ShouldSplit(field, options_) &&
CanBeManipulatedAsRawBytes(field, options_, scc_analyzer_);
});
for (size_t i = 0; i < optimized_order_.size(); ++i) {
const FieldDescriptor* field = optimized_order_[i];
if (ShouldSplit(field, options_)) {
continue;
}
const auto it = runs.find(field);
// We only apply the memswap technique to runs of more than one field, as
// `swap(field_, other.field_)` is better than
// `memswap<...>(&field_, &other.field_)` for generated code readability.
if (it != runs.end() && it->second > 1) {
// Use a memswap, then skip run_length fields.
const size_t run_length = it->second;
const std::string first_field_name =
FieldMemberName(field, /*cold=*/false);
const std::string last_field_name = FieldMemberName(
optimized_order_[i + run_length - 1], /*cold=*/false);
format.Set("first", first_field_name);
format.Set("last", last_field_name);
format(
"::PROTOBUF_NAMESPACE_ID::internal::memswap<\n"
" PROTOBUF_FIELD_OFFSET($classname$, $last$)\n"
" + sizeof($classname$::$last$)\n"
" - PROTOBUF_FIELD_OFFSET($classname$, $first$)>(\n"
" reinterpret_cast<char*>(&$first$),\n"
" reinterpret_cast<char*>(&other->$first$));\n");
i += run_length - 1;
// ++i at the top of the loop.
} else {
field_generators_.get(field).GenerateSwappingCode(printer);
}
}
if (ShouldSplit(descriptor_, options_)) {
format("swap($split$, other->$split$);\n");
}
for (auto oneof : OneOfRange(descriptor_)) {
format("swap(_impl_.$1$_, other->_impl_.$1$_);\n", oneof->name());
}
for (int i = 0; i < descriptor_->real_oneof_decl_count(); i++) {
format("swap($oneof_case$[$1$], other->$oneof_case$[$1$]);\n", i);
}
if (num_weak_fields_) {
format(
"$weak_field_map$.UnsafeArenaSwap(&other->$weak_field_map$)"
";\n");
}
if (!inlined_string_indices_.empty()) {
for (size_t i = 0; i < InlinedStringDonatedSize(); ++i) {
format(
"swap($inlined_string_donated_array$[$1$], "
"other->$inlined_string_donated_array$[$1$]);\n",
i);
}
}
} else {
format("GetReflection()->Swap(this, other);");
}
format.Outdent();
format("}\n");
}
void MessageGenerator::GenerateMergeFrom(io::Printer* printer) {
Formatter format(printer, variables_);
if (!HasSimpleBaseClass(descriptor_, options_)) {
if (HasDescriptorMethods(descriptor_->file(), options_)) {
// We don't override the generalized MergeFrom (aka that which
// takes in the Message base class as a parameter); instead we just
// let the base Message::MergeFrom take care of it. The base MergeFrom
// knows how to quickly confirm the types exactly match, and if so, will
// use GetClassData() to retrieve the address of MergeImpl, which calls
// the fast MergeFrom overload. Most callers avoid all this by passing
// a "from" message that is the same type as the message being merged
// into, rather than a generic Message.
format(
"const ::$proto_ns$::Message::ClassData "
"$classname$::_class_data_ = {\n"
" ::$proto_ns$::Message::CopyWithSourceCheck,\n"
" $classname$::MergeImpl\n"
"};\n"
"const ::$proto_ns$::Message::ClassData*"
"$classname$::GetClassData() const { return &_class_data_; }\n"
"\n");
} else {
// Generate CheckTypeAndMergeFrom().
format(
"void $classname$::CheckTypeAndMergeFrom(\n"
" const ::$proto_ns$::MessageLite& from) {\n"
" MergeFrom(*::_pbi::DownCast<const $classname$*>(\n"
" &from));\n"
"}\n");
}
} else {
// In the simple case, we just define ClassData that vectors back to the
// simple implementation of Copy and Merge.
format(
"const ::$proto_ns$::Message::ClassData "
"$classname$::_class_data_ = {\n"
" $superclass$::CopyImpl,\n"
" $superclass$::MergeImpl,\n"
"};\n"
"const ::$proto_ns$::Message::ClassData*"
"$classname$::GetClassData() const { return &_class_data_; }\n"
"\n"
"\n");
}
}
void MessageGenerator::GenerateClassSpecificMergeImpl(io::Printer* printer) {
if (HasSimpleBaseClass(descriptor_, options_)) return;
// Generate the class-specific MergeFrom, which avoids the GOOGLE_CHECK and cast.
Formatter format(printer, variables_);
if (!HasDescriptorMethods(descriptor_->file(), options_)) {
// For messages that don't inherit from Message, just implement MergeFrom
// directly.
format(
"void $classname$::MergeFrom(const $classname$& from) {\n"
" $classname$* const _this = this;\n");
} else {
format(
"void $classname$::MergeImpl(::$proto_ns$::Message& to_msg, const "
"::$proto_ns$::Message& from_msg) {\n"
" auto* const _this = static_cast<$classname$*>(&to_msg);\n"
" auto& from = static_cast<const $classname$&>(from_msg);\n");
}
format.Indent();
format(
"$annotate_mergefrom$"
"// @@protoc_insertion_point(class_specific_merge_from_start:"
"$full_name$)\n");
format("$DCHK$_NE(&from, _this);\n");
format(
"$uint32$ cached_has_bits = 0;\n"
"(void) cached_has_bits;\n\n");
if (ShouldSplit(descriptor_, options_)) {
format(
"if (!from.IsSplitMessageDefault()) {\n"
" _this->PrepareSplitMessageForWrite();\n"
"}\n");
}
std::vector<std::vector<const FieldDescriptor*>> chunks = CollectFields(
optimized_order_,
[&](const FieldDescriptor* a, const FieldDescriptor* b) -> bool {
return HasByteIndex(a) == HasByteIndex(b) &&
ShouldSplit(a, options_) == ShouldSplit(b, options_);
});
ColdChunkSkipper cold_skipper(descriptor_, options_, chunks, has_bit_indices_,
kColdRatio);
// cached_has_word_index maintains that:
// cached_has_bits = from._has_bits_[cached_has_word_index]
// for cached_has_word_index >= 0
int cached_has_word_index = -1;
for (int chunk_index = 0; chunk_index < chunks.size(); chunk_index++) {
const std::vector<const FieldDescriptor*>& chunk = chunks[chunk_index];
bool have_outer_if =
chunk.size() > 1 && HasByteIndex(chunk.front()) != kNoHasbit;
cold_skipper.OnStartChunk(chunk_index, cached_has_word_index, "from.",
printer);
if (have_outer_if) {
// Emit an if() that will let us skip the whole chunk if none are set.
uint32_t chunk_mask = GenChunkMask(chunk, has_bit_indices_);
std::string chunk_mask_str =
StrCat(strings::Hex(chunk_mask, strings::ZERO_PAD_8));
// Check (up to) 8 has_bits at a time if we have more than one field in
// this chunk. Due to field layout ordering, we may check
// _has_bits_[last_chunk * 8 / 32] multiple times.
GOOGLE_DCHECK_LE(2, popcnt(chunk_mask));
GOOGLE_DCHECK_GE(8, popcnt(chunk_mask));
if (cached_has_word_index != HasWordIndex(chunk.front())) {
cached_has_word_index = HasWordIndex(chunk.front());
format("cached_has_bits = from.$has_bits$[$1$];\n",
cached_has_word_index);
}
format("if (cached_has_bits & 0x$1$u) {\n", chunk_mask_str);
format.Indent();
}
// Go back and emit merging code for each of the fields we processed.
bool deferred_has_bit_changes = false;
for (const auto field : chunk) {
const FieldGenerator& generator = field_generators_.get(field);
if (field->is_repeated()) {
generator.GenerateMergingCode(printer);
} else if (field->is_optional() && !HasHasbit(field)) {
// Merge semantics without true field presence: primitive fields are
// merged only if non-zero (numeric) or non-empty (string).
bool have_enclosing_if =
EmitFieldNonDefaultCondition(printer, "from.", field);
generator.GenerateMergingCode(printer);
if (have_enclosing_if) {
format.Outdent();
format("}\n");
}
} else if (field->options().weak() ||
cached_has_word_index != HasWordIndex(field)) {
// Check hasbit, not using cached bits.
GOOGLE_CHECK(HasHasbit(field));
format("if (from._internal_has_$1$()) {\n", FieldName(field));
format.Indent();
generator.GenerateMergingCode(printer);
format.Outdent();
format("}\n");
} else {
// Check hasbit, using cached bits.
GOOGLE_CHECK(HasHasbit(field));
int has_bit_index = has_bit_indices_[field->index()];
const std::string mask = StrCat(
strings::Hex(1u << (has_bit_index % 32), strings::ZERO_PAD_8));
format("if (cached_has_bits & 0x$1$u) {\n", mask);
format.Indent();
if (have_outer_if && IsPOD(field)) {
// Defer hasbit modification until the end of chunk.
// This can reduce the number of loads/stores by up to 7 per 8 fields.
deferred_has_bit_changes = true;
generator.GenerateCopyConstructorCode(printer);
} else {
generator.GenerateMergingCode(printer);
}
format.Outdent();
format("}\n");
}
}
if (have_outer_if) {
if (deferred_has_bit_changes) {
// Flush the has bits for the primitives we deferred.
GOOGLE_CHECK_LE(0, cached_has_word_index);
format("_this->$has_bits$[$1$] |= cached_has_bits;\n",
cached_has_word_index);
}
format.Outdent();
format("}\n");
}
if (cold_skipper.OnEndChunk(chunk_index, printer)) {
// Reset here as it may have been updated in just closed if statement.
cached_has_word_index = -1;
}
}
// Merge oneof fields. Oneof field requires oneof case check.
for (auto oneof : OneOfRange(descriptor_)) {
format("switch (from.$1$_case()) {\n", oneof->name());
format.Indent();
for (auto field : FieldRange(oneof)) {
format("case k$1$: {\n", UnderscoresToCamelCase(field->name(), true));
format.Indent();
if (!IsFieldStripped(field, options_)) {
field_generators_.get(field).GenerateMergingCode(printer);
}
format("break;\n");
format.Outdent();
format("}\n");
}
format(
"case $1$_NOT_SET: {\n"
" break;\n"
"}\n",
ToUpper(oneof->name()));
format.Outdent();
format("}\n");
}
if (num_weak_fields_) {
format(
"_this->$weak_field_map$.MergeFrom(from.$weak_field_map$);"
"\n");
}
// Merging of extensions and unknown fields is done last, to maximize
// the opportunity for tail calls.
if (descriptor_->extension_range_count() > 0) {
format(
"_this->$extensions$.MergeFrom(internal_default_instance(), "
"from.$extensions$);\n");
}
format(
"_this->_internal_metadata_.MergeFrom<$unknown_fields_type$>(from._"
"internal_"
"metadata_);\n");
format.Outdent();
format("}\n");
}
void MessageGenerator::GenerateCopyFrom(io::Printer* printer) {
if (HasSimpleBaseClass(descriptor_, options_)) return;
Formatter format(printer, variables_);
if (HasDescriptorMethods(descriptor_->file(), options_)) {
// We don't override the generalized CopyFrom (aka that which
// takes in the Message base class as a parameter); instead we just
// let the base Message::CopyFrom take care of it. The base MergeFrom
// knows how to quickly confirm the types exactly match, and if so, will
// use GetClassData() to get the address of Message::CopyWithSourceCheck,
// which calls Clear() and then MergeFrom(), as well as making sure that
// clearing the destination message doesn't alter the source, when in debug
// builds. Most callers avoid this by passing a "from" message that is the
// same type as the message being merged into, rather than a generic
// Message.
}
// Generate the class-specific CopyFrom.
format(
"void $classname$::CopyFrom(const $classname$& from) {\n"
"// @@protoc_insertion_point(class_specific_copy_from_start:"
"$full_name$)\n");
format.Indent();
format("if (&from == this) return;\n");
if (!options_.opensource_runtime && HasMessageFieldOrExtension(descriptor_)) {
// This check is disabled in the opensource release because we're
// concerned that many users do not define NDEBUG in their release builds.
// It is also disabled if a message has neither message fields nor
// extensions, as it's impossible to copy from its descendant.
//
// Note that FailIfCopyFromDescendant is implemented by reflection and not
// available for lite runtime. In that case, check if the size of the source
// has changed after Clear.
format("#ifndef NDEBUG\n");
if (HasDescriptorMethods(descriptor_->file(), options_)) {
format("FailIfCopyFromDescendant(*this, from);\n");
} else {
format("size_t from_size = from.ByteSizeLong();\n");
}
format(
"#endif\n"
"Clear();\n");
if (!HasDescriptorMethods(descriptor_->file(), options_)) {
format(
"#ifndef NDEBUG\n"
"$CHK$_EQ(from_size, from.ByteSizeLong())\n"
" << \"Source of CopyFrom changed when clearing target. Either \"\n"
" \"source is a nested message in target (not allowed), or \"\n"
" \"another thread is modifying the source.\";\n"
"#endif\n");
}
} else {
format("Clear();\n");
}
format("MergeFrom(from);\n");
format.Outdent();
format("}\n");
}
void MessageGenerator::GenerateVerify(io::Printer* printer) {
}
void MessageGenerator::GenerateSerializeOneofFields(
io::Printer* printer, const std::vector<const FieldDescriptor*>& fields) {
Formatter format(printer, variables_);
GOOGLE_CHECK(!fields.empty());
if (fields.size() == 1) {
GenerateSerializeOneField(printer, fields[0], -1);
return;
}
// We have multiple mutually exclusive choices. Emit a switch statement.
const OneofDescriptor* oneof = fields[0]->containing_oneof();
format("switch ($1$_case()) {\n", oneof->name());
format.Indent();
for (auto field : fields) {
format("case k$1$: {\n", UnderscoresToCamelCase(field->name(), true));
format.Indent();
field_generators_.get(field).GenerateSerializeWithCachedSizesToArray(
printer);
format("break;\n");
format.Outdent();
format("}\n");
}
format.Outdent();
// Doing nothing is an option.
format(
" default: ;\n"
"}\n");
}
void MessageGenerator::GenerateSerializeOneField(io::Printer* printer,
const FieldDescriptor* field,
int cached_has_bits_index) {
Formatter format(printer, variables_);
if (!field->options().weak()) {
// For weakfields, PrintFieldComment is called during iteration.
PrintFieldComment(format, field);
}
bool have_enclosing_if = false;
if (field->options().weak()) {
} else if (HasHasbit(field)) {
// Attempt to use the state of cached_has_bits, if possible.
int has_bit_index = HasBitIndex(field);
if (cached_has_bits_index == has_bit_index / 32) {
const std::string mask =
StrCat(strings::Hex(1u << (has_bit_index % 32), strings::ZERO_PAD_8));
format("if (cached_has_bits & 0x$1$u) {\n", mask);
} else {
format("if (_internal_has_$1$()) {\n", FieldName(field));
}
format.Indent();
have_enclosing_if = true;
} else if (field->is_optional() && !HasHasbit(field)) {
have_enclosing_if = EmitFieldNonDefaultCondition(printer, "this->", field);
}
field_generators_.get(field).GenerateSerializeWithCachedSizesToArray(printer);
if (have_enclosing_if) {
format.Outdent();
format("}\n");
}
format("\n");
}
void MessageGenerator::GenerateSerializeOneExtensionRange(
io::Printer* printer, const Descriptor::ExtensionRange* range) {
std::map<std::string, std::string> vars = variables_;
vars["start"] = StrCat(range->start);
vars["end"] = StrCat(range->end);
Formatter format(printer, vars);
format("// Extension range [$start$, $end$)\n");
format(
"target = $extensions$._InternalSerialize(\n"
"internal_default_instance(), $start$, $end$, target, stream);\n\n");
}
void MessageGenerator::GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) {
if (HasSimpleBaseClass(descriptor_, options_)) return;
Formatter format(printer, variables_);
if (descriptor_->options().message_set_wire_format()) {
// Special-case MessageSet.
format(
"$uint8$* $classname$::_InternalSerialize(\n"
" $uint8$* target, ::$proto_ns$::io::EpsCopyOutputStream* stream) "
"const {\n"
"$annotate_serialize$"
" target = $extensions$."
"InternalSerializeMessageSetWithCachedSizesToArray(\n" //
"internal_default_instance(), target, stream);\n");
std::map<std::string, std::string> vars;
SetUnknownFieldsVariable(descriptor_, options_, &vars);
format.AddMap(vars);
format(
" target = ::_pbi::"
"InternalSerializeUnknownMessageSetItemsToArray(\n"
" $unknown_fields$, target, stream);\n");
format(
" return target;\n"
"}\n");
return;
}
format(
"$uint8$* $classname$::_InternalSerialize(\n"
" $uint8$* target, ::$proto_ns$::io::EpsCopyOutputStream* stream) "
"const {\n"
"$annotate_serialize$");
format.Indent();
format("// @@protoc_insertion_point(serialize_to_array_start:$full_name$)\n");
if (!ShouldSerializeInOrder(descriptor_, options_)) {
format.Outdent();
format("#ifdef NDEBUG\n");
format.Indent();
}
GenerateSerializeWithCachedSizesBody(printer);
if (!ShouldSerializeInOrder(descriptor_, options_)) {
format.Outdent();
format("#else // NDEBUG\n");
format.Indent();
GenerateSerializeWithCachedSizesBodyShuffled(printer);
format.Outdent();
format("#endif // !NDEBUG\n");
format.Indent();
}
format("// @@protoc_insertion_point(serialize_to_array_end:$full_name$)\n");
format.Outdent();
format(
" return target;\n"
"}\n");
}
void MessageGenerator::GenerateSerializeWithCachedSizesBody(
io::Printer* printer) {
if (HasSimpleBaseClass(descriptor_, options_)) return;
Formatter format(printer, variables_);
// If there are multiple fields in a row from the same oneof then we
// coalesce them and emit a switch statement. This is more efficient
// because it lets the C++ compiler know this is a "at most one can happen"
// situation. If we emitted "if (has_x()) ...; if (has_y()) ..." the C++
// compiler's emitted code might check has_y() even when has_x() is true.
class LazySerializerEmitter {
public:
LazySerializerEmitter(MessageGenerator* mg, io::Printer* printer)
: mg_(mg),
format_(printer),
eager_(IsProto3(mg->descriptor_->file())),
cached_has_bit_index_(kNoHasbit) {}
~LazySerializerEmitter() { Flush(); }
// If conditions allow, try to accumulate a run of fields from the same
// oneof, and handle them at the next Flush().
void Emit(const FieldDescriptor* field) {
if (eager_ || MustFlush(field)) {
Flush();
}
if (!field->real_containing_oneof()) {
// TODO(ckennelly): Defer non-oneof fields similarly to oneof fields.
if (!field->options().weak() && !field->is_repeated() && !eager_) {
// We speculatively load the entire _has_bits_[index] contents, even
// if it is for only one field. Deferring non-oneof emitting would
// allow us to determine whether this is going to be useful.
int has_bit_index = mg_->has_bit_indices_[field->index()];
if (cached_has_bit_index_ != has_bit_index / 32) {
// Reload.
int new_index = has_bit_index / 32;
format_("cached_has_bits = _impl_._has_bits_[$1$];\n", new_index);
cached_has_bit_index_ = new_index;
}
}
mg_->GenerateSerializeOneField(format_.printer(), field,
cached_has_bit_index_);
} else {
v_.push_back(field);
}
}
void EmitIfNotNull(const FieldDescriptor* field) {
if (field != nullptr) {
Emit(field);
}
}
void Flush() {
if (!v_.empty()) {
mg_->GenerateSerializeOneofFields(format_.printer(), v_);
v_.clear();
}
}
private:
// If we have multiple fields in v_ then they all must be from the same
// oneof. Would adding field to v_ break that invariant?
bool MustFlush(const FieldDescriptor* field) {
return !v_.empty() &&
v_[0]->containing_oneof() != field->containing_oneof();
}
MessageGenerator* mg_;
Formatter format_;
const bool eager_;
std::vector<const FieldDescriptor*> v_;
// cached_has_bit_index_ maintains that:
// cached_has_bits = from._has_bits_[cached_has_bit_index_]
// for cached_has_bit_index_ >= 0
int cached_has_bit_index_;
};
class LazyExtensionRangeEmitter {
public:
LazyExtensionRangeEmitter(MessageGenerator* mg, io::Printer* printer)
: mg_(mg), format_(printer) {}
void AddToRange(const Descriptor::ExtensionRange* range) {
if (!has_current_range_) {
current_combined_range_ = *range;
has_current_range_ = true;
} else {
current_combined_range_.start =
std::min(current_combined_range_.start, range->start);
current_combined_range_.end =
std::max(current_combined_range_.end, range->end);
}
}
void Flush() {
if (has_current_range_) {
mg_->GenerateSerializeOneExtensionRange(format_.printer(),
&current_combined_range_);
}
has_current_range_ = false;
}
private:
MessageGenerator* mg_;
Formatter format_;
bool has_current_range_ = false;
Descriptor::ExtensionRange current_combined_range_;
};
// We need to track the largest weak field, because weak fields are serialized
// differently than normal fields. The WeakFieldMap::FieldWriter will
// serialize all weak fields that are ordinally between the last serialized
// weak field and the current field. In order to guarantee that all weak
// fields are serialized, we need to make sure to emit the code to serialize
// the largest weak field present at some point.
class LargestWeakFieldHolder {
public:
const FieldDescriptor* Release() {
const FieldDescriptor* result = field_;
field_ = nullptr;
return result;
}
void ReplaceIfLarger(const FieldDescriptor* field) {
if (field_ == nullptr || field_->number() < field->number()) {
field_ = field;
}
}
private:
const FieldDescriptor* field_ = nullptr;
};
std::vector<const FieldDescriptor*> ordered_fields =
SortFieldsByNumber(descriptor_);
std::vector<const Descriptor::ExtensionRange*> sorted_extensions;
sorted_extensions.reserve(descriptor_->extension_range_count());
for (int i = 0; i < descriptor_->extension_range_count(); ++i) {
sorted_extensions.push_back(descriptor_->extension_range(i));
}
std::sort(sorted_extensions.begin(), sorted_extensions.end(),
ExtensionRangeSorter());
if (num_weak_fields_) {
format(
"::_pbi::WeakFieldMap::FieldWriter field_writer("
"$weak_field_map$);\n");
}
format(
"$uint32$ cached_has_bits = 0;\n"
"(void) cached_has_bits;\n\n");
// Merge the fields and the extension ranges, both sorted by field number.
{
LazySerializerEmitter e(this, printer);
LazyExtensionRangeEmitter re(this, printer);
LargestWeakFieldHolder largest_weak_field;
int i, j;
for (i = 0, j = 0;
i < ordered_fields.size() || j < sorted_extensions.size();) {
if ((j == sorted_extensions.size()) ||
(i < descriptor_->field_count() &&
ordered_fields[i]->number() < sorted_extensions[j]->start)) {
const FieldDescriptor* field = ordered_fields[i++];
if (IsFieldStripped(field, options_)) {
continue;
}
re.Flush();
if (field->options().weak()) {
largest_weak_field.ReplaceIfLarger(field);
PrintFieldComment(format, field);
} else {
e.EmitIfNotNull(largest_weak_field.Release());
e.Emit(field);
}
} else {
e.EmitIfNotNull(largest_weak_field.Release());
e.Flush();
re.AddToRange(sorted_extensions[j++]);
}
}
re.Flush();
e.EmitIfNotNull(largest_weak_field.Release());
}
std::map<std::string, std::string> vars;
SetUnknownFieldsVariable(descriptor_, options_, &vars);
format.AddMap(vars);
format("if (PROTOBUF_PREDICT_FALSE($have_unknown_fields$)) {\n");
format.Indent();
if (UseUnknownFieldSet(descriptor_->file(), options_)) {
format(
"target = "
"::_pbi::WireFormat::"
"InternalSerializeUnknownFieldsToArray(\n"
" $unknown_fields$, target, stream);\n");
} else {
format(
"target = stream->WriteRaw($unknown_fields$.data(),\n"
" static_cast<int>($unknown_fields$.size()), target);\n");
}
format.Outdent();
format("}\n");
}
void MessageGenerator::GenerateSerializeWithCachedSizesBodyShuffled(
io::Printer* printer) {
Formatter format(printer, variables_);
std::vector<const FieldDescriptor*> ordered_fields =
SortFieldsByNumber(descriptor_);
ordered_fields.erase(
std::remove_if(ordered_fields.begin(), ordered_fields.end(),
[this](const FieldDescriptor* f) {
return !IsFieldUsed(f, options_);
}),
ordered_fields.end());
std::vector<const Descriptor::ExtensionRange*> sorted_extensions;
sorted_extensions.reserve(descriptor_->extension_range_count());
for (int i = 0; i < descriptor_->extension_range_count(); ++i) {
sorted_extensions.push_back(descriptor_->extension_range(i));
}
std::sort(sorted_extensions.begin(), sorted_extensions.end(),
ExtensionRangeSorter());
int num_fields = ordered_fields.size() + sorted_extensions.size();
constexpr int kLargePrime = 1000003;
GOOGLE_CHECK_LT(num_fields, kLargePrime)
<< "Prime offset must be greater than the number of fields to ensure "
"those are coprime.";
if (num_weak_fields_) {
format(
"::_pbi::WeakFieldMap::FieldWriter field_writer("
"$weak_field_map$);\n");
}
format("for (int i = $1$; i >= 0; i-- ) {\n", num_fields - 1);
format.Indent();
format("switch(i) {\n");
format.Indent();
int index = 0;
for (const auto* f : ordered_fields) {
format("case $1$: {\n", index++);
format.Indent();
GenerateSerializeOneField(printer, f, -1);
format("break;\n");
format.Outdent();
format("}\n");
}
for (const auto* r : sorted_extensions) {
format("case $1$: {\n", index++);
format.Indent();
GenerateSerializeOneExtensionRange(printer, r);
format("break;\n");
format.Outdent();
format("}\n");
}
format(
"default: {\n"
" $DCHK$(false) << \"Unexpected index: \" << i;\n"
"}\n");
format.Outdent();
format("}\n");
format.Outdent();
format("}\n");
std::map<std::string, std::string> vars;
SetUnknownFieldsVariable(descriptor_, options_, &vars);
format.AddMap(vars);
format("if (PROTOBUF_PREDICT_FALSE($have_unknown_fields$)) {\n");
format.Indent();
if (UseUnknownFieldSet(descriptor_->file(), options_)) {
format(
"target = "
"::_pbi::WireFormat::"
"InternalSerializeUnknownFieldsToArray(\n"
" $unknown_fields$, target, stream);\n");
} else {
format(
"target = stream->WriteRaw($unknown_fields$.data(),\n"
" static_cast<int>($unknown_fields$.size()), target);\n");
}
format.Outdent();
format("}\n");
}
std::vector<uint32_t> MessageGenerator::RequiredFieldsBitMask() const {
const int array_size = HasBitsSize();
std::vector<uint32_t> masks(array_size, 0);
for (auto field : FieldRange(descriptor_)) {
if (!field->is_required()) {
continue;
}
const int has_bit_index = has_bit_indices_[field->index()];
masks[has_bit_index / 32] |= static_cast<uint32_t>(1)
<< (has_bit_index % 32);
}
return masks;
}
void MessageGenerator::GenerateByteSize(io::Printer* printer) {
if (HasSimpleBaseClass(descriptor_, options_)) return;
Formatter format(printer, variables_);
if (descriptor_->options().message_set_wire_format()) {
// Special-case MessageSet.
std::map<std::string, std::string> vars;
SetUnknownFieldsVariable(descriptor_, options_, &vars);
format.AddMap(vars);
format(
"size_t $classname$::ByteSizeLong() const {\n"
"$annotate_bytesize$"
"// @@protoc_insertion_point(message_set_byte_size_start:$full_name$)\n"
" size_t total_size = $extensions$.MessageSetByteSize();\n"
" if ($have_unknown_fields$) {\n"
" total_size += ::_pbi::\n"
" ComputeUnknownMessageSetItemsSize($unknown_fields$);\n"
" }\n"
" int cached_size = "
"::_pbi::ToCachedSize(total_size);\n"
" SetCachedSize(cached_size);\n"
" return total_size;\n"
"}\n");
return;
}
if (num_required_fields_ > 1) {
// Emit a function (rarely used, we hope) that handles the required fields
// by checking for each one individually.
format(
"size_t $classname$::RequiredFieldsByteSizeFallback() const {\n"
"// @@protoc_insertion_point(required_fields_byte_size_fallback_start:"
"$full_name$)\n");
format.Indent();
format("size_t total_size = 0;\n");
for (auto field : optimized_order_) {
if (field->is_required()) {
format(
"\n"
"if (_internal_has_$1$()) {\n",
FieldName(field));
format.Indent();
PrintFieldComment(format, field);
field_generators_.get(field).GenerateByteSize(printer);
format.Outdent();
format("}\n");
}
}
format(
"\n"
"return total_size;\n");
format.Outdent();
format("}\n");
}
format(
"size_t $classname$::ByteSizeLong() const {\n"
"$annotate_bytesize$"
"// @@protoc_insertion_point(message_byte_size_start:$full_name$)\n");
format.Indent();
format(
"size_t total_size = 0;\n"
"\n");
if (descriptor_->extension_range_count() > 0) {
format(
"total_size += $extensions$.ByteSize();\n"
"\n");
}
std::map<std::string, std::string> vars;
SetUnknownFieldsVariable(descriptor_, options_, &vars);
format.AddMap(vars);
// Handle required fields (if any). We expect all of them to be
// present, so emit one conditional that checks for that. If they are all
// present then the fast path executes; otherwise the slow path executes.
if (num_required_fields_ > 1) {
// The fast path works if all required fields are present.
const std::vector<uint32_t> masks_for_has_bits = RequiredFieldsBitMask();
format("if ($1$) { // All required fields are present.\n",
ConditionalToCheckBitmasks(masks_for_has_bits));
format.Indent();
// Oneof fields cannot be required, so optimized_order_ contains all of the
// fields that we need to potentially emit.
for (auto field : optimized_order_) {
if (!field->is_required()) continue;
PrintFieldComment(format, field);
field_generators_.get(field).GenerateByteSize(printer);
format("\n");
}
format.Outdent();
format(
"} else {\n" // the slow path
" total_size += RequiredFieldsByteSizeFallback();\n"
"}\n");
} else {
// num_required_fields_ <= 1: no need to be tricky
for (auto field : optimized_order_) {
if (!field->is_required()) continue;
PrintFieldComment(format, field);
format("if (_internal_has_$1$()) {\n", FieldName(field));
format.Indent();
field_generators_.get(field).GenerateByteSize(printer);
format.Outdent();
format("}\n");
}
}
std::vector<std::vector<const FieldDescriptor*>> chunks = CollectFields(
optimized_order_,
[&](const FieldDescriptor* a, const FieldDescriptor* b) -> bool {
return a->label() == b->label() && HasByteIndex(a) == HasByteIndex(b) &&
ShouldSplit(a, options_) == ShouldSplit(b, options_);
});
// Remove chunks with required fields.
chunks.erase(std::remove_if(chunks.begin(), chunks.end(), IsRequired),
chunks.end());
ColdChunkSkipper cold_skipper(descriptor_, options_, chunks, has_bit_indices_,
kColdRatio);
int cached_has_word_index = -1;
format(
"$uint32$ cached_has_bits = 0;\n"
"// Prevent compiler warnings about cached_has_bits being unused\n"
"(void) cached_has_bits;\n\n");
for (int chunk_index = 0; chunk_index < chunks.size(); chunk_index++) {
const std::vector<const FieldDescriptor*>& chunk = chunks[chunk_index];
const bool have_outer_if =
chunk.size() > 1 && HasWordIndex(chunk[0]) != kNoHasbit;
cold_skipper.OnStartChunk(chunk_index, cached_has_word_index, "", printer);
if (have_outer_if) {
// Emit an if() that will let us skip the whole chunk if none are set.
uint32_t chunk_mask = GenChunkMask(chunk, has_bit_indices_);
std::string chunk_mask_str =
StrCat(strings::Hex(chunk_mask, strings::ZERO_PAD_8));
// Check (up to) 8 has_bits at a time if we have more than one field in
// this chunk. Due to field layout ordering, we may check
// _has_bits_[last_chunk * 8 / 32] multiple times.
GOOGLE_DCHECK_LE(2, popcnt(chunk_mask));
GOOGLE_DCHECK_GE(8, popcnt(chunk_mask));
if (cached_has_word_index != HasWordIndex(chunk.front())) {
cached_has_word_index = HasWordIndex(chunk.front());
format("cached_has_bits = $has_bits$[$1$];\n", cached_has_word_index);
}
format("if (cached_has_bits & 0x$1$u) {\n", chunk_mask_str);
format.Indent();
}
// Go back and emit checks for each of the fields we processed.
for (int j = 0; j < chunk.size(); j++) {
const FieldDescriptor* field = chunk[j];
const FieldGenerator& generator = field_generators_.get(field);
bool have_enclosing_if = false;
bool need_extra_newline = false;
PrintFieldComment(format, field);
if (field->is_repeated()) {
// No presence check is required.
need_extra_newline = true;
} else if (HasHasbit(field)) {
PrintPresenceCheck(format, field, has_bit_indices_, printer,
&cached_has_word_index);
have_enclosing_if = true;
} else {
// Without field presence: field is serialized only if it has a
// non-default value.
have_enclosing_if =
EmitFieldNonDefaultCondition(printer, "this->", field);
}
generator.GenerateByteSize(printer);
if (have_enclosing_if) {
format.Outdent();
format(
"}\n"
"\n");
}
if (need_extra_newline) {
format("\n");
}
}
if (have_outer_if) {
format.Outdent();
format("}\n");
}
if (cold_skipper.OnEndChunk(chunk_index, printer)) {
// Reset here as it may have been updated in just closed if statement.
cached_has_word_index = -1;
}
}
// Fields inside a oneof don't use _has_bits_ so we count them in a separate
// pass.
for (auto oneof : OneOfRange(descriptor_)) {
format("switch ($1$_case()) {\n", oneof->name());
format.Indent();
for (auto field : FieldRange(oneof)) {
PrintFieldComment(format, field);
format("case k$1$: {\n", UnderscoresToCamelCase(field->name(), true));
format.Indent();
if (!IsFieldStripped(field, options_)) {
field_generators_.get(field).GenerateByteSize(printer);
}
format("break;\n");
format.Outdent();
format("}\n");
}
format(
"case $1$_NOT_SET: {\n"
" break;\n"
"}\n",
ToUpper(oneof->name()));
format.Outdent();
format("}\n");
}
if (num_weak_fields_) {
// TagSize + MessageSize
format("total_size += $weak_field_map$.ByteSizeLong();\n");
}
if (UseUnknownFieldSet(descriptor_->file(), options_)) {
// We go out of our way to put the computation of the uncommon path of
// unknown fields in tail position. This allows for better code generation
// of this function for simple protos.
format(
"return MaybeComputeUnknownFieldsSize(total_size, &$cached_size$);\n");
} else {
format("if (PROTOBUF_PREDICT_FALSE($have_unknown_fields$)) {\n");
format(" total_size += $unknown_fields$.size();\n");
format("}\n");
// We update _cached_size_ even though this is a const method. Because
// const methods might be called concurrently this needs to be atomic
// operations or the program is undefined. In practice, since any
// concurrent writes will be writing the exact same value, normal writes
// will work on all common processors. We use a dedicated wrapper class to
// abstract away the underlying atomic. This makes it easier on platforms
// where even relaxed memory order might have perf impact to replace it with
// ordinary loads and stores.
format(
"int cached_size = ::_pbi::ToCachedSize(total_size);\n"
"SetCachedSize(cached_size);\n"
"return total_size;\n");
}
format.Outdent();
format("}\n");
}
void MessageGenerator::GenerateIsInitialized(io::Printer* printer) {
if (HasSimpleBaseClass(descriptor_, options_)) return;
Formatter format(printer, variables_);
format("bool $classname$::IsInitialized() const {\n");
format.Indent();
if (descriptor_->extension_range_count() > 0) {
format(
"if (!$extensions$.IsInitialized()) {\n"
" return false;\n"
"}\n\n");
}
if (num_required_fields_ > 0) {
format(
"if (_Internal::MissingRequiredFields($has_bits$))"
" return false;\n");
}
// Now check that all non-oneof embedded messages are initialized.
for (auto field : optimized_order_) {
field_generators_.get(field).GenerateIsInitialized(printer);
}
if (num_weak_fields_) {
// For Weak fields.
format("if (!$weak_field_map$.IsInitialized()) return false;\n");
}
// Go through the oneof fields, emitting a switch if any might have required
// fields.
for (auto oneof : OneOfRange(descriptor_)) {
bool has_required_fields = false;
for (auto field : FieldRange(oneof)) {
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
!ShouldIgnoreRequiredFieldCheck(field, options_) &&
scc_analyzer_->HasRequiredFields(field->message_type())) {
has_required_fields = true;
break;
}
}
if (!has_required_fields) {
continue;
}
format("switch ($1$_case()) {\n", oneof->name());
format.Indent();
for (auto field : FieldRange(oneof)) {
format("case k$1$: {\n", UnderscoresToCamelCase(field->name(), true));
format.Indent();
if (!IsFieldStripped(field, options_)) {
field_generators_.get(field).GenerateIsInitialized(printer);
}
format("break;\n");
format.Outdent();
format("}\n");
}
format(
"case $1$_NOT_SET: {\n"
" break;\n"
"}\n",
ToUpper(oneof->name()));
format.Outdent();
format("}\n");
}
format.Outdent();
format(
" return true;\n"
"}\n");
}
} // namespace cpp
} // namespace compiler
} // namespace protobuf
} // namespace google
#include <thirdparty/protobuf/port_undef.inc>
Reference in New Issue View Git Blame Copy Permalink