1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: system/extras/simpleperf/record_file.proto
3
4 #include "system/extras/simpleperf/record_file.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 {
DebugUnwindFeature_File(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR DebugUnwindFeature_File::DebugUnwindFeature_File(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_.path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
26 , /*decltype(_impl_.size_)*/::uint64_t{0u}
27 , /*decltype(_impl_._cached_size_)*/{}} {}
28 struct DebugUnwindFeature_FileDefaultTypeInternal {
DebugUnwindFeature_FileDefaultTypeInternalsimpleperf::proto::DebugUnwindFeature_FileDefaultTypeInternal29 PROTOBUF_CONSTEXPR DebugUnwindFeature_FileDefaultTypeInternal()
30 : _instance(::_pbi::ConstantInitialized{}) {}
~DebugUnwindFeature_FileDefaultTypeInternalsimpleperf::proto::DebugUnwindFeature_FileDefaultTypeInternal31 ~DebugUnwindFeature_FileDefaultTypeInternal() {}
32 union { // NOLINT(misc-non-private-member-variables-in-classes)
33 DebugUnwindFeature_File _instance;
34 };
35 };
36 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DebugUnwindFeature_FileDefaultTypeInternal _DebugUnwindFeature_File_default_instance_;
DebugUnwindFeature(::_pbi::ConstantInitialized)37 PROTOBUF_CONSTEXPR DebugUnwindFeature::DebugUnwindFeature(
38 ::_pbi::ConstantInitialized): _impl_{
39 /*decltype(_impl_.file_)*/{}
40 , /*decltype(_impl_._cached_size_)*/{}} {}
41 struct DebugUnwindFeatureDefaultTypeInternal {
DebugUnwindFeatureDefaultTypeInternalsimpleperf::proto::DebugUnwindFeatureDefaultTypeInternal42 PROTOBUF_CONSTEXPR DebugUnwindFeatureDefaultTypeInternal()
43 : _instance(::_pbi::ConstantInitialized{}) {}
~DebugUnwindFeatureDefaultTypeInternalsimpleperf::proto::DebugUnwindFeatureDefaultTypeInternal44 ~DebugUnwindFeatureDefaultTypeInternal() {}
45 union { // NOLINT(misc-non-private-member-variables-in-classes)
46 DebugUnwindFeature _instance;
47 };
48 };
49 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DebugUnwindFeatureDefaultTypeInternal _DebugUnwindFeature_default_instance_;
FileFeature_Symbol(::_pbi::ConstantInitialized)50 PROTOBUF_CONSTEXPR FileFeature_Symbol::FileFeature_Symbol(
51 ::_pbi::ConstantInitialized): _impl_{
52 /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
53 , /*decltype(_impl_.vaddr_)*/::uint64_t{0u}
54 , /*decltype(_impl_.len_)*/0u
55 , /*decltype(_impl_._cached_size_)*/{}} {}
56 struct FileFeature_SymbolDefaultTypeInternal {
FileFeature_SymbolDefaultTypeInternalsimpleperf::proto::FileFeature_SymbolDefaultTypeInternal57 PROTOBUF_CONSTEXPR FileFeature_SymbolDefaultTypeInternal()
58 : _instance(::_pbi::ConstantInitialized{}) {}
~FileFeature_SymbolDefaultTypeInternalsimpleperf::proto::FileFeature_SymbolDefaultTypeInternal59 ~FileFeature_SymbolDefaultTypeInternal() {}
60 union { // NOLINT(misc-non-private-member-variables-in-classes)
61 FileFeature_Symbol _instance;
62 };
63 };
64 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FileFeature_SymbolDefaultTypeInternal _FileFeature_Symbol_default_instance_;
FileFeature_DexFile(::_pbi::ConstantInitialized)65 PROTOBUF_CONSTEXPR FileFeature_DexFile::FileFeature_DexFile(
66 ::_pbi::ConstantInitialized): _impl_{
67 /*decltype(_impl_.dex_file_offset_)*/{}
68 , /*decltype(_impl_._dex_file_offset_cached_byte_size_)*/{0}
69 , /*decltype(_impl_._cached_size_)*/{}} {}
70 struct FileFeature_DexFileDefaultTypeInternal {
FileFeature_DexFileDefaultTypeInternalsimpleperf::proto::FileFeature_DexFileDefaultTypeInternal71 PROTOBUF_CONSTEXPR FileFeature_DexFileDefaultTypeInternal()
72 : _instance(::_pbi::ConstantInitialized{}) {}
~FileFeature_DexFileDefaultTypeInternalsimpleperf::proto::FileFeature_DexFileDefaultTypeInternal73 ~FileFeature_DexFileDefaultTypeInternal() {}
74 union { // NOLINT(misc-non-private-member-variables-in-classes)
75 FileFeature_DexFile _instance;
76 };
77 };
78 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FileFeature_DexFileDefaultTypeInternal _FileFeature_DexFile_default_instance_;
FileFeature_ElfFile(::_pbi::ConstantInitialized)79 PROTOBUF_CONSTEXPR FileFeature_ElfFile::FileFeature_ElfFile(
80 ::_pbi::ConstantInitialized): _impl_{
81 /*decltype(_impl_.file_offset_of_min_vaddr_)*/::uint64_t{0u}
82 , /*decltype(_impl_._cached_size_)*/{}} {}
83 struct FileFeature_ElfFileDefaultTypeInternal {
FileFeature_ElfFileDefaultTypeInternalsimpleperf::proto::FileFeature_ElfFileDefaultTypeInternal84 PROTOBUF_CONSTEXPR FileFeature_ElfFileDefaultTypeInternal()
85 : _instance(::_pbi::ConstantInitialized{}) {}
~FileFeature_ElfFileDefaultTypeInternalsimpleperf::proto::FileFeature_ElfFileDefaultTypeInternal86 ~FileFeature_ElfFileDefaultTypeInternal() {}
87 union { // NOLINT(misc-non-private-member-variables-in-classes)
88 FileFeature_ElfFile _instance;
89 };
90 };
91 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FileFeature_ElfFileDefaultTypeInternal _FileFeature_ElfFile_default_instance_;
FileFeature_KernelModule(::_pbi::ConstantInitialized)92 PROTOBUF_CONSTEXPR FileFeature_KernelModule::FileFeature_KernelModule(
93 ::_pbi::ConstantInitialized): _impl_{
94 /*decltype(_impl_.memory_offset_of_min_vaddr_)*/::uint64_t{0u}
95 , /*decltype(_impl_._cached_size_)*/{}} {}
96 struct FileFeature_KernelModuleDefaultTypeInternal {
FileFeature_KernelModuleDefaultTypeInternalsimpleperf::proto::FileFeature_KernelModuleDefaultTypeInternal97 PROTOBUF_CONSTEXPR FileFeature_KernelModuleDefaultTypeInternal()
98 : _instance(::_pbi::ConstantInitialized{}) {}
~FileFeature_KernelModuleDefaultTypeInternalsimpleperf::proto::FileFeature_KernelModuleDefaultTypeInternal99 ~FileFeature_KernelModuleDefaultTypeInternal() {}
100 union { // NOLINT(misc-non-private-member-variables-in-classes)
101 FileFeature_KernelModule _instance;
102 };
103 };
104 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FileFeature_KernelModuleDefaultTypeInternal _FileFeature_KernelModule_default_instance_;
FileFeature(::_pbi::ConstantInitialized)105 PROTOBUF_CONSTEXPR FileFeature::FileFeature(
106 ::_pbi::ConstantInitialized): _impl_{
107 /*decltype(_impl_.symbol_)*/{}
108 , /*decltype(_impl_.path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
109 , /*decltype(_impl_.min_vaddr_)*/::uint64_t{0u}
110 , /*decltype(_impl_.type_)*/0u
111 , /*decltype(_impl_.type_specific_msg_)*/{}
112 , /*decltype(_impl_._cached_size_)*/{}
113 , /*decltype(_impl_._oneof_case_)*/{}} {}
114 struct FileFeatureDefaultTypeInternal {
FileFeatureDefaultTypeInternalsimpleperf::proto::FileFeatureDefaultTypeInternal115 PROTOBUF_CONSTEXPR FileFeatureDefaultTypeInternal()
116 : _instance(::_pbi::ConstantInitialized{}) {}
~FileFeatureDefaultTypeInternalsimpleperf::proto::FileFeatureDefaultTypeInternal117 ~FileFeatureDefaultTypeInternal() {}
118 union { // NOLINT(misc-non-private-member-variables-in-classes)
119 FileFeature _instance;
120 };
121 };
122 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FileFeatureDefaultTypeInternal _FileFeature_default_instance_;
123 } // namespace proto
124 } // namespace simpleperf
125 namespace simpleperf {
126 namespace proto {
127
128 // ===================================================================
129
130 class DebugUnwindFeature_File::_Internal {
131 public:
132 };
133
DebugUnwindFeature_File(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)134 DebugUnwindFeature_File::DebugUnwindFeature_File(::PROTOBUF_NAMESPACE_ID::Arena* arena,
135 bool is_message_owned)
136 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
137 SharedCtor(arena, is_message_owned);
138 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.DebugUnwindFeature.File)
139 }
DebugUnwindFeature_File(const DebugUnwindFeature_File & from)140 DebugUnwindFeature_File::DebugUnwindFeature_File(const DebugUnwindFeature_File& from)
141 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
142 DebugUnwindFeature_File* const _this = this; (void)_this;
143 new (&_impl_) Impl_{
144 decltype(_impl_.path_){}
145 , decltype(_impl_.size_){}
146 , /*decltype(_impl_._cached_size_)*/{}};
147
148 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
149 _impl_.path_.InitDefault();
150 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
151 _impl_.path_.Set("", GetArenaForAllocation());
152 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
153 if (!from._internal_path().empty()) {
154 _this->_impl_.path_.Set(from._internal_path(),
155 _this->GetArenaForAllocation());
156 }
157 _this->_impl_.size_ = from._impl_.size_;
158 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.DebugUnwindFeature.File)
159 }
160
SharedCtor(::_pb::Arena * arena,bool is_message_owned)161 inline void DebugUnwindFeature_File::SharedCtor(
162 ::_pb::Arena* arena, bool is_message_owned) {
163 (void)arena;
164 (void)is_message_owned;
165 new (&_impl_) Impl_{
166 decltype(_impl_.path_){}
167 , decltype(_impl_.size_){::uint64_t{0u}}
168 , /*decltype(_impl_._cached_size_)*/{}
169 };
170 _impl_.path_.InitDefault();
171 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
172 _impl_.path_.Set("", GetArenaForAllocation());
173 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
174 }
175
~DebugUnwindFeature_File()176 DebugUnwindFeature_File::~DebugUnwindFeature_File() {
177 // @@protoc_insertion_point(destructor:simpleperf.proto.DebugUnwindFeature.File)
178 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
179 (void)arena;
180 return;
181 }
182 SharedDtor();
183 }
184
SharedDtor()185 inline void DebugUnwindFeature_File::SharedDtor() {
186 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
187 _impl_.path_.Destroy();
188 }
189
SetCachedSize(int size) const190 void DebugUnwindFeature_File::SetCachedSize(int size) const {
191 _impl_._cached_size_.Set(size);
192 }
193
Clear()194 void DebugUnwindFeature_File::Clear() {
195 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.DebugUnwindFeature.File)
196 ::uint32_t cached_has_bits = 0;
197 // Prevent compiler warnings about cached_has_bits being unused
198 (void) cached_has_bits;
199
200 _impl_.path_.ClearToEmpty();
201 _impl_.size_ = ::uint64_t{0u};
202 _internal_metadata_.Clear<std::string>();
203 }
204
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)205 const char* DebugUnwindFeature_File::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
206 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
207 while (!ctx->Done(&ptr)) {
208 ::uint32_t tag;
209 ptr = ::_pbi::ReadTag(ptr, &tag);
210 switch (tag >> 3) {
211 // string path = 1;
212 case 1:
213 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
214 auto str = _internal_mutable_path();
215 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
216 CHK_(ptr);
217 CHK_(::_pbi::VerifyUTF8(str, nullptr));
218 } else {
219 goto handle_unusual;
220 }
221 continue;
222 // uint64 size = 2;
223 case 2:
224 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
225 _impl_.size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
226 CHK_(ptr);
227 } else {
228 goto handle_unusual;
229 }
230 continue;
231 default:
232 goto handle_unusual;
233 } // switch
234 handle_unusual:
235 if ((tag == 0) || ((tag & 7) == 4)) {
236 CHK_(ptr);
237 ctx->SetLastTag(tag);
238 goto message_done;
239 }
240 ptr = UnknownFieldParse(
241 tag,
242 _internal_metadata_.mutable_unknown_fields<std::string>(),
243 ptr, ctx);
244 CHK_(ptr != nullptr);
245 } // while
246 message_done:
247 return ptr;
248 failure:
249 ptr = nullptr;
250 goto message_done;
251 #undef CHK_
252 }
253
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const254 ::uint8_t* DebugUnwindFeature_File::_InternalSerialize(
255 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
256 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.DebugUnwindFeature.File)
257 ::uint32_t cached_has_bits = 0;
258 (void) cached_has_bits;
259
260 // string path = 1;
261 if (!this->_internal_path().empty()) {
262 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
263 this->_internal_path().data(), static_cast<int>(this->_internal_path().length()),
264 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
265 "simpleperf.proto.DebugUnwindFeature.File.path");
266 target = stream->WriteStringMaybeAliased(
267 1, this->_internal_path(), target);
268 }
269
270 // uint64 size = 2;
271 if (this->_internal_size() != 0) {
272 target = stream->EnsureSpace(target);
273 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_size(), target);
274 }
275
276 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
277 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
278 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
279 }
280 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.DebugUnwindFeature.File)
281 return target;
282 }
283
ByteSizeLong() const284 size_t DebugUnwindFeature_File::ByteSizeLong() const {
285 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.DebugUnwindFeature.File)
286 size_t total_size = 0;
287
288 ::uint32_t cached_has_bits = 0;
289 // Prevent compiler warnings about cached_has_bits being unused
290 (void) cached_has_bits;
291
292 // string path = 1;
293 if (!this->_internal_path().empty()) {
294 total_size += 1 +
295 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
296 this->_internal_path());
297 }
298
299 // uint64 size = 2;
300 if (this->_internal_size() != 0) {
301 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_size());
302 }
303
304 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
305 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
306 }
307 int cached_size = ::_pbi::ToCachedSize(total_size);
308 SetCachedSize(cached_size);
309 return total_size;
310 }
311
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)312 void DebugUnwindFeature_File::CheckTypeAndMergeFrom(
313 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
314 MergeFrom(*::_pbi::DownCast<const DebugUnwindFeature_File*>(
315 &from));
316 }
317
MergeFrom(const DebugUnwindFeature_File & from)318 void DebugUnwindFeature_File::MergeFrom(const DebugUnwindFeature_File& from) {
319 DebugUnwindFeature_File* const _this = this;
320 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.DebugUnwindFeature.File)
321 GOOGLE_DCHECK_NE(&from, _this);
322 ::uint32_t cached_has_bits = 0;
323 (void) cached_has_bits;
324
325 if (!from._internal_path().empty()) {
326 _this->_internal_set_path(from._internal_path());
327 }
328 if (from._internal_size() != 0) {
329 _this->_internal_set_size(from._internal_size());
330 }
331 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
332 }
333
CopyFrom(const DebugUnwindFeature_File & from)334 void DebugUnwindFeature_File::CopyFrom(const DebugUnwindFeature_File& from) {
335 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.DebugUnwindFeature.File)
336 if (&from == this) return;
337 Clear();
338 MergeFrom(from);
339 }
340
IsInitialized() const341 bool DebugUnwindFeature_File::IsInitialized() const {
342 return true;
343 }
344
InternalSwap(DebugUnwindFeature_File * other)345 void DebugUnwindFeature_File::InternalSwap(DebugUnwindFeature_File* other) {
346 using std::swap;
347 auto* lhs_arena = GetArenaForAllocation();
348 auto* rhs_arena = other->GetArenaForAllocation();
349 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
350 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
351 &_impl_.path_, lhs_arena,
352 &other->_impl_.path_, rhs_arena
353 );
354 swap(_impl_.size_, other->_impl_.size_);
355 }
356
GetTypeName() const357 std::string DebugUnwindFeature_File::GetTypeName() const {
358 return "simpleperf.proto.DebugUnwindFeature.File";
359 }
360
361
362 // ===================================================================
363
364 class DebugUnwindFeature::_Internal {
365 public:
366 };
367
DebugUnwindFeature(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)368 DebugUnwindFeature::DebugUnwindFeature(::PROTOBUF_NAMESPACE_ID::Arena* arena,
369 bool is_message_owned)
370 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
371 SharedCtor(arena, is_message_owned);
372 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.DebugUnwindFeature)
373 }
DebugUnwindFeature(const DebugUnwindFeature & from)374 DebugUnwindFeature::DebugUnwindFeature(const DebugUnwindFeature& from)
375 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
376 DebugUnwindFeature* const _this = this; (void)_this;
377 new (&_impl_) Impl_{
378 decltype(_impl_.file_){from._impl_.file_}
379 , /*decltype(_impl_._cached_size_)*/{}};
380
381 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
382 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.DebugUnwindFeature)
383 }
384
SharedCtor(::_pb::Arena * arena,bool is_message_owned)385 inline void DebugUnwindFeature::SharedCtor(
386 ::_pb::Arena* arena, bool is_message_owned) {
387 (void)arena;
388 (void)is_message_owned;
389 new (&_impl_) Impl_{
390 decltype(_impl_.file_){arena}
391 , /*decltype(_impl_._cached_size_)*/{}
392 };
393 }
394
~DebugUnwindFeature()395 DebugUnwindFeature::~DebugUnwindFeature() {
396 // @@protoc_insertion_point(destructor:simpleperf.proto.DebugUnwindFeature)
397 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
398 (void)arena;
399 return;
400 }
401 SharedDtor();
402 }
403
SharedDtor()404 inline void DebugUnwindFeature::SharedDtor() {
405 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
406 _impl_.file_.~RepeatedPtrField();
407 }
408
SetCachedSize(int size) const409 void DebugUnwindFeature::SetCachedSize(int size) const {
410 _impl_._cached_size_.Set(size);
411 }
412
Clear()413 void DebugUnwindFeature::Clear() {
414 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.DebugUnwindFeature)
415 ::uint32_t cached_has_bits = 0;
416 // Prevent compiler warnings about cached_has_bits being unused
417 (void) cached_has_bits;
418
419 _impl_.file_.Clear();
420 _internal_metadata_.Clear<std::string>();
421 }
422
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)423 const char* DebugUnwindFeature::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
424 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
425 while (!ctx->Done(&ptr)) {
426 ::uint32_t tag;
427 ptr = ::_pbi::ReadTag(ptr, &tag);
428 switch (tag >> 3) {
429 // repeated .simpleperf.proto.DebugUnwindFeature.File file = 1;
430 case 1:
431 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
432 ptr -= 1;
433 do {
434 ptr += 1;
435 ptr = ctx->ParseMessage(_internal_add_file(), ptr);
436 CHK_(ptr);
437 if (!ctx->DataAvailable(ptr)) break;
438 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
439 } else {
440 goto handle_unusual;
441 }
442 continue;
443 default:
444 goto handle_unusual;
445 } // switch
446 handle_unusual:
447 if ((tag == 0) || ((tag & 7) == 4)) {
448 CHK_(ptr);
449 ctx->SetLastTag(tag);
450 goto message_done;
451 }
452 ptr = UnknownFieldParse(
453 tag,
454 _internal_metadata_.mutable_unknown_fields<std::string>(),
455 ptr, ctx);
456 CHK_(ptr != nullptr);
457 } // while
458 message_done:
459 return ptr;
460 failure:
461 ptr = nullptr;
462 goto message_done;
463 #undef CHK_
464 }
465
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const466 ::uint8_t* DebugUnwindFeature::_InternalSerialize(
467 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
468 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.DebugUnwindFeature)
469 ::uint32_t cached_has_bits = 0;
470 (void) cached_has_bits;
471
472 // repeated .simpleperf.proto.DebugUnwindFeature.File file = 1;
473 for (unsigned i = 0,
474 n = static_cast<unsigned>(this->_internal_file_size()); i < n; i++) {
475 const auto& repfield = this->_internal_file(i);
476 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
477 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
478 }
479
480 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
481 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
482 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
483 }
484 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.DebugUnwindFeature)
485 return target;
486 }
487
ByteSizeLong() const488 size_t DebugUnwindFeature::ByteSizeLong() const {
489 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.DebugUnwindFeature)
490 size_t total_size = 0;
491
492 ::uint32_t cached_has_bits = 0;
493 // Prevent compiler warnings about cached_has_bits being unused
494 (void) cached_has_bits;
495
496 // repeated .simpleperf.proto.DebugUnwindFeature.File file = 1;
497 total_size += 1UL * this->_internal_file_size();
498 for (const auto& msg : this->_impl_.file_) {
499 total_size +=
500 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
501 }
502
503 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
504 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
505 }
506 int cached_size = ::_pbi::ToCachedSize(total_size);
507 SetCachedSize(cached_size);
508 return total_size;
509 }
510
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)511 void DebugUnwindFeature::CheckTypeAndMergeFrom(
512 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
513 MergeFrom(*::_pbi::DownCast<const DebugUnwindFeature*>(
514 &from));
515 }
516
MergeFrom(const DebugUnwindFeature & from)517 void DebugUnwindFeature::MergeFrom(const DebugUnwindFeature& from) {
518 DebugUnwindFeature* const _this = this;
519 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.DebugUnwindFeature)
520 GOOGLE_DCHECK_NE(&from, _this);
521 ::uint32_t cached_has_bits = 0;
522 (void) cached_has_bits;
523
524 _this->_impl_.file_.MergeFrom(from._impl_.file_);
525 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
526 }
527
CopyFrom(const DebugUnwindFeature & from)528 void DebugUnwindFeature::CopyFrom(const DebugUnwindFeature& from) {
529 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.DebugUnwindFeature)
530 if (&from == this) return;
531 Clear();
532 MergeFrom(from);
533 }
534
IsInitialized() const535 bool DebugUnwindFeature::IsInitialized() const {
536 return true;
537 }
538
InternalSwap(DebugUnwindFeature * other)539 void DebugUnwindFeature::InternalSwap(DebugUnwindFeature* other) {
540 using std::swap;
541 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
542 _impl_.file_.InternalSwap(&other->_impl_.file_);
543 }
544
GetTypeName() const545 std::string DebugUnwindFeature::GetTypeName() const {
546 return "simpleperf.proto.DebugUnwindFeature";
547 }
548
549
550 // ===================================================================
551
552 class FileFeature_Symbol::_Internal {
553 public:
554 };
555
FileFeature_Symbol(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)556 FileFeature_Symbol::FileFeature_Symbol(::PROTOBUF_NAMESPACE_ID::Arena* arena,
557 bool is_message_owned)
558 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
559 SharedCtor(arena, is_message_owned);
560 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.FileFeature.Symbol)
561 }
FileFeature_Symbol(const FileFeature_Symbol & from)562 FileFeature_Symbol::FileFeature_Symbol(const FileFeature_Symbol& from)
563 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
564 FileFeature_Symbol* const _this = this; (void)_this;
565 new (&_impl_) Impl_{
566 decltype(_impl_.name_){}
567 , decltype(_impl_.vaddr_){}
568 , decltype(_impl_.len_){}
569 , /*decltype(_impl_._cached_size_)*/{}};
570
571 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
572 _impl_.name_.InitDefault();
573 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
574 _impl_.name_.Set("", GetArenaForAllocation());
575 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
576 if (!from._internal_name().empty()) {
577 _this->_impl_.name_.Set(from._internal_name(),
578 _this->GetArenaForAllocation());
579 }
580 ::memcpy(&_impl_.vaddr_, &from._impl_.vaddr_,
581 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.len_) -
582 reinterpret_cast<char*>(&_impl_.vaddr_)) + sizeof(_impl_.len_));
583 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.FileFeature.Symbol)
584 }
585
SharedCtor(::_pb::Arena * arena,bool is_message_owned)586 inline void FileFeature_Symbol::SharedCtor(
587 ::_pb::Arena* arena, bool is_message_owned) {
588 (void)arena;
589 (void)is_message_owned;
590 new (&_impl_) Impl_{
591 decltype(_impl_.name_){}
592 , decltype(_impl_.vaddr_){::uint64_t{0u}}
593 , decltype(_impl_.len_){0u}
594 , /*decltype(_impl_._cached_size_)*/{}
595 };
596 _impl_.name_.InitDefault();
597 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
598 _impl_.name_.Set("", GetArenaForAllocation());
599 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
600 }
601
~FileFeature_Symbol()602 FileFeature_Symbol::~FileFeature_Symbol() {
603 // @@protoc_insertion_point(destructor:simpleperf.proto.FileFeature.Symbol)
604 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
605 (void)arena;
606 return;
607 }
608 SharedDtor();
609 }
610
SharedDtor()611 inline void FileFeature_Symbol::SharedDtor() {
612 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
613 _impl_.name_.Destroy();
614 }
615
SetCachedSize(int size) const616 void FileFeature_Symbol::SetCachedSize(int size) const {
617 _impl_._cached_size_.Set(size);
618 }
619
Clear()620 void FileFeature_Symbol::Clear() {
621 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.FileFeature.Symbol)
622 ::uint32_t cached_has_bits = 0;
623 // Prevent compiler warnings about cached_has_bits being unused
624 (void) cached_has_bits;
625
626 _impl_.name_.ClearToEmpty();
627 ::memset(&_impl_.vaddr_, 0, static_cast<size_t>(
628 reinterpret_cast<char*>(&_impl_.len_) -
629 reinterpret_cast<char*>(&_impl_.vaddr_)) + sizeof(_impl_.len_));
630 _internal_metadata_.Clear<std::string>();
631 }
632
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)633 const char* FileFeature_Symbol::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
634 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
635 while (!ctx->Done(&ptr)) {
636 ::uint32_t tag;
637 ptr = ::_pbi::ReadTag(ptr, &tag);
638 switch (tag >> 3) {
639 // uint64 vaddr = 1;
640 case 1:
641 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
642 _impl_.vaddr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
643 CHK_(ptr);
644 } else {
645 goto handle_unusual;
646 }
647 continue;
648 // uint32 len = 2;
649 case 2:
650 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
651 _impl_.len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
652 CHK_(ptr);
653 } else {
654 goto handle_unusual;
655 }
656 continue;
657 // string name = 3;
658 case 3:
659 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
660 auto str = _internal_mutable_name();
661 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
662 CHK_(ptr);
663 CHK_(::_pbi::VerifyUTF8(str, nullptr));
664 } else {
665 goto handle_unusual;
666 }
667 continue;
668 default:
669 goto handle_unusual;
670 } // switch
671 handle_unusual:
672 if ((tag == 0) || ((tag & 7) == 4)) {
673 CHK_(ptr);
674 ctx->SetLastTag(tag);
675 goto message_done;
676 }
677 ptr = UnknownFieldParse(
678 tag,
679 _internal_metadata_.mutable_unknown_fields<std::string>(),
680 ptr, ctx);
681 CHK_(ptr != nullptr);
682 } // while
683 message_done:
684 return ptr;
685 failure:
686 ptr = nullptr;
687 goto message_done;
688 #undef CHK_
689 }
690
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const691 ::uint8_t* FileFeature_Symbol::_InternalSerialize(
692 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
693 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.FileFeature.Symbol)
694 ::uint32_t cached_has_bits = 0;
695 (void) cached_has_bits;
696
697 // uint64 vaddr = 1;
698 if (this->_internal_vaddr() != 0) {
699 target = stream->EnsureSpace(target);
700 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_vaddr(), target);
701 }
702
703 // uint32 len = 2;
704 if (this->_internal_len() != 0) {
705 target = stream->EnsureSpace(target);
706 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_len(), target);
707 }
708
709 // string name = 3;
710 if (!this->_internal_name().empty()) {
711 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
712 this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
713 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
714 "simpleperf.proto.FileFeature.Symbol.name");
715 target = stream->WriteStringMaybeAliased(
716 3, this->_internal_name(), target);
717 }
718
719 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
720 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
721 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
722 }
723 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.FileFeature.Symbol)
724 return target;
725 }
726
ByteSizeLong() const727 size_t FileFeature_Symbol::ByteSizeLong() const {
728 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.FileFeature.Symbol)
729 size_t total_size = 0;
730
731 ::uint32_t cached_has_bits = 0;
732 // Prevent compiler warnings about cached_has_bits being unused
733 (void) cached_has_bits;
734
735 // string name = 3;
736 if (!this->_internal_name().empty()) {
737 total_size += 1 +
738 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
739 this->_internal_name());
740 }
741
742 // uint64 vaddr = 1;
743 if (this->_internal_vaddr() != 0) {
744 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_vaddr());
745 }
746
747 // uint32 len = 2;
748 if (this->_internal_len() != 0) {
749 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_len());
750 }
751
752 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
753 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
754 }
755 int cached_size = ::_pbi::ToCachedSize(total_size);
756 SetCachedSize(cached_size);
757 return total_size;
758 }
759
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)760 void FileFeature_Symbol::CheckTypeAndMergeFrom(
761 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
762 MergeFrom(*::_pbi::DownCast<const FileFeature_Symbol*>(
763 &from));
764 }
765
MergeFrom(const FileFeature_Symbol & from)766 void FileFeature_Symbol::MergeFrom(const FileFeature_Symbol& from) {
767 FileFeature_Symbol* const _this = this;
768 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.FileFeature.Symbol)
769 GOOGLE_DCHECK_NE(&from, _this);
770 ::uint32_t cached_has_bits = 0;
771 (void) cached_has_bits;
772
773 if (!from._internal_name().empty()) {
774 _this->_internal_set_name(from._internal_name());
775 }
776 if (from._internal_vaddr() != 0) {
777 _this->_internal_set_vaddr(from._internal_vaddr());
778 }
779 if (from._internal_len() != 0) {
780 _this->_internal_set_len(from._internal_len());
781 }
782 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
783 }
784
CopyFrom(const FileFeature_Symbol & from)785 void FileFeature_Symbol::CopyFrom(const FileFeature_Symbol& from) {
786 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.FileFeature.Symbol)
787 if (&from == this) return;
788 Clear();
789 MergeFrom(from);
790 }
791
IsInitialized() const792 bool FileFeature_Symbol::IsInitialized() const {
793 return true;
794 }
795
InternalSwap(FileFeature_Symbol * other)796 void FileFeature_Symbol::InternalSwap(FileFeature_Symbol* other) {
797 using std::swap;
798 auto* lhs_arena = GetArenaForAllocation();
799 auto* rhs_arena = other->GetArenaForAllocation();
800 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
801 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
802 &_impl_.name_, lhs_arena,
803 &other->_impl_.name_, rhs_arena
804 );
805 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
806 PROTOBUF_FIELD_OFFSET(FileFeature_Symbol, _impl_.len_)
807 + sizeof(FileFeature_Symbol::_impl_.len_) // NOLINT
808 - PROTOBUF_FIELD_OFFSET(FileFeature_Symbol, _impl_.vaddr_)>(
809 reinterpret_cast<char*>(&_impl_.vaddr_),
810 reinterpret_cast<char*>(&other->_impl_.vaddr_));
811 }
812
GetTypeName() const813 std::string FileFeature_Symbol::GetTypeName() const {
814 return "simpleperf.proto.FileFeature.Symbol";
815 }
816
817
818 // ===================================================================
819
820 class FileFeature_DexFile::_Internal {
821 public:
822 };
823
FileFeature_DexFile(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)824 FileFeature_DexFile::FileFeature_DexFile(::PROTOBUF_NAMESPACE_ID::Arena* arena,
825 bool is_message_owned)
826 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
827 SharedCtor(arena, is_message_owned);
828 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.FileFeature.DexFile)
829 }
FileFeature_DexFile(const FileFeature_DexFile & from)830 FileFeature_DexFile::FileFeature_DexFile(const FileFeature_DexFile& from)
831 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
832 FileFeature_DexFile* const _this = this; (void)_this;
833 new (&_impl_) Impl_{
834 decltype(_impl_.dex_file_offset_){from._impl_.dex_file_offset_}
835 , /*decltype(_impl_._dex_file_offset_cached_byte_size_)*/{0}
836 , /*decltype(_impl_._cached_size_)*/{}};
837
838 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
839 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.FileFeature.DexFile)
840 }
841
SharedCtor(::_pb::Arena * arena,bool is_message_owned)842 inline void FileFeature_DexFile::SharedCtor(
843 ::_pb::Arena* arena, bool is_message_owned) {
844 (void)arena;
845 (void)is_message_owned;
846 new (&_impl_) Impl_{
847 decltype(_impl_.dex_file_offset_){arena}
848 , /*decltype(_impl_._dex_file_offset_cached_byte_size_)*/{0}
849 , /*decltype(_impl_._cached_size_)*/{}
850 };
851 }
852
~FileFeature_DexFile()853 FileFeature_DexFile::~FileFeature_DexFile() {
854 // @@protoc_insertion_point(destructor:simpleperf.proto.FileFeature.DexFile)
855 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
856 (void)arena;
857 return;
858 }
859 SharedDtor();
860 }
861
SharedDtor()862 inline void FileFeature_DexFile::SharedDtor() {
863 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
864 _impl_.dex_file_offset_.~RepeatedField();
865 }
866
SetCachedSize(int size) const867 void FileFeature_DexFile::SetCachedSize(int size) const {
868 _impl_._cached_size_.Set(size);
869 }
870
Clear()871 void FileFeature_DexFile::Clear() {
872 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.FileFeature.DexFile)
873 ::uint32_t cached_has_bits = 0;
874 // Prevent compiler warnings about cached_has_bits being unused
875 (void) cached_has_bits;
876
877 _impl_.dex_file_offset_.Clear();
878 _internal_metadata_.Clear<std::string>();
879 }
880
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)881 const char* FileFeature_DexFile::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
882 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
883 while (!ctx->Done(&ptr)) {
884 ::uint32_t tag;
885 ptr = ::_pbi::ReadTag(ptr, &tag);
886 switch (tag >> 3) {
887 // repeated uint64 dex_file_offset = 1;
888 case 1:
889 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
890 ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt64Parser(_internal_mutable_dex_file_offset(), ptr, ctx);
891 CHK_(ptr);
892 } else if (static_cast<::uint8_t>(tag) == 8) {
893 _internal_add_dex_file_offset(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
894 CHK_(ptr);
895 } else {
896 goto handle_unusual;
897 }
898 continue;
899 default:
900 goto handle_unusual;
901 } // switch
902 handle_unusual:
903 if ((tag == 0) || ((tag & 7) == 4)) {
904 CHK_(ptr);
905 ctx->SetLastTag(tag);
906 goto message_done;
907 }
908 ptr = UnknownFieldParse(
909 tag,
910 _internal_metadata_.mutable_unknown_fields<std::string>(),
911 ptr, ctx);
912 CHK_(ptr != nullptr);
913 } // while
914 message_done:
915 return ptr;
916 failure:
917 ptr = nullptr;
918 goto message_done;
919 #undef CHK_
920 }
921
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const922 ::uint8_t* FileFeature_DexFile::_InternalSerialize(
923 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
924 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.FileFeature.DexFile)
925 ::uint32_t cached_has_bits = 0;
926 (void) cached_has_bits;
927
928 // repeated uint64 dex_file_offset = 1;
929 {
930 int byte_size = _impl_._dex_file_offset_cached_byte_size_.load(std::memory_order_relaxed);
931 if (byte_size > 0) {
932 target = stream->WriteUInt64Packed(
933 1, _internal_dex_file_offset(), byte_size, target);
934 }
935 }
936
937 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
938 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
939 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
940 }
941 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.FileFeature.DexFile)
942 return target;
943 }
944
ByteSizeLong() const945 size_t FileFeature_DexFile::ByteSizeLong() const {
946 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.FileFeature.DexFile)
947 size_t total_size = 0;
948
949 ::uint32_t cached_has_bits = 0;
950 // Prevent compiler warnings about cached_has_bits being unused
951 (void) cached_has_bits;
952
953 // repeated uint64 dex_file_offset = 1;
954 {
955 size_t data_size = ::_pbi::WireFormatLite::
956 UInt64Size(this->_impl_.dex_file_offset_);
957 if (data_size > 0) {
958 total_size += 1 +
959 ::_pbi::WireFormatLite::Int32Size(static_cast<::int32_t>(data_size));
960 }
961 int cached_size = ::_pbi::ToCachedSize(data_size);
962 _impl_._dex_file_offset_cached_byte_size_.store(cached_size,
963 std::memory_order_relaxed);
964 total_size += data_size;
965 }
966
967 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
968 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
969 }
970 int cached_size = ::_pbi::ToCachedSize(total_size);
971 SetCachedSize(cached_size);
972 return total_size;
973 }
974
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)975 void FileFeature_DexFile::CheckTypeAndMergeFrom(
976 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
977 MergeFrom(*::_pbi::DownCast<const FileFeature_DexFile*>(
978 &from));
979 }
980
MergeFrom(const FileFeature_DexFile & from)981 void FileFeature_DexFile::MergeFrom(const FileFeature_DexFile& from) {
982 FileFeature_DexFile* const _this = this;
983 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.FileFeature.DexFile)
984 GOOGLE_DCHECK_NE(&from, _this);
985 ::uint32_t cached_has_bits = 0;
986 (void) cached_has_bits;
987
988 _this->_impl_.dex_file_offset_.MergeFrom(from._impl_.dex_file_offset_);
989 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
990 }
991
CopyFrom(const FileFeature_DexFile & from)992 void FileFeature_DexFile::CopyFrom(const FileFeature_DexFile& from) {
993 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.FileFeature.DexFile)
994 if (&from == this) return;
995 Clear();
996 MergeFrom(from);
997 }
998
IsInitialized() const999 bool FileFeature_DexFile::IsInitialized() const {
1000 return true;
1001 }
1002
InternalSwap(FileFeature_DexFile * other)1003 void FileFeature_DexFile::InternalSwap(FileFeature_DexFile* other) {
1004 using std::swap;
1005 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1006 _impl_.dex_file_offset_.InternalSwap(&other->_impl_.dex_file_offset_);
1007 }
1008
GetTypeName() const1009 std::string FileFeature_DexFile::GetTypeName() const {
1010 return "simpleperf.proto.FileFeature.DexFile";
1011 }
1012
1013
1014 // ===================================================================
1015
1016 class FileFeature_ElfFile::_Internal {
1017 public:
1018 };
1019
FileFeature_ElfFile(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1020 FileFeature_ElfFile::FileFeature_ElfFile(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1021 bool is_message_owned)
1022 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1023 SharedCtor(arena, is_message_owned);
1024 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.FileFeature.ElfFile)
1025 }
FileFeature_ElfFile(const FileFeature_ElfFile & from)1026 FileFeature_ElfFile::FileFeature_ElfFile(const FileFeature_ElfFile& from)
1027 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1028 FileFeature_ElfFile* const _this = this; (void)_this;
1029 new (&_impl_) Impl_{
1030 decltype(_impl_.file_offset_of_min_vaddr_){}
1031 , /*decltype(_impl_._cached_size_)*/{}};
1032
1033 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1034 _this->_impl_.file_offset_of_min_vaddr_ = from._impl_.file_offset_of_min_vaddr_;
1035 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.FileFeature.ElfFile)
1036 }
1037
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1038 inline void FileFeature_ElfFile::SharedCtor(
1039 ::_pb::Arena* arena, bool is_message_owned) {
1040 (void)arena;
1041 (void)is_message_owned;
1042 new (&_impl_) Impl_{
1043 decltype(_impl_.file_offset_of_min_vaddr_){::uint64_t{0u}}
1044 , /*decltype(_impl_._cached_size_)*/{}
1045 };
1046 }
1047
~FileFeature_ElfFile()1048 FileFeature_ElfFile::~FileFeature_ElfFile() {
1049 // @@protoc_insertion_point(destructor:simpleperf.proto.FileFeature.ElfFile)
1050 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1051 (void)arena;
1052 return;
1053 }
1054 SharedDtor();
1055 }
1056
SharedDtor()1057 inline void FileFeature_ElfFile::SharedDtor() {
1058 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1059 }
1060
SetCachedSize(int size) const1061 void FileFeature_ElfFile::SetCachedSize(int size) const {
1062 _impl_._cached_size_.Set(size);
1063 }
1064
Clear()1065 void FileFeature_ElfFile::Clear() {
1066 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.FileFeature.ElfFile)
1067 ::uint32_t cached_has_bits = 0;
1068 // Prevent compiler warnings about cached_has_bits being unused
1069 (void) cached_has_bits;
1070
1071 _impl_.file_offset_of_min_vaddr_ = ::uint64_t{0u};
1072 _internal_metadata_.Clear<std::string>();
1073 }
1074
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1075 const char* FileFeature_ElfFile::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1076 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1077 while (!ctx->Done(&ptr)) {
1078 ::uint32_t tag;
1079 ptr = ::_pbi::ReadTag(ptr, &tag);
1080 switch (tag >> 3) {
1081 // uint64 file_offset_of_min_vaddr = 1;
1082 case 1:
1083 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1084 _impl_.file_offset_of_min_vaddr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1085 CHK_(ptr);
1086 } else {
1087 goto handle_unusual;
1088 }
1089 continue;
1090 default:
1091 goto handle_unusual;
1092 } // switch
1093 handle_unusual:
1094 if ((tag == 0) || ((tag & 7) == 4)) {
1095 CHK_(ptr);
1096 ctx->SetLastTag(tag);
1097 goto message_done;
1098 }
1099 ptr = UnknownFieldParse(
1100 tag,
1101 _internal_metadata_.mutable_unknown_fields<std::string>(),
1102 ptr, ctx);
1103 CHK_(ptr != nullptr);
1104 } // while
1105 message_done:
1106 return ptr;
1107 failure:
1108 ptr = nullptr;
1109 goto message_done;
1110 #undef CHK_
1111 }
1112
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1113 ::uint8_t* FileFeature_ElfFile::_InternalSerialize(
1114 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1115 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.FileFeature.ElfFile)
1116 ::uint32_t cached_has_bits = 0;
1117 (void) cached_has_bits;
1118
1119 // uint64 file_offset_of_min_vaddr = 1;
1120 if (this->_internal_file_offset_of_min_vaddr() != 0) {
1121 target = stream->EnsureSpace(target);
1122 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_file_offset_of_min_vaddr(), target);
1123 }
1124
1125 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1126 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1127 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1128 }
1129 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.FileFeature.ElfFile)
1130 return target;
1131 }
1132
ByteSizeLong() const1133 size_t FileFeature_ElfFile::ByteSizeLong() const {
1134 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.FileFeature.ElfFile)
1135 size_t total_size = 0;
1136
1137 ::uint32_t cached_has_bits = 0;
1138 // Prevent compiler warnings about cached_has_bits being unused
1139 (void) cached_has_bits;
1140
1141 // uint64 file_offset_of_min_vaddr = 1;
1142 if (this->_internal_file_offset_of_min_vaddr() != 0) {
1143 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_file_offset_of_min_vaddr());
1144 }
1145
1146 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1147 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1148 }
1149 int cached_size = ::_pbi::ToCachedSize(total_size);
1150 SetCachedSize(cached_size);
1151 return total_size;
1152 }
1153
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1154 void FileFeature_ElfFile::CheckTypeAndMergeFrom(
1155 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1156 MergeFrom(*::_pbi::DownCast<const FileFeature_ElfFile*>(
1157 &from));
1158 }
1159
MergeFrom(const FileFeature_ElfFile & from)1160 void FileFeature_ElfFile::MergeFrom(const FileFeature_ElfFile& from) {
1161 FileFeature_ElfFile* const _this = this;
1162 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.FileFeature.ElfFile)
1163 GOOGLE_DCHECK_NE(&from, _this);
1164 ::uint32_t cached_has_bits = 0;
1165 (void) cached_has_bits;
1166
1167 if (from._internal_file_offset_of_min_vaddr() != 0) {
1168 _this->_internal_set_file_offset_of_min_vaddr(from._internal_file_offset_of_min_vaddr());
1169 }
1170 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1171 }
1172
CopyFrom(const FileFeature_ElfFile & from)1173 void FileFeature_ElfFile::CopyFrom(const FileFeature_ElfFile& from) {
1174 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.FileFeature.ElfFile)
1175 if (&from == this) return;
1176 Clear();
1177 MergeFrom(from);
1178 }
1179
IsInitialized() const1180 bool FileFeature_ElfFile::IsInitialized() const {
1181 return true;
1182 }
1183
InternalSwap(FileFeature_ElfFile * other)1184 void FileFeature_ElfFile::InternalSwap(FileFeature_ElfFile* other) {
1185 using std::swap;
1186 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1187 swap(_impl_.file_offset_of_min_vaddr_, other->_impl_.file_offset_of_min_vaddr_);
1188 }
1189
GetTypeName() const1190 std::string FileFeature_ElfFile::GetTypeName() const {
1191 return "simpleperf.proto.FileFeature.ElfFile";
1192 }
1193
1194
1195 // ===================================================================
1196
1197 class FileFeature_KernelModule::_Internal {
1198 public:
1199 };
1200
FileFeature_KernelModule(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1201 FileFeature_KernelModule::FileFeature_KernelModule(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1202 bool is_message_owned)
1203 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1204 SharedCtor(arena, is_message_owned);
1205 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.FileFeature.KernelModule)
1206 }
FileFeature_KernelModule(const FileFeature_KernelModule & from)1207 FileFeature_KernelModule::FileFeature_KernelModule(const FileFeature_KernelModule& from)
1208 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1209 FileFeature_KernelModule* const _this = this; (void)_this;
1210 new (&_impl_) Impl_{
1211 decltype(_impl_.memory_offset_of_min_vaddr_){}
1212 , /*decltype(_impl_._cached_size_)*/{}};
1213
1214 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1215 _this->_impl_.memory_offset_of_min_vaddr_ = from._impl_.memory_offset_of_min_vaddr_;
1216 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.FileFeature.KernelModule)
1217 }
1218
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1219 inline void FileFeature_KernelModule::SharedCtor(
1220 ::_pb::Arena* arena, bool is_message_owned) {
1221 (void)arena;
1222 (void)is_message_owned;
1223 new (&_impl_) Impl_{
1224 decltype(_impl_.memory_offset_of_min_vaddr_){::uint64_t{0u}}
1225 , /*decltype(_impl_._cached_size_)*/{}
1226 };
1227 }
1228
~FileFeature_KernelModule()1229 FileFeature_KernelModule::~FileFeature_KernelModule() {
1230 // @@protoc_insertion_point(destructor:simpleperf.proto.FileFeature.KernelModule)
1231 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1232 (void)arena;
1233 return;
1234 }
1235 SharedDtor();
1236 }
1237
SharedDtor()1238 inline void FileFeature_KernelModule::SharedDtor() {
1239 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1240 }
1241
SetCachedSize(int size) const1242 void FileFeature_KernelModule::SetCachedSize(int size) const {
1243 _impl_._cached_size_.Set(size);
1244 }
1245
Clear()1246 void FileFeature_KernelModule::Clear() {
1247 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.FileFeature.KernelModule)
1248 ::uint32_t cached_has_bits = 0;
1249 // Prevent compiler warnings about cached_has_bits being unused
1250 (void) cached_has_bits;
1251
1252 _impl_.memory_offset_of_min_vaddr_ = ::uint64_t{0u};
1253 _internal_metadata_.Clear<std::string>();
1254 }
1255
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1256 const char* FileFeature_KernelModule::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1257 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1258 while (!ctx->Done(&ptr)) {
1259 ::uint32_t tag;
1260 ptr = ::_pbi::ReadTag(ptr, &tag);
1261 switch (tag >> 3) {
1262 // uint64 memory_offset_of_min_vaddr = 1;
1263 case 1:
1264 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1265 _impl_.memory_offset_of_min_vaddr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1266 CHK_(ptr);
1267 } else {
1268 goto handle_unusual;
1269 }
1270 continue;
1271 default:
1272 goto handle_unusual;
1273 } // switch
1274 handle_unusual:
1275 if ((tag == 0) || ((tag & 7) == 4)) {
1276 CHK_(ptr);
1277 ctx->SetLastTag(tag);
1278 goto message_done;
1279 }
1280 ptr = UnknownFieldParse(
1281 tag,
1282 _internal_metadata_.mutable_unknown_fields<std::string>(),
1283 ptr, ctx);
1284 CHK_(ptr != nullptr);
1285 } // while
1286 message_done:
1287 return ptr;
1288 failure:
1289 ptr = nullptr;
1290 goto message_done;
1291 #undef CHK_
1292 }
1293
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1294 ::uint8_t* FileFeature_KernelModule::_InternalSerialize(
1295 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1296 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.FileFeature.KernelModule)
1297 ::uint32_t cached_has_bits = 0;
1298 (void) cached_has_bits;
1299
1300 // uint64 memory_offset_of_min_vaddr = 1;
1301 if (this->_internal_memory_offset_of_min_vaddr() != 0) {
1302 target = stream->EnsureSpace(target);
1303 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_memory_offset_of_min_vaddr(), target);
1304 }
1305
1306 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1307 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1308 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1309 }
1310 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.FileFeature.KernelModule)
1311 return target;
1312 }
1313
ByteSizeLong() const1314 size_t FileFeature_KernelModule::ByteSizeLong() const {
1315 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.FileFeature.KernelModule)
1316 size_t total_size = 0;
1317
1318 ::uint32_t cached_has_bits = 0;
1319 // Prevent compiler warnings about cached_has_bits being unused
1320 (void) cached_has_bits;
1321
1322 // uint64 memory_offset_of_min_vaddr = 1;
1323 if (this->_internal_memory_offset_of_min_vaddr() != 0) {
1324 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_memory_offset_of_min_vaddr());
1325 }
1326
1327 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1328 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1329 }
1330 int cached_size = ::_pbi::ToCachedSize(total_size);
1331 SetCachedSize(cached_size);
1332 return total_size;
1333 }
1334
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1335 void FileFeature_KernelModule::CheckTypeAndMergeFrom(
1336 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1337 MergeFrom(*::_pbi::DownCast<const FileFeature_KernelModule*>(
1338 &from));
1339 }
1340
MergeFrom(const FileFeature_KernelModule & from)1341 void FileFeature_KernelModule::MergeFrom(const FileFeature_KernelModule& from) {
1342 FileFeature_KernelModule* const _this = this;
1343 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.FileFeature.KernelModule)
1344 GOOGLE_DCHECK_NE(&from, _this);
1345 ::uint32_t cached_has_bits = 0;
1346 (void) cached_has_bits;
1347
1348 if (from._internal_memory_offset_of_min_vaddr() != 0) {
1349 _this->_internal_set_memory_offset_of_min_vaddr(from._internal_memory_offset_of_min_vaddr());
1350 }
1351 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1352 }
1353
CopyFrom(const FileFeature_KernelModule & from)1354 void FileFeature_KernelModule::CopyFrom(const FileFeature_KernelModule& from) {
1355 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.FileFeature.KernelModule)
1356 if (&from == this) return;
1357 Clear();
1358 MergeFrom(from);
1359 }
1360
IsInitialized() const1361 bool FileFeature_KernelModule::IsInitialized() const {
1362 return true;
1363 }
1364
InternalSwap(FileFeature_KernelModule * other)1365 void FileFeature_KernelModule::InternalSwap(FileFeature_KernelModule* other) {
1366 using std::swap;
1367 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1368 swap(_impl_.memory_offset_of_min_vaddr_, other->_impl_.memory_offset_of_min_vaddr_);
1369 }
1370
GetTypeName() const1371 std::string FileFeature_KernelModule::GetTypeName() const {
1372 return "simpleperf.proto.FileFeature.KernelModule";
1373 }
1374
1375
1376 // ===================================================================
1377
1378 class FileFeature::_Internal {
1379 public:
1380 static const ::simpleperf::proto::FileFeature_DexFile& dex_file(const FileFeature* msg);
1381 static const ::simpleperf::proto::FileFeature_ElfFile& elf_file(const FileFeature* msg);
1382 static const ::simpleperf::proto::FileFeature_KernelModule& kernel_module(const FileFeature* msg);
1383 };
1384
1385 const ::simpleperf::proto::FileFeature_DexFile&
dex_file(const FileFeature * msg)1386 FileFeature::_Internal::dex_file(const FileFeature* msg) {
1387 return *msg->_impl_.type_specific_msg_.dex_file_;
1388 }
1389 const ::simpleperf::proto::FileFeature_ElfFile&
elf_file(const FileFeature * msg)1390 FileFeature::_Internal::elf_file(const FileFeature* msg) {
1391 return *msg->_impl_.type_specific_msg_.elf_file_;
1392 }
1393 const ::simpleperf::proto::FileFeature_KernelModule&
kernel_module(const FileFeature * msg)1394 FileFeature::_Internal::kernel_module(const FileFeature* msg) {
1395 return *msg->_impl_.type_specific_msg_.kernel_module_;
1396 }
set_allocated_dex_file(::simpleperf::proto::FileFeature_DexFile * dex_file)1397 void FileFeature::set_allocated_dex_file(::simpleperf::proto::FileFeature_DexFile* dex_file) {
1398 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1399 clear_type_specific_msg();
1400 if (dex_file) {
1401 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1402 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dex_file);
1403 if (message_arena != submessage_arena) {
1404 dex_file = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1405 message_arena, dex_file, submessage_arena);
1406 }
1407 set_has_dex_file();
1408 _impl_.type_specific_msg_.dex_file_ = dex_file;
1409 }
1410 // @@protoc_insertion_point(field_set_allocated:simpleperf.proto.FileFeature.dex_file)
1411 }
set_allocated_elf_file(::simpleperf::proto::FileFeature_ElfFile * elf_file)1412 void FileFeature::set_allocated_elf_file(::simpleperf::proto::FileFeature_ElfFile* elf_file) {
1413 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1414 clear_type_specific_msg();
1415 if (elf_file) {
1416 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1417 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(elf_file);
1418 if (message_arena != submessage_arena) {
1419 elf_file = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1420 message_arena, elf_file, submessage_arena);
1421 }
1422 set_has_elf_file();
1423 _impl_.type_specific_msg_.elf_file_ = elf_file;
1424 }
1425 // @@protoc_insertion_point(field_set_allocated:simpleperf.proto.FileFeature.elf_file)
1426 }
set_allocated_kernel_module(::simpleperf::proto::FileFeature_KernelModule * kernel_module)1427 void FileFeature::set_allocated_kernel_module(::simpleperf::proto::FileFeature_KernelModule* kernel_module) {
1428 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1429 clear_type_specific_msg();
1430 if (kernel_module) {
1431 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1432 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(kernel_module);
1433 if (message_arena != submessage_arena) {
1434 kernel_module = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1435 message_arena, kernel_module, submessage_arena);
1436 }
1437 set_has_kernel_module();
1438 _impl_.type_specific_msg_.kernel_module_ = kernel_module;
1439 }
1440 // @@protoc_insertion_point(field_set_allocated:simpleperf.proto.FileFeature.kernel_module)
1441 }
FileFeature(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1442 FileFeature::FileFeature(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1443 bool is_message_owned)
1444 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1445 SharedCtor(arena, is_message_owned);
1446 // @@protoc_insertion_point(arena_constructor:simpleperf.proto.FileFeature)
1447 }
FileFeature(const FileFeature & from)1448 FileFeature::FileFeature(const FileFeature& from)
1449 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1450 FileFeature* const _this = this; (void)_this;
1451 new (&_impl_) Impl_{
1452 decltype(_impl_.symbol_){from._impl_.symbol_}
1453 , decltype(_impl_.path_){}
1454 , decltype(_impl_.min_vaddr_){}
1455 , decltype(_impl_.type_){}
1456 , decltype(_impl_.type_specific_msg_){}
1457 , /*decltype(_impl_._cached_size_)*/{}
1458 , /*decltype(_impl_._oneof_case_)*/{}};
1459
1460 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1461 _impl_.path_.InitDefault();
1462 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1463 _impl_.path_.Set("", GetArenaForAllocation());
1464 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1465 if (!from._internal_path().empty()) {
1466 _this->_impl_.path_.Set(from._internal_path(),
1467 _this->GetArenaForAllocation());
1468 }
1469 ::memcpy(&_impl_.min_vaddr_, &from._impl_.min_vaddr_,
1470 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.type_) -
1471 reinterpret_cast<char*>(&_impl_.min_vaddr_)) + sizeof(_impl_.type_));
1472 clear_has_type_specific_msg();
1473 switch (from.type_specific_msg_case()) {
1474 case kDexFile: {
1475 _this->_internal_mutable_dex_file()->::simpleperf::proto::FileFeature_DexFile::MergeFrom(
1476 from._internal_dex_file());
1477 break;
1478 }
1479 case kElfFile: {
1480 _this->_internal_mutable_elf_file()->::simpleperf::proto::FileFeature_ElfFile::MergeFrom(
1481 from._internal_elf_file());
1482 break;
1483 }
1484 case kKernelModule: {
1485 _this->_internal_mutable_kernel_module()->::simpleperf::proto::FileFeature_KernelModule::MergeFrom(
1486 from._internal_kernel_module());
1487 break;
1488 }
1489 case TYPE_SPECIFIC_MSG_NOT_SET: {
1490 break;
1491 }
1492 }
1493 // @@protoc_insertion_point(copy_constructor:simpleperf.proto.FileFeature)
1494 }
1495
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1496 inline void FileFeature::SharedCtor(
1497 ::_pb::Arena* arena, bool is_message_owned) {
1498 (void)arena;
1499 (void)is_message_owned;
1500 new (&_impl_) Impl_{
1501 decltype(_impl_.symbol_){arena}
1502 , decltype(_impl_.path_){}
1503 , decltype(_impl_.min_vaddr_){::uint64_t{0u}}
1504 , decltype(_impl_.type_){0u}
1505 , decltype(_impl_.type_specific_msg_){}
1506 , /*decltype(_impl_._cached_size_)*/{}
1507 , /*decltype(_impl_._oneof_case_)*/{}
1508 };
1509 _impl_.path_.InitDefault();
1510 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1511 _impl_.path_.Set("", GetArenaForAllocation());
1512 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1513 clear_has_type_specific_msg();
1514 }
1515
~FileFeature()1516 FileFeature::~FileFeature() {
1517 // @@protoc_insertion_point(destructor:simpleperf.proto.FileFeature)
1518 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1519 (void)arena;
1520 return;
1521 }
1522 SharedDtor();
1523 }
1524
SharedDtor()1525 inline void FileFeature::SharedDtor() {
1526 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1527 _impl_.symbol_.~RepeatedPtrField();
1528 _impl_.path_.Destroy();
1529 if (has_type_specific_msg()) {
1530 clear_type_specific_msg();
1531 }
1532 }
1533
SetCachedSize(int size) const1534 void FileFeature::SetCachedSize(int size) const {
1535 _impl_._cached_size_.Set(size);
1536 }
1537
clear_type_specific_msg()1538 void FileFeature::clear_type_specific_msg() {
1539 // @@protoc_insertion_point(one_of_clear_start:simpleperf.proto.FileFeature)
1540 switch (type_specific_msg_case()) {
1541 case kDexFile: {
1542 if (GetArenaForAllocation() == nullptr) {
1543 delete _impl_.type_specific_msg_.dex_file_;
1544 }
1545 break;
1546 }
1547 case kElfFile: {
1548 if (GetArenaForAllocation() == nullptr) {
1549 delete _impl_.type_specific_msg_.elf_file_;
1550 }
1551 break;
1552 }
1553 case kKernelModule: {
1554 if (GetArenaForAllocation() == nullptr) {
1555 delete _impl_.type_specific_msg_.kernel_module_;
1556 }
1557 break;
1558 }
1559 case TYPE_SPECIFIC_MSG_NOT_SET: {
1560 break;
1561 }
1562 }
1563 _impl_._oneof_case_[0] = TYPE_SPECIFIC_MSG_NOT_SET;
1564 }
1565
1566
Clear()1567 void FileFeature::Clear() {
1568 // @@protoc_insertion_point(message_clear_start:simpleperf.proto.FileFeature)
1569 ::uint32_t cached_has_bits = 0;
1570 // Prevent compiler warnings about cached_has_bits being unused
1571 (void) cached_has_bits;
1572
1573 _impl_.symbol_.Clear();
1574 _impl_.path_.ClearToEmpty();
1575 ::memset(&_impl_.min_vaddr_, 0, static_cast<size_t>(
1576 reinterpret_cast<char*>(&_impl_.type_) -
1577 reinterpret_cast<char*>(&_impl_.min_vaddr_)) + sizeof(_impl_.type_));
1578 clear_type_specific_msg();
1579 _internal_metadata_.Clear<std::string>();
1580 }
1581
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1582 const char* FileFeature::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1583 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1584 while (!ctx->Done(&ptr)) {
1585 ::uint32_t tag;
1586 ptr = ::_pbi::ReadTag(ptr, &tag);
1587 switch (tag >> 3) {
1588 // string path = 1;
1589 case 1:
1590 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1591 auto str = _internal_mutable_path();
1592 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1593 CHK_(ptr);
1594 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1595 } else {
1596 goto handle_unusual;
1597 }
1598 continue;
1599 // uint32 type = 2;
1600 case 2:
1601 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1602 _impl_.type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1603 CHK_(ptr);
1604 } else {
1605 goto handle_unusual;
1606 }
1607 continue;
1608 // uint64 min_vaddr = 3;
1609 case 3:
1610 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1611 _impl_.min_vaddr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1612 CHK_(ptr);
1613 } else {
1614 goto handle_unusual;
1615 }
1616 continue;
1617 // repeated .simpleperf.proto.FileFeature.Symbol symbol = 4;
1618 case 4:
1619 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1620 ptr -= 1;
1621 do {
1622 ptr += 1;
1623 ptr = ctx->ParseMessage(_internal_add_symbol(), ptr);
1624 CHK_(ptr);
1625 if (!ctx->DataAvailable(ptr)) break;
1626 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
1627 } else {
1628 goto handle_unusual;
1629 }
1630 continue;
1631 // .simpleperf.proto.FileFeature.DexFile dex_file = 5;
1632 case 5:
1633 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1634 ptr = ctx->ParseMessage(_internal_mutable_dex_file(), ptr);
1635 CHK_(ptr);
1636 } else {
1637 goto handle_unusual;
1638 }
1639 continue;
1640 // .simpleperf.proto.FileFeature.ElfFile elf_file = 6;
1641 case 6:
1642 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
1643 ptr = ctx->ParseMessage(_internal_mutable_elf_file(), ptr);
1644 CHK_(ptr);
1645 } else {
1646 goto handle_unusual;
1647 }
1648 continue;
1649 // .simpleperf.proto.FileFeature.KernelModule kernel_module = 7;
1650 case 7:
1651 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
1652 ptr = ctx->ParseMessage(_internal_mutable_kernel_module(), ptr);
1653 CHK_(ptr);
1654 } else {
1655 goto handle_unusual;
1656 }
1657 continue;
1658 default:
1659 goto handle_unusual;
1660 } // switch
1661 handle_unusual:
1662 if ((tag == 0) || ((tag & 7) == 4)) {
1663 CHK_(ptr);
1664 ctx->SetLastTag(tag);
1665 goto message_done;
1666 }
1667 ptr = UnknownFieldParse(
1668 tag,
1669 _internal_metadata_.mutable_unknown_fields<std::string>(),
1670 ptr, ctx);
1671 CHK_(ptr != nullptr);
1672 } // while
1673 message_done:
1674 return ptr;
1675 failure:
1676 ptr = nullptr;
1677 goto message_done;
1678 #undef CHK_
1679 }
1680
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1681 ::uint8_t* FileFeature::_InternalSerialize(
1682 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1683 // @@protoc_insertion_point(serialize_to_array_start:simpleperf.proto.FileFeature)
1684 ::uint32_t cached_has_bits = 0;
1685 (void) cached_has_bits;
1686
1687 // string path = 1;
1688 if (!this->_internal_path().empty()) {
1689 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1690 this->_internal_path().data(), static_cast<int>(this->_internal_path().length()),
1691 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1692 "simpleperf.proto.FileFeature.path");
1693 target = stream->WriteStringMaybeAliased(
1694 1, this->_internal_path(), target);
1695 }
1696
1697 // uint32 type = 2;
1698 if (this->_internal_type() != 0) {
1699 target = stream->EnsureSpace(target);
1700 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type(), target);
1701 }
1702
1703 // uint64 min_vaddr = 3;
1704 if (this->_internal_min_vaddr() != 0) {
1705 target = stream->EnsureSpace(target);
1706 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_min_vaddr(), target);
1707 }
1708
1709 // repeated .simpleperf.proto.FileFeature.Symbol symbol = 4;
1710 for (unsigned i = 0,
1711 n = static_cast<unsigned>(this->_internal_symbol_size()); i < n; i++) {
1712 const auto& repfield = this->_internal_symbol(i);
1713 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1714 InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
1715 }
1716
1717 // .simpleperf.proto.FileFeature.DexFile dex_file = 5;
1718 if (_internal_has_dex_file()) {
1719 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1720 InternalWriteMessage(5, _Internal::dex_file(this),
1721 _Internal::dex_file(this).GetCachedSize(), target, stream);
1722 }
1723
1724 // .simpleperf.proto.FileFeature.ElfFile elf_file = 6;
1725 if (_internal_has_elf_file()) {
1726 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1727 InternalWriteMessage(6, _Internal::elf_file(this),
1728 _Internal::elf_file(this).GetCachedSize(), target, stream);
1729 }
1730
1731 // .simpleperf.proto.FileFeature.KernelModule kernel_module = 7;
1732 if (_internal_has_kernel_module()) {
1733 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1734 InternalWriteMessage(7, _Internal::kernel_module(this),
1735 _Internal::kernel_module(this).GetCachedSize(), target, stream);
1736 }
1737
1738 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1739 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1740 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1741 }
1742 // @@protoc_insertion_point(serialize_to_array_end:simpleperf.proto.FileFeature)
1743 return target;
1744 }
1745
ByteSizeLong() const1746 size_t FileFeature::ByteSizeLong() const {
1747 // @@protoc_insertion_point(message_byte_size_start:simpleperf.proto.FileFeature)
1748 size_t total_size = 0;
1749
1750 ::uint32_t cached_has_bits = 0;
1751 // Prevent compiler warnings about cached_has_bits being unused
1752 (void) cached_has_bits;
1753
1754 // repeated .simpleperf.proto.FileFeature.Symbol symbol = 4;
1755 total_size += 1UL * this->_internal_symbol_size();
1756 for (const auto& msg : this->_impl_.symbol_) {
1757 total_size +=
1758 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1759 }
1760
1761 // string path = 1;
1762 if (!this->_internal_path().empty()) {
1763 total_size += 1 +
1764 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1765 this->_internal_path());
1766 }
1767
1768 // uint64 min_vaddr = 3;
1769 if (this->_internal_min_vaddr() != 0) {
1770 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_min_vaddr());
1771 }
1772
1773 // uint32 type = 2;
1774 if (this->_internal_type() != 0) {
1775 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_type());
1776 }
1777
1778 switch (type_specific_msg_case()) {
1779 // .simpleperf.proto.FileFeature.DexFile dex_file = 5;
1780 case kDexFile: {
1781 total_size += 1 +
1782 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1783 *_impl_.type_specific_msg_.dex_file_);
1784 break;
1785 }
1786 // .simpleperf.proto.FileFeature.ElfFile elf_file = 6;
1787 case kElfFile: {
1788 total_size += 1 +
1789 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1790 *_impl_.type_specific_msg_.elf_file_);
1791 break;
1792 }
1793 // .simpleperf.proto.FileFeature.KernelModule kernel_module = 7;
1794 case kKernelModule: {
1795 total_size += 1 +
1796 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1797 *_impl_.type_specific_msg_.kernel_module_);
1798 break;
1799 }
1800 case TYPE_SPECIFIC_MSG_NOT_SET: {
1801 break;
1802 }
1803 }
1804 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1805 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1806 }
1807 int cached_size = ::_pbi::ToCachedSize(total_size);
1808 SetCachedSize(cached_size);
1809 return total_size;
1810 }
1811
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1812 void FileFeature::CheckTypeAndMergeFrom(
1813 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1814 MergeFrom(*::_pbi::DownCast<const FileFeature*>(
1815 &from));
1816 }
1817
MergeFrom(const FileFeature & from)1818 void FileFeature::MergeFrom(const FileFeature& from) {
1819 FileFeature* const _this = this;
1820 // @@protoc_insertion_point(class_specific_merge_from_start:simpleperf.proto.FileFeature)
1821 GOOGLE_DCHECK_NE(&from, _this);
1822 ::uint32_t cached_has_bits = 0;
1823 (void) cached_has_bits;
1824
1825 _this->_impl_.symbol_.MergeFrom(from._impl_.symbol_);
1826 if (!from._internal_path().empty()) {
1827 _this->_internal_set_path(from._internal_path());
1828 }
1829 if (from._internal_min_vaddr() != 0) {
1830 _this->_internal_set_min_vaddr(from._internal_min_vaddr());
1831 }
1832 if (from._internal_type() != 0) {
1833 _this->_internal_set_type(from._internal_type());
1834 }
1835 switch (from.type_specific_msg_case()) {
1836 case kDexFile: {
1837 _this->_internal_mutable_dex_file()->::simpleperf::proto::FileFeature_DexFile::MergeFrom(
1838 from._internal_dex_file());
1839 break;
1840 }
1841 case kElfFile: {
1842 _this->_internal_mutable_elf_file()->::simpleperf::proto::FileFeature_ElfFile::MergeFrom(
1843 from._internal_elf_file());
1844 break;
1845 }
1846 case kKernelModule: {
1847 _this->_internal_mutable_kernel_module()->::simpleperf::proto::FileFeature_KernelModule::MergeFrom(
1848 from._internal_kernel_module());
1849 break;
1850 }
1851 case TYPE_SPECIFIC_MSG_NOT_SET: {
1852 break;
1853 }
1854 }
1855 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1856 }
1857
CopyFrom(const FileFeature & from)1858 void FileFeature::CopyFrom(const FileFeature& from) {
1859 // @@protoc_insertion_point(class_specific_copy_from_start:simpleperf.proto.FileFeature)
1860 if (&from == this) return;
1861 Clear();
1862 MergeFrom(from);
1863 }
1864
IsInitialized() const1865 bool FileFeature::IsInitialized() const {
1866 return true;
1867 }
1868
InternalSwap(FileFeature * other)1869 void FileFeature::InternalSwap(FileFeature* other) {
1870 using std::swap;
1871 auto* lhs_arena = GetArenaForAllocation();
1872 auto* rhs_arena = other->GetArenaForAllocation();
1873 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1874 _impl_.symbol_.InternalSwap(&other->_impl_.symbol_);
1875 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1876 &_impl_.path_, lhs_arena,
1877 &other->_impl_.path_, rhs_arena
1878 );
1879 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1880 PROTOBUF_FIELD_OFFSET(FileFeature, _impl_.type_)
1881 + sizeof(FileFeature::_impl_.type_) // NOLINT
1882 - PROTOBUF_FIELD_OFFSET(FileFeature, _impl_.min_vaddr_)>(
1883 reinterpret_cast<char*>(&_impl_.min_vaddr_),
1884 reinterpret_cast<char*>(&other->_impl_.min_vaddr_));
1885 swap(_impl_.type_specific_msg_, other->_impl_.type_specific_msg_);
1886 swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
1887 }
1888
GetTypeName() const1889 std::string FileFeature::GetTypeName() const {
1890 return "simpleperf.proto.FileFeature";
1891 }
1892
1893
1894 // @@protoc_insertion_point(namespace_scope)
1895 } // namespace proto
1896 } // namespace simpleperf
1897 PROTOBUF_NAMESPACE_OPEN
1898 template<> PROTOBUF_NOINLINE ::simpleperf::proto::DebugUnwindFeature_File*
CreateMaybeMessage(Arena * arena)1899 Arena::CreateMaybeMessage< ::simpleperf::proto::DebugUnwindFeature_File >(Arena* arena) {
1900 return Arena::CreateMessageInternal< ::simpleperf::proto::DebugUnwindFeature_File >(arena);
1901 }
1902 template<> PROTOBUF_NOINLINE ::simpleperf::proto::DebugUnwindFeature*
CreateMaybeMessage(Arena * arena)1903 Arena::CreateMaybeMessage< ::simpleperf::proto::DebugUnwindFeature >(Arena* arena) {
1904 return Arena::CreateMessageInternal< ::simpleperf::proto::DebugUnwindFeature >(arena);
1905 }
1906 template<> PROTOBUF_NOINLINE ::simpleperf::proto::FileFeature_Symbol*
CreateMaybeMessage(Arena * arena)1907 Arena::CreateMaybeMessage< ::simpleperf::proto::FileFeature_Symbol >(Arena* arena) {
1908 return Arena::CreateMessageInternal< ::simpleperf::proto::FileFeature_Symbol >(arena);
1909 }
1910 template<> PROTOBUF_NOINLINE ::simpleperf::proto::FileFeature_DexFile*
CreateMaybeMessage(Arena * arena)1911 Arena::CreateMaybeMessage< ::simpleperf::proto::FileFeature_DexFile >(Arena* arena) {
1912 return Arena::CreateMessageInternal< ::simpleperf::proto::FileFeature_DexFile >(arena);
1913 }
1914 template<> PROTOBUF_NOINLINE ::simpleperf::proto::FileFeature_ElfFile*
CreateMaybeMessage(Arena * arena)1915 Arena::CreateMaybeMessage< ::simpleperf::proto::FileFeature_ElfFile >(Arena* arena) {
1916 return Arena::CreateMessageInternal< ::simpleperf::proto::FileFeature_ElfFile >(arena);
1917 }
1918 template<> PROTOBUF_NOINLINE ::simpleperf::proto::FileFeature_KernelModule*
CreateMaybeMessage(Arena * arena)1919 Arena::CreateMaybeMessage< ::simpleperf::proto::FileFeature_KernelModule >(Arena* arena) {
1920 return Arena::CreateMessageInternal< ::simpleperf::proto::FileFeature_KernelModule >(arena);
1921 }
1922 template<> PROTOBUF_NOINLINE ::simpleperf::proto::FileFeature*
CreateMaybeMessage(Arena * arena)1923 Arena::CreateMaybeMessage< ::simpleperf::proto::FileFeature >(Arena* arena) {
1924 return Arena::CreateMessageInternal< ::simpleperf::proto::FileFeature >(arena);
1925 }
1926 PROTOBUF_NAMESPACE_CLOSE
1927
1928 // @@protoc_insertion_point(global_scope)
1929 #include <google/protobuf/port_undef.inc>
1930