1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/hyp.proto
3 
4 #include "protos/perfetto/trace/ftrace/hyp.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 {
HypEnterFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR HypEnterFtraceEvent::HypEnterFtraceEvent(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._cached_size_)*/{}} {}
26 struct HypEnterFtraceEventDefaultTypeInternal {
HypEnterFtraceEventDefaultTypeInternalperfetto::protos::HypEnterFtraceEventDefaultTypeInternal27   PROTOBUF_CONSTEXPR HypEnterFtraceEventDefaultTypeInternal()
28       : _instance(::_pbi::ConstantInitialized{}) {}
~HypEnterFtraceEventDefaultTypeInternalperfetto::protos::HypEnterFtraceEventDefaultTypeInternal29   ~HypEnterFtraceEventDefaultTypeInternal() {}
30   union {  // NOLINT(misc-non-private-member-variables-in-classes)
31     HypEnterFtraceEvent _instance;
32   };
33 };
34 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HypEnterFtraceEventDefaultTypeInternal _HypEnterFtraceEvent_default_instance_;
HypExitFtraceEvent(::_pbi::ConstantInitialized)35 PROTOBUF_CONSTEXPR HypExitFtraceEvent::HypExitFtraceEvent(
36     ::_pbi::ConstantInitialized): _impl_{
37     /*decltype(_impl_._cached_size_)*/{}} {}
38 struct HypExitFtraceEventDefaultTypeInternal {
HypExitFtraceEventDefaultTypeInternalperfetto::protos::HypExitFtraceEventDefaultTypeInternal39   PROTOBUF_CONSTEXPR HypExitFtraceEventDefaultTypeInternal()
40       : _instance(::_pbi::ConstantInitialized{}) {}
~HypExitFtraceEventDefaultTypeInternalperfetto::protos::HypExitFtraceEventDefaultTypeInternal41   ~HypExitFtraceEventDefaultTypeInternal() {}
42   union {  // NOLINT(misc-non-private-member-variables-in-classes)
43     HypExitFtraceEvent _instance;
44   };
45 };
46 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HypExitFtraceEventDefaultTypeInternal _HypExitFtraceEvent_default_instance_;
HostHcallFtraceEvent(::_pbi::ConstantInitialized)47 PROTOBUF_CONSTEXPR HostHcallFtraceEvent::HostHcallFtraceEvent(
48     ::_pbi::ConstantInitialized): _impl_{
49     /*decltype(_impl_._has_bits_)*/{}
50   , /*decltype(_impl_._cached_size_)*/{}
51   , /*decltype(_impl_.id_)*/0u
52   , /*decltype(_impl_.invalid_)*/0u} {}
53 struct HostHcallFtraceEventDefaultTypeInternal {
HostHcallFtraceEventDefaultTypeInternalperfetto::protos::HostHcallFtraceEventDefaultTypeInternal54   PROTOBUF_CONSTEXPR HostHcallFtraceEventDefaultTypeInternal()
55       : _instance(::_pbi::ConstantInitialized{}) {}
~HostHcallFtraceEventDefaultTypeInternalperfetto::protos::HostHcallFtraceEventDefaultTypeInternal56   ~HostHcallFtraceEventDefaultTypeInternal() {}
57   union {  // NOLINT(misc-non-private-member-variables-in-classes)
58     HostHcallFtraceEvent _instance;
59   };
60 };
61 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HostHcallFtraceEventDefaultTypeInternal _HostHcallFtraceEvent_default_instance_;
HostSmcFtraceEvent(::_pbi::ConstantInitialized)62 PROTOBUF_CONSTEXPR HostSmcFtraceEvent::HostSmcFtraceEvent(
63     ::_pbi::ConstantInitialized): _impl_{
64     /*decltype(_impl_._has_bits_)*/{}
65   , /*decltype(_impl_._cached_size_)*/{}
66   , /*decltype(_impl_.id_)*/::uint64_t{0u}
67   , /*decltype(_impl_.forwarded_)*/0u} {}
68 struct HostSmcFtraceEventDefaultTypeInternal {
HostSmcFtraceEventDefaultTypeInternalperfetto::protos::HostSmcFtraceEventDefaultTypeInternal69   PROTOBUF_CONSTEXPR HostSmcFtraceEventDefaultTypeInternal()
70       : _instance(::_pbi::ConstantInitialized{}) {}
~HostSmcFtraceEventDefaultTypeInternalperfetto::protos::HostSmcFtraceEventDefaultTypeInternal71   ~HostSmcFtraceEventDefaultTypeInternal() {}
72   union {  // NOLINT(misc-non-private-member-variables-in-classes)
73     HostSmcFtraceEvent _instance;
74   };
75 };
76 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HostSmcFtraceEventDefaultTypeInternal _HostSmcFtraceEvent_default_instance_;
HostMemAbortFtraceEvent(::_pbi::ConstantInitialized)77 PROTOBUF_CONSTEXPR HostMemAbortFtraceEvent::HostMemAbortFtraceEvent(
78     ::_pbi::ConstantInitialized): _impl_{
79     /*decltype(_impl_._has_bits_)*/{}
80   , /*decltype(_impl_._cached_size_)*/{}
81   , /*decltype(_impl_.esr_)*/::uint64_t{0u}
82   , /*decltype(_impl_.addr_)*/::uint64_t{0u}} {}
83 struct HostMemAbortFtraceEventDefaultTypeInternal {
HostMemAbortFtraceEventDefaultTypeInternalperfetto::protos::HostMemAbortFtraceEventDefaultTypeInternal84   PROTOBUF_CONSTEXPR HostMemAbortFtraceEventDefaultTypeInternal()
85       : _instance(::_pbi::ConstantInitialized{}) {}
~HostMemAbortFtraceEventDefaultTypeInternalperfetto::protos::HostMemAbortFtraceEventDefaultTypeInternal86   ~HostMemAbortFtraceEventDefaultTypeInternal() {}
87   union {  // NOLINT(misc-non-private-member-variables-in-classes)
88     HostMemAbortFtraceEvent _instance;
89   };
90 };
91 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HostMemAbortFtraceEventDefaultTypeInternal _HostMemAbortFtraceEvent_default_instance_;
92 }  // namespace protos
93 }  // namespace perfetto
94 namespace perfetto {
95 namespace protos {
96 
97 // ===================================================================
98 
99 class HypEnterFtraceEvent::_Internal {
100  public:
101 };
102 
HypEnterFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)103 HypEnterFtraceEvent::HypEnterFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
104                          bool is_message_owned)
105   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
106   SharedCtor(arena, is_message_owned);
107   // @@protoc_insertion_point(arena_constructor:perfetto.protos.HypEnterFtraceEvent)
108 }
HypEnterFtraceEvent(const HypEnterFtraceEvent & from)109 HypEnterFtraceEvent::HypEnterFtraceEvent(const HypEnterFtraceEvent& from)
110   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
111   HypEnterFtraceEvent* const _this = this; (void)_this;
112   new (&_impl_) Impl_{
113       /*decltype(_impl_._cached_size_)*/{}};
114 
115   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
116   // @@protoc_insertion_point(copy_constructor:perfetto.protos.HypEnterFtraceEvent)
117 }
118 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)119 inline void HypEnterFtraceEvent::SharedCtor(
120     ::_pb::Arena* arena, bool is_message_owned) {
121   (void)arena;
122   (void)is_message_owned;
123   new (&_impl_) Impl_{
124       /*decltype(_impl_._cached_size_)*/{}
125   };
126 }
127 
~HypEnterFtraceEvent()128 HypEnterFtraceEvent::~HypEnterFtraceEvent() {
129   // @@protoc_insertion_point(destructor:perfetto.protos.HypEnterFtraceEvent)
130   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
131   (void)arena;
132     return;
133   }
134   SharedDtor();
135 }
136 
SharedDtor()137 inline void HypEnterFtraceEvent::SharedDtor() {
138   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
139 }
140 
SetCachedSize(int size) const141 void HypEnterFtraceEvent::SetCachedSize(int size) const {
142   _impl_._cached_size_.Set(size);
143 }
144 
Clear()145 void HypEnterFtraceEvent::Clear() {
146 // @@protoc_insertion_point(message_clear_start:perfetto.protos.HypEnterFtraceEvent)
147   ::uint32_t cached_has_bits = 0;
148   // Prevent compiler warnings about cached_has_bits being unused
149   (void) cached_has_bits;
150 
151   _internal_metadata_.Clear<std::string>();
152 }
153 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)154 const char* HypEnterFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
155 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
156   while (!ctx->Done(&ptr)) {
157     ::uint32_t tag;
158     ptr = ::_pbi::ReadTag(ptr, &tag);
159     if ((tag == 0) || ((tag & 7) == 4)) {
160       CHK_(ptr);
161       ctx->SetLastTag(tag);
162       goto message_done;
163     }
164     ptr = UnknownFieldParse(
165         tag,
166         _internal_metadata_.mutable_unknown_fields<std::string>(),
167         ptr, ctx);
168     CHK_(ptr != nullptr);
169   }  // while
170 message_done:
171   return ptr;
172 failure:
173   ptr = nullptr;
174   goto message_done;
175 #undef CHK_
176 }
177 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const178 ::uint8_t* HypEnterFtraceEvent::_InternalSerialize(
179     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
180   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.HypEnterFtraceEvent)
181   ::uint32_t cached_has_bits = 0;
182   (void) cached_has_bits;
183 
184   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
185     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
186         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
187   }
188   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.HypEnterFtraceEvent)
189   return target;
190 }
191 
ByteSizeLong() const192 size_t HypEnterFtraceEvent::ByteSizeLong() const {
193 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.HypEnterFtraceEvent)
194   size_t total_size = 0;
195 
196   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
197     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
198   }
199   int cached_size = ::_pbi::ToCachedSize(total_size);
200   SetCachedSize(cached_size);
201   return total_size;
202 }
203 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)204 void HypEnterFtraceEvent::CheckTypeAndMergeFrom(
205     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
206   MergeFrom(*::_pbi::DownCast<const HypEnterFtraceEvent*>(
207       &from));
208 }
209 
MergeFrom(const HypEnterFtraceEvent & from)210 void HypEnterFtraceEvent::MergeFrom(const HypEnterFtraceEvent& from) {
211   HypEnterFtraceEvent* const _this = this;
212   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.HypEnterFtraceEvent)
213   GOOGLE_DCHECK_NE(&from, _this);
214   ::uint32_t cached_has_bits = 0;
215   (void) cached_has_bits;
216 
217   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
218 }
219 
CopyFrom(const HypEnterFtraceEvent & from)220 void HypEnterFtraceEvent::CopyFrom(const HypEnterFtraceEvent& from) {
221 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.HypEnterFtraceEvent)
222   if (&from == this) return;
223   Clear();
224   MergeFrom(from);
225 }
226 
IsInitialized() const227 bool HypEnterFtraceEvent::IsInitialized() const {
228   return true;
229 }
230 
InternalSwap(HypEnterFtraceEvent * other)231 void HypEnterFtraceEvent::InternalSwap(HypEnterFtraceEvent* other) {
232   using std::swap;
233   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
234 }
235 
GetTypeName() const236 std::string HypEnterFtraceEvent::GetTypeName() const {
237   return "perfetto.protos.HypEnterFtraceEvent";
238 }
239 
240 
241 // ===================================================================
242 
243 class HypExitFtraceEvent::_Internal {
244  public:
245 };
246 
HypExitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)247 HypExitFtraceEvent::HypExitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
248                          bool is_message_owned)
249   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
250   SharedCtor(arena, is_message_owned);
251   // @@protoc_insertion_point(arena_constructor:perfetto.protos.HypExitFtraceEvent)
252 }
HypExitFtraceEvent(const HypExitFtraceEvent & from)253 HypExitFtraceEvent::HypExitFtraceEvent(const HypExitFtraceEvent& from)
254   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
255   HypExitFtraceEvent* const _this = this; (void)_this;
256   new (&_impl_) Impl_{
257       /*decltype(_impl_._cached_size_)*/{}};
258 
259   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
260   // @@protoc_insertion_point(copy_constructor:perfetto.protos.HypExitFtraceEvent)
261 }
262 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)263 inline void HypExitFtraceEvent::SharedCtor(
264     ::_pb::Arena* arena, bool is_message_owned) {
265   (void)arena;
266   (void)is_message_owned;
267   new (&_impl_) Impl_{
268       /*decltype(_impl_._cached_size_)*/{}
269   };
270 }
271 
~HypExitFtraceEvent()272 HypExitFtraceEvent::~HypExitFtraceEvent() {
273   // @@protoc_insertion_point(destructor:perfetto.protos.HypExitFtraceEvent)
274   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
275   (void)arena;
276     return;
277   }
278   SharedDtor();
279 }
280 
SharedDtor()281 inline void HypExitFtraceEvent::SharedDtor() {
282   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
283 }
284 
SetCachedSize(int size) const285 void HypExitFtraceEvent::SetCachedSize(int size) const {
286   _impl_._cached_size_.Set(size);
287 }
288 
Clear()289 void HypExitFtraceEvent::Clear() {
290 // @@protoc_insertion_point(message_clear_start:perfetto.protos.HypExitFtraceEvent)
291   ::uint32_t cached_has_bits = 0;
292   // Prevent compiler warnings about cached_has_bits being unused
293   (void) cached_has_bits;
294 
295   _internal_metadata_.Clear<std::string>();
296 }
297 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)298 const char* HypExitFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
299 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
300   while (!ctx->Done(&ptr)) {
301     ::uint32_t tag;
302     ptr = ::_pbi::ReadTag(ptr, &tag);
303     if ((tag == 0) || ((tag & 7) == 4)) {
304       CHK_(ptr);
305       ctx->SetLastTag(tag);
306       goto message_done;
307     }
308     ptr = UnknownFieldParse(
309         tag,
310         _internal_metadata_.mutable_unknown_fields<std::string>(),
311         ptr, ctx);
312     CHK_(ptr != nullptr);
313   }  // while
314 message_done:
315   return ptr;
316 failure:
317   ptr = nullptr;
318   goto message_done;
319 #undef CHK_
320 }
321 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const322 ::uint8_t* HypExitFtraceEvent::_InternalSerialize(
323     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
324   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.HypExitFtraceEvent)
325   ::uint32_t cached_has_bits = 0;
326   (void) cached_has_bits;
327 
328   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
329     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
330         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
331   }
332   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.HypExitFtraceEvent)
333   return target;
334 }
335 
ByteSizeLong() const336 size_t HypExitFtraceEvent::ByteSizeLong() const {
337 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.HypExitFtraceEvent)
338   size_t total_size = 0;
339 
340   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
341     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
342   }
343   int cached_size = ::_pbi::ToCachedSize(total_size);
344   SetCachedSize(cached_size);
345   return total_size;
346 }
347 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)348 void HypExitFtraceEvent::CheckTypeAndMergeFrom(
349     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
350   MergeFrom(*::_pbi::DownCast<const HypExitFtraceEvent*>(
351       &from));
352 }
353 
MergeFrom(const HypExitFtraceEvent & from)354 void HypExitFtraceEvent::MergeFrom(const HypExitFtraceEvent& from) {
355   HypExitFtraceEvent* const _this = this;
356   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.HypExitFtraceEvent)
357   GOOGLE_DCHECK_NE(&from, _this);
358   ::uint32_t cached_has_bits = 0;
359   (void) cached_has_bits;
360 
361   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
362 }
363 
CopyFrom(const HypExitFtraceEvent & from)364 void HypExitFtraceEvent::CopyFrom(const HypExitFtraceEvent& from) {
365 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.HypExitFtraceEvent)
366   if (&from == this) return;
367   Clear();
368   MergeFrom(from);
369 }
370 
IsInitialized() const371 bool HypExitFtraceEvent::IsInitialized() const {
372   return true;
373 }
374 
InternalSwap(HypExitFtraceEvent * other)375 void HypExitFtraceEvent::InternalSwap(HypExitFtraceEvent* other) {
376   using std::swap;
377   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
378 }
379 
GetTypeName() const380 std::string HypExitFtraceEvent::GetTypeName() const {
381   return "perfetto.protos.HypExitFtraceEvent";
382 }
383 
384 
385 // ===================================================================
386 
387 class HostHcallFtraceEvent::_Internal {
388  public:
389   using HasBits = decltype(std::declval<HostHcallFtraceEvent>()._impl_._has_bits_);
set_has_id(HasBits * has_bits)390   static void set_has_id(HasBits* has_bits) {
391     (*has_bits)[0] |= 1u;
392   }
set_has_invalid(HasBits * has_bits)393   static void set_has_invalid(HasBits* has_bits) {
394     (*has_bits)[0] |= 2u;
395   }
396 };
397 
HostHcallFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)398 HostHcallFtraceEvent::HostHcallFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
399                          bool is_message_owned)
400   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
401   SharedCtor(arena, is_message_owned);
402   // @@protoc_insertion_point(arena_constructor:perfetto.protos.HostHcallFtraceEvent)
403 }
HostHcallFtraceEvent(const HostHcallFtraceEvent & from)404 HostHcallFtraceEvent::HostHcallFtraceEvent(const HostHcallFtraceEvent& from)
405   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
406   HostHcallFtraceEvent* const _this = this; (void)_this;
407   new (&_impl_) Impl_{
408       decltype(_impl_._has_bits_){from._impl_._has_bits_}
409     , /*decltype(_impl_._cached_size_)*/{}
410     , decltype(_impl_.id_){}
411     , decltype(_impl_.invalid_){}};
412 
413   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
414   ::memcpy(&_impl_.id_, &from._impl_.id_,
415     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.invalid_) -
416     reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.invalid_));
417   // @@protoc_insertion_point(copy_constructor:perfetto.protos.HostHcallFtraceEvent)
418 }
419 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)420 inline void HostHcallFtraceEvent::SharedCtor(
421     ::_pb::Arena* arena, bool is_message_owned) {
422   (void)arena;
423   (void)is_message_owned;
424   new (&_impl_) Impl_{
425       decltype(_impl_._has_bits_){}
426     , /*decltype(_impl_._cached_size_)*/{}
427     , decltype(_impl_.id_){0u}
428     , decltype(_impl_.invalid_){0u}
429   };
430 }
431 
~HostHcallFtraceEvent()432 HostHcallFtraceEvent::~HostHcallFtraceEvent() {
433   // @@protoc_insertion_point(destructor:perfetto.protos.HostHcallFtraceEvent)
434   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
435   (void)arena;
436     return;
437   }
438   SharedDtor();
439 }
440 
SharedDtor()441 inline void HostHcallFtraceEvent::SharedDtor() {
442   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
443 }
444 
SetCachedSize(int size) const445 void HostHcallFtraceEvent::SetCachedSize(int size) const {
446   _impl_._cached_size_.Set(size);
447 }
448 
Clear()449 void HostHcallFtraceEvent::Clear() {
450 // @@protoc_insertion_point(message_clear_start:perfetto.protos.HostHcallFtraceEvent)
451   ::uint32_t cached_has_bits = 0;
452   // Prevent compiler warnings about cached_has_bits being unused
453   (void) cached_has_bits;
454 
455   cached_has_bits = _impl_._has_bits_[0];
456   if (cached_has_bits & 0x00000003u) {
457     ::memset(&_impl_.id_, 0, static_cast<size_t>(
458         reinterpret_cast<char*>(&_impl_.invalid_) -
459         reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.invalid_));
460   }
461   _impl_._has_bits_.Clear();
462   _internal_metadata_.Clear<std::string>();
463 }
464 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)465 const char* HostHcallFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
466 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
467   _Internal::HasBits has_bits{};
468   while (!ctx->Done(&ptr)) {
469     ::uint32_t tag;
470     ptr = ::_pbi::ReadTag(ptr, &tag);
471     switch (tag >> 3) {
472       // optional uint32 id = 1;
473       case 1:
474         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
475           _Internal::set_has_id(&has_bits);
476           _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
477           CHK_(ptr);
478         } else {
479           goto handle_unusual;
480         }
481         continue;
482       // optional uint32 invalid = 2;
483       case 2:
484         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
485           _Internal::set_has_invalid(&has_bits);
486           _impl_.invalid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
487           CHK_(ptr);
488         } else {
489           goto handle_unusual;
490         }
491         continue;
492       default:
493         goto handle_unusual;
494     }  // switch
495   handle_unusual:
496     if ((tag == 0) || ((tag & 7) == 4)) {
497       CHK_(ptr);
498       ctx->SetLastTag(tag);
499       goto message_done;
500     }
501     ptr = UnknownFieldParse(
502         tag,
503         _internal_metadata_.mutable_unknown_fields<std::string>(),
504         ptr, ctx);
505     CHK_(ptr != nullptr);
506   }  // while
507 message_done:
508   _impl_._has_bits_.Or(has_bits);
509   return ptr;
510 failure:
511   ptr = nullptr;
512   goto message_done;
513 #undef CHK_
514 }
515 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const516 ::uint8_t* HostHcallFtraceEvent::_InternalSerialize(
517     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
518   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.HostHcallFtraceEvent)
519   ::uint32_t cached_has_bits = 0;
520   (void) cached_has_bits;
521 
522   cached_has_bits = _impl_._has_bits_[0];
523   // optional uint32 id = 1;
524   if (cached_has_bits & 0x00000001u) {
525     target = stream->EnsureSpace(target);
526     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target);
527   }
528 
529   // optional uint32 invalid = 2;
530   if (cached_has_bits & 0x00000002u) {
531     target = stream->EnsureSpace(target);
532     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_invalid(), target);
533   }
534 
535   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
536     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
537         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
538   }
539   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.HostHcallFtraceEvent)
540   return target;
541 }
542 
ByteSizeLong() const543 size_t HostHcallFtraceEvent::ByteSizeLong() const {
544 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.HostHcallFtraceEvent)
545   size_t total_size = 0;
546 
547   ::uint32_t cached_has_bits = 0;
548   // Prevent compiler warnings about cached_has_bits being unused
549   (void) cached_has_bits;
550 
551   cached_has_bits = _impl_._has_bits_[0];
552   if (cached_has_bits & 0x00000003u) {
553     // optional uint32 id = 1;
554     if (cached_has_bits & 0x00000001u) {
555       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_id());
556     }
557 
558     // optional uint32 invalid = 2;
559     if (cached_has_bits & 0x00000002u) {
560       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_invalid());
561     }
562 
563   }
564   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
565     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
566   }
567   int cached_size = ::_pbi::ToCachedSize(total_size);
568   SetCachedSize(cached_size);
569   return total_size;
570 }
571 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)572 void HostHcallFtraceEvent::CheckTypeAndMergeFrom(
573     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
574   MergeFrom(*::_pbi::DownCast<const HostHcallFtraceEvent*>(
575       &from));
576 }
577 
MergeFrom(const HostHcallFtraceEvent & from)578 void HostHcallFtraceEvent::MergeFrom(const HostHcallFtraceEvent& from) {
579   HostHcallFtraceEvent* const _this = this;
580   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.HostHcallFtraceEvent)
581   GOOGLE_DCHECK_NE(&from, _this);
582   ::uint32_t cached_has_bits = 0;
583   (void) cached_has_bits;
584 
585   cached_has_bits = from._impl_._has_bits_[0];
586   if (cached_has_bits & 0x00000003u) {
587     if (cached_has_bits & 0x00000001u) {
588       _this->_impl_.id_ = from._impl_.id_;
589     }
590     if (cached_has_bits & 0x00000002u) {
591       _this->_impl_.invalid_ = from._impl_.invalid_;
592     }
593     _this->_impl_._has_bits_[0] |= cached_has_bits;
594   }
595   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
596 }
597 
CopyFrom(const HostHcallFtraceEvent & from)598 void HostHcallFtraceEvent::CopyFrom(const HostHcallFtraceEvent& from) {
599 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.HostHcallFtraceEvent)
600   if (&from == this) return;
601   Clear();
602   MergeFrom(from);
603 }
604 
IsInitialized() const605 bool HostHcallFtraceEvent::IsInitialized() const {
606   return true;
607 }
608 
InternalSwap(HostHcallFtraceEvent * other)609 void HostHcallFtraceEvent::InternalSwap(HostHcallFtraceEvent* other) {
610   using std::swap;
611   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
612   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
613   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
614       PROTOBUF_FIELD_OFFSET(HostHcallFtraceEvent, _impl_.invalid_)
615       + sizeof(HostHcallFtraceEvent::_impl_.invalid_)  // NOLINT
616       - PROTOBUF_FIELD_OFFSET(HostHcallFtraceEvent, _impl_.id_)>(
617           reinterpret_cast<char*>(&_impl_.id_),
618           reinterpret_cast<char*>(&other->_impl_.id_));
619 }
620 
GetTypeName() const621 std::string HostHcallFtraceEvent::GetTypeName() const {
622   return "perfetto.protos.HostHcallFtraceEvent";
623 }
624 
625 
626 // ===================================================================
627 
628 class HostSmcFtraceEvent::_Internal {
629  public:
630   using HasBits = decltype(std::declval<HostSmcFtraceEvent>()._impl_._has_bits_);
set_has_id(HasBits * has_bits)631   static void set_has_id(HasBits* has_bits) {
632     (*has_bits)[0] |= 1u;
633   }
set_has_forwarded(HasBits * has_bits)634   static void set_has_forwarded(HasBits* has_bits) {
635     (*has_bits)[0] |= 2u;
636   }
637 };
638 
HostSmcFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)639 HostSmcFtraceEvent::HostSmcFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
640                          bool is_message_owned)
641   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
642   SharedCtor(arena, is_message_owned);
643   // @@protoc_insertion_point(arena_constructor:perfetto.protos.HostSmcFtraceEvent)
644 }
HostSmcFtraceEvent(const HostSmcFtraceEvent & from)645 HostSmcFtraceEvent::HostSmcFtraceEvent(const HostSmcFtraceEvent& from)
646   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
647   HostSmcFtraceEvent* const _this = this; (void)_this;
648   new (&_impl_) Impl_{
649       decltype(_impl_._has_bits_){from._impl_._has_bits_}
650     , /*decltype(_impl_._cached_size_)*/{}
651     , decltype(_impl_.id_){}
652     , decltype(_impl_.forwarded_){}};
653 
654   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
655   ::memcpy(&_impl_.id_, &from._impl_.id_,
656     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.forwarded_) -
657     reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.forwarded_));
658   // @@protoc_insertion_point(copy_constructor:perfetto.protos.HostSmcFtraceEvent)
659 }
660 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)661 inline void HostSmcFtraceEvent::SharedCtor(
662     ::_pb::Arena* arena, bool is_message_owned) {
663   (void)arena;
664   (void)is_message_owned;
665   new (&_impl_) Impl_{
666       decltype(_impl_._has_bits_){}
667     , /*decltype(_impl_._cached_size_)*/{}
668     , decltype(_impl_.id_){::uint64_t{0u}}
669     , decltype(_impl_.forwarded_){0u}
670   };
671 }
672 
~HostSmcFtraceEvent()673 HostSmcFtraceEvent::~HostSmcFtraceEvent() {
674   // @@protoc_insertion_point(destructor:perfetto.protos.HostSmcFtraceEvent)
675   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
676   (void)arena;
677     return;
678   }
679   SharedDtor();
680 }
681 
SharedDtor()682 inline void HostSmcFtraceEvent::SharedDtor() {
683   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
684 }
685 
SetCachedSize(int size) const686 void HostSmcFtraceEvent::SetCachedSize(int size) const {
687   _impl_._cached_size_.Set(size);
688 }
689 
Clear()690 void HostSmcFtraceEvent::Clear() {
691 // @@protoc_insertion_point(message_clear_start:perfetto.protos.HostSmcFtraceEvent)
692   ::uint32_t cached_has_bits = 0;
693   // Prevent compiler warnings about cached_has_bits being unused
694   (void) cached_has_bits;
695 
696   cached_has_bits = _impl_._has_bits_[0];
697   if (cached_has_bits & 0x00000003u) {
698     ::memset(&_impl_.id_, 0, static_cast<size_t>(
699         reinterpret_cast<char*>(&_impl_.forwarded_) -
700         reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.forwarded_));
701   }
702   _impl_._has_bits_.Clear();
703   _internal_metadata_.Clear<std::string>();
704 }
705 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)706 const char* HostSmcFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
707 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
708   _Internal::HasBits has_bits{};
709   while (!ctx->Done(&ptr)) {
710     ::uint32_t tag;
711     ptr = ::_pbi::ReadTag(ptr, &tag);
712     switch (tag >> 3) {
713       // optional uint64 id = 1;
714       case 1:
715         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
716           _Internal::set_has_id(&has_bits);
717           _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
718           CHK_(ptr);
719         } else {
720           goto handle_unusual;
721         }
722         continue;
723       // optional uint32 forwarded = 2;
724       case 2:
725         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
726           _Internal::set_has_forwarded(&has_bits);
727           _impl_.forwarded_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
728           CHK_(ptr);
729         } else {
730           goto handle_unusual;
731         }
732         continue;
733       default:
734         goto handle_unusual;
735     }  // switch
736   handle_unusual:
737     if ((tag == 0) || ((tag & 7) == 4)) {
738       CHK_(ptr);
739       ctx->SetLastTag(tag);
740       goto message_done;
741     }
742     ptr = UnknownFieldParse(
743         tag,
744         _internal_metadata_.mutable_unknown_fields<std::string>(),
745         ptr, ctx);
746     CHK_(ptr != nullptr);
747   }  // while
748 message_done:
749   _impl_._has_bits_.Or(has_bits);
750   return ptr;
751 failure:
752   ptr = nullptr;
753   goto message_done;
754 #undef CHK_
755 }
756 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const757 ::uint8_t* HostSmcFtraceEvent::_InternalSerialize(
758     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
759   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.HostSmcFtraceEvent)
760   ::uint32_t cached_has_bits = 0;
761   (void) cached_has_bits;
762 
763   cached_has_bits = _impl_._has_bits_[0];
764   // optional uint64 id = 1;
765   if (cached_has_bits & 0x00000001u) {
766     target = stream->EnsureSpace(target);
767     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_id(), target);
768   }
769 
770   // optional uint32 forwarded = 2;
771   if (cached_has_bits & 0x00000002u) {
772     target = stream->EnsureSpace(target);
773     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_forwarded(), target);
774   }
775 
776   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
777     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
778         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
779   }
780   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.HostSmcFtraceEvent)
781   return target;
782 }
783 
ByteSizeLong() const784 size_t HostSmcFtraceEvent::ByteSizeLong() const {
785 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.HostSmcFtraceEvent)
786   size_t total_size = 0;
787 
788   ::uint32_t cached_has_bits = 0;
789   // Prevent compiler warnings about cached_has_bits being unused
790   (void) cached_has_bits;
791 
792   cached_has_bits = _impl_._has_bits_[0];
793   if (cached_has_bits & 0x00000003u) {
794     // optional uint64 id = 1;
795     if (cached_has_bits & 0x00000001u) {
796       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_id());
797     }
798 
799     // optional uint32 forwarded = 2;
800     if (cached_has_bits & 0x00000002u) {
801       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_forwarded());
802     }
803 
804   }
805   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
806     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
807   }
808   int cached_size = ::_pbi::ToCachedSize(total_size);
809   SetCachedSize(cached_size);
810   return total_size;
811 }
812 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)813 void HostSmcFtraceEvent::CheckTypeAndMergeFrom(
814     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
815   MergeFrom(*::_pbi::DownCast<const HostSmcFtraceEvent*>(
816       &from));
817 }
818 
MergeFrom(const HostSmcFtraceEvent & from)819 void HostSmcFtraceEvent::MergeFrom(const HostSmcFtraceEvent& from) {
820   HostSmcFtraceEvent* const _this = this;
821   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.HostSmcFtraceEvent)
822   GOOGLE_DCHECK_NE(&from, _this);
823   ::uint32_t cached_has_bits = 0;
824   (void) cached_has_bits;
825 
826   cached_has_bits = from._impl_._has_bits_[0];
827   if (cached_has_bits & 0x00000003u) {
828     if (cached_has_bits & 0x00000001u) {
829       _this->_impl_.id_ = from._impl_.id_;
830     }
831     if (cached_has_bits & 0x00000002u) {
832       _this->_impl_.forwarded_ = from._impl_.forwarded_;
833     }
834     _this->_impl_._has_bits_[0] |= cached_has_bits;
835   }
836   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
837 }
838 
CopyFrom(const HostSmcFtraceEvent & from)839 void HostSmcFtraceEvent::CopyFrom(const HostSmcFtraceEvent& from) {
840 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.HostSmcFtraceEvent)
841   if (&from == this) return;
842   Clear();
843   MergeFrom(from);
844 }
845 
IsInitialized() const846 bool HostSmcFtraceEvent::IsInitialized() const {
847   return true;
848 }
849 
InternalSwap(HostSmcFtraceEvent * other)850 void HostSmcFtraceEvent::InternalSwap(HostSmcFtraceEvent* other) {
851   using std::swap;
852   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
853   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
854   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
855       PROTOBUF_FIELD_OFFSET(HostSmcFtraceEvent, _impl_.forwarded_)
856       + sizeof(HostSmcFtraceEvent::_impl_.forwarded_)  // NOLINT
857       - PROTOBUF_FIELD_OFFSET(HostSmcFtraceEvent, _impl_.id_)>(
858           reinterpret_cast<char*>(&_impl_.id_),
859           reinterpret_cast<char*>(&other->_impl_.id_));
860 }
861 
GetTypeName() const862 std::string HostSmcFtraceEvent::GetTypeName() const {
863   return "perfetto.protos.HostSmcFtraceEvent";
864 }
865 
866 
867 // ===================================================================
868 
869 class HostMemAbortFtraceEvent::_Internal {
870  public:
871   using HasBits = decltype(std::declval<HostMemAbortFtraceEvent>()._impl_._has_bits_);
set_has_esr(HasBits * has_bits)872   static void set_has_esr(HasBits* has_bits) {
873     (*has_bits)[0] |= 1u;
874   }
set_has_addr(HasBits * has_bits)875   static void set_has_addr(HasBits* has_bits) {
876     (*has_bits)[0] |= 2u;
877   }
878 };
879 
HostMemAbortFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)880 HostMemAbortFtraceEvent::HostMemAbortFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
881                          bool is_message_owned)
882   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
883   SharedCtor(arena, is_message_owned);
884   // @@protoc_insertion_point(arena_constructor:perfetto.protos.HostMemAbortFtraceEvent)
885 }
HostMemAbortFtraceEvent(const HostMemAbortFtraceEvent & from)886 HostMemAbortFtraceEvent::HostMemAbortFtraceEvent(const HostMemAbortFtraceEvent& from)
887   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
888   HostMemAbortFtraceEvent* const _this = this; (void)_this;
889   new (&_impl_) Impl_{
890       decltype(_impl_._has_bits_){from._impl_._has_bits_}
891     , /*decltype(_impl_._cached_size_)*/{}
892     , decltype(_impl_.esr_){}
893     , decltype(_impl_.addr_){}};
894 
895   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
896   ::memcpy(&_impl_.esr_, &from._impl_.esr_,
897     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.addr_) -
898     reinterpret_cast<char*>(&_impl_.esr_)) + sizeof(_impl_.addr_));
899   // @@protoc_insertion_point(copy_constructor:perfetto.protos.HostMemAbortFtraceEvent)
900 }
901 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)902 inline void HostMemAbortFtraceEvent::SharedCtor(
903     ::_pb::Arena* arena, bool is_message_owned) {
904   (void)arena;
905   (void)is_message_owned;
906   new (&_impl_) Impl_{
907       decltype(_impl_._has_bits_){}
908     , /*decltype(_impl_._cached_size_)*/{}
909     , decltype(_impl_.esr_){::uint64_t{0u}}
910     , decltype(_impl_.addr_){::uint64_t{0u}}
911   };
912 }
913 
~HostMemAbortFtraceEvent()914 HostMemAbortFtraceEvent::~HostMemAbortFtraceEvent() {
915   // @@protoc_insertion_point(destructor:perfetto.protos.HostMemAbortFtraceEvent)
916   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
917   (void)arena;
918     return;
919   }
920   SharedDtor();
921 }
922 
SharedDtor()923 inline void HostMemAbortFtraceEvent::SharedDtor() {
924   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
925 }
926 
SetCachedSize(int size) const927 void HostMemAbortFtraceEvent::SetCachedSize(int size) const {
928   _impl_._cached_size_.Set(size);
929 }
930 
Clear()931 void HostMemAbortFtraceEvent::Clear() {
932 // @@protoc_insertion_point(message_clear_start:perfetto.protos.HostMemAbortFtraceEvent)
933   ::uint32_t cached_has_bits = 0;
934   // Prevent compiler warnings about cached_has_bits being unused
935   (void) cached_has_bits;
936 
937   cached_has_bits = _impl_._has_bits_[0];
938   if (cached_has_bits & 0x00000003u) {
939     ::memset(&_impl_.esr_, 0, static_cast<size_t>(
940         reinterpret_cast<char*>(&_impl_.addr_) -
941         reinterpret_cast<char*>(&_impl_.esr_)) + sizeof(_impl_.addr_));
942   }
943   _impl_._has_bits_.Clear();
944   _internal_metadata_.Clear<std::string>();
945 }
946 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)947 const char* HostMemAbortFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
948 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
949   _Internal::HasBits has_bits{};
950   while (!ctx->Done(&ptr)) {
951     ::uint32_t tag;
952     ptr = ::_pbi::ReadTag(ptr, &tag);
953     switch (tag >> 3) {
954       // optional uint64 esr = 1;
955       case 1:
956         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
957           _Internal::set_has_esr(&has_bits);
958           _impl_.esr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
959           CHK_(ptr);
960         } else {
961           goto handle_unusual;
962         }
963         continue;
964       // optional uint64 addr = 2;
965       case 2:
966         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
967           _Internal::set_has_addr(&has_bits);
968           _impl_.addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
969           CHK_(ptr);
970         } else {
971           goto handle_unusual;
972         }
973         continue;
974       default:
975         goto handle_unusual;
976     }  // switch
977   handle_unusual:
978     if ((tag == 0) || ((tag & 7) == 4)) {
979       CHK_(ptr);
980       ctx->SetLastTag(tag);
981       goto message_done;
982     }
983     ptr = UnknownFieldParse(
984         tag,
985         _internal_metadata_.mutable_unknown_fields<std::string>(),
986         ptr, ctx);
987     CHK_(ptr != nullptr);
988   }  // while
989 message_done:
990   _impl_._has_bits_.Or(has_bits);
991   return ptr;
992 failure:
993   ptr = nullptr;
994   goto message_done;
995 #undef CHK_
996 }
997 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const998 ::uint8_t* HostMemAbortFtraceEvent::_InternalSerialize(
999     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1000   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.HostMemAbortFtraceEvent)
1001   ::uint32_t cached_has_bits = 0;
1002   (void) cached_has_bits;
1003 
1004   cached_has_bits = _impl_._has_bits_[0];
1005   // optional uint64 esr = 1;
1006   if (cached_has_bits & 0x00000001u) {
1007     target = stream->EnsureSpace(target);
1008     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_esr(), target);
1009   }
1010 
1011   // optional uint64 addr = 2;
1012   if (cached_has_bits & 0x00000002u) {
1013     target = stream->EnsureSpace(target);
1014     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_addr(), target);
1015   }
1016 
1017   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1018     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1019         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1020   }
1021   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.HostMemAbortFtraceEvent)
1022   return target;
1023 }
1024 
ByteSizeLong() const1025 size_t HostMemAbortFtraceEvent::ByteSizeLong() const {
1026 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.HostMemAbortFtraceEvent)
1027   size_t total_size = 0;
1028 
1029   ::uint32_t cached_has_bits = 0;
1030   // Prevent compiler warnings about cached_has_bits being unused
1031   (void) cached_has_bits;
1032 
1033   cached_has_bits = _impl_._has_bits_[0];
1034   if (cached_has_bits & 0x00000003u) {
1035     // optional uint64 esr = 1;
1036     if (cached_has_bits & 0x00000001u) {
1037       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_esr());
1038     }
1039 
1040     // optional uint64 addr = 2;
1041     if (cached_has_bits & 0x00000002u) {
1042       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_addr());
1043     }
1044 
1045   }
1046   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1047     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1048   }
1049   int cached_size = ::_pbi::ToCachedSize(total_size);
1050   SetCachedSize(cached_size);
1051   return total_size;
1052 }
1053 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1054 void HostMemAbortFtraceEvent::CheckTypeAndMergeFrom(
1055     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1056   MergeFrom(*::_pbi::DownCast<const HostMemAbortFtraceEvent*>(
1057       &from));
1058 }
1059 
MergeFrom(const HostMemAbortFtraceEvent & from)1060 void HostMemAbortFtraceEvent::MergeFrom(const HostMemAbortFtraceEvent& from) {
1061   HostMemAbortFtraceEvent* const _this = this;
1062   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.HostMemAbortFtraceEvent)
1063   GOOGLE_DCHECK_NE(&from, _this);
1064   ::uint32_t cached_has_bits = 0;
1065   (void) cached_has_bits;
1066 
1067   cached_has_bits = from._impl_._has_bits_[0];
1068   if (cached_has_bits & 0x00000003u) {
1069     if (cached_has_bits & 0x00000001u) {
1070       _this->_impl_.esr_ = from._impl_.esr_;
1071     }
1072     if (cached_has_bits & 0x00000002u) {
1073       _this->_impl_.addr_ = from._impl_.addr_;
1074     }
1075     _this->_impl_._has_bits_[0] |= cached_has_bits;
1076   }
1077   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1078 }
1079 
CopyFrom(const HostMemAbortFtraceEvent & from)1080 void HostMemAbortFtraceEvent::CopyFrom(const HostMemAbortFtraceEvent& from) {
1081 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.HostMemAbortFtraceEvent)
1082   if (&from == this) return;
1083   Clear();
1084   MergeFrom(from);
1085 }
1086 
IsInitialized() const1087 bool HostMemAbortFtraceEvent::IsInitialized() const {
1088   return true;
1089 }
1090 
InternalSwap(HostMemAbortFtraceEvent * other)1091 void HostMemAbortFtraceEvent::InternalSwap(HostMemAbortFtraceEvent* other) {
1092   using std::swap;
1093   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1094   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1095   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1096       PROTOBUF_FIELD_OFFSET(HostMemAbortFtraceEvent, _impl_.addr_)
1097       + sizeof(HostMemAbortFtraceEvent::_impl_.addr_)  // NOLINT
1098       - PROTOBUF_FIELD_OFFSET(HostMemAbortFtraceEvent, _impl_.esr_)>(
1099           reinterpret_cast<char*>(&_impl_.esr_),
1100           reinterpret_cast<char*>(&other->_impl_.esr_));
1101 }
1102 
GetTypeName() const1103 std::string HostMemAbortFtraceEvent::GetTypeName() const {
1104   return "perfetto.protos.HostMemAbortFtraceEvent";
1105 }
1106 
1107 
1108 // @@protoc_insertion_point(namespace_scope)
1109 }  // namespace protos
1110 }  // namespace perfetto
1111 PROTOBUF_NAMESPACE_OPEN
1112 template<> PROTOBUF_NOINLINE ::perfetto::protos::HypEnterFtraceEvent*
CreateMaybeMessage(Arena * arena)1113 Arena::CreateMaybeMessage< ::perfetto::protos::HypEnterFtraceEvent >(Arena* arena) {
1114   return Arena::CreateMessageInternal< ::perfetto::protos::HypEnterFtraceEvent >(arena);
1115 }
1116 template<> PROTOBUF_NOINLINE ::perfetto::protos::HypExitFtraceEvent*
CreateMaybeMessage(Arena * arena)1117 Arena::CreateMaybeMessage< ::perfetto::protos::HypExitFtraceEvent >(Arena* arena) {
1118   return Arena::CreateMessageInternal< ::perfetto::protos::HypExitFtraceEvent >(arena);
1119 }
1120 template<> PROTOBUF_NOINLINE ::perfetto::protos::HostHcallFtraceEvent*
CreateMaybeMessage(Arena * arena)1121 Arena::CreateMaybeMessage< ::perfetto::protos::HostHcallFtraceEvent >(Arena* arena) {
1122   return Arena::CreateMessageInternal< ::perfetto::protos::HostHcallFtraceEvent >(arena);
1123 }
1124 template<> PROTOBUF_NOINLINE ::perfetto::protos::HostSmcFtraceEvent*
CreateMaybeMessage(Arena * arena)1125 Arena::CreateMaybeMessage< ::perfetto::protos::HostSmcFtraceEvent >(Arena* arena) {
1126   return Arena::CreateMessageInternal< ::perfetto::protos::HostSmcFtraceEvent >(arena);
1127 }
1128 template<> PROTOBUF_NOINLINE ::perfetto::protos::HostMemAbortFtraceEvent*
CreateMaybeMessage(Arena * arena)1129 Arena::CreateMaybeMessage< ::perfetto::protos::HostMemAbortFtraceEvent >(Arena* arena) {
1130   return Arena::CreateMessageInternal< ::perfetto::protos::HostMemAbortFtraceEvent >(arena);
1131 }
1132 PROTOBUF_NAMESPACE_CLOSE
1133 
1134 // @@protoc_insertion_point(global_scope)
1135 #include <google/protobuf/port_undef.inc>
1136