1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/irq.proto
3 
4 #include "protos/perfetto/trace/ftrace/irq.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 {
SoftirqEntryFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR SoftirqEntryFtraceEvent::SoftirqEntryFtraceEvent(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.vec_)*/0u} {}
28 struct SoftirqEntryFtraceEventDefaultTypeInternal {
SoftirqEntryFtraceEventDefaultTypeInternalperfetto::protos::SoftirqEntryFtraceEventDefaultTypeInternal29   PROTOBUF_CONSTEXPR SoftirqEntryFtraceEventDefaultTypeInternal()
30       : _instance(::_pbi::ConstantInitialized{}) {}
~SoftirqEntryFtraceEventDefaultTypeInternalperfetto::protos::SoftirqEntryFtraceEventDefaultTypeInternal31   ~SoftirqEntryFtraceEventDefaultTypeInternal() {}
32   union {  // NOLINT(misc-non-private-member-variables-in-classes)
33     SoftirqEntryFtraceEvent _instance;
34   };
35 };
36 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SoftirqEntryFtraceEventDefaultTypeInternal _SoftirqEntryFtraceEvent_default_instance_;
SoftirqExitFtraceEvent(::_pbi::ConstantInitialized)37 PROTOBUF_CONSTEXPR SoftirqExitFtraceEvent::SoftirqExitFtraceEvent(
38     ::_pbi::ConstantInitialized): _impl_{
39     /*decltype(_impl_._has_bits_)*/{}
40   , /*decltype(_impl_._cached_size_)*/{}
41   , /*decltype(_impl_.vec_)*/0u} {}
42 struct SoftirqExitFtraceEventDefaultTypeInternal {
SoftirqExitFtraceEventDefaultTypeInternalperfetto::protos::SoftirqExitFtraceEventDefaultTypeInternal43   PROTOBUF_CONSTEXPR SoftirqExitFtraceEventDefaultTypeInternal()
44       : _instance(::_pbi::ConstantInitialized{}) {}
~SoftirqExitFtraceEventDefaultTypeInternalperfetto::protos::SoftirqExitFtraceEventDefaultTypeInternal45   ~SoftirqExitFtraceEventDefaultTypeInternal() {}
46   union {  // NOLINT(misc-non-private-member-variables-in-classes)
47     SoftirqExitFtraceEvent _instance;
48   };
49 };
50 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SoftirqExitFtraceEventDefaultTypeInternal _SoftirqExitFtraceEvent_default_instance_;
SoftirqRaiseFtraceEvent(::_pbi::ConstantInitialized)51 PROTOBUF_CONSTEXPR SoftirqRaiseFtraceEvent::SoftirqRaiseFtraceEvent(
52     ::_pbi::ConstantInitialized): _impl_{
53     /*decltype(_impl_._has_bits_)*/{}
54   , /*decltype(_impl_._cached_size_)*/{}
55   , /*decltype(_impl_.vec_)*/0u} {}
56 struct SoftirqRaiseFtraceEventDefaultTypeInternal {
SoftirqRaiseFtraceEventDefaultTypeInternalperfetto::protos::SoftirqRaiseFtraceEventDefaultTypeInternal57   PROTOBUF_CONSTEXPR SoftirqRaiseFtraceEventDefaultTypeInternal()
58       : _instance(::_pbi::ConstantInitialized{}) {}
~SoftirqRaiseFtraceEventDefaultTypeInternalperfetto::protos::SoftirqRaiseFtraceEventDefaultTypeInternal59   ~SoftirqRaiseFtraceEventDefaultTypeInternal() {}
60   union {  // NOLINT(misc-non-private-member-variables-in-classes)
61     SoftirqRaiseFtraceEvent _instance;
62   };
63 };
64 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SoftirqRaiseFtraceEventDefaultTypeInternal _SoftirqRaiseFtraceEvent_default_instance_;
IrqHandlerEntryFtraceEvent(::_pbi::ConstantInitialized)65 PROTOBUF_CONSTEXPR IrqHandlerEntryFtraceEvent::IrqHandlerEntryFtraceEvent(
66     ::_pbi::ConstantInitialized): _impl_{
67     /*decltype(_impl_._has_bits_)*/{}
68   , /*decltype(_impl_._cached_size_)*/{}
69   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
70   , /*decltype(_impl_.irq_)*/0
71   , /*decltype(_impl_.handler_)*/0u} {}
72 struct IrqHandlerEntryFtraceEventDefaultTypeInternal {
IrqHandlerEntryFtraceEventDefaultTypeInternalperfetto::protos::IrqHandlerEntryFtraceEventDefaultTypeInternal73   PROTOBUF_CONSTEXPR IrqHandlerEntryFtraceEventDefaultTypeInternal()
74       : _instance(::_pbi::ConstantInitialized{}) {}
~IrqHandlerEntryFtraceEventDefaultTypeInternalperfetto::protos::IrqHandlerEntryFtraceEventDefaultTypeInternal75   ~IrqHandlerEntryFtraceEventDefaultTypeInternal() {}
76   union {  // NOLINT(misc-non-private-member-variables-in-classes)
77     IrqHandlerEntryFtraceEvent _instance;
78   };
79 };
80 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IrqHandlerEntryFtraceEventDefaultTypeInternal _IrqHandlerEntryFtraceEvent_default_instance_;
IrqHandlerExitFtraceEvent(::_pbi::ConstantInitialized)81 PROTOBUF_CONSTEXPR IrqHandlerExitFtraceEvent::IrqHandlerExitFtraceEvent(
82     ::_pbi::ConstantInitialized): _impl_{
83     /*decltype(_impl_._has_bits_)*/{}
84   , /*decltype(_impl_._cached_size_)*/{}
85   , /*decltype(_impl_.irq_)*/0
86   , /*decltype(_impl_.ret_)*/0} {}
87 struct IrqHandlerExitFtraceEventDefaultTypeInternal {
IrqHandlerExitFtraceEventDefaultTypeInternalperfetto::protos::IrqHandlerExitFtraceEventDefaultTypeInternal88   PROTOBUF_CONSTEXPR IrqHandlerExitFtraceEventDefaultTypeInternal()
89       : _instance(::_pbi::ConstantInitialized{}) {}
~IrqHandlerExitFtraceEventDefaultTypeInternalperfetto::protos::IrqHandlerExitFtraceEventDefaultTypeInternal90   ~IrqHandlerExitFtraceEventDefaultTypeInternal() {}
91   union {  // NOLINT(misc-non-private-member-variables-in-classes)
92     IrqHandlerExitFtraceEvent _instance;
93   };
94 };
95 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IrqHandlerExitFtraceEventDefaultTypeInternal _IrqHandlerExitFtraceEvent_default_instance_;
96 }  // namespace protos
97 }  // namespace perfetto
98 namespace perfetto {
99 namespace protos {
100 
101 // ===================================================================
102 
103 class SoftirqEntryFtraceEvent::_Internal {
104  public:
105   using HasBits = decltype(std::declval<SoftirqEntryFtraceEvent>()._impl_._has_bits_);
set_has_vec(HasBits * has_bits)106   static void set_has_vec(HasBits* has_bits) {
107     (*has_bits)[0] |= 1u;
108   }
109 };
110 
SoftirqEntryFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)111 SoftirqEntryFtraceEvent::SoftirqEntryFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
112                          bool is_message_owned)
113   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
114   SharedCtor(arena, is_message_owned);
115   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SoftirqEntryFtraceEvent)
116 }
SoftirqEntryFtraceEvent(const SoftirqEntryFtraceEvent & from)117 SoftirqEntryFtraceEvent::SoftirqEntryFtraceEvent(const SoftirqEntryFtraceEvent& from)
118   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
119   SoftirqEntryFtraceEvent* const _this = this; (void)_this;
120   new (&_impl_) Impl_{
121       decltype(_impl_._has_bits_){from._impl_._has_bits_}
122     , /*decltype(_impl_._cached_size_)*/{}
123     , decltype(_impl_.vec_){}};
124 
125   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
126   _this->_impl_.vec_ = from._impl_.vec_;
127   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SoftirqEntryFtraceEvent)
128 }
129 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)130 inline void SoftirqEntryFtraceEvent::SharedCtor(
131     ::_pb::Arena* arena, bool is_message_owned) {
132   (void)arena;
133   (void)is_message_owned;
134   new (&_impl_) Impl_{
135       decltype(_impl_._has_bits_){}
136     , /*decltype(_impl_._cached_size_)*/{}
137     , decltype(_impl_.vec_){0u}
138   };
139 }
140 
~SoftirqEntryFtraceEvent()141 SoftirqEntryFtraceEvent::~SoftirqEntryFtraceEvent() {
142   // @@protoc_insertion_point(destructor:perfetto.protos.SoftirqEntryFtraceEvent)
143   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
144   (void)arena;
145     return;
146   }
147   SharedDtor();
148 }
149 
SharedDtor()150 inline void SoftirqEntryFtraceEvent::SharedDtor() {
151   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
152 }
153 
SetCachedSize(int size) const154 void SoftirqEntryFtraceEvent::SetCachedSize(int size) const {
155   _impl_._cached_size_.Set(size);
156 }
157 
Clear()158 void SoftirqEntryFtraceEvent::Clear() {
159 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SoftirqEntryFtraceEvent)
160   ::uint32_t cached_has_bits = 0;
161   // Prevent compiler warnings about cached_has_bits being unused
162   (void) cached_has_bits;
163 
164   _impl_.vec_ = 0u;
165   _impl_._has_bits_.Clear();
166   _internal_metadata_.Clear<std::string>();
167 }
168 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)169 const char* SoftirqEntryFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
170 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
171   _Internal::HasBits has_bits{};
172   while (!ctx->Done(&ptr)) {
173     ::uint32_t tag;
174     ptr = ::_pbi::ReadTag(ptr, &tag);
175     switch (tag >> 3) {
176       // optional uint32 vec = 1;
177       case 1:
178         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
179           _Internal::set_has_vec(&has_bits);
180           _impl_.vec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
181           CHK_(ptr);
182         } else {
183           goto handle_unusual;
184         }
185         continue;
186       default:
187         goto handle_unusual;
188     }  // switch
189   handle_unusual:
190     if ((tag == 0) || ((tag & 7) == 4)) {
191       CHK_(ptr);
192       ctx->SetLastTag(tag);
193       goto message_done;
194     }
195     ptr = UnknownFieldParse(
196         tag,
197         _internal_metadata_.mutable_unknown_fields<std::string>(),
198         ptr, ctx);
199     CHK_(ptr != nullptr);
200   }  // while
201 message_done:
202   _impl_._has_bits_.Or(has_bits);
203   return ptr;
204 failure:
205   ptr = nullptr;
206   goto message_done;
207 #undef CHK_
208 }
209 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const210 ::uint8_t* SoftirqEntryFtraceEvent::_InternalSerialize(
211     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
212   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SoftirqEntryFtraceEvent)
213   ::uint32_t cached_has_bits = 0;
214   (void) cached_has_bits;
215 
216   cached_has_bits = _impl_._has_bits_[0];
217   // optional uint32 vec = 1;
218   if (cached_has_bits & 0x00000001u) {
219     target = stream->EnsureSpace(target);
220     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_vec(), target);
221   }
222 
223   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
224     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
225         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
226   }
227   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SoftirqEntryFtraceEvent)
228   return target;
229 }
230 
ByteSizeLong() const231 size_t SoftirqEntryFtraceEvent::ByteSizeLong() const {
232 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SoftirqEntryFtraceEvent)
233   size_t total_size = 0;
234 
235   ::uint32_t cached_has_bits = 0;
236   // Prevent compiler warnings about cached_has_bits being unused
237   (void) cached_has_bits;
238 
239   // optional uint32 vec = 1;
240   cached_has_bits = _impl_._has_bits_[0];
241   if (cached_has_bits & 0x00000001u) {
242     total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_vec());
243   }
244 
245   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
246     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
247   }
248   int cached_size = ::_pbi::ToCachedSize(total_size);
249   SetCachedSize(cached_size);
250   return total_size;
251 }
252 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)253 void SoftirqEntryFtraceEvent::CheckTypeAndMergeFrom(
254     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
255   MergeFrom(*::_pbi::DownCast<const SoftirqEntryFtraceEvent*>(
256       &from));
257 }
258 
MergeFrom(const SoftirqEntryFtraceEvent & from)259 void SoftirqEntryFtraceEvent::MergeFrom(const SoftirqEntryFtraceEvent& from) {
260   SoftirqEntryFtraceEvent* const _this = this;
261   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SoftirqEntryFtraceEvent)
262   GOOGLE_DCHECK_NE(&from, _this);
263   ::uint32_t cached_has_bits = 0;
264   (void) cached_has_bits;
265 
266   if (from._internal_has_vec()) {
267     _this->_internal_set_vec(from._internal_vec());
268   }
269   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
270 }
271 
CopyFrom(const SoftirqEntryFtraceEvent & from)272 void SoftirqEntryFtraceEvent::CopyFrom(const SoftirqEntryFtraceEvent& from) {
273 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SoftirqEntryFtraceEvent)
274   if (&from == this) return;
275   Clear();
276   MergeFrom(from);
277 }
278 
IsInitialized() const279 bool SoftirqEntryFtraceEvent::IsInitialized() const {
280   return true;
281 }
282 
InternalSwap(SoftirqEntryFtraceEvent * other)283 void SoftirqEntryFtraceEvent::InternalSwap(SoftirqEntryFtraceEvent* other) {
284   using std::swap;
285   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
286   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
287   swap(_impl_.vec_, other->_impl_.vec_);
288 }
289 
GetTypeName() const290 std::string SoftirqEntryFtraceEvent::GetTypeName() const {
291   return "perfetto.protos.SoftirqEntryFtraceEvent";
292 }
293 
294 
295 // ===================================================================
296 
297 class SoftirqExitFtraceEvent::_Internal {
298  public:
299   using HasBits = decltype(std::declval<SoftirqExitFtraceEvent>()._impl_._has_bits_);
set_has_vec(HasBits * has_bits)300   static void set_has_vec(HasBits* has_bits) {
301     (*has_bits)[0] |= 1u;
302   }
303 };
304 
SoftirqExitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)305 SoftirqExitFtraceEvent::SoftirqExitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
306                          bool is_message_owned)
307   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
308   SharedCtor(arena, is_message_owned);
309   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SoftirqExitFtraceEvent)
310 }
SoftirqExitFtraceEvent(const SoftirqExitFtraceEvent & from)311 SoftirqExitFtraceEvent::SoftirqExitFtraceEvent(const SoftirqExitFtraceEvent& from)
312   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
313   SoftirqExitFtraceEvent* const _this = this; (void)_this;
314   new (&_impl_) Impl_{
315       decltype(_impl_._has_bits_){from._impl_._has_bits_}
316     , /*decltype(_impl_._cached_size_)*/{}
317     , decltype(_impl_.vec_){}};
318 
319   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
320   _this->_impl_.vec_ = from._impl_.vec_;
321   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SoftirqExitFtraceEvent)
322 }
323 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)324 inline void SoftirqExitFtraceEvent::SharedCtor(
325     ::_pb::Arena* arena, bool is_message_owned) {
326   (void)arena;
327   (void)is_message_owned;
328   new (&_impl_) Impl_{
329       decltype(_impl_._has_bits_){}
330     , /*decltype(_impl_._cached_size_)*/{}
331     , decltype(_impl_.vec_){0u}
332   };
333 }
334 
~SoftirqExitFtraceEvent()335 SoftirqExitFtraceEvent::~SoftirqExitFtraceEvent() {
336   // @@protoc_insertion_point(destructor:perfetto.protos.SoftirqExitFtraceEvent)
337   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
338   (void)arena;
339     return;
340   }
341   SharedDtor();
342 }
343 
SharedDtor()344 inline void SoftirqExitFtraceEvent::SharedDtor() {
345   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
346 }
347 
SetCachedSize(int size) const348 void SoftirqExitFtraceEvent::SetCachedSize(int size) const {
349   _impl_._cached_size_.Set(size);
350 }
351 
Clear()352 void SoftirqExitFtraceEvent::Clear() {
353 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SoftirqExitFtraceEvent)
354   ::uint32_t cached_has_bits = 0;
355   // Prevent compiler warnings about cached_has_bits being unused
356   (void) cached_has_bits;
357 
358   _impl_.vec_ = 0u;
359   _impl_._has_bits_.Clear();
360   _internal_metadata_.Clear<std::string>();
361 }
362 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)363 const char* SoftirqExitFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
364 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
365   _Internal::HasBits has_bits{};
366   while (!ctx->Done(&ptr)) {
367     ::uint32_t tag;
368     ptr = ::_pbi::ReadTag(ptr, &tag);
369     switch (tag >> 3) {
370       // optional uint32 vec = 1;
371       case 1:
372         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
373           _Internal::set_has_vec(&has_bits);
374           _impl_.vec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
375           CHK_(ptr);
376         } else {
377           goto handle_unusual;
378         }
379         continue;
380       default:
381         goto handle_unusual;
382     }  // switch
383   handle_unusual:
384     if ((tag == 0) || ((tag & 7) == 4)) {
385       CHK_(ptr);
386       ctx->SetLastTag(tag);
387       goto message_done;
388     }
389     ptr = UnknownFieldParse(
390         tag,
391         _internal_metadata_.mutable_unknown_fields<std::string>(),
392         ptr, ctx);
393     CHK_(ptr != nullptr);
394   }  // while
395 message_done:
396   _impl_._has_bits_.Or(has_bits);
397   return ptr;
398 failure:
399   ptr = nullptr;
400   goto message_done;
401 #undef CHK_
402 }
403 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const404 ::uint8_t* SoftirqExitFtraceEvent::_InternalSerialize(
405     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
406   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SoftirqExitFtraceEvent)
407   ::uint32_t cached_has_bits = 0;
408   (void) cached_has_bits;
409 
410   cached_has_bits = _impl_._has_bits_[0];
411   // optional uint32 vec = 1;
412   if (cached_has_bits & 0x00000001u) {
413     target = stream->EnsureSpace(target);
414     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_vec(), target);
415   }
416 
417   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
418     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
419         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
420   }
421   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SoftirqExitFtraceEvent)
422   return target;
423 }
424 
ByteSizeLong() const425 size_t SoftirqExitFtraceEvent::ByteSizeLong() const {
426 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SoftirqExitFtraceEvent)
427   size_t total_size = 0;
428 
429   ::uint32_t cached_has_bits = 0;
430   // Prevent compiler warnings about cached_has_bits being unused
431   (void) cached_has_bits;
432 
433   // optional uint32 vec = 1;
434   cached_has_bits = _impl_._has_bits_[0];
435   if (cached_has_bits & 0x00000001u) {
436     total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_vec());
437   }
438 
439   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
440     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
441   }
442   int cached_size = ::_pbi::ToCachedSize(total_size);
443   SetCachedSize(cached_size);
444   return total_size;
445 }
446 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)447 void SoftirqExitFtraceEvent::CheckTypeAndMergeFrom(
448     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
449   MergeFrom(*::_pbi::DownCast<const SoftirqExitFtraceEvent*>(
450       &from));
451 }
452 
MergeFrom(const SoftirqExitFtraceEvent & from)453 void SoftirqExitFtraceEvent::MergeFrom(const SoftirqExitFtraceEvent& from) {
454   SoftirqExitFtraceEvent* const _this = this;
455   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SoftirqExitFtraceEvent)
456   GOOGLE_DCHECK_NE(&from, _this);
457   ::uint32_t cached_has_bits = 0;
458   (void) cached_has_bits;
459 
460   if (from._internal_has_vec()) {
461     _this->_internal_set_vec(from._internal_vec());
462   }
463   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
464 }
465 
CopyFrom(const SoftirqExitFtraceEvent & from)466 void SoftirqExitFtraceEvent::CopyFrom(const SoftirqExitFtraceEvent& from) {
467 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SoftirqExitFtraceEvent)
468   if (&from == this) return;
469   Clear();
470   MergeFrom(from);
471 }
472 
IsInitialized() const473 bool SoftirqExitFtraceEvent::IsInitialized() const {
474   return true;
475 }
476 
InternalSwap(SoftirqExitFtraceEvent * other)477 void SoftirqExitFtraceEvent::InternalSwap(SoftirqExitFtraceEvent* other) {
478   using std::swap;
479   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
480   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
481   swap(_impl_.vec_, other->_impl_.vec_);
482 }
483 
GetTypeName() const484 std::string SoftirqExitFtraceEvent::GetTypeName() const {
485   return "perfetto.protos.SoftirqExitFtraceEvent";
486 }
487 
488 
489 // ===================================================================
490 
491 class SoftirqRaiseFtraceEvent::_Internal {
492  public:
493   using HasBits = decltype(std::declval<SoftirqRaiseFtraceEvent>()._impl_._has_bits_);
set_has_vec(HasBits * has_bits)494   static void set_has_vec(HasBits* has_bits) {
495     (*has_bits)[0] |= 1u;
496   }
497 };
498 
SoftirqRaiseFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)499 SoftirqRaiseFtraceEvent::SoftirqRaiseFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
500                          bool is_message_owned)
501   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
502   SharedCtor(arena, is_message_owned);
503   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SoftirqRaiseFtraceEvent)
504 }
SoftirqRaiseFtraceEvent(const SoftirqRaiseFtraceEvent & from)505 SoftirqRaiseFtraceEvent::SoftirqRaiseFtraceEvent(const SoftirqRaiseFtraceEvent& from)
506   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
507   SoftirqRaiseFtraceEvent* const _this = this; (void)_this;
508   new (&_impl_) Impl_{
509       decltype(_impl_._has_bits_){from._impl_._has_bits_}
510     , /*decltype(_impl_._cached_size_)*/{}
511     , decltype(_impl_.vec_){}};
512 
513   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
514   _this->_impl_.vec_ = from._impl_.vec_;
515   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SoftirqRaiseFtraceEvent)
516 }
517 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)518 inline void SoftirqRaiseFtraceEvent::SharedCtor(
519     ::_pb::Arena* arena, bool is_message_owned) {
520   (void)arena;
521   (void)is_message_owned;
522   new (&_impl_) Impl_{
523       decltype(_impl_._has_bits_){}
524     , /*decltype(_impl_._cached_size_)*/{}
525     , decltype(_impl_.vec_){0u}
526   };
527 }
528 
~SoftirqRaiseFtraceEvent()529 SoftirqRaiseFtraceEvent::~SoftirqRaiseFtraceEvent() {
530   // @@protoc_insertion_point(destructor:perfetto.protos.SoftirqRaiseFtraceEvent)
531   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
532   (void)arena;
533     return;
534   }
535   SharedDtor();
536 }
537 
SharedDtor()538 inline void SoftirqRaiseFtraceEvent::SharedDtor() {
539   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
540 }
541 
SetCachedSize(int size) const542 void SoftirqRaiseFtraceEvent::SetCachedSize(int size) const {
543   _impl_._cached_size_.Set(size);
544 }
545 
Clear()546 void SoftirqRaiseFtraceEvent::Clear() {
547 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SoftirqRaiseFtraceEvent)
548   ::uint32_t cached_has_bits = 0;
549   // Prevent compiler warnings about cached_has_bits being unused
550   (void) cached_has_bits;
551 
552   _impl_.vec_ = 0u;
553   _impl_._has_bits_.Clear();
554   _internal_metadata_.Clear<std::string>();
555 }
556 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)557 const char* SoftirqRaiseFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
558 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
559   _Internal::HasBits has_bits{};
560   while (!ctx->Done(&ptr)) {
561     ::uint32_t tag;
562     ptr = ::_pbi::ReadTag(ptr, &tag);
563     switch (tag >> 3) {
564       // optional uint32 vec = 1;
565       case 1:
566         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
567           _Internal::set_has_vec(&has_bits);
568           _impl_.vec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
569           CHK_(ptr);
570         } else {
571           goto handle_unusual;
572         }
573         continue;
574       default:
575         goto handle_unusual;
576     }  // switch
577   handle_unusual:
578     if ((tag == 0) || ((tag & 7) == 4)) {
579       CHK_(ptr);
580       ctx->SetLastTag(tag);
581       goto message_done;
582     }
583     ptr = UnknownFieldParse(
584         tag,
585         _internal_metadata_.mutable_unknown_fields<std::string>(),
586         ptr, ctx);
587     CHK_(ptr != nullptr);
588   }  // while
589 message_done:
590   _impl_._has_bits_.Or(has_bits);
591   return ptr;
592 failure:
593   ptr = nullptr;
594   goto message_done;
595 #undef CHK_
596 }
597 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const598 ::uint8_t* SoftirqRaiseFtraceEvent::_InternalSerialize(
599     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
600   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SoftirqRaiseFtraceEvent)
601   ::uint32_t cached_has_bits = 0;
602   (void) cached_has_bits;
603 
604   cached_has_bits = _impl_._has_bits_[0];
605   // optional uint32 vec = 1;
606   if (cached_has_bits & 0x00000001u) {
607     target = stream->EnsureSpace(target);
608     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_vec(), target);
609   }
610 
611   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
612     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
613         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
614   }
615   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SoftirqRaiseFtraceEvent)
616   return target;
617 }
618 
ByteSizeLong() const619 size_t SoftirqRaiseFtraceEvent::ByteSizeLong() const {
620 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SoftirqRaiseFtraceEvent)
621   size_t total_size = 0;
622 
623   ::uint32_t cached_has_bits = 0;
624   // Prevent compiler warnings about cached_has_bits being unused
625   (void) cached_has_bits;
626 
627   // optional uint32 vec = 1;
628   cached_has_bits = _impl_._has_bits_[0];
629   if (cached_has_bits & 0x00000001u) {
630     total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_vec());
631   }
632 
633   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
634     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
635   }
636   int cached_size = ::_pbi::ToCachedSize(total_size);
637   SetCachedSize(cached_size);
638   return total_size;
639 }
640 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)641 void SoftirqRaiseFtraceEvent::CheckTypeAndMergeFrom(
642     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
643   MergeFrom(*::_pbi::DownCast<const SoftirqRaiseFtraceEvent*>(
644       &from));
645 }
646 
MergeFrom(const SoftirqRaiseFtraceEvent & from)647 void SoftirqRaiseFtraceEvent::MergeFrom(const SoftirqRaiseFtraceEvent& from) {
648   SoftirqRaiseFtraceEvent* const _this = this;
649   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SoftirqRaiseFtraceEvent)
650   GOOGLE_DCHECK_NE(&from, _this);
651   ::uint32_t cached_has_bits = 0;
652   (void) cached_has_bits;
653 
654   if (from._internal_has_vec()) {
655     _this->_internal_set_vec(from._internal_vec());
656   }
657   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
658 }
659 
CopyFrom(const SoftirqRaiseFtraceEvent & from)660 void SoftirqRaiseFtraceEvent::CopyFrom(const SoftirqRaiseFtraceEvent& from) {
661 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SoftirqRaiseFtraceEvent)
662   if (&from == this) return;
663   Clear();
664   MergeFrom(from);
665 }
666 
IsInitialized() const667 bool SoftirqRaiseFtraceEvent::IsInitialized() const {
668   return true;
669 }
670 
InternalSwap(SoftirqRaiseFtraceEvent * other)671 void SoftirqRaiseFtraceEvent::InternalSwap(SoftirqRaiseFtraceEvent* other) {
672   using std::swap;
673   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
674   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
675   swap(_impl_.vec_, other->_impl_.vec_);
676 }
677 
GetTypeName() const678 std::string SoftirqRaiseFtraceEvent::GetTypeName() const {
679   return "perfetto.protos.SoftirqRaiseFtraceEvent";
680 }
681 
682 
683 // ===================================================================
684 
685 class IrqHandlerEntryFtraceEvent::_Internal {
686  public:
687   using HasBits = decltype(std::declval<IrqHandlerEntryFtraceEvent>()._impl_._has_bits_);
set_has_irq(HasBits * has_bits)688   static void set_has_irq(HasBits* has_bits) {
689     (*has_bits)[0] |= 2u;
690   }
set_has_name(HasBits * has_bits)691   static void set_has_name(HasBits* has_bits) {
692     (*has_bits)[0] |= 1u;
693   }
set_has_handler(HasBits * has_bits)694   static void set_has_handler(HasBits* has_bits) {
695     (*has_bits)[0] |= 4u;
696   }
697 };
698 
IrqHandlerEntryFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)699 IrqHandlerEntryFtraceEvent::IrqHandlerEntryFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
700                          bool is_message_owned)
701   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
702   SharedCtor(arena, is_message_owned);
703   // @@protoc_insertion_point(arena_constructor:perfetto.protos.IrqHandlerEntryFtraceEvent)
704 }
IrqHandlerEntryFtraceEvent(const IrqHandlerEntryFtraceEvent & from)705 IrqHandlerEntryFtraceEvent::IrqHandlerEntryFtraceEvent(const IrqHandlerEntryFtraceEvent& from)
706   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
707   IrqHandlerEntryFtraceEvent* const _this = this; (void)_this;
708   new (&_impl_) Impl_{
709       decltype(_impl_._has_bits_){from._impl_._has_bits_}
710     , /*decltype(_impl_._cached_size_)*/{}
711     , decltype(_impl_.name_){}
712     , decltype(_impl_.irq_){}
713     , decltype(_impl_.handler_){}};
714 
715   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
716   _impl_.name_.InitDefault();
717   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
718     _impl_.name_.Set("", GetArenaForAllocation());
719   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
720   if (from._internal_has_name()) {
721     _this->_impl_.name_.Set(from._internal_name(),
722       _this->GetArenaForAllocation());
723   }
724   ::memcpy(&_impl_.irq_, &from._impl_.irq_,
725     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.handler_) -
726     reinterpret_cast<char*>(&_impl_.irq_)) + sizeof(_impl_.handler_));
727   // @@protoc_insertion_point(copy_constructor:perfetto.protos.IrqHandlerEntryFtraceEvent)
728 }
729 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)730 inline void IrqHandlerEntryFtraceEvent::SharedCtor(
731     ::_pb::Arena* arena, bool is_message_owned) {
732   (void)arena;
733   (void)is_message_owned;
734   new (&_impl_) Impl_{
735       decltype(_impl_._has_bits_){}
736     , /*decltype(_impl_._cached_size_)*/{}
737     , decltype(_impl_.name_){}
738     , decltype(_impl_.irq_){0}
739     , decltype(_impl_.handler_){0u}
740   };
741   _impl_.name_.InitDefault();
742   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
743     _impl_.name_.Set("", GetArenaForAllocation());
744   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
745 }
746 
~IrqHandlerEntryFtraceEvent()747 IrqHandlerEntryFtraceEvent::~IrqHandlerEntryFtraceEvent() {
748   // @@protoc_insertion_point(destructor:perfetto.protos.IrqHandlerEntryFtraceEvent)
749   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
750   (void)arena;
751     return;
752   }
753   SharedDtor();
754 }
755 
SharedDtor()756 inline void IrqHandlerEntryFtraceEvent::SharedDtor() {
757   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
758   _impl_.name_.Destroy();
759 }
760 
SetCachedSize(int size) const761 void IrqHandlerEntryFtraceEvent::SetCachedSize(int size) const {
762   _impl_._cached_size_.Set(size);
763 }
764 
Clear()765 void IrqHandlerEntryFtraceEvent::Clear() {
766 // @@protoc_insertion_point(message_clear_start:perfetto.protos.IrqHandlerEntryFtraceEvent)
767   ::uint32_t cached_has_bits = 0;
768   // Prevent compiler warnings about cached_has_bits being unused
769   (void) cached_has_bits;
770 
771   cached_has_bits = _impl_._has_bits_[0];
772   if (cached_has_bits & 0x00000001u) {
773     _impl_.name_.ClearNonDefaultToEmpty();
774   }
775   if (cached_has_bits & 0x00000006u) {
776     ::memset(&_impl_.irq_, 0, static_cast<size_t>(
777         reinterpret_cast<char*>(&_impl_.handler_) -
778         reinterpret_cast<char*>(&_impl_.irq_)) + sizeof(_impl_.handler_));
779   }
780   _impl_._has_bits_.Clear();
781   _internal_metadata_.Clear<std::string>();
782 }
783 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)784 const char* IrqHandlerEntryFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
785 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
786   _Internal::HasBits has_bits{};
787   while (!ctx->Done(&ptr)) {
788     ::uint32_t tag;
789     ptr = ::_pbi::ReadTag(ptr, &tag);
790     switch (tag >> 3) {
791       // optional int32 irq = 1;
792       case 1:
793         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
794           _Internal::set_has_irq(&has_bits);
795           _impl_.irq_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
796           CHK_(ptr);
797         } else {
798           goto handle_unusual;
799         }
800         continue;
801       // optional string name = 2;
802       case 2:
803         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
804           auto str = _internal_mutable_name();
805           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
806           CHK_(ptr);
807         } else {
808           goto handle_unusual;
809         }
810         continue;
811       // optional uint32 handler = 3;
812       case 3:
813         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
814           _Internal::set_has_handler(&has_bits);
815           _impl_.handler_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
816           CHK_(ptr);
817         } else {
818           goto handle_unusual;
819         }
820         continue;
821       default:
822         goto handle_unusual;
823     }  // switch
824   handle_unusual:
825     if ((tag == 0) || ((tag & 7) == 4)) {
826       CHK_(ptr);
827       ctx->SetLastTag(tag);
828       goto message_done;
829     }
830     ptr = UnknownFieldParse(
831         tag,
832         _internal_metadata_.mutable_unknown_fields<std::string>(),
833         ptr, ctx);
834     CHK_(ptr != nullptr);
835   }  // while
836 message_done:
837   _impl_._has_bits_.Or(has_bits);
838   return ptr;
839 failure:
840   ptr = nullptr;
841   goto message_done;
842 #undef CHK_
843 }
844 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const845 ::uint8_t* IrqHandlerEntryFtraceEvent::_InternalSerialize(
846     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
847   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.IrqHandlerEntryFtraceEvent)
848   ::uint32_t cached_has_bits = 0;
849   (void) cached_has_bits;
850 
851   cached_has_bits = _impl_._has_bits_[0];
852   // optional int32 irq = 1;
853   if (cached_has_bits & 0x00000002u) {
854     target = stream->EnsureSpace(target);
855     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_irq(), target);
856   }
857 
858   // optional string name = 2;
859   if (cached_has_bits & 0x00000001u) {
860     target = stream->WriteStringMaybeAliased(
861         2, this->_internal_name(), target);
862   }
863 
864   // optional uint32 handler = 3;
865   if (cached_has_bits & 0x00000004u) {
866     target = stream->EnsureSpace(target);
867     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_handler(), target);
868   }
869 
870   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
871     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
872         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
873   }
874   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.IrqHandlerEntryFtraceEvent)
875   return target;
876 }
877 
ByteSizeLong() const878 size_t IrqHandlerEntryFtraceEvent::ByteSizeLong() const {
879 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.IrqHandlerEntryFtraceEvent)
880   size_t total_size = 0;
881 
882   ::uint32_t cached_has_bits = 0;
883   // Prevent compiler warnings about cached_has_bits being unused
884   (void) cached_has_bits;
885 
886   cached_has_bits = _impl_._has_bits_[0];
887   if (cached_has_bits & 0x00000007u) {
888     // optional string name = 2;
889     if (cached_has_bits & 0x00000001u) {
890       total_size += 1 +
891         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
892           this->_internal_name());
893     }
894 
895     // optional int32 irq = 1;
896     if (cached_has_bits & 0x00000002u) {
897       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_irq());
898     }
899 
900     // optional uint32 handler = 3;
901     if (cached_has_bits & 0x00000004u) {
902       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_handler());
903     }
904 
905   }
906   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
907     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
908   }
909   int cached_size = ::_pbi::ToCachedSize(total_size);
910   SetCachedSize(cached_size);
911   return total_size;
912 }
913 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)914 void IrqHandlerEntryFtraceEvent::CheckTypeAndMergeFrom(
915     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
916   MergeFrom(*::_pbi::DownCast<const IrqHandlerEntryFtraceEvent*>(
917       &from));
918 }
919 
MergeFrom(const IrqHandlerEntryFtraceEvent & from)920 void IrqHandlerEntryFtraceEvent::MergeFrom(const IrqHandlerEntryFtraceEvent& from) {
921   IrqHandlerEntryFtraceEvent* const _this = this;
922   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.IrqHandlerEntryFtraceEvent)
923   GOOGLE_DCHECK_NE(&from, _this);
924   ::uint32_t cached_has_bits = 0;
925   (void) cached_has_bits;
926 
927   cached_has_bits = from._impl_._has_bits_[0];
928   if (cached_has_bits & 0x00000007u) {
929     if (cached_has_bits & 0x00000001u) {
930       _this->_internal_set_name(from._internal_name());
931     }
932     if (cached_has_bits & 0x00000002u) {
933       _this->_impl_.irq_ = from._impl_.irq_;
934     }
935     if (cached_has_bits & 0x00000004u) {
936       _this->_impl_.handler_ = from._impl_.handler_;
937     }
938     _this->_impl_._has_bits_[0] |= cached_has_bits;
939   }
940   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
941 }
942 
CopyFrom(const IrqHandlerEntryFtraceEvent & from)943 void IrqHandlerEntryFtraceEvent::CopyFrom(const IrqHandlerEntryFtraceEvent& from) {
944 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.IrqHandlerEntryFtraceEvent)
945   if (&from == this) return;
946   Clear();
947   MergeFrom(from);
948 }
949 
IsInitialized() const950 bool IrqHandlerEntryFtraceEvent::IsInitialized() const {
951   return true;
952 }
953 
InternalSwap(IrqHandlerEntryFtraceEvent * other)954 void IrqHandlerEntryFtraceEvent::InternalSwap(IrqHandlerEntryFtraceEvent* other) {
955   using std::swap;
956   auto* lhs_arena = GetArenaForAllocation();
957   auto* rhs_arena = other->GetArenaForAllocation();
958   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
959   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
960   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
961       &_impl_.name_, lhs_arena,
962       &other->_impl_.name_, rhs_arena
963   );
964   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
965       PROTOBUF_FIELD_OFFSET(IrqHandlerEntryFtraceEvent, _impl_.handler_)
966       + sizeof(IrqHandlerEntryFtraceEvent::_impl_.handler_)  // NOLINT
967       - PROTOBUF_FIELD_OFFSET(IrqHandlerEntryFtraceEvent, _impl_.irq_)>(
968           reinterpret_cast<char*>(&_impl_.irq_),
969           reinterpret_cast<char*>(&other->_impl_.irq_));
970 }
971 
GetTypeName() const972 std::string IrqHandlerEntryFtraceEvent::GetTypeName() const {
973   return "perfetto.protos.IrqHandlerEntryFtraceEvent";
974 }
975 
976 
977 // ===================================================================
978 
979 class IrqHandlerExitFtraceEvent::_Internal {
980  public:
981   using HasBits = decltype(std::declval<IrqHandlerExitFtraceEvent>()._impl_._has_bits_);
set_has_irq(HasBits * has_bits)982   static void set_has_irq(HasBits* has_bits) {
983     (*has_bits)[0] |= 1u;
984   }
set_has_ret(HasBits * has_bits)985   static void set_has_ret(HasBits* has_bits) {
986     (*has_bits)[0] |= 2u;
987   }
988 };
989 
IrqHandlerExitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)990 IrqHandlerExitFtraceEvent::IrqHandlerExitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
991                          bool is_message_owned)
992   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
993   SharedCtor(arena, is_message_owned);
994   // @@protoc_insertion_point(arena_constructor:perfetto.protos.IrqHandlerExitFtraceEvent)
995 }
IrqHandlerExitFtraceEvent(const IrqHandlerExitFtraceEvent & from)996 IrqHandlerExitFtraceEvent::IrqHandlerExitFtraceEvent(const IrqHandlerExitFtraceEvent& from)
997   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
998   IrqHandlerExitFtraceEvent* const _this = this; (void)_this;
999   new (&_impl_) Impl_{
1000       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1001     , /*decltype(_impl_._cached_size_)*/{}
1002     , decltype(_impl_.irq_){}
1003     , decltype(_impl_.ret_){}};
1004 
1005   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1006   ::memcpy(&_impl_.irq_, &from._impl_.irq_,
1007     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ret_) -
1008     reinterpret_cast<char*>(&_impl_.irq_)) + sizeof(_impl_.ret_));
1009   // @@protoc_insertion_point(copy_constructor:perfetto.protos.IrqHandlerExitFtraceEvent)
1010 }
1011 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1012 inline void IrqHandlerExitFtraceEvent::SharedCtor(
1013     ::_pb::Arena* arena, bool is_message_owned) {
1014   (void)arena;
1015   (void)is_message_owned;
1016   new (&_impl_) Impl_{
1017       decltype(_impl_._has_bits_){}
1018     , /*decltype(_impl_._cached_size_)*/{}
1019     , decltype(_impl_.irq_){0}
1020     , decltype(_impl_.ret_){0}
1021   };
1022 }
1023 
~IrqHandlerExitFtraceEvent()1024 IrqHandlerExitFtraceEvent::~IrqHandlerExitFtraceEvent() {
1025   // @@protoc_insertion_point(destructor:perfetto.protos.IrqHandlerExitFtraceEvent)
1026   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1027   (void)arena;
1028     return;
1029   }
1030   SharedDtor();
1031 }
1032 
SharedDtor()1033 inline void IrqHandlerExitFtraceEvent::SharedDtor() {
1034   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1035 }
1036 
SetCachedSize(int size) const1037 void IrqHandlerExitFtraceEvent::SetCachedSize(int size) const {
1038   _impl_._cached_size_.Set(size);
1039 }
1040 
Clear()1041 void IrqHandlerExitFtraceEvent::Clear() {
1042 // @@protoc_insertion_point(message_clear_start:perfetto.protos.IrqHandlerExitFtraceEvent)
1043   ::uint32_t cached_has_bits = 0;
1044   // Prevent compiler warnings about cached_has_bits being unused
1045   (void) cached_has_bits;
1046 
1047   cached_has_bits = _impl_._has_bits_[0];
1048   if (cached_has_bits & 0x00000003u) {
1049     ::memset(&_impl_.irq_, 0, static_cast<size_t>(
1050         reinterpret_cast<char*>(&_impl_.ret_) -
1051         reinterpret_cast<char*>(&_impl_.irq_)) + sizeof(_impl_.ret_));
1052   }
1053   _impl_._has_bits_.Clear();
1054   _internal_metadata_.Clear<std::string>();
1055 }
1056 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1057 const char* IrqHandlerExitFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1058 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1059   _Internal::HasBits has_bits{};
1060   while (!ctx->Done(&ptr)) {
1061     ::uint32_t tag;
1062     ptr = ::_pbi::ReadTag(ptr, &tag);
1063     switch (tag >> 3) {
1064       // optional int32 irq = 1;
1065       case 1:
1066         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1067           _Internal::set_has_irq(&has_bits);
1068           _impl_.irq_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1069           CHK_(ptr);
1070         } else {
1071           goto handle_unusual;
1072         }
1073         continue;
1074       // optional int32 ret = 2;
1075       case 2:
1076         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1077           _Internal::set_has_ret(&has_bits);
1078           _impl_.ret_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1079           CHK_(ptr);
1080         } else {
1081           goto handle_unusual;
1082         }
1083         continue;
1084       default:
1085         goto handle_unusual;
1086     }  // switch
1087   handle_unusual:
1088     if ((tag == 0) || ((tag & 7) == 4)) {
1089       CHK_(ptr);
1090       ctx->SetLastTag(tag);
1091       goto message_done;
1092     }
1093     ptr = UnknownFieldParse(
1094         tag,
1095         _internal_metadata_.mutable_unknown_fields<std::string>(),
1096         ptr, ctx);
1097     CHK_(ptr != nullptr);
1098   }  // while
1099 message_done:
1100   _impl_._has_bits_.Or(has_bits);
1101   return ptr;
1102 failure:
1103   ptr = nullptr;
1104   goto message_done;
1105 #undef CHK_
1106 }
1107 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1108 ::uint8_t* IrqHandlerExitFtraceEvent::_InternalSerialize(
1109     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1110   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.IrqHandlerExitFtraceEvent)
1111   ::uint32_t cached_has_bits = 0;
1112   (void) cached_has_bits;
1113 
1114   cached_has_bits = _impl_._has_bits_[0];
1115   // optional int32 irq = 1;
1116   if (cached_has_bits & 0x00000001u) {
1117     target = stream->EnsureSpace(target);
1118     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_irq(), target);
1119   }
1120 
1121   // optional int32 ret = 2;
1122   if (cached_has_bits & 0x00000002u) {
1123     target = stream->EnsureSpace(target);
1124     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_ret(), target);
1125   }
1126 
1127   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1128     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1129         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1130   }
1131   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.IrqHandlerExitFtraceEvent)
1132   return target;
1133 }
1134 
ByteSizeLong() const1135 size_t IrqHandlerExitFtraceEvent::ByteSizeLong() const {
1136 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.IrqHandlerExitFtraceEvent)
1137   size_t total_size = 0;
1138 
1139   ::uint32_t cached_has_bits = 0;
1140   // Prevent compiler warnings about cached_has_bits being unused
1141   (void) cached_has_bits;
1142 
1143   cached_has_bits = _impl_._has_bits_[0];
1144   if (cached_has_bits & 0x00000003u) {
1145     // optional int32 irq = 1;
1146     if (cached_has_bits & 0x00000001u) {
1147       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_irq());
1148     }
1149 
1150     // optional int32 ret = 2;
1151     if (cached_has_bits & 0x00000002u) {
1152       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_ret());
1153     }
1154 
1155   }
1156   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1157     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1158   }
1159   int cached_size = ::_pbi::ToCachedSize(total_size);
1160   SetCachedSize(cached_size);
1161   return total_size;
1162 }
1163 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1164 void IrqHandlerExitFtraceEvent::CheckTypeAndMergeFrom(
1165     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1166   MergeFrom(*::_pbi::DownCast<const IrqHandlerExitFtraceEvent*>(
1167       &from));
1168 }
1169 
MergeFrom(const IrqHandlerExitFtraceEvent & from)1170 void IrqHandlerExitFtraceEvent::MergeFrom(const IrqHandlerExitFtraceEvent& from) {
1171   IrqHandlerExitFtraceEvent* const _this = this;
1172   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.IrqHandlerExitFtraceEvent)
1173   GOOGLE_DCHECK_NE(&from, _this);
1174   ::uint32_t cached_has_bits = 0;
1175   (void) cached_has_bits;
1176 
1177   cached_has_bits = from._impl_._has_bits_[0];
1178   if (cached_has_bits & 0x00000003u) {
1179     if (cached_has_bits & 0x00000001u) {
1180       _this->_impl_.irq_ = from._impl_.irq_;
1181     }
1182     if (cached_has_bits & 0x00000002u) {
1183       _this->_impl_.ret_ = from._impl_.ret_;
1184     }
1185     _this->_impl_._has_bits_[0] |= cached_has_bits;
1186   }
1187   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1188 }
1189 
CopyFrom(const IrqHandlerExitFtraceEvent & from)1190 void IrqHandlerExitFtraceEvent::CopyFrom(const IrqHandlerExitFtraceEvent& from) {
1191 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.IrqHandlerExitFtraceEvent)
1192   if (&from == this) return;
1193   Clear();
1194   MergeFrom(from);
1195 }
1196 
IsInitialized() const1197 bool IrqHandlerExitFtraceEvent::IsInitialized() const {
1198   return true;
1199 }
1200 
InternalSwap(IrqHandlerExitFtraceEvent * other)1201 void IrqHandlerExitFtraceEvent::InternalSwap(IrqHandlerExitFtraceEvent* other) {
1202   using std::swap;
1203   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1204   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1205   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1206       PROTOBUF_FIELD_OFFSET(IrqHandlerExitFtraceEvent, _impl_.ret_)
1207       + sizeof(IrqHandlerExitFtraceEvent::_impl_.ret_)  // NOLINT
1208       - PROTOBUF_FIELD_OFFSET(IrqHandlerExitFtraceEvent, _impl_.irq_)>(
1209           reinterpret_cast<char*>(&_impl_.irq_),
1210           reinterpret_cast<char*>(&other->_impl_.irq_));
1211 }
1212 
GetTypeName() const1213 std::string IrqHandlerExitFtraceEvent::GetTypeName() const {
1214   return "perfetto.protos.IrqHandlerExitFtraceEvent";
1215 }
1216 
1217 
1218 // @@protoc_insertion_point(namespace_scope)
1219 }  // namespace protos
1220 }  // namespace perfetto
1221 PROTOBUF_NAMESPACE_OPEN
1222 template<> PROTOBUF_NOINLINE ::perfetto::protos::SoftirqEntryFtraceEvent*
CreateMaybeMessage(Arena * arena)1223 Arena::CreateMaybeMessage< ::perfetto::protos::SoftirqEntryFtraceEvent >(Arena* arena) {
1224   return Arena::CreateMessageInternal< ::perfetto::protos::SoftirqEntryFtraceEvent >(arena);
1225 }
1226 template<> PROTOBUF_NOINLINE ::perfetto::protos::SoftirqExitFtraceEvent*
CreateMaybeMessage(Arena * arena)1227 Arena::CreateMaybeMessage< ::perfetto::protos::SoftirqExitFtraceEvent >(Arena* arena) {
1228   return Arena::CreateMessageInternal< ::perfetto::protos::SoftirqExitFtraceEvent >(arena);
1229 }
1230 template<> PROTOBUF_NOINLINE ::perfetto::protos::SoftirqRaiseFtraceEvent*
CreateMaybeMessage(Arena * arena)1231 Arena::CreateMaybeMessage< ::perfetto::protos::SoftirqRaiseFtraceEvent >(Arena* arena) {
1232   return Arena::CreateMessageInternal< ::perfetto::protos::SoftirqRaiseFtraceEvent >(arena);
1233 }
1234 template<> PROTOBUF_NOINLINE ::perfetto::protos::IrqHandlerEntryFtraceEvent*
CreateMaybeMessage(Arena * arena)1235 Arena::CreateMaybeMessage< ::perfetto::protos::IrqHandlerEntryFtraceEvent >(Arena* arena) {
1236   return Arena::CreateMessageInternal< ::perfetto::protos::IrqHandlerEntryFtraceEvent >(arena);
1237 }
1238 template<> PROTOBUF_NOINLINE ::perfetto::protos::IrqHandlerExitFtraceEvent*
CreateMaybeMessage(Arena * arena)1239 Arena::CreateMaybeMessage< ::perfetto::protos::IrqHandlerExitFtraceEvent >(Arena* arena) {
1240   return Arena::CreateMessageInternal< ::perfetto::protos::IrqHandlerExitFtraceEvent >(arena);
1241 }
1242 PROTOBUF_NAMESPACE_CLOSE
1243 
1244 // @@protoc_insertion_point(global_scope)
1245 #include <google/protobuf/port_undef.inc>
1246