1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: system/extras/simpleperf/branch_list.proto
3
4 #include "system/extras/simpleperf/branch_list.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 simpleperf {
22 namespace proto {
BranchList(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR BranchList::BranchList(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_.etm_data_)*/{}
26 , /*decltype(_impl_.magic_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
27 , /*decltype(_impl_.lbr_data_)*/nullptr
28 , /*decltype(_impl_._cached_size_)*/{}} {}
29 struct BranchListDefaultTypeInternal {
BranchListDefaultTypeInternalsimpleperf::proto::BranchListDefaultTypeInternal30 PROTOBUF_CONSTEXPR BranchListDefaultTypeInternal()
31 : _instance(::_pbi::ConstantInitialized{}) {}
~BranchListDefaultTypeInternalsimpleperf::proto::BranchListDefaultTypeInternal32 ~BranchListDefaultTypeInternal() {}
33 union { // NOLINT(misc-non-private-member-variables-in-classes)
34 BranchList _instance;
35 };
36 };
37 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BranchListDefaultTypeInternal _BranchList_default_instance_;
ETMBinary_Address_Branch(::_pbi::ConstantInitialized)38 PROTOBUF_CONSTEXPR ETMBinary_Address_Branch::ETMBinary_Address_Branch(
39 ::_pbi::ConstantInitialized): _impl_{
40 /*decltype(_impl_.branch_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
41 , /*decltype(_impl_.count_)*/::uint64_t{0u}
42 , /*decltype(_impl_.branch_size_)*/0u
43 , /*decltype(_impl_._cached_size_)*/{}} {}
44 struct ETMBinary_Address_BranchDefaultTypeInternal {
ETMBinary_Address_BranchDefaultTypeInternalsimpleperf::proto::ETMBinary_Address_BranchDefaultTypeInternal45 PROTOBUF_CONSTEXPR ETMBinary_Address_BranchDefaultTypeInternal()
46 : _instance(::_pbi::ConstantInitialized{}) {}
~ETMBinary_Address_BranchDefaultTypeInternalsimpleperf::proto::ETMBinary_Address_BranchDefaultTypeInternal47 ~ETMBinary_Address_BranchDefaultTypeInternal() {}
48 union { // NOLINT(misc-non-private-member-variables-in-classes)
49 ETMBinary_Address_Branch _instance;
50 };
51 };
52 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ETMBinary_Address_BranchDefaultTypeInternal _ETMBinary_Address_Branch_default_instance_;
ETMBinary_Address(::_pbi::ConstantInitialized)53 PROTOBUF_CONSTEXPR ETMBinary_Address::ETMBinary_Address(
54 ::_pbi::ConstantInitialized): _impl_{
55 /*decltype(_impl_.branches_)*/{}
56 , /*decltype(_impl_.addr_)*/::uint64_t{0u}
57 , /*decltype(_impl_._cached_size_)*/{}} {}
58 struct ETMBinary_AddressDefaultTypeInternal {
ETMBinary_AddressDefaultTypeInternalsimpleperf::proto::ETMBinary_AddressDefaultTypeInternal59 PROTOBUF_CONSTEXPR ETMBinary_AddressDefaultTypeInternal()
60 : _instance(::_pbi::ConstantInitialized{}) {}
~ETMBinary_AddressDefaultTypeInternalsimpleperf::proto::ETMBinary_AddressDefaultTypeInternal61 ~ETMBinary_AddressDefaultTypeInternal() {}
62 union { // NOLINT(misc-non-private-member-variables-in-classes)
63 ETMBinary_Address _instance;
64 };
65 };
66 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ETMBinary_AddressDefaultTypeInternal _ETMBinary_Address_default_instance_;
ETMBinary_KernelBinaryInfo(::_pbi::ConstantInitialized)67 PROTOBUF_CONSTEXPR ETMBinary_KernelBinaryInfo::ETMBinary_KernelBinaryInfo(
68 ::_pbi::ConstantInitialized): _impl_{
69 /*decltype(_impl_.kernel_start_addr_)*/::uint64_t{0u}
70 , /*decltype(_impl_._cached_size_)*/{}} {}
71 struct ETMBinary_KernelBinaryInfoDefaultTypeInternal {
ETMBinary_KernelBinaryInfoDefaultTypeInternalsimpleperf::proto::ETMBinary_KernelBinaryInfoDefaultTypeInternal72 PROTOBUF_CONSTEXPR ETMBinary_KernelBinaryInfoDefaultTypeInternal()
73 : _instance(::_pbi::ConstantInitialized{}) {}
~ETMBinary_KernelBinaryInfoDefaultTypeInternalsimpleperf::proto::ETMBinary_KernelBinaryInfoDefaultTypeInternal74 ~ETMBinary_KernelBinaryInfoDefaultTypeInternal() {}
75 union { // NOLINT(misc-non-private-member-variables-in-classes)
76 ETMBinary_KernelBinaryInfo _instance;
77 };
78 };
79 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ETMBinary_KernelBinaryInfoDefaultTypeInternal _ETMBinary_KernelBinaryInfo_default_instance_;
ETMBinary(::_pbi::ConstantInitialized)80 PROTOBUF_CONSTEXPR ETMBinary::ETMBinary(
81 ::_pbi::ConstantInitialized): _impl_{
82 /*decltype(_impl_.addrs_)*/{}
83 , /*decltype(_impl_.path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
84 , /*decltype(_impl_.build_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
85 , /*decltype(_impl_.kernel_info_)*/nullptr
86 , /*decltype(_impl_.type_)*/0
87 , /*decltype(_impl_._cached_size_)*/{}} {}
88 struct ETMBinaryDefaultTypeInternal {
ETMBinaryDefaultTypeInternalsimpleperf::proto::ETMBinaryDefaultTypeInternal89 PROTOBUF_CONSTEXPR ETMBinaryDefaultTypeInternal()
90 : _instance(::_pbi::ConstantInitialized{}) {}
~ETMBinaryDefaultTypeInternalsimpleperf::proto::ETMBinaryDefaultTypeInternal91 ~ETMBinaryDefaultTypeInternal() {}
92 union { // NOLINT(misc-non-private-member-variables-in-classes)
93 ETMBinary _instance;
94 };
95 };
96 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ETMBinaryDefaultTypeInternal _ETMBinary_default_instance_;
LBRData_Sample_Branch(::_pbi::ConstantInitialized)97 PROTOBUF_CONSTEXPR LBRData_Sample_Branch::LBRData_Sample_Branch(
98 ::_pbi::ConstantInitialized): _impl_{
99 /*decltype(_impl_.from_binary_id_)*/0u
100 , /*decltype(_impl_.to_binary_id_)*/0u
101 , /*decltype(_impl_.from_vaddr_in_file_)*/::uint64_t{0u}
102 , /*decltype(_impl_.to_vaddr_in_file_)*/::uint64_t{0u}
103 , /*decltype(_impl_._cached_size_)*/{}} {}
104 struct LBRData_Sample_BranchDefaultTypeInternal {
LBRData_Sample_BranchDefaultTypeInternalsimpleperf::proto::LBRData_Sample_BranchDefaultTypeInternal105 PROTOBUF_CONSTEXPR LBRData_Sample_BranchDefaultTypeInternal()
106 : _instance(::_pbi::ConstantInitialized{}) {}
~LBRData_Sample_BranchDefaultTypeInternalsimpleperf::proto::LBRData_Sample_BranchDefaultTypeInternal107 ~LBRData_Sample_BranchDefaultTypeInternal() {}
108 union { // NOLINT(misc-non-private-member-variables-in-classes)
109 LBRData_Sample_Branch _instance;
110 };
111 };
112 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LBRData_Sample_BranchDefaultTypeInternal _LBRData_Sample_Branch_default_instance_;
LBRData_Sample(::_pbi::ConstantInitialized)113 PROTOBUF_CONSTEXPR LBRData_Sample::LBRData_Sample(
114 ::_pbi::ConstantInitialized): _impl_{
115 /*decltype(_impl_.branches_)*/{}
116 , /*decltype(_impl_.vaddr_in_file_)*/::uint64_t{0u}
117 , /*decltype(_impl_.binary_id_)*/0u
118 , /*decltype(_impl_._cached_size_)*/{}} {}
119 struct LBRData_SampleDefaultTypeInternal {
LBRData_SampleDefaultTypeInternalsimpleperf::proto::LBRData_SampleDefaultTypeInternal120 PROTOBUF_CONSTEXPR LBRData_SampleDefaultTypeInternal()
121 : _instance(::_pbi::ConstantInitialized{}) {}
~LBRData_SampleDefaultTypeInternalsimpleperf::proto::LBRData_SampleDefaultTypeInternal122 ~LBRData_SampleDefaultTypeInternal() {}
123 union { // NOLINT(misc-non-private-member-variables-in-classes)
124 LBRData_Sample _instance;
125 };
126 };
127 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LBRData_SampleDefaultTypeInternal _LBRData_Sample_default_instance_;
LBRData_Binary(::_pbi::ConstantInitialized)128 PROTOBUF_CONSTEXPR LBRData_Binary::LBRData_Binary(
129 ::_pbi::ConstantInitialized): _impl_{
130 /*decltype(_impl_.path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
131 , /*decltype(_impl_.build_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
132 , /*decltype(_impl_._cached_size_)*/{}} {}
133 struct LBRData_BinaryDefaultTypeInternal {
LBRData_BinaryDefaultTypeInternalsimpleperf::proto::LBRData_BinaryDefaultTypeInternal134 PROTOBUF_CONSTEXPR LBRData_BinaryDefaultTypeInternal()
135 : _instance(::_pbi::ConstantInitialized{}) {}
~LBRData_BinaryDefaultTypeInternalsimpleperf::proto::LBRData_BinaryDefaultTypeInternal136 ~LBRData_BinaryDefaultTypeInternal() {}
137 union { // NOLINT(misc-non-private-member-variables-in-classes)
138 LBRData_Binary _instance;
139 };
140 };
141 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LBRData_BinaryDefaultTypeInternal _LBRData_Binary_default_instance_;
LBRData(::_pbi::ConstantInitialized)142 PROTOBUF_CONSTEXPR LBRData::LBRData(
143 ::_pbi::ConstantInitialized): _impl_{
144 /*decltype(_impl_.samples_)*/{}
145 , /*decltype(_impl_.binaries_)*/{}
146 , /*decltype(_impl_._cached_size_)*/{}} {}
147 struct LBRDataDefaultTypeInternal {
LBRDataDefaultTypeInternalsimpleperf::proto::LBRDataDefaultTypeInternal148 PROTOBUF_CONSTEXPR LBRDataDefaultTypeInternal()
149 : _instance(::_pbi::ConstantInitialized{}) {}
~LBRDataDefaultTypeInternalsimpleperf::proto::LBRDataDefaultTypeInternal150 ~LBRDataDefaultTypeInternal() {}
151 union { // NOLINT(misc-non-private-member-variables-in-classes)
152 LBRData _instance;
153 };
154 };
155 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LBRDataDefaultTypeInternal _LBRData_default_instance_;
156 } // namespace proto
157 } // namespace simpleperf
158 namespace simpleperf {
159 namespace proto {
ETMBinary_BinaryType_IsValid(int value)160 bool ETMBinary_BinaryType_IsValid(int value) {
161 switch (value) {
162 case 0:
163 case 1:
164 case 2:
165 return true;
166 default:
167 return false;
168 }
169 }
170
171 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ETMBinary_BinaryType_strings[3] = {};
172
173 static const char ETMBinary_BinaryType_names[] =
174 "ELF_FILE"
175 "KERNEL"
176 "KERNEL_MODULE";
177
178 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ETMBinary_BinaryType_entries[] = {
179 { {ETMBinary_BinaryType_names + 0, 8}, 0 },
180 { {ETMBinary_BinaryType_names + 8, 6}, 1 },
181 { {ETMBinary_BinaryType_names + 14, 13}, 2 },
182 };
183
184 static const int ETMBinary_BinaryType_entries_by_number[] = {
185 0, // 0 -> ELF_FILE
186 1, // 1 -> KERNEL
187 2, // 2 -> KERNEL_MODULE
188 };
189
ETMBinary_BinaryType_Name(ETMBinary_BinaryType value)190 const std::string& ETMBinary_BinaryType_Name(
191 ETMBinary_BinaryType value) {
192 static const bool dummy =
193 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
194 ETMBinary_BinaryType_entries,
195 ETMBinary_BinaryType_entries_by_number,
196 3, ETMBinary_BinaryType_strings);
197 (void) dummy;
198 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
199 ETMBinary_BinaryType_entries,
200 ETMBinary_BinaryType_entries_by_number,
201 3, value);
202 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
203 ETMBinary_BinaryType_strings[idx].get();
204 }
ETMBinary_BinaryType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,ETMBinary_BinaryType * value)205 bool ETMBinary_BinaryType_Parse(
206 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ETMBinary_BinaryType* value) {
207 int int_value;
208 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
209 ETMBinary_BinaryType_entries, 3, name, &int_value);
210 if (success) {
211 *value = static_cast<ETMBinary_BinaryType>(int_value);
212 }
213 return success;
214 }
215 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
216 constexpr ETMBinary_BinaryType ETMBinary::ELF_FILE;
217 constexpr ETMBinary_BinaryType ETMBinary::KERNEL;
218 constexpr ETMBinary_BinaryType ETMBinary::KERNEL_MODULE;
219 constexpr ETMBinary_BinaryType ETMBinary::BinaryType_MIN;
220 constexpr ETMBinary_BinaryType ETMBinary::BinaryType_MAX;
221 constexpr int ETMBinary::BinaryType_ARRAYSIZE;
222 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
223
224 // ===================================================================
225
226 class BranchList::_Internal {
227 public:
228 static const ::simpleperf::proto::LBRData& lbr_data(const BranchList* msg);
229 };
230
231 const ::simpleperf::proto::LBRData&
lbr_data(const BranchList * msg)232 BranchList::_Internal::lbr_data(const BranchList* msg) {
233 return *msg->_impl_.lbr_data_;
234 }
BranchList(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)235 BranchList::BranchList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
236 bool is_message_owned)
237 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
238 SharedCtor(arena, is_message_owned);
239 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.BranchList)
240 }
BranchList(const BranchList & from)241 BranchList::BranchList(const BranchList& from)
242 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
243 BranchList* const _this = this; (void)_this;
244 new (&_impl_) Impl_{
245 decltype(_impl_.etm_data_){from._impl_.etm_data_}
246 , decltype(_impl_.magic_){}
247 , decltype(_impl_.lbr_data_){nullptr}
248 , /*decltype(_impl_._cached_size_)*/{}};
249
250 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
251 _impl_.magic_.InitDefault();
252 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
253 _impl_.magic_.Set("", GetArenaForAllocation());
254 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
255 if (!from._internal_magic().empty()) {
256 _this->_impl_.magic_.Set(from._internal_magic(),
257 _this->GetArenaForAllocation());
258 }
259 if (from._internal_has_lbr_data()) {
260 _this->_impl_.lbr_data_ = new ::simpleperf::proto::LBRData(*from._impl_.lbr_data_);
261 }
262 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.BranchList)
263 }
264
SharedCtor(::_pb::Arena * arena,bool is_message_owned)265 inline void BranchList::SharedCtor(
266 ::_pb::Arena* arena, bool is_message_owned) {
267 (void)arena;
268 (void)is_message_owned;
269 new (&_impl_) Impl_{
270 decltype(_impl_.etm_data_){arena}
271 , decltype(_impl_.magic_){}
272 , decltype(_impl_.lbr_data_){nullptr}
273 , /*decltype(_impl_._cached_size_)*/{}
274 };
275 _impl_.magic_.InitDefault();
276 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
277 _impl_.magic_.Set("", GetArenaForAllocation());
278 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
279 }
280
~BranchList()281 BranchList::~BranchList() {
282 // @@protoc_insertion_point(destructor:simpleperf.proto.BranchList)
283 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
284 (void)arena;
285 return;
286 }
287 SharedDtor();
288 }
289
SharedDtor()290 inline void BranchList::SharedDtor() {
291 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
292 _impl_.etm_data_.~RepeatedPtrField();
293 _impl_.magic_.Destroy();
294 if (this != internal_default_instance()) delete _impl_.lbr_data_;
295 }
296
SetCachedSize(int size) const297 void BranchList::SetCachedSize(int size) const {
298 _impl_._cached_size_.Set(size);
299 }
300
Clear()301 void BranchList::Clear() {
302 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.BranchList)
303 ::uint32_t cached_has_bits = 0;
304 // Prevent compiler warnings about cached_has_bits being unused
305 (void) cached_has_bits;
306
307 _impl_.etm_data_.Clear();
308 _impl_.magic_.ClearToEmpty();
309 if (GetArenaForAllocation() == nullptr && _impl_.lbr_data_ != nullptr) {
310 delete _impl_.lbr_data_;
311 }
312 _impl_.lbr_data_ = nullptr;
313 _internal_metadata_.Clear<std::string>();
314 }
315
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)316 const char* BranchList::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
317 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
318 while (!ctx->Done(&ptr)) {
319 ::uint32_t tag;
320 ptr = ::_pbi::ReadTag(ptr, &tag);
321 switch (tag >> 3) {
322 // string magic = 1;
323 case 1:
324 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
325 auto str = _internal_mutable_magic();
326 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
327 CHK_(ptr);
328 CHK_(::_pbi::VerifyUTF8(str, nullptr));
329 } else {
330 goto handle_unusual;
331 }
332 continue;
333 // repeated .simpleperf.proto.ETMBinary etm_data = 2;
334 case 2:
335 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
336 ptr -= 1;
337 do {
338 ptr += 1;
339 ptr = ctx->ParseMessage(_internal_add_etm_data(), ptr);
340 CHK_(ptr);
341 if (!ctx->DataAvailable(ptr)) break;
342 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
343 } else {
344 goto handle_unusual;
345 }
346 continue;
347 // .simpleperf.proto.LBRData lbr_data = 3;
348 case 3:
349 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
350 ptr = ctx->ParseMessage(_internal_mutable_lbr_data(), ptr);
351 CHK_(ptr);
352 } else {
353 goto handle_unusual;
354 }
355 continue;
356 default:
357 goto handle_unusual;
358 } // switch
359 handle_unusual:
360 if ((tag == 0) || ((tag & 7) == 4)) {
361 CHK_(ptr);
362 ctx->SetLastTag(tag);
363 goto message_done;
364 }
365 ptr = UnknownFieldParse(
366 tag,
367 _internal_metadata_.mutable_unknown_fields<std::string>(),
368 ptr, ctx);
369 CHK_(ptr != nullptr);
370 } // while
371 message_done:
372 return ptr;
373 failure:
374 ptr = nullptr;
375 goto message_done;
376 #undef CHK_
377 }
378
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const379 ::uint8_t* BranchList::_InternalSerialize(
380 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
381 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.BranchList)
382 ::uint32_t cached_has_bits = 0;
383 (void) cached_has_bits;
384
385 // string magic = 1;
386 if (!this->_internal_magic().empty()) {
387 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
388 this->_internal_magic().data(), static_cast<int>(this->_internal_magic().length()),
389 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
390 "simpleperf.proto.BranchList.magic");
391 target = stream->WriteStringMaybeAliased(
392 1, this->_internal_magic(), target);
393 }
394
395 // repeated .simpleperf.proto.ETMBinary etm_data = 2;
396 for (unsigned i = 0,
397 n = static_cast<unsigned>(this->_internal_etm_data_size()); i < n; i++) {
398 const auto& repfield = this->_internal_etm_data(i);
399 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
400 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
401 }
402
403 // .simpleperf.proto.LBRData lbr_data = 3;
404 if (this->_internal_has_lbr_data()) {
405 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
406 InternalWriteMessage(3, _Internal::lbr_data(this),
407 _Internal::lbr_data(this).GetCachedSize(), target, stream);
408 }
409
410 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
411 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
412 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
413 }
414 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.BranchList)
415 return target;
416 }
417
ByteSizeLong() const418 size_t BranchList::ByteSizeLong() const {
419 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.BranchList)
420 size_t total_size = 0;
421
422 ::uint32_t cached_has_bits = 0;
423 // Prevent compiler warnings about cached_has_bits being unused
424 (void) cached_has_bits;
425
426 // repeated .simpleperf.proto.ETMBinary etm_data = 2;
427 total_size += 1UL * this->_internal_etm_data_size();
428 for (const auto& msg : this->_impl_.etm_data_) {
429 total_size +=
430 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
431 }
432
433 // string magic = 1;
434 if (!this->_internal_magic().empty()) {
435 total_size += 1 +
436 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
437 this->_internal_magic());
438 }
439
440 // .simpleperf.proto.LBRData lbr_data = 3;
441 if (this->_internal_has_lbr_data()) {
442 total_size += 1 +
443 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
444 *_impl_.lbr_data_);
445 }
446
447 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
448 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
449 }
450 int cached_size = ::_pbi::ToCachedSize(total_size);
451 SetCachedSize(cached_size);
452 return total_size;
453 }
454
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)455 void BranchList::CheckTypeAndMergeFrom(
456 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
457 MergeFrom(*::_pbi::DownCast<const BranchList*>(
458 &from));
459 }
460
MergeFrom(const BranchList & from)461 void BranchList::MergeFrom(const BranchList& from) {
462 BranchList* const _this = this;
463 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.BranchList)
464 GOOGLE_DCHECK_NE(&from, _this);
465 ::uint32_t cached_has_bits = 0;
466 (void) cached_has_bits;
467
468 _this->_impl_.etm_data_.MergeFrom(from._impl_.etm_data_);
469 if (!from._internal_magic().empty()) {
470 _this->_internal_set_magic(from._internal_magic());
471 }
472 if (from._internal_has_lbr_data()) {
473 _this->_internal_mutable_lbr_data()->::simpleperf::proto::LBRData::MergeFrom(
474 from._internal_lbr_data());
475 }
476 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
477 }
478
CopyFrom(const BranchList & from)479 void BranchList::CopyFrom(const BranchList& from) {
480 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.BranchList)
481 if (&from == this) return;
482 Clear();
483 MergeFrom(from);
484 }
485
IsInitialized() const486 bool BranchList::IsInitialized() const {
487 return true;
488 }
489
InternalSwap(BranchList * other)490 void BranchList::InternalSwap(BranchList* other) {
491 using std::swap;
492 auto* lhs_arena = GetArenaForAllocation();
493 auto* rhs_arena = other->GetArenaForAllocation();
494 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
495 _impl_.etm_data_.InternalSwap(&other->_impl_.etm_data_);
496 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
497 &_impl_.magic_, lhs_arena,
498 &other->_impl_.magic_, rhs_arena
499 );
500 swap(_impl_.lbr_data_, other->_impl_.lbr_data_);
501 }
502
GetTypeName() const503 std::string BranchList::GetTypeName() const {
504 return "simpleperf.proto.BranchList";
505 }
506
507
508 // ===================================================================
509
510 class ETMBinary_Address_Branch::_Internal {
511 public:
512 };
513
ETMBinary_Address_Branch(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)514 ETMBinary_Address_Branch::ETMBinary_Address_Branch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
515 bool is_message_owned)
516 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
517 SharedCtor(arena, is_message_owned);
518 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.ETMBinary.Address.Branch)
519 }
ETMBinary_Address_Branch(const ETMBinary_Address_Branch & from)520 ETMBinary_Address_Branch::ETMBinary_Address_Branch(const ETMBinary_Address_Branch& from)
521 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
522 ETMBinary_Address_Branch* const _this = this; (void)_this;
523 new (&_impl_) Impl_{
524 decltype(_impl_.branch_){}
525 , decltype(_impl_.count_){}
526 , decltype(_impl_.branch_size_){}
527 , /*decltype(_impl_._cached_size_)*/{}};
528
529 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
530 _impl_.branch_.InitDefault();
531 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
532 _impl_.branch_.Set("", GetArenaForAllocation());
533 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
534 if (!from._internal_branch().empty()) {
535 _this->_impl_.branch_.Set(from._internal_branch(),
536 _this->GetArenaForAllocation());
537 }
538 ::memcpy(&_impl_.count_, &from._impl_.count_,
539 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.branch_size_) -
540 reinterpret_cast<char*>(&_impl_.count_)) + sizeof(_impl_.branch_size_));
541 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.ETMBinary.Address.Branch)
542 }
543
SharedCtor(::_pb::Arena * arena,bool is_message_owned)544 inline void ETMBinary_Address_Branch::SharedCtor(
545 ::_pb::Arena* arena, bool is_message_owned) {
546 (void)arena;
547 (void)is_message_owned;
548 new (&_impl_) Impl_{
549 decltype(_impl_.branch_){}
550 , decltype(_impl_.count_){::uint64_t{0u}}
551 , decltype(_impl_.branch_size_){0u}
552 , /*decltype(_impl_._cached_size_)*/{}
553 };
554 _impl_.branch_.InitDefault();
555 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
556 _impl_.branch_.Set("", GetArenaForAllocation());
557 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
558 }
559
~ETMBinary_Address_Branch()560 ETMBinary_Address_Branch::~ETMBinary_Address_Branch() {
561 // @@protoc_insertion_point(destructor:simpleperf.proto.ETMBinary.Address.Branch)
562 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
563 (void)arena;
564 return;
565 }
566 SharedDtor();
567 }
568
SharedDtor()569 inline void ETMBinary_Address_Branch::SharedDtor() {
570 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
571 _impl_.branch_.Destroy();
572 }
573
SetCachedSize(int size) const574 void ETMBinary_Address_Branch::SetCachedSize(int size) const {
575 _impl_._cached_size_.Set(size);
576 }
577
Clear()578 void ETMBinary_Address_Branch::Clear() {
579 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.ETMBinary.Address.Branch)
580 ::uint32_t cached_has_bits = 0;
581 // Prevent compiler warnings about cached_has_bits being unused
582 (void) cached_has_bits;
583
584 _impl_.branch_.ClearToEmpty();
585 ::memset(&_impl_.count_, 0, static_cast<size_t>(
586 reinterpret_cast<char*>(&_impl_.branch_size_) -
587 reinterpret_cast<char*>(&_impl_.count_)) + sizeof(_impl_.branch_size_));
588 _internal_metadata_.Clear<std::string>();
589 }
590
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)591 const char* ETMBinary_Address_Branch::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
592 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
593 while (!ctx->Done(&ptr)) {
594 ::uint32_t tag;
595 ptr = ::_pbi::ReadTag(ptr, &tag);
596 switch (tag >> 3) {
597 // bytes branch = 1;
598 case 1:
599 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
600 auto str = _internal_mutable_branch();
601 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
602 CHK_(ptr);
603 } else {
604 goto handle_unusual;
605 }
606 continue;
607 // uint32 branch_size = 2;
608 case 2:
609 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
610 _impl_.branch_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
611 CHK_(ptr);
612 } else {
613 goto handle_unusual;
614 }
615 continue;
616 // uint64 count = 3;
617 case 3:
618 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
619 _impl_.count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
620 CHK_(ptr);
621 } else {
622 goto handle_unusual;
623 }
624 continue;
625 default:
626 goto handle_unusual;
627 } // switch
628 handle_unusual:
629 if ((tag == 0) || ((tag & 7) == 4)) {
630 CHK_(ptr);
631 ctx->SetLastTag(tag);
632 goto message_done;
633 }
634 ptr = UnknownFieldParse(
635 tag,
636 _internal_metadata_.mutable_unknown_fields<std::string>(),
637 ptr, ctx);
638 CHK_(ptr != nullptr);
639 } // while
640 message_done:
641 return ptr;
642 failure:
643 ptr = nullptr;
644 goto message_done;
645 #undef CHK_
646 }
647
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const648 ::uint8_t* ETMBinary_Address_Branch::_InternalSerialize(
649 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
650 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.ETMBinary.Address.Branch)
651 ::uint32_t cached_has_bits = 0;
652 (void) cached_has_bits;
653
654 // bytes branch = 1;
655 if (!this->_internal_branch().empty()) {
656 target = stream->WriteBytesMaybeAliased(
657 1, this->_internal_branch(), target);
658 }
659
660 // uint32 branch_size = 2;
661 if (this->_internal_branch_size() != 0) {
662 target = stream->EnsureSpace(target);
663 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_branch_size(), target);
664 }
665
666 // uint64 count = 3;
667 if (this->_internal_count() != 0) {
668 target = stream->EnsureSpace(target);
669 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_count(), target);
670 }
671
672 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
673 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
674 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
675 }
676 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.ETMBinary.Address.Branch)
677 return target;
678 }
679
ByteSizeLong() const680 size_t ETMBinary_Address_Branch::ByteSizeLong() const {
681 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.ETMBinary.Address.Branch)
682 size_t total_size = 0;
683
684 ::uint32_t cached_has_bits = 0;
685 // Prevent compiler warnings about cached_has_bits being unused
686 (void) cached_has_bits;
687
688 // bytes branch = 1;
689 if (!this->_internal_branch().empty()) {
690 total_size += 1 +
691 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
692 this->_internal_branch());
693 }
694
695 // uint64 count = 3;
696 if (this->_internal_count() != 0) {
697 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_count());
698 }
699
700 // uint32 branch_size = 2;
701 if (this->_internal_branch_size() != 0) {
702 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_branch_size());
703 }
704
705 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
706 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
707 }
708 int cached_size = ::_pbi::ToCachedSize(total_size);
709 SetCachedSize(cached_size);
710 return total_size;
711 }
712
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)713 void ETMBinary_Address_Branch::CheckTypeAndMergeFrom(
714 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
715 MergeFrom(*::_pbi::DownCast<const ETMBinary_Address_Branch*>(
716 &from));
717 }
718
MergeFrom(const ETMBinary_Address_Branch & from)719 void ETMBinary_Address_Branch::MergeFrom(const ETMBinary_Address_Branch& from) {
720 ETMBinary_Address_Branch* const _this = this;
721 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.ETMBinary.Address.Branch)
722 GOOGLE_DCHECK_NE(&from, _this);
723 ::uint32_t cached_has_bits = 0;
724 (void) cached_has_bits;
725
726 if (!from._internal_branch().empty()) {
727 _this->_internal_set_branch(from._internal_branch());
728 }
729 if (from._internal_count() != 0) {
730 _this->_internal_set_count(from._internal_count());
731 }
732 if (from._internal_branch_size() != 0) {
733 _this->_internal_set_branch_size(from._internal_branch_size());
734 }
735 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
736 }
737
CopyFrom(const ETMBinary_Address_Branch & from)738 void ETMBinary_Address_Branch::CopyFrom(const ETMBinary_Address_Branch& from) {
739 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.ETMBinary.Address.Branch)
740 if (&from == this) return;
741 Clear();
742 MergeFrom(from);
743 }
744
IsInitialized() const745 bool ETMBinary_Address_Branch::IsInitialized() const {
746 return true;
747 }
748
InternalSwap(ETMBinary_Address_Branch * other)749 void ETMBinary_Address_Branch::InternalSwap(ETMBinary_Address_Branch* other) {
750 using std::swap;
751 auto* lhs_arena = GetArenaForAllocation();
752 auto* rhs_arena = other->GetArenaForAllocation();
753 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
754 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
755 &_impl_.branch_, lhs_arena,
756 &other->_impl_.branch_, rhs_arena
757 );
758 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
759 PROTOBUF_FIELD_OFFSET(ETMBinary_Address_Branch, _impl_.branch_size_)
760 + sizeof(ETMBinary_Address_Branch::_impl_.branch_size_) // NOLINT
761 - PROTOBUF_FIELD_OFFSET(ETMBinary_Address_Branch, _impl_.count_)>(
762 reinterpret_cast<char*>(&_impl_.count_),
763 reinterpret_cast<char*>(&other->_impl_.count_));
764 }
765
GetTypeName() const766 std::string ETMBinary_Address_Branch::GetTypeName() const {
767 return "simpleperf.proto.ETMBinary.Address.Branch";
768 }
769
770
771 // ===================================================================
772
773 class ETMBinary_Address::_Internal {
774 public:
775 };
776
ETMBinary_Address(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)777 ETMBinary_Address::ETMBinary_Address(::PROTOBUF_NAMESPACE_ID::Arena* arena,
778 bool is_message_owned)
779 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
780 SharedCtor(arena, is_message_owned);
781 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.ETMBinary.Address)
782 }
ETMBinary_Address(const ETMBinary_Address & from)783 ETMBinary_Address::ETMBinary_Address(const ETMBinary_Address& from)
784 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
785 ETMBinary_Address* const _this = this; (void)_this;
786 new (&_impl_) Impl_{
787 decltype(_impl_.branches_){from._impl_.branches_}
788 , decltype(_impl_.addr_){}
789 , /*decltype(_impl_._cached_size_)*/{}};
790
791 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
792 _this->_impl_.addr_ = from._impl_.addr_;
793 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.ETMBinary.Address)
794 }
795
SharedCtor(::_pb::Arena * arena,bool is_message_owned)796 inline void ETMBinary_Address::SharedCtor(
797 ::_pb::Arena* arena, bool is_message_owned) {
798 (void)arena;
799 (void)is_message_owned;
800 new (&_impl_) Impl_{
801 decltype(_impl_.branches_){arena}
802 , decltype(_impl_.addr_){::uint64_t{0u}}
803 , /*decltype(_impl_._cached_size_)*/{}
804 };
805 }
806
~ETMBinary_Address()807 ETMBinary_Address::~ETMBinary_Address() {
808 // @@protoc_insertion_point(destructor:simpleperf.proto.ETMBinary.Address)
809 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
810 (void)arena;
811 return;
812 }
813 SharedDtor();
814 }
815
SharedDtor()816 inline void ETMBinary_Address::SharedDtor() {
817 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
818 _impl_.branches_.~RepeatedPtrField();
819 }
820
SetCachedSize(int size) const821 void ETMBinary_Address::SetCachedSize(int size) const {
822 _impl_._cached_size_.Set(size);
823 }
824
Clear()825 void ETMBinary_Address::Clear() {
826 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.ETMBinary.Address)
827 ::uint32_t cached_has_bits = 0;
828 // Prevent compiler warnings about cached_has_bits being unused
829 (void) cached_has_bits;
830
831 _impl_.branches_.Clear();
832 _impl_.addr_ = ::uint64_t{0u};
833 _internal_metadata_.Clear<std::string>();
834 }
835
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)836 const char* ETMBinary_Address::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
837 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
838 while (!ctx->Done(&ptr)) {
839 ::uint32_t tag;
840 ptr = ::_pbi::ReadTag(ptr, &tag);
841 switch (tag >> 3) {
842 // uint64 addr = 1;
843 case 1:
844 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
845 _impl_.addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
846 CHK_(ptr);
847 } else {
848 goto handle_unusual;
849 }
850 continue;
851 // repeated .simpleperf.proto.ETMBinary.Address.Branch branches = 2;
852 case 2:
853 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
854 ptr -= 1;
855 do {
856 ptr += 1;
857 ptr = ctx->ParseMessage(_internal_add_branches(), ptr);
858 CHK_(ptr);
859 if (!ctx->DataAvailable(ptr)) break;
860 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
861 } else {
862 goto handle_unusual;
863 }
864 continue;
865 default:
866 goto handle_unusual;
867 } // switch
868 handle_unusual:
869 if ((tag == 0) || ((tag & 7) == 4)) {
870 CHK_(ptr);
871 ctx->SetLastTag(tag);
872 goto message_done;
873 }
874 ptr = UnknownFieldParse(
875 tag,
876 _internal_metadata_.mutable_unknown_fields<std::string>(),
877 ptr, ctx);
878 CHK_(ptr != nullptr);
879 } // while
880 message_done:
881 return ptr;
882 failure:
883 ptr = nullptr;
884 goto message_done;
885 #undef CHK_
886 }
887
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const888 ::uint8_t* ETMBinary_Address::_InternalSerialize(
889 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
890 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.ETMBinary.Address)
891 ::uint32_t cached_has_bits = 0;
892 (void) cached_has_bits;
893
894 // uint64 addr = 1;
895 if (this->_internal_addr() != 0) {
896 target = stream->EnsureSpace(target);
897 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_addr(), target);
898 }
899
900 // repeated .simpleperf.proto.ETMBinary.Address.Branch branches = 2;
901 for (unsigned i = 0,
902 n = static_cast<unsigned>(this->_internal_branches_size()); i < n; i++) {
903 const auto& repfield = this->_internal_branches(i);
904 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
905 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
906 }
907
908 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
909 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
910 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
911 }
912 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.ETMBinary.Address)
913 return target;
914 }
915
ByteSizeLong() const916 size_t ETMBinary_Address::ByteSizeLong() const {
917 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.ETMBinary.Address)
918 size_t total_size = 0;
919
920 ::uint32_t cached_has_bits = 0;
921 // Prevent compiler warnings about cached_has_bits being unused
922 (void) cached_has_bits;
923
924 // repeated .simpleperf.proto.ETMBinary.Address.Branch branches = 2;
925 total_size += 1UL * this->_internal_branches_size();
926 for (const auto& msg : this->_impl_.branches_) {
927 total_size +=
928 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
929 }
930
931 // uint64 addr = 1;
932 if (this->_internal_addr() != 0) {
933 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_addr());
934 }
935
936 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
937 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
938 }
939 int cached_size = ::_pbi::ToCachedSize(total_size);
940 SetCachedSize(cached_size);
941 return total_size;
942 }
943
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)944 void ETMBinary_Address::CheckTypeAndMergeFrom(
945 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
946 MergeFrom(*::_pbi::DownCast<const ETMBinary_Address*>(
947 &from));
948 }
949
MergeFrom(const ETMBinary_Address & from)950 void ETMBinary_Address::MergeFrom(const ETMBinary_Address& from) {
951 ETMBinary_Address* const _this = this;
952 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.ETMBinary.Address)
953 GOOGLE_DCHECK_NE(&from, _this);
954 ::uint32_t cached_has_bits = 0;
955 (void) cached_has_bits;
956
957 _this->_impl_.branches_.MergeFrom(from._impl_.branches_);
958 if (from._internal_addr() != 0) {
959 _this->_internal_set_addr(from._internal_addr());
960 }
961 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
962 }
963
CopyFrom(const ETMBinary_Address & from)964 void ETMBinary_Address::CopyFrom(const ETMBinary_Address& from) {
965 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.ETMBinary.Address)
966 if (&from == this) return;
967 Clear();
968 MergeFrom(from);
969 }
970
IsInitialized() const971 bool ETMBinary_Address::IsInitialized() const {
972 return true;
973 }
974
InternalSwap(ETMBinary_Address * other)975 void ETMBinary_Address::InternalSwap(ETMBinary_Address* other) {
976 using std::swap;
977 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
978 _impl_.branches_.InternalSwap(&other->_impl_.branches_);
979 swap(_impl_.addr_, other->_impl_.addr_);
980 }
981
GetTypeName() const982 std::string ETMBinary_Address::GetTypeName() const {
983 return "simpleperf.proto.ETMBinary.Address";
984 }
985
986
987 // ===================================================================
988
989 class ETMBinary_KernelBinaryInfo::_Internal {
990 public:
991 };
992
ETMBinary_KernelBinaryInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)993 ETMBinary_KernelBinaryInfo::ETMBinary_KernelBinaryInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
994 bool is_message_owned)
995 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
996 SharedCtor(arena, is_message_owned);
997 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.ETMBinary.KernelBinaryInfo)
998 }
ETMBinary_KernelBinaryInfo(const ETMBinary_KernelBinaryInfo & from)999 ETMBinary_KernelBinaryInfo::ETMBinary_KernelBinaryInfo(const ETMBinary_KernelBinaryInfo& from)
1000 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1001 ETMBinary_KernelBinaryInfo* const _this = this; (void)_this;
1002 new (&_impl_) Impl_{
1003 decltype(_impl_.kernel_start_addr_){}
1004 , /*decltype(_impl_._cached_size_)*/{}};
1005
1006 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1007 _this->_impl_.kernel_start_addr_ = from._impl_.kernel_start_addr_;
1008 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.ETMBinary.KernelBinaryInfo)
1009 }
1010
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1011 inline void ETMBinary_KernelBinaryInfo::SharedCtor(
1012 ::_pb::Arena* arena, bool is_message_owned) {
1013 (void)arena;
1014 (void)is_message_owned;
1015 new (&_impl_) Impl_{
1016 decltype(_impl_.kernel_start_addr_){::uint64_t{0u}}
1017 , /*decltype(_impl_._cached_size_)*/{}
1018 };
1019 }
1020
~ETMBinary_KernelBinaryInfo()1021 ETMBinary_KernelBinaryInfo::~ETMBinary_KernelBinaryInfo() {
1022 // @@protoc_insertion_point(destructor:simpleperf.proto.ETMBinary.KernelBinaryInfo)
1023 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1024 (void)arena;
1025 return;
1026 }
1027 SharedDtor();
1028 }
1029
SharedDtor()1030 inline void ETMBinary_KernelBinaryInfo::SharedDtor() {
1031 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1032 }
1033
SetCachedSize(int size) const1034 void ETMBinary_KernelBinaryInfo::SetCachedSize(int size) const {
1035 _impl_._cached_size_.Set(size);
1036 }
1037
Clear()1038 void ETMBinary_KernelBinaryInfo::Clear() {
1039 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.ETMBinary.KernelBinaryInfo)
1040 ::uint32_t cached_has_bits = 0;
1041 // Prevent compiler warnings about cached_has_bits being unused
1042 (void) cached_has_bits;
1043
1044 _impl_.kernel_start_addr_ = ::uint64_t{0u};
1045 _internal_metadata_.Clear<std::string>();
1046 }
1047
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1048 const char* ETMBinary_KernelBinaryInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1049 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1050 while (!ctx->Done(&ptr)) {
1051 ::uint32_t tag;
1052 ptr = ::_pbi::ReadTag(ptr, &tag);
1053 switch (tag >> 3) {
1054 // uint64 kernel_start_addr = 1;
1055 case 1:
1056 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1057 _impl_.kernel_start_addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1058 CHK_(ptr);
1059 } else {
1060 goto handle_unusual;
1061 }
1062 continue;
1063 default:
1064 goto handle_unusual;
1065 } // switch
1066 handle_unusual:
1067 if ((tag == 0) || ((tag & 7) == 4)) {
1068 CHK_(ptr);
1069 ctx->SetLastTag(tag);
1070 goto message_done;
1071 }
1072 ptr = UnknownFieldParse(
1073 tag,
1074 _internal_metadata_.mutable_unknown_fields<std::string>(),
1075 ptr, ctx);
1076 CHK_(ptr != nullptr);
1077 } // while
1078 message_done:
1079 return ptr;
1080 failure:
1081 ptr = nullptr;
1082 goto message_done;
1083 #undef CHK_
1084 }
1085
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1086 ::uint8_t* ETMBinary_KernelBinaryInfo::_InternalSerialize(
1087 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1088 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.ETMBinary.KernelBinaryInfo)
1089 ::uint32_t cached_has_bits = 0;
1090 (void) cached_has_bits;
1091
1092 // uint64 kernel_start_addr = 1;
1093 if (this->_internal_kernel_start_addr() != 0) {
1094 target = stream->EnsureSpace(target);
1095 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_kernel_start_addr(), target);
1096 }
1097
1098 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1099 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1100 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1101 }
1102 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.ETMBinary.KernelBinaryInfo)
1103 return target;
1104 }
1105
ByteSizeLong() const1106 size_t ETMBinary_KernelBinaryInfo::ByteSizeLong() const {
1107 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.ETMBinary.KernelBinaryInfo)
1108 size_t total_size = 0;
1109
1110 ::uint32_t cached_has_bits = 0;
1111 // Prevent compiler warnings about cached_has_bits being unused
1112 (void) cached_has_bits;
1113
1114 // uint64 kernel_start_addr = 1;
1115 if (this->_internal_kernel_start_addr() != 0) {
1116 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_kernel_start_addr());
1117 }
1118
1119 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1120 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1121 }
1122 int cached_size = ::_pbi::ToCachedSize(total_size);
1123 SetCachedSize(cached_size);
1124 return total_size;
1125 }
1126
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1127 void ETMBinary_KernelBinaryInfo::CheckTypeAndMergeFrom(
1128 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1129 MergeFrom(*::_pbi::DownCast<const ETMBinary_KernelBinaryInfo*>(
1130 &from));
1131 }
1132
MergeFrom(const ETMBinary_KernelBinaryInfo & from)1133 void ETMBinary_KernelBinaryInfo::MergeFrom(const ETMBinary_KernelBinaryInfo& from) {
1134 ETMBinary_KernelBinaryInfo* const _this = this;
1135 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.ETMBinary.KernelBinaryInfo)
1136 GOOGLE_DCHECK_NE(&from, _this);
1137 ::uint32_t cached_has_bits = 0;
1138 (void) cached_has_bits;
1139
1140 if (from._internal_kernel_start_addr() != 0) {
1141 _this->_internal_set_kernel_start_addr(from._internal_kernel_start_addr());
1142 }
1143 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1144 }
1145
CopyFrom(const ETMBinary_KernelBinaryInfo & from)1146 void ETMBinary_KernelBinaryInfo::CopyFrom(const ETMBinary_KernelBinaryInfo& from) {
1147 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.ETMBinary.KernelBinaryInfo)
1148 if (&from == this) return;
1149 Clear();
1150 MergeFrom(from);
1151 }
1152
IsInitialized() const1153 bool ETMBinary_KernelBinaryInfo::IsInitialized() const {
1154 return true;
1155 }
1156
InternalSwap(ETMBinary_KernelBinaryInfo * other)1157 void ETMBinary_KernelBinaryInfo::InternalSwap(ETMBinary_KernelBinaryInfo* other) {
1158 using std::swap;
1159 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1160 swap(_impl_.kernel_start_addr_, other->_impl_.kernel_start_addr_);
1161 }
1162
GetTypeName() const1163 std::string ETMBinary_KernelBinaryInfo::GetTypeName() const {
1164 return "simpleperf.proto.ETMBinary.KernelBinaryInfo";
1165 }
1166
1167
1168 // ===================================================================
1169
1170 class ETMBinary::_Internal {
1171 public:
1172 static const ::simpleperf::proto::ETMBinary_KernelBinaryInfo& kernel_info(const ETMBinary* msg);
1173 };
1174
1175 const ::simpleperf::proto::ETMBinary_KernelBinaryInfo&
kernel_info(const ETMBinary * msg)1176 ETMBinary::_Internal::kernel_info(const ETMBinary* msg) {
1177 return *msg->_impl_.kernel_info_;
1178 }
ETMBinary(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1179 ETMBinary::ETMBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1180 bool is_message_owned)
1181 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1182 SharedCtor(arena, is_message_owned);
1183 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.ETMBinary)
1184 }
ETMBinary(const ETMBinary & from)1185 ETMBinary::ETMBinary(const ETMBinary& from)
1186 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1187 ETMBinary* const _this = this; (void)_this;
1188 new (&_impl_) Impl_{
1189 decltype(_impl_.addrs_){from._impl_.addrs_}
1190 , decltype(_impl_.path_){}
1191 , decltype(_impl_.build_id_){}
1192 , decltype(_impl_.kernel_info_){nullptr}
1193 , decltype(_impl_.type_){}
1194 , /*decltype(_impl_._cached_size_)*/{}};
1195
1196 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1197 _impl_.path_.InitDefault();
1198 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1199 _impl_.path_.Set("", GetArenaForAllocation());
1200 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1201 if (!from._internal_path().empty()) {
1202 _this->_impl_.path_.Set(from._internal_path(),
1203 _this->GetArenaForAllocation());
1204 }
1205 _impl_.build_id_.InitDefault();
1206 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1207 _impl_.build_id_.Set("", GetArenaForAllocation());
1208 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1209 if (!from._internal_build_id().empty()) {
1210 _this->_impl_.build_id_.Set(from._internal_build_id(),
1211 _this->GetArenaForAllocation());
1212 }
1213 if (from._internal_has_kernel_info()) {
1214 _this->_impl_.kernel_info_ = new ::simpleperf::proto::ETMBinary_KernelBinaryInfo(*from._impl_.kernel_info_);
1215 }
1216 _this->_impl_.type_ = from._impl_.type_;
1217 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.ETMBinary)
1218 }
1219
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1220 inline void ETMBinary::SharedCtor(
1221 ::_pb::Arena* arena, bool is_message_owned) {
1222 (void)arena;
1223 (void)is_message_owned;
1224 new (&_impl_) Impl_{
1225 decltype(_impl_.addrs_){arena}
1226 , decltype(_impl_.path_){}
1227 , decltype(_impl_.build_id_){}
1228 , decltype(_impl_.kernel_info_){nullptr}
1229 , decltype(_impl_.type_){0}
1230 , /*decltype(_impl_._cached_size_)*/{}
1231 };
1232 _impl_.path_.InitDefault();
1233 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1234 _impl_.path_.Set("", GetArenaForAllocation());
1235 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1236 _impl_.build_id_.InitDefault();
1237 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1238 _impl_.build_id_.Set("", GetArenaForAllocation());
1239 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1240 }
1241
~ETMBinary()1242 ETMBinary::~ETMBinary() {
1243 // @@protoc_insertion_point(destructor:simpleperf.proto.ETMBinary)
1244 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1245 (void)arena;
1246 return;
1247 }
1248 SharedDtor();
1249 }
1250
SharedDtor()1251 inline void ETMBinary::SharedDtor() {
1252 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1253 _impl_.addrs_.~RepeatedPtrField();
1254 _impl_.path_.Destroy();
1255 _impl_.build_id_.Destroy();
1256 if (this != internal_default_instance()) delete _impl_.kernel_info_;
1257 }
1258
SetCachedSize(int size) const1259 void ETMBinary::SetCachedSize(int size) const {
1260 _impl_._cached_size_.Set(size);
1261 }
1262
Clear()1263 void ETMBinary::Clear() {
1264 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.ETMBinary)
1265 ::uint32_t cached_has_bits = 0;
1266 // Prevent compiler warnings about cached_has_bits being unused
1267 (void) cached_has_bits;
1268
1269 _impl_.addrs_.Clear();
1270 _impl_.path_.ClearToEmpty();
1271 _impl_.build_id_.ClearToEmpty();
1272 if (GetArenaForAllocation() == nullptr && _impl_.kernel_info_ != nullptr) {
1273 delete _impl_.kernel_info_;
1274 }
1275 _impl_.kernel_info_ = nullptr;
1276 _impl_.type_ = 0;
1277 _internal_metadata_.Clear<std::string>();
1278 }
1279
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1280 const char* ETMBinary::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1281 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1282 while (!ctx->Done(&ptr)) {
1283 ::uint32_t tag;
1284 ptr = ::_pbi::ReadTag(ptr, &tag);
1285 switch (tag >> 3) {
1286 // string path = 1;
1287 case 1:
1288 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1289 auto str = _internal_mutable_path();
1290 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1291 CHK_(ptr);
1292 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1293 } else {
1294 goto handle_unusual;
1295 }
1296 continue;
1297 // string build_id = 2;
1298 case 2:
1299 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1300 auto str = _internal_mutable_build_id();
1301 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1302 CHK_(ptr);
1303 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1304 } else {
1305 goto handle_unusual;
1306 }
1307 continue;
1308 // repeated .simpleperf.proto.ETMBinary.Address addrs = 3;
1309 case 3:
1310 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1311 ptr -= 1;
1312 do {
1313 ptr += 1;
1314 ptr = ctx->ParseMessage(_internal_add_addrs(), ptr);
1315 CHK_(ptr);
1316 if (!ctx->DataAvailable(ptr)) break;
1317 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
1318 } else {
1319 goto handle_unusual;
1320 }
1321 continue;
1322 // .simpleperf.proto.ETMBinary.BinaryType type = 4;
1323 case 4:
1324 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1325 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1326 CHK_(ptr);
1327 _internal_set_type(static_cast<::simpleperf::proto::ETMBinary_BinaryType>(val));
1328 } else {
1329 goto handle_unusual;
1330 }
1331 continue;
1332 // .simpleperf.proto.ETMBinary.KernelBinaryInfo kernel_info = 5;
1333 case 5:
1334 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1335 ptr = ctx->ParseMessage(_internal_mutable_kernel_info(), ptr);
1336 CHK_(ptr);
1337 } else {
1338 goto handle_unusual;
1339 }
1340 continue;
1341 default:
1342 goto handle_unusual;
1343 } // switch
1344 handle_unusual:
1345 if ((tag == 0) || ((tag & 7) == 4)) {
1346 CHK_(ptr);
1347 ctx->SetLastTag(tag);
1348 goto message_done;
1349 }
1350 ptr = UnknownFieldParse(
1351 tag,
1352 _internal_metadata_.mutable_unknown_fields<std::string>(),
1353 ptr, ctx);
1354 CHK_(ptr != nullptr);
1355 } // while
1356 message_done:
1357 return ptr;
1358 failure:
1359 ptr = nullptr;
1360 goto message_done;
1361 #undef CHK_
1362 }
1363
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1364 ::uint8_t* ETMBinary::_InternalSerialize(
1365 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1366 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.ETMBinary)
1367 ::uint32_t cached_has_bits = 0;
1368 (void) cached_has_bits;
1369
1370 // string path = 1;
1371 if (!this->_internal_path().empty()) {
1372 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1373 this->_internal_path().data(), static_cast<int>(this->_internal_path().length()),
1374 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1375 "simpleperf.proto.ETMBinary.path");
1376 target = stream->WriteStringMaybeAliased(
1377 1, this->_internal_path(), target);
1378 }
1379
1380 // string build_id = 2;
1381 if (!this->_internal_build_id().empty()) {
1382 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1383 this->_internal_build_id().data(), static_cast<int>(this->_internal_build_id().length()),
1384 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1385 "simpleperf.proto.ETMBinary.build_id");
1386 target = stream->WriteStringMaybeAliased(
1387 2, this->_internal_build_id(), target);
1388 }
1389
1390 // repeated .simpleperf.proto.ETMBinary.Address addrs = 3;
1391 for (unsigned i = 0,
1392 n = static_cast<unsigned>(this->_internal_addrs_size()); i < n; i++) {
1393 const auto& repfield = this->_internal_addrs(i);
1394 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1395 InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
1396 }
1397
1398 // .simpleperf.proto.ETMBinary.BinaryType type = 4;
1399 if (this->_internal_type() != 0) {
1400 target = stream->EnsureSpace(target);
1401 target = ::_pbi::WireFormatLite::WriteEnumToArray(
1402 4, this->_internal_type(), target);
1403 }
1404
1405 // .simpleperf.proto.ETMBinary.KernelBinaryInfo kernel_info = 5;
1406 if (this->_internal_has_kernel_info()) {
1407 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1408 InternalWriteMessage(5, _Internal::kernel_info(this),
1409 _Internal::kernel_info(this).GetCachedSize(), target, stream);
1410 }
1411
1412 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1413 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1414 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1415 }
1416 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.ETMBinary)
1417 return target;
1418 }
1419
ByteSizeLong() const1420 size_t ETMBinary::ByteSizeLong() const {
1421 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.ETMBinary)
1422 size_t total_size = 0;
1423
1424 ::uint32_t cached_has_bits = 0;
1425 // Prevent compiler warnings about cached_has_bits being unused
1426 (void) cached_has_bits;
1427
1428 // repeated .simpleperf.proto.ETMBinary.Address addrs = 3;
1429 total_size += 1UL * this->_internal_addrs_size();
1430 for (const auto& msg : this->_impl_.addrs_) {
1431 total_size +=
1432 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1433 }
1434
1435 // string path = 1;
1436 if (!this->_internal_path().empty()) {
1437 total_size += 1 +
1438 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1439 this->_internal_path());
1440 }
1441
1442 // string build_id = 2;
1443 if (!this->_internal_build_id().empty()) {
1444 total_size += 1 +
1445 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1446 this->_internal_build_id());
1447 }
1448
1449 // .simpleperf.proto.ETMBinary.KernelBinaryInfo kernel_info = 5;
1450 if (this->_internal_has_kernel_info()) {
1451 total_size += 1 +
1452 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1453 *_impl_.kernel_info_);
1454 }
1455
1456 // .simpleperf.proto.ETMBinary.BinaryType type = 4;
1457 if (this->_internal_type() != 0) {
1458 total_size += 1 +
1459 ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
1460 }
1461
1462 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1463 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1464 }
1465 int cached_size = ::_pbi::ToCachedSize(total_size);
1466 SetCachedSize(cached_size);
1467 return total_size;
1468 }
1469
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1470 void ETMBinary::CheckTypeAndMergeFrom(
1471 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1472 MergeFrom(*::_pbi::DownCast<const ETMBinary*>(
1473 &from));
1474 }
1475
MergeFrom(const ETMBinary & from)1476 void ETMBinary::MergeFrom(const ETMBinary& from) {
1477 ETMBinary* const _this = this;
1478 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.ETMBinary)
1479 GOOGLE_DCHECK_NE(&from, _this);
1480 ::uint32_t cached_has_bits = 0;
1481 (void) cached_has_bits;
1482
1483 _this->_impl_.addrs_.MergeFrom(from._impl_.addrs_);
1484 if (!from._internal_path().empty()) {
1485 _this->_internal_set_path(from._internal_path());
1486 }
1487 if (!from._internal_build_id().empty()) {
1488 _this->_internal_set_build_id(from._internal_build_id());
1489 }
1490 if (from._internal_has_kernel_info()) {
1491 _this->_internal_mutable_kernel_info()->::simpleperf::proto::ETMBinary_KernelBinaryInfo::MergeFrom(
1492 from._internal_kernel_info());
1493 }
1494 if (from._internal_type() != 0) {
1495 _this->_internal_set_type(from._internal_type());
1496 }
1497 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1498 }
1499
CopyFrom(const ETMBinary & from)1500 void ETMBinary::CopyFrom(const ETMBinary& from) {
1501 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.ETMBinary)
1502 if (&from == this) return;
1503 Clear();
1504 MergeFrom(from);
1505 }
1506
IsInitialized() const1507 bool ETMBinary::IsInitialized() const {
1508 return true;
1509 }
1510
InternalSwap(ETMBinary * other)1511 void ETMBinary::InternalSwap(ETMBinary* other) {
1512 using std::swap;
1513 auto* lhs_arena = GetArenaForAllocation();
1514 auto* rhs_arena = other->GetArenaForAllocation();
1515 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1516 _impl_.addrs_.InternalSwap(&other->_impl_.addrs_);
1517 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1518 &_impl_.path_, lhs_arena,
1519 &other->_impl_.path_, rhs_arena
1520 );
1521 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1522 &_impl_.build_id_, lhs_arena,
1523 &other->_impl_.build_id_, rhs_arena
1524 );
1525 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1526 PROTOBUF_FIELD_OFFSET(ETMBinary, _impl_.type_)
1527 + sizeof(ETMBinary::_impl_.type_) // NOLINT
1528 - PROTOBUF_FIELD_OFFSET(ETMBinary, _impl_.kernel_info_)>(
1529 reinterpret_cast<char*>(&_impl_.kernel_info_),
1530 reinterpret_cast<char*>(&other->_impl_.kernel_info_));
1531 }
1532
GetTypeName() const1533 std::string ETMBinary::GetTypeName() const {
1534 return "simpleperf.proto.ETMBinary";
1535 }
1536
1537
1538 // ===================================================================
1539
1540 class LBRData_Sample_Branch::_Internal {
1541 public:
1542 };
1543
LBRData_Sample_Branch(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1544 LBRData_Sample_Branch::LBRData_Sample_Branch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1545 bool is_message_owned)
1546 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1547 SharedCtor(arena, is_message_owned);
1548 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.LBRData.Sample.Branch)
1549 }
LBRData_Sample_Branch(const LBRData_Sample_Branch & from)1550 LBRData_Sample_Branch::LBRData_Sample_Branch(const LBRData_Sample_Branch& from)
1551 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1552 LBRData_Sample_Branch* const _this = this; (void)_this;
1553 new (&_impl_) Impl_{
1554 decltype(_impl_.from_binary_id_){}
1555 , decltype(_impl_.to_binary_id_){}
1556 , decltype(_impl_.from_vaddr_in_file_){}
1557 , decltype(_impl_.to_vaddr_in_file_){}
1558 , /*decltype(_impl_._cached_size_)*/{}};
1559
1560 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1561 ::memcpy(&_impl_.from_binary_id_, &from._impl_.from_binary_id_,
1562 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.to_vaddr_in_file_) -
1563 reinterpret_cast<char*>(&_impl_.from_binary_id_)) + sizeof(_impl_.to_vaddr_in_file_));
1564 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.LBRData.Sample.Branch)
1565 }
1566
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1567 inline void LBRData_Sample_Branch::SharedCtor(
1568 ::_pb::Arena* arena, bool is_message_owned) {
1569 (void)arena;
1570 (void)is_message_owned;
1571 new (&_impl_) Impl_{
1572 decltype(_impl_.from_binary_id_){0u}
1573 , decltype(_impl_.to_binary_id_){0u}
1574 , decltype(_impl_.from_vaddr_in_file_){::uint64_t{0u}}
1575 , decltype(_impl_.to_vaddr_in_file_){::uint64_t{0u}}
1576 , /*decltype(_impl_._cached_size_)*/{}
1577 };
1578 }
1579
~LBRData_Sample_Branch()1580 LBRData_Sample_Branch::~LBRData_Sample_Branch() {
1581 // @@protoc_insertion_point(destructor:simpleperf.proto.LBRData.Sample.Branch)
1582 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1583 (void)arena;
1584 return;
1585 }
1586 SharedDtor();
1587 }
1588
SharedDtor()1589 inline void LBRData_Sample_Branch::SharedDtor() {
1590 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1591 }
1592
SetCachedSize(int size) const1593 void LBRData_Sample_Branch::SetCachedSize(int size) const {
1594 _impl_._cached_size_.Set(size);
1595 }
1596
Clear()1597 void LBRData_Sample_Branch::Clear() {
1598 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.LBRData.Sample.Branch)
1599 ::uint32_t cached_has_bits = 0;
1600 // Prevent compiler warnings about cached_has_bits being unused
1601 (void) cached_has_bits;
1602
1603 ::memset(&_impl_.from_binary_id_, 0, static_cast<size_t>(
1604 reinterpret_cast<char*>(&_impl_.to_vaddr_in_file_) -
1605 reinterpret_cast<char*>(&_impl_.from_binary_id_)) + sizeof(_impl_.to_vaddr_in_file_));
1606 _internal_metadata_.Clear<std::string>();
1607 }
1608
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1609 const char* LBRData_Sample_Branch::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1610 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1611 while (!ctx->Done(&ptr)) {
1612 ::uint32_t tag;
1613 ptr = ::_pbi::ReadTag(ptr, &tag);
1614 switch (tag >> 3) {
1615 // uint32 from_binary_id = 1;
1616 case 1:
1617 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1618 _impl_.from_binary_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1619 CHK_(ptr);
1620 } else {
1621 goto handle_unusual;
1622 }
1623 continue;
1624 // uint32 to_binary_id = 2;
1625 case 2:
1626 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1627 _impl_.to_binary_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1628 CHK_(ptr);
1629 } else {
1630 goto handle_unusual;
1631 }
1632 continue;
1633 // uint64 from_vaddr_in_file = 3;
1634 case 3:
1635 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1636 _impl_.from_vaddr_in_file_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1637 CHK_(ptr);
1638 } else {
1639 goto handle_unusual;
1640 }
1641 continue;
1642 // uint64 to_vaddr_in_file = 4;
1643 case 4:
1644 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1645 _impl_.to_vaddr_in_file_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1646 CHK_(ptr);
1647 } else {
1648 goto handle_unusual;
1649 }
1650 continue;
1651 default:
1652 goto handle_unusual;
1653 } // switch
1654 handle_unusual:
1655 if ((tag == 0) || ((tag & 7) == 4)) {
1656 CHK_(ptr);
1657 ctx->SetLastTag(tag);
1658 goto message_done;
1659 }
1660 ptr = UnknownFieldParse(
1661 tag,
1662 _internal_metadata_.mutable_unknown_fields<std::string>(),
1663 ptr, ctx);
1664 CHK_(ptr != nullptr);
1665 } // while
1666 message_done:
1667 return ptr;
1668 failure:
1669 ptr = nullptr;
1670 goto message_done;
1671 #undef CHK_
1672 }
1673
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1674 ::uint8_t* LBRData_Sample_Branch::_InternalSerialize(
1675 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1676 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.LBRData.Sample.Branch)
1677 ::uint32_t cached_has_bits = 0;
1678 (void) cached_has_bits;
1679
1680 // uint32 from_binary_id = 1;
1681 if (this->_internal_from_binary_id() != 0) {
1682 target = stream->EnsureSpace(target);
1683 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_from_binary_id(), target);
1684 }
1685
1686 // uint32 to_binary_id = 2;
1687 if (this->_internal_to_binary_id() != 0) {
1688 target = stream->EnsureSpace(target);
1689 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_to_binary_id(), target);
1690 }
1691
1692 // uint64 from_vaddr_in_file = 3;
1693 if (this->_internal_from_vaddr_in_file() != 0) {
1694 target = stream->EnsureSpace(target);
1695 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_from_vaddr_in_file(), target);
1696 }
1697
1698 // uint64 to_vaddr_in_file = 4;
1699 if (this->_internal_to_vaddr_in_file() != 0) {
1700 target = stream->EnsureSpace(target);
1701 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_to_vaddr_in_file(), target);
1702 }
1703
1704 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1705 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1706 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1707 }
1708 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.LBRData.Sample.Branch)
1709 return target;
1710 }
1711
ByteSizeLong() const1712 size_t LBRData_Sample_Branch::ByteSizeLong() const {
1713 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.LBRData.Sample.Branch)
1714 size_t total_size = 0;
1715
1716 ::uint32_t cached_has_bits = 0;
1717 // Prevent compiler warnings about cached_has_bits being unused
1718 (void) cached_has_bits;
1719
1720 // uint32 from_binary_id = 1;
1721 if (this->_internal_from_binary_id() != 0) {
1722 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_from_binary_id());
1723 }
1724
1725 // uint32 to_binary_id = 2;
1726 if (this->_internal_to_binary_id() != 0) {
1727 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_to_binary_id());
1728 }
1729
1730 // uint64 from_vaddr_in_file = 3;
1731 if (this->_internal_from_vaddr_in_file() != 0) {
1732 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_from_vaddr_in_file());
1733 }
1734
1735 // uint64 to_vaddr_in_file = 4;
1736 if (this->_internal_to_vaddr_in_file() != 0) {
1737 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_to_vaddr_in_file());
1738 }
1739
1740 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1741 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1742 }
1743 int cached_size = ::_pbi::ToCachedSize(total_size);
1744 SetCachedSize(cached_size);
1745 return total_size;
1746 }
1747
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1748 void LBRData_Sample_Branch::CheckTypeAndMergeFrom(
1749 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1750 MergeFrom(*::_pbi::DownCast<const LBRData_Sample_Branch*>(
1751 &from));
1752 }
1753
MergeFrom(const LBRData_Sample_Branch & from)1754 void LBRData_Sample_Branch::MergeFrom(const LBRData_Sample_Branch& from) {
1755 LBRData_Sample_Branch* const _this = this;
1756 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.LBRData.Sample.Branch)
1757 GOOGLE_DCHECK_NE(&from, _this);
1758 ::uint32_t cached_has_bits = 0;
1759 (void) cached_has_bits;
1760
1761 if (from._internal_from_binary_id() != 0) {
1762 _this->_internal_set_from_binary_id(from._internal_from_binary_id());
1763 }
1764 if (from._internal_to_binary_id() != 0) {
1765 _this->_internal_set_to_binary_id(from._internal_to_binary_id());
1766 }
1767 if (from._internal_from_vaddr_in_file() != 0) {
1768 _this->_internal_set_from_vaddr_in_file(from._internal_from_vaddr_in_file());
1769 }
1770 if (from._internal_to_vaddr_in_file() != 0) {
1771 _this->_internal_set_to_vaddr_in_file(from._internal_to_vaddr_in_file());
1772 }
1773 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1774 }
1775
CopyFrom(const LBRData_Sample_Branch & from)1776 void LBRData_Sample_Branch::CopyFrom(const LBRData_Sample_Branch& from) {
1777 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.LBRData.Sample.Branch)
1778 if (&from == this) return;
1779 Clear();
1780 MergeFrom(from);
1781 }
1782
IsInitialized() const1783 bool LBRData_Sample_Branch::IsInitialized() const {
1784 return true;
1785 }
1786
InternalSwap(LBRData_Sample_Branch * other)1787 void LBRData_Sample_Branch::InternalSwap(LBRData_Sample_Branch* other) {
1788 using std::swap;
1789 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1790 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1791 PROTOBUF_FIELD_OFFSET(LBRData_Sample_Branch, _impl_.to_vaddr_in_file_)
1792 + sizeof(LBRData_Sample_Branch::_impl_.to_vaddr_in_file_) // NOLINT
1793 - PROTOBUF_FIELD_OFFSET(LBRData_Sample_Branch, _impl_.from_binary_id_)>(
1794 reinterpret_cast<char*>(&_impl_.from_binary_id_),
1795 reinterpret_cast<char*>(&other->_impl_.from_binary_id_));
1796 }
1797
GetTypeName() const1798 std::string LBRData_Sample_Branch::GetTypeName() const {
1799 return "simpleperf.proto.LBRData.Sample.Branch";
1800 }
1801
1802
1803 // ===================================================================
1804
1805 class LBRData_Sample::_Internal {
1806 public:
1807 };
1808
LBRData_Sample(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1809 LBRData_Sample::LBRData_Sample(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1810 bool is_message_owned)
1811 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1812 SharedCtor(arena, is_message_owned);
1813 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.LBRData.Sample)
1814 }
LBRData_Sample(const LBRData_Sample & from)1815 LBRData_Sample::LBRData_Sample(const LBRData_Sample& from)
1816 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1817 LBRData_Sample* const _this = this; (void)_this;
1818 new (&_impl_) Impl_{
1819 decltype(_impl_.branches_){from._impl_.branches_}
1820 , decltype(_impl_.vaddr_in_file_){}
1821 , decltype(_impl_.binary_id_){}
1822 , /*decltype(_impl_._cached_size_)*/{}};
1823
1824 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1825 ::memcpy(&_impl_.vaddr_in_file_, &from._impl_.vaddr_in_file_,
1826 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.binary_id_) -
1827 reinterpret_cast<char*>(&_impl_.vaddr_in_file_)) + sizeof(_impl_.binary_id_));
1828 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.LBRData.Sample)
1829 }
1830
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1831 inline void LBRData_Sample::SharedCtor(
1832 ::_pb::Arena* arena, bool is_message_owned) {
1833 (void)arena;
1834 (void)is_message_owned;
1835 new (&_impl_) Impl_{
1836 decltype(_impl_.branches_){arena}
1837 , decltype(_impl_.vaddr_in_file_){::uint64_t{0u}}
1838 , decltype(_impl_.binary_id_){0u}
1839 , /*decltype(_impl_._cached_size_)*/{}
1840 };
1841 }
1842
~LBRData_Sample()1843 LBRData_Sample::~LBRData_Sample() {
1844 // @@protoc_insertion_point(destructor:simpleperf.proto.LBRData.Sample)
1845 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1846 (void)arena;
1847 return;
1848 }
1849 SharedDtor();
1850 }
1851
SharedDtor()1852 inline void LBRData_Sample::SharedDtor() {
1853 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1854 _impl_.branches_.~RepeatedPtrField();
1855 }
1856
SetCachedSize(int size) const1857 void LBRData_Sample::SetCachedSize(int size) const {
1858 _impl_._cached_size_.Set(size);
1859 }
1860
Clear()1861 void LBRData_Sample::Clear() {
1862 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.LBRData.Sample)
1863 ::uint32_t cached_has_bits = 0;
1864 // Prevent compiler warnings about cached_has_bits being unused
1865 (void) cached_has_bits;
1866
1867 _impl_.branches_.Clear();
1868 ::memset(&_impl_.vaddr_in_file_, 0, static_cast<size_t>(
1869 reinterpret_cast<char*>(&_impl_.binary_id_) -
1870 reinterpret_cast<char*>(&_impl_.vaddr_in_file_)) + sizeof(_impl_.binary_id_));
1871 _internal_metadata_.Clear<std::string>();
1872 }
1873
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1874 const char* LBRData_Sample::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1875 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1876 while (!ctx->Done(&ptr)) {
1877 ::uint32_t tag;
1878 ptr = ::_pbi::ReadTag(ptr, &tag);
1879 switch (tag >> 3) {
1880 // uint32 binary_id = 1;
1881 case 1:
1882 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1883 _impl_.binary_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1884 CHK_(ptr);
1885 } else {
1886 goto handle_unusual;
1887 }
1888 continue;
1889 // uint64 vaddr_in_file = 2;
1890 case 2:
1891 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1892 _impl_.vaddr_in_file_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1893 CHK_(ptr);
1894 } else {
1895 goto handle_unusual;
1896 }
1897 continue;
1898 // repeated .simpleperf.proto.LBRData.Sample.Branch branches = 3;
1899 case 3:
1900 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1901 ptr -= 1;
1902 do {
1903 ptr += 1;
1904 ptr = ctx->ParseMessage(_internal_add_branches(), ptr);
1905 CHK_(ptr);
1906 if (!ctx->DataAvailable(ptr)) break;
1907 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
1908 } else {
1909 goto handle_unusual;
1910 }
1911 continue;
1912 default:
1913 goto handle_unusual;
1914 } // switch
1915 handle_unusual:
1916 if ((tag == 0) || ((tag & 7) == 4)) {
1917 CHK_(ptr);
1918 ctx->SetLastTag(tag);
1919 goto message_done;
1920 }
1921 ptr = UnknownFieldParse(
1922 tag,
1923 _internal_metadata_.mutable_unknown_fields<std::string>(),
1924 ptr, ctx);
1925 CHK_(ptr != nullptr);
1926 } // while
1927 message_done:
1928 return ptr;
1929 failure:
1930 ptr = nullptr;
1931 goto message_done;
1932 #undef CHK_
1933 }
1934
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1935 ::uint8_t* LBRData_Sample::_InternalSerialize(
1936 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1937 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.LBRData.Sample)
1938 ::uint32_t cached_has_bits = 0;
1939 (void) cached_has_bits;
1940
1941 // uint32 binary_id = 1;
1942 if (this->_internal_binary_id() != 0) {
1943 target = stream->EnsureSpace(target);
1944 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_binary_id(), target);
1945 }
1946
1947 // uint64 vaddr_in_file = 2;
1948 if (this->_internal_vaddr_in_file() != 0) {
1949 target = stream->EnsureSpace(target);
1950 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_vaddr_in_file(), target);
1951 }
1952
1953 // repeated .simpleperf.proto.LBRData.Sample.Branch branches = 3;
1954 for (unsigned i = 0,
1955 n = static_cast<unsigned>(this->_internal_branches_size()); i < n; i++) {
1956 const auto& repfield = this->_internal_branches(i);
1957 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1958 InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
1959 }
1960
1961 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1962 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1963 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1964 }
1965 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.LBRData.Sample)
1966 return target;
1967 }
1968
ByteSizeLong() const1969 size_t LBRData_Sample::ByteSizeLong() const {
1970 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.LBRData.Sample)
1971 size_t total_size = 0;
1972
1973 ::uint32_t cached_has_bits = 0;
1974 // Prevent compiler warnings about cached_has_bits being unused
1975 (void) cached_has_bits;
1976
1977 // repeated .simpleperf.proto.LBRData.Sample.Branch branches = 3;
1978 total_size += 1UL * this->_internal_branches_size();
1979 for (const auto& msg : this->_impl_.branches_) {
1980 total_size +=
1981 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1982 }
1983
1984 // uint64 vaddr_in_file = 2;
1985 if (this->_internal_vaddr_in_file() != 0) {
1986 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_vaddr_in_file());
1987 }
1988
1989 // uint32 binary_id = 1;
1990 if (this->_internal_binary_id() != 0) {
1991 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_binary_id());
1992 }
1993
1994 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1995 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1996 }
1997 int cached_size = ::_pbi::ToCachedSize(total_size);
1998 SetCachedSize(cached_size);
1999 return total_size;
2000 }
2001
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2002 void LBRData_Sample::CheckTypeAndMergeFrom(
2003 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2004 MergeFrom(*::_pbi::DownCast<const LBRData_Sample*>(
2005 &from));
2006 }
2007
MergeFrom(const LBRData_Sample & from)2008 void LBRData_Sample::MergeFrom(const LBRData_Sample& from) {
2009 LBRData_Sample* const _this = this;
2010 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.LBRData.Sample)
2011 GOOGLE_DCHECK_NE(&from, _this);
2012 ::uint32_t cached_has_bits = 0;
2013 (void) cached_has_bits;
2014
2015 _this->_impl_.branches_.MergeFrom(from._impl_.branches_);
2016 if (from._internal_vaddr_in_file() != 0) {
2017 _this->_internal_set_vaddr_in_file(from._internal_vaddr_in_file());
2018 }
2019 if (from._internal_binary_id() != 0) {
2020 _this->_internal_set_binary_id(from._internal_binary_id());
2021 }
2022 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2023 }
2024
CopyFrom(const LBRData_Sample & from)2025 void LBRData_Sample::CopyFrom(const LBRData_Sample& from) {
2026 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.LBRData.Sample)
2027 if (&from == this) return;
2028 Clear();
2029 MergeFrom(from);
2030 }
2031
IsInitialized() const2032 bool LBRData_Sample::IsInitialized() const {
2033 return true;
2034 }
2035
InternalSwap(LBRData_Sample * other)2036 void LBRData_Sample::InternalSwap(LBRData_Sample* other) {
2037 using std::swap;
2038 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2039 _impl_.branches_.InternalSwap(&other->_impl_.branches_);
2040 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2041 PROTOBUF_FIELD_OFFSET(LBRData_Sample, _impl_.binary_id_)
2042 + sizeof(LBRData_Sample::_impl_.binary_id_) // NOLINT
2043 - PROTOBUF_FIELD_OFFSET(LBRData_Sample, _impl_.vaddr_in_file_)>(
2044 reinterpret_cast<char*>(&_impl_.vaddr_in_file_),
2045 reinterpret_cast<char*>(&other->_impl_.vaddr_in_file_));
2046 }
2047
GetTypeName() const2048 std::string LBRData_Sample::GetTypeName() const {
2049 return "simpleperf.proto.LBRData.Sample";
2050 }
2051
2052
2053 // ===================================================================
2054
2055 class LBRData_Binary::_Internal {
2056 public:
2057 };
2058
LBRData_Binary(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2059 LBRData_Binary::LBRData_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2060 bool is_message_owned)
2061 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2062 SharedCtor(arena, is_message_owned);
2063 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.LBRData.Binary)
2064 }
LBRData_Binary(const LBRData_Binary & from)2065 LBRData_Binary::LBRData_Binary(const LBRData_Binary& from)
2066 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2067 LBRData_Binary* const _this = this; (void)_this;
2068 new (&_impl_) Impl_{
2069 decltype(_impl_.path_){}
2070 , decltype(_impl_.build_id_){}
2071 , /*decltype(_impl_._cached_size_)*/{}};
2072
2073 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2074 _impl_.path_.InitDefault();
2075 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2076 _impl_.path_.Set("", GetArenaForAllocation());
2077 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2078 if (!from._internal_path().empty()) {
2079 _this->_impl_.path_.Set(from._internal_path(),
2080 _this->GetArenaForAllocation());
2081 }
2082 _impl_.build_id_.InitDefault();
2083 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2084 _impl_.build_id_.Set("", GetArenaForAllocation());
2085 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2086 if (!from._internal_build_id().empty()) {
2087 _this->_impl_.build_id_.Set(from._internal_build_id(),
2088 _this->GetArenaForAllocation());
2089 }
2090 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.LBRData.Binary)
2091 }
2092
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2093 inline void LBRData_Binary::SharedCtor(
2094 ::_pb::Arena* arena, bool is_message_owned) {
2095 (void)arena;
2096 (void)is_message_owned;
2097 new (&_impl_) Impl_{
2098 decltype(_impl_.path_){}
2099 , decltype(_impl_.build_id_){}
2100 , /*decltype(_impl_._cached_size_)*/{}
2101 };
2102 _impl_.path_.InitDefault();
2103 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2104 _impl_.path_.Set("", GetArenaForAllocation());
2105 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2106 _impl_.build_id_.InitDefault();
2107 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2108 _impl_.build_id_.Set("", GetArenaForAllocation());
2109 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2110 }
2111
~LBRData_Binary()2112 LBRData_Binary::~LBRData_Binary() {
2113 // @@protoc_insertion_point(destructor:simpleperf.proto.LBRData.Binary)
2114 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2115 (void)arena;
2116 return;
2117 }
2118 SharedDtor();
2119 }
2120
SharedDtor()2121 inline void LBRData_Binary::SharedDtor() {
2122 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2123 _impl_.path_.Destroy();
2124 _impl_.build_id_.Destroy();
2125 }
2126
SetCachedSize(int size) const2127 void LBRData_Binary::SetCachedSize(int size) const {
2128 _impl_._cached_size_.Set(size);
2129 }
2130
Clear()2131 void LBRData_Binary::Clear() {
2132 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.LBRData.Binary)
2133 ::uint32_t cached_has_bits = 0;
2134 // Prevent compiler warnings about cached_has_bits being unused
2135 (void) cached_has_bits;
2136
2137 _impl_.path_.ClearToEmpty();
2138 _impl_.build_id_.ClearToEmpty();
2139 _internal_metadata_.Clear<std::string>();
2140 }
2141
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2142 const char* LBRData_Binary::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2143 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2144 while (!ctx->Done(&ptr)) {
2145 ::uint32_t tag;
2146 ptr = ::_pbi::ReadTag(ptr, &tag);
2147 switch (tag >> 3) {
2148 // string path = 1;
2149 case 1:
2150 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2151 auto str = _internal_mutable_path();
2152 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2153 CHK_(ptr);
2154 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2155 } else {
2156 goto handle_unusual;
2157 }
2158 continue;
2159 // string build_id = 2;
2160 case 2:
2161 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2162 auto str = _internal_mutable_build_id();
2163 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2164 CHK_(ptr);
2165 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2166 } else {
2167 goto handle_unusual;
2168 }
2169 continue;
2170 default:
2171 goto handle_unusual;
2172 } // switch
2173 handle_unusual:
2174 if ((tag == 0) || ((tag & 7) == 4)) {
2175 CHK_(ptr);
2176 ctx->SetLastTag(tag);
2177 goto message_done;
2178 }
2179 ptr = UnknownFieldParse(
2180 tag,
2181 _internal_metadata_.mutable_unknown_fields<std::string>(),
2182 ptr, ctx);
2183 CHK_(ptr != nullptr);
2184 } // while
2185 message_done:
2186 return ptr;
2187 failure:
2188 ptr = nullptr;
2189 goto message_done;
2190 #undef CHK_
2191 }
2192
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2193 ::uint8_t* LBRData_Binary::_InternalSerialize(
2194 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2195 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.LBRData.Binary)
2196 ::uint32_t cached_has_bits = 0;
2197 (void) cached_has_bits;
2198
2199 // string path = 1;
2200 if (!this->_internal_path().empty()) {
2201 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2202 this->_internal_path().data(), static_cast<int>(this->_internal_path().length()),
2203 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2204 "simpleperf.proto.LBRData.Binary.path");
2205 target = stream->WriteStringMaybeAliased(
2206 1, this->_internal_path(), target);
2207 }
2208
2209 // string build_id = 2;
2210 if (!this->_internal_build_id().empty()) {
2211 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2212 this->_internal_build_id().data(), static_cast<int>(this->_internal_build_id().length()),
2213 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2214 "simpleperf.proto.LBRData.Binary.build_id");
2215 target = stream->WriteStringMaybeAliased(
2216 2, this->_internal_build_id(), target);
2217 }
2218
2219 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2220 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2221 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2222 }
2223 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.LBRData.Binary)
2224 return target;
2225 }
2226
ByteSizeLong() const2227 size_t LBRData_Binary::ByteSizeLong() const {
2228 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.LBRData.Binary)
2229 size_t total_size = 0;
2230
2231 ::uint32_t cached_has_bits = 0;
2232 // Prevent compiler warnings about cached_has_bits being unused
2233 (void) cached_has_bits;
2234
2235 // string path = 1;
2236 if (!this->_internal_path().empty()) {
2237 total_size += 1 +
2238 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2239 this->_internal_path());
2240 }
2241
2242 // string build_id = 2;
2243 if (!this->_internal_build_id().empty()) {
2244 total_size += 1 +
2245 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2246 this->_internal_build_id());
2247 }
2248
2249 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2250 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2251 }
2252 int cached_size = ::_pbi::ToCachedSize(total_size);
2253 SetCachedSize(cached_size);
2254 return total_size;
2255 }
2256
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2257 void LBRData_Binary::CheckTypeAndMergeFrom(
2258 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2259 MergeFrom(*::_pbi::DownCast<const LBRData_Binary*>(
2260 &from));
2261 }
2262
MergeFrom(const LBRData_Binary & from)2263 void LBRData_Binary::MergeFrom(const LBRData_Binary& from) {
2264 LBRData_Binary* const _this = this;
2265 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.LBRData.Binary)
2266 GOOGLE_DCHECK_NE(&from, _this);
2267 ::uint32_t cached_has_bits = 0;
2268 (void) cached_has_bits;
2269
2270 if (!from._internal_path().empty()) {
2271 _this->_internal_set_path(from._internal_path());
2272 }
2273 if (!from._internal_build_id().empty()) {
2274 _this->_internal_set_build_id(from._internal_build_id());
2275 }
2276 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2277 }
2278
CopyFrom(const LBRData_Binary & from)2279 void LBRData_Binary::CopyFrom(const LBRData_Binary& from) {
2280 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.LBRData.Binary)
2281 if (&from == this) return;
2282 Clear();
2283 MergeFrom(from);
2284 }
2285
IsInitialized() const2286 bool LBRData_Binary::IsInitialized() const {
2287 return true;
2288 }
2289
InternalSwap(LBRData_Binary * other)2290 void LBRData_Binary::InternalSwap(LBRData_Binary* other) {
2291 using std::swap;
2292 auto* lhs_arena = GetArenaForAllocation();
2293 auto* rhs_arena = other->GetArenaForAllocation();
2294 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2295 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2296 &_impl_.path_, lhs_arena,
2297 &other->_impl_.path_, rhs_arena
2298 );
2299 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2300 &_impl_.build_id_, lhs_arena,
2301 &other->_impl_.build_id_, rhs_arena
2302 );
2303 }
2304
GetTypeName() const2305 std::string LBRData_Binary::GetTypeName() const {
2306 return "simpleperf.proto.LBRData.Binary";
2307 }
2308
2309
2310 // ===================================================================
2311
2312 class LBRData::_Internal {
2313 public:
2314 };
2315
LBRData(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2316 LBRData::LBRData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2317 bool is_message_owned)
2318 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2319 SharedCtor(arena, is_message_owned);
2320 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.LBRData)
2321 }
LBRData(const LBRData & from)2322 LBRData::LBRData(const LBRData& from)
2323 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2324 LBRData* const _this = this; (void)_this;
2325 new (&_impl_) Impl_{
2326 decltype(_impl_.samples_){from._impl_.samples_}
2327 , decltype(_impl_.binaries_){from._impl_.binaries_}
2328 , /*decltype(_impl_._cached_size_)*/{}};
2329
2330 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2331 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.LBRData)
2332 }
2333
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2334 inline void LBRData::SharedCtor(
2335 ::_pb::Arena* arena, bool is_message_owned) {
2336 (void)arena;
2337 (void)is_message_owned;
2338 new (&_impl_) Impl_{
2339 decltype(_impl_.samples_){arena}
2340 , decltype(_impl_.binaries_){arena}
2341 , /*decltype(_impl_._cached_size_)*/{}
2342 };
2343 }
2344
~LBRData()2345 LBRData::~LBRData() {
2346 // @@protoc_insertion_point(destructor:simpleperf.proto.LBRData)
2347 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2348 (void)arena;
2349 return;
2350 }
2351 SharedDtor();
2352 }
2353
SharedDtor()2354 inline void LBRData::SharedDtor() {
2355 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2356 _impl_.samples_.~RepeatedPtrField();
2357 _impl_.binaries_.~RepeatedPtrField();
2358 }
2359
SetCachedSize(int size) const2360 void LBRData::SetCachedSize(int size) const {
2361 _impl_._cached_size_.Set(size);
2362 }
2363
Clear()2364 void LBRData::Clear() {
2365 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.LBRData)
2366 ::uint32_t cached_has_bits = 0;
2367 // Prevent compiler warnings about cached_has_bits being unused
2368 (void) cached_has_bits;
2369
2370 _impl_.samples_.Clear();
2371 _impl_.binaries_.Clear();
2372 _internal_metadata_.Clear<std::string>();
2373 }
2374
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2375 const char* LBRData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2376 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2377 while (!ctx->Done(&ptr)) {
2378 ::uint32_t tag;
2379 ptr = ::_pbi::ReadTag(ptr, &tag);
2380 switch (tag >> 3) {
2381 // repeated .simpleperf.proto.LBRData.Sample samples = 1;
2382 case 1:
2383 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2384 ptr -= 1;
2385 do {
2386 ptr += 1;
2387 ptr = ctx->ParseMessage(_internal_add_samples(), ptr);
2388 CHK_(ptr);
2389 if (!ctx->DataAvailable(ptr)) break;
2390 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
2391 } else {
2392 goto handle_unusual;
2393 }
2394 continue;
2395 // repeated .simpleperf.proto.LBRData.Binary binaries = 2;
2396 case 2:
2397 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2398 ptr -= 1;
2399 do {
2400 ptr += 1;
2401 ptr = ctx->ParseMessage(_internal_add_binaries(), ptr);
2402 CHK_(ptr);
2403 if (!ctx->DataAvailable(ptr)) break;
2404 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
2405 } else {
2406 goto handle_unusual;
2407 }
2408 continue;
2409 default:
2410 goto handle_unusual;
2411 } // switch
2412 handle_unusual:
2413 if ((tag == 0) || ((tag & 7) == 4)) {
2414 CHK_(ptr);
2415 ctx->SetLastTag(tag);
2416 goto message_done;
2417 }
2418 ptr = UnknownFieldParse(
2419 tag,
2420 _internal_metadata_.mutable_unknown_fields<std::string>(),
2421 ptr, ctx);
2422 CHK_(ptr != nullptr);
2423 } // while
2424 message_done:
2425 return ptr;
2426 failure:
2427 ptr = nullptr;
2428 goto message_done;
2429 #undef CHK_
2430 }
2431
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2432 ::uint8_t* LBRData::_InternalSerialize(
2433 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2434 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.LBRData)
2435 ::uint32_t cached_has_bits = 0;
2436 (void) cached_has_bits;
2437
2438 // repeated .simpleperf.proto.LBRData.Sample samples = 1;
2439 for (unsigned i = 0,
2440 n = static_cast<unsigned>(this->_internal_samples_size()); i < n; i++) {
2441 const auto& repfield = this->_internal_samples(i);
2442 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2443 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
2444 }
2445
2446 // repeated .simpleperf.proto.LBRData.Binary binaries = 2;
2447 for (unsigned i = 0,
2448 n = static_cast<unsigned>(this->_internal_binaries_size()); i < n; i++) {
2449 const auto& repfield = this->_internal_binaries(i);
2450 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2451 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
2452 }
2453
2454 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2455 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2456 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2457 }
2458 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.LBRData)
2459 return target;
2460 }
2461
ByteSizeLong() const2462 size_t LBRData::ByteSizeLong() const {
2463 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.LBRData)
2464 size_t total_size = 0;
2465
2466 ::uint32_t cached_has_bits = 0;
2467 // Prevent compiler warnings about cached_has_bits being unused
2468 (void) cached_has_bits;
2469
2470 // repeated .simpleperf.proto.LBRData.Sample samples = 1;
2471 total_size += 1UL * this->_internal_samples_size();
2472 for (const auto& msg : this->_impl_.samples_) {
2473 total_size +=
2474 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2475 }
2476
2477 // repeated .simpleperf.proto.LBRData.Binary binaries = 2;
2478 total_size += 1UL * this->_internal_binaries_size();
2479 for (const auto& msg : this->_impl_.binaries_) {
2480 total_size +=
2481 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2482 }
2483
2484 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2485 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2486 }
2487 int cached_size = ::_pbi::ToCachedSize(total_size);
2488 SetCachedSize(cached_size);
2489 return total_size;
2490 }
2491
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2492 void LBRData::CheckTypeAndMergeFrom(
2493 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2494 MergeFrom(*::_pbi::DownCast<const LBRData*>(
2495 &from));
2496 }
2497
MergeFrom(const LBRData & from)2498 void LBRData::MergeFrom(const LBRData& from) {
2499 LBRData* const _this = this;
2500 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.LBRData)
2501 GOOGLE_DCHECK_NE(&from, _this);
2502 ::uint32_t cached_has_bits = 0;
2503 (void) cached_has_bits;
2504
2505 _this->_impl_.samples_.MergeFrom(from._impl_.samples_);
2506 _this->_impl_.binaries_.MergeFrom(from._impl_.binaries_);
2507 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2508 }
2509
CopyFrom(const LBRData & from)2510 void LBRData::CopyFrom(const LBRData& from) {
2511 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.LBRData)
2512 if (&from == this) return;
2513 Clear();
2514 MergeFrom(from);
2515 }
2516
IsInitialized() const2517 bool LBRData::IsInitialized() const {
2518 return true;
2519 }
2520
InternalSwap(LBRData * other)2521 void LBRData::InternalSwap(LBRData* other) {
2522 using std::swap;
2523 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2524 _impl_.samples_.InternalSwap(&other->_impl_.samples_);
2525 _impl_.binaries_.InternalSwap(&other->_impl_.binaries_);
2526 }
2527
GetTypeName() const2528 std::string LBRData::GetTypeName() const {
2529 return "simpleperf.proto.LBRData";
2530 }
2531
2532
2533 // @@protoc_insertion_point(namespace_scope)
2534 } // namespace proto
2535 } // namespace simpleperf
2536 PROTOBUF_NAMESPACE_OPEN
2537 template<> PROTOBUF_NOINLINE ::simpleperf::proto::BranchList*
CreateMaybeMessage(Arena * arena)2538 Arena::CreateMaybeMessage< ::simpleperf::proto::BranchList >(Arena* arena) {
2539 return Arena::CreateMessageInternal< ::simpleperf::proto::BranchList >(arena);
2540 }
2541 template<> PROTOBUF_NOINLINE ::simpleperf::proto::ETMBinary_Address_Branch*
CreateMaybeMessage(Arena * arena)2542 Arena::CreateMaybeMessage< ::simpleperf::proto::ETMBinary_Address_Branch >(Arena* arena) {
2543 return Arena::CreateMessageInternal< ::simpleperf::proto::ETMBinary_Address_Branch >(arena);
2544 }
2545 template<> PROTOBUF_NOINLINE ::simpleperf::proto::ETMBinary_Address*
CreateMaybeMessage(Arena * arena)2546 Arena::CreateMaybeMessage< ::simpleperf::proto::ETMBinary_Address >(Arena* arena) {
2547 return Arena::CreateMessageInternal< ::simpleperf::proto::ETMBinary_Address >(arena);
2548 }
2549 template<> PROTOBUF_NOINLINE ::simpleperf::proto::ETMBinary_KernelBinaryInfo*
CreateMaybeMessage(Arena * arena)2550 Arena::CreateMaybeMessage< ::simpleperf::proto::ETMBinary_KernelBinaryInfo >(Arena* arena) {
2551 return Arena::CreateMessageInternal< ::simpleperf::proto::ETMBinary_KernelBinaryInfo >(arena);
2552 }
2553 template<> PROTOBUF_NOINLINE ::simpleperf::proto::ETMBinary*
CreateMaybeMessage(Arena * arena)2554 Arena::CreateMaybeMessage< ::simpleperf::proto::ETMBinary >(Arena* arena) {
2555 return Arena::CreateMessageInternal< ::simpleperf::proto::ETMBinary >(arena);
2556 }
2557 template<> PROTOBUF_NOINLINE ::simpleperf::proto::LBRData_Sample_Branch*
CreateMaybeMessage(Arena * arena)2558 Arena::CreateMaybeMessage< ::simpleperf::proto::LBRData_Sample_Branch >(Arena* arena) {
2559 return Arena::CreateMessageInternal< ::simpleperf::proto::LBRData_Sample_Branch >(arena);
2560 }
2561 template<> PROTOBUF_NOINLINE ::simpleperf::proto::LBRData_Sample*
CreateMaybeMessage(Arena * arena)2562 Arena::CreateMaybeMessage< ::simpleperf::proto::LBRData_Sample >(Arena* arena) {
2563 return Arena::CreateMessageInternal< ::simpleperf::proto::LBRData_Sample >(arena);
2564 }
2565 template<> PROTOBUF_NOINLINE ::simpleperf::proto::LBRData_Binary*
CreateMaybeMessage(Arena * arena)2566 Arena::CreateMaybeMessage< ::simpleperf::proto::LBRData_Binary >(Arena* arena) {
2567 return Arena::CreateMessageInternal< ::simpleperf::proto::LBRData_Binary >(arena);
2568 }
2569 template<> PROTOBUF_NOINLINE ::simpleperf::proto::LBRData*
CreateMaybeMessage(Arena * arena)2570 Arena::CreateMaybeMessage< ::simpleperf::proto::LBRData >(Arena* arena) {
2571 return Arena::CreateMessageInternal< ::simpleperf::proto::LBRData >(arena);
2572 }
2573 PROTOBUF_NAMESPACE_CLOSE
2574
2575 // @@protoc_insertion_point(global_scope)
2576 #include <google/protobuf/port_undef.inc>
2577