1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/sde.proto
3
4 #include "protos/perfetto/trace/ftrace/sde.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 {
SdeTracingMarkWriteFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR SdeTracingMarkWriteFtraceEvent::SdeTracingMarkWriteFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.trace_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28 , /*decltype(_impl_.pid_)*/0
29 , /*decltype(_impl_.trace_type_)*/0u
30 , /*decltype(_impl_.value_)*/0
31 , /*decltype(_impl_.trace_begin_)*/0u} {}
32 struct SdeTracingMarkWriteFtraceEventDefaultTypeInternal {
SdeTracingMarkWriteFtraceEventDefaultTypeInternalperfetto::protos::SdeTracingMarkWriteFtraceEventDefaultTypeInternal33 PROTOBUF_CONSTEXPR SdeTracingMarkWriteFtraceEventDefaultTypeInternal()
34 : _instance(::_pbi::ConstantInitialized{}) {}
~SdeTracingMarkWriteFtraceEventDefaultTypeInternalperfetto::protos::SdeTracingMarkWriteFtraceEventDefaultTypeInternal35 ~SdeTracingMarkWriteFtraceEventDefaultTypeInternal() {}
36 union { // NOLINT(misc-non-private-member-variables-in-classes)
37 SdeTracingMarkWriteFtraceEvent _instance;
38 };
39 };
40 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SdeTracingMarkWriteFtraceEventDefaultTypeInternal _SdeTracingMarkWriteFtraceEvent_default_instance_;
SdeSdeEvtlogFtraceEvent(::_pbi::ConstantInitialized)41 PROTOBUF_CONSTEXPR SdeSdeEvtlogFtraceEvent::SdeSdeEvtlogFtraceEvent(
42 ::_pbi::ConstantInitialized): _impl_{
43 /*decltype(_impl_._has_bits_)*/{}
44 , /*decltype(_impl_._cached_size_)*/{}
45 , /*decltype(_impl_.evtlog_tag_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
46 , /*decltype(_impl_.pid_)*/0
47 , /*decltype(_impl_.tag_id_)*/0u} {}
48 struct SdeSdeEvtlogFtraceEventDefaultTypeInternal {
SdeSdeEvtlogFtraceEventDefaultTypeInternalperfetto::protos::SdeSdeEvtlogFtraceEventDefaultTypeInternal49 PROTOBUF_CONSTEXPR SdeSdeEvtlogFtraceEventDefaultTypeInternal()
50 : _instance(::_pbi::ConstantInitialized{}) {}
~SdeSdeEvtlogFtraceEventDefaultTypeInternalperfetto::protos::SdeSdeEvtlogFtraceEventDefaultTypeInternal51 ~SdeSdeEvtlogFtraceEventDefaultTypeInternal() {}
52 union { // NOLINT(misc-non-private-member-variables-in-classes)
53 SdeSdeEvtlogFtraceEvent _instance;
54 };
55 };
56 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SdeSdeEvtlogFtraceEventDefaultTypeInternal _SdeSdeEvtlogFtraceEvent_default_instance_;
SdeSdePerfCalcCrtcFtraceEvent(::_pbi::ConstantInitialized)57 PROTOBUF_CONSTEXPR SdeSdePerfCalcCrtcFtraceEvent::SdeSdePerfCalcCrtcFtraceEvent(
58 ::_pbi::ConstantInitialized): _impl_{
59 /*decltype(_impl_._has_bits_)*/{}
60 , /*decltype(_impl_._cached_size_)*/{}
61 , /*decltype(_impl_.bw_ctl_ebi_)*/::uint64_t{0u}
62 , /*decltype(_impl_.bw_ctl_llcc_)*/::uint64_t{0u}
63 , /*decltype(_impl_.bw_ctl_mnoc_)*/::uint64_t{0u}
64 , /*decltype(_impl_.core_clk_rate_)*/0u
65 , /*decltype(_impl_.crtc_)*/0u
66 , /*decltype(_impl_.ib_ebi_)*/::uint64_t{0u}
67 , /*decltype(_impl_.ib_llcc_)*/::uint64_t{0u}
68 , /*decltype(_impl_.ib_mnoc_)*/::uint64_t{0u}} {}
69 struct SdeSdePerfCalcCrtcFtraceEventDefaultTypeInternal {
SdeSdePerfCalcCrtcFtraceEventDefaultTypeInternalperfetto::protos::SdeSdePerfCalcCrtcFtraceEventDefaultTypeInternal70 PROTOBUF_CONSTEXPR SdeSdePerfCalcCrtcFtraceEventDefaultTypeInternal()
71 : _instance(::_pbi::ConstantInitialized{}) {}
~SdeSdePerfCalcCrtcFtraceEventDefaultTypeInternalperfetto::protos::SdeSdePerfCalcCrtcFtraceEventDefaultTypeInternal72 ~SdeSdePerfCalcCrtcFtraceEventDefaultTypeInternal() {}
73 union { // NOLINT(misc-non-private-member-variables-in-classes)
74 SdeSdePerfCalcCrtcFtraceEvent _instance;
75 };
76 };
77 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SdeSdePerfCalcCrtcFtraceEventDefaultTypeInternal _SdeSdePerfCalcCrtcFtraceEvent_default_instance_;
SdeSdePerfCrtcUpdateFtraceEvent(::_pbi::ConstantInitialized)78 PROTOBUF_CONSTEXPR SdeSdePerfCrtcUpdateFtraceEvent::SdeSdePerfCrtcUpdateFtraceEvent(
79 ::_pbi::ConstantInitialized): _impl_{
80 /*decltype(_impl_._has_bits_)*/{}
81 , /*decltype(_impl_._cached_size_)*/{}
82 , /*decltype(_impl_.bw_ctl_ebi_)*/::uint64_t{0u}
83 , /*decltype(_impl_.bw_ctl_llcc_)*/::uint64_t{0u}
84 , /*decltype(_impl_.bw_ctl_mnoc_)*/::uint64_t{0u}
85 , /*decltype(_impl_.core_clk_rate_)*/0u
86 , /*decltype(_impl_.crtc_)*/0u
87 , /*decltype(_impl_.per_pipe_ib_ebi_)*/::uint64_t{0u}
88 , /*decltype(_impl_.per_pipe_ib_llcc_)*/::uint64_t{0u}
89 , /*decltype(_impl_.params_)*/0
90 , /*decltype(_impl_.stop_req_)*/0u
91 , /*decltype(_impl_.per_pipe_ib_mnoc_)*/::uint64_t{0u}
92 , /*decltype(_impl_.update_bus_)*/0u
93 , /*decltype(_impl_.update_clk_)*/0u} {}
94 struct SdeSdePerfCrtcUpdateFtraceEventDefaultTypeInternal {
SdeSdePerfCrtcUpdateFtraceEventDefaultTypeInternalperfetto::protos::SdeSdePerfCrtcUpdateFtraceEventDefaultTypeInternal95 PROTOBUF_CONSTEXPR SdeSdePerfCrtcUpdateFtraceEventDefaultTypeInternal()
96 : _instance(::_pbi::ConstantInitialized{}) {}
~SdeSdePerfCrtcUpdateFtraceEventDefaultTypeInternalperfetto::protos::SdeSdePerfCrtcUpdateFtraceEventDefaultTypeInternal97 ~SdeSdePerfCrtcUpdateFtraceEventDefaultTypeInternal() {}
98 union { // NOLINT(misc-non-private-member-variables-in-classes)
99 SdeSdePerfCrtcUpdateFtraceEvent _instance;
100 };
101 };
102 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SdeSdePerfCrtcUpdateFtraceEventDefaultTypeInternal _SdeSdePerfCrtcUpdateFtraceEvent_default_instance_;
SdeSdePerfSetQosLutsFtraceEvent(::_pbi::ConstantInitialized)103 PROTOBUF_CONSTEXPR SdeSdePerfSetQosLutsFtraceEvent::SdeSdePerfSetQosLutsFtraceEvent(
104 ::_pbi::ConstantInitialized): _impl_{
105 /*decltype(_impl_._has_bits_)*/{}
106 , /*decltype(_impl_._cached_size_)*/{}
107 , /*decltype(_impl_.fl_)*/0u
108 , /*decltype(_impl_.fmt_)*/0u
109 , /*decltype(_impl_.lut_)*/::uint64_t{0u}
110 , /*decltype(_impl_.lut_usage_)*/0u
111 , /*decltype(_impl_.pnum_)*/0u
112 , /*decltype(_impl_.rt_)*/0u} {}
113 struct SdeSdePerfSetQosLutsFtraceEventDefaultTypeInternal {
SdeSdePerfSetQosLutsFtraceEventDefaultTypeInternalperfetto::protos::SdeSdePerfSetQosLutsFtraceEventDefaultTypeInternal114 PROTOBUF_CONSTEXPR SdeSdePerfSetQosLutsFtraceEventDefaultTypeInternal()
115 : _instance(::_pbi::ConstantInitialized{}) {}
~SdeSdePerfSetQosLutsFtraceEventDefaultTypeInternalperfetto::protos::SdeSdePerfSetQosLutsFtraceEventDefaultTypeInternal116 ~SdeSdePerfSetQosLutsFtraceEventDefaultTypeInternal() {}
117 union { // NOLINT(misc-non-private-member-variables-in-classes)
118 SdeSdePerfSetQosLutsFtraceEvent _instance;
119 };
120 };
121 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SdeSdePerfSetQosLutsFtraceEventDefaultTypeInternal _SdeSdePerfSetQosLutsFtraceEvent_default_instance_;
SdeSdePerfUpdateBusFtraceEvent(::_pbi::ConstantInitialized)122 PROTOBUF_CONSTEXPR SdeSdePerfUpdateBusFtraceEvent::SdeSdePerfUpdateBusFtraceEvent(
123 ::_pbi::ConstantInitialized): _impl_{
124 /*decltype(_impl_._has_bits_)*/{}
125 , /*decltype(_impl_._cached_size_)*/{}
126 , /*decltype(_impl_.ab_quota_)*/::uint64_t{0u}
127 , /*decltype(_impl_.bus_id_)*/0u
128 , /*decltype(_impl_.client_)*/0
129 , /*decltype(_impl_.ib_quota_)*/::uint64_t{0u}} {}
130 struct SdeSdePerfUpdateBusFtraceEventDefaultTypeInternal {
SdeSdePerfUpdateBusFtraceEventDefaultTypeInternalperfetto::protos::SdeSdePerfUpdateBusFtraceEventDefaultTypeInternal131 PROTOBUF_CONSTEXPR SdeSdePerfUpdateBusFtraceEventDefaultTypeInternal()
132 : _instance(::_pbi::ConstantInitialized{}) {}
~SdeSdePerfUpdateBusFtraceEventDefaultTypeInternalperfetto::protos::SdeSdePerfUpdateBusFtraceEventDefaultTypeInternal133 ~SdeSdePerfUpdateBusFtraceEventDefaultTypeInternal() {}
134 union { // NOLINT(misc-non-private-member-variables-in-classes)
135 SdeSdePerfUpdateBusFtraceEvent _instance;
136 };
137 };
138 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SdeSdePerfUpdateBusFtraceEventDefaultTypeInternal _SdeSdePerfUpdateBusFtraceEvent_default_instance_;
139 } // namespace protos
140 } // namespace perfetto
141 namespace perfetto {
142 namespace protos {
143
144 // ===================================================================
145
146 class SdeTracingMarkWriteFtraceEvent::_Internal {
147 public:
148 using HasBits = decltype(std::declval<SdeTracingMarkWriteFtraceEvent>()._impl_._has_bits_);
set_has_pid(HasBits * has_bits)149 static void set_has_pid(HasBits* has_bits) {
150 (*has_bits)[0] |= 2u;
151 }
set_has_trace_name(HasBits * has_bits)152 static void set_has_trace_name(HasBits* has_bits) {
153 (*has_bits)[0] |= 1u;
154 }
set_has_trace_type(HasBits * has_bits)155 static void set_has_trace_type(HasBits* has_bits) {
156 (*has_bits)[0] |= 4u;
157 }
set_has_value(HasBits * has_bits)158 static void set_has_value(HasBits* has_bits) {
159 (*has_bits)[0] |= 8u;
160 }
set_has_trace_begin(HasBits * has_bits)161 static void set_has_trace_begin(HasBits* has_bits) {
162 (*has_bits)[0] |= 16u;
163 }
164 };
165
SdeTracingMarkWriteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)166 SdeTracingMarkWriteFtraceEvent::SdeTracingMarkWriteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
167 bool is_message_owned)
168 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
169 SharedCtor(arena, is_message_owned);
170 // @@protoc_insertion_point(arena_constructor:perfetto.protos.SdeTracingMarkWriteFtraceEvent)
171 }
SdeTracingMarkWriteFtraceEvent(const SdeTracingMarkWriteFtraceEvent & from)172 SdeTracingMarkWriteFtraceEvent::SdeTracingMarkWriteFtraceEvent(const SdeTracingMarkWriteFtraceEvent& from)
173 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
174 SdeTracingMarkWriteFtraceEvent* const _this = this; (void)_this;
175 new (&_impl_) Impl_{
176 decltype(_impl_._has_bits_){from._impl_._has_bits_}
177 , /*decltype(_impl_._cached_size_)*/{}
178 , decltype(_impl_.trace_name_){}
179 , decltype(_impl_.pid_){}
180 , decltype(_impl_.trace_type_){}
181 , decltype(_impl_.value_){}
182 , decltype(_impl_.trace_begin_){}};
183
184 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
185 _impl_.trace_name_.InitDefault();
186 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
187 _impl_.trace_name_.Set("", GetArenaForAllocation());
188 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
189 if (from._internal_has_trace_name()) {
190 _this->_impl_.trace_name_.Set(from._internal_trace_name(),
191 _this->GetArenaForAllocation());
192 }
193 ::memcpy(&_impl_.pid_, &from._impl_.pid_,
194 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.trace_begin_) -
195 reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.trace_begin_));
196 // @@protoc_insertion_point(copy_constructor:perfetto.protos.SdeTracingMarkWriteFtraceEvent)
197 }
198
SharedCtor(::_pb::Arena * arena,bool is_message_owned)199 inline void SdeTracingMarkWriteFtraceEvent::SharedCtor(
200 ::_pb::Arena* arena, bool is_message_owned) {
201 (void)arena;
202 (void)is_message_owned;
203 new (&_impl_) Impl_{
204 decltype(_impl_._has_bits_){}
205 , /*decltype(_impl_._cached_size_)*/{}
206 , decltype(_impl_.trace_name_){}
207 , decltype(_impl_.pid_){0}
208 , decltype(_impl_.trace_type_){0u}
209 , decltype(_impl_.value_){0}
210 , decltype(_impl_.trace_begin_){0u}
211 };
212 _impl_.trace_name_.InitDefault();
213 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
214 _impl_.trace_name_.Set("", GetArenaForAllocation());
215 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
216 }
217
~SdeTracingMarkWriteFtraceEvent()218 SdeTracingMarkWriteFtraceEvent::~SdeTracingMarkWriteFtraceEvent() {
219 // @@protoc_insertion_point(destructor:perfetto.protos.SdeTracingMarkWriteFtraceEvent)
220 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
221 (void)arena;
222 return;
223 }
224 SharedDtor();
225 }
226
SharedDtor()227 inline void SdeTracingMarkWriteFtraceEvent::SharedDtor() {
228 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
229 _impl_.trace_name_.Destroy();
230 }
231
SetCachedSize(int size) const232 void SdeTracingMarkWriteFtraceEvent::SetCachedSize(int size) const {
233 _impl_._cached_size_.Set(size);
234 }
235
Clear()236 void SdeTracingMarkWriteFtraceEvent::Clear() {
237 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SdeTracingMarkWriteFtraceEvent)
238 ::uint32_t cached_has_bits = 0;
239 // Prevent compiler warnings about cached_has_bits being unused
240 (void) cached_has_bits;
241
242 cached_has_bits = _impl_._has_bits_[0];
243 if (cached_has_bits & 0x00000001u) {
244 _impl_.trace_name_.ClearNonDefaultToEmpty();
245 }
246 if (cached_has_bits & 0x0000001eu) {
247 ::memset(&_impl_.pid_, 0, static_cast<size_t>(
248 reinterpret_cast<char*>(&_impl_.trace_begin_) -
249 reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.trace_begin_));
250 }
251 _impl_._has_bits_.Clear();
252 _internal_metadata_.Clear<std::string>();
253 }
254
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)255 const char* SdeTracingMarkWriteFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
256 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
257 _Internal::HasBits has_bits{};
258 while (!ctx->Done(&ptr)) {
259 ::uint32_t tag;
260 ptr = ::_pbi::ReadTag(ptr, &tag);
261 switch (tag >> 3) {
262 // optional int32 pid = 1;
263 case 1:
264 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
265 _Internal::set_has_pid(&has_bits);
266 _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
267 CHK_(ptr);
268 } else {
269 goto handle_unusual;
270 }
271 continue;
272 // optional string trace_name = 2;
273 case 2:
274 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
275 auto str = _internal_mutable_trace_name();
276 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
277 CHK_(ptr);
278 } else {
279 goto handle_unusual;
280 }
281 continue;
282 // optional uint32 trace_type = 3;
283 case 3:
284 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
285 _Internal::set_has_trace_type(&has_bits);
286 _impl_.trace_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
287 CHK_(ptr);
288 } else {
289 goto handle_unusual;
290 }
291 continue;
292 // optional int32 value = 4;
293 case 4:
294 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
295 _Internal::set_has_value(&has_bits);
296 _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
297 CHK_(ptr);
298 } else {
299 goto handle_unusual;
300 }
301 continue;
302 // optional uint32 trace_begin = 5;
303 case 5:
304 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
305 _Internal::set_has_trace_begin(&has_bits);
306 _impl_.trace_begin_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
307 CHK_(ptr);
308 } else {
309 goto handle_unusual;
310 }
311 continue;
312 default:
313 goto handle_unusual;
314 } // switch
315 handle_unusual:
316 if ((tag == 0) || ((tag & 7) == 4)) {
317 CHK_(ptr);
318 ctx->SetLastTag(tag);
319 goto message_done;
320 }
321 ptr = UnknownFieldParse(
322 tag,
323 _internal_metadata_.mutable_unknown_fields<std::string>(),
324 ptr, ctx);
325 CHK_(ptr != nullptr);
326 } // while
327 message_done:
328 _impl_._has_bits_.Or(has_bits);
329 return ptr;
330 failure:
331 ptr = nullptr;
332 goto message_done;
333 #undef CHK_
334 }
335
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const336 ::uint8_t* SdeTracingMarkWriteFtraceEvent::_InternalSerialize(
337 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
338 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SdeTracingMarkWriteFtraceEvent)
339 ::uint32_t cached_has_bits = 0;
340 (void) cached_has_bits;
341
342 cached_has_bits = _impl_._has_bits_[0];
343 // optional int32 pid = 1;
344 if (cached_has_bits & 0x00000002u) {
345 target = stream->EnsureSpace(target);
346 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_pid(), target);
347 }
348
349 // optional string trace_name = 2;
350 if (cached_has_bits & 0x00000001u) {
351 target = stream->WriteStringMaybeAliased(
352 2, this->_internal_trace_name(), target);
353 }
354
355 // optional uint32 trace_type = 3;
356 if (cached_has_bits & 0x00000004u) {
357 target = stream->EnsureSpace(target);
358 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_trace_type(), target);
359 }
360
361 // optional int32 value = 4;
362 if (cached_has_bits & 0x00000008u) {
363 target = stream->EnsureSpace(target);
364 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_value(), target);
365 }
366
367 // optional uint32 trace_begin = 5;
368 if (cached_has_bits & 0x00000010u) {
369 target = stream->EnsureSpace(target);
370 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_trace_begin(), target);
371 }
372
373 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
374 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
375 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
376 }
377 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SdeTracingMarkWriteFtraceEvent)
378 return target;
379 }
380
ByteSizeLong() const381 size_t SdeTracingMarkWriteFtraceEvent::ByteSizeLong() const {
382 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SdeTracingMarkWriteFtraceEvent)
383 size_t total_size = 0;
384
385 ::uint32_t cached_has_bits = 0;
386 // Prevent compiler warnings about cached_has_bits being unused
387 (void) cached_has_bits;
388
389 cached_has_bits = _impl_._has_bits_[0];
390 if (cached_has_bits & 0x0000001fu) {
391 // optional string trace_name = 2;
392 if (cached_has_bits & 0x00000001u) {
393 total_size += 1 +
394 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
395 this->_internal_trace_name());
396 }
397
398 // optional int32 pid = 1;
399 if (cached_has_bits & 0x00000002u) {
400 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
401 }
402
403 // optional uint32 trace_type = 3;
404 if (cached_has_bits & 0x00000004u) {
405 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_trace_type());
406 }
407
408 // optional int32 value = 4;
409 if (cached_has_bits & 0x00000008u) {
410 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_value());
411 }
412
413 // optional uint32 trace_begin = 5;
414 if (cached_has_bits & 0x00000010u) {
415 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_trace_begin());
416 }
417
418 }
419 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
420 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
421 }
422 int cached_size = ::_pbi::ToCachedSize(total_size);
423 SetCachedSize(cached_size);
424 return total_size;
425 }
426
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)427 void SdeTracingMarkWriteFtraceEvent::CheckTypeAndMergeFrom(
428 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
429 MergeFrom(*::_pbi::DownCast<const SdeTracingMarkWriteFtraceEvent*>(
430 &from));
431 }
432
MergeFrom(const SdeTracingMarkWriteFtraceEvent & from)433 void SdeTracingMarkWriteFtraceEvent::MergeFrom(const SdeTracingMarkWriteFtraceEvent& from) {
434 SdeTracingMarkWriteFtraceEvent* const _this = this;
435 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SdeTracingMarkWriteFtraceEvent)
436 GOOGLE_DCHECK_NE(&from, _this);
437 ::uint32_t cached_has_bits = 0;
438 (void) cached_has_bits;
439
440 cached_has_bits = from._impl_._has_bits_[0];
441 if (cached_has_bits & 0x0000001fu) {
442 if (cached_has_bits & 0x00000001u) {
443 _this->_internal_set_trace_name(from._internal_trace_name());
444 }
445 if (cached_has_bits & 0x00000002u) {
446 _this->_impl_.pid_ = from._impl_.pid_;
447 }
448 if (cached_has_bits & 0x00000004u) {
449 _this->_impl_.trace_type_ = from._impl_.trace_type_;
450 }
451 if (cached_has_bits & 0x00000008u) {
452 _this->_impl_.value_ = from._impl_.value_;
453 }
454 if (cached_has_bits & 0x00000010u) {
455 _this->_impl_.trace_begin_ = from._impl_.trace_begin_;
456 }
457 _this->_impl_._has_bits_[0] |= cached_has_bits;
458 }
459 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
460 }
461
CopyFrom(const SdeTracingMarkWriteFtraceEvent & from)462 void SdeTracingMarkWriteFtraceEvent::CopyFrom(const SdeTracingMarkWriteFtraceEvent& from) {
463 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SdeTracingMarkWriteFtraceEvent)
464 if (&from == this) return;
465 Clear();
466 MergeFrom(from);
467 }
468
IsInitialized() const469 bool SdeTracingMarkWriteFtraceEvent::IsInitialized() const {
470 return true;
471 }
472
InternalSwap(SdeTracingMarkWriteFtraceEvent * other)473 void SdeTracingMarkWriteFtraceEvent::InternalSwap(SdeTracingMarkWriteFtraceEvent* other) {
474 using std::swap;
475 auto* lhs_arena = GetArenaForAllocation();
476 auto* rhs_arena = other->GetArenaForAllocation();
477 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
478 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
479 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
480 &_impl_.trace_name_, lhs_arena,
481 &other->_impl_.trace_name_, rhs_arena
482 );
483 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
484 PROTOBUF_FIELD_OFFSET(SdeTracingMarkWriteFtraceEvent, _impl_.trace_begin_)
485 + sizeof(SdeTracingMarkWriteFtraceEvent::_impl_.trace_begin_) // NOLINT
486 - PROTOBUF_FIELD_OFFSET(SdeTracingMarkWriteFtraceEvent, _impl_.pid_)>(
487 reinterpret_cast<char*>(&_impl_.pid_),
488 reinterpret_cast<char*>(&other->_impl_.pid_));
489 }
490
GetTypeName() const491 std::string SdeTracingMarkWriteFtraceEvent::GetTypeName() const {
492 return "perfetto.protos.SdeTracingMarkWriteFtraceEvent";
493 }
494
495
496 // ===================================================================
497
498 class SdeSdeEvtlogFtraceEvent::_Internal {
499 public:
500 using HasBits = decltype(std::declval<SdeSdeEvtlogFtraceEvent>()._impl_._has_bits_);
set_has_evtlog_tag(HasBits * has_bits)501 static void set_has_evtlog_tag(HasBits* has_bits) {
502 (*has_bits)[0] |= 1u;
503 }
set_has_pid(HasBits * has_bits)504 static void set_has_pid(HasBits* has_bits) {
505 (*has_bits)[0] |= 2u;
506 }
set_has_tag_id(HasBits * has_bits)507 static void set_has_tag_id(HasBits* has_bits) {
508 (*has_bits)[0] |= 4u;
509 }
510 };
511
SdeSdeEvtlogFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)512 SdeSdeEvtlogFtraceEvent::SdeSdeEvtlogFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
513 bool is_message_owned)
514 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
515 SharedCtor(arena, is_message_owned);
516 // @@protoc_insertion_point(arena_constructor:perfetto.protos.SdeSdeEvtlogFtraceEvent)
517 }
SdeSdeEvtlogFtraceEvent(const SdeSdeEvtlogFtraceEvent & from)518 SdeSdeEvtlogFtraceEvent::SdeSdeEvtlogFtraceEvent(const SdeSdeEvtlogFtraceEvent& from)
519 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
520 SdeSdeEvtlogFtraceEvent* const _this = this; (void)_this;
521 new (&_impl_) Impl_{
522 decltype(_impl_._has_bits_){from._impl_._has_bits_}
523 , /*decltype(_impl_._cached_size_)*/{}
524 , decltype(_impl_.evtlog_tag_){}
525 , decltype(_impl_.pid_){}
526 , decltype(_impl_.tag_id_){}};
527
528 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
529 _impl_.evtlog_tag_.InitDefault();
530 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
531 _impl_.evtlog_tag_.Set("", GetArenaForAllocation());
532 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
533 if (from._internal_has_evtlog_tag()) {
534 _this->_impl_.evtlog_tag_.Set(from._internal_evtlog_tag(),
535 _this->GetArenaForAllocation());
536 }
537 ::memcpy(&_impl_.pid_, &from._impl_.pid_,
538 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.tag_id_) -
539 reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.tag_id_));
540 // @@protoc_insertion_point(copy_constructor:perfetto.protos.SdeSdeEvtlogFtraceEvent)
541 }
542
SharedCtor(::_pb::Arena * arena,bool is_message_owned)543 inline void SdeSdeEvtlogFtraceEvent::SharedCtor(
544 ::_pb::Arena* arena, bool is_message_owned) {
545 (void)arena;
546 (void)is_message_owned;
547 new (&_impl_) Impl_{
548 decltype(_impl_._has_bits_){}
549 , /*decltype(_impl_._cached_size_)*/{}
550 , decltype(_impl_.evtlog_tag_){}
551 , decltype(_impl_.pid_){0}
552 , decltype(_impl_.tag_id_){0u}
553 };
554 _impl_.evtlog_tag_.InitDefault();
555 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
556 _impl_.evtlog_tag_.Set("", GetArenaForAllocation());
557 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
558 }
559
~SdeSdeEvtlogFtraceEvent()560 SdeSdeEvtlogFtraceEvent::~SdeSdeEvtlogFtraceEvent() {
561 // @@protoc_insertion_point(destructor:perfetto.protos.SdeSdeEvtlogFtraceEvent)
562 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
563 (void)arena;
564 return;
565 }
566 SharedDtor();
567 }
568
SharedDtor()569 inline void SdeSdeEvtlogFtraceEvent::SharedDtor() {
570 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
571 _impl_.evtlog_tag_.Destroy();
572 }
573
SetCachedSize(int size) const574 void SdeSdeEvtlogFtraceEvent::SetCachedSize(int size) const {
575 _impl_._cached_size_.Set(size);
576 }
577
Clear()578 void SdeSdeEvtlogFtraceEvent::Clear() {
579 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SdeSdeEvtlogFtraceEvent)
580 ::uint32_t cached_has_bits = 0;
581 // Prevent compiler warnings about cached_has_bits being unused
582 (void) cached_has_bits;
583
584 cached_has_bits = _impl_._has_bits_[0];
585 if (cached_has_bits & 0x00000001u) {
586 _impl_.evtlog_tag_.ClearNonDefaultToEmpty();
587 }
588 if (cached_has_bits & 0x00000006u) {
589 ::memset(&_impl_.pid_, 0, static_cast<size_t>(
590 reinterpret_cast<char*>(&_impl_.tag_id_) -
591 reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.tag_id_));
592 }
593 _impl_._has_bits_.Clear();
594 _internal_metadata_.Clear<std::string>();
595 }
596
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)597 const char* SdeSdeEvtlogFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
598 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
599 _Internal::HasBits has_bits{};
600 while (!ctx->Done(&ptr)) {
601 ::uint32_t tag;
602 ptr = ::_pbi::ReadTag(ptr, &tag);
603 switch (tag >> 3) {
604 // optional string evtlog_tag = 1;
605 case 1:
606 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
607 auto str = _internal_mutable_evtlog_tag();
608 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
609 CHK_(ptr);
610 } else {
611 goto handle_unusual;
612 }
613 continue;
614 // optional int32 pid = 2;
615 case 2:
616 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
617 _Internal::set_has_pid(&has_bits);
618 _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
619 CHK_(ptr);
620 } else {
621 goto handle_unusual;
622 }
623 continue;
624 // optional uint32 tag_id = 3;
625 case 3:
626 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
627 _Internal::set_has_tag_id(&has_bits);
628 _impl_.tag_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
629 CHK_(ptr);
630 } else {
631 goto handle_unusual;
632 }
633 continue;
634 default:
635 goto handle_unusual;
636 } // switch
637 handle_unusual:
638 if ((tag == 0) || ((tag & 7) == 4)) {
639 CHK_(ptr);
640 ctx->SetLastTag(tag);
641 goto message_done;
642 }
643 ptr = UnknownFieldParse(
644 tag,
645 _internal_metadata_.mutable_unknown_fields<std::string>(),
646 ptr, ctx);
647 CHK_(ptr != nullptr);
648 } // while
649 message_done:
650 _impl_._has_bits_.Or(has_bits);
651 return ptr;
652 failure:
653 ptr = nullptr;
654 goto message_done;
655 #undef CHK_
656 }
657
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const658 ::uint8_t* SdeSdeEvtlogFtraceEvent::_InternalSerialize(
659 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
660 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SdeSdeEvtlogFtraceEvent)
661 ::uint32_t cached_has_bits = 0;
662 (void) cached_has_bits;
663
664 cached_has_bits = _impl_._has_bits_[0];
665 // optional string evtlog_tag = 1;
666 if (cached_has_bits & 0x00000001u) {
667 target = stream->WriteStringMaybeAliased(
668 1, this->_internal_evtlog_tag(), target);
669 }
670
671 // optional int32 pid = 2;
672 if (cached_has_bits & 0x00000002u) {
673 target = stream->EnsureSpace(target);
674 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_pid(), target);
675 }
676
677 // optional uint32 tag_id = 3;
678 if (cached_has_bits & 0x00000004u) {
679 target = stream->EnsureSpace(target);
680 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_tag_id(), target);
681 }
682
683 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
684 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
685 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
686 }
687 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SdeSdeEvtlogFtraceEvent)
688 return target;
689 }
690
ByteSizeLong() const691 size_t SdeSdeEvtlogFtraceEvent::ByteSizeLong() const {
692 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SdeSdeEvtlogFtraceEvent)
693 size_t total_size = 0;
694
695 ::uint32_t cached_has_bits = 0;
696 // Prevent compiler warnings about cached_has_bits being unused
697 (void) cached_has_bits;
698
699 cached_has_bits = _impl_._has_bits_[0];
700 if (cached_has_bits & 0x00000007u) {
701 // optional string evtlog_tag = 1;
702 if (cached_has_bits & 0x00000001u) {
703 total_size += 1 +
704 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
705 this->_internal_evtlog_tag());
706 }
707
708 // optional int32 pid = 2;
709 if (cached_has_bits & 0x00000002u) {
710 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
711 }
712
713 // optional uint32 tag_id = 3;
714 if (cached_has_bits & 0x00000004u) {
715 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tag_id());
716 }
717
718 }
719 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
720 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
721 }
722 int cached_size = ::_pbi::ToCachedSize(total_size);
723 SetCachedSize(cached_size);
724 return total_size;
725 }
726
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)727 void SdeSdeEvtlogFtraceEvent::CheckTypeAndMergeFrom(
728 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
729 MergeFrom(*::_pbi::DownCast<const SdeSdeEvtlogFtraceEvent*>(
730 &from));
731 }
732
MergeFrom(const SdeSdeEvtlogFtraceEvent & from)733 void SdeSdeEvtlogFtraceEvent::MergeFrom(const SdeSdeEvtlogFtraceEvent& from) {
734 SdeSdeEvtlogFtraceEvent* const _this = this;
735 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SdeSdeEvtlogFtraceEvent)
736 GOOGLE_DCHECK_NE(&from, _this);
737 ::uint32_t cached_has_bits = 0;
738 (void) cached_has_bits;
739
740 cached_has_bits = from._impl_._has_bits_[0];
741 if (cached_has_bits & 0x00000007u) {
742 if (cached_has_bits & 0x00000001u) {
743 _this->_internal_set_evtlog_tag(from._internal_evtlog_tag());
744 }
745 if (cached_has_bits & 0x00000002u) {
746 _this->_impl_.pid_ = from._impl_.pid_;
747 }
748 if (cached_has_bits & 0x00000004u) {
749 _this->_impl_.tag_id_ = from._impl_.tag_id_;
750 }
751 _this->_impl_._has_bits_[0] |= cached_has_bits;
752 }
753 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
754 }
755
CopyFrom(const SdeSdeEvtlogFtraceEvent & from)756 void SdeSdeEvtlogFtraceEvent::CopyFrom(const SdeSdeEvtlogFtraceEvent& from) {
757 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SdeSdeEvtlogFtraceEvent)
758 if (&from == this) return;
759 Clear();
760 MergeFrom(from);
761 }
762
IsInitialized() const763 bool SdeSdeEvtlogFtraceEvent::IsInitialized() const {
764 return true;
765 }
766
InternalSwap(SdeSdeEvtlogFtraceEvent * other)767 void SdeSdeEvtlogFtraceEvent::InternalSwap(SdeSdeEvtlogFtraceEvent* other) {
768 using std::swap;
769 auto* lhs_arena = GetArenaForAllocation();
770 auto* rhs_arena = other->GetArenaForAllocation();
771 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
772 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
773 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
774 &_impl_.evtlog_tag_, lhs_arena,
775 &other->_impl_.evtlog_tag_, rhs_arena
776 );
777 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
778 PROTOBUF_FIELD_OFFSET(SdeSdeEvtlogFtraceEvent, _impl_.tag_id_)
779 + sizeof(SdeSdeEvtlogFtraceEvent::_impl_.tag_id_) // NOLINT
780 - PROTOBUF_FIELD_OFFSET(SdeSdeEvtlogFtraceEvent, _impl_.pid_)>(
781 reinterpret_cast<char*>(&_impl_.pid_),
782 reinterpret_cast<char*>(&other->_impl_.pid_));
783 }
784
GetTypeName() const785 std::string SdeSdeEvtlogFtraceEvent::GetTypeName() const {
786 return "perfetto.protos.SdeSdeEvtlogFtraceEvent";
787 }
788
789
790 // ===================================================================
791
792 class SdeSdePerfCalcCrtcFtraceEvent::_Internal {
793 public:
794 using HasBits = decltype(std::declval<SdeSdePerfCalcCrtcFtraceEvent>()._impl_._has_bits_);
set_has_bw_ctl_ebi(HasBits * has_bits)795 static void set_has_bw_ctl_ebi(HasBits* has_bits) {
796 (*has_bits)[0] |= 1u;
797 }
set_has_bw_ctl_llcc(HasBits * has_bits)798 static void set_has_bw_ctl_llcc(HasBits* has_bits) {
799 (*has_bits)[0] |= 2u;
800 }
set_has_bw_ctl_mnoc(HasBits * has_bits)801 static void set_has_bw_ctl_mnoc(HasBits* has_bits) {
802 (*has_bits)[0] |= 4u;
803 }
set_has_core_clk_rate(HasBits * has_bits)804 static void set_has_core_clk_rate(HasBits* has_bits) {
805 (*has_bits)[0] |= 8u;
806 }
set_has_crtc(HasBits * has_bits)807 static void set_has_crtc(HasBits* has_bits) {
808 (*has_bits)[0] |= 16u;
809 }
set_has_ib_ebi(HasBits * has_bits)810 static void set_has_ib_ebi(HasBits* has_bits) {
811 (*has_bits)[0] |= 32u;
812 }
set_has_ib_llcc(HasBits * has_bits)813 static void set_has_ib_llcc(HasBits* has_bits) {
814 (*has_bits)[0] |= 64u;
815 }
set_has_ib_mnoc(HasBits * has_bits)816 static void set_has_ib_mnoc(HasBits* has_bits) {
817 (*has_bits)[0] |= 128u;
818 }
819 };
820
SdeSdePerfCalcCrtcFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)821 SdeSdePerfCalcCrtcFtraceEvent::SdeSdePerfCalcCrtcFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
822 bool is_message_owned)
823 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
824 SharedCtor(arena, is_message_owned);
825 // @@protoc_insertion_point(arena_constructor:perfetto.protos.SdeSdePerfCalcCrtcFtraceEvent)
826 }
SdeSdePerfCalcCrtcFtraceEvent(const SdeSdePerfCalcCrtcFtraceEvent & from)827 SdeSdePerfCalcCrtcFtraceEvent::SdeSdePerfCalcCrtcFtraceEvent(const SdeSdePerfCalcCrtcFtraceEvent& from)
828 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
829 SdeSdePerfCalcCrtcFtraceEvent* const _this = this; (void)_this;
830 new (&_impl_) Impl_{
831 decltype(_impl_._has_bits_){from._impl_._has_bits_}
832 , /*decltype(_impl_._cached_size_)*/{}
833 , decltype(_impl_.bw_ctl_ebi_){}
834 , decltype(_impl_.bw_ctl_llcc_){}
835 , decltype(_impl_.bw_ctl_mnoc_){}
836 , decltype(_impl_.core_clk_rate_){}
837 , decltype(_impl_.crtc_){}
838 , decltype(_impl_.ib_ebi_){}
839 , decltype(_impl_.ib_llcc_){}
840 , decltype(_impl_.ib_mnoc_){}};
841
842 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
843 ::memcpy(&_impl_.bw_ctl_ebi_, &from._impl_.bw_ctl_ebi_,
844 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ib_mnoc_) -
845 reinterpret_cast<char*>(&_impl_.bw_ctl_ebi_)) + sizeof(_impl_.ib_mnoc_));
846 // @@protoc_insertion_point(copy_constructor:perfetto.protos.SdeSdePerfCalcCrtcFtraceEvent)
847 }
848
SharedCtor(::_pb::Arena * arena,bool is_message_owned)849 inline void SdeSdePerfCalcCrtcFtraceEvent::SharedCtor(
850 ::_pb::Arena* arena, bool is_message_owned) {
851 (void)arena;
852 (void)is_message_owned;
853 new (&_impl_) Impl_{
854 decltype(_impl_._has_bits_){}
855 , /*decltype(_impl_._cached_size_)*/{}
856 , decltype(_impl_.bw_ctl_ebi_){::uint64_t{0u}}
857 , decltype(_impl_.bw_ctl_llcc_){::uint64_t{0u}}
858 , decltype(_impl_.bw_ctl_mnoc_){::uint64_t{0u}}
859 , decltype(_impl_.core_clk_rate_){0u}
860 , decltype(_impl_.crtc_){0u}
861 , decltype(_impl_.ib_ebi_){::uint64_t{0u}}
862 , decltype(_impl_.ib_llcc_){::uint64_t{0u}}
863 , decltype(_impl_.ib_mnoc_){::uint64_t{0u}}
864 };
865 }
866
~SdeSdePerfCalcCrtcFtraceEvent()867 SdeSdePerfCalcCrtcFtraceEvent::~SdeSdePerfCalcCrtcFtraceEvent() {
868 // @@protoc_insertion_point(destructor:perfetto.protos.SdeSdePerfCalcCrtcFtraceEvent)
869 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
870 (void)arena;
871 return;
872 }
873 SharedDtor();
874 }
875
SharedDtor()876 inline void SdeSdePerfCalcCrtcFtraceEvent::SharedDtor() {
877 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
878 }
879
SetCachedSize(int size) const880 void SdeSdePerfCalcCrtcFtraceEvent::SetCachedSize(int size) const {
881 _impl_._cached_size_.Set(size);
882 }
883
Clear()884 void SdeSdePerfCalcCrtcFtraceEvent::Clear() {
885 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SdeSdePerfCalcCrtcFtraceEvent)
886 ::uint32_t cached_has_bits = 0;
887 // Prevent compiler warnings about cached_has_bits being unused
888 (void) cached_has_bits;
889
890 cached_has_bits = _impl_._has_bits_[0];
891 if (cached_has_bits & 0x000000ffu) {
892 ::memset(&_impl_.bw_ctl_ebi_, 0, static_cast<size_t>(
893 reinterpret_cast<char*>(&_impl_.ib_mnoc_) -
894 reinterpret_cast<char*>(&_impl_.bw_ctl_ebi_)) + sizeof(_impl_.ib_mnoc_));
895 }
896 _impl_._has_bits_.Clear();
897 _internal_metadata_.Clear<std::string>();
898 }
899
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)900 const char* SdeSdePerfCalcCrtcFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
901 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
902 _Internal::HasBits has_bits{};
903 while (!ctx->Done(&ptr)) {
904 ::uint32_t tag;
905 ptr = ::_pbi::ReadTag(ptr, &tag);
906 switch (tag >> 3) {
907 // optional uint64 bw_ctl_ebi = 1;
908 case 1:
909 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
910 _Internal::set_has_bw_ctl_ebi(&has_bits);
911 _impl_.bw_ctl_ebi_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
912 CHK_(ptr);
913 } else {
914 goto handle_unusual;
915 }
916 continue;
917 // optional uint64 bw_ctl_llcc = 2;
918 case 2:
919 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
920 _Internal::set_has_bw_ctl_llcc(&has_bits);
921 _impl_.bw_ctl_llcc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
922 CHK_(ptr);
923 } else {
924 goto handle_unusual;
925 }
926 continue;
927 // optional uint64 bw_ctl_mnoc = 3;
928 case 3:
929 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
930 _Internal::set_has_bw_ctl_mnoc(&has_bits);
931 _impl_.bw_ctl_mnoc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
932 CHK_(ptr);
933 } else {
934 goto handle_unusual;
935 }
936 continue;
937 // optional uint32 core_clk_rate = 4;
938 case 4:
939 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
940 _Internal::set_has_core_clk_rate(&has_bits);
941 _impl_.core_clk_rate_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
942 CHK_(ptr);
943 } else {
944 goto handle_unusual;
945 }
946 continue;
947 // optional uint32 crtc = 5;
948 case 5:
949 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
950 _Internal::set_has_crtc(&has_bits);
951 _impl_.crtc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
952 CHK_(ptr);
953 } else {
954 goto handle_unusual;
955 }
956 continue;
957 // optional uint64 ib_ebi = 6;
958 case 6:
959 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
960 _Internal::set_has_ib_ebi(&has_bits);
961 _impl_.ib_ebi_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
962 CHK_(ptr);
963 } else {
964 goto handle_unusual;
965 }
966 continue;
967 // optional uint64 ib_llcc = 7;
968 case 7:
969 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
970 _Internal::set_has_ib_llcc(&has_bits);
971 _impl_.ib_llcc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
972 CHK_(ptr);
973 } else {
974 goto handle_unusual;
975 }
976 continue;
977 // optional uint64 ib_mnoc = 8;
978 case 8:
979 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
980 _Internal::set_has_ib_mnoc(&has_bits);
981 _impl_.ib_mnoc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
982 CHK_(ptr);
983 } else {
984 goto handle_unusual;
985 }
986 continue;
987 default:
988 goto handle_unusual;
989 } // switch
990 handle_unusual:
991 if ((tag == 0) || ((tag & 7) == 4)) {
992 CHK_(ptr);
993 ctx->SetLastTag(tag);
994 goto message_done;
995 }
996 ptr = UnknownFieldParse(
997 tag,
998 _internal_metadata_.mutable_unknown_fields<std::string>(),
999 ptr, ctx);
1000 CHK_(ptr != nullptr);
1001 } // while
1002 message_done:
1003 _impl_._has_bits_.Or(has_bits);
1004 return ptr;
1005 failure:
1006 ptr = nullptr;
1007 goto message_done;
1008 #undef CHK_
1009 }
1010
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1011 ::uint8_t* SdeSdePerfCalcCrtcFtraceEvent::_InternalSerialize(
1012 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1013 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SdeSdePerfCalcCrtcFtraceEvent)
1014 ::uint32_t cached_has_bits = 0;
1015 (void) cached_has_bits;
1016
1017 cached_has_bits = _impl_._has_bits_[0];
1018 // optional uint64 bw_ctl_ebi = 1;
1019 if (cached_has_bits & 0x00000001u) {
1020 target = stream->EnsureSpace(target);
1021 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_bw_ctl_ebi(), target);
1022 }
1023
1024 // optional uint64 bw_ctl_llcc = 2;
1025 if (cached_has_bits & 0x00000002u) {
1026 target = stream->EnsureSpace(target);
1027 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_bw_ctl_llcc(), target);
1028 }
1029
1030 // optional uint64 bw_ctl_mnoc = 3;
1031 if (cached_has_bits & 0x00000004u) {
1032 target = stream->EnsureSpace(target);
1033 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_bw_ctl_mnoc(), target);
1034 }
1035
1036 // optional uint32 core_clk_rate = 4;
1037 if (cached_has_bits & 0x00000008u) {
1038 target = stream->EnsureSpace(target);
1039 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_core_clk_rate(), target);
1040 }
1041
1042 // optional uint32 crtc = 5;
1043 if (cached_has_bits & 0x00000010u) {
1044 target = stream->EnsureSpace(target);
1045 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_crtc(), target);
1046 }
1047
1048 // optional uint64 ib_ebi = 6;
1049 if (cached_has_bits & 0x00000020u) {
1050 target = stream->EnsureSpace(target);
1051 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_ib_ebi(), target);
1052 }
1053
1054 // optional uint64 ib_llcc = 7;
1055 if (cached_has_bits & 0x00000040u) {
1056 target = stream->EnsureSpace(target);
1057 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_ib_llcc(), target);
1058 }
1059
1060 // optional uint64 ib_mnoc = 8;
1061 if (cached_has_bits & 0x00000080u) {
1062 target = stream->EnsureSpace(target);
1063 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_ib_mnoc(), target);
1064 }
1065
1066 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1067 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1068 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1069 }
1070 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SdeSdePerfCalcCrtcFtraceEvent)
1071 return target;
1072 }
1073
ByteSizeLong() const1074 size_t SdeSdePerfCalcCrtcFtraceEvent::ByteSizeLong() const {
1075 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SdeSdePerfCalcCrtcFtraceEvent)
1076 size_t total_size = 0;
1077
1078 ::uint32_t cached_has_bits = 0;
1079 // Prevent compiler warnings about cached_has_bits being unused
1080 (void) cached_has_bits;
1081
1082 cached_has_bits = _impl_._has_bits_[0];
1083 if (cached_has_bits & 0x000000ffu) {
1084 // optional uint64 bw_ctl_ebi = 1;
1085 if (cached_has_bits & 0x00000001u) {
1086 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_bw_ctl_ebi());
1087 }
1088
1089 // optional uint64 bw_ctl_llcc = 2;
1090 if (cached_has_bits & 0x00000002u) {
1091 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_bw_ctl_llcc());
1092 }
1093
1094 // optional uint64 bw_ctl_mnoc = 3;
1095 if (cached_has_bits & 0x00000004u) {
1096 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_bw_ctl_mnoc());
1097 }
1098
1099 // optional uint32 core_clk_rate = 4;
1100 if (cached_has_bits & 0x00000008u) {
1101 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_core_clk_rate());
1102 }
1103
1104 // optional uint32 crtc = 5;
1105 if (cached_has_bits & 0x00000010u) {
1106 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_crtc());
1107 }
1108
1109 // optional uint64 ib_ebi = 6;
1110 if (cached_has_bits & 0x00000020u) {
1111 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ib_ebi());
1112 }
1113
1114 // optional uint64 ib_llcc = 7;
1115 if (cached_has_bits & 0x00000040u) {
1116 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ib_llcc());
1117 }
1118
1119 // optional uint64 ib_mnoc = 8;
1120 if (cached_has_bits & 0x00000080u) {
1121 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ib_mnoc());
1122 }
1123
1124 }
1125 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1126 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1127 }
1128 int cached_size = ::_pbi::ToCachedSize(total_size);
1129 SetCachedSize(cached_size);
1130 return total_size;
1131 }
1132
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1133 void SdeSdePerfCalcCrtcFtraceEvent::CheckTypeAndMergeFrom(
1134 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1135 MergeFrom(*::_pbi::DownCast<const SdeSdePerfCalcCrtcFtraceEvent*>(
1136 &from));
1137 }
1138
MergeFrom(const SdeSdePerfCalcCrtcFtraceEvent & from)1139 void SdeSdePerfCalcCrtcFtraceEvent::MergeFrom(const SdeSdePerfCalcCrtcFtraceEvent& from) {
1140 SdeSdePerfCalcCrtcFtraceEvent* const _this = this;
1141 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SdeSdePerfCalcCrtcFtraceEvent)
1142 GOOGLE_DCHECK_NE(&from, _this);
1143 ::uint32_t cached_has_bits = 0;
1144 (void) cached_has_bits;
1145
1146 cached_has_bits = from._impl_._has_bits_[0];
1147 if (cached_has_bits & 0x000000ffu) {
1148 if (cached_has_bits & 0x00000001u) {
1149 _this->_impl_.bw_ctl_ebi_ = from._impl_.bw_ctl_ebi_;
1150 }
1151 if (cached_has_bits & 0x00000002u) {
1152 _this->_impl_.bw_ctl_llcc_ = from._impl_.bw_ctl_llcc_;
1153 }
1154 if (cached_has_bits & 0x00000004u) {
1155 _this->_impl_.bw_ctl_mnoc_ = from._impl_.bw_ctl_mnoc_;
1156 }
1157 if (cached_has_bits & 0x00000008u) {
1158 _this->_impl_.core_clk_rate_ = from._impl_.core_clk_rate_;
1159 }
1160 if (cached_has_bits & 0x00000010u) {
1161 _this->_impl_.crtc_ = from._impl_.crtc_;
1162 }
1163 if (cached_has_bits & 0x00000020u) {
1164 _this->_impl_.ib_ebi_ = from._impl_.ib_ebi_;
1165 }
1166 if (cached_has_bits & 0x00000040u) {
1167 _this->_impl_.ib_llcc_ = from._impl_.ib_llcc_;
1168 }
1169 if (cached_has_bits & 0x00000080u) {
1170 _this->_impl_.ib_mnoc_ = from._impl_.ib_mnoc_;
1171 }
1172 _this->_impl_._has_bits_[0] |= cached_has_bits;
1173 }
1174 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1175 }
1176
CopyFrom(const SdeSdePerfCalcCrtcFtraceEvent & from)1177 void SdeSdePerfCalcCrtcFtraceEvent::CopyFrom(const SdeSdePerfCalcCrtcFtraceEvent& from) {
1178 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SdeSdePerfCalcCrtcFtraceEvent)
1179 if (&from == this) return;
1180 Clear();
1181 MergeFrom(from);
1182 }
1183
IsInitialized() const1184 bool SdeSdePerfCalcCrtcFtraceEvent::IsInitialized() const {
1185 return true;
1186 }
1187
InternalSwap(SdeSdePerfCalcCrtcFtraceEvent * other)1188 void SdeSdePerfCalcCrtcFtraceEvent::InternalSwap(SdeSdePerfCalcCrtcFtraceEvent* other) {
1189 using std::swap;
1190 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1191 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1192 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1193 PROTOBUF_FIELD_OFFSET(SdeSdePerfCalcCrtcFtraceEvent, _impl_.ib_mnoc_)
1194 + sizeof(SdeSdePerfCalcCrtcFtraceEvent::_impl_.ib_mnoc_) // NOLINT
1195 - PROTOBUF_FIELD_OFFSET(SdeSdePerfCalcCrtcFtraceEvent, _impl_.bw_ctl_ebi_)>(
1196 reinterpret_cast<char*>(&_impl_.bw_ctl_ebi_),
1197 reinterpret_cast<char*>(&other->_impl_.bw_ctl_ebi_));
1198 }
1199
GetTypeName() const1200 std::string SdeSdePerfCalcCrtcFtraceEvent::GetTypeName() const {
1201 return "perfetto.protos.SdeSdePerfCalcCrtcFtraceEvent";
1202 }
1203
1204
1205 // ===================================================================
1206
1207 class SdeSdePerfCrtcUpdateFtraceEvent::_Internal {
1208 public:
1209 using HasBits = decltype(std::declval<SdeSdePerfCrtcUpdateFtraceEvent>()._impl_._has_bits_);
set_has_bw_ctl_ebi(HasBits * has_bits)1210 static void set_has_bw_ctl_ebi(HasBits* has_bits) {
1211 (*has_bits)[0] |= 1u;
1212 }
set_has_bw_ctl_llcc(HasBits * has_bits)1213 static void set_has_bw_ctl_llcc(HasBits* has_bits) {
1214 (*has_bits)[0] |= 2u;
1215 }
set_has_bw_ctl_mnoc(HasBits * has_bits)1216 static void set_has_bw_ctl_mnoc(HasBits* has_bits) {
1217 (*has_bits)[0] |= 4u;
1218 }
set_has_core_clk_rate(HasBits * has_bits)1219 static void set_has_core_clk_rate(HasBits* has_bits) {
1220 (*has_bits)[0] |= 8u;
1221 }
set_has_crtc(HasBits * has_bits)1222 static void set_has_crtc(HasBits* has_bits) {
1223 (*has_bits)[0] |= 16u;
1224 }
set_has_params(HasBits * has_bits)1225 static void set_has_params(HasBits* has_bits) {
1226 (*has_bits)[0] |= 128u;
1227 }
set_has_per_pipe_ib_ebi(HasBits * has_bits)1228 static void set_has_per_pipe_ib_ebi(HasBits* has_bits) {
1229 (*has_bits)[0] |= 32u;
1230 }
set_has_per_pipe_ib_llcc(HasBits * has_bits)1231 static void set_has_per_pipe_ib_llcc(HasBits* has_bits) {
1232 (*has_bits)[0] |= 64u;
1233 }
set_has_per_pipe_ib_mnoc(HasBits * has_bits)1234 static void set_has_per_pipe_ib_mnoc(HasBits* has_bits) {
1235 (*has_bits)[0] |= 512u;
1236 }
set_has_stop_req(HasBits * has_bits)1237 static void set_has_stop_req(HasBits* has_bits) {
1238 (*has_bits)[0] |= 256u;
1239 }
set_has_update_bus(HasBits * has_bits)1240 static void set_has_update_bus(HasBits* has_bits) {
1241 (*has_bits)[0] |= 1024u;
1242 }
set_has_update_clk(HasBits * has_bits)1243 static void set_has_update_clk(HasBits* has_bits) {
1244 (*has_bits)[0] |= 2048u;
1245 }
1246 };
1247
SdeSdePerfCrtcUpdateFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1248 SdeSdePerfCrtcUpdateFtraceEvent::SdeSdePerfCrtcUpdateFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1249 bool is_message_owned)
1250 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1251 SharedCtor(arena, is_message_owned);
1252 // @@protoc_insertion_point(arena_constructor:perfetto.protos.SdeSdePerfCrtcUpdateFtraceEvent)
1253 }
SdeSdePerfCrtcUpdateFtraceEvent(const SdeSdePerfCrtcUpdateFtraceEvent & from)1254 SdeSdePerfCrtcUpdateFtraceEvent::SdeSdePerfCrtcUpdateFtraceEvent(const SdeSdePerfCrtcUpdateFtraceEvent& from)
1255 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1256 SdeSdePerfCrtcUpdateFtraceEvent* const _this = this; (void)_this;
1257 new (&_impl_) Impl_{
1258 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1259 , /*decltype(_impl_._cached_size_)*/{}
1260 , decltype(_impl_.bw_ctl_ebi_){}
1261 , decltype(_impl_.bw_ctl_llcc_){}
1262 , decltype(_impl_.bw_ctl_mnoc_){}
1263 , decltype(_impl_.core_clk_rate_){}
1264 , decltype(_impl_.crtc_){}
1265 , decltype(_impl_.per_pipe_ib_ebi_){}
1266 , decltype(_impl_.per_pipe_ib_llcc_){}
1267 , decltype(_impl_.params_){}
1268 , decltype(_impl_.stop_req_){}
1269 , decltype(_impl_.per_pipe_ib_mnoc_){}
1270 , decltype(_impl_.update_bus_){}
1271 , decltype(_impl_.update_clk_){}};
1272
1273 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1274 ::memcpy(&_impl_.bw_ctl_ebi_, &from._impl_.bw_ctl_ebi_,
1275 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.update_clk_) -
1276 reinterpret_cast<char*>(&_impl_.bw_ctl_ebi_)) + sizeof(_impl_.update_clk_));
1277 // @@protoc_insertion_point(copy_constructor:perfetto.protos.SdeSdePerfCrtcUpdateFtraceEvent)
1278 }
1279
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1280 inline void SdeSdePerfCrtcUpdateFtraceEvent::SharedCtor(
1281 ::_pb::Arena* arena, bool is_message_owned) {
1282 (void)arena;
1283 (void)is_message_owned;
1284 new (&_impl_) Impl_{
1285 decltype(_impl_._has_bits_){}
1286 , /*decltype(_impl_._cached_size_)*/{}
1287 , decltype(_impl_.bw_ctl_ebi_){::uint64_t{0u}}
1288 , decltype(_impl_.bw_ctl_llcc_){::uint64_t{0u}}
1289 , decltype(_impl_.bw_ctl_mnoc_){::uint64_t{0u}}
1290 , decltype(_impl_.core_clk_rate_){0u}
1291 , decltype(_impl_.crtc_){0u}
1292 , decltype(_impl_.per_pipe_ib_ebi_){::uint64_t{0u}}
1293 , decltype(_impl_.per_pipe_ib_llcc_){::uint64_t{0u}}
1294 , decltype(_impl_.params_){0}
1295 , decltype(_impl_.stop_req_){0u}
1296 , decltype(_impl_.per_pipe_ib_mnoc_){::uint64_t{0u}}
1297 , decltype(_impl_.update_bus_){0u}
1298 , decltype(_impl_.update_clk_){0u}
1299 };
1300 }
1301
~SdeSdePerfCrtcUpdateFtraceEvent()1302 SdeSdePerfCrtcUpdateFtraceEvent::~SdeSdePerfCrtcUpdateFtraceEvent() {
1303 // @@protoc_insertion_point(destructor:perfetto.protos.SdeSdePerfCrtcUpdateFtraceEvent)
1304 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1305 (void)arena;
1306 return;
1307 }
1308 SharedDtor();
1309 }
1310
SharedDtor()1311 inline void SdeSdePerfCrtcUpdateFtraceEvent::SharedDtor() {
1312 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1313 }
1314
SetCachedSize(int size) const1315 void SdeSdePerfCrtcUpdateFtraceEvent::SetCachedSize(int size) const {
1316 _impl_._cached_size_.Set(size);
1317 }
1318
Clear()1319 void SdeSdePerfCrtcUpdateFtraceEvent::Clear() {
1320 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SdeSdePerfCrtcUpdateFtraceEvent)
1321 ::uint32_t cached_has_bits = 0;
1322 // Prevent compiler warnings about cached_has_bits being unused
1323 (void) cached_has_bits;
1324
1325 cached_has_bits = _impl_._has_bits_[0];
1326 if (cached_has_bits & 0x000000ffu) {
1327 ::memset(&_impl_.bw_ctl_ebi_, 0, static_cast<size_t>(
1328 reinterpret_cast<char*>(&_impl_.params_) -
1329 reinterpret_cast<char*>(&_impl_.bw_ctl_ebi_)) + sizeof(_impl_.params_));
1330 }
1331 if (cached_has_bits & 0x00000f00u) {
1332 ::memset(&_impl_.stop_req_, 0, static_cast<size_t>(
1333 reinterpret_cast<char*>(&_impl_.update_clk_) -
1334 reinterpret_cast<char*>(&_impl_.stop_req_)) + sizeof(_impl_.update_clk_));
1335 }
1336 _impl_._has_bits_.Clear();
1337 _internal_metadata_.Clear<std::string>();
1338 }
1339
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1340 const char* SdeSdePerfCrtcUpdateFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1341 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1342 _Internal::HasBits has_bits{};
1343 while (!ctx->Done(&ptr)) {
1344 ::uint32_t tag;
1345 ptr = ::_pbi::ReadTag(ptr, &tag);
1346 switch (tag >> 3) {
1347 // optional uint64 bw_ctl_ebi = 1;
1348 case 1:
1349 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1350 _Internal::set_has_bw_ctl_ebi(&has_bits);
1351 _impl_.bw_ctl_ebi_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1352 CHK_(ptr);
1353 } else {
1354 goto handle_unusual;
1355 }
1356 continue;
1357 // optional uint64 bw_ctl_llcc = 2;
1358 case 2:
1359 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1360 _Internal::set_has_bw_ctl_llcc(&has_bits);
1361 _impl_.bw_ctl_llcc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1362 CHK_(ptr);
1363 } else {
1364 goto handle_unusual;
1365 }
1366 continue;
1367 // optional uint64 bw_ctl_mnoc = 3;
1368 case 3:
1369 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1370 _Internal::set_has_bw_ctl_mnoc(&has_bits);
1371 _impl_.bw_ctl_mnoc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1372 CHK_(ptr);
1373 } else {
1374 goto handle_unusual;
1375 }
1376 continue;
1377 // optional uint32 core_clk_rate = 4;
1378 case 4:
1379 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1380 _Internal::set_has_core_clk_rate(&has_bits);
1381 _impl_.core_clk_rate_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1382 CHK_(ptr);
1383 } else {
1384 goto handle_unusual;
1385 }
1386 continue;
1387 // optional uint32 crtc = 5;
1388 case 5:
1389 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1390 _Internal::set_has_crtc(&has_bits);
1391 _impl_.crtc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1392 CHK_(ptr);
1393 } else {
1394 goto handle_unusual;
1395 }
1396 continue;
1397 // optional int32 params = 6;
1398 case 6:
1399 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
1400 _Internal::set_has_params(&has_bits);
1401 _impl_.params_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1402 CHK_(ptr);
1403 } else {
1404 goto handle_unusual;
1405 }
1406 continue;
1407 // optional uint64 per_pipe_ib_ebi = 7;
1408 case 7:
1409 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
1410 _Internal::set_has_per_pipe_ib_ebi(&has_bits);
1411 _impl_.per_pipe_ib_ebi_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1412 CHK_(ptr);
1413 } else {
1414 goto handle_unusual;
1415 }
1416 continue;
1417 // optional uint64 per_pipe_ib_llcc = 8;
1418 case 8:
1419 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
1420 _Internal::set_has_per_pipe_ib_llcc(&has_bits);
1421 _impl_.per_pipe_ib_llcc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1422 CHK_(ptr);
1423 } else {
1424 goto handle_unusual;
1425 }
1426 continue;
1427 // optional uint64 per_pipe_ib_mnoc = 9;
1428 case 9:
1429 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
1430 _Internal::set_has_per_pipe_ib_mnoc(&has_bits);
1431 _impl_.per_pipe_ib_mnoc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1432 CHK_(ptr);
1433 } else {
1434 goto handle_unusual;
1435 }
1436 continue;
1437 // optional uint32 stop_req = 10;
1438 case 10:
1439 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
1440 _Internal::set_has_stop_req(&has_bits);
1441 _impl_.stop_req_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1442 CHK_(ptr);
1443 } else {
1444 goto handle_unusual;
1445 }
1446 continue;
1447 // optional uint32 update_bus = 11;
1448 case 11:
1449 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
1450 _Internal::set_has_update_bus(&has_bits);
1451 _impl_.update_bus_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1452 CHK_(ptr);
1453 } else {
1454 goto handle_unusual;
1455 }
1456 continue;
1457 // optional uint32 update_clk = 12;
1458 case 12:
1459 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 96)) {
1460 _Internal::set_has_update_clk(&has_bits);
1461 _impl_.update_clk_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1462 CHK_(ptr);
1463 } else {
1464 goto handle_unusual;
1465 }
1466 continue;
1467 default:
1468 goto handle_unusual;
1469 } // switch
1470 handle_unusual:
1471 if ((tag == 0) || ((tag & 7) == 4)) {
1472 CHK_(ptr);
1473 ctx->SetLastTag(tag);
1474 goto message_done;
1475 }
1476 ptr = UnknownFieldParse(
1477 tag,
1478 _internal_metadata_.mutable_unknown_fields<std::string>(),
1479 ptr, ctx);
1480 CHK_(ptr != nullptr);
1481 } // while
1482 message_done:
1483 _impl_._has_bits_.Or(has_bits);
1484 return ptr;
1485 failure:
1486 ptr = nullptr;
1487 goto message_done;
1488 #undef CHK_
1489 }
1490
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1491 ::uint8_t* SdeSdePerfCrtcUpdateFtraceEvent::_InternalSerialize(
1492 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1493 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SdeSdePerfCrtcUpdateFtraceEvent)
1494 ::uint32_t cached_has_bits = 0;
1495 (void) cached_has_bits;
1496
1497 cached_has_bits = _impl_._has_bits_[0];
1498 // optional uint64 bw_ctl_ebi = 1;
1499 if (cached_has_bits & 0x00000001u) {
1500 target = stream->EnsureSpace(target);
1501 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_bw_ctl_ebi(), target);
1502 }
1503
1504 // optional uint64 bw_ctl_llcc = 2;
1505 if (cached_has_bits & 0x00000002u) {
1506 target = stream->EnsureSpace(target);
1507 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_bw_ctl_llcc(), target);
1508 }
1509
1510 // optional uint64 bw_ctl_mnoc = 3;
1511 if (cached_has_bits & 0x00000004u) {
1512 target = stream->EnsureSpace(target);
1513 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_bw_ctl_mnoc(), target);
1514 }
1515
1516 // optional uint32 core_clk_rate = 4;
1517 if (cached_has_bits & 0x00000008u) {
1518 target = stream->EnsureSpace(target);
1519 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_core_clk_rate(), target);
1520 }
1521
1522 // optional uint32 crtc = 5;
1523 if (cached_has_bits & 0x00000010u) {
1524 target = stream->EnsureSpace(target);
1525 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_crtc(), target);
1526 }
1527
1528 // optional int32 params = 6;
1529 if (cached_has_bits & 0x00000080u) {
1530 target = stream->EnsureSpace(target);
1531 target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_params(), target);
1532 }
1533
1534 // optional uint64 per_pipe_ib_ebi = 7;
1535 if (cached_has_bits & 0x00000020u) {
1536 target = stream->EnsureSpace(target);
1537 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_per_pipe_ib_ebi(), target);
1538 }
1539
1540 // optional uint64 per_pipe_ib_llcc = 8;
1541 if (cached_has_bits & 0x00000040u) {
1542 target = stream->EnsureSpace(target);
1543 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_per_pipe_ib_llcc(), target);
1544 }
1545
1546 // optional uint64 per_pipe_ib_mnoc = 9;
1547 if (cached_has_bits & 0x00000200u) {
1548 target = stream->EnsureSpace(target);
1549 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(9, this->_internal_per_pipe_ib_mnoc(), target);
1550 }
1551
1552 // optional uint32 stop_req = 10;
1553 if (cached_has_bits & 0x00000100u) {
1554 target = stream->EnsureSpace(target);
1555 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_stop_req(), target);
1556 }
1557
1558 // optional uint32 update_bus = 11;
1559 if (cached_has_bits & 0x00000400u) {
1560 target = stream->EnsureSpace(target);
1561 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(11, this->_internal_update_bus(), target);
1562 }
1563
1564 // optional uint32 update_clk = 12;
1565 if (cached_has_bits & 0x00000800u) {
1566 target = stream->EnsureSpace(target);
1567 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(12, this->_internal_update_clk(), target);
1568 }
1569
1570 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1571 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1572 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1573 }
1574 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SdeSdePerfCrtcUpdateFtraceEvent)
1575 return target;
1576 }
1577
ByteSizeLong() const1578 size_t SdeSdePerfCrtcUpdateFtraceEvent::ByteSizeLong() const {
1579 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SdeSdePerfCrtcUpdateFtraceEvent)
1580 size_t total_size = 0;
1581
1582 ::uint32_t cached_has_bits = 0;
1583 // Prevent compiler warnings about cached_has_bits being unused
1584 (void) cached_has_bits;
1585
1586 cached_has_bits = _impl_._has_bits_[0];
1587 if (cached_has_bits & 0x000000ffu) {
1588 // optional uint64 bw_ctl_ebi = 1;
1589 if (cached_has_bits & 0x00000001u) {
1590 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_bw_ctl_ebi());
1591 }
1592
1593 // optional uint64 bw_ctl_llcc = 2;
1594 if (cached_has_bits & 0x00000002u) {
1595 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_bw_ctl_llcc());
1596 }
1597
1598 // optional uint64 bw_ctl_mnoc = 3;
1599 if (cached_has_bits & 0x00000004u) {
1600 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_bw_ctl_mnoc());
1601 }
1602
1603 // optional uint32 core_clk_rate = 4;
1604 if (cached_has_bits & 0x00000008u) {
1605 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_core_clk_rate());
1606 }
1607
1608 // optional uint32 crtc = 5;
1609 if (cached_has_bits & 0x00000010u) {
1610 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_crtc());
1611 }
1612
1613 // optional uint64 per_pipe_ib_ebi = 7;
1614 if (cached_has_bits & 0x00000020u) {
1615 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_per_pipe_ib_ebi());
1616 }
1617
1618 // optional uint64 per_pipe_ib_llcc = 8;
1619 if (cached_has_bits & 0x00000040u) {
1620 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_per_pipe_ib_llcc());
1621 }
1622
1623 // optional int32 params = 6;
1624 if (cached_has_bits & 0x00000080u) {
1625 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_params());
1626 }
1627
1628 }
1629 if (cached_has_bits & 0x00000f00u) {
1630 // optional uint32 stop_req = 10;
1631 if (cached_has_bits & 0x00000100u) {
1632 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_stop_req());
1633 }
1634
1635 // optional uint64 per_pipe_ib_mnoc = 9;
1636 if (cached_has_bits & 0x00000200u) {
1637 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_per_pipe_ib_mnoc());
1638 }
1639
1640 // optional uint32 update_bus = 11;
1641 if (cached_has_bits & 0x00000400u) {
1642 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_update_bus());
1643 }
1644
1645 // optional uint32 update_clk = 12;
1646 if (cached_has_bits & 0x00000800u) {
1647 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_update_clk());
1648 }
1649
1650 }
1651 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1652 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1653 }
1654 int cached_size = ::_pbi::ToCachedSize(total_size);
1655 SetCachedSize(cached_size);
1656 return total_size;
1657 }
1658
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1659 void SdeSdePerfCrtcUpdateFtraceEvent::CheckTypeAndMergeFrom(
1660 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1661 MergeFrom(*::_pbi::DownCast<const SdeSdePerfCrtcUpdateFtraceEvent*>(
1662 &from));
1663 }
1664
MergeFrom(const SdeSdePerfCrtcUpdateFtraceEvent & from)1665 void SdeSdePerfCrtcUpdateFtraceEvent::MergeFrom(const SdeSdePerfCrtcUpdateFtraceEvent& from) {
1666 SdeSdePerfCrtcUpdateFtraceEvent* const _this = this;
1667 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SdeSdePerfCrtcUpdateFtraceEvent)
1668 GOOGLE_DCHECK_NE(&from, _this);
1669 ::uint32_t cached_has_bits = 0;
1670 (void) cached_has_bits;
1671
1672 cached_has_bits = from._impl_._has_bits_[0];
1673 if (cached_has_bits & 0x000000ffu) {
1674 if (cached_has_bits & 0x00000001u) {
1675 _this->_impl_.bw_ctl_ebi_ = from._impl_.bw_ctl_ebi_;
1676 }
1677 if (cached_has_bits & 0x00000002u) {
1678 _this->_impl_.bw_ctl_llcc_ = from._impl_.bw_ctl_llcc_;
1679 }
1680 if (cached_has_bits & 0x00000004u) {
1681 _this->_impl_.bw_ctl_mnoc_ = from._impl_.bw_ctl_mnoc_;
1682 }
1683 if (cached_has_bits & 0x00000008u) {
1684 _this->_impl_.core_clk_rate_ = from._impl_.core_clk_rate_;
1685 }
1686 if (cached_has_bits & 0x00000010u) {
1687 _this->_impl_.crtc_ = from._impl_.crtc_;
1688 }
1689 if (cached_has_bits & 0x00000020u) {
1690 _this->_impl_.per_pipe_ib_ebi_ = from._impl_.per_pipe_ib_ebi_;
1691 }
1692 if (cached_has_bits & 0x00000040u) {
1693 _this->_impl_.per_pipe_ib_llcc_ = from._impl_.per_pipe_ib_llcc_;
1694 }
1695 if (cached_has_bits & 0x00000080u) {
1696 _this->_impl_.params_ = from._impl_.params_;
1697 }
1698 _this->_impl_._has_bits_[0] |= cached_has_bits;
1699 }
1700 if (cached_has_bits & 0x00000f00u) {
1701 if (cached_has_bits & 0x00000100u) {
1702 _this->_impl_.stop_req_ = from._impl_.stop_req_;
1703 }
1704 if (cached_has_bits & 0x00000200u) {
1705 _this->_impl_.per_pipe_ib_mnoc_ = from._impl_.per_pipe_ib_mnoc_;
1706 }
1707 if (cached_has_bits & 0x00000400u) {
1708 _this->_impl_.update_bus_ = from._impl_.update_bus_;
1709 }
1710 if (cached_has_bits & 0x00000800u) {
1711 _this->_impl_.update_clk_ = from._impl_.update_clk_;
1712 }
1713 _this->_impl_._has_bits_[0] |= cached_has_bits;
1714 }
1715 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1716 }
1717
CopyFrom(const SdeSdePerfCrtcUpdateFtraceEvent & from)1718 void SdeSdePerfCrtcUpdateFtraceEvent::CopyFrom(const SdeSdePerfCrtcUpdateFtraceEvent& from) {
1719 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SdeSdePerfCrtcUpdateFtraceEvent)
1720 if (&from == this) return;
1721 Clear();
1722 MergeFrom(from);
1723 }
1724
IsInitialized() const1725 bool SdeSdePerfCrtcUpdateFtraceEvent::IsInitialized() const {
1726 return true;
1727 }
1728
InternalSwap(SdeSdePerfCrtcUpdateFtraceEvent * other)1729 void SdeSdePerfCrtcUpdateFtraceEvent::InternalSwap(SdeSdePerfCrtcUpdateFtraceEvent* other) {
1730 using std::swap;
1731 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1732 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1733 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1734 PROTOBUF_FIELD_OFFSET(SdeSdePerfCrtcUpdateFtraceEvent, _impl_.update_clk_)
1735 + sizeof(SdeSdePerfCrtcUpdateFtraceEvent::_impl_.update_clk_) // NOLINT
1736 - PROTOBUF_FIELD_OFFSET(SdeSdePerfCrtcUpdateFtraceEvent, _impl_.bw_ctl_ebi_)>(
1737 reinterpret_cast<char*>(&_impl_.bw_ctl_ebi_),
1738 reinterpret_cast<char*>(&other->_impl_.bw_ctl_ebi_));
1739 }
1740
GetTypeName() const1741 std::string SdeSdePerfCrtcUpdateFtraceEvent::GetTypeName() const {
1742 return "perfetto.protos.SdeSdePerfCrtcUpdateFtraceEvent";
1743 }
1744
1745
1746 // ===================================================================
1747
1748 class SdeSdePerfSetQosLutsFtraceEvent::_Internal {
1749 public:
1750 using HasBits = decltype(std::declval<SdeSdePerfSetQosLutsFtraceEvent>()._impl_._has_bits_);
set_has_fl(HasBits * has_bits)1751 static void set_has_fl(HasBits* has_bits) {
1752 (*has_bits)[0] |= 1u;
1753 }
set_has_fmt(HasBits * has_bits)1754 static void set_has_fmt(HasBits* has_bits) {
1755 (*has_bits)[0] |= 2u;
1756 }
set_has_lut(HasBits * has_bits)1757 static void set_has_lut(HasBits* has_bits) {
1758 (*has_bits)[0] |= 4u;
1759 }
set_has_lut_usage(HasBits * has_bits)1760 static void set_has_lut_usage(HasBits* has_bits) {
1761 (*has_bits)[0] |= 8u;
1762 }
set_has_pnum(HasBits * has_bits)1763 static void set_has_pnum(HasBits* has_bits) {
1764 (*has_bits)[0] |= 16u;
1765 }
set_has_rt(HasBits * has_bits)1766 static void set_has_rt(HasBits* has_bits) {
1767 (*has_bits)[0] |= 32u;
1768 }
1769 };
1770
SdeSdePerfSetQosLutsFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1771 SdeSdePerfSetQosLutsFtraceEvent::SdeSdePerfSetQosLutsFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1772 bool is_message_owned)
1773 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1774 SharedCtor(arena, is_message_owned);
1775 // @@protoc_insertion_point(arena_constructor:perfetto.protos.SdeSdePerfSetQosLutsFtraceEvent)
1776 }
SdeSdePerfSetQosLutsFtraceEvent(const SdeSdePerfSetQosLutsFtraceEvent & from)1777 SdeSdePerfSetQosLutsFtraceEvent::SdeSdePerfSetQosLutsFtraceEvent(const SdeSdePerfSetQosLutsFtraceEvent& from)
1778 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1779 SdeSdePerfSetQosLutsFtraceEvent* const _this = this; (void)_this;
1780 new (&_impl_) Impl_{
1781 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1782 , /*decltype(_impl_._cached_size_)*/{}
1783 , decltype(_impl_.fl_){}
1784 , decltype(_impl_.fmt_){}
1785 , decltype(_impl_.lut_){}
1786 , decltype(_impl_.lut_usage_){}
1787 , decltype(_impl_.pnum_){}
1788 , decltype(_impl_.rt_){}};
1789
1790 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1791 ::memcpy(&_impl_.fl_, &from._impl_.fl_,
1792 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.rt_) -
1793 reinterpret_cast<char*>(&_impl_.fl_)) + sizeof(_impl_.rt_));
1794 // @@protoc_insertion_point(copy_constructor:perfetto.protos.SdeSdePerfSetQosLutsFtraceEvent)
1795 }
1796
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1797 inline void SdeSdePerfSetQosLutsFtraceEvent::SharedCtor(
1798 ::_pb::Arena* arena, bool is_message_owned) {
1799 (void)arena;
1800 (void)is_message_owned;
1801 new (&_impl_) Impl_{
1802 decltype(_impl_._has_bits_){}
1803 , /*decltype(_impl_._cached_size_)*/{}
1804 , decltype(_impl_.fl_){0u}
1805 , decltype(_impl_.fmt_){0u}
1806 , decltype(_impl_.lut_){::uint64_t{0u}}
1807 , decltype(_impl_.lut_usage_){0u}
1808 , decltype(_impl_.pnum_){0u}
1809 , decltype(_impl_.rt_){0u}
1810 };
1811 }
1812
~SdeSdePerfSetQosLutsFtraceEvent()1813 SdeSdePerfSetQosLutsFtraceEvent::~SdeSdePerfSetQosLutsFtraceEvent() {
1814 // @@protoc_insertion_point(destructor:perfetto.protos.SdeSdePerfSetQosLutsFtraceEvent)
1815 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1816 (void)arena;
1817 return;
1818 }
1819 SharedDtor();
1820 }
1821
SharedDtor()1822 inline void SdeSdePerfSetQosLutsFtraceEvent::SharedDtor() {
1823 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1824 }
1825
SetCachedSize(int size) const1826 void SdeSdePerfSetQosLutsFtraceEvent::SetCachedSize(int size) const {
1827 _impl_._cached_size_.Set(size);
1828 }
1829
Clear()1830 void SdeSdePerfSetQosLutsFtraceEvent::Clear() {
1831 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SdeSdePerfSetQosLutsFtraceEvent)
1832 ::uint32_t cached_has_bits = 0;
1833 // Prevent compiler warnings about cached_has_bits being unused
1834 (void) cached_has_bits;
1835
1836 cached_has_bits = _impl_._has_bits_[0];
1837 if (cached_has_bits & 0x0000003fu) {
1838 ::memset(&_impl_.fl_, 0, static_cast<size_t>(
1839 reinterpret_cast<char*>(&_impl_.rt_) -
1840 reinterpret_cast<char*>(&_impl_.fl_)) + sizeof(_impl_.rt_));
1841 }
1842 _impl_._has_bits_.Clear();
1843 _internal_metadata_.Clear<std::string>();
1844 }
1845
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1846 const char* SdeSdePerfSetQosLutsFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1847 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1848 _Internal::HasBits has_bits{};
1849 while (!ctx->Done(&ptr)) {
1850 ::uint32_t tag;
1851 ptr = ::_pbi::ReadTag(ptr, &tag);
1852 switch (tag >> 3) {
1853 // optional uint32 fl = 1;
1854 case 1:
1855 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1856 _Internal::set_has_fl(&has_bits);
1857 _impl_.fl_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1858 CHK_(ptr);
1859 } else {
1860 goto handle_unusual;
1861 }
1862 continue;
1863 // optional uint32 fmt = 2;
1864 case 2:
1865 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1866 _Internal::set_has_fmt(&has_bits);
1867 _impl_.fmt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1868 CHK_(ptr);
1869 } else {
1870 goto handle_unusual;
1871 }
1872 continue;
1873 // optional uint64 lut = 3;
1874 case 3:
1875 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1876 _Internal::set_has_lut(&has_bits);
1877 _impl_.lut_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1878 CHK_(ptr);
1879 } else {
1880 goto handle_unusual;
1881 }
1882 continue;
1883 // optional uint32 lut_usage = 4;
1884 case 4:
1885 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1886 _Internal::set_has_lut_usage(&has_bits);
1887 _impl_.lut_usage_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1888 CHK_(ptr);
1889 } else {
1890 goto handle_unusual;
1891 }
1892 continue;
1893 // optional uint32 pnum = 5;
1894 case 5:
1895 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1896 _Internal::set_has_pnum(&has_bits);
1897 _impl_.pnum_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1898 CHK_(ptr);
1899 } else {
1900 goto handle_unusual;
1901 }
1902 continue;
1903 // optional uint32 rt = 6;
1904 case 6:
1905 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
1906 _Internal::set_has_rt(&has_bits);
1907 _impl_.rt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1908 CHK_(ptr);
1909 } else {
1910 goto handle_unusual;
1911 }
1912 continue;
1913 default:
1914 goto handle_unusual;
1915 } // switch
1916 handle_unusual:
1917 if ((tag == 0) || ((tag & 7) == 4)) {
1918 CHK_(ptr);
1919 ctx->SetLastTag(tag);
1920 goto message_done;
1921 }
1922 ptr = UnknownFieldParse(
1923 tag,
1924 _internal_metadata_.mutable_unknown_fields<std::string>(),
1925 ptr, ctx);
1926 CHK_(ptr != nullptr);
1927 } // while
1928 message_done:
1929 _impl_._has_bits_.Or(has_bits);
1930 return ptr;
1931 failure:
1932 ptr = nullptr;
1933 goto message_done;
1934 #undef CHK_
1935 }
1936
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1937 ::uint8_t* SdeSdePerfSetQosLutsFtraceEvent::_InternalSerialize(
1938 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1939 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SdeSdePerfSetQosLutsFtraceEvent)
1940 ::uint32_t cached_has_bits = 0;
1941 (void) cached_has_bits;
1942
1943 cached_has_bits = _impl_._has_bits_[0];
1944 // optional uint32 fl = 1;
1945 if (cached_has_bits & 0x00000001u) {
1946 target = stream->EnsureSpace(target);
1947 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_fl(), target);
1948 }
1949
1950 // optional uint32 fmt = 2;
1951 if (cached_has_bits & 0x00000002u) {
1952 target = stream->EnsureSpace(target);
1953 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_fmt(), target);
1954 }
1955
1956 // optional uint64 lut = 3;
1957 if (cached_has_bits & 0x00000004u) {
1958 target = stream->EnsureSpace(target);
1959 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_lut(), target);
1960 }
1961
1962 // optional uint32 lut_usage = 4;
1963 if (cached_has_bits & 0x00000008u) {
1964 target = stream->EnsureSpace(target);
1965 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_lut_usage(), target);
1966 }
1967
1968 // optional uint32 pnum = 5;
1969 if (cached_has_bits & 0x00000010u) {
1970 target = stream->EnsureSpace(target);
1971 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_pnum(), target);
1972 }
1973
1974 // optional uint32 rt = 6;
1975 if (cached_has_bits & 0x00000020u) {
1976 target = stream->EnsureSpace(target);
1977 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_rt(), target);
1978 }
1979
1980 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1981 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1982 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1983 }
1984 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SdeSdePerfSetQosLutsFtraceEvent)
1985 return target;
1986 }
1987
ByteSizeLong() const1988 size_t SdeSdePerfSetQosLutsFtraceEvent::ByteSizeLong() const {
1989 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SdeSdePerfSetQosLutsFtraceEvent)
1990 size_t total_size = 0;
1991
1992 ::uint32_t cached_has_bits = 0;
1993 // Prevent compiler warnings about cached_has_bits being unused
1994 (void) cached_has_bits;
1995
1996 cached_has_bits = _impl_._has_bits_[0];
1997 if (cached_has_bits & 0x0000003fu) {
1998 // optional uint32 fl = 1;
1999 if (cached_has_bits & 0x00000001u) {
2000 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_fl());
2001 }
2002
2003 // optional uint32 fmt = 2;
2004 if (cached_has_bits & 0x00000002u) {
2005 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_fmt());
2006 }
2007
2008 // optional uint64 lut = 3;
2009 if (cached_has_bits & 0x00000004u) {
2010 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_lut());
2011 }
2012
2013 // optional uint32 lut_usage = 4;
2014 if (cached_has_bits & 0x00000008u) {
2015 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_lut_usage());
2016 }
2017
2018 // optional uint32 pnum = 5;
2019 if (cached_has_bits & 0x00000010u) {
2020 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_pnum());
2021 }
2022
2023 // optional uint32 rt = 6;
2024 if (cached_has_bits & 0x00000020u) {
2025 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rt());
2026 }
2027
2028 }
2029 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2030 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2031 }
2032 int cached_size = ::_pbi::ToCachedSize(total_size);
2033 SetCachedSize(cached_size);
2034 return total_size;
2035 }
2036
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2037 void SdeSdePerfSetQosLutsFtraceEvent::CheckTypeAndMergeFrom(
2038 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2039 MergeFrom(*::_pbi::DownCast<const SdeSdePerfSetQosLutsFtraceEvent*>(
2040 &from));
2041 }
2042
MergeFrom(const SdeSdePerfSetQosLutsFtraceEvent & from)2043 void SdeSdePerfSetQosLutsFtraceEvent::MergeFrom(const SdeSdePerfSetQosLutsFtraceEvent& from) {
2044 SdeSdePerfSetQosLutsFtraceEvent* const _this = this;
2045 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SdeSdePerfSetQosLutsFtraceEvent)
2046 GOOGLE_DCHECK_NE(&from, _this);
2047 ::uint32_t cached_has_bits = 0;
2048 (void) cached_has_bits;
2049
2050 cached_has_bits = from._impl_._has_bits_[0];
2051 if (cached_has_bits & 0x0000003fu) {
2052 if (cached_has_bits & 0x00000001u) {
2053 _this->_impl_.fl_ = from._impl_.fl_;
2054 }
2055 if (cached_has_bits & 0x00000002u) {
2056 _this->_impl_.fmt_ = from._impl_.fmt_;
2057 }
2058 if (cached_has_bits & 0x00000004u) {
2059 _this->_impl_.lut_ = from._impl_.lut_;
2060 }
2061 if (cached_has_bits & 0x00000008u) {
2062 _this->_impl_.lut_usage_ = from._impl_.lut_usage_;
2063 }
2064 if (cached_has_bits & 0x00000010u) {
2065 _this->_impl_.pnum_ = from._impl_.pnum_;
2066 }
2067 if (cached_has_bits & 0x00000020u) {
2068 _this->_impl_.rt_ = from._impl_.rt_;
2069 }
2070 _this->_impl_._has_bits_[0] |= cached_has_bits;
2071 }
2072 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2073 }
2074
CopyFrom(const SdeSdePerfSetQosLutsFtraceEvent & from)2075 void SdeSdePerfSetQosLutsFtraceEvent::CopyFrom(const SdeSdePerfSetQosLutsFtraceEvent& from) {
2076 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SdeSdePerfSetQosLutsFtraceEvent)
2077 if (&from == this) return;
2078 Clear();
2079 MergeFrom(from);
2080 }
2081
IsInitialized() const2082 bool SdeSdePerfSetQosLutsFtraceEvent::IsInitialized() const {
2083 return true;
2084 }
2085
InternalSwap(SdeSdePerfSetQosLutsFtraceEvent * other)2086 void SdeSdePerfSetQosLutsFtraceEvent::InternalSwap(SdeSdePerfSetQosLutsFtraceEvent* other) {
2087 using std::swap;
2088 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2089 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2090 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2091 PROTOBUF_FIELD_OFFSET(SdeSdePerfSetQosLutsFtraceEvent, _impl_.rt_)
2092 + sizeof(SdeSdePerfSetQosLutsFtraceEvent::_impl_.rt_) // NOLINT
2093 - PROTOBUF_FIELD_OFFSET(SdeSdePerfSetQosLutsFtraceEvent, _impl_.fl_)>(
2094 reinterpret_cast<char*>(&_impl_.fl_),
2095 reinterpret_cast<char*>(&other->_impl_.fl_));
2096 }
2097
GetTypeName() const2098 std::string SdeSdePerfSetQosLutsFtraceEvent::GetTypeName() const {
2099 return "perfetto.protos.SdeSdePerfSetQosLutsFtraceEvent";
2100 }
2101
2102
2103 // ===================================================================
2104
2105 class SdeSdePerfUpdateBusFtraceEvent::_Internal {
2106 public:
2107 using HasBits = decltype(std::declval<SdeSdePerfUpdateBusFtraceEvent>()._impl_._has_bits_);
set_has_ab_quota(HasBits * has_bits)2108 static void set_has_ab_quota(HasBits* has_bits) {
2109 (*has_bits)[0] |= 1u;
2110 }
set_has_bus_id(HasBits * has_bits)2111 static void set_has_bus_id(HasBits* has_bits) {
2112 (*has_bits)[0] |= 2u;
2113 }
set_has_client(HasBits * has_bits)2114 static void set_has_client(HasBits* has_bits) {
2115 (*has_bits)[0] |= 4u;
2116 }
set_has_ib_quota(HasBits * has_bits)2117 static void set_has_ib_quota(HasBits* has_bits) {
2118 (*has_bits)[0] |= 8u;
2119 }
2120 };
2121
SdeSdePerfUpdateBusFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2122 SdeSdePerfUpdateBusFtraceEvent::SdeSdePerfUpdateBusFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2123 bool is_message_owned)
2124 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2125 SharedCtor(arena, is_message_owned);
2126 // @@protoc_insertion_point(arena_constructor:perfetto.protos.SdeSdePerfUpdateBusFtraceEvent)
2127 }
SdeSdePerfUpdateBusFtraceEvent(const SdeSdePerfUpdateBusFtraceEvent & from)2128 SdeSdePerfUpdateBusFtraceEvent::SdeSdePerfUpdateBusFtraceEvent(const SdeSdePerfUpdateBusFtraceEvent& from)
2129 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2130 SdeSdePerfUpdateBusFtraceEvent* const _this = this; (void)_this;
2131 new (&_impl_) Impl_{
2132 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2133 , /*decltype(_impl_._cached_size_)*/{}
2134 , decltype(_impl_.ab_quota_){}
2135 , decltype(_impl_.bus_id_){}
2136 , decltype(_impl_.client_){}
2137 , decltype(_impl_.ib_quota_){}};
2138
2139 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2140 ::memcpy(&_impl_.ab_quota_, &from._impl_.ab_quota_,
2141 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ib_quota_) -
2142 reinterpret_cast<char*>(&_impl_.ab_quota_)) + sizeof(_impl_.ib_quota_));
2143 // @@protoc_insertion_point(copy_constructor:perfetto.protos.SdeSdePerfUpdateBusFtraceEvent)
2144 }
2145
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2146 inline void SdeSdePerfUpdateBusFtraceEvent::SharedCtor(
2147 ::_pb::Arena* arena, bool is_message_owned) {
2148 (void)arena;
2149 (void)is_message_owned;
2150 new (&_impl_) Impl_{
2151 decltype(_impl_._has_bits_){}
2152 , /*decltype(_impl_._cached_size_)*/{}
2153 , decltype(_impl_.ab_quota_){::uint64_t{0u}}
2154 , decltype(_impl_.bus_id_){0u}
2155 , decltype(_impl_.client_){0}
2156 , decltype(_impl_.ib_quota_){::uint64_t{0u}}
2157 };
2158 }
2159
~SdeSdePerfUpdateBusFtraceEvent()2160 SdeSdePerfUpdateBusFtraceEvent::~SdeSdePerfUpdateBusFtraceEvent() {
2161 // @@protoc_insertion_point(destructor:perfetto.protos.SdeSdePerfUpdateBusFtraceEvent)
2162 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2163 (void)arena;
2164 return;
2165 }
2166 SharedDtor();
2167 }
2168
SharedDtor()2169 inline void SdeSdePerfUpdateBusFtraceEvent::SharedDtor() {
2170 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2171 }
2172
SetCachedSize(int size) const2173 void SdeSdePerfUpdateBusFtraceEvent::SetCachedSize(int size) const {
2174 _impl_._cached_size_.Set(size);
2175 }
2176
Clear()2177 void SdeSdePerfUpdateBusFtraceEvent::Clear() {
2178 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SdeSdePerfUpdateBusFtraceEvent)
2179 ::uint32_t cached_has_bits = 0;
2180 // Prevent compiler warnings about cached_has_bits being unused
2181 (void) cached_has_bits;
2182
2183 cached_has_bits = _impl_._has_bits_[0];
2184 if (cached_has_bits & 0x0000000fu) {
2185 ::memset(&_impl_.ab_quota_, 0, static_cast<size_t>(
2186 reinterpret_cast<char*>(&_impl_.ib_quota_) -
2187 reinterpret_cast<char*>(&_impl_.ab_quota_)) + sizeof(_impl_.ib_quota_));
2188 }
2189 _impl_._has_bits_.Clear();
2190 _internal_metadata_.Clear<std::string>();
2191 }
2192
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2193 const char* SdeSdePerfUpdateBusFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2194 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2195 _Internal::HasBits has_bits{};
2196 while (!ctx->Done(&ptr)) {
2197 ::uint32_t tag;
2198 ptr = ::_pbi::ReadTag(ptr, &tag);
2199 switch (tag >> 3) {
2200 // optional uint64 ab_quota = 1;
2201 case 1:
2202 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2203 _Internal::set_has_ab_quota(&has_bits);
2204 _impl_.ab_quota_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2205 CHK_(ptr);
2206 } else {
2207 goto handle_unusual;
2208 }
2209 continue;
2210 // optional uint32 bus_id = 2;
2211 case 2:
2212 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2213 _Internal::set_has_bus_id(&has_bits);
2214 _impl_.bus_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2215 CHK_(ptr);
2216 } else {
2217 goto handle_unusual;
2218 }
2219 continue;
2220 // optional int32 client = 3;
2221 case 3:
2222 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2223 _Internal::set_has_client(&has_bits);
2224 _impl_.client_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2225 CHK_(ptr);
2226 } else {
2227 goto handle_unusual;
2228 }
2229 continue;
2230 // optional uint64 ib_quota = 4;
2231 case 4:
2232 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2233 _Internal::set_has_ib_quota(&has_bits);
2234 _impl_.ib_quota_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2235 CHK_(ptr);
2236 } else {
2237 goto handle_unusual;
2238 }
2239 continue;
2240 default:
2241 goto handle_unusual;
2242 } // switch
2243 handle_unusual:
2244 if ((tag == 0) || ((tag & 7) == 4)) {
2245 CHK_(ptr);
2246 ctx->SetLastTag(tag);
2247 goto message_done;
2248 }
2249 ptr = UnknownFieldParse(
2250 tag,
2251 _internal_metadata_.mutable_unknown_fields<std::string>(),
2252 ptr, ctx);
2253 CHK_(ptr != nullptr);
2254 } // while
2255 message_done:
2256 _impl_._has_bits_.Or(has_bits);
2257 return ptr;
2258 failure:
2259 ptr = nullptr;
2260 goto message_done;
2261 #undef CHK_
2262 }
2263
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2264 ::uint8_t* SdeSdePerfUpdateBusFtraceEvent::_InternalSerialize(
2265 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2266 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SdeSdePerfUpdateBusFtraceEvent)
2267 ::uint32_t cached_has_bits = 0;
2268 (void) cached_has_bits;
2269
2270 cached_has_bits = _impl_._has_bits_[0];
2271 // optional uint64 ab_quota = 1;
2272 if (cached_has_bits & 0x00000001u) {
2273 target = stream->EnsureSpace(target);
2274 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_ab_quota(), target);
2275 }
2276
2277 // optional uint32 bus_id = 2;
2278 if (cached_has_bits & 0x00000002u) {
2279 target = stream->EnsureSpace(target);
2280 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_bus_id(), target);
2281 }
2282
2283 // optional int32 client = 3;
2284 if (cached_has_bits & 0x00000004u) {
2285 target = stream->EnsureSpace(target);
2286 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_client(), target);
2287 }
2288
2289 // optional uint64 ib_quota = 4;
2290 if (cached_has_bits & 0x00000008u) {
2291 target = stream->EnsureSpace(target);
2292 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_ib_quota(), target);
2293 }
2294
2295 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2296 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2297 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2298 }
2299 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SdeSdePerfUpdateBusFtraceEvent)
2300 return target;
2301 }
2302
ByteSizeLong() const2303 size_t SdeSdePerfUpdateBusFtraceEvent::ByteSizeLong() const {
2304 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SdeSdePerfUpdateBusFtraceEvent)
2305 size_t total_size = 0;
2306
2307 ::uint32_t cached_has_bits = 0;
2308 // Prevent compiler warnings about cached_has_bits being unused
2309 (void) cached_has_bits;
2310
2311 cached_has_bits = _impl_._has_bits_[0];
2312 if (cached_has_bits & 0x0000000fu) {
2313 // optional uint64 ab_quota = 1;
2314 if (cached_has_bits & 0x00000001u) {
2315 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ab_quota());
2316 }
2317
2318 // optional uint32 bus_id = 2;
2319 if (cached_has_bits & 0x00000002u) {
2320 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_bus_id());
2321 }
2322
2323 // optional int32 client = 3;
2324 if (cached_has_bits & 0x00000004u) {
2325 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_client());
2326 }
2327
2328 // optional uint64 ib_quota = 4;
2329 if (cached_has_bits & 0x00000008u) {
2330 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ib_quota());
2331 }
2332
2333 }
2334 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2335 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2336 }
2337 int cached_size = ::_pbi::ToCachedSize(total_size);
2338 SetCachedSize(cached_size);
2339 return total_size;
2340 }
2341
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2342 void SdeSdePerfUpdateBusFtraceEvent::CheckTypeAndMergeFrom(
2343 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2344 MergeFrom(*::_pbi::DownCast<const SdeSdePerfUpdateBusFtraceEvent*>(
2345 &from));
2346 }
2347
MergeFrom(const SdeSdePerfUpdateBusFtraceEvent & from)2348 void SdeSdePerfUpdateBusFtraceEvent::MergeFrom(const SdeSdePerfUpdateBusFtraceEvent& from) {
2349 SdeSdePerfUpdateBusFtraceEvent* const _this = this;
2350 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SdeSdePerfUpdateBusFtraceEvent)
2351 GOOGLE_DCHECK_NE(&from, _this);
2352 ::uint32_t cached_has_bits = 0;
2353 (void) cached_has_bits;
2354
2355 cached_has_bits = from._impl_._has_bits_[0];
2356 if (cached_has_bits & 0x0000000fu) {
2357 if (cached_has_bits & 0x00000001u) {
2358 _this->_impl_.ab_quota_ = from._impl_.ab_quota_;
2359 }
2360 if (cached_has_bits & 0x00000002u) {
2361 _this->_impl_.bus_id_ = from._impl_.bus_id_;
2362 }
2363 if (cached_has_bits & 0x00000004u) {
2364 _this->_impl_.client_ = from._impl_.client_;
2365 }
2366 if (cached_has_bits & 0x00000008u) {
2367 _this->_impl_.ib_quota_ = from._impl_.ib_quota_;
2368 }
2369 _this->_impl_._has_bits_[0] |= cached_has_bits;
2370 }
2371 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2372 }
2373
CopyFrom(const SdeSdePerfUpdateBusFtraceEvent & from)2374 void SdeSdePerfUpdateBusFtraceEvent::CopyFrom(const SdeSdePerfUpdateBusFtraceEvent& from) {
2375 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SdeSdePerfUpdateBusFtraceEvent)
2376 if (&from == this) return;
2377 Clear();
2378 MergeFrom(from);
2379 }
2380
IsInitialized() const2381 bool SdeSdePerfUpdateBusFtraceEvent::IsInitialized() const {
2382 return true;
2383 }
2384
InternalSwap(SdeSdePerfUpdateBusFtraceEvent * other)2385 void SdeSdePerfUpdateBusFtraceEvent::InternalSwap(SdeSdePerfUpdateBusFtraceEvent* other) {
2386 using std::swap;
2387 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2388 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2389 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2390 PROTOBUF_FIELD_OFFSET(SdeSdePerfUpdateBusFtraceEvent, _impl_.ib_quota_)
2391 + sizeof(SdeSdePerfUpdateBusFtraceEvent::_impl_.ib_quota_) // NOLINT
2392 - PROTOBUF_FIELD_OFFSET(SdeSdePerfUpdateBusFtraceEvent, _impl_.ab_quota_)>(
2393 reinterpret_cast<char*>(&_impl_.ab_quota_),
2394 reinterpret_cast<char*>(&other->_impl_.ab_quota_));
2395 }
2396
GetTypeName() const2397 std::string SdeSdePerfUpdateBusFtraceEvent::GetTypeName() const {
2398 return "perfetto.protos.SdeSdePerfUpdateBusFtraceEvent";
2399 }
2400
2401
2402 // @@protoc_insertion_point(namespace_scope)
2403 } // namespace protos
2404 } // namespace perfetto
2405 PROTOBUF_NAMESPACE_OPEN
2406 template<> PROTOBUF_NOINLINE ::perfetto::protos::SdeTracingMarkWriteFtraceEvent*
CreateMaybeMessage(Arena * arena)2407 Arena::CreateMaybeMessage< ::perfetto::protos::SdeTracingMarkWriteFtraceEvent >(Arena* arena) {
2408 return Arena::CreateMessageInternal< ::perfetto::protos::SdeTracingMarkWriteFtraceEvent >(arena);
2409 }
2410 template<> PROTOBUF_NOINLINE ::perfetto::protos::SdeSdeEvtlogFtraceEvent*
CreateMaybeMessage(Arena * arena)2411 Arena::CreateMaybeMessage< ::perfetto::protos::SdeSdeEvtlogFtraceEvent >(Arena* arena) {
2412 return Arena::CreateMessageInternal< ::perfetto::protos::SdeSdeEvtlogFtraceEvent >(arena);
2413 }
2414 template<> PROTOBUF_NOINLINE ::perfetto::protos::SdeSdePerfCalcCrtcFtraceEvent*
CreateMaybeMessage(Arena * arena)2415 Arena::CreateMaybeMessage< ::perfetto::protos::SdeSdePerfCalcCrtcFtraceEvent >(Arena* arena) {
2416 return Arena::CreateMessageInternal< ::perfetto::protos::SdeSdePerfCalcCrtcFtraceEvent >(arena);
2417 }
2418 template<> PROTOBUF_NOINLINE ::perfetto::protos::SdeSdePerfCrtcUpdateFtraceEvent*
CreateMaybeMessage(Arena * arena)2419 Arena::CreateMaybeMessage< ::perfetto::protos::SdeSdePerfCrtcUpdateFtraceEvent >(Arena* arena) {
2420 return Arena::CreateMessageInternal< ::perfetto::protos::SdeSdePerfCrtcUpdateFtraceEvent >(arena);
2421 }
2422 template<> PROTOBUF_NOINLINE ::perfetto::protos::SdeSdePerfSetQosLutsFtraceEvent*
CreateMaybeMessage(Arena * arena)2423 Arena::CreateMaybeMessage< ::perfetto::protos::SdeSdePerfSetQosLutsFtraceEvent >(Arena* arena) {
2424 return Arena::CreateMessageInternal< ::perfetto::protos::SdeSdePerfSetQosLutsFtraceEvent >(arena);
2425 }
2426 template<> PROTOBUF_NOINLINE ::perfetto::protos::SdeSdePerfUpdateBusFtraceEvent*
CreateMaybeMessage(Arena * arena)2427 Arena::CreateMaybeMessage< ::perfetto::protos::SdeSdePerfUpdateBusFtraceEvent >(Arena* arena) {
2428 return Arena::CreateMessageInternal< ::perfetto::protos::SdeSdePerfUpdateBusFtraceEvent >(arena);
2429 }
2430 PROTOBUF_NAMESPACE_CLOSE
2431
2432 // @@protoc_insertion_point(global_scope)
2433 #include <google/protobuf/port_undef.inc>
2434