cpp_parse_function_generator.cc

Go to the documentation of this file.

// 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.
 
#include <google/protobuf/compiler/cpp/cpp_parse_function_generator.h>
 
#include <algorithm>
#include <limits>
#include <string>
 
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
#include <google/protobuf/wire_format.h>
 
namespace google {
namespace protobuf {
namespace compiler {
namespace cpp {
 
namespace {
using google::protobuf::internal::TcFieldData;
using google::protobuf::internal::WireFormat;
using google::protobuf::internal::WireFormatLite;
 
std::vector<const FieldDescriptor*> GetOrderedFields(
    const Descriptor* descriptor, const Options& options) {
  std::vector<const FieldDescriptor*> ordered_fields;
  for (auto field : FieldRange(descriptor)) {
    if (!IsFieldStripped(field, options)) {
      ordered_fields.push_back(field);
    }
  }
  std::sort(ordered_fields.begin(), ordered_fields.end(),
            [](const FieldDescriptor* a, const FieldDescriptor* b) {
              return a->number() < b->number();
            });
  return ordered_fields;
}
 
bool HasInternalAccessors(const FieldOptions::CType ctype) {
  return ctype == FieldOptions::STRING || ctype == FieldOptions::CORD;
}
 
int TagSize(uint32_t field_number) {
  if (field_number < 16) return 1;
  GOOGLE_CHECK_LT(field_number, (1 << 14))
      << "coded tag for " << field_number << " too big for uint16_t";
  return 2;
}
 
const char* CodedTagType(int tag_size) {
  return tag_size == 1 ? "uint8_t" : "uint16_t";
}
 
const char* TagType(const FieldDescriptor* field) {
  return CodedTagType(TagSize(field->number()));
}
 
std::string TcParserName(const Options& options) {
  return StrCat("::", ProtobufNamespace(options),
                      "::internal::TcParser::");
}
 
std::string MessageTcParseFunctionName(const FieldDescriptor* field,
                                       const Options& options) {
  if (field->message_type()->field_count() == 0 ||
      !HasGeneratedMethods(field->message_type()->file(), options)) {
    // For files with `option optimize_for = CODE_SIZE`, or which derive from
    // `ZeroFieldsBase`, we need to call the `_InternalParse` function, because
    // there is no generated tailcall function. For tailcall parsing, this is
    // done by helpers in TcParser.
    return StrCat(TcParserName(options),
                        (field->is_repeated() ? "Repeated" : "Singular"),
                        "ParseMessage<",
                        QualifiedClassName(field->message_type()),  //
                        ", ", TagType(field), ">");
  }
  // This matches macros in generated_message_tctable_impl.h:
  return StrCat("PROTOBUF_TC_PARSE_",
                      (field->is_repeated() ? "REPEATED" : "SINGULAR"),
                      TagSize(field->number()), "(",
                      QualifiedClassName(field->message_type()), ")");
}
 
std::string FieldParseFunctionName(const FieldDescriptor* field,
                                   const Options& options);
 
}  // namespace
 
TailCallTableInfo::TailCallTableInfo(const Descriptor* descriptor,
                                     const Options& options,
                                     const std::vector<int>& has_bit_indices,
                                     MessageSCCAnalyzer* scc_analyzer) {
  std::vector<const FieldDescriptor*> ordered_fields =
      GetOrderedFields(descriptor, options);
 
  // The table size is rounded up to the nearest power of 2, clamping at 2^5.
  // Note that this is a naive approach: a better approach should only consider
  // table-eligible fields. We may also want to push rarely-encountered fields
  // into the fallback, to make the table smaller.
  table_size_log2 = ordered_fields.size() >= 16  ? 5
                    : ordered_fields.size() >= 8 ? 4
                    : ordered_fields.size() >= 4 ? 3
                    : ordered_fields.size() >= 2 ? 2
                                                 : 1;
  const unsigned table_size = 1 << table_size_log2;
 
  // Construct info for each possible entry. Fields that do not use table-driven
  // parsing will still have an entry that nominates the fallback function.
  fast_path_fields.resize(table_size);
 
  for (const auto* field : ordered_fields) {
    // Eagerly assume slow path. If we can handle this field on the fast path,
    // we will pop its entry from `fallback_fields`.
    fallback_fields.push_back(field);
 
    // Anything difficult slow path:
    if (field->is_map()) continue;
    if (field->real_containing_oneof()) continue;
    if (field->options().weak()) continue;
    if (IsImplicitWeakField(field, options, scc_analyzer)) continue;
    if (IsLazy(field, options, scc_analyzer)) continue;
 
    // The largest tag that can be read by the tailcall parser is two bytes
    // when varint-coded. This allows 14 bits for the numeric tag value:
    //   byte 0   byte 1
    //   1nnnnttt 0nnnnnnn
    //    ^^^^^^^  ^^^^^^^
    uint32_t tag = WireFormat::MakeTag(field);
    if (tag >= 1 << 14) {
      continue;
    } else if (tag >= 1 << 7) {
      tag = ((tag << 1) & 0x7F00) | 0x80 | (tag & 0x7F);
    }
    // The field index is determined by the low bits of the field number, where
    // the table size determines the width of the mask. The largest table
    // supported is 32 entries. The parse loop uses these bits directly, so that
    // the dispatch does not require arithmetic:
    //   byte 0   byte 1
    //   1nnnnttt 0nnnnnnn
    //   ^^^^^
    // This means that any field number that does not fit in the lower 4 bits
    // will always have the top bit of its table index asserted:
    uint32_t idx = (tag >> 3) & (table_size - 1);
    // If this entry in the table is already used, then this field will be
    // handled by the generated fallback function.
    if (!fast_path_fields[idx].func_name.empty()) continue;
 
    // Determine the hasbit mask for this field, if needed. (Note that fields
    // without hasbits use different parse functions.)
    int hasbit_idx;
    if (HasHasbit(field)) {
      hasbit_idx = has_bit_indices[field->index()];
      GOOGLE_CHECK_NE(-1, hasbit_idx) << field->DebugString();
      // The tailcall parser can only update the first 32 hasbits. If this
      // field's has-bit is beyond that, then it will need to be handled by the
      // fallback parse function.
      if (hasbit_idx >= 32) continue;
    } else {
      // The tailcall parser only ever syncs 32 has-bits, so if there is no
      // presence, set a bit that will not be used.
      hasbit_idx = 63;
    }
 
    // Determine the name of the fastpath parse function to use for this field.
    std::string name;
 
    switch (field->type()) {
      case FieldDescriptor::TYPE_MESSAGE:
        name = MessageTcParseFunctionName(field, options);
        break;
 
      case FieldDescriptor::TYPE_FIXED64:
      case FieldDescriptor::TYPE_FIXED32:
      case FieldDescriptor::TYPE_SFIXED64:
      case FieldDescriptor::TYPE_SFIXED32:
      case FieldDescriptor::TYPE_DOUBLE:
      case FieldDescriptor::TYPE_FLOAT:
      case FieldDescriptor::TYPE_INT64:
      case FieldDescriptor::TYPE_INT32:
      case FieldDescriptor::TYPE_UINT64:
      case FieldDescriptor::TYPE_UINT32:
      case FieldDescriptor::TYPE_SINT64:
      case FieldDescriptor::TYPE_SINT32:
      case FieldDescriptor::TYPE_BOOL:
        name = FieldParseFunctionName(field, options);
        break;
 
      case FieldDescriptor::TYPE_BYTES:
        if (field->options().ctype() == FieldOptions::STRING &&
            field->default_value_string().empty() &&
            !IsStringInlined(field, options)) {
          name = FieldParseFunctionName(field, options);
        }
        break;
 
      default:
        break;
    }
 
    if (name.empty()) {
      continue;
    }
    // This field made it into the fast path, so remove it from the fallback
    // fields and fill in the table entry.
    fallback_fields.pop_back();
    fast_path_fields[idx].func_name = name;
    fast_path_fields[idx].bits = TcFieldData(tag, hasbit_idx, 0);
    fast_path_fields[idx].field = field;
  }
 
  // If there are no fallback fields, and at most one extension range, the
  // parser can use a generic fallback function. Otherwise, a message-specific
  // fallback routine is needed.
  use_generated_fallback =
      !fallback_fields.empty() || descriptor->extension_range_count() > 1;
}
 
ParseFunctionGenerator::ParseFunctionGenerator(
    const Descriptor* descriptor, int max_has_bit_index,
    const std::vector<int>& has_bit_indices,
    const std::vector<int>& inlined_string_indices, const Options& options,
    MessageSCCAnalyzer* scc_analyzer,
    const std::map<std::string, std::string>& vars)
    : descriptor_(descriptor),
      scc_analyzer_(scc_analyzer),
      options_(options),
      variables_(vars),
      inlined_string_indices_(inlined_string_indices),
      num_hasbits_(max_has_bit_index) {
  if (should_generate_tctable()) {
    tc_table_info_.reset(new TailCallTableInfo(descriptor_, options_,
                                               has_bit_indices, scc_analyzer));
  }
  SetCommonVars(options_, &variables_);
  SetUnknownFieldsVariable(descriptor_, options_, &variables_);
  variables_["classname"] = ClassName(descriptor, false);
}
 
void ParseFunctionGenerator::GenerateMethodDecls(io::Printer* printer) {
  Formatter format(printer, variables_);
  if (should_generate_tctable()) {
    auto declare_function = [&format](const char* name,
                                      const std::string& guard) {
      if (!guard.empty()) {
        format.Outdent();
        format("#if $1$\n", guard);
        format.Indent();
      }
      format("static const char* $1$(PROTOBUF_TC_PARAM_DECL);\n", name);
      if (!guard.empty()) {
        format.Outdent();
        format("#endif  // $1$\n", guard);
        format.Indent();
      }
    };
    if (should_generate_guarded_tctable()) {
      format.Outdent();
      format("#ifdef PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED\n");
      format.Indent();
    }
    format("// The Tct_* functions are internal to the protobuf runtime:\n");
    // These guards are defined in port_def.inc:
    declare_function("Tct_ParseS1", "PROTOBUF_TC_STATIC_PARSE_SINGULAR1");
    declare_function("Tct_ParseS2", "PROTOBUF_TC_STATIC_PARSE_SINGULAR2");
    declare_function("Tct_ParseR1", "PROTOBUF_TC_STATIC_PARSE_REPEATED1");
    declare_function("Tct_ParseR2", "PROTOBUF_TC_STATIC_PARSE_REPEATED2");
    if (tc_table_info_->use_generated_fallback) {
      format.Outdent();
      format(
          " private:\n"
          "  ");
      declare_function("Tct_ParseFallback", "");
      format(" public:\n");
      format.Indent();
    }
    if (should_generate_guarded_tctable()) {
      format.Outdent();
      format("#endif\n");
      format.Indent();
    }
  }
  format(
      "const char* _InternalParse(const char* ptr, "
      "::$proto_ns$::internal::ParseContext* ctx) final;\n");
}
 
void ParseFunctionGenerator::GenerateMethodImpls(io::Printer* printer) {
  Formatter format(printer, variables_);
  bool need_parse_function = true;
  if (descriptor_->options().message_set_wire_format()) {
    // Special-case MessageSet.
    need_parse_function = false;
    format(
        "const char* $classname$::_InternalParse(const char* ptr,\n"
        "                  ::$proto_ns$::internal::ParseContext* ctx) {\n"
        "$annotate_deserialize$"
        "  return _extensions_.ParseMessageSet(ptr, \n"
        "      internal_default_instance(), &_internal_metadata_, ctx);\n"
        "}\n");
  }
  if (!should_generate_tctable()) {
    if (need_parse_function) {
      GenerateLoopingParseFunction(format);
    }
    return;
  }
  if (should_generate_guarded_tctable()) {
    format("#ifdef PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED\n\n");
  }
  if (need_parse_function) {
    GenerateTailcallParseFunction(format);
  }
  if (tc_table_info_->use_generated_fallback) {
    GenerateTailcallFallbackFunction(format);
  }
  GenerateTailcallFieldParseFunctions(format);
  if (should_generate_guarded_tctable()) {
    if (need_parse_function) {
      format("\n#else  // PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED\n\n");
      GenerateLoopingParseFunction(format);
    }
    format("\n#endif  // PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED\n");
  }
}
 
bool ParseFunctionGenerator::should_generate_tctable() const {
  if (options_.tctable_mode == Options::kTCTableNever) {
    return false;
  }
  return true;
}
 
void ParseFunctionGenerator::GenerateTailcallParseFunction(Formatter& format) {
  GOOGLE_CHECK(should_generate_tctable());
 
  // Generate an `_InternalParse` that starts the tail-calling loop.
  format(
      "const char* $classname$::_InternalParse(\n"
      "    const char* ptr, ::$proto_ns$::internal::ParseContext* ctx) {\n"
      "$annotate_deserialize$"
      "  ptr = ::$proto_ns$::internal::TcParser::ParseLoop(\n"
      "      this, ptr, ctx, &_table_.header);\n");
  format(
      "  return ptr;\n"
      "}\n\n");
}
 
void ParseFunctionGenerator::GenerateTailcallFallbackFunction(
    Formatter& format) {
  GOOGLE_CHECK(should_generate_tctable());
  format(
      "const char* $classname$::Tct_ParseFallback(PROTOBUF_TC_PARAM_DECL) {\n"
      "#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) return nullptr\n");
  format.Indent();
  format("auto* typed_msg = static_cast<$classname$*>(msg);\n");
 
  if (num_hasbits_ > 0) {
    // Sync hasbits
    format("typed_msg->_has_bits_[0] = hasbits;\n");
  }
 
  format.Set("msg", "typed_msg->");
  format.Set("this", "typed_msg");
  format.Set("has_bits", "typed_msg->_has_bits_");
  format.Set("next_tag", "goto next_tag");
  GenerateParseIterationBody(format, descriptor_,
                             tc_table_info_->fallback_fields);
 
  format.Outdent();
  format(
      "next_tag:\n"
      "message_done:\n"
      "  return ptr;\n"
      "#undef CHK_\n"
      "}\n");
}
 
void ParseFunctionGenerator::GenerateTailcallFieldParseFunctions(
    Formatter& format) {
  GOOGLE_CHECK(should_generate_tctable());
  // There are four cases where a tailcall target are needed for messages:
  //   {singular, repeated} x {1, 2}-byte tag
  struct {
    const char* type;
    int size;
  } const kTagLayouts[] = {
      {"uint8_t", 1},
      {"uint16_t", 2},
  };
  // Singular:
  for (const auto& layout : kTagLayouts) {
    // Guard macros are defined in port_def.inc.
    format(
        "#if PROTOBUF_TC_STATIC_PARSE_SINGULAR$1$\n"
        "const char* $classname$::Tct_ParseS$1$(PROTOBUF_TC_PARAM_DECL) {\n"
        "  if (PROTOBUF_PREDICT_FALSE(data.coded_tag<$2$>() != 0))\n"
        "    PROTOBUF_MUSTTAIL "
        "return table->fallback(PROTOBUF_TC_PARAM_PASS);\n"
        "  ptr += $1$;\n"
        "  hasbits |= (uint64_t{1} << data.hasbit_idx());\n"
        "  ::$proto_ns$::internal::TcParser::SyncHasbits"
        "(msg, hasbits, table);\n"
        "  auto& field = ::$proto_ns$::internal::TcParser::"
        "RefAt<$classtype$*>(msg, data.offset());\n"
        "  if (field == nullptr)\n"
        "    field = CreateMaybeMessage<$classtype$>(ctx->data().arena);\n"
        "  return ctx->ParseMessage(field, ptr);\n"
        "}\n"
        "#endif  // PROTOBUF_TC_STATIC_PARSE_SINGULAR$1$\n",
        layout.size, layout.type);
  }
  // Repeated:
  for (const auto& layout : kTagLayouts) {
    // Guard macros are defined in port_def.inc.
    format(
        "#if PROTOBUF_TC_STATIC_PARSE_REPEATED$1$\n"
        "const char* $classname$::Tct_ParseR$1$(PROTOBUF_TC_PARAM_DECL) {\n"
        "  if (PROTOBUF_PREDICT_FALSE(data.coded_tag<$2$>() != 0)) {\n"
        "    PROTOBUF_MUSTTAIL "
        "return table->fallback(PROTOBUF_TC_PARAM_PASS);\n"
        "  }\n"
        "  ptr += $1$;\n"
        "  auto& field = ::$proto_ns$::internal::TcParser::RefAt<"
        "::$proto_ns$::RepeatedPtrField<$classname$>>(msg, data.offset());\n"
        "  ::$proto_ns$::internal::TcParser::SyncHasbits"
        "(msg, hasbits, table);\n"
        "  ptr = ctx->ParseMessage(field.Add(), ptr);\n"
        "  return ptr;\n"
        "}\n"
        "#endif  // PROTOBUF_TC_STATIC_PARSE_REPEATED$1$\n",
        layout.size, layout.type);
  }
}
 
void ParseFunctionGenerator::GenerateDataDecls(io::Printer* printer) {
  if (!should_generate_tctable()) {
    return;
  }
  Formatter format(printer, variables_);
  if (should_generate_guarded_tctable()) {
    format.Outdent();
    format("#ifdef PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED\n");
    format.Indent();
  }
  format(
      "static const ::$proto_ns$::internal::TcParseTable<$1$>\n"
      "    _table_;\n",
      tc_table_info_->table_size_log2);
  if (should_generate_guarded_tctable()) {
    format.Outdent();
    format("#endif  // PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED\n");
    format.Indent();
  }
}
 
void ParseFunctionGenerator::GenerateDataDefinitions(io::Printer* printer) {
  if (!should_generate_tctable()) {
    return;
  }
  Formatter format(printer, variables_);
  if (should_generate_guarded_tctable()) {
    format("#ifdef PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED\n");
  }
  GenerateTailCallTable(format);
  if (should_generate_guarded_tctable()) {
    format("#endif  // PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED\n");
  }
}
 
void ParseFunctionGenerator::GenerateLoopingParseFunction(Formatter& format) {
  format(
      "const char* $classname$::_InternalParse(const char* ptr, "
      "::$proto_ns$::internal::ParseContext* ctx) {\n"
      "$annotate_deserialize$"
      "#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure\n");
  format.Indent();
  format.Set("msg", "");
  format.Set("this", "this");
  int hasbits_size = 0;
  if (num_hasbits_ > 0) {
    hasbits_size = (num_hasbits_ + 31) / 32;
  }
  // For now only optimize small hasbits.
  if (hasbits_size != 1) hasbits_size = 0;
  if (hasbits_size) {
    format("_Internal::HasBits has_bits{};\n");
    format.Set("has_bits", "has_bits");
  } else {
    format.Set("has_bits", "_has_bits_");
  }
  format.Set("next_tag", "continue");
  format("while (!ctx->Done(&ptr)) {\n");
  format.Indent();
 
  GenerateParseIterationBody(format, descriptor_,
                             GetOrderedFields(descriptor_, options_));
 
  format.Outdent();
  format("}  // while\n");
 
  format.Outdent();
  format("message_done:\n");
  if (hasbits_size) format("  _has_bits_.Or(has_bits);\n");
 
  format(
      "  return ptr;\n"
      "failure:\n"
      "  ptr = nullptr;\n"
      "  goto message_done;\n"
      "#undef CHK_\n"
      "}\n");
}
 
void ParseFunctionGenerator::GenerateTailCallTable(Formatter& format) {
  GOOGLE_CHECK(should_generate_tctable());
  // All entries without a fast-path parsing function need a fallback.
  std::string fallback;
  if (tc_table_info_->use_generated_fallback) {
    fallback = ClassName(descriptor_) + "::Tct_ParseFallback";
  } else {
    fallback = TcParserName(options_) + "GenericFallback";
    if (GetOptimizeFor(descriptor_->file(), options_) ==
        FileOptions::LITE_RUNTIME) {
      fallback += "Lite";
    }
  }
 
  // For simplicity and speed, the table is not covering all proto
  // configurations. This model uses a fallback to cover all situations that
  // the table can't accommodate, together with unknown fields or extensions.
  // These are number of fields over 32, fields with 3 or more tag bytes,
  // maps, weak fields, lazy, more than 1 extension range. In the cases
  // the table is sufficient we can use a generic routine, that just handles
  // unknown fields and potentially an extension range.
  format(
      "const ::$proto_ns$::internal::TcParseTable<$1$>\n"
      "    $classname$::_table_ = {\n",
      tc_table_info_->table_size_log2);
  {
    auto table_scope = format.ScopedIndent();
    format("{\n");
    {
      auto header_scope = format.ScopedIndent();
      if (num_hasbits_ > 0 || IsMapEntryMessage(descriptor_)) {
        format("PROTOBUF_FIELD_OFFSET($classname$, _has_bits_),\n");
      } else {
        format("0,  // no _has_bits_\n");
      }
      if (descriptor_->extension_range_count() == 1) {
        format(
            "PROTOBUF_FIELD_OFFSET($classname$, _extensions_),\n"
            "$1$, $2$,  // extension_range_{low,high}\n",
            descriptor_->extension_range(0)->start,
            descriptor_->extension_range(0)->end);
      } else {
        format("0, 0, 0,  // no _extensions_\n");
      }
      format(
          "$1$, 0, $2$,  // fast_idx_mask, reserved, num_fields\n"
          "&$3$._instance,\n"
          "$4$  // fallback\n",
          (((1 << tc_table_info_->table_size_log2) - 1) << 3),
          descriptor_->field_count(),
          DefaultInstanceName(descriptor_, options_), fallback);
    }
    format("}, {\n");
    {
      auto fast_scope = format.ScopedIndent();
      GenerateFastFieldEntries(format, fallback);
    }
    format("},\n");  // entries[]
  }
  format("};\n\n");  // _table_
}
 
void ParseFunctionGenerator::GenerateFastFieldEntries(
    Formatter& format, const std::string& fallback) {
  for (const auto& info : tc_table_info_->fast_path_fields) {
    if (info.field != nullptr) {
      PrintFieldComment(format, info.field);
    }
    format("{$1$, ", info.func_name.empty() ? fallback : info.func_name);
    if (info.bits.data) {
      GOOGLE_DCHECK_NE(nullptr, info.field);
      format(
          "{$1$, $2$, "
          "static_cast<uint16_t>(PROTOBUF_FIELD_OFFSET($classname$, $3$_))}",
          info.bits.coded_tag(), info.bits.hasbit_idx(), FieldName(info.field));
    } else {
      format("{}");
    }
    format("},\n");
  }
}
 
void ParseFunctionGenerator::GenerateArenaString(Formatter& format,
                                                 const FieldDescriptor* field) {
  if (HasHasbit(field)) {
    format("_Internal::set_has_$1$(&$has_bits$);\n", FieldName(field));
  }
  std::string default_string =
      field->default_value_string().empty()
          ? "::" + ProtobufNamespace(options_) +
                "::internal::GetEmptyStringAlreadyInited()"
          : QualifiedClassName(field->containing_type(), options_) +
                "::" + MakeDefaultName(field) + ".get()";
  format(
      "if (arena != nullptr) {\n"
      "  ptr = ctx->ReadArenaString(ptr, &$msg$$name$_, arena");
  if (IsStringInlined(field, options_)) {
    GOOGLE_DCHECK(!inlined_string_indices_.empty());
    int inlined_string_index = inlined_string_indices_[field->index()];
    GOOGLE_DCHECK_GE(inlined_string_index, 0);
    format(
        ", $msg$_internal_$name$_donated()"
        ", &$msg$_inlined_string_donated_[$1$]"
        ", ~0x$2$u",
        inlined_string_index / 32,
        strings::Hex(1u << (inlined_string_index % 32), strings::ZERO_PAD_8));
  } else {
    GOOGLE_DCHECK(field->default_value_string().empty());
  }
  format(
      ");\n"
      "} else {\n"
      "  ptr = ::$proto_ns$::internal::InlineGreedyStringParser("
      "$msg$$name$_.MutableNoArenaNoDefault(&$1$), ptr, ctx);\n"
      "}\n"
      "const std::string* str = &$msg$$name$_.Get(); (void)str;\n",
      default_string);
}
 
void ParseFunctionGenerator::GenerateStrings(Formatter& format,
                                             const FieldDescriptor* field,
                                             bool check_utf8) {
  FieldOptions::CType ctype = FieldOptions::STRING;
  if (!options_.opensource_runtime) {
    // Open source doesn't support other ctypes;
    ctype = field->options().ctype();
  }
  if (!field->is_repeated() && !options_.opensource_runtime &&
      GetOptimizeFor(field->file(), options_) != FileOptions::LITE_RUNTIME &&
      // For now only use arena string for strings with empty defaults.
      field->default_value_string().empty() &&
      !field->real_containing_oneof() && ctype == FieldOptions::STRING) {
    GenerateArenaString(format, field);
  } else {
    std::string parser_name;
    switch (ctype) {
      case FieldOptions::STRING:
        parser_name = "GreedyStringParser";
        break;
      case FieldOptions::CORD:
        parser_name = "CordParser";
        break;
      case FieldOptions::STRING_PIECE:
        parser_name = "StringPieceParser";
        break;
    }
    format(
        "auto str = $msg$$1$$2$_$name$();\n"
        "ptr = ::$proto_ns$::internal::Inline$3$(str, ptr, ctx);\n",
        HasInternalAccessors(ctype) ? "_internal_" : "",
        field->is_repeated() && !field->is_packable() ? "add" : "mutable",
        parser_name);
  }
  if (!check_utf8) return;  // return if this is a bytes field
  auto level = GetUtf8CheckMode(field, options_);
  switch (level) {
    case Utf8CheckMode::kNone:
      return;
    case Utf8CheckMode::kVerify:
      format("#ifndef NDEBUG\n");
      break;
    case Utf8CheckMode::kStrict:
      format("CHK_(");
      break;
  }
  std::string field_name;
  field_name = "nullptr";
  if (HasDescriptorMethods(field->file(), options_)) {
    field_name = StrCat("\"", field->full_name(), "\"");
  }
  format("::$proto_ns$::internal::VerifyUTF8(str, $1$)", field_name);
  switch (level) {
    case Utf8CheckMode::kNone:
      return;
    case Utf8CheckMode::kVerify:
      format(
          ";\n"
          "#endif  // !NDEBUG\n");
      break;
    case Utf8CheckMode::kStrict:
      format(");\n");
      break;
  }
}
 
void ParseFunctionGenerator::GenerateLengthDelim(Formatter& format,
                                                 const FieldDescriptor* field) {
  if (field->is_packable()) {
    if (field->type() == FieldDescriptor::TYPE_ENUM &&
        !HasPreservingUnknownEnumSemantics(field)) {
      std::string enum_type = QualifiedClassName(field->enum_type(), options_);
      format(
          "ptr = "
          "::$proto_ns$::internal::Packed$1$Parser<$unknown_fields_type$>("
          "$msg$_internal_mutable_$name$(), ptr, ctx, $2$_IsValid, "
          "&$msg$_internal_metadata_, $3$);\n",
          DeclaredTypeMethodName(field->type()), enum_type, field->number());
    } else {
      format(
          "ptr = ::$proto_ns$::internal::Packed$1$Parser("
          "$msg$_internal_mutable_$name$(), ptr, ctx);\n",
          DeclaredTypeMethodName(field->type()));
    }
  } else {
    auto field_type = field->type();
    switch (field_type) {
      case FieldDescriptor::TYPE_STRING:
        GenerateStrings(format, field, true /* utf8 */);
        break;
      case FieldDescriptor::TYPE_BYTES:
        GenerateStrings(format, field, false /* utf8 */);
        break;
      case FieldDescriptor::TYPE_MESSAGE: {
        if (field->is_map()) {
          const FieldDescriptor* val =
              field->message_type()->FindFieldByName("value");
          GOOGLE_CHECK(val);
          if (val->type() == FieldDescriptor::TYPE_ENUM &&
              !HasPreservingUnknownEnumSemantics(field)) {
            format(
                "auto object = "
                "::$proto_ns$::internal::InitEnumParseWrapper<"
                "$unknown_fields_type$>(&$msg$$name$_, $1$_IsValid, "
                "$2$, &$msg$_internal_metadata_);\n"
                "ptr = ctx->ParseMessage(&object, ptr);\n",
                QualifiedClassName(val->enum_type(), options_),
                field->number());
          } else {
            format("ptr = ctx->ParseMessage(&$msg$$name$_, ptr);\n");
          }
        } else if (IsLazy(field, options_, scc_analyzer_)) {
          if (field->real_containing_oneof()) {
            format(
                "if (!$msg$_internal_has_$name$()) {\n"
                "  $msg$clear_$1$();\n"
                "  $msg$$1$_.$name$_ = ::$proto_ns$::Arena::CreateMessage<\n"
                "      ::$proto_ns$::internal::LazyField>("
                "$msg$GetArenaForAllocation());\n"
                "  $msg$set_has_$name$();\n"
                "}\n"
                "auto* lazy_field = $msg$$1$_.$name$_;\n",
                field->containing_oneof()->name());
          } else if (HasHasbit(field)) {
            format(
                "_Internal::set_has_$name$(&$has_bits$);\n"
                "auto* lazy_field = &$msg$$name$_;\n");
          } else {
            format("auto* lazy_field = &$msg$$name$_;\n");
          }
          format(
              "::$proto_ns$::internal::LazyFieldParseHelper<\n"
              "  ::$proto_ns$::internal::LazyField> parse_helper(\n"
              "    $1$::default_instance(),\n"
              "    $msg$GetArenaForAllocation(), lazy_field);\n"
              "ptr = ctx->ParseMessage(&parse_helper, ptr);\n",
              FieldMessageTypeName(field, options_));
        } else if (IsImplicitWeakField(field, options_, scc_analyzer_)) {
          if (!field->is_repeated()) {
            format(
                "ptr = ctx->ParseMessage(_Internal::mutable_$name$($this$), "
                "ptr);\n");
          } else {
            format(
                "ptr = ctx->ParseMessage($msg$$name$_.AddWeak("
                "reinterpret_cast<const ::$proto_ns$::MessageLite*>($1$ptr_)"
                "), ptr);\n",
                QualifiedDefaultInstanceName(field->message_type(), options_));
          }
        } else if (IsWeak(field, options_)) {
          format(
              "{\n"
              "  auto* default_ = &reinterpret_cast<const Message&>($1$);\n"
              "  ptr = ctx->ParseMessage($msg$_weak_field_map_.MutableMessage("
              "$2$, default_), ptr);\n"
              "}\n",
              QualifiedDefaultInstanceName(field->message_type(), options_),
              field->number());
        } else {
          format(
              "ptr = ctx->ParseMessage($msg$_internal_$mutable_field$(), "
              "ptr);\n");
        }
        break;
      }
      default:
        GOOGLE_LOG(FATAL) << "Illegal combination for length delimited wiretype "
                   << " filed type is " << field->type();
    }
  }
}
 
static bool ShouldRepeat(const FieldDescriptor* descriptor,
                         WireFormatLite::WireType wiretype) {
  constexpr int kMaxTwoByteFieldNumber = 16 * 128;
  return descriptor->number() < kMaxTwoByteFieldNumber &&
         descriptor->is_repeated() &&
         (!descriptor->is_packable() ||
          wiretype != WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
}
 
void ParseFunctionGenerator::GenerateFieldBody(
    Formatter& format, WireFormatLite::WireType wiretype,
    const FieldDescriptor* field) {
  Formatter::SaveState formatter_state(&format);
  format.AddMap(
      {{"name", FieldName(field)},
       {"primitive_type", PrimitiveTypeName(options_, field->cpp_type())}});
  if (field->is_repeated()) {
    format.AddMap({{"put_field", StrCat("add_", FieldName(field))},
                   {"mutable_field", StrCat("add_", FieldName(field))}});
  } else {
    format.AddMap(
        {{"put_field", StrCat("set_", FieldName(field))},
         {"mutable_field", StrCat("mutable_", FieldName(field))}});
  }
  uint32_t tag = WireFormatLite::MakeTag(field->number(), wiretype);
  switch (wiretype) {
    case WireFormatLite::WIRETYPE_VARINT: {
      std::string type = PrimitiveTypeName(options_, field->cpp_type());
      if (field->type() == FieldDescriptor::TYPE_ENUM) {
        format.Set("enum_type",
                   QualifiedClassName(field->enum_type(), options_));
        format(
            "$uint64$ val = ::$proto_ns$::internal::ReadVarint64(&ptr);\n"
            "CHK_(ptr);\n");
        if (!HasPreservingUnknownEnumSemantics(field)) {
          format("if (PROTOBUF_PREDICT_TRUE($enum_type$_IsValid(val))) {\n");
          format.Indent();
        }
        format("$msg$_internal_$put_field$(static_cast<$enum_type$>(val));\n");
        if (!HasPreservingUnknownEnumSemantics(field)) {
          format.Outdent();
          format(
              "} else {\n"
              "  ::$proto_ns$::internal::WriteVarint("
              "$1$, val, $msg$mutable_unknown_fields());\n"
              "}\n",
              field->number());
        }
      } else {
        std::string size = (field->type() == FieldDescriptor::TYPE_INT32 ||
                            field->type() == FieldDescriptor::TYPE_SINT32 ||
                            field->type() == FieldDescriptor::TYPE_UINT32)
                               ? "32"
                               : "64";
        std::string zigzag;
        if ((field->type() == FieldDescriptor::TYPE_SINT32 ||
             field->type() == FieldDescriptor::TYPE_SINT64)) {
          zigzag = "ZigZag";
        }
        if (field->is_repeated() || field->real_containing_oneof()) {
          format(
              "$msg$_internal_$put_field$("
              "::$proto_ns$::internal::ReadVarint$1$$2$(&ptr));\n"
              "CHK_(ptr);\n",
              zigzag, size);
        } else {
          if (HasHasbit(field)) {
            format("_Internal::set_has_$name$(&$has_bits$);\n");
          }
          format(
              "$msg$$name$_ = ::$proto_ns$::internal::ReadVarint$1$$2$(&ptr);\n"
              "CHK_(ptr);\n",
              zigzag, size);
        }
      }
      break;
    }
    case WireFormatLite::WIRETYPE_FIXED32:
    case WireFormatLite::WIRETYPE_FIXED64: {
      if (field->is_repeated() || field->real_containing_oneof()) {
        format(
            "$msg$_internal_$put_field$("
            "::$proto_ns$::internal::UnalignedLoad<$primitive_type$>(ptr));\n"
            "ptr += sizeof($primitive_type$);\n");
      } else {
        if (HasHasbit(field)) {
          format("_Internal::set_has_$name$(&$has_bits$);\n");
        }
        format(
            "$msg$$name$_ = "
            "::$proto_ns$::internal::UnalignedLoad<$primitive_type$>(ptr);\n"
            "ptr += sizeof($primitive_type$);\n");
      }
      break;
    }
    case WireFormatLite::WIRETYPE_LENGTH_DELIMITED: {
      GenerateLengthDelim(format, field);
      format("CHK_(ptr);\n");
      break;
    }
    case WireFormatLite::WIRETYPE_START_GROUP: {
      format(
          "ptr = ctx->ParseGroup($msg$_internal_$mutable_field$(), ptr, $1$);\n"
          "CHK_(ptr);\n",
          tag);
      break;
    }
    case WireFormatLite::WIRETYPE_END_GROUP: {
      GOOGLE_LOG(FATAL) << "Can't have end group field\n";
      break;
    }
  }  // switch (wire_type)
}
 
// Returns the tag for this field and in case of repeated packable fields,
// sets a fallback tag in fallback_tag_ptr.
static uint32_t ExpectedTag(const FieldDescriptor* field,
                            uint32_t* fallback_tag_ptr) {
  uint32_t expected_tag;
  if (field->is_packable()) {
    auto expected_wiretype = WireFormat::WireTypeForFieldType(field->type());
    expected_tag = WireFormatLite::MakeTag(field->number(), expected_wiretype);
    GOOGLE_CHECK(expected_wiretype != WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
    auto fallback_wiretype = WireFormatLite::WIRETYPE_LENGTH_DELIMITED;
    uint32_t fallback_tag =
        WireFormatLite::MakeTag(field->number(), fallback_wiretype);
 
    if (field->is_packed()) std::swap(expected_tag, fallback_tag);
    *fallback_tag_ptr = fallback_tag;
  } else {
    auto expected_wiretype = WireFormat::WireTypeForField(field);
    expected_tag = WireFormatLite::MakeTag(field->number(), expected_wiretype);
  }
  return expected_tag;
}
 
// These variables are used by the generated parse iteration, and must already
// be defined in the generated code:
// - `const char* ptr`: the input buffer.
// - `ParseContext* ctx`: the associated context for `ptr`.
// - implicit `this`: i.e., we must be in a non-static member function.
//
// The macro `CHK_(x)` must be defined. It should return an error condition if
// the macro parameter is false.
//
// Whenever an END_GROUP tag was read, or tag 0 was read, the generated code
// branches to the label `message_done`.
//
// These formatter variables are used:
// - `next_tag`: a single statement to begin parsing the next tag.
//
// At the end of the generated code, the enclosing function should proceed to
// parse the next tag in the stream.
void ParseFunctionGenerator::GenerateParseIterationBody(
    Formatter& format, const Descriptor* descriptor,
    const std::vector<const FieldDescriptor*>& ordered_fields) {
  format(
      "$uint32$ tag;\n"
      "ptr = ::$proto_ns$::internal::ReadTag(ptr, &tag);\n");
 
  if (!ordered_fields.empty()) {
    GenerateFieldSwitch(format, ordered_fields);
    // Each field `case` only considers field number. Field numbers that are
    // not defined in the message, or tags with an incompatible wire type, are
    // considered "unusual" cases. They will be handled by the logic below.
    format.Outdent();
    format("handle_unusual:\n");
    format.Indent();
  }
 
  // Unusual/extension/unknown case:
  format(
      "if ((tag == 0) || ((tag & 7) == 4)) {\n"
      "  CHK_(ptr);\n"
      "  ctx->SetLastTag(tag);\n"
      "  goto message_done;\n"
      "}\n");
  if (IsMapEntryMessage(descriptor)) {
    format("$next_tag$;\n");
  } else {
    if (descriptor->extension_range_count() > 0) {
      format("if (");
      for (int i = 0; i < descriptor->extension_range_count(); i++) {
        const Descriptor::ExtensionRange* range =
            descriptor->extension_range(i);
        if (i > 0) format(" ||\n    ");
 
        uint32_t start_tag = WireFormatLite::MakeTag(
            range->start, static_cast<WireFormatLite::WireType>(0));
        uint32_t end_tag = WireFormatLite::MakeTag(
            range->end, static_cast<WireFormatLite::WireType>(0));
 
        if (range->end > FieldDescriptor::kMaxNumber) {
          format("($1$u <= tag)", start_tag);
        } else {
          format("($1$u <= tag && tag < $2$u)", start_tag, end_tag);
        }
      }
      format(
          ") {\n"
          "  ptr = $msg$_extensions_.ParseField(tag, ptr, "
          "internal_default_instance(), &$msg$_internal_metadata_, ctx);\n"
          "  CHK_(ptr != nullptr);\n"
          "  $next_tag$;\n"
          "}\n");
    }
    format(
        "ptr = UnknownFieldParse(\n"
        "    tag,\n"
        "    $msg$_internal_metadata_.mutable_unknown_fields<"
        "$unknown_fields_type$>(),\n"
        "    ptr, ctx);\n"
        "CHK_(ptr != nullptr);\n");
  }
}
 
void ParseFunctionGenerator::GenerateFieldSwitch(
    Formatter& format,
    const std::vector<const FieldDescriptor*>& ordered_fields) {
  format("switch (tag >> 3) {\n");
  format.Indent();
 
  for (const auto* field : ordered_fields) {
    PrintFieldComment(format, field);
    format("case $1$:\n", field->number());
    format.Indent();
    uint32_t fallback_tag = 0;
    uint32_t expected_tag = ExpectedTag(field, &fallback_tag);
    format("if (PROTOBUF_PREDICT_TRUE(static_cast<$uint8$>(tag) == $1$)) {\n",
           expected_tag & 0xFF);
    format.Indent();
    auto wiretype = WireFormatLite::GetTagWireType(expected_tag);
    uint32_t tag = WireFormatLite::MakeTag(field->number(), wiretype);
    int tag_size = io::CodedOutputStream::VarintSize32(tag);
    bool is_repeat = ShouldRepeat(field, wiretype);
    if (is_repeat) {
      format(
          "ptr -= $1$;\n"
          "do {\n"
          "  ptr += $1$;\n",
          tag_size);
      format.Indent();
    }
    GenerateFieldBody(format, wiretype, field);
    if (is_repeat) {
      format.Outdent();
      format(
          "  if (!ctx->DataAvailable(ptr)) break;\n"
          "} while (::$proto_ns$::internal::ExpectTag<$1$>(ptr));\n",
          tag);
    }
    format.Outdent();
    if (fallback_tag) {
      format("} else if (static_cast<$uint8$>(tag) == $1$) {\n",
             fallback_tag & 0xFF);
      format.Indent();
      GenerateFieldBody(format, WireFormatLite::GetTagWireType(fallback_tag),
                        field);
      format.Outdent();
    }
    format(
        "} else\n"
        "  goto handle_unusual;\n"
        "$next_tag$;\n");
    format.Outdent();
  }  // for loop over ordered fields
 
  format(
      "default:\n"
      "  goto handle_unusual;\n");
  format.Outdent();
  format("}  // switch\n");
}
 
namespace {
 
std::string FieldParseFunctionName(const FieldDescriptor* field,
                                   const Options& options) {
  ParseCardinality card =  //
      field->is_packed()               ? ParseCardinality::kPacked
      : field->is_repeated()           ? ParseCardinality::kRepeated
      : field->real_containing_oneof() ? ParseCardinality::kOneof
                                       : ParseCardinality::kSingular;
 
  TypeFormat type_format;
  switch (field->type()) {
    case FieldDescriptor::TYPE_FIXED64:
    case FieldDescriptor::TYPE_SFIXED64:
    case FieldDescriptor::TYPE_DOUBLE:
      type_format = TypeFormat::kFixed64;
      break;
 
    case FieldDescriptor::TYPE_FIXED32:
    case FieldDescriptor::TYPE_SFIXED32:
    case FieldDescriptor::TYPE_FLOAT:
      type_format = TypeFormat::kFixed32;
      break;
 
    case FieldDescriptor::TYPE_INT64:
    case FieldDescriptor::TYPE_UINT64:
      type_format = TypeFormat::kVar64;
      break;
 
    case FieldDescriptor::TYPE_INT32:
    case FieldDescriptor::TYPE_UINT32:
      type_format = TypeFormat::kVar32;
      break;
 
    case FieldDescriptor::TYPE_SINT64:
      type_format = TypeFormat::kSInt64;
      break;
 
    case FieldDescriptor::TYPE_SINT32:
      type_format = TypeFormat::kSInt32;
      break;
 
    case FieldDescriptor::TYPE_BOOL:
      type_format = TypeFormat::kBool;
      break;
 
    case FieldDescriptor::TYPE_BYTES:
      type_format = TypeFormat::kBytes;
      break;
 
    case FieldDescriptor::TYPE_STRING:
      switch (GetUtf8CheckMode(field, options)) {
        case Utf8CheckMode::kNone:
          type_format = TypeFormat::kBytes;
          break;
        case Utf8CheckMode::kStrict:
          type_format = TypeFormat::kString;
          break;
        case Utf8CheckMode::kVerify:
          type_format = TypeFormat::kStringValidateOnly;
          break;
        default:
          GOOGLE_LOG(DFATAL) << "Mode not handled: "
                      << static_cast<int>(GetUtf8CheckMode(field, options));
          return "";
      }
      break;
 
    default:
      GOOGLE_LOG(DFATAL) << "Type not handled: " << field->DebugString();
      return "";
  }
 
  return "::" + ProtobufNamespace(options) + "::internal::TcParser::" +
         GetTailCallFieldHandlerName(card, type_format,
                                     TagSize(field->number()), options);
}
 
}  // namespace
 
std::string GetTailCallFieldHandlerName(ParseCardinality card,
                                        TypeFormat type_format,
                                        int tag_length_bytes,
                                        const Options& options) {
  std::string name;
 
  // The field implementation functions are prefixed by cardinality:
  //   `Singular` for optional or implicit fields.
  //   `Repeated` for non-packed repeated.
  //   `Packed` for packed repeated.
  switch (card) {
    case ParseCardinality::kSingular:
      name.append("Singular");
      break;
    case ParseCardinality::kOneof:
      name.append("Oneof");
      break;
    case ParseCardinality::kRepeated:
      name.append("Repeated");
      break;
    case ParseCardinality::kPacked:
      name.append("Packed");
      break;
  }
 
  // Next in the function name is the TypeFormat-specific name.
  switch (type_format) {
    case TypeFormat::kFixed64:
    case TypeFormat::kFixed32:
      name.append("Fixed");
      break;
 
    case TypeFormat::kVar64:
    case TypeFormat::kVar32:
    case TypeFormat::kSInt64:
    case TypeFormat::kSInt32:
    case TypeFormat::kBool:
      name.append("Varint");
      break;
 
    case TypeFormat::kBytes:
    case TypeFormat::kString:
    case TypeFormat::kStringValidateOnly:
      name.append("String");
      break;
 
    default:
      break;
  }
 
  name.append("<");
 
  // Determine the numeric layout type for the parser to use, independent of
  // the specific parsing logic used.
  switch (type_format) {
    case TypeFormat::kVar64:
    case TypeFormat::kFixed64:
      name.append("uint64_t, ");
      break;
 
    case TypeFormat::kSInt64:
      name.append("int64_t, ");
      break;
 
    case TypeFormat::kVar32:
    case TypeFormat::kFixed32:
      name.append("uint32_t, ");
      break;
 
    case TypeFormat::kSInt32:
      name.append("int32_t, ");
      break;
 
    case TypeFormat::kBool:
      name.append("bool, ");
      break;
 
    default:
      break;
  }
 
  name.append(CodedTagType(tag_length_bytes));
 
  switch (type_format) {
    case TypeFormat::kVar64:
    case TypeFormat::kVar32:
    case TypeFormat::kBool:
      StrAppend(&name, ", ", TcParserName(options), "kNoConversion");
      break;
 
    case TypeFormat::kSInt64:
    case TypeFormat::kSInt32:
      StrAppend(&name, ", ", TcParserName(options), "kZigZag");
      break;
 
    case TypeFormat::kBytes:
      StrAppend(&name, ", ", TcParserName(options), "kNoUtf8");
      break;
 
    case TypeFormat::kString:
      StrAppend(&name, ", ", TcParserName(options), "kUtf8");
      break;
 
    case TypeFormat::kStringValidateOnly:
      StrAppend(&name, ", ", TcParserName(options), "kUtf8ValidateOnly");
      break;
 
    default:
      break;
  }
 
  name.append(">");
  return name;
}
 
}  // namespace cpp
}  // namespace compiler
}  // namespace protobuf
}  // namespace google