1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/generic.proto
3 
4 #include "protos/perfetto/trace/ftrace/generic.pb.h"
5 
6 #include <algorithm>
7 #include <cstdint>
8 
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15 
16 PROTOBUF_PRAGMA_INIT_SEG
17 
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20 
21 namespace perfetto {
22 namespace protos {
GenericFtraceEvent_Field(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR GenericFtraceEvent_Field::GenericFtraceEvent_Field(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28   , /*decltype(_impl_.value_)*/{}
29   , /*decltype(_impl_._oneof_case_)*/{}} {}
30 struct GenericFtraceEvent_FieldDefaultTypeInternal {
GenericFtraceEvent_FieldDefaultTypeInternalperfetto::protos::GenericFtraceEvent_FieldDefaultTypeInternal31   PROTOBUF_CONSTEXPR GenericFtraceEvent_FieldDefaultTypeInternal()
32       : _instance(::_pbi::ConstantInitialized{}) {}
~GenericFtraceEvent_FieldDefaultTypeInternalperfetto::protos::GenericFtraceEvent_FieldDefaultTypeInternal33   ~GenericFtraceEvent_FieldDefaultTypeInternal() {}
34   union {  // NOLINT(misc-non-private-member-variables-in-classes)
35     GenericFtraceEvent_Field _instance;
36   };
37 };
38 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GenericFtraceEvent_FieldDefaultTypeInternal _GenericFtraceEvent_Field_default_instance_;
GenericFtraceEvent(::_pbi::ConstantInitialized)39 PROTOBUF_CONSTEXPR GenericFtraceEvent::GenericFtraceEvent(
40     ::_pbi::ConstantInitialized): _impl_{
41     /*decltype(_impl_._has_bits_)*/{}
42   , /*decltype(_impl_._cached_size_)*/{}
43   , /*decltype(_impl_.field_)*/{}
44   , /*decltype(_impl_.event_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
45 struct GenericFtraceEventDefaultTypeInternal {
GenericFtraceEventDefaultTypeInternalperfetto::protos::GenericFtraceEventDefaultTypeInternal46   PROTOBUF_CONSTEXPR GenericFtraceEventDefaultTypeInternal()
47       : _instance(::_pbi::ConstantInitialized{}) {}
~GenericFtraceEventDefaultTypeInternalperfetto::protos::GenericFtraceEventDefaultTypeInternal48   ~GenericFtraceEventDefaultTypeInternal() {}
49   union {  // NOLINT(misc-non-private-member-variables-in-classes)
50     GenericFtraceEvent _instance;
51   };
52 };
53 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GenericFtraceEventDefaultTypeInternal _GenericFtraceEvent_default_instance_;
KprobeEvent(::_pbi::ConstantInitialized)54 PROTOBUF_CONSTEXPR KprobeEvent::KprobeEvent(
55     ::_pbi::ConstantInitialized): _impl_{
56     /*decltype(_impl_._has_bits_)*/{}
57   , /*decltype(_impl_._cached_size_)*/{}
58   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
59   , /*decltype(_impl_.type_)*/0} {}
60 struct KprobeEventDefaultTypeInternal {
KprobeEventDefaultTypeInternalperfetto::protos::KprobeEventDefaultTypeInternal61   PROTOBUF_CONSTEXPR KprobeEventDefaultTypeInternal()
62       : _instance(::_pbi::ConstantInitialized{}) {}
~KprobeEventDefaultTypeInternalperfetto::protos::KprobeEventDefaultTypeInternal63   ~KprobeEventDefaultTypeInternal() {}
64   union {  // NOLINT(misc-non-private-member-variables-in-classes)
65     KprobeEvent _instance;
66   };
67 };
68 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KprobeEventDefaultTypeInternal _KprobeEvent_default_instance_;
69 }  // namespace protos
70 }  // namespace perfetto
71 namespace perfetto {
72 namespace protos {
KprobeEvent_KprobeType_IsValid(int value)73 bool KprobeEvent_KprobeType_IsValid(int value) {
74   switch (value) {
75     case 0:
76     case 1:
77     case 2:
78     case 3:
79       return true;
80     default:
81       return false;
82   }
83 }
84 
85 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> KprobeEvent_KprobeType_strings[4] = {};
86 
87 static const char KprobeEvent_KprobeType_names[] =
88   "KPROBE_TYPE_BEGIN"
89   "KPROBE_TYPE_END"
90   "KPROBE_TYPE_INSTANT"
91   "KPROBE_TYPE_UNKNOWN";
92 
93 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry KprobeEvent_KprobeType_entries[] = {
94   { {KprobeEvent_KprobeType_names + 0, 17}, 1 },
95   { {KprobeEvent_KprobeType_names + 17, 15}, 2 },
96   { {KprobeEvent_KprobeType_names + 32, 19}, 3 },
97   { {KprobeEvent_KprobeType_names + 51, 19}, 0 },
98 };
99 
100 static const int KprobeEvent_KprobeType_entries_by_number[] = {
101   3, // 0 -> KPROBE_TYPE_UNKNOWN
102   0, // 1 -> KPROBE_TYPE_BEGIN
103   1, // 2 -> KPROBE_TYPE_END
104   2, // 3 -> KPROBE_TYPE_INSTANT
105 };
106 
KprobeEvent_KprobeType_Name(KprobeEvent_KprobeType value)107 const std::string& KprobeEvent_KprobeType_Name(
108     KprobeEvent_KprobeType value) {
109   static const bool dummy =
110       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
111           KprobeEvent_KprobeType_entries,
112           KprobeEvent_KprobeType_entries_by_number,
113           4, KprobeEvent_KprobeType_strings);
114   (void) dummy;
115   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
116       KprobeEvent_KprobeType_entries,
117       KprobeEvent_KprobeType_entries_by_number,
118       4, value);
119   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
120                      KprobeEvent_KprobeType_strings[idx].get();
121 }
KprobeEvent_KprobeType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,KprobeEvent_KprobeType * value)122 bool KprobeEvent_KprobeType_Parse(
123     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, KprobeEvent_KprobeType* value) {
124   int int_value;
125   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
126       KprobeEvent_KprobeType_entries, 4, name, &int_value);
127   if (success) {
128     *value = static_cast<KprobeEvent_KprobeType>(int_value);
129   }
130   return success;
131 }
132 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
133 constexpr KprobeEvent_KprobeType KprobeEvent::KPROBE_TYPE_UNKNOWN;
134 constexpr KprobeEvent_KprobeType KprobeEvent::KPROBE_TYPE_BEGIN;
135 constexpr KprobeEvent_KprobeType KprobeEvent::KPROBE_TYPE_END;
136 constexpr KprobeEvent_KprobeType KprobeEvent::KPROBE_TYPE_INSTANT;
137 constexpr KprobeEvent_KprobeType KprobeEvent::KprobeType_MIN;
138 constexpr KprobeEvent_KprobeType KprobeEvent::KprobeType_MAX;
139 constexpr int KprobeEvent::KprobeType_ARRAYSIZE;
140 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
141 
142 // ===================================================================
143 
144 class GenericFtraceEvent_Field::_Internal {
145  public:
146   using HasBits = decltype(std::declval<GenericFtraceEvent_Field>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)147   static void set_has_name(HasBits* has_bits) {
148     (*has_bits)[0] |= 1u;
149   }
150 };
151 
GenericFtraceEvent_Field(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)152 GenericFtraceEvent_Field::GenericFtraceEvent_Field(::PROTOBUF_NAMESPACE_ID::Arena* arena,
153                          bool is_message_owned)
154   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
155   SharedCtor(arena, is_message_owned);
156   // @@protoc_insertion_point(arena_constructor:perfetto.protos.GenericFtraceEvent.Field)
157 }
GenericFtraceEvent_Field(const GenericFtraceEvent_Field & from)158 GenericFtraceEvent_Field::GenericFtraceEvent_Field(const GenericFtraceEvent_Field& from)
159   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
160   GenericFtraceEvent_Field* const _this = this; (void)_this;
161   new (&_impl_) Impl_{
162       decltype(_impl_._has_bits_){from._impl_._has_bits_}
163     , /*decltype(_impl_._cached_size_)*/{}
164     , decltype(_impl_.name_){}
165     , decltype(_impl_.value_){}
166     , /*decltype(_impl_._oneof_case_)*/{}};
167 
168   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
169   _impl_.name_.InitDefault();
170   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
171     _impl_.name_.Set("", GetArenaForAllocation());
172   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
173   if (from._internal_has_name()) {
174     _this->_impl_.name_.Set(from._internal_name(),
175       _this->GetArenaForAllocation());
176   }
177   clear_has_value();
178   switch (from.value_case()) {
179     case kStrValue: {
180       _this->_internal_set_str_value(from._internal_str_value());
181       break;
182     }
183     case kIntValue: {
184       _this->_internal_set_int_value(from._internal_int_value());
185       break;
186     }
187     case kUintValue: {
188       _this->_internal_set_uint_value(from._internal_uint_value());
189       break;
190     }
191     case VALUE_NOT_SET: {
192       break;
193     }
194   }
195   // @@protoc_insertion_point(copy_constructor:perfetto.protos.GenericFtraceEvent.Field)
196 }
197 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)198 inline void GenericFtraceEvent_Field::SharedCtor(
199     ::_pb::Arena* arena, bool is_message_owned) {
200   (void)arena;
201   (void)is_message_owned;
202   new (&_impl_) Impl_{
203       decltype(_impl_._has_bits_){}
204     , /*decltype(_impl_._cached_size_)*/{}
205     , decltype(_impl_.name_){}
206     , decltype(_impl_.value_){}
207     , /*decltype(_impl_._oneof_case_)*/{}
208   };
209   _impl_.name_.InitDefault();
210   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
211     _impl_.name_.Set("", GetArenaForAllocation());
212   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
213   clear_has_value();
214 }
215 
~GenericFtraceEvent_Field()216 GenericFtraceEvent_Field::~GenericFtraceEvent_Field() {
217   // @@protoc_insertion_point(destructor:perfetto.protos.GenericFtraceEvent.Field)
218   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
219   (void)arena;
220     return;
221   }
222   SharedDtor();
223 }
224 
SharedDtor()225 inline void GenericFtraceEvent_Field::SharedDtor() {
226   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
227   _impl_.name_.Destroy();
228   if (has_value()) {
229     clear_value();
230   }
231 }
232 
SetCachedSize(int size) const233 void GenericFtraceEvent_Field::SetCachedSize(int size) const {
234   _impl_._cached_size_.Set(size);
235 }
236 
clear_value()237 void GenericFtraceEvent_Field::clear_value() {
238 // @@protoc_insertion_point(one_of_clear_start:perfetto.protos.GenericFtraceEvent.Field)
239   switch (value_case()) {
240     case kStrValue: {
241       _impl_.value_.str_value_.Destroy();
242       break;
243     }
244     case kIntValue: {
245       // No need to clear
246       break;
247     }
248     case kUintValue: {
249       // No need to clear
250       break;
251     }
252     case VALUE_NOT_SET: {
253       break;
254     }
255   }
256   _impl_._oneof_case_[0] = VALUE_NOT_SET;
257 }
258 
259 
Clear()260 void GenericFtraceEvent_Field::Clear() {
261 // @@protoc_insertion_point(message_clear_start:perfetto.protos.GenericFtraceEvent.Field)
262   ::uint32_t cached_has_bits = 0;
263   // Prevent compiler warnings about cached_has_bits being unused
264   (void) cached_has_bits;
265 
266   cached_has_bits = _impl_._has_bits_[0];
267   if (cached_has_bits & 0x00000001u) {
268     _impl_.name_.ClearNonDefaultToEmpty();
269   }
270   clear_value();
271   _impl_._has_bits_.Clear();
272   _internal_metadata_.Clear<std::string>();
273 }
274 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)275 const char* GenericFtraceEvent_Field::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
276 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
277   _Internal::HasBits has_bits{};
278   while (!ctx->Done(&ptr)) {
279     ::uint32_t tag;
280     ptr = ::_pbi::ReadTag(ptr, &tag);
281     switch (tag >> 3) {
282       // optional string name = 1;
283       case 1:
284         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
285           auto str = _internal_mutable_name();
286           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
287           CHK_(ptr);
288         } else {
289           goto handle_unusual;
290         }
291         continue;
292       // string str_value = 3;
293       case 3:
294         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
295           auto str = _internal_mutable_str_value();
296           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
297           CHK_(ptr);
298         } else {
299           goto handle_unusual;
300         }
301         continue;
302       // int64 int_value = 4;
303       case 4:
304         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
305           _internal_set_int_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
306           CHK_(ptr);
307         } else {
308           goto handle_unusual;
309         }
310         continue;
311       // uint64 uint_value = 5;
312       case 5:
313         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
314           _internal_set_uint_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
315           CHK_(ptr);
316         } else {
317           goto handle_unusual;
318         }
319         continue;
320       default:
321         goto handle_unusual;
322     }  // switch
323   handle_unusual:
324     if ((tag == 0) || ((tag & 7) == 4)) {
325       CHK_(ptr);
326       ctx->SetLastTag(tag);
327       goto message_done;
328     }
329     ptr = UnknownFieldParse(
330         tag,
331         _internal_metadata_.mutable_unknown_fields<std::string>(),
332         ptr, ctx);
333     CHK_(ptr != nullptr);
334   }  // while
335 message_done:
336   _impl_._has_bits_.Or(has_bits);
337   return ptr;
338 failure:
339   ptr = nullptr;
340   goto message_done;
341 #undef CHK_
342 }
343 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const344 ::uint8_t* GenericFtraceEvent_Field::_InternalSerialize(
345     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
346   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.GenericFtraceEvent.Field)
347   ::uint32_t cached_has_bits = 0;
348   (void) cached_has_bits;
349 
350   cached_has_bits = _impl_._has_bits_[0];
351   // optional string name = 1;
352   if (cached_has_bits & 0x00000001u) {
353     target = stream->WriteStringMaybeAliased(
354         1, this->_internal_name(), target);
355   }
356 
357   switch (value_case()) {
358     case kStrValue: {
359       target = stream->WriteStringMaybeAliased(
360           3, this->_internal_str_value(), target);
361       break;
362     }
363     case kIntValue: {
364       target = stream->EnsureSpace(target);
365       target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_int_value(), target);
366       break;
367     }
368     case kUintValue: {
369       target = stream->EnsureSpace(target);
370       target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_uint_value(), target);
371       break;
372     }
373     default: ;
374   }
375   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
376     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
377         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
378   }
379   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.GenericFtraceEvent.Field)
380   return target;
381 }
382 
ByteSizeLong() const383 size_t GenericFtraceEvent_Field::ByteSizeLong() const {
384 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.GenericFtraceEvent.Field)
385   size_t total_size = 0;
386 
387   ::uint32_t cached_has_bits = 0;
388   // Prevent compiler warnings about cached_has_bits being unused
389   (void) cached_has_bits;
390 
391   // optional string name = 1;
392   cached_has_bits = _impl_._has_bits_[0];
393   if (cached_has_bits & 0x00000001u) {
394     total_size += 1 +
395       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
396         this->_internal_name());
397   }
398 
399   switch (value_case()) {
400     // string str_value = 3;
401     case kStrValue: {
402       total_size += 1 +
403         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
404           this->_internal_str_value());
405       break;
406     }
407     // int64 int_value = 4;
408     case kIntValue: {
409       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_int_value());
410       break;
411     }
412     // uint64 uint_value = 5;
413     case kUintValue: {
414       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_uint_value());
415       break;
416     }
417     case VALUE_NOT_SET: {
418       break;
419     }
420   }
421   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
422     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
423   }
424   int cached_size = ::_pbi::ToCachedSize(total_size);
425   SetCachedSize(cached_size);
426   return total_size;
427 }
428 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)429 void GenericFtraceEvent_Field::CheckTypeAndMergeFrom(
430     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
431   MergeFrom(*::_pbi::DownCast<const GenericFtraceEvent_Field*>(
432       &from));
433 }
434 
MergeFrom(const GenericFtraceEvent_Field & from)435 void GenericFtraceEvent_Field::MergeFrom(const GenericFtraceEvent_Field& from) {
436   GenericFtraceEvent_Field* const _this = this;
437   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.GenericFtraceEvent.Field)
438   GOOGLE_DCHECK_NE(&from, _this);
439   ::uint32_t cached_has_bits = 0;
440   (void) cached_has_bits;
441 
442   if (from._internal_has_name()) {
443     _this->_internal_set_name(from._internal_name());
444   }
445   switch (from.value_case()) {
446     case kStrValue: {
447       _this->_internal_set_str_value(from._internal_str_value());
448       break;
449     }
450     case kIntValue: {
451       _this->_internal_set_int_value(from._internal_int_value());
452       break;
453     }
454     case kUintValue: {
455       _this->_internal_set_uint_value(from._internal_uint_value());
456       break;
457     }
458     case VALUE_NOT_SET: {
459       break;
460     }
461   }
462   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
463 }
464 
CopyFrom(const GenericFtraceEvent_Field & from)465 void GenericFtraceEvent_Field::CopyFrom(const GenericFtraceEvent_Field& from) {
466 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.GenericFtraceEvent.Field)
467   if (&from == this) return;
468   Clear();
469   MergeFrom(from);
470 }
471 
IsInitialized() const472 bool GenericFtraceEvent_Field::IsInitialized() const {
473   return true;
474 }
475 
InternalSwap(GenericFtraceEvent_Field * other)476 void GenericFtraceEvent_Field::InternalSwap(GenericFtraceEvent_Field* other) {
477   using std::swap;
478   auto* lhs_arena = GetArenaForAllocation();
479   auto* rhs_arena = other->GetArenaForAllocation();
480   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
481   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
482   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
483       &_impl_.name_, lhs_arena,
484       &other->_impl_.name_, rhs_arena
485   );
486   swap(_impl_.value_, other->_impl_.value_);
487   swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
488 }
489 
GetTypeName() const490 std::string GenericFtraceEvent_Field::GetTypeName() const {
491   return "perfetto.protos.GenericFtraceEvent.Field";
492 }
493 
494 
495 // ===================================================================
496 
497 class GenericFtraceEvent::_Internal {
498  public:
499   using HasBits = decltype(std::declval<GenericFtraceEvent>()._impl_._has_bits_);
set_has_event_name(HasBits * has_bits)500   static void set_has_event_name(HasBits* has_bits) {
501     (*has_bits)[0] |= 1u;
502   }
503 };
504 
GenericFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)505 GenericFtraceEvent::GenericFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
506                          bool is_message_owned)
507   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
508   SharedCtor(arena, is_message_owned);
509   // @@protoc_insertion_point(arena_constructor:perfetto.protos.GenericFtraceEvent)
510 }
GenericFtraceEvent(const GenericFtraceEvent & from)511 GenericFtraceEvent::GenericFtraceEvent(const GenericFtraceEvent& from)
512   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
513   GenericFtraceEvent* const _this = this; (void)_this;
514   new (&_impl_) Impl_{
515       decltype(_impl_._has_bits_){from._impl_._has_bits_}
516     , /*decltype(_impl_._cached_size_)*/{}
517     , decltype(_impl_.field_){from._impl_.field_}
518     , decltype(_impl_.event_name_){}};
519 
520   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
521   _impl_.event_name_.InitDefault();
522   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
523     _impl_.event_name_.Set("", GetArenaForAllocation());
524   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
525   if (from._internal_has_event_name()) {
526     _this->_impl_.event_name_.Set(from._internal_event_name(),
527       _this->GetArenaForAllocation());
528   }
529   // @@protoc_insertion_point(copy_constructor:perfetto.protos.GenericFtraceEvent)
530 }
531 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)532 inline void GenericFtraceEvent::SharedCtor(
533     ::_pb::Arena* arena, bool is_message_owned) {
534   (void)arena;
535   (void)is_message_owned;
536   new (&_impl_) Impl_{
537       decltype(_impl_._has_bits_){}
538     , /*decltype(_impl_._cached_size_)*/{}
539     , decltype(_impl_.field_){arena}
540     , decltype(_impl_.event_name_){}
541   };
542   _impl_.event_name_.InitDefault();
543   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
544     _impl_.event_name_.Set("", GetArenaForAllocation());
545   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
546 }
547 
~GenericFtraceEvent()548 GenericFtraceEvent::~GenericFtraceEvent() {
549   // @@protoc_insertion_point(destructor:perfetto.protos.GenericFtraceEvent)
550   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
551   (void)arena;
552     return;
553   }
554   SharedDtor();
555 }
556 
SharedDtor()557 inline void GenericFtraceEvent::SharedDtor() {
558   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
559   _impl_.field_.~RepeatedPtrField();
560   _impl_.event_name_.Destroy();
561 }
562 
SetCachedSize(int size) const563 void GenericFtraceEvent::SetCachedSize(int size) const {
564   _impl_._cached_size_.Set(size);
565 }
566 
Clear()567 void GenericFtraceEvent::Clear() {
568 // @@protoc_insertion_point(message_clear_start:perfetto.protos.GenericFtraceEvent)
569   ::uint32_t cached_has_bits = 0;
570   // Prevent compiler warnings about cached_has_bits being unused
571   (void) cached_has_bits;
572 
573   _impl_.field_.Clear();
574   cached_has_bits = _impl_._has_bits_[0];
575   if (cached_has_bits & 0x00000001u) {
576     _impl_.event_name_.ClearNonDefaultToEmpty();
577   }
578   _impl_._has_bits_.Clear();
579   _internal_metadata_.Clear<std::string>();
580 }
581 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)582 const char* GenericFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
583 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
584   _Internal::HasBits has_bits{};
585   while (!ctx->Done(&ptr)) {
586     ::uint32_t tag;
587     ptr = ::_pbi::ReadTag(ptr, &tag);
588     switch (tag >> 3) {
589       // optional string event_name = 1;
590       case 1:
591         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
592           auto str = _internal_mutable_event_name();
593           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
594           CHK_(ptr);
595         } else {
596           goto handle_unusual;
597         }
598         continue;
599       // repeated .perfetto.protos.GenericFtraceEvent.Field field = 2;
600       case 2:
601         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
602           ptr -= 1;
603           do {
604             ptr += 1;
605             ptr = ctx->ParseMessage(_internal_add_field(), ptr);
606             CHK_(ptr);
607             if (!ctx->DataAvailable(ptr)) break;
608           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
609         } else {
610           goto handle_unusual;
611         }
612         continue;
613       default:
614         goto handle_unusual;
615     }  // switch
616   handle_unusual:
617     if ((tag == 0) || ((tag & 7) == 4)) {
618       CHK_(ptr);
619       ctx->SetLastTag(tag);
620       goto message_done;
621     }
622     ptr = UnknownFieldParse(
623         tag,
624         _internal_metadata_.mutable_unknown_fields<std::string>(),
625         ptr, ctx);
626     CHK_(ptr != nullptr);
627   }  // while
628 message_done:
629   _impl_._has_bits_.Or(has_bits);
630   return ptr;
631 failure:
632   ptr = nullptr;
633   goto message_done;
634 #undef CHK_
635 }
636 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const637 ::uint8_t* GenericFtraceEvent::_InternalSerialize(
638     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
639   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.GenericFtraceEvent)
640   ::uint32_t cached_has_bits = 0;
641   (void) cached_has_bits;
642 
643   cached_has_bits = _impl_._has_bits_[0];
644   // optional string event_name = 1;
645   if (cached_has_bits & 0x00000001u) {
646     target = stream->WriteStringMaybeAliased(
647         1, this->_internal_event_name(), target);
648   }
649 
650   // repeated .perfetto.protos.GenericFtraceEvent.Field field = 2;
651   for (unsigned i = 0,
652       n = static_cast<unsigned>(this->_internal_field_size()); i < n; i++) {
653     const auto& repfield = this->_internal_field(i);
654     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
655         InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
656   }
657 
658   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
659     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
660         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
661   }
662   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.GenericFtraceEvent)
663   return target;
664 }
665 
ByteSizeLong() const666 size_t GenericFtraceEvent::ByteSizeLong() const {
667 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.GenericFtraceEvent)
668   size_t total_size = 0;
669 
670   ::uint32_t cached_has_bits = 0;
671   // Prevent compiler warnings about cached_has_bits being unused
672   (void) cached_has_bits;
673 
674   // repeated .perfetto.protos.GenericFtraceEvent.Field field = 2;
675   total_size += 1UL * this->_internal_field_size();
676   for (const auto& msg : this->_impl_.field_) {
677     total_size +=
678       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
679   }
680 
681   // optional string event_name = 1;
682   cached_has_bits = _impl_._has_bits_[0];
683   if (cached_has_bits & 0x00000001u) {
684     total_size += 1 +
685       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
686         this->_internal_event_name());
687   }
688 
689   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
690     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
691   }
692   int cached_size = ::_pbi::ToCachedSize(total_size);
693   SetCachedSize(cached_size);
694   return total_size;
695 }
696 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)697 void GenericFtraceEvent::CheckTypeAndMergeFrom(
698     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
699   MergeFrom(*::_pbi::DownCast<const GenericFtraceEvent*>(
700       &from));
701 }
702 
MergeFrom(const GenericFtraceEvent & from)703 void GenericFtraceEvent::MergeFrom(const GenericFtraceEvent& from) {
704   GenericFtraceEvent* const _this = this;
705   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.GenericFtraceEvent)
706   GOOGLE_DCHECK_NE(&from, _this);
707   ::uint32_t cached_has_bits = 0;
708   (void) cached_has_bits;
709 
710   _this->_impl_.field_.MergeFrom(from._impl_.field_);
711   if (from._internal_has_event_name()) {
712     _this->_internal_set_event_name(from._internal_event_name());
713   }
714   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
715 }
716 
CopyFrom(const GenericFtraceEvent & from)717 void GenericFtraceEvent::CopyFrom(const GenericFtraceEvent& from) {
718 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.GenericFtraceEvent)
719   if (&from == this) return;
720   Clear();
721   MergeFrom(from);
722 }
723 
IsInitialized() const724 bool GenericFtraceEvent::IsInitialized() const {
725   return true;
726 }
727 
InternalSwap(GenericFtraceEvent * other)728 void GenericFtraceEvent::InternalSwap(GenericFtraceEvent* other) {
729   using std::swap;
730   auto* lhs_arena = GetArenaForAllocation();
731   auto* rhs_arena = other->GetArenaForAllocation();
732   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
733   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
734   _impl_.field_.InternalSwap(&other->_impl_.field_);
735   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
736       &_impl_.event_name_, lhs_arena,
737       &other->_impl_.event_name_, rhs_arena
738   );
739 }
740 
GetTypeName() const741 std::string GenericFtraceEvent::GetTypeName() const {
742   return "perfetto.protos.GenericFtraceEvent";
743 }
744 
745 
746 // ===================================================================
747 
748 class KprobeEvent::_Internal {
749  public:
750   using HasBits = decltype(std::declval<KprobeEvent>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)751   static void set_has_name(HasBits* has_bits) {
752     (*has_bits)[0] |= 1u;
753   }
set_has_type(HasBits * has_bits)754   static void set_has_type(HasBits* has_bits) {
755     (*has_bits)[0] |= 2u;
756   }
757 };
758 
KprobeEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)759 KprobeEvent::KprobeEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
760                          bool is_message_owned)
761   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
762   SharedCtor(arena, is_message_owned);
763   // @@protoc_insertion_point(arena_constructor:perfetto.protos.KprobeEvent)
764 }
KprobeEvent(const KprobeEvent & from)765 KprobeEvent::KprobeEvent(const KprobeEvent& from)
766   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
767   KprobeEvent* const _this = this; (void)_this;
768   new (&_impl_) Impl_{
769       decltype(_impl_._has_bits_){from._impl_._has_bits_}
770     , /*decltype(_impl_._cached_size_)*/{}
771     , decltype(_impl_.name_){}
772     , decltype(_impl_.type_){}};
773 
774   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
775   _impl_.name_.InitDefault();
776   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
777     _impl_.name_.Set("", GetArenaForAllocation());
778   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
779   if (from._internal_has_name()) {
780     _this->_impl_.name_.Set(from._internal_name(),
781       _this->GetArenaForAllocation());
782   }
783   _this->_impl_.type_ = from._impl_.type_;
784   // @@protoc_insertion_point(copy_constructor:perfetto.protos.KprobeEvent)
785 }
786 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)787 inline void KprobeEvent::SharedCtor(
788     ::_pb::Arena* arena, bool is_message_owned) {
789   (void)arena;
790   (void)is_message_owned;
791   new (&_impl_) Impl_{
792       decltype(_impl_._has_bits_){}
793     , /*decltype(_impl_._cached_size_)*/{}
794     , decltype(_impl_.name_){}
795     , decltype(_impl_.type_){0}
796   };
797   _impl_.name_.InitDefault();
798   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
799     _impl_.name_.Set("", GetArenaForAllocation());
800   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
801 }
802 
~KprobeEvent()803 KprobeEvent::~KprobeEvent() {
804   // @@protoc_insertion_point(destructor:perfetto.protos.KprobeEvent)
805   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
806   (void)arena;
807     return;
808   }
809   SharedDtor();
810 }
811 
SharedDtor()812 inline void KprobeEvent::SharedDtor() {
813   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
814   _impl_.name_.Destroy();
815 }
816 
SetCachedSize(int size) const817 void KprobeEvent::SetCachedSize(int size) const {
818   _impl_._cached_size_.Set(size);
819 }
820 
Clear()821 void KprobeEvent::Clear() {
822 // @@protoc_insertion_point(message_clear_start:perfetto.protos.KprobeEvent)
823   ::uint32_t cached_has_bits = 0;
824   // Prevent compiler warnings about cached_has_bits being unused
825   (void) cached_has_bits;
826 
827   cached_has_bits = _impl_._has_bits_[0];
828   if (cached_has_bits & 0x00000001u) {
829     _impl_.name_.ClearNonDefaultToEmpty();
830   }
831   _impl_.type_ = 0;
832   _impl_._has_bits_.Clear();
833   _internal_metadata_.Clear<std::string>();
834 }
835 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)836 const char* KprobeEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
837 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
838   _Internal::HasBits has_bits{};
839   while (!ctx->Done(&ptr)) {
840     ::uint32_t tag;
841     ptr = ::_pbi::ReadTag(ptr, &tag);
842     switch (tag >> 3) {
843       // optional string name = 1;
844       case 1:
845         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
846           auto str = _internal_mutable_name();
847           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
848           CHK_(ptr);
849         } else {
850           goto handle_unusual;
851         }
852         continue;
853       // optional .perfetto.protos.KprobeEvent.KprobeType type = 2;
854       case 2:
855         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
856           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
857           CHK_(ptr);
858           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::KprobeEvent_KprobeType_IsValid(val))) {
859             _internal_set_type(static_cast<::perfetto::protos::KprobeEvent_KprobeType>(val));
860           } else {
861             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
862           }
863         } else {
864           goto handle_unusual;
865         }
866         continue;
867       default:
868         goto handle_unusual;
869     }  // switch
870   handle_unusual:
871     if ((tag == 0) || ((tag & 7) == 4)) {
872       CHK_(ptr);
873       ctx->SetLastTag(tag);
874       goto message_done;
875     }
876     ptr = UnknownFieldParse(
877         tag,
878         _internal_metadata_.mutable_unknown_fields<std::string>(),
879         ptr, ctx);
880     CHK_(ptr != nullptr);
881   }  // while
882 message_done:
883   _impl_._has_bits_.Or(has_bits);
884   return ptr;
885 failure:
886   ptr = nullptr;
887   goto message_done;
888 #undef CHK_
889 }
890 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const891 ::uint8_t* KprobeEvent::_InternalSerialize(
892     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
893   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.KprobeEvent)
894   ::uint32_t cached_has_bits = 0;
895   (void) cached_has_bits;
896 
897   cached_has_bits = _impl_._has_bits_[0];
898   // optional string name = 1;
899   if (cached_has_bits & 0x00000001u) {
900     target = stream->WriteStringMaybeAliased(
901         1, this->_internal_name(), target);
902   }
903 
904   // optional .perfetto.protos.KprobeEvent.KprobeType type = 2;
905   if (cached_has_bits & 0x00000002u) {
906     target = stream->EnsureSpace(target);
907     target = ::_pbi::WireFormatLite::WriteEnumToArray(
908       2, this->_internal_type(), target);
909   }
910 
911   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
912     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
913         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
914   }
915   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.KprobeEvent)
916   return target;
917 }
918 
ByteSizeLong() const919 size_t KprobeEvent::ByteSizeLong() const {
920 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.KprobeEvent)
921   size_t total_size = 0;
922 
923   ::uint32_t cached_has_bits = 0;
924   // Prevent compiler warnings about cached_has_bits being unused
925   (void) cached_has_bits;
926 
927   cached_has_bits = _impl_._has_bits_[0];
928   if (cached_has_bits & 0x00000003u) {
929     // optional string name = 1;
930     if (cached_has_bits & 0x00000001u) {
931       total_size += 1 +
932         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
933           this->_internal_name());
934     }
935 
936     // optional .perfetto.protos.KprobeEvent.KprobeType type = 2;
937     if (cached_has_bits & 0x00000002u) {
938       total_size += 1 +
939         ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
940     }
941 
942   }
943   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
944     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
945   }
946   int cached_size = ::_pbi::ToCachedSize(total_size);
947   SetCachedSize(cached_size);
948   return total_size;
949 }
950 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)951 void KprobeEvent::CheckTypeAndMergeFrom(
952     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
953   MergeFrom(*::_pbi::DownCast<const KprobeEvent*>(
954       &from));
955 }
956 
MergeFrom(const KprobeEvent & from)957 void KprobeEvent::MergeFrom(const KprobeEvent& from) {
958   KprobeEvent* const _this = this;
959   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.KprobeEvent)
960   GOOGLE_DCHECK_NE(&from, _this);
961   ::uint32_t cached_has_bits = 0;
962   (void) cached_has_bits;
963 
964   cached_has_bits = from._impl_._has_bits_[0];
965   if (cached_has_bits & 0x00000003u) {
966     if (cached_has_bits & 0x00000001u) {
967       _this->_internal_set_name(from._internal_name());
968     }
969     if (cached_has_bits & 0x00000002u) {
970       _this->_impl_.type_ = from._impl_.type_;
971     }
972     _this->_impl_._has_bits_[0] |= cached_has_bits;
973   }
974   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
975 }
976 
CopyFrom(const KprobeEvent & from)977 void KprobeEvent::CopyFrom(const KprobeEvent& from) {
978 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.KprobeEvent)
979   if (&from == this) return;
980   Clear();
981   MergeFrom(from);
982 }
983 
IsInitialized() const984 bool KprobeEvent::IsInitialized() const {
985   return true;
986 }
987 
InternalSwap(KprobeEvent * other)988 void KprobeEvent::InternalSwap(KprobeEvent* other) {
989   using std::swap;
990   auto* lhs_arena = GetArenaForAllocation();
991   auto* rhs_arena = other->GetArenaForAllocation();
992   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
993   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
994   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
995       &_impl_.name_, lhs_arena,
996       &other->_impl_.name_, rhs_arena
997   );
998   swap(_impl_.type_, other->_impl_.type_);
999 }
1000 
GetTypeName() const1001 std::string KprobeEvent::GetTypeName() const {
1002   return "perfetto.protos.KprobeEvent";
1003 }
1004 
1005 
1006 // @@protoc_insertion_point(namespace_scope)
1007 }  // namespace protos
1008 }  // namespace perfetto
1009 PROTOBUF_NAMESPACE_OPEN
1010 template<> PROTOBUF_NOINLINE ::perfetto::protos::GenericFtraceEvent_Field*
CreateMaybeMessage(Arena * arena)1011 Arena::CreateMaybeMessage< ::perfetto::protos::GenericFtraceEvent_Field >(Arena* arena) {
1012   return Arena::CreateMessageInternal< ::perfetto::protos::GenericFtraceEvent_Field >(arena);
1013 }
1014 template<> PROTOBUF_NOINLINE ::perfetto::protos::GenericFtraceEvent*
CreateMaybeMessage(Arena * arena)1015 Arena::CreateMaybeMessage< ::perfetto::protos::GenericFtraceEvent >(Arena* arena) {
1016   return Arena::CreateMessageInternal< ::perfetto::protos::GenericFtraceEvent >(arena);
1017 }
1018 template<> PROTOBUF_NOINLINE ::perfetto::protos::KprobeEvent*
CreateMaybeMessage(Arena * arena)1019 Arena::CreateMaybeMessage< ::perfetto::protos::KprobeEvent >(Arena* arena) {
1020   return Arena::CreateMessageInternal< ::perfetto::protos::KprobeEvent >(arena);
1021 }
1022 PROTOBUF_NAMESPACE_CLOSE
1023 
1024 // @@protoc_insertion_point(global_scope)
1025 #include <google/protobuf/port_undef.inc>
1026