1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/chrome/v8.proto
3 
4 #include "protos/perfetto/trace/chrome/v8.pb.h"
5 
6 #include <algorithm>
7 #include <cstdint>
8 
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15 
16 PROTOBUF_PRAGMA_INIT_SEG
17 
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20 
21 namespace perfetto {
22 namespace protos {
V8String(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR V8String::V8String(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_.encoded_string_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_._oneof_case_)*/{}} {}
28 struct V8StringDefaultTypeInternal {
V8StringDefaultTypeInternalperfetto::protos::V8StringDefaultTypeInternal29   PROTOBUF_CONSTEXPR V8StringDefaultTypeInternal()
30       : _instance(::_pbi::ConstantInitialized{}) {}
~V8StringDefaultTypeInternalperfetto::protos::V8StringDefaultTypeInternal31   ~V8StringDefaultTypeInternal() {}
32   union {  // NOLINT(misc-non-private-member-variables-in-classes)
33     V8String _instance;
34   };
35 };
36 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 V8StringDefaultTypeInternal _V8String_default_instance_;
InternedV8String(::_pbi::ConstantInitialized)37 PROTOBUF_CONSTEXPR InternedV8String::InternedV8String(
38     ::_pbi::ConstantInitialized): _impl_{
39     /*decltype(_impl_._has_bits_)*/{}
40   , /*decltype(_impl_._cached_size_)*/{}
41   , /*decltype(_impl_.iid_)*/::uint64_t{0u}
42   , /*decltype(_impl_.encoded_string_)*/{}
43   , /*decltype(_impl_._oneof_case_)*/{}} {}
44 struct InternedV8StringDefaultTypeInternal {
InternedV8StringDefaultTypeInternalperfetto::protos::InternedV8StringDefaultTypeInternal45   PROTOBUF_CONSTEXPR InternedV8StringDefaultTypeInternal()
46       : _instance(::_pbi::ConstantInitialized{}) {}
~InternedV8StringDefaultTypeInternalperfetto::protos::InternedV8StringDefaultTypeInternal47   ~InternedV8StringDefaultTypeInternal() {}
48   union {  // NOLINT(misc-non-private-member-variables-in-classes)
49     InternedV8String _instance;
50   };
51 };
52 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InternedV8StringDefaultTypeInternal _InternedV8String_default_instance_;
InternedV8JsScript(::_pbi::ConstantInitialized)53 PROTOBUF_CONSTEXPR InternedV8JsScript::InternedV8JsScript(
54     ::_pbi::ConstantInitialized): _impl_{
55     /*decltype(_impl_._has_bits_)*/{}
56   , /*decltype(_impl_._cached_size_)*/{}
57   , /*decltype(_impl_.name_)*/nullptr
58   , /*decltype(_impl_.source_)*/nullptr
59   , /*decltype(_impl_.iid_)*/::uint64_t{0u}
60   , /*decltype(_impl_.script_id_)*/0
61   , /*decltype(_impl_.type_)*/0} {}
62 struct InternedV8JsScriptDefaultTypeInternal {
InternedV8JsScriptDefaultTypeInternalperfetto::protos::InternedV8JsScriptDefaultTypeInternal63   PROTOBUF_CONSTEXPR InternedV8JsScriptDefaultTypeInternal()
64       : _instance(::_pbi::ConstantInitialized{}) {}
~InternedV8JsScriptDefaultTypeInternalperfetto::protos::InternedV8JsScriptDefaultTypeInternal65   ~InternedV8JsScriptDefaultTypeInternal() {}
66   union {  // NOLINT(misc-non-private-member-variables-in-classes)
67     InternedV8JsScript _instance;
68   };
69 };
70 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InternedV8JsScriptDefaultTypeInternal _InternedV8JsScript_default_instance_;
InternedV8WasmScript(::_pbi::ConstantInitialized)71 PROTOBUF_CONSTEXPR InternedV8WasmScript::InternedV8WasmScript(
72     ::_pbi::ConstantInitialized): _impl_{
73     /*decltype(_impl_._has_bits_)*/{}
74   , /*decltype(_impl_._cached_size_)*/{}
75   , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
76   , /*decltype(_impl_.iid_)*/::uint64_t{0u}
77   , /*decltype(_impl_.script_id_)*/0} {}
78 struct InternedV8WasmScriptDefaultTypeInternal {
InternedV8WasmScriptDefaultTypeInternalperfetto::protos::InternedV8WasmScriptDefaultTypeInternal79   PROTOBUF_CONSTEXPR InternedV8WasmScriptDefaultTypeInternal()
80       : _instance(::_pbi::ConstantInitialized{}) {}
~InternedV8WasmScriptDefaultTypeInternalperfetto::protos::InternedV8WasmScriptDefaultTypeInternal81   ~InternedV8WasmScriptDefaultTypeInternal() {}
82   union {  // NOLINT(misc-non-private-member-variables-in-classes)
83     InternedV8WasmScript _instance;
84   };
85 };
86 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InternedV8WasmScriptDefaultTypeInternal _InternedV8WasmScript_default_instance_;
InternedV8JsFunction(::_pbi::ConstantInitialized)87 PROTOBUF_CONSTEXPR InternedV8JsFunction::InternedV8JsFunction(
88     ::_pbi::ConstantInitialized): _impl_{
89     /*decltype(_impl_._has_bits_)*/{}
90   , /*decltype(_impl_._cached_size_)*/{}
91   , /*decltype(_impl_.iid_)*/::uint64_t{0u}
92   , /*decltype(_impl_.v8_js_function_name_iid_)*/::uint64_t{0u}
93   , /*decltype(_impl_.v8_js_script_iid_)*/::uint64_t{0u}
94   , /*decltype(_impl_.is_toplevel_)*/false
95   , /*decltype(_impl_.kind_)*/0
96   , /*decltype(_impl_.byte_offset_)*/0u} {}
97 struct InternedV8JsFunctionDefaultTypeInternal {
InternedV8JsFunctionDefaultTypeInternalperfetto::protos::InternedV8JsFunctionDefaultTypeInternal98   PROTOBUF_CONSTEXPR InternedV8JsFunctionDefaultTypeInternal()
99       : _instance(::_pbi::ConstantInitialized{}) {}
~InternedV8JsFunctionDefaultTypeInternalperfetto::protos::InternedV8JsFunctionDefaultTypeInternal100   ~InternedV8JsFunctionDefaultTypeInternal() {}
101   union {  // NOLINT(misc-non-private-member-variables-in-classes)
102     InternedV8JsFunction _instance;
103   };
104 };
105 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InternedV8JsFunctionDefaultTypeInternal _InternedV8JsFunction_default_instance_;
InternedV8Isolate_CodeRange(::_pbi::ConstantInitialized)106 PROTOBUF_CONSTEXPR InternedV8Isolate_CodeRange::InternedV8Isolate_CodeRange(
107     ::_pbi::ConstantInitialized): _impl_{
108     /*decltype(_impl_._has_bits_)*/{}
109   , /*decltype(_impl_._cached_size_)*/{}
110   , /*decltype(_impl_.base_address_)*/::uint64_t{0u}
111   , /*decltype(_impl_.size_)*/::uint64_t{0u}
112   , /*decltype(_impl_.embedded_blob_code_copy_start_address_)*/::uint64_t{0u}
113   , /*decltype(_impl_.is_process_wide_)*/false} {}
114 struct InternedV8Isolate_CodeRangeDefaultTypeInternal {
InternedV8Isolate_CodeRangeDefaultTypeInternalperfetto::protos::InternedV8Isolate_CodeRangeDefaultTypeInternal115   PROTOBUF_CONSTEXPR InternedV8Isolate_CodeRangeDefaultTypeInternal()
116       : _instance(::_pbi::ConstantInitialized{}) {}
~InternedV8Isolate_CodeRangeDefaultTypeInternalperfetto::protos::InternedV8Isolate_CodeRangeDefaultTypeInternal117   ~InternedV8Isolate_CodeRangeDefaultTypeInternal() {}
118   union {  // NOLINT(misc-non-private-member-variables-in-classes)
119     InternedV8Isolate_CodeRange _instance;
120   };
121 };
122 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InternedV8Isolate_CodeRangeDefaultTypeInternal _InternedV8Isolate_CodeRange_default_instance_;
InternedV8Isolate(::_pbi::ConstantInitialized)123 PROTOBUF_CONSTEXPR InternedV8Isolate::InternedV8Isolate(
124     ::_pbi::ConstantInitialized): _impl_{
125     /*decltype(_impl_._has_bits_)*/{}
126   , /*decltype(_impl_._cached_size_)*/{}
127   , /*decltype(_impl_.code_range_)*/nullptr
128   , /*decltype(_impl_.iid_)*/::uint64_t{0u}
129   , /*decltype(_impl_.pid_)*/0u
130   , /*decltype(_impl_.isolate_id_)*/0
131   , /*decltype(_impl_.embedded_blob_code_start_address_)*/::uint64_t{0u}
132   , /*decltype(_impl_.embedded_blob_code_size_)*/::uint64_t{0u}} {}
133 struct InternedV8IsolateDefaultTypeInternal {
InternedV8IsolateDefaultTypeInternalperfetto::protos::InternedV8IsolateDefaultTypeInternal134   PROTOBUF_CONSTEXPR InternedV8IsolateDefaultTypeInternal()
135       : _instance(::_pbi::ConstantInitialized{}) {}
~InternedV8IsolateDefaultTypeInternalperfetto::protos::InternedV8IsolateDefaultTypeInternal136   ~InternedV8IsolateDefaultTypeInternal() {}
137   union {  // NOLINT(misc-non-private-member-variables-in-classes)
138     InternedV8Isolate _instance;
139   };
140 };
141 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InternedV8IsolateDefaultTypeInternal _InternedV8Isolate_default_instance_;
V8JsCode(::_pbi::ConstantInitialized)142 PROTOBUF_CONSTEXPR V8JsCode::V8JsCode(
143     ::_pbi::ConstantInitialized): _impl_{
144     /*decltype(_impl_._has_bits_)*/{}
145   , /*decltype(_impl_._cached_size_)*/{}
146   , /*decltype(_impl_.v8_isolate_iid_)*/::uint64_t{0u}
147   , /*decltype(_impl_.v8_js_function_iid_)*/::uint64_t{0u}
148   , /*decltype(_impl_.tid_)*/0u
149   , /*decltype(_impl_.tier_)*/0
150   , /*decltype(_impl_.instruction_start_)*/::uint64_t{0u}
151   , /*decltype(_impl_.instruction_size_bytes_)*/::uint64_t{0u}
152   , /*decltype(_impl_.instructions_)*/{}
153   , /*decltype(_impl_._oneof_case_)*/{}} {}
154 struct V8JsCodeDefaultTypeInternal {
V8JsCodeDefaultTypeInternalperfetto::protos::V8JsCodeDefaultTypeInternal155   PROTOBUF_CONSTEXPR V8JsCodeDefaultTypeInternal()
156       : _instance(::_pbi::ConstantInitialized{}) {}
~V8JsCodeDefaultTypeInternalperfetto::protos::V8JsCodeDefaultTypeInternal157   ~V8JsCodeDefaultTypeInternal() {}
158   union {  // NOLINT(misc-non-private-member-variables-in-classes)
159     V8JsCode _instance;
160   };
161 };
162 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 V8JsCodeDefaultTypeInternal _V8JsCode_default_instance_;
V8InternalCode(::_pbi::ConstantInitialized)163 PROTOBUF_CONSTEXPR V8InternalCode::V8InternalCode(
164     ::_pbi::ConstantInitialized): _impl_{
165     /*decltype(_impl_._has_bits_)*/{}
166   , /*decltype(_impl_._cached_size_)*/{}
167   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
168   , /*decltype(_impl_.machine_code_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
169   , /*decltype(_impl_.v8_isolate_iid_)*/::uint64_t{0u}
170   , /*decltype(_impl_.tid_)*/0u
171   , /*decltype(_impl_.type_)*/0
172   , /*decltype(_impl_.instruction_start_)*/::uint64_t{0u}
173   , /*decltype(_impl_.instruction_size_bytes_)*/::uint64_t{0u}
174   , /*decltype(_impl_.builtin_id_)*/0} {}
175 struct V8InternalCodeDefaultTypeInternal {
V8InternalCodeDefaultTypeInternalperfetto::protos::V8InternalCodeDefaultTypeInternal176   PROTOBUF_CONSTEXPR V8InternalCodeDefaultTypeInternal()
177       : _instance(::_pbi::ConstantInitialized{}) {}
~V8InternalCodeDefaultTypeInternalperfetto::protos::V8InternalCodeDefaultTypeInternal178   ~V8InternalCodeDefaultTypeInternal() {}
179   union {  // NOLINT(misc-non-private-member-variables-in-classes)
180     V8InternalCode _instance;
181   };
182 };
183 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 V8InternalCodeDefaultTypeInternal _V8InternalCode_default_instance_;
V8WasmCode(::_pbi::ConstantInitialized)184 PROTOBUF_CONSTEXPR V8WasmCode::V8WasmCode(
185     ::_pbi::ConstantInitialized): _impl_{
186     /*decltype(_impl_._has_bits_)*/{}
187   , /*decltype(_impl_._cached_size_)*/{}
188   , /*decltype(_impl_.function_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
189   , /*decltype(_impl_.machine_code_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
190   , /*decltype(_impl_.v8_isolate_iid_)*/::uint64_t{0u}
191   , /*decltype(_impl_.v8_wasm_script_iid_)*/::uint64_t{0u}
192   , /*decltype(_impl_.tid_)*/0u
193   , /*decltype(_impl_.tier_)*/0
194   , /*decltype(_impl_.instruction_start_)*/::uint64_t{0u}
195   , /*decltype(_impl_.instruction_size_bytes_)*/::uint64_t{0u}
196   , /*decltype(_impl_.code_offset_in_module_)*/0} {}
197 struct V8WasmCodeDefaultTypeInternal {
V8WasmCodeDefaultTypeInternalperfetto::protos::V8WasmCodeDefaultTypeInternal198   PROTOBUF_CONSTEXPR V8WasmCodeDefaultTypeInternal()
199       : _instance(::_pbi::ConstantInitialized{}) {}
~V8WasmCodeDefaultTypeInternalperfetto::protos::V8WasmCodeDefaultTypeInternal200   ~V8WasmCodeDefaultTypeInternal() {}
201   union {  // NOLINT(misc-non-private-member-variables-in-classes)
202     V8WasmCode _instance;
203   };
204 };
205 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 V8WasmCodeDefaultTypeInternal _V8WasmCode_default_instance_;
V8RegExpCode(::_pbi::ConstantInitialized)206 PROTOBUF_CONSTEXPR V8RegExpCode::V8RegExpCode(
207     ::_pbi::ConstantInitialized): _impl_{
208     /*decltype(_impl_._has_bits_)*/{}
209   , /*decltype(_impl_._cached_size_)*/{}
210   , /*decltype(_impl_.machine_code_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
211   , /*decltype(_impl_.pattern_)*/nullptr
212   , /*decltype(_impl_.v8_isolate_iid_)*/::uint64_t{0u}
213   , /*decltype(_impl_.instruction_start_)*/::uint64_t{0u}
214   , /*decltype(_impl_.instruction_size_bytes_)*/::uint64_t{0u}
215   , /*decltype(_impl_.tid_)*/0u} {}
216 struct V8RegExpCodeDefaultTypeInternal {
V8RegExpCodeDefaultTypeInternalperfetto::protos::V8RegExpCodeDefaultTypeInternal217   PROTOBUF_CONSTEXPR V8RegExpCodeDefaultTypeInternal()
218       : _instance(::_pbi::ConstantInitialized{}) {}
~V8RegExpCodeDefaultTypeInternalperfetto::protos::V8RegExpCodeDefaultTypeInternal219   ~V8RegExpCodeDefaultTypeInternal() {}
220   union {  // NOLINT(misc-non-private-member-variables-in-classes)
221     V8RegExpCode _instance;
222   };
223 };
224 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 V8RegExpCodeDefaultTypeInternal _V8RegExpCode_default_instance_;
V8CodeMove(::_pbi::ConstantInitialized)225 PROTOBUF_CONSTEXPR V8CodeMove::V8CodeMove(
226     ::_pbi::ConstantInitialized): _impl_{
227     /*decltype(_impl_._has_bits_)*/{}
228   , /*decltype(_impl_._cached_size_)*/{}
229   , /*decltype(_impl_.isolate_iid_)*/::uint64_t{0u}
230   , /*decltype(_impl_.from_instruction_start_address_)*/::uint64_t{0u}
231   , /*decltype(_impl_.to_instruction_start_address_)*/::uint64_t{0u}
232   , /*decltype(_impl_.instruction_size_bytes_)*/::uint64_t{0u}
233   , /*decltype(_impl_.tid_)*/0u
234   , /*decltype(_impl_.to_instructions_)*/{}
235   , /*decltype(_impl_._oneof_case_)*/{}} {}
236 struct V8CodeMoveDefaultTypeInternal {
V8CodeMoveDefaultTypeInternalperfetto::protos::V8CodeMoveDefaultTypeInternal237   PROTOBUF_CONSTEXPR V8CodeMoveDefaultTypeInternal()
238       : _instance(::_pbi::ConstantInitialized{}) {}
~V8CodeMoveDefaultTypeInternalperfetto::protos::V8CodeMoveDefaultTypeInternal239   ~V8CodeMoveDefaultTypeInternal() {}
240   union {  // NOLINT(misc-non-private-member-variables-in-classes)
241     V8CodeMove _instance;
242   };
243 };
244 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 V8CodeMoveDefaultTypeInternal _V8CodeMove_default_instance_;
V8CodeDefaults(::_pbi::ConstantInitialized)245 PROTOBUF_CONSTEXPR V8CodeDefaults::V8CodeDefaults(
246     ::_pbi::ConstantInitialized): _impl_{
247     /*decltype(_impl_._has_bits_)*/{}
248   , /*decltype(_impl_._cached_size_)*/{}
249   , /*decltype(_impl_.tid_)*/0u} {}
250 struct V8CodeDefaultsDefaultTypeInternal {
V8CodeDefaultsDefaultTypeInternalperfetto::protos::V8CodeDefaultsDefaultTypeInternal251   PROTOBUF_CONSTEXPR V8CodeDefaultsDefaultTypeInternal()
252       : _instance(::_pbi::ConstantInitialized{}) {}
~V8CodeDefaultsDefaultTypeInternalperfetto::protos::V8CodeDefaultsDefaultTypeInternal253   ~V8CodeDefaultsDefaultTypeInternal() {}
254   union {  // NOLINT(misc-non-private-member-variables-in-classes)
255     V8CodeDefaults _instance;
256   };
257 };
258 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 V8CodeDefaultsDefaultTypeInternal _V8CodeDefaults_default_instance_;
259 }  // namespace protos
260 }  // namespace perfetto
261 namespace perfetto {
262 namespace protos {
InternedV8JsScript_Type_IsValid(int value)263 bool InternedV8JsScript_Type_IsValid(int value) {
264   switch (value) {
265     case 0:
266     case 1:
267     case 2:
268     case 3:
269     case 4:
270     case 5:
271     case 6:
272       return true;
273     default:
274       return false;
275   }
276 }
277 
278 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> InternedV8JsScript_Type_strings[7] = {};
279 
280 static const char InternedV8JsScript_Type_names[] =
281   "TYPE_EVAL"
282   "TYPE_EXTENSION"
283   "TYPE_INSPECTOR"
284   "TYPE_MODULE"
285   "TYPE_NATIVE"
286   "TYPE_NORMAL"
287   "TYPE_UNKNOWN";
288 
289 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry InternedV8JsScript_Type_entries[] = {
290   { {InternedV8JsScript_Type_names + 0, 9}, 2 },
291   { {InternedV8JsScript_Type_names + 9, 14}, 5 },
292   { {InternedV8JsScript_Type_names + 23, 14}, 6 },
293   { {InternedV8JsScript_Type_names + 37, 11}, 3 },
294   { {InternedV8JsScript_Type_names + 48, 11}, 4 },
295   { {InternedV8JsScript_Type_names + 59, 11}, 1 },
296   { {InternedV8JsScript_Type_names + 70, 12}, 0 },
297 };
298 
299 static const int InternedV8JsScript_Type_entries_by_number[] = {
300   6, // 0 -> TYPE_UNKNOWN
301   5, // 1 -> TYPE_NORMAL
302   0, // 2 -> TYPE_EVAL
303   3, // 3 -> TYPE_MODULE
304   4, // 4 -> TYPE_NATIVE
305   1, // 5 -> TYPE_EXTENSION
306   2, // 6 -> TYPE_INSPECTOR
307 };
308 
InternedV8JsScript_Type_Name(InternedV8JsScript_Type value)309 const std::string& InternedV8JsScript_Type_Name(
310     InternedV8JsScript_Type value) {
311   static const bool dummy =
312       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
313           InternedV8JsScript_Type_entries,
314           InternedV8JsScript_Type_entries_by_number,
315           7, InternedV8JsScript_Type_strings);
316   (void) dummy;
317   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
318       InternedV8JsScript_Type_entries,
319       InternedV8JsScript_Type_entries_by_number,
320       7, value);
321   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
322                      InternedV8JsScript_Type_strings[idx].get();
323 }
InternedV8JsScript_Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,InternedV8JsScript_Type * value)324 bool InternedV8JsScript_Type_Parse(
325     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InternedV8JsScript_Type* value) {
326   int int_value;
327   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
328       InternedV8JsScript_Type_entries, 7, name, &int_value);
329   if (success) {
330     *value = static_cast<InternedV8JsScript_Type>(int_value);
331   }
332   return success;
333 }
334 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
335 constexpr InternedV8JsScript_Type InternedV8JsScript::TYPE_UNKNOWN;
336 constexpr InternedV8JsScript_Type InternedV8JsScript::TYPE_NORMAL;
337 constexpr InternedV8JsScript_Type InternedV8JsScript::TYPE_EVAL;
338 constexpr InternedV8JsScript_Type InternedV8JsScript::TYPE_MODULE;
339 constexpr InternedV8JsScript_Type InternedV8JsScript::TYPE_NATIVE;
340 constexpr InternedV8JsScript_Type InternedV8JsScript::TYPE_EXTENSION;
341 constexpr InternedV8JsScript_Type InternedV8JsScript::TYPE_INSPECTOR;
342 constexpr InternedV8JsScript_Type InternedV8JsScript::Type_MIN;
343 constexpr InternedV8JsScript_Type InternedV8JsScript::Type_MAX;
344 constexpr int InternedV8JsScript::Type_ARRAYSIZE;
345 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
InternedV8JsFunction_Kind_IsValid(int value)346 bool InternedV8JsFunction_Kind_IsValid(int value) {
347   switch (value) {
348     case 0:
349     case 1:
350     case 2:
351     case 3:
352     case 4:
353     case 5:
354     case 6:
355     case 7:
356     case 8:
357     case 9:
358     case 10:
359     case 11:
360     case 12:
361     case 13:
362     case 14:
363     case 15:
364     case 16:
365     case 17:
366     case 18:
367     case 19:
368     case 20:
369     case 21:
370     case 22:
371     case 23:
372     case 24:
373     case 25:
374     case 26:
375     case 27:
376       return true;
377     default:
378       return false;
379   }
380 }
381 
382 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> InternedV8JsFunction_Kind_strings[28] = {};
383 
384 static const char InternedV8JsFunction_Kind_names[] =
385   "KIND_ARROW_FUNCTION"
386   "KIND_ASYNC_ARROW_FUNCTION"
387   "KIND_ASYNC_CONCISE_GENERATOR_METHOD"
388   "KIND_ASYNC_CONCISE_METHOD"
389   "KIND_ASYNC_FUNCTION"
390   "KIND_ASYNC_GENERATOR_FUNCTION"
391   "KIND_ASYNC_MODULE"
392   "KIND_BASE_CONSTRUCTOR"
393   "KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION"
394   "KIND_CLASS_STATIC_INITIALIZER_FUNCTION"
395   "KIND_CONCISE_GENERATOR_METHOD"
396   "KIND_CONCISE_METHOD"
397   "KIND_DEFAULT_BASE_CONSTRUCTOR"
398   "KIND_DEFAULT_DERIVED_CONSTRUCTOR"
399   "KIND_DERIVED_CONSTRUCTOR"
400   "KIND_GENERATOR_FUNCTION"
401   "KIND_GETTER_FUNCTION"
402   "KIND_INVALID"
403   "KIND_MODULE"
404   "KIND_NORMAL_FUNCTION"
405   "KIND_SETTER_FUNCTION"
406   "KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD"
407   "KIND_STATIC_ASYNC_CONCISE_METHOD"
408   "KIND_STATIC_CONCISE_GENERATOR_METHOD"
409   "KIND_STATIC_CONCISE_METHOD"
410   "KIND_STATIC_GETTER_FUNCTION"
411   "KIND_STATIC_SETTER_FUNCTION"
412   "KIND_UNKNOWN";
413 
414 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry InternedV8JsFunction_Kind_entries[] = {
415   { {InternedV8JsFunction_Kind_names + 0, 19}, 12 },
416   { {InternedV8JsFunction_Kind_names + 19, 25}, 13 },
417   { {InternedV8JsFunction_Kind_names + 44, 35}, 17 },
418   { {InternedV8JsFunction_Kind_names + 79, 25}, 15 },
419   { {InternedV8JsFunction_Kind_names + 104, 19}, 14 },
420   { {InternedV8JsFunction_Kind_names + 123, 29}, 19 },
421   { {InternedV8JsFunction_Kind_names + 152, 17}, 3 },
422   { {InternedV8JsFunction_Kind_names + 169, 21}, 4 },
423   { {InternedV8JsFunction_Kind_names + 190, 39}, 25 },
424   { {InternedV8JsFunction_Kind_names + 229, 38}, 26 },
425   { {InternedV8JsFunction_Kind_names + 267, 29}, 21 },
426   { {InternedV8JsFunction_Kind_names + 296, 19}, 23 },
427   { {InternedV8JsFunction_Kind_names + 315, 29}, 5 },
428   { {InternedV8JsFunction_Kind_names + 344, 32}, 6 },
429   { {InternedV8JsFunction_Kind_names + 376, 24}, 7 },
430   { {InternedV8JsFunction_Kind_names + 400, 23}, 20 },
431   { {InternedV8JsFunction_Kind_names + 423, 20}, 8 },
432   { {InternedV8JsFunction_Kind_names + 443, 12}, 27 },
433   { {InternedV8JsFunction_Kind_names + 455, 11}, 2 },
434   { {InternedV8JsFunction_Kind_names + 466, 20}, 1 },
435   { {InternedV8JsFunction_Kind_names + 486, 20}, 10 },
436   { {InternedV8JsFunction_Kind_names + 506, 42}, 18 },
437   { {InternedV8JsFunction_Kind_names + 548, 32}, 16 },
438   { {InternedV8JsFunction_Kind_names + 580, 36}, 22 },
439   { {InternedV8JsFunction_Kind_names + 616, 26}, 24 },
440   { {InternedV8JsFunction_Kind_names + 642, 27}, 9 },
441   { {InternedV8JsFunction_Kind_names + 669, 27}, 11 },
442   { {InternedV8JsFunction_Kind_names + 696, 12}, 0 },
443 };
444 
445 static const int InternedV8JsFunction_Kind_entries_by_number[] = {
446   27, // 0 -> KIND_UNKNOWN
447   19, // 1 -> KIND_NORMAL_FUNCTION
448   18, // 2 -> KIND_MODULE
449   6, // 3 -> KIND_ASYNC_MODULE
450   7, // 4 -> KIND_BASE_CONSTRUCTOR
451   12, // 5 -> KIND_DEFAULT_BASE_CONSTRUCTOR
452   13, // 6 -> KIND_DEFAULT_DERIVED_CONSTRUCTOR
453   14, // 7 -> KIND_DERIVED_CONSTRUCTOR
454   16, // 8 -> KIND_GETTER_FUNCTION
455   25, // 9 -> KIND_STATIC_GETTER_FUNCTION
456   20, // 10 -> KIND_SETTER_FUNCTION
457   26, // 11 -> KIND_STATIC_SETTER_FUNCTION
458   0, // 12 -> KIND_ARROW_FUNCTION
459   1, // 13 -> KIND_ASYNC_ARROW_FUNCTION
460   4, // 14 -> KIND_ASYNC_FUNCTION
461   3, // 15 -> KIND_ASYNC_CONCISE_METHOD
462   22, // 16 -> KIND_STATIC_ASYNC_CONCISE_METHOD
463   2, // 17 -> KIND_ASYNC_CONCISE_GENERATOR_METHOD
464   21, // 18 -> KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD
465   5, // 19 -> KIND_ASYNC_GENERATOR_FUNCTION
466   15, // 20 -> KIND_GENERATOR_FUNCTION
467   10, // 21 -> KIND_CONCISE_GENERATOR_METHOD
468   23, // 22 -> KIND_STATIC_CONCISE_GENERATOR_METHOD
469   11, // 23 -> KIND_CONCISE_METHOD
470   24, // 24 -> KIND_STATIC_CONCISE_METHOD
471   8, // 25 -> KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION
472   9, // 26 -> KIND_CLASS_STATIC_INITIALIZER_FUNCTION
473   17, // 27 -> KIND_INVALID
474 };
475 
InternedV8JsFunction_Kind_Name(InternedV8JsFunction_Kind value)476 const std::string& InternedV8JsFunction_Kind_Name(
477     InternedV8JsFunction_Kind value) {
478   static const bool dummy =
479       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
480           InternedV8JsFunction_Kind_entries,
481           InternedV8JsFunction_Kind_entries_by_number,
482           28, InternedV8JsFunction_Kind_strings);
483   (void) dummy;
484   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
485       InternedV8JsFunction_Kind_entries,
486       InternedV8JsFunction_Kind_entries_by_number,
487       28, value);
488   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
489                      InternedV8JsFunction_Kind_strings[idx].get();
490 }
InternedV8JsFunction_Kind_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,InternedV8JsFunction_Kind * value)491 bool InternedV8JsFunction_Kind_Parse(
492     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InternedV8JsFunction_Kind* value) {
493   int int_value;
494   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
495       InternedV8JsFunction_Kind_entries, 28, name, &int_value);
496   if (success) {
497     *value = static_cast<InternedV8JsFunction_Kind>(int_value);
498   }
499   return success;
500 }
501 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
502 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_UNKNOWN;
503 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_NORMAL_FUNCTION;
504 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_MODULE;
505 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_ASYNC_MODULE;
506 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_BASE_CONSTRUCTOR;
507 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_DEFAULT_BASE_CONSTRUCTOR;
508 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_DEFAULT_DERIVED_CONSTRUCTOR;
509 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_DERIVED_CONSTRUCTOR;
510 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_GETTER_FUNCTION;
511 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_STATIC_GETTER_FUNCTION;
512 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_SETTER_FUNCTION;
513 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_STATIC_SETTER_FUNCTION;
514 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_ARROW_FUNCTION;
515 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_ASYNC_ARROW_FUNCTION;
516 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_ASYNC_FUNCTION;
517 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_ASYNC_CONCISE_METHOD;
518 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_STATIC_ASYNC_CONCISE_METHOD;
519 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_ASYNC_CONCISE_GENERATOR_METHOD;
520 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD;
521 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_ASYNC_GENERATOR_FUNCTION;
522 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_GENERATOR_FUNCTION;
523 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_CONCISE_GENERATOR_METHOD;
524 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_STATIC_CONCISE_GENERATOR_METHOD;
525 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_CONCISE_METHOD;
526 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_STATIC_CONCISE_METHOD;
527 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION;
528 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_CLASS_STATIC_INITIALIZER_FUNCTION;
529 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_INVALID;
530 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::Kind_MIN;
531 constexpr InternedV8JsFunction_Kind InternedV8JsFunction::Kind_MAX;
532 constexpr int InternedV8JsFunction::Kind_ARRAYSIZE;
533 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
V8JsCode_Tier_IsValid(int value)534 bool V8JsCode_Tier_IsValid(int value) {
535   switch (value) {
536     case 0:
537     case 1:
538     case 2:
539     case 3:
540     case 4:
541     case 5:
542       return true;
543     default:
544       return false;
545   }
546 }
547 
548 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> V8JsCode_Tier_strings[6] = {};
549 
550 static const char V8JsCode_Tier_names[] =
551   "TIER_IGNITION"
552   "TIER_MAGLEV"
553   "TIER_SPARKPLUG"
554   "TIER_TURBOFAN"
555   "TIER_TURBOSHAFT"
556   "TIER_UNKNOWN";
557 
558 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry V8JsCode_Tier_entries[] = {
559   { {V8JsCode_Tier_names + 0, 13}, 1 },
560   { {V8JsCode_Tier_names + 13, 11}, 3 },
561   { {V8JsCode_Tier_names + 24, 14}, 2 },
562   { {V8JsCode_Tier_names + 38, 13}, 5 },
563   { {V8JsCode_Tier_names + 51, 15}, 4 },
564   { {V8JsCode_Tier_names + 66, 12}, 0 },
565 };
566 
567 static const int V8JsCode_Tier_entries_by_number[] = {
568   5, // 0 -> TIER_UNKNOWN
569   0, // 1 -> TIER_IGNITION
570   2, // 2 -> TIER_SPARKPLUG
571   1, // 3 -> TIER_MAGLEV
572   4, // 4 -> TIER_TURBOSHAFT
573   3, // 5 -> TIER_TURBOFAN
574 };
575 
V8JsCode_Tier_Name(V8JsCode_Tier value)576 const std::string& V8JsCode_Tier_Name(
577     V8JsCode_Tier value) {
578   static const bool dummy =
579       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
580           V8JsCode_Tier_entries,
581           V8JsCode_Tier_entries_by_number,
582           6, V8JsCode_Tier_strings);
583   (void) dummy;
584   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
585       V8JsCode_Tier_entries,
586       V8JsCode_Tier_entries_by_number,
587       6, value);
588   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
589                      V8JsCode_Tier_strings[idx].get();
590 }
V8JsCode_Tier_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,V8JsCode_Tier * value)591 bool V8JsCode_Tier_Parse(
592     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V8JsCode_Tier* value) {
593   int int_value;
594   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
595       V8JsCode_Tier_entries, 6, name, &int_value);
596   if (success) {
597     *value = static_cast<V8JsCode_Tier>(int_value);
598   }
599   return success;
600 }
601 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
602 constexpr V8JsCode_Tier V8JsCode::TIER_UNKNOWN;
603 constexpr V8JsCode_Tier V8JsCode::TIER_IGNITION;
604 constexpr V8JsCode_Tier V8JsCode::TIER_SPARKPLUG;
605 constexpr V8JsCode_Tier V8JsCode::TIER_MAGLEV;
606 constexpr V8JsCode_Tier V8JsCode::TIER_TURBOSHAFT;
607 constexpr V8JsCode_Tier V8JsCode::TIER_TURBOFAN;
608 constexpr V8JsCode_Tier V8JsCode::Tier_MIN;
609 constexpr V8JsCode_Tier V8JsCode::Tier_MAX;
610 constexpr int V8JsCode::Tier_ARRAYSIZE;
611 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
V8InternalCode_Type_IsValid(int value)612 bool V8InternalCode_Type_IsValid(int value) {
613   switch (value) {
614     case 0:
615     case 1:
616     case 2:
617     case 3:
618     case 4:
619     case 5:
620     case 6:
621     case 7:
622     case 8:
623     case 9:
624       return true;
625     default:
626       return false;
627   }
628 }
629 
630 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> V8InternalCode_Type_strings[10] = {};
631 
632 static const char V8InternalCode_Type_names[] =
633   "TYPE_BUILTIN"
634   "TYPE_BYTECODE_HANDLER"
635   "TYPE_C_WASM_ENTRY"
636   "TYPE_FOR_TESTING"
637   "TYPE_JS_TO_JS_FUNCTION"
638   "TYPE_JS_TO_WASM_FUNCTION"
639   "TYPE_UNKNOWN"
640   "TYPE_WASM_FUNCTION"
641   "TYPE_WASM_TO_CAPI_FUNCTION"
642   "TYPE_WASM_TO_JS_FUNCTION";
643 
644 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry V8InternalCode_Type_entries[] = {
645   { {V8InternalCode_Type_names + 0, 12}, 3 },
646   { {V8InternalCode_Type_names + 12, 21}, 1 },
647   { {V8InternalCode_Type_names + 33, 17}, 9 },
648   { {V8InternalCode_Type_names + 50, 16}, 2 },
649   { {V8InternalCode_Type_names + 66, 22}, 8 },
650   { {V8InternalCode_Type_names + 88, 24}, 7 },
651   { {V8InternalCode_Type_names + 112, 12}, 0 },
652   { {V8InternalCode_Type_names + 124, 18}, 4 },
653   { {V8InternalCode_Type_names + 142, 26}, 5 },
654   { {V8InternalCode_Type_names + 168, 24}, 6 },
655 };
656 
657 static const int V8InternalCode_Type_entries_by_number[] = {
658   6, // 0 -> TYPE_UNKNOWN
659   1, // 1 -> TYPE_BYTECODE_HANDLER
660   3, // 2 -> TYPE_FOR_TESTING
661   0, // 3 -> TYPE_BUILTIN
662   7, // 4 -> TYPE_WASM_FUNCTION
663   8, // 5 -> TYPE_WASM_TO_CAPI_FUNCTION
664   9, // 6 -> TYPE_WASM_TO_JS_FUNCTION
665   5, // 7 -> TYPE_JS_TO_WASM_FUNCTION
666   4, // 8 -> TYPE_JS_TO_JS_FUNCTION
667   2, // 9 -> TYPE_C_WASM_ENTRY
668 };
669 
V8InternalCode_Type_Name(V8InternalCode_Type value)670 const std::string& V8InternalCode_Type_Name(
671     V8InternalCode_Type value) {
672   static const bool dummy =
673       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
674           V8InternalCode_Type_entries,
675           V8InternalCode_Type_entries_by_number,
676           10, V8InternalCode_Type_strings);
677   (void) dummy;
678   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
679       V8InternalCode_Type_entries,
680       V8InternalCode_Type_entries_by_number,
681       10, value);
682   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
683                      V8InternalCode_Type_strings[idx].get();
684 }
V8InternalCode_Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,V8InternalCode_Type * value)685 bool V8InternalCode_Type_Parse(
686     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V8InternalCode_Type* value) {
687   int int_value;
688   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
689       V8InternalCode_Type_entries, 10, name, &int_value);
690   if (success) {
691     *value = static_cast<V8InternalCode_Type>(int_value);
692   }
693   return success;
694 }
695 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
696 constexpr V8InternalCode_Type V8InternalCode::TYPE_UNKNOWN;
697 constexpr V8InternalCode_Type V8InternalCode::TYPE_BYTECODE_HANDLER;
698 constexpr V8InternalCode_Type V8InternalCode::TYPE_FOR_TESTING;
699 constexpr V8InternalCode_Type V8InternalCode::TYPE_BUILTIN;
700 constexpr V8InternalCode_Type V8InternalCode::TYPE_WASM_FUNCTION;
701 constexpr V8InternalCode_Type V8InternalCode::TYPE_WASM_TO_CAPI_FUNCTION;
702 constexpr V8InternalCode_Type V8InternalCode::TYPE_WASM_TO_JS_FUNCTION;
703 constexpr V8InternalCode_Type V8InternalCode::TYPE_JS_TO_WASM_FUNCTION;
704 constexpr V8InternalCode_Type V8InternalCode::TYPE_JS_TO_JS_FUNCTION;
705 constexpr V8InternalCode_Type V8InternalCode::TYPE_C_WASM_ENTRY;
706 constexpr V8InternalCode_Type V8InternalCode::Type_MIN;
707 constexpr V8InternalCode_Type V8InternalCode::Type_MAX;
708 constexpr int V8InternalCode::Type_ARRAYSIZE;
709 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
V8WasmCode_Tier_IsValid(int value)710 bool V8WasmCode_Tier_IsValid(int value) {
711   switch (value) {
712     case 0:
713     case 1:
714     case 2:
715       return true;
716     default:
717       return false;
718   }
719 }
720 
721 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> V8WasmCode_Tier_strings[3] = {};
722 
723 static const char V8WasmCode_Tier_names[] =
724   "TIER_LIFTOFF"
725   "TIER_TURBOFAN"
726   "TIER_UNKNOWN";
727 
728 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry V8WasmCode_Tier_entries[] = {
729   { {V8WasmCode_Tier_names + 0, 12}, 1 },
730   { {V8WasmCode_Tier_names + 12, 13}, 2 },
731   { {V8WasmCode_Tier_names + 25, 12}, 0 },
732 };
733 
734 static const int V8WasmCode_Tier_entries_by_number[] = {
735   2, // 0 -> TIER_UNKNOWN
736   0, // 1 -> TIER_LIFTOFF
737   1, // 2 -> TIER_TURBOFAN
738 };
739 
V8WasmCode_Tier_Name(V8WasmCode_Tier value)740 const std::string& V8WasmCode_Tier_Name(
741     V8WasmCode_Tier value) {
742   static const bool dummy =
743       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
744           V8WasmCode_Tier_entries,
745           V8WasmCode_Tier_entries_by_number,
746           3, V8WasmCode_Tier_strings);
747   (void) dummy;
748   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
749       V8WasmCode_Tier_entries,
750       V8WasmCode_Tier_entries_by_number,
751       3, value);
752   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
753                      V8WasmCode_Tier_strings[idx].get();
754 }
V8WasmCode_Tier_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,V8WasmCode_Tier * value)755 bool V8WasmCode_Tier_Parse(
756     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V8WasmCode_Tier* value) {
757   int int_value;
758   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
759       V8WasmCode_Tier_entries, 3, name, &int_value);
760   if (success) {
761     *value = static_cast<V8WasmCode_Tier>(int_value);
762   }
763   return success;
764 }
765 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
766 constexpr V8WasmCode_Tier V8WasmCode::TIER_UNKNOWN;
767 constexpr V8WasmCode_Tier V8WasmCode::TIER_LIFTOFF;
768 constexpr V8WasmCode_Tier V8WasmCode::TIER_TURBOFAN;
769 constexpr V8WasmCode_Tier V8WasmCode::Tier_MIN;
770 constexpr V8WasmCode_Tier V8WasmCode::Tier_MAX;
771 constexpr int V8WasmCode::Tier_ARRAYSIZE;
772 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
773 
774 // ===================================================================
775 
776 class V8String::_Internal {
777  public:
778 };
779 
V8String(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)780 V8String::V8String(::PROTOBUF_NAMESPACE_ID::Arena* arena,
781                          bool is_message_owned)
782   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
783   SharedCtor(arena, is_message_owned);
784   // @@protoc_insertion_point(arena_constructor:perfetto.protos.V8String)
785 }
V8String(const V8String & from)786 V8String::V8String(const V8String& from)
787   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
788   V8String* const _this = this; (void)_this;
789   new (&_impl_) Impl_{
790       decltype(_impl_.encoded_string_){}
791     , /*decltype(_impl_._cached_size_)*/{}
792     , /*decltype(_impl_._oneof_case_)*/{}};
793 
794   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
795   clear_has_encoded_string();
796   switch (from.encoded_string_case()) {
797     case kLatin1: {
798       _this->_internal_set_latin1(from._internal_latin1());
799       break;
800     }
801     case kUtf16Le: {
802       _this->_internal_set_utf16_le(from._internal_utf16_le());
803       break;
804     }
805     case kUtf16Be: {
806       _this->_internal_set_utf16_be(from._internal_utf16_be());
807       break;
808     }
809     case ENCODED_STRING_NOT_SET: {
810       break;
811     }
812   }
813   // @@protoc_insertion_point(copy_constructor:perfetto.protos.V8String)
814 }
815 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)816 inline void V8String::SharedCtor(
817     ::_pb::Arena* arena, bool is_message_owned) {
818   (void)arena;
819   (void)is_message_owned;
820   new (&_impl_) Impl_{
821       decltype(_impl_.encoded_string_){}
822     , /*decltype(_impl_._cached_size_)*/{}
823     , /*decltype(_impl_._oneof_case_)*/{}
824   };
825   clear_has_encoded_string();
826 }
827 
~V8String()828 V8String::~V8String() {
829   // @@protoc_insertion_point(destructor:perfetto.protos.V8String)
830   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
831   (void)arena;
832     return;
833   }
834   SharedDtor();
835 }
836 
SharedDtor()837 inline void V8String::SharedDtor() {
838   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
839   if (has_encoded_string()) {
840     clear_encoded_string();
841   }
842 }
843 
SetCachedSize(int size) const844 void V8String::SetCachedSize(int size) const {
845   _impl_._cached_size_.Set(size);
846 }
847 
clear_encoded_string()848 void V8String::clear_encoded_string() {
849 // @@protoc_insertion_point(one_of_clear_start:perfetto.protos.V8String)
850   switch (encoded_string_case()) {
851     case kLatin1: {
852       _impl_.encoded_string_.latin1_.Destroy();
853       break;
854     }
855     case kUtf16Le: {
856       _impl_.encoded_string_.utf16_le_.Destroy();
857       break;
858     }
859     case kUtf16Be: {
860       _impl_.encoded_string_.utf16_be_.Destroy();
861       break;
862     }
863     case ENCODED_STRING_NOT_SET: {
864       break;
865     }
866   }
867   _impl_._oneof_case_[0] = ENCODED_STRING_NOT_SET;
868 }
869 
870 
Clear()871 void V8String::Clear() {
872 // @@protoc_insertion_point(message_clear_start:perfetto.protos.V8String)
873   ::uint32_t cached_has_bits = 0;
874   // Prevent compiler warnings about cached_has_bits being unused
875   (void) cached_has_bits;
876 
877   clear_encoded_string();
878   _internal_metadata_.Clear<std::string>();
879 }
880 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)881 const char* V8String::_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       // bytes latin1 = 1;
888       case 1:
889         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
890           auto str = _internal_mutable_latin1();
891           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
892           CHK_(ptr);
893         } else {
894           goto handle_unusual;
895         }
896         continue;
897       // bytes utf16_le = 2;
898       case 2:
899         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
900           auto str = _internal_mutable_utf16_le();
901           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
902           CHK_(ptr);
903         } else {
904           goto handle_unusual;
905         }
906         continue;
907       // bytes utf16_be = 3;
908       case 3:
909         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
910           auto str = _internal_mutable_utf16_be();
911           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
912           CHK_(ptr);
913         } else {
914           goto handle_unusual;
915         }
916         continue;
917       default:
918         goto handle_unusual;
919     }  // switch
920   handle_unusual:
921     if ((tag == 0) || ((tag & 7) == 4)) {
922       CHK_(ptr);
923       ctx->SetLastTag(tag);
924       goto message_done;
925     }
926     ptr = UnknownFieldParse(
927         tag,
928         _internal_metadata_.mutable_unknown_fields<std::string>(),
929         ptr, ctx);
930     CHK_(ptr != nullptr);
931   }  // while
932 message_done:
933   return ptr;
934 failure:
935   ptr = nullptr;
936   goto message_done;
937 #undef CHK_
938 }
939 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const940 ::uint8_t* V8String::_InternalSerialize(
941     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
942   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.V8String)
943   ::uint32_t cached_has_bits = 0;
944   (void) cached_has_bits;
945 
946   switch (encoded_string_case()) {
947     case kLatin1: {
948       target = stream->WriteBytesMaybeAliased(
949           1, this->_internal_latin1(), target);
950       break;
951     }
952     case kUtf16Le: {
953       target = stream->WriteBytesMaybeAliased(
954           2, this->_internal_utf16_le(), target);
955       break;
956     }
957     case kUtf16Be: {
958       target = stream->WriteBytesMaybeAliased(
959           3, this->_internal_utf16_be(), target);
960       break;
961     }
962     default: ;
963   }
964   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
965     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
966         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
967   }
968   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.V8String)
969   return target;
970 }
971 
ByteSizeLong() const972 size_t V8String::ByteSizeLong() const {
973 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.V8String)
974   size_t total_size = 0;
975 
976   switch (encoded_string_case()) {
977     // bytes latin1 = 1;
978     case kLatin1: {
979       total_size += 1 +
980         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
981           this->_internal_latin1());
982       break;
983     }
984     // bytes utf16_le = 2;
985     case kUtf16Le: {
986       total_size += 1 +
987         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
988           this->_internal_utf16_le());
989       break;
990     }
991     // bytes utf16_be = 3;
992     case kUtf16Be: {
993       total_size += 1 +
994         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
995           this->_internal_utf16_be());
996       break;
997     }
998     case ENCODED_STRING_NOT_SET: {
999       break;
1000     }
1001   }
1002   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1003     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1004   }
1005   int cached_size = ::_pbi::ToCachedSize(total_size);
1006   SetCachedSize(cached_size);
1007   return total_size;
1008 }
1009 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1010 void V8String::CheckTypeAndMergeFrom(
1011     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1012   MergeFrom(*::_pbi::DownCast<const V8String*>(
1013       &from));
1014 }
1015 
MergeFrom(const V8String & from)1016 void V8String::MergeFrom(const V8String& from) {
1017   V8String* const _this = this;
1018   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.V8String)
1019   GOOGLE_DCHECK_NE(&from, _this);
1020   ::uint32_t cached_has_bits = 0;
1021   (void) cached_has_bits;
1022 
1023   switch (from.encoded_string_case()) {
1024     case kLatin1: {
1025       _this->_internal_set_latin1(from._internal_latin1());
1026       break;
1027     }
1028     case kUtf16Le: {
1029       _this->_internal_set_utf16_le(from._internal_utf16_le());
1030       break;
1031     }
1032     case kUtf16Be: {
1033       _this->_internal_set_utf16_be(from._internal_utf16_be());
1034       break;
1035     }
1036     case ENCODED_STRING_NOT_SET: {
1037       break;
1038     }
1039   }
1040   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1041 }
1042 
CopyFrom(const V8String & from)1043 void V8String::CopyFrom(const V8String& from) {
1044 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.V8String)
1045   if (&from == this) return;
1046   Clear();
1047   MergeFrom(from);
1048 }
1049 
IsInitialized() const1050 bool V8String::IsInitialized() const {
1051   return true;
1052 }
1053 
InternalSwap(V8String * other)1054 void V8String::InternalSwap(V8String* other) {
1055   using std::swap;
1056   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1057   swap(_impl_.encoded_string_, other->_impl_.encoded_string_);
1058   swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
1059 }
1060 
GetTypeName() const1061 std::string V8String::GetTypeName() const {
1062   return "perfetto.protos.V8String";
1063 }
1064 
1065 
1066 // ===================================================================
1067 
1068 class InternedV8String::_Internal {
1069  public:
1070   using HasBits = decltype(std::declval<InternedV8String>()._impl_._has_bits_);
set_has_iid(HasBits * has_bits)1071   static void set_has_iid(HasBits* has_bits) {
1072     (*has_bits)[0] |= 1u;
1073   }
1074 };
1075 
InternedV8String(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1076 InternedV8String::InternedV8String(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1077                          bool is_message_owned)
1078   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1079   SharedCtor(arena, is_message_owned);
1080   // @@protoc_insertion_point(arena_constructor:perfetto.protos.InternedV8String)
1081 }
InternedV8String(const InternedV8String & from)1082 InternedV8String::InternedV8String(const InternedV8String& from)
1083   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1084   InternedV8String* const _this = this; (void)_this;
1085   new (&_impl_) Impl_{
1086       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1087     , /*decltype(_impl_._cached_size_)*/{}
1088     , decltype(_impl_.iid_){}
1089     , decltype(_impl_.encoded_string_){}
1090     , /*decltype(_impl_._oneof_case_)*/{}};
1091 
1092   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1093   _this->_impl_.iid_ = from._impl_.iid_;
1094   clear_has_encoded_string();
1095   switch (from.encoded_string_case()) {
1096     case kLatin1: {
1097       _this->_internal_set_latin1(from._internal_latin1());
1098       break;
1099     }
1100     case kUtf16Le: {
1101       _this->_internal_set_utf16_le(from._internal_utf16_le());
1102       break;
1103     }
1104     case kUtf16Be: {
1105       _this->_internal_set_utf16_be(from._internal_utf16_be());
1106       break;
1107     }
1108     case ENCODED_STRING_NOT_SET: {
1109       break;
1110     }
1111   }
1112   // @@protoc_insertion_point(copy_constructor:perfetto.protos.InternedV8String)
1113 }
1114 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1115 inline void InternedV8String::SharedCtor(
1116     ::_pb::Arena* arena, bool is_message_owned) {
1117   (void)arena;
1118   (void)is_message_owned;
1119   new (&_impl_) Impl_{
1120       decltype(_impl_._has_bits_){}
1121     , /*decltype(_impl_._cached_size_)*/{}
1122     , decltype(_impl_.iid_){::uint64_t{0u}}
1123     , decltype(_impl_.encoded_string_){}
1124     , /*decltype(_impl_._oneof_case_)*/{}
1125   };
1126   clear_has_encoded_string();
1127 }
1128 
~InternedV8String()1129 InternedV8String::~InternedV8String() {
1130   // @@protoc_insertion_point(destructor:perfetto.protos.InternedV8String)
1131   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1132   (void)arena;
1133     return;
1134   }
1135   SharedDtor();
1136 }
1137 
SharedDtor()1138 inline void InternedV8String::SharedDtor() {
1139   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1140   if (has_encoded_string()) {
1141     clear_encoded_string();
1142   }
1143 }
1144 
SetCachedSize(int size) const1145 void InternedV8String::SetCachedSize(int size) const {
1146   _impl_._cached_size_.Set(size);
1147 }
1148 
clear_encoded_string()1149 void InternedV8String::clear_encoded_string() {
1150 // @@protoc_insertion_point(one_of_clear_start:perfetto.protos.InternedV8String)
1151   switch (encoded_string_case()) {
1152     case kLatin1: {
1153       _impl_.encoded_string_.latin1_.Destroy();
1154       break;
1155     }
1156     case kUtf16Le: {
1157       _impl_.encoded_string_.utf16_le_.Destroy();
1158       break;
1159     }
1160     case kUtf16Be: {
1161       _impl_.encoded_string_.utf16_be_.Destroy();
1162       break;
1163     }
1164     case ENCODED_STRING_NOT_SET: {
1165       break;
1166     }
1167   }
1168   _impl_._oneof_case_[0] = ENCODED_STRING_NOT_SET;
1169 }
1170 
1171 
Clear()1172 void InternedV8String::Clear() {
1173 // @@protoc_insertion_point(message_clear_start:perfetto.protos.InternedV8String)
1174   ::uint32_t cached_has_bits = 0;
1175   // Prevent compiler warnings about cached_has_bits being unused
1176   (void) cached_has_bits;
1177 
1178   _impl_.iid_ = ::uint64_t{0u};
1179   clear_encoded_string();
1180   _impl_._has_bits_.Clear();
1181   _internal_metadata_.Clear<std::string>();
1182 }
1183 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1184 const char* InternedV8String::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1185 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1186   _Internal::HasBits has_bits{};
1187   while (!ctx->Done(&ptr)) {
1188     ::uint32_t tag;
1189     ptr = ::_pbi::ReadTag(ptr, &tag);
1190     switch (tag >> 3) {
1191       // optional uint64 iid = 1;
1192       case 1:
1193         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1194           _Internal::set_has_iid(&has_bits);
1195           _impl_.iid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1196           CHK_(ptr);
1197         } else {
1198           goto handle_unusual;
1199         }
1200         continue;
1201       // bytes latin1 = 2;
1202       case 2:
1203         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1204           auto str = _internal_mutable_latin1();
1205           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1206           CHK_(ptr);
1207         } else {
1208           goto handle_unusual;
1209         }
1210         continue;
1211       // bytes utf16_le = 3;
1212       case 3:
1213         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1214           auto str = _internal_mutable_utf16_le();
1215           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1216           CHK_(ptr);
1217         } else {
1218           goto handle_unusual;
1219         }
1220         continue;
1221       // bytes utf16_be = 4;
1222       case 4:
1223         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1224           auto str = _internal_mutable_utf16_be();
1225           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1226           CHK_(ptr);
1227         } else {
1228           goto handle_unusual;
1229         }
1230         continue;
1231       default:
1232         goto handle_unusual;
1233     }  // switch
1234   handle_unusual:
1235     if ((tag == 0) || ((tag & 7) == 4)) {
1236       CHK_(ptr);
1237       ctx->SetLastTag(tag);
1238       goto message_done;
1239     }
1240     ptr = UnknownFieldParse(
1241         tag,
1242         _internal_metadata_.mutable_unknown_fields<std::string>(),
1243         ptr, ctx);
1244     CHK_(ptr != nullptr);
1245   }  // while
1246 message_done:
1247   _impl_._has_bits_.Or(has_bits);
1248   return ptr;
1249 failure:
1250   ptr = nullptr;
1251   goto message_done;
1252 #undef CHK_
1253 }
1254 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1255 ::uint8_t* InternedV8String::_InternalSerialize(
1256     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1257   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.InternedV8String)
1258   ::uint32_t cached_has_bits = 0;
1259   (void) cached_has_bits;
1260 
1261   cached_has_bits = _impl_._has_bits_[0];
1262   // optional uint64 iid = 1;
1263   if (cached_has_bits & 0x00000001u) {
1264     target = stream->EnsureSpace(target);
1265     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_iid(), target);
1266   }
1267 
1268   switch (encoded_string_case()) {
1269     case kLatin1: {
1270       target = stream->WriteBytesMaybeAliased(
1271           2, this->_internal_latin1(), target);
1272       break;
1273     }
1274     case kUtf16Le: {
1275       target = stream->WriteBytesMaybeAliased(
1276           3, this->_internal_utf16_le(), target);
1277       break;
1278     }
1279     case kUtf16Be: {
1280       target = stream->WriteBytesMaybeAliased(
1281           4, this->_internal_utf16_be(), target);
1282       break;
1283     }
1284     default: ;
1285   }
1286   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1287     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1288         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1289   }
1290   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.InternedV8String)
1291   return target;
1292 }
1293 
ByteSizeLong() const1294 size_t InternedV8String::ByteSizeLong() const {
1295 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.InternedV8String)
1296   size_t total_size = 0;
1297 
1298   ::uint32_t cached_has_bits = 0;
1299   // Prevent compiler warnings about cached_has_bits being unused
1300   (void) cached_has_bits;
1301 
1302   // optional uint64 iid = 1;
1303   cached_has_bits = _impl_._has_bits_[0];
1304   if (cached_has_bits & 0x00000001u) {
1305     total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_iid());
1306   }
1307 
1308   switch (encoded_string_case()) {
1309     // bytes latin1 = 2;
1310     case kLatin1: {
1311       total_size += 1 +
1312         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
1313           this->_internal_latin1());
1314       break;
1315     }
1316     // bytes utf16_le = 3;
1317     case kUtf16Le: {
1318       total_size += 1 +
1319         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
1320           this->_internal_utf16_le());
1321       break;
1322     }
1323     // bytes utf16_be = 4;
1324     case kUtf16Be: {
1325       total_size += 1 +
1326         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
1327           this->_internal_utf16_be());
1328       break;
1329     }
1330     case ENCODED_STRING_NOT_SET: {
1331       break;
1332     }
1333   }
1334   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1335     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1336   }
1337   int cached_size = ::_pbi::ToCachedSize(total_size);
1338   SetCachedSize(cached_size);
1339   return total_size;
1340 }
1341 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1342 void InternedV8String::CheckTypeAndMergeFrom(
1343     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1344   MergeFrom(*::_pbi::DownCast<const InternedV8String*>(
1345       &from));
1346 }
1347 
MergeFrom(const InternedV8String & from)1348 void InternedV8String::MergeFrom(const InternedV8String& from) {
1349   InternedV8String* const _this = this;
1350   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.InternedV8String)
1351   GOOGLE_DCHECK_NE(&from, _this);
1352   ::uint32_t cached_has_bits = 0;
1353   (void) cached_has_bits;
1354 
1355   if (from._internal_has_iid()) {
1356     _this->_internal_set_iid(from._internal_iid());
1357   }
1358   switch (from.encoded_string_case()) {
1359     case kLatin1: {
1360       _this->_internal_set_latin1(from._internal_latin1());
1361       break;
1362     }
1363     case kUtf16Le: {
1364       _this->_internal_set_utf16_le(from._internal_utf16_le());
1365       break;
1366     }
1367     case kUtf16Be: {
1368       _this->_internal_set_utf16_be(from._internal_utf16_be());
1369       break;
1370     }
1371     case ENCODED_STRING_NOT_SET: {
1372       break;
1373     }
1374   }
1375   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1376 }
1377 
CopyFrom(const InternedV8String & from)1378 void InternedV8String::CopyFrom(const InternedV8String& from) {
1379 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.InternedV8String)
1380   if (&from == this) return;
1381   Clear();
1382   MergeFrom(from);
1383 }
1384 
IsInitialized() const1385 bool InternedV8String::IsInitialized() const {
1386   return true;
1387 }
1388 
InternalSwap(InternedV8String * other)1389 void InternedV8String::InternalSwap(InternedV8String* other) {
1390   using std::swap;
1391   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1392   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1393   swap(_impl_.iid_, other->_impl_.iid_);
1394   swap(_impl_.encoded_string_, other->_impl_.encoded_string_);
1395   swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
1396 }
1397 
GetTypeName() const1398 std::string InternedV8String::GetTypeName() const {
1399   return "perfetto.protos.InternedV8String";
1400 }
1401 
1402 
1403 // ===================================================================
1404 
1405 class InternedV8JsScript::_Internal {
1406  public:
1407   using HasBits = decltype(std::declval<InternedV8JsScript>()._impl_._has_bits_);
set_has_iid(HasBits * has_bits)1408   static void set_has_iid(HasBits* has_bits) {
1409     (*has_bits)[0] |= 4u;
1410   }
set_has_script_id(HasBits * has_bits)1411   static void set_has_script_id(HasBits* has_bits) {
1412     (*has_bits)[0] |= 8u;
1413   }
set_has_type(HasBits * has_bits)1414   static void set_has_type(HasBits* has_bits) {
1415     (*has_bits)[0] |= 16u;
1416   }
1417   static const ::perfetto::protos::V8String& name(const InternedV8JsScript* msg);
set_has_name(HasBits * has_bits)1418   static void set_has_name(HasBits* has_bits) {
1419     (*has_bits)[0] |= 1u;
1420   }
1421   static const ::perfetto::protos::V8String& source(const InternedV8JsScript* msg);
set_has_source(HasBits * has_bits)1422   static void set_has_source(HasBits* has_bits) {
1423     (*has_bits)[0] |= 2u;
1424   }
1425 };
1426 
1427 const ::perfetto::protos::V8String&
name(const InternedV8JsScript * msg)1428 InternedV8JsScript::_Internal::name(const InternedV8JsScript* msg) {
1429   return *msg->_impl_.name_;
1430 }
1431 const ::perfetto::protos::V8String&
source(const InternedV8JsScript * msg)1432 InternedV8JsScript::_Internal::source(const InternedV8JsScript* msg) {
1433   return *msg->_impl_.source_;
1434 }
InternedV8JsScript(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1435 InternedV8JsScript::InternedV8JsScript(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1436                          bool is_message_owned)
1437   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1438   SharedCtor(arena, is_message_owned);
1439   // @@protoc_insertion_point(arena_constructor:perfetto.protos.InternedV8JsScript)
1440 }
InternedV8JsScript(const InternedV8JsScript & from)1441 InternedV8JsScript::InternedV8JsScript(const InternedV8JsScript& from)
1442   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1443   InternedV8JsScript* const _this = this; (void)_this;
1444   new (&_impl_) Impl_{
1445       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1446     , /*decltype(_impl_._cached_size_)*/{}
1447     , decltype(_impl_.name_){nullptr}
1448     , decltype(_impl_.source_){nullptr}
1449     , decltype(_impl_.iid_){}
1450     , decltype(_impl_.script_id_){}
1451     , decltype(_impl_.type_){}};
1452 
1453   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1454   if (from._internal_has_name()) {
1455     _this->_impl_.name_ = new ::perfetto::protos::V8String(*from._impl_.name_);
1456   }
1457   if (from._internal_has_source()) {
1458     _this->_impl_.source_ = new ::perfetto::protos::V8String(*from._impl_.source_);
1459   }
1460   ::memcpy(&_impl_.iid_, &from._impl_.iid_,
1461     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.type_) -
1462     reinterpret_cast<char*>(&_impl_.iid_)) + sizeof(_impl_.type_));
1463   // @@protoc_insertion_point(copy_constructor:perfetto.protos.InternedV8JsScript)
1464 }
1465 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1466 inline void InternedV8JsScript::SharedCtor(
1467     ::_pb::Arena* arena, bool is_message_owned) {
1468   (void)arena;
1469   (void)is_message_owned;
1470   new (&_impl_) Impl_{
1471       decltype(_impl_._has_bits_){}
1472     , /*decltype(_impl_._cached_size_)*/{}
1473     , decltype(_impl_.name_){nullptr}
1474     , decltype(_impl_.source_){nullptr}
1475     , decltype(_impl_.iid_){::uint64_t{0u}}
1476     , decltype(_impl_.script_id_){0}
1477     , decltype(_impl_.type_){0}
1478   };
1479 }
1480 
~InternedV8JsScript()1481 InternedV8JsScript::~InternedV8JsScript() {
1482   // @@protoc_insertion_point(destructor:perfetto.protos.InternedV8JsScript)
1483   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1484   (void)arena;
1485     return;
1486   }
1487   SharedDtor();
1488 }
1489 
SharedDtor()1490 inline void InternedV8JsScript::SharedDtor() {
1491   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1492   if (this != internal_default_instance()) delete _impl_.name_;
1493   if (this != internal_default_instance()) delete _impl_.source_;
1494 }
1495 
SetCachedSize(int size) const1496 void InternedV8JsScript::SetCachedSize(int size) const {
1497   _impl_._cached_size_.Set(size);
1498 }
1499 
Clear()1500 void InternedV8JsScript::Clear() {
1501 // @@protoc_insertion_point(message_clear_start:perfetto.protos.InternedV8JsScript)
1502   ::uint32_t cached_has_bits = 0;
1503   // Prevent compiler warnings about cached_has_bits being unused
1504   (void) cached_has_bits;
1505 
1506   cached_has_bits = _impl_._has_bits_[0];
1507   if (cached_has_bits & 0x00000003u) {
1508     if (cached_has_bits & 0x00000001u) {
1509       GOOGLE_DCHECK(_impl_.name_ != nullptr);
1510       _impl_.name_->Clear();
1511     }
1512     if (cached_has_bits & 0x00000002u) {
1513       GOOGLE_DCHECK(_impl_.source_ != nullptr);
1514       _impl_.source_->Clear();
1515     }
1516   }
1517   if (cached_has_bits & 0x0000001cu) {
1518     ::memset(&_impl_.iid_, 0, static_cast<size_t>(
1519         reinterpret_cast<char*>(&_impl_.type_) -
1520         reinterpret_cast<char*>(&_impl_.iid_)) + sizeof(_impl_.type_));
1521   }
1522   _impl_._has_bits_.Clear();
1523   _internal_metadata_.Clear<std::string>();
1524 }
1525 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1526 const char* InternedV8JsScript::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1527 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1528   _Internal::HasBits has_bits{};
1529   while (!ctx->Done(&ptr)) {
1530     ::uint32_t tag;
1531     ptr = ::_pbi::ReadTag(ptr, &tag);
1532     switch (tag >> 3) {
1533       // optional uint64 iid = 1;
1534       case 1:
1535         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1536           _Internal::set_has_iid(&has_bits);
1537           _impl_.iid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1538           CHK_(ptr);
1539         } else {
1540           goto handle_unusual;
1541         }
1542         continue;
1543       // optional int32 script_id = 2;
1544       case 2:
1545         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1546           _Internal::set_has_script_id(&has_bits);
1547           _impl_.script_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1548           CHK_(ptr);
1549         } else {
1550           goto handle_unusual;
1551         }
1552         continue;
1553       // optional .perfetto.protos.InternedV8JsScript.Type type = 3;
1554       case 3:
1555         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1556           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1557           CHK_(ptr);
1558           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::InternedV8JsScript_Type_IsValid(val))) {
1559             _internal_set_type(static_cast<::perfetto::protos::InternedV8JsScript_Type>(val));
1560           } else {
1561             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
1562           }
1563         } else {
1564           goto handle_unusual;
1565         }
1566         continue;
1567       // optional .perfetto.protos.V8String name = 4;
1568       case 4:
1569         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1570           ptr = ctx->ParseMessage(_internal_mutable_name(), ptr);
1571           CHK_(ptr);
1572         } else {
1573           goto handle_unusual;
1574         }
1575         continue;
1576       // optional .perfetto.protos.V8String source = 5;
1577       case 5:
1578         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1579           ptr = ctx->ParseMessage(_internal_mutable_source(), ptr);
1580           CHK_(ptr);
1581         } else {
1582           goto handle_unusual;
1583         }
1584         continue;
1585       default:
1586         goto handle_unusual;
1587     }  // switch
1588   handle_unusual:
1589     if ((tag == 0) || ((tag & 7) == 4)) {
1590       CHK_(ptr);
1591       ctx->SetLastTag(tag);
1592       goto message_done;
1593     }
1594     ptr = UnknownFieldParse(
1595         tag,
1596         _internal_metadata_.mutable_unknown_fields<std::string>(),
1597         ptr, ctx);
1598     CHK_(ptr != nullptr);
1599   }  // while
1600 message_done:
1601   _impl_._has_bits_.Or(has_bits);
1602   return ptr;
1603 failure:
1604   ptr = nullptr;
1605   goto message_done;
1606 #undef CHK_
1607 }
1608 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1609 ::uint8_t* InternedV8JsScript::_InternalSerialize(
1610     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1611   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.InternedV8JsScript)
1612   ::uint32_t cached_has_bits = 0;
1613   (void) cached_has_bits;
1614 
1615   cached_has_bits = _impl_._has_bits_[0];
1616   // optional uint64 iid = 1;
1617   if (cached_has_bits & 0x00000004u) {
1618     target = stream->EnsureSpace(target);
1619     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_iid(), target);
1620   }
1621 
1622   // optional int32 script_id = 2;
1623   if (cached_has_bits & 0x00000008u) {
1624     target = stream->EnsureSpace(target);
1625     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_script_id(), target);
1626   }
1627 
1628   // optional .perfetto.protos.InternedV8JsScript.Type type = 3;
1629   if (cached_has_bits & 0x00000010u) {
1630     target = stream->EnsureSpace(target);
1631     target = ::_pbi::WireFormatLite::WriteEnumToArray(
1632       3, this->_internal_type(), target);
1633   }
1634 
1635   // optional .perfetto.protos.V8String name = 4;
1636   if (cached_has_bits & 0x00000001u) {
1637     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1638       InternalWriteMessage(4, _Internal::name(this),
1639         _Internal::name(this).GetCachedSize(), target, stream);
1640   }
1641 
1642   // optional .perfetto.protos.V8String source = 5;
1643   if (cached_has_bits & 0x00000002u) {
1644     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1645       InternalWriteMessage(5, _Internal::source(this),
1646         _Internal::source(this).GetCachedSize(), target, stream);
1647   }
1648 
1649   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1650     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1651         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1652   }
1653   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.InternedV8JsScript)
1654   return target;
1655 }
1656 
ByteSizeLong() const1657 size_t InternedV8JsScript::ByteSizeLong() const {
1658 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.InternedV8JsScript)
1659   size_t total_size = 0;
1660 
1661   ::uint32_t cached_has_bits = 0;
1662   // Prevent compiler warnings about cached_has_bits being unused
1663   (void) cached_has_bits;
1664 
1665   cached_has_bits = _impl_._has_bits_[0];
1666   if (cached_has_bits & 0x0000001fu) {
1667     // optional .perfetto.protos.V8String name = 4;
1668     if (cached_has_bits & 0x00000001u) {
1669       total_size += 1 +
1670         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1671           *_impl_.name_);
1672     }
1673 
1674     // optional .perfetto.protos.V8String source = 5;
1675     if (cached_has_bits & 0x00000002u) {
1676       total_size += 1 +
1677         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1678           *_impl_.source_);
1679     }
1680 
1681     // optional uint64 iid = 1;
1682     if (cached_has_bits & 0x00000004u) {
1683       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_iid());
1684     }
1685 
1686     // optional int32 script_id = 2;
1687     if (cached_has_bits & 0x00000008u) {
1688       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_script_id());
1689     }
1690 
1691     // optional .perfetto.protos.InternedV8JsScript.Type type = 3;
1692     if (cached_has_bits & 0x00000010u) {
1693       total_size += 1 +
1694         ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
1695     }
1696 
1697   }
1698   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1699     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1700   }
1701   int cached_size = ::_pbi::ToCachedSize(total_size);
1702   SetCachedSize(cached_size);
1703   return total_size;
1704 }
1705 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1706 void InternedV8JsScript::CheckTypeAndMergeFrom(
1707     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1708   MergeFrom(*::_pbi::DownCast<const InternedV8JsScript*>(
1709       &from));
1710 }
1711 
MergeFrom(const InternedV8JsScript & from)1712 void InternedV8JsScript::MergeFrom(const InternedV8JsScript& from) {
1713   InternedV8JsScript* const _this = this;
1714   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.InternedV8JsScript)
1715   GOOGLE_DCHECK_NE(&from, _this);
1716   ::uint32_t cached_has_bits = 0;
1717   (void) cached_has_bits;
1718 
1719   cached_has_bits = from._impl_._has_bits_[0];
1720   if (cached_has_bits & 0x0000001fu) {
1721     if (cached_has_bits & 0x00000001u) {
1722       _this->_internal_mutable_name()->::perfetto::protos::V8String::MergeFrom(
1723           from._internal_name());
1724     }
1725     if (cached_has_bits & 0x00000002u) {
1726       _this->_internal_mutable_source()->::perfetto::protos::V8String::MergeFrom(
1727           from._internal_source());
1728     }
1729     if (cached_has_bits & 0x00000004u) {
1730       _this->_impl_.iid_ = from._impl_.iid_;
1731     }
1732     if (cached_has_bits & 0x00000008u) {
1733       _this->_impl_.script_id_ = from._impl_.script_id_;
1734     }
1735     if (cached_has_bits & 0x00000010u) {
1736       _this->_impl_.type_ = from._impl_.type_;
1737     }
1738     _this->_impl_._has_bits_[0] |= cached_has_bits;
1739   }
1740   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1741 }
1742 
CopyFrom(const InternedV8JsScript & from)1743 void InternedV8JsScript::CopyFrom(const InternedV8JsScript& from) {
1744 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.InternedV8JsScript)
1745   if (&from == this) return;
1746   Clear();
1747   MergeFrom(from);
1748 }
1749 
IsInitialized() const1750 bool InternedV8JsScript::IsInitialized() const {
1751   return true;
1752 }
1753 
InternalSwap(InternedV8JsScript * other)1754 void InternedV8JsScript::InternalSwap(InternedV8JsScript* other) {
1755   using std::swap;
1756   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1757   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1758   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1759       PROTOBUF_FIELD_OFFSET(InternedV8JsScript, _impl_.type_)
1760       + sizeof(InternedV8JsScript::_impl_.type_)  // NOLINT
1761       - PROTOBUF_FIELD_OFFSET(InternedV8JsScript, _impl_.name_)>(
1762           reinterpret_cast<char*>(&_impl_.name_),
1763           reinterpret_cast<char*>(&other->_impl_.name_));
1764 }
1765 
GetTypeName() const1766 std::string InternedV8JsScript::GetTypeName() const {
1767   return "perfetto.protos.InternedV8JsScript";
1768 }
1769 
1770 
1771 // ===================================================================
1772 
1773 class InternedV8WasmScript::_Internal {
1774  public:
1775   using HasBits = decltype(std::declval<InternedV8WasmScript>()._impl_._has_bits_);
set_has_iid(HasBits * has_bits)1776   static void set_has_iid(HasBits* has_bits) {
1777     (*has_bits)[0] |= 2u;
1778   }
set_has_script_id(HasBits * has_bits)1779   static void set_has_script_id(HasBits* has_bits) {
1780     (*has_bits)[0] |= 4u;
1781   }
set_has_url(HasBits * has_bits)1782   static void set_has_url(HasBits* has_bits) {
1783     (*has_bits)[0] |= 1u;
1784   }
1785 };
1786 
InternedV8WasmScript(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1787 InternedV8WasmScript::InternedV8WasmScript(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1788                          bool is_message_owned)
1789   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1790   SharedCtor(arena, is_message_owned);
1791   // @@protoc_insertion_point(arena_constructor:perfetto.protos.InternedV8WasmScript)
1792 }
InternedV8WasmScript(const InternedV8WasmScript & from)1793 InternedV8WasmScript::InternedV8WasmScript(const InternedV8WasmScript& from)
1794   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1795   InternedV8WasmScript* const _this = this; (void)_this;
1796   new (&_impl_) Impl_{
1797       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1798     , /*decltype(_impl_._cached_size_)*/{}
1799     , decltype(_impl_.url_){}
1800     , decltype(_impl_.iid_){}
1801     , decltype(_impl_.script_id_){}};
1802 
1803   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1804   _impl_.url_.InitDefault();
1805   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1806     _impl_.url_.Set("", GetArenaForAllocation());
1807   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1808   if (from._internal_has_url()) {
1809     _this->_impl_.url_.Set(from._internal_url(),
1810       _this->GetArenaForAllocation());
1811   }
1812   ::memcpy(&_impl_.iid_, &from._impl_.iid_,
1813     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.script_id_) -
1814     reinterpret_cast<char*>(&_impl_.iid_)) + sizeof(_impl_.script_id_));
1815   // @@protoc_insertion_point(copy_constructor:perfetto.protos.InternedV8WasmScript)
1816 }
1817 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1818 inline void InternedV8WasmScript::SharedCtor(
1819     ::_pb::Arena* arena, bool is_message_owned) {
1820   (void)arena;
1821   (void)is_message_owned;
1822   new (&_impl_) Impl_{
1823       decltype(_impl_._has_bits_){}
1824     , /*decltype(_impl_._cached_size_)*/{}
1825     , decltype(_impl_.url_){}
1826     , decltype(_impl_.iid_){::uint64_t{0u}}
1827     , decltype(_impl_.script_id_){0}
1828   };
1829   _impl_.url_.InitDefault();
1830   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1831     _impl_.url_.Set("", GetArenaForAllocation());
1832   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1833 }
1834 
~InternedV8WasmScript()1835 InternedV8WasmScript::~InternedV8WasmScript() {
1836   // @@protoc_insertion_point(destructor:perfetto.protos.InternedV8WasmScript)
1837   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1838   (void)arena;
1839     return;
1840   }
1841   SharedDtor();
1842 }
1843 
SharedDtor()1844 inline void InternedV8WasmScript::SharedDtor() {
1845   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1846   _impl_.url_.Destroy();
1847 }
1848 
SetCachedSize(int size) const1849 void InternedV8WasmScript::SetCachedSize(int size) const {
1850   _impl_._cached_size_.Set(size);
1851 }
1852 
Clear()1853 void InternedV8WasmScript::Clear() {
1854 // @@protoc_insertion_point(message_clear_start:perfetto.protos.InternedV8WasmScript)
1855   ::uint32_t cached_has_bits = 0;
1856   // Prevent compiler warnings about cached_has_bits being unused
1857   (void) cached_has_bits;
1858 
1859   cached_has_bits = _impl_._has_bits_[0];
1860   if (cached_has_bits & 0x00000001u) {
1861     _impl_.url_.ClearNonDefaultToEmpty();
1862   }
1863   if (cached_has_bits & 0x00000006u) {
1864     ::memset(&_impl_.iid_, 0, static_cast<size_t>(
1865         reinterpret_cast<char*>(&_impl_.script_id_) -
1866         reinterpret_cast<char*>(&_impl_.iid_)) + sizeof(_impl_.script_id_));
1867   }
1868   _impl_._has_bits_.Clear();
1869   _internal_metadata_.Clear<std::string>();
1870 }
1871 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1872 const char* InternedV8WasmScript::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1873 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1874   _Internal::HasBits has_bits{};
1875   while (!ctx->Done(&ptr)) {
1876     ::uint32_t tag;
1877     ptr = ::_pbi::ReadTag(ptr, &tag);
1878     switch (tag >> 3) {
1879       // optional uint64 iid = 1;
1880       case 1:
1881         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1882           _Internal::set_has_iid(&has_bits);
1883           _impl_.iid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1884           CHK_(ptr);
1885         } else {
1886           goto handle_unusual;
1887         }
1888         continue;
1889       // optional int32 script_id = 2;
1890       case 2:
1891         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1892           _Internal::set_has_script_id(&has_bits);
1893           _impl_.script_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1894           CHK_(ptr);
1895         } else {
1896           goto handle_unusual;
1897         }
1898         continue;
1899       // optional string url = 3;
1900       case 3:
1901         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1902           auto str = _internal_mutable_url();
1903           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1904           CHK_(ptr);
1905         } else {
1906           goto handle_unusual;
1907         }
1908         continue;
1909       default:
1910         goto handle_unusual;
1911     }  // switch
1912   handle_unusual:
1913     if ((tag == 0) || ((tag & 7) == 4)) {
1914       CHK_(ptr);
1915       ctx->SetLastTag(tag);
1916       goto message_done;
1917     }
1918     ptr = UnknownFieldParse(
1919         tag,
1920         _internal_metadata_.mutable_unknown_fields<std::string>(),
1921         ptr, ctx);
1922     CHK_(ptr != nullptr);
1923   }  // while
1924 message_done:
1925   _impl_._has_bits_.Or(has_bits);
1926   return ptr;
1927 failure:
1928   ptr = nullptr;
1929   goto message_done;
1930 #undef CHK_
1931 }
1932 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1933 ::uint8_t* InternedV8WasmScript::_InternalSerialize(
1934     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1935   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.InternedV8WasmScript)
1936   ::uint32_t cached_has_bits = 0;
1937   (void) cached_has_bits;
1938 
1939   cached_has_bits = _impl_._has_bits_[0];
1940   // optional uint64 iid = 1;
1941   if (cached_has_bits & 0x00000002u) {
1942     target = stream->EnsureSpace(target);
1943     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_iid(), target);
1944   }
1945 
1946   // optional int32 script_id = 2;
1947   if (cached_has_bits & 0x00000004u) {
1948     target = stream->EnsureSpace(target);
1949     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_script_id(), target);
1950   }
1951 
1952   // optional string url = 3;
1953   if (cached_has_bits & 0x00000001u) {
1954     target = stream->WriteStringMaybeAliased(
1955         3, this->_internal_url(), target);
1956   }
1957 
1958   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1959     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1960         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1961   }
1962   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.InternedV8WasmScript)
1963   return target;
1964 }
1965 
ByteSizeLong() const1966 size_t InternedV8WasmScript::ByteSizeLong() const {
1967 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.InternedV8WasmScript)
1968   size_t total_size = 0;
1969 
1970   ::uint32_t cached_has_bits = 0;
1971   // Prevent compiler warnings about cached_has_bits being unused
1972   (void) cached_has_bits;
1973 
1974   cached_has_bits = _impl_._has_bits_[0];
1975   if (cached_has_bits & 0x00000007u) {
1976     // optional string url = 3;
1977     if (cached_has_bits & 0x00000001u) {
1978       total_size += 1 +
1979         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1980           this->_internal_url());
1981     }
1982 
1983     // optional uint64 iid = 1;
1984     if (cached_has_bits & 0x00000002u) {
1985       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_iid());
1986     }
1987 
1988     // optional int32 script_id = 2;
1989     if (cached_has_bits & 0x00000004u) {
1990       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_script_id());
1991     }
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 InternedV8WasmScript::CheckTypeAndMergeFrom(
2003     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2004   MergeFrom(*::_pbi::DownCast<const InternedV8WasmScript*>(
2005       &from));
2006 }
2007 
MergeFrom(const InternedV8WasmScript & from)2008 void InternedV8WasmScript::MergeFrom(const InternedV8WasmScript& from) {
2009   InternedV8WasmScript* const _this = this;
2010   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.InternedV8WasmScript)
2011   GOOGLE_DCHECK_NE(&from, _this);
2012   ::uint32_t cached_has_bits = 0;
2013   (void) cached_has_bits;
2014 
2015   cached_has_bits = from._impl_._has_bits_[0];
2016   if (cached_has_bits & 0x00000007u) {
2017     if (cached_has_bits & 0x00000001u) {
2018       _this->_internal_set_url(from._internal_url());
2019     }
2020     if (cached_has_bits & 0x00000002u) {
2021       _this->_impl_.iid_ = from._impl_.iid_;
2022     }
2023     if (cached_has_bits & 0x00000004u) {
2024       _this->_impl_.script_id_ = from._impl_.script_id_;
2025     }
2026     _this->_impl_._has_bits_[0] |= cached_has_bits;
2027   }
2028   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2029 }
2030 
CopyFrom(const InternedV8WasmScript & from)2031 void InternedV8WasmScript::CopyFrom(const InternedV8WasmScript& from) {
2032 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.InternedV8WasmScript)
2033   if (&from == this) return;
2034   Clear();
2035   MergeFrom(from);
2036 }
2037 
IsInitialized() const2038 bool InternedV8WasmScript::IsInitialized() const {
2039   return true;
2040 }
2041 
InternalSwap(InternedV8WasmScript * other)2042 void InternedV8WasmScript::InternalSwap(InternedV8WasmScript* other) {
2043   using std::swap;
2044   auto* lhs_arena = GetArenaForAllocation();
2045   auto* rhs_arena = other->GetArenaForAllocation();
2046   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2047   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2048   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2049       &_impl_.url_, lhs_arena,
2050       &other->_impl_.url_, rhs_arena
2051   );
2052   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2053       PROTOBUF_FIELD_OFFSET(InternedV8WasmScript, _impl_.script_id_)
2054       + sizeof(InternedV8WasmScript::_impl_.script_id_)  // NOLINT
2055       - PROTOBUF_FIELD_OFFSET(InternedV8WasmScript, _impl_.iid_)>(
2056           reinterpret_cast<char*>(&_impl_.iid_),
2057           reinterpret_cast<char*>(&other->_impl_.iid_));
2058 }
2059 
GetTypeName() const2060 std::string InternedV8WasmScript::GetTypeName() const {
2061   return "perfetto.protos.InternedV8WasmScript";
2062 }
2063 
2064 
2065 // ===================================================================
2066 
2067 class InternedV8JsFunction::_Internal {
2068  public:
2069   using HasBits = decltype(std::declval<InternedV8JsFunction>()._impl_._has_bits_);
set_has_iid(HasBits * has_bits)2070   static void set_has_iid(HasBits* has_bits) {
2071     (*has_bits)[0] |= 1u;
2072   }
set_has_v8_js_function_name_iid(HasBits * has_bits)2073   static void set_has_v8_js_function_name_iid(HasBits* has_bits) {
2074     (*has_bits)[0] |= 2u;
2075   }
set_has_v8_js_script_iid(HasBits * has_bits)2076   static void set_has_v8_js_script_iid(HasBits* has_bits) {
2077     (*has_bits)[0] |= 4u;
2078   }
set_has_is_toplevel(HasBits * has_bits)2079   static void set_has_is_toplevel(HasBits* has_bits) {
2080     (*has_bits)[0] |= 8u;
2081   }
set_has_kind(HasBits * has_bits)2082   static void set_has_kind(HasBits* has_bits) {
2083     (*has_bits)[0] |= 16u;
2084   }
set_has_byte_offset(HasBits * has_bits)2085   static void set_has_byte_offset(HasBits* has_bits) {
2086     (*has_bits)[0] |= 32u;
2087   }
2088 };
2089 
InternedV8JsFunction(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2090 InternedV8JsFunction::InternedV8JsFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2091                          bool is_message_owned)
2092   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2093   SharedCtor(arena, is_message_owned);
2094   // @@protoc_insertion_point(arena_constructor:perfetto.protos.InternedV8JsFunction)
2095 }
InternedV8JsFunction(const InternedV8JsFunction & from)2096 InternedV8JsFunction::InternedV8JsFunction(const InternedV8JsFunction& from)
2097   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2098   InternedV8JsFunction* const _this = this; (void)_this;
2099   new (&_impl_) Impl_{
2100       decltype(_impl_._has_bits_){from._impl_._has_bits_}
2101     , /*decltype(_impl_._cached_size_)*/{}
2102     , decltype(_impl_.iid_){}
2103     , decltype(_impl_.v8_js_function_name_iid_){}
2104     , decltype(_impl_.v8_js_script_iid_){}
2105     , decltype(_impl_.is_toplevel_){}
2106     , decltype(_impl_.kind_){}
2107     , decltype(_impl_.byte_offset_){}};
2108 
2109   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2110   ::memcpy(&_impl_.iid_, &from._impl_.iid_,
2111     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.byte_offset_) -
2112     reinterpret_cast<char*>(&_impl_.iid_)) + sizeof(_impl_.byte_offset_));
2113   // @@protoc_insertion_point(copy_constructor:perfetto.protos.InternedV8JsFunction)
2114 }
2115 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2116 inline void InternedV8JsFunction::SharedCtor(
2117     ::_pb::Arena* arena, bool is_message_owned) {
2118   (void)arena;
2119   (void)is_message_owned;
2120   new (&_impl_) Impl_{
2121       decltype(_impl_._has_bits_){}
2122     , /*decltype(_impl_._cached_size_)*/{}
2123     , decltype(_impl_.iid_){::uint64_t{0u}}
2124     , decltype(_impl_.v8_js_function_name_iid_){::uint64_t{0u}}
2125     , decltype(_impl_.v8_js_script_iid_){::uint64_t{0u}}
2126     , decltype(_impl_.is_toplevel_){false}
2127     , decltype(_impl_.kind_){0}
2128     , decltype(_impl_.byte_offset_){0u}
2129   };
2130 }
2131 
~InternedV8JsFunction()2132 InternedV8JsFunction::~InternedV8JsFunction() {
2133   // @@protoc_insertion_point(destructor:perfetto.protos.InternedV8JsFunction)
2134   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2135   (void)arena;
2136     return;
2137   }
2138   SharedDtor();
2139 }
2140 
SharedDtor()2141 inline void InternedV8JsFunction::SharedDtor() {
2142   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2143 }
2144 
SetCachedSize(int size) const2145 void InternedV8JsFunction::SetCachedSize(int size) const {
2146   _impl_._cached_size_.Set(size);
2147 }
2148 
Clear()2149 void InternedV8JsFunction::Clear() {
2150 // @@protoc_insertion_point(message_clear_start:perfetto.protos.InternedV8JsFunction)
2151   ::uint32_t cached_has_bits = 0;
2152   // Prevent compiler warnings about cached_has_bits being unused
2153   (void) cached_has_bits;
2154 
2155   cached_has_bits = _impl_._has_bits_[0];
2156   if (cached_has_bits & 0x0000003fu) {
2157     ::memset(&_impl_.iid_, 0, static_cast<size_t>(
2158         reinterpret_cast<char*>(&_impl_.byte_offset_) -
2159         reinterpret_cast<char*>(&_impl_.iid_)) + sizeof(_impl_.byte_offset_));
2160   }
2161   _impl_._has_bits_.Clear();
2162   _internal_metadata_.Clear<std::string>();
2163 }
2164 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2165 const char* InternedV8JsFunction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2166 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2167   _Internal::HasBits has_bits{};
2168   while (!ctx->Done(&ptr)) {
2169     ::uint32_t tag;
2170     ptr = ::_pbi::ReadTag(ptr, &tag);
2171     switch (tag >> 3) {
2172       // optional uint64 iid = 1;
2173       case 1:
2174         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2175           _Internal::set_has_iid(&has_bits);
2176           _impl_.iid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2177           CHK_(ptr);
2178         } else {
2179           goto handle_unusual;
2180         }
2181         continue;
2182       // optional uint64 v8_js_function_name_iid = 2;
2183       case 2:
2184         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2185           _Internal::set_has_v8_js_function_name_iid(&has_bits);
2186           _impl_.v8_js_function_name_iid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2187           CHK_(ptr);
2188         } else {
2189           goto handle_unusual;
2190         }
2191         continue;
2192       // optional uint64 v8_js_script_iid = 3;
2193       case 3:
2194         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2195           _Internal::set_has_v8_js_script_iid(&has_bits);
2196           _impl_.v8_js_script_iid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2197           CHK_(ptr);
2198         } else {
2199           goto handle_unusual;
2200         }
2201         continue;
2202       // optional bool is_toplevel = 4;
2203       case 4:
2204         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2205           _Internal::set_has_is_toplevel(&has_bits);
2206           _impl_.is_toplevel_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2207           CHK_(ptr);
2208         } else {
2209           goto handle_unusual;
2210         }
2211         continue;
2212       // optional .perfetto.protos.InternedV8JsFunction.Kind kind = 5;
2213       case 5:
2214         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
2215           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2216           CHK_(ptr);
2217           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::InternedV8JsFunction_Kind_IsValid(val))) {
2218             _internal_set_kind(static_cast<::perfetto::protos::InternedV8JsFunction_Kind>(val));
2219           } else {
2220             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
2221           }
2222         } else {
2223           goto handle_unusual;
2224         }
2225         continue;
2226       // optional uint32 byte_offset = 6;
2227       case 6:
2228         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
2229           _Internal::set_has_byte_offset(&has_bits);
2230           _impl_.byte_offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2231           CHK_(ptr);
2232         } else {
2233           goto handle_unusual;
2234         }
2235         continue;
2236       default:
2237         goto handle_unusual;
2238     }  // switch
2239   handle_unusual:
2240     if ((tag == 0) || ((tag & 7) == 4)) {
2241       CHK_(ptr);
2242       ctx->SetLastTag(tag);
2243       goto message_done;
2244     }
2245     ptr = UnknownFieldParse(
2246         tag,
2247         _internal_metadata_.mutable_unknown_fields<std::string>(),
2248         ptr, ctx);
2249     CHK_(ptr != nullptr);
2250   }  // while
2251 message_done:
2252   _impl_._has_bits_.Or(has_bits);
2253   return ptr;
2254 failure:
2255   ptr = nullptr;
2256   goto message_done;
2257 #undef CHK_
2258 }
2259 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2260 ::uint8_t* InternedV8JsFunction::_InternalSerialize(
2261     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2262   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.InternedV8JsFunction)
2263   ::uint32_t cached_has_bits = 0;
2264   (void) cached_has_bits;
2265 
2266   cached_has_bits = _impl_._has_bits_[0];
2267   // optional uint64 iid = 1;
2268   if (cached_has_bits & 0x00000001u) {
2269     target = stream->EnsureSpace(target);
2270     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_iid(), target);
2271   }
2272 
2273   // optional uint64 v8_js_function_name_iid = 2;
2274   if (cached_has_bits & 0x00000002u) {
2275     target = stream->EnsureSpace(target);
2276     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_v8_js_function_name_iid(), target);
2277   }
2278 
2279   // optional uint64 v8_js_script_iid = 3;
2280   if (cached_has_bits & 0x00000004u) {
2281     target = stream->EnsureSpace(target);
2282     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_v8_js_script_iid(), target);
2283   }
2284 
2285   // optional bool is_toplevel = 4;
2286   if (cached_has_bits & 0x00000008u) {
2287     target = stream->EnsureSpace(target);
2288     target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_is_toplevel(), target);
2289   }
2290 
2291   // optional .perfetto.protos.InternedV8JsFunction.Kind kind = 5;
2292   if (cached_has_bits & 0x00000010u) {
2293     target = stream->EnsureSpace(target);
2294     target = ::_pbi::WireFormatLite::WriteEnumToArray(
2295       5, this->_internal_kind(), target);
2296   }
2297 
2298   // optional uint32 byte_offset = 6;
2299   if (cached_has_bits & 0x00000020u) {
2300     target = stream->EnsureSpace(target);
2301     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_byte_offset(), target);
2302   }
2303 
2304   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2305     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2306         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2307   }
2308   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.InternedV8JsFunction)
2309   return target;
2310 }
2311 
ByteSizeLong() const2312 size_t InternedV8JsFunction::ByteSizeLong() const {
2313 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.InternedV8JsFunction)
2314   size_t total_size = 0;
2315 
2316   ::uint32_t cached_has_bits = 0;
2317   // Prevent compiler warnings about cached_has_bits being unused
2318   (void) cached_has_bits;
2319 
2320   cached_has_bits = _impl_._has_bits_[0];
2321   if (cached_has_bits & 0x0000003fu) {
2322     // optional uint64 iid = 1;
2323     if (cached_has_bits & 0x00000001u) {
2324       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_iid());
2325     }
2326 
2327     // optional uint64 v8_js_function_name_iid = 2;
2328     if (cached_has_bits & 0x00000002u) {
2329       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_v8_js_function_name_iid());
2330     }
2331 
2332     // optional uint64 v8_js_script_iid = 3;
2333     if (cached_has_bits & 0x00000004u) {
2334       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_v8_js_script_iid());
2335     }
2336 
2337     // optional bool is_toplevel = 4;
2338     if (cached_has_bits & 0x00000008u) {
2339       total_size += 1 + 1;
2340     }
2341 
2342     // optional .perfetto.protos.InternedV8JsFunction.Kind kind = 5;
2343     if (cached_has_bits & 0x00000010u) {
2344       total_size += 1 +
2345         ::_pbi::WireFormatLite::EnumSize(this->_internal_kind());
2346     }
2347 
2348     // optional uint32 byte_offset = 6;
2349     if (cached_has_bits & 0x00000020u) {
2350       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_byte_offset());
2351     }
2352 
2353   }
2354   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2355     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2356   }
2357   int cached_size = ::_pbi::ToCachedSize(total_size);
2358   SetCachedSize(cached_size);
2359   return total_size;
2360 }
2361 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2362 void InternedV8JsFunction::CheckTypeAndMergeFrom(
2363     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2364   MergeFrom(*::_pbi::DownCast<const InternedV8JsFunction*>(
2365       &from));
2366 }
2367 
MergeFrom(const InternedV8JsFunction & from)2368 void InternedV8JsFunction::MergeFrom(const InternedV8JsFunction& from) {
2369   InternedV8JsFunction* const _this = this;
2370   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.InternedV8JsFunction)
2371   GOOGLE_DCHECK_NE(&from, _this);
2372   ::uint32_t cached_has_bits = 0;
2373   (void) cached_has_bits;
2374 
2375   cached_has_bits = from._impl_._has_bits_[0];
2376   if (cached_has_bits & 0x0000003fu) {
2377     if (cached_has_bits & 0x00000001u) {
2378       _this->_impl_.iid_ = from._impl_.iid_;
2379     }
2380     if (cached_has_bits & 0x00000002u) {
2381       _this->_impl_.v8_js_function_name_iid_ = from._impl_.v8_js_function_name_iid_;
2382     }
2383     if (cached_has_bits & 0x00000004u) {
2384       _this->_impl_.v8_js_script_iid_ = from._impl_.v8_js_script_iid_;
2385     }
2386     if (cached_has_bits & 0x00000008u) {
2387       _this->_impl_.is_toplevel_ = from._impl_.is_toplevel_;
2388     }
2389     if (cached_has_bits & 0x00000010u) {
2390       _this->_impl_.kind_ = from._impl_.kind_;
2391     }
2392     if (cached_has_bits & 0x00000020u) {
2393       _this->_impl_.byte_offset_ = from._impl_.byte_offset_;
2394     }
2395     _this->_impl_._has_bits_[0] |= cached_has_bits;
2396   }
2397   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2398 }
2399 
CopyFrom(const InternedV8JsFunction & from)2400 void InternedV8JsFunction::CopyFrom(const InternedV8JsFunction& from) {
2401 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.InternedV8JsFunction)
2402   if (&from == this) return;
2403   Clear();
2404   MergeFrom(from);
2405 }
2406 
IsInitialized() const2407 bool InternedV8JsFunction::IsInitialized() const {
2408   return true;
2409 }
2410 
InternalSwap(InternedV8JsFunction * other)2411 void InternedV8JsFunction::InternalSwap(InternedV8JsFunction* other) {
2412   using std::swap;
2413   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2414   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2415   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2416       PROTOBUF_FIELD_OFFSET(InternedV8JsFunction, _impl_.byte_offset_)
2417       + sizeof(InternedV8JsFunction::_impl_.byte_offset_)  // NOLINT
2418       - PROTOBUF_FIELD_OFFSET(InternedV8JsFunction, _impl_.iid_)>(
2419           reinterpret_cast<char*>(&_impl_.iid_),
2420           reinterpret_cast<char*>(&other->_impl_.iid_));
2421 }
2422 
GetTypeName() const2423 std::string InternedV8JsFunction::GetTypeName() const {
2424   return "perfetto.protos.InternedV8JsFunction";
2425 }
2426 
2427 
2428 // ===================================================================
2429 
2430 class InternedV8Isolate_CodeRange::_Internal {
2431  public:
2432   using HasBits = decltype(std::declval<InternedV8Isolate_CodeRange>()._impl_._has_bits_);
set_has_base_address(HasBits * has_bits)2433   static void set_has_base_address(HasBits* has_bits) {
2434     (*has_bits)[0] |= 1u;
2435   }
set_has_size(HasBits * has_bits)2436   static void set_has_size(HasBits* has_bits) {
2437     (*has_bits)[0] |= 2u;
2438   }
set_has_embedded_blob_code_copy_start_address(HasBits * has_bits)2439   static void set_has_embedded_blob_code_copy_start_address(HasBits* has_bits) {
2440     (*has_bits)[0] |= 4u;
2441   }
set_has_is_process_wide(HasBits * has_bits)2442   static void set_has_is_process_wide(HasBits* has_bits) {
2443     (*has_bits)[0] |= 8u;
2444   }
2445 };
2446 
InternedV8Isolate_CodeRange(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2447 InternedV8Isolate_CodeRange::InternedV8Isolate_CodeRange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2448                          bool is_message_owned)
2449   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2450   SharedCtor(arena, is_message_owned);
2451   // @@protoc_insertion_point(arena_constructor:perfetto.protos.InternedV8Isolate.CodeRange)
2452 }
InternedV8Isolate_CodeRange(const InternedV8Isolate_CodeRange & from)2453 InternedV8Isolate_CodeRange::InternedV8Isolate_CodeRange(const InternedV8Isolate_CodeRange& from)
2454   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2455   InternedV8Isolate_CodeRange* const _this = this; (void)_this;
2456   new (&_impl_) Impl_{
2457       decltype(_impl_._has_bits_){from._impl_._has_bits_}
2458     , /*decltype(_impl_._cached_size_)*/{}
2459     , decltype(_impl_.base_address_){}
2460     , decltype(_impl_.size_){}
2461     , decltype(_impl_.embedded_blob_code_copy_start_address_){}
2462     , decltype(_impl_.is_process_wide_){}};
2463 
2464   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2465   ::memcpy(&_impl_.base_address_, &from._impl_.base_address_,
2466     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.is_process_wide_) -
2467     reinterpret_cast<char*>(&_impl_.base_address_)) + sizeof(_impl_.is_process_wide_));
2468   // @@protoc_insertion_point(copy_constructor:perfetto.protos.InternedV8Isolate.CodeRange)
2469 }
2470 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2471 inline void InternedV8Isolate_CodeRange::SharedCtor(
2472     ::_pb::Arena* arena, bool is_message_owned) {
2473   (void)arena;
2474   (void)is_message_owned;
2475   new (&_impl_) Impl_{
2476       decltype(_impl_._has_bits_){}
2477     , /*decltype(_impl_._cached_size_)*/{}
2478     , decltype(_impl_.base_address_){::uint64_t{0u}}
2479     , decltype(_impl_.size_){::uint64_t{0u}}
2480     , decltype(_impl_.embedded_blob_code_copy_start_address_){::uint64_t{0u}}
2481     , decltype(_impl_.is_process_wide_){false}
2482   };
2483 }
2484 
~InternedV8Isolate_CodeRange()2485 InternedV8Isolate_CodeRange::~InternedV8Isolate_CodeRange() {
2486   // @@protoc_insertion_point(destructor:perfetto.protos.InternedV8Isolate.CodeRange)
2487   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2488   (void)arena;
2489     return;
2490   }
2491   SharedDtor();
2492 }
2493 
SharedDtor()2494 inline void InternedV8Isolate_CodeRange::SharedDtor() {
2495   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2496 }
2497 
SetCachedSize(int size) const2498 void InternedV8Isolate_CodeRange::SetCachedSize(int size) const {
2499   _impl_._cached_size_.Set(size);
2500 }
2501 
Clear()2502 void InternedV8Isolate_CodeRange::Clear() {
2503 // @@protoc_insertion_point(message_clear_start:perfetto.protos.InternedV8Isolate.CodeRange)
2504   ::uint32_t cached_has_bits = 0;
2505   // Prevent compiler warnings about cached_has_bits being unused
2506   (void) cached_has_bits;
2507 
2508   cached_has_bits = _impl_._has_bits_[0];
2509   if (cached_has_bits & 0x0000000fu) {
2510     ::memset(&_impl_.base_address_, 0, static_cast<size_t>(
2511         reinterpret_cast<char*>(&_impl_.is_process_wide_) -
2512         reinterpret_cast<char*>(&_impl_.base_address_)) + sizeof(_impl_.is_process_wide_));
2513   }
2514   _impl_._has_bits_.Clear();
2515   _internal_metadata_.Clear<std::string>();
2516 }
2517 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2518 const char* InternedV8Isolate_CodeRange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2519 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2520   _Internal::HasBits has_bits{};
2521   while (!ctx->Done(&ptr)) {
2522     ::uint32_t tag;
2523     ptr = ::_pbi::ReadTag(ptr, &tag);
2524     switch (tag >> 3) {
2525       // optional uint64 base_address = 1;
2526       case 1:
2527         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2528           _Internal::set_has_base_address(&has_bits);
2529           _impl_.base_address_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2530           CHK_(ptr);
2531         } else {
2532           goto handle_unusual;
2533         }
2534         continue;
2535       // optional uint64 size = 2;
2536       case 2:
2537         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2538           _Internal::set_has_size(&has_bits);
2539           _impl_.size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2540           CHK_(ptr);
2541         } else {
2542           goto handle_unusual;
2543         }
2544         continue;
2545       // optional uint64 embedded_blob_code_copy_start_address = 3;
2546       case 3:
2547         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2548           _Internal::set_has_embedded_blob_code_copy_start_address(&has_bits);
2549           _impl_.embedded_blob_code_copy_start_address_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2550           CHK_(ptr);
2551         } else {
2552           goto handle_unusual;
2553         }
2554         continue;
2555       // optional bool is_process_wide = 4;
2556       case 4:
2557         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2558           _Internal::set_has_is_process_wide(&has_bits);
2559           _impl_.is_process_wide_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2560           CHK_(ptr);
2561         } else {
2562           goto handle_unusual;
2563         }
2564         continue;
2565       default:
2566         goto handle_unusual;
2567     }  // switch
2568   handle_unusual:
2569     if ((tag == 0) || ((tag & 7) == 4)) {
2570       CHK_(ptr);
2571       ctx->SetLastTag(tag);
2572       goto message_done;
2573     }
2574     ptr = UnknownFieldParse(
2575         tag,
2576         _internal_metadata_.mutable_unknown_fields<std::string>(),
2577         ptr, ctx);
2578     CHK_(ptr != nullptr);
2579   }  // while
2580 message_done:
2581   _impl_._has_bits_.Or(has_bits);
2582   return ptr;
2583 failure:
2584   ptr = nullptr;
2585   goto message_done;
2586 #undef CHK_
2587 }
2588 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2589 ::uint8_t* InternedV8Isolate_CodeRange::_InternalSerialize(
2590     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2591   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.InternedV8Isolate.CodeRange)
2592   ::uint32_t cached_has_bits = 0;
2593   (void) cached_has_bits;
2594 
2595   cached_has_bits = _impl_._has_bits_[0];
2596   // optional uint64 base_address = 1;
2597   if (cached_has_bits & 0x00000001u) {
2598     target = stream->EnsureSpace(target);
2599     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_base_address(), target);
2600   }
2601 
2602   // optional uint64 size = 2;
2603   if (cached_has_bits & 0x00000002u) {
2604     target = stream->EnsureSpace(target);
2605     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_size(), target);
2606   }
2607 
2608   // optional uint64 embedded_blob_code_copy_start_address = 3;
2609   if (cached_has_bits & 0x00000004u) {
2610     target = stream->EnsureSpace(target);
2611     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_embedded_blob_code_copy_start_address(), target);
2612   }
2613 
2614   // optional bool is_process_wide = 4;
2615   if (cached_has_bits & 0x00000008u) {
2616     target = stream->EnsureSpace(target);
2617     target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_is_process_wide(), target);
2618   }
2619 
2620   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2621     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2622         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2623   }
2624   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.InternedV8Isolate.CodeRange)
2625   return target;
2626 }
2627 
ByteSizeLong() const2628 size_t InternedV8Isolate_CodeRange::ByteSizeLong() const {
2629 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.InternedV8Isolate.CodeRange)
2630   size_t total_size = 0;
2631 
2632   ::uint32_t cached_has_bits = 0;
2633   // Prevent compiler warnings about cached_has_bits being unused
2634   (void) cached_has_bits;
2635 
2636   cached_has_bits = _impl_._has_bits_[0];
2637   if (cached_has_bits & 0x0000000fu) {
2638     // optional uint64 base_address = 1;
2639     if (cached_has_bits & 0x00000001u) {
2640       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_base_address());
2641     }
2642 
2643     // optional uint64 size = 2;
2644     if (cached_has_bits & 0x00000002u) {
2645       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_size());
2646     }
2647 
2648     // optional uint64 embedded_blob_code_copy_start_address = 3;
2649     if (cached_has_bits & 0x00000004u) {
2650       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_embedded_blob_code_copy_start_address());
2651     }
2652 
2653     // optional bool is_process_wide = 4;
2654     if (cached_has_bits & 0x00000008u) {
2655       total_size += 1 + 1;
2656     }
2657 
2658   }
2659   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2660     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2661   }
2662   int cached_size = ::_pbi::ToCachedSize(total_size);
2663   SetCachedSize(cached_size);
2664   return total_size;
2665 }
2666 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2667 void InternedV8Isolate_CodeRange::CheckTypeAndMergeFrom(
2668     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2669   MergeFrom(*::_pbi::DownCast<const InternedV8Isolate_CodeRange*>(
2670       &from));
2671 }
2672 
MergeFrom(const InternedV8Isolate_CodeRange & from)2673 void InternedV8Isolate_CodeRange::MergeFrom(const InternedV8Isolate_CodeRange& from) {
2674   InternedV8Isolate_CodeRange* const _this = this;
2675   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.InternedV8Isolate.CodeRange)
2676   GOOGLE_DCHECK_NE(&from, _this);
2677   ::uint32_t cached_has_bits = 0;
2678   (void) cached_has_bits;
2679 
2680   cached_has_bits = from._impl_._has_bits_[0];
2681   if (cached_has_bits & 0x0000000fu) {
2682     if (cached_has_bits & 0x00000001u) {
2683       _this->_impl_.base_address_ = from._impl_.base_address_;
2684     }
2685     if (cached_has_bits & 0x00000002u) {
2686       _this->_impl_.size_ = from._impl_.size_;
2687     }
2688     if (cached_has_bits & 0x00000004u) {
2689       _this->_impl_.embedded_blob_code_copy_start_address_ = from._impl_.embedded_blob_code_copy_start_address_;
2690     }
2691     if (cached_has_bits & 0x00000008u) {
2692       _this->_impl_.is_process_wide_ = from._impl_.is_process_wide_;
2693     }
2694     _this->_impl_._has_bits_[0] |= cached_has_bits;
2695   }
2696   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2697 }
2698 
CopyFrom(const InternedV8Isolate_CodeRange & from)2699 void InternedV8Isolate_CodeRange::CopyFrom(const InternedV8Isolate_CodeRange& from) {
2700 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.InternedV8Isolate.CodeRange)
2701   if (&from == this) return;
2702   Clear();
2703   MergeFrom(from);
2704 }
2705 
IsInitialized() const2706 bool InternedV8Isolate_CodeRange::IsInitialized() const {
2707   return true;
2708 }
2709 
InternalSwap(InternedV8Isolate_CodeRange * other)2710 void InternedV8Isolate_CodeRange::InternalSwap(InternedV8Isolate_CodeRange* other) {
2711   using std::swap;
2712   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2713   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2714   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2715       PROTOBUF_FIELD_OFFSET(InternedV8Isolate_CodeRange, _impl_.is_process_wide_)
2716       + sizeof(InternedV8Isolate_CodeRange::_impl_.is_process_wide_)  // NOLINT
2717       - PROTOBUF_FIELD_OFFSET(InternedV8Isolate_CodeRange, _impl_.base_address_)>(
2718           reinterpret_cast<char*>(&_impl_.base_address_),
2719           reinterpret_cast<char*>(&other->_impl_.base_address_));
2720 }
2721 
GetTypeName() const2722 std::string InternedV8Isolate_CodeRange::GetTypeName() const {
2723   return "perfetto.protos.InternedV8Isolate.CodeRange";
2724 }
2725 
2726 
2727 // ===================================================================
2728 
2729 class InternedV8Isolate::_Internal {
2730  public:
2731   using HasBits = decltype(std::declval<InternedV8Isolate>()._impl_._has_bits_);
set_has_iid(HasBits * has_bits)2732   static void set_has_iid(HasBits* has_bits) {
2733     (*has_bits)[0] |= 2u;
2734   }
set_has_pid(HasBits * has_bits)2735   static void set_has_pid(HasBits* has_bits) {
2736     (*has_bits)[0] |= 4u;
2737   }
set_has_isolate_id(HasBits * has_bits)2738   static void set_has_isolate_id(HasBits* has_bits) {
2739     (*has_bits)[0] |= 8u;
2740   }
2741   static const ::perfetto::protos::InternedV8Isolate_CodeRange& code_range(const InternedV8Isolate* msg);
set_has_code_range(HasBits * has_bits)2742   static void set_has_code_range(HasBits* has_bits) {
2743     (*has_bits)[0] |= 1u;
2744   }
set_has_embedded_blob_code_start_address(HasBits * has_bits)2745   static void set_has_embedded_blob_code_start_address(HasBits* has_bits) {
2746     (*has_bits)[0] |= 16u;
2747   }
set_has_embedded_blob_code_size(HasBits * has_bits)2748   static void set_has_embedded_blob_code_size(HasBits* has_bits) {
2749     (*has_bits)[0] |= 32u;
2750   }
2751 };
2752 
2753 const ::perfetto::protos::InternedV8Isolate_CodeRange&
code_range(const InternedV8Isolate * msg)2754 InternedV8Isolate::_Internal::code_range(const InternedV8Isolate* msg) {
2755   return *msg->_impl_.code_range_;
2756 }
InternedV8Isolate(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2757 InternedV8Isolate::InternedV8Isolate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2758                          bool is_message_owned)
2759   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2760   SharedCtor(arena, is_message_owned);
2761   // @@protoc_insertion_point(arena_constructor:perfetto.protos.InternedV8Isolate)
2762 }
InternedV8Isolate(const InternedV8Isolate & from)2763 InternedV8Isolate::InternedV8Isolate(const InternedV8Isolate& from)
2764   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2765   InternedV8Isolate* const _this = this; (void)_this;
2766   new (&_impl_) Impl_{
2767       decltype(_impl_._has_bits_){from._impl_._has_bits_}
2768     , /*decltype(_impl_._cached_size_)*/{}
2769     , decltype(_impl_.code_range_){nullptr}
2770     , decltype(_impl_.iid_){}
2771     , decltype(_impl_.pid_){}
2772     , decltype(_impl_.isolate_id_){}
2773     , decltype(_impl_.embedded_blob_code_start_address_){}
2774     , decltype(_impl_.embedded_blob_code_size_){}};
2775 
2776   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2777   if (from._internal_has_code_range()) {
2778     _this->_impl_.code_range_ = new ::perfetto::protos::InternedV8Isolate_CodeRange(*from._impl_.code_range_);
2779   }
2780   ::memcpy(&_impl_.iid_, &from._impl_.iid_,
2781     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.embedded_blob_code_size_) -
2782     reinterpret_cast<char*>(&_impl_.iid_)) + sizeof(_impl_.embedded_blob_code_size_));
2783   // @@protoc_insertion_point(copy_constructor:perfetto.protos.InternedV8Isolate)
2784 }
2785 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2786 inline void InternedV8Isolate::SharedCtor(
2787     ::_pb::Arena* arena, bool is_message_owned) {
2788   (void)arena;
2789   (void)is_message_owned;
2790   new (&_impl_) Impl_{
2791       decltype(_impl_._has_bits_){}
2792     , /*decltype(_impl_._cached_size_)*/{}
2793     , decltype(_impl_.code_range_){nullptr}
2794     , decltype(_impl_.iid_){::uint64_t{0u}}
2795     , decltype(_impl_.pid_){0u}
2796     , decltype(_impl_.isolate_id_){0}
2797     , decltype(_impl_.embedded_blob_code_start_address_){::uint64_t{0u}}
2798     , decltype(_impl_.embedded_blob_code_size_){::uint64_t{0u}}
2799   };
2800 }
2801 
~InternedV8Isolate()2802 InternedV8Isolate::~InternedV8Isolate() {
2803   // @@protoc_insertion_point(destructor:perfetto.protos.InternedV8Isolate)
2804   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2805   (void)arena;
2806     return;
2807   }
2808   SharedDtor();
2809 }
2810 
SharedDtor()2811 inline void InternedV8Isolate::SharedDtor() {
2812   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2813   if (this != internal_default_instance()) delete _impl_.code_range_;
2814 }
2815 
SetCachedSize(int size) const2816 void InternedV8Isolate::SetCachedSize(int size) const {
2817   _impl_._cached_size_.Set(size);
2818 }
2819 
Clear()2820 void InternedV8Isolate::Clear() {
2821 // @@protoc_insertion_point(message_clear_start:perfetto.protos.InternedV8Isolate)
2822   ::uint32_t cached_has_bits = 0;
2823   // Prevent compiler warnings about cached_has_bits being unused
2824   (void) cached_has_bits;
2825 
2826   cached_has_bits = _impl_._has_bits_[0];
2827   if (cached_has_bits & 0x00000001u) {
2828     GOOGLE_DCHECK(_impl_.code_range_ != nullptr);
2829     _impl_.code_range_->Clear();
2830   }
2831   if (cached_has_bits & 0x0000003eu) {
2832     ::memset(&_impl_.iid_, 0, static_cast<size_t>(
2833         reinterpret_cast<char*>(&_impl_.embedded_blob_code_size_) -
2834         reinterpret_cast<char*>(&_impl_.iid_)) + sizeof(_impl_.embedded_blob_code_size_));
2835   }
2836   _impl_._has_bits_.Clear();
2837   _internal_metadata_.Clear<std::string>();
2838 }
2839 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2840 const char* InternedV8Isolate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2841 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2842   _Internal::HasBits has_bits{};
2843   while (!ctx->Done(&ptr)) {
2844     ::uint32_t tag;
2845     ptr = ::_pbi::ReadTag(ptr, &tag);
2846     switch (tag >> 3) {
2847       // optional uint64 iid = 1;
2848       case 1:
2849         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2850           _Internal::set_has_iid(&has_bits);
2851           _impl_.iid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2852           CHK_(ptr);
2853         } else {
2854           goto handle_unusual;
2855         }
2856         continue;
2857       // optional uint32 pid = 2;
2858       case 2:
2859         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2860           _Internal::set_has_pid(&has_bits);
2861           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2862           CHK_(ptr);
2863         } else {
2864           goto handle_unusual;
2865         }
2866         continue;
2867       // optional int32 isolate_id = 3;
2868       case 3:
2869         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2870           _Internal::set_has_isolate_id(&has_bits);
2871           _impl_.isolate_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2872           CHK_(ptr);
2873         } else {
2874           goto handle_unusual;
2875         }
2876         continue;
2877       // optional .perfetto.protos.InternedV8Isolate.CodeRange code_range = 4;
2878       case 4:
2879         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
2880           ptr = ctx->ParseMessage(_internal_mutable_code_range(), ptr);
2881           CHK_(ptr);
2882         } else {
2883           goto handle_unusual;
2884         }
2885         continue;
2886       // optional uint64 embedded_blob_code_start_address = 5;
2887       case 5:
2888         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
2889           _Internal::set_has_embedded_blob_code_start_address(&has_bits);
2890           _impl_.embedded_blob_code_start_address_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2891           CHK_(ptr);
2892         } else {
2893           goto handle_unusual;
2894         }
2895         continue;
2896       // optional uint64 embedded_blob_code_size = 6;
2897       case 6:
2898         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
2899           _Internal::set_has_embedded_blob_code_size(&has_bits);
2900           _impl_.embedded_blob_code_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2901           CHK_(ptr);
2902         } else {
2903           goto handle_unusual;
2904         }
2905         continue;
2906       default:
2907         goto handle_unusual;
2908     }  // switch
2909   handle_unusual:
2910     if ((tag == 0) || ((tag & 7) == 4)) {
2911       CHK_(ptr);
2912       ctx->SetLastTag(tag);
2913       goto message_done;
2914     }
2915     ptr = UnknownFieldParse(
2916         tag,
2917         _internal_metadata_.mutable_unknown_fields<std::string>(),
2918         ptr, ctx);
2919     CHK_(ptr != nullptr);
2920   }  // while
2921 message_done:
2922   _impl_._has_bits_.Or(has_bits);
2923   return ptr;
2924 failure:
2925   ptr = nullptr;
2926   goto message_done;
2927 #undef CHK_
2928 }
2929 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2930 ::uint8_t* InternedV8Isolate::_InternalSerialize(
2931     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2932   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.InternedV8Isolate)
2933   ::uint32_t cached_has_bits = 0;
2934   (void) cached_has_bits;
2935 
2936   cached_has_bits = _impl_._has_bits_[0];
2937   // optional uint64 iid = 1;
2938   if (cached_has_bits & 0x00000002u) {
2939     target = stream->EnsureSpace(target);
2940     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_iid(), target);
2941   }
2942 
2943   // optional uint32 pid = 2;
2944   if (cached_has_bits & 0x00000004u) {
2945     target = stream->EnsureSpace(target);
2946     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_pid(), target);
2947   }
2948 
2949   // optional int32 isolate_id = 3;
2950   if (cached_has_bits & 0x00000008u) {
2951     target = stream->EnsureSpace(target);
2952     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_isolate_id(), target);
2953   }
2954 
2955   // optional .perfetto.protos.InternedV8Isolate.CodeRange code_range = 4;
2956   if (cached_has_bits & 0x00000001u) {
2957     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2958       InternalWriteMessage(4, _Internal::code_range(this),
2959         _Internal::code_range(this).GetCachedSize(), target, stream);
2960   }
2961 
2962   // optional uint64 embedded_blob_code_start_address = 5;
2963   if (cached_has_bits & 0x00000010u) {
2964     target = stream->EnsureSpace(target);
2965     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_embedded_blob_code_start_address(), target);
2966   }
2967 
2968   // optional uint64 embedded_blob_code_size = 6;
2969   if (cached_has_bits & 0x00000020u) {
2970     target = stream->EnsureSpace(target);
2971     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_embedded_blob_code_size(), target);
2972   }
2973 
2974   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2975     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2976         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2977   }
2978   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.InternedV8Isolate)
2979   return target;
2980 }
2981 
ByteSizeLong() const2982 size_t InternedV8Isolate::ByteSizeLong() const {
2983 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.InternedV8Isolate)
2984   size_t total_size = 0;
2985 
2986   ::uint32_t cached_has_bits = 0;
2987   // Prevent compiler warnings about cached_has_bits being unused
2988   (void) cached_has_bits;
2989 
2990   cached_has_bits = _impl_._has_bits_[0];
2991   if (cached_has_bits & 0x0000003fu) {
2992     // optional .perfetto.protos.InternedV8Isolate.CodeRange code_range = 4;
2993     if (cached_has_bits & 0x00000001u) {
2994       total_size += 1 +
2995         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2996           *_impl_.code_range_);
2997     }
2998 
2999     // optional uint64 iid = 1;
3000     if (cached_has_bits & 0x00000002u) {
3001       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_iid());
3002     }
3003 
3004     // optional uint32 pid = 2;
3005     if (cached_has_bits & 0x00000004u) {
3006       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_pid());
3007     }
3008 
3009     // optional int32 isolate_id = 3;
3010     if (cached_has_bits & 0x00000008u) {
3011       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_isolate_id());
3012     }
3013 
3014     // optional uint64 embedded_blob_code_start_address = 5;
3015     if (cached_has_bits & 0x00000010u) {
3016       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_embedded_blob_code_start_address());
3017     }
3018 
3019     // optional uint64 embedded_blob_code_size = 6;
3020     if (cached_has_bits & 0x00000020u) {
3021       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_embedded_blob_code_size());
3022     }
3023 
3024   }
3025   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3026     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3027   }
3028   int cached_size = ::_pbi::ToCachedSize(total_size);
3029   SetCachedSize(cached_size);
3030   return total_size;
3031 }
3032 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3033 void InternedV8Isolate::CheckTypeAndMergeFrom(
3034     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3035   MergeFrom(*::_pbi::DownCast<const InternedV8Isolate*>(
3036       &from));
3037 }
3038 
MergeFrom(const InternedV8Isolate & from)3039 void InternedV8Isolate::MergeFrom(const InternedV8Isolate& from) {
3040   InternedV8Isolate* const _this = this;
3041   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.InternedV8Isolate)
3042   GOOGLE_DCHECK_NE(&from, _this);
3043   ::uint32_t cached_has_bits = 0;
3044   (void) cached_has_bits;
3045 
3046   cached_has_bits = from._impl_._has_bits_[0];
3047   if (cached_has_bits & 0x0000003fu) {
3048     if (cached_has_bits & 0x00000001u) {
3049       _this->_internal_mutable_code_range()->::perfetto::protos::InternedV8Isolate_CodeRange::MergeFrom(
3050           from._internal_code_range());
3051     }
3052     if (cached_has_bits & 0x00000002u) {
3053       _this->_impl_.iid_ = from._impl_.iid_;
3054     }
3055     if (cached_has_bits & 0x00000004u) {
3056       _this->_impl_.pid_ = from._impl_.pid_;
3057     }
3058     if (cached_has_bits & 0x00000008u) {
3059       _this->_impl_.isolate_id_ = from._impl_.isolate_id_;
3060     }
3061     if (cached_has_bits & 0x00000010u) {
3062       _this->_impl_.embedded_blob_code_start_address_ = from._impl_.embedded_blob_code_start_address_;
3063     }
3064     if (cached_has_bits & 0x00000020u) {
3065       _this->_impl_.embedded_blob_code_size_ = from._impl_.embedded_blob_code_size_;
3066     }
3067     _this->_impl_._has_bits_[0] |= cached_has_bits;
3068   }
3069   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3070 }
3071 
CopyFrom(const InternedV8Isolate & from)3072 void InternedV8Isolate::CopyFrom(const InternedV8Isolate& from) {
3073 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.InternedV8Isolate)
3074   if (&from == this) return;
3075   Clear();
3076   MergeFrom(from);
3077 }
3078 
IsInitialized() const3079 bool InternedV8Isolate::IsInitialized() const {
3080   return true;
3081 }
3082 
InternalSwap(InternedV8Isolate * other)3083 void InternedV8Isolate::InternalSwap(InternedV8Isolate* other) {
3084   using std::swap;
3085   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3086   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3087   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3088       PROTOBUF_FIELD_OFFSET(InternedV8Isolate, _impl_.embedded_blob_code_size_)
3089       + sizeof(InternedV8Isolate::_impl_.embedded_blob_code_size_)  // NOLINT
3090       - PROTOBUF_FIELD_OFFSET(InternedV8Isolate, _impl_.code_range_)>(
3091           reinterpret_cast<char*>(&_impl_.code_range_),
3092           reinterpret_cast<char*>(&other->_impl_.code_range_));
3093 }
3094 
GetTypeName() const3095 std::string InternedV8Isolate::GetTypeName() const {
3096   return "perfetto.protos.InternedV8Isolate";
3097 }
3098 
3099 
3100 // ===================================================================
3101 
3102 class V8JsCode::_Internal {
3103  public:
3104   using HasBits = decltype(std::declval<V8JsCode>()._impl_._has_bits_);
set_has_v8_isolate_iid(HasBits * has_bits)3105   static void set_has_v8_isolate_iid(HasBits* has_bits) {
3106     (*has_bits)[0] |= 1u;
3107   }
set_has_tid(HasBits * has_bits)3108   static void set_has_tid(HasBits* has_bits) {
3109     (*has_bits)[0] |= 4u;
3110   }
set_has_v8_js_function_iid(HasBits * has_bits)3111   static void set_has_v8_js_function_iid(HasBits* has_bits) {
3112     (*has_bits)[0] |= 2u;
3113   }
set_has_tier(HasBits * has_bits)3114   static void set_has_tier(HasBits* has_bits) {
3115     (*has_bits)[0] |= 8u;
3116   }
set_has_instruction_start(HasBits * has_bits)3117   static void set_has_instruction_start(HasBits* has_bits) {
3118     (*has_bits)[0] |= 16u;
3119   }
set_has_instruction_size_bytes(HasBits * has_bits)3120   static void set_has_instruction_size_bytes(HasBits* has_bits) {
3121     (*has_bits)[0] |= 32u;
3122   }
3123 };
3124 
V8JsCode(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3125 V8JsCode::V8JsCode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3126                          bool is_message_owned)
3127   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3128   SharedCtor(arena, is_message_owned);
3129   // @@protoc_insertion_point(arena_constructor:perfetto.protos.V8JsCode)
3130 }
V8JsCode(const V8JsCode & from)3131 V8JsCode::V8JsCode(const V8JsCode& from)
3132   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3133   V8JsCode* const _this = this; (void)_this;
3134   new (&_impl_) Impl_{
3135       decltype(_impl_._has_bits_){from._impl_._has_bits_}
3136     , /*decltype(_impl_._cached_size_)*/{}
3137     , decltype(_impl_.v8_isolate_iid_){}
3138     , decltype(_impl_.v8_js_function_iid_){}
3139     , decltype(_impl_.tid_){}
3140     , decltype(_impl_.tier_){}
3141     , decltype(_impl_.instruction_start_){}
3142     , decltype(_impl_.instruction_size_bytes_){}
3143     , decltype(_impl_.instructions_){}
3144     , /*decltype(_impl_._oneof_case_)*/{}};
3145 
3146   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3147   ::memcpy(&_impl_.v8_isolate_iid_, &from._impl_.v8_isolate_iid_,
3148     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.instruction_size_bytes_) -
3149     reinterpret_cast<char*>(&_impl_.v8_isolate_iid_)) + sizeof(_impl_.instruction_size_bytes_));
3150   clear_has_instructions();
3151   switch (from.instructions_case()) {
3152     case kMachineCode: {
3153       _this->_internal_set_machine_code(from._internal_machine_code());
3154       break;
3155     }
3156     case kBytecode: {
3157       _this->_internal_set_bytecode(from._internal_bytecode());
3158       break;
3159     }
3160     case INSTRUCTIONS_NOT_SET: {
3161       break;
3162     }
3163   }
3164   // @@protoc_insertion_point(copy_constructor:perfetto.protos.V8JsCode)
3165 }
3166 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3167 inline void V8JsCode::SharedCtor(
3168     ::_pb::Arena* arena, bool is_message_owned) {
3169   (void)arena;
3170   (void)is_message_owned;
3171   new (&_impl_) Impl_{
3172       decltype(_impl_._has_bits_){}
3173     , /*decltype(_impl_._cached_size_)*/{}
3174     , decltype(_impl_.v8_isolate_iid_){::uint64_t{0u}}
3175     , decltype(_impl_.v8_js_function_iid_){::uint64_t{0u}}
3176     , decltype(_impl_.tid_){0u}
3177     , decltype(_impl_.tier_){0}
3178     , decltype(_impl_.instruction_start_){::uint64_t{0u}}
3179     , decltype(_impl_.instruction_size_bytes_){::uint64_t{0u}}
3180     , decltype(_impl_.instructions_){}
3181     , /*decltype(_impl_._oneof_case_)*/{}
3182   };
3183   clear_has_instructions();
3184 }
3185 
~V8JsCode()3186 V8JsCode::~V8JsCode() {
3187   // @@protoc_insertion_point(destructor:perfetto.protos.V8JsCode)
3188   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3189   (void)arena;
3190     return;
3191   }
3192   SharedDtor();
3193 }
3194 
SharedDtor()3195 inline void V8JsCode::SharedDtor() {
3196   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3197   if (has_instructions()) {
3198     clear_instructions();
3199   }
3200 }
3201 
SetCachedSize(int size) const3202 void V8JsCode::SetCachedSize(int size) const {
3203   _impl_._cached_size_.Set(size);
3204 }
3205 
clear_instructions()3206 void V8JsCode::clear_instructions() {
3207 // @@protoc_insertion_point(one_of_clear_start:perfetto.protos.V8JsCode)
3208   switch (instructions_case()) {
3209     case kMachineCode: {
3210       _impl_.instructions_.machine_code_.Destroy();
3211       break;
3212     }
3213     case kBytecode: {
3214       _impl_.instructions_.bytecode_.Destroy();
3215       break;
3216     }
3217     case INSTRUCTIONS_NOT_SET: {
3218       break;
3219     }
3220   }
3221   _impl_._oneof_case_[0] = INSTRUCTIONS_NOT_SET;
3222 }
3223 
3224 
Clear()3225 void V8JsCode::Clear() {
3226 // @@protoc_insertion_point(message_clear_start:perfetto.protos.V8JsCode)
3227   ::uint32_t cached_has_bits = 0;
3228   // Prevent compiler warnings about cached_has_bits being unused
3229   (void) cached_has_bits;
3230 
3231   cached_has_bits = _impl_._has_bits_[0];
3232   if (cached_has_bits & 0x0000003fu) {
3233     ::memset(&_impl_.v8_isolate_iid_, 0, static_cast<size_t>(
3234         reinterpret_cast<char*>(&_impl_.instruction_size_bytes_) -
3235         reinterpret_cast<char*>(&_impl_.v8_isolate_iid_)) + sizeof(_impl_.instruction_size_bytes_));
3236   }
3237   clear_instructions();
3238   _impl_._has_bits_.Clear();
3239   _internal_metadata_.Clear<std::string>();
3240 }
3241 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3242 const char* V8JsCode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3243 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3244   _Internal::HasBits has_bits{};
3245   while (!ctx->Done(&ptr)) {
3246     ::uint32_t tag;
3247     ptr = ::_pbi::ReadTag(ptr, &tag);
3248     switch (tag >> 3) {
3249       // optional uint64 v8_isolate_iid = 1;
3250       case 1:
3251         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3252           _Internal::set_has_v8_isolate_iid(&has_bits);
3253           _impl_.v8_isolate_iid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3254           CHK_(ptr);
3255         } else {
3256           goto handle_unusual;
3257         }
3258         continue;
3259       // optional uint32 tid = 2;
3260       case 2:
3261         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3262           _Internal::set_has_tid(&has_bits);
3263           _impl_.tid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3264           CHK_(ptr);
3265         } else {
3266           goto handle_unusual;
3267         }
3268         continue;
3269       // optional uint64 v8_js_function_iid = 3;
3270       case 3:
3271         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3272           _Internal::set_has_v8_js_function_iid(&has_bits);
3273           _impl_.v8_js_function_iid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3274           CHK_(ptr);
3275         } else {
3276           goto handle_unusual;
3277         }
3278         continue;
3279       // optional .perfetto.protos.V8JsCode.Tier tier = 4;
3280       case 4:
3281         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
3282           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3283           CHK_(ptr);
3284           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::V8JsCode_Tier_IsValid(val))) {
3285             _internal_set_tier(static_cast<::perfetto::protos::V8JsCode_Tier>(val));
3286           } else {
3287             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
3288           }
3289         } else {
3290           goto handle_unusual;
3291         }
3292         continue;
3293       // optional uint64 instruction_start = 5;
3294       case 5:
3295         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
3296           _Internal::set_has_instruction_start(&has_bits);
3297           _impl_.instruction_start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3298           CHK_(ptr);
3299         } else {
3300           goto handle_unusual;
3301         }
3302         continue;
3303       // optional uint64 instruction_size_bytes = 6;
3304       case 6:
3305         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
3306           _Internal::set_has_instruction_size_bytes(&has_bits);
3307           _impl_.instruction_size_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3308           CHK_(ptr);
3309         } else {
3310           goto handle_unusual;
3311         }
3312         continue;
3313       // bytes machine_code = 7;
3314       case 7:
3315         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
3316           auto str = _internal_mutable_machine_code();
3317           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3318           CHK_(ptr);
3319         } else {
3320           goto handle_unusual;
3321         }
3322         continue;
3323       // bytes bytecode = 8;
3324       case 8:
3325         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
3326           auto str = _internal_mutable_bytecode();
3327           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3328           CHK_(ptr);
3329         } else {
3330           goto handle_unusual;
3331         }
3332         continue;
3333       default:
3334         goto handle_unusual;
3335     }  // switch
3336   handle_unusual:
3337     if ((tag == 0) || ((tag & 7) == 4)) {
3338       CHK_(ptr);
3339       ctx->SetLastTag(tag);
3340       goto message_done;
3341     }
3342     ptr = UnknownFieldParse(
3343         tag,
3344         _internal_metadata_.mutable_unknown_fields<std::string>(),
3345         ptr, ctx);
3346     CHK_(ptr != nullptr);
3347   }  // while
3348 message_done:
3349   _impl_._has_bits_.Or(has_bits);
3350   return ptr;
3351 failure:
3352   ptr = nullptr;
3353   goto message_done;
3354 #undef CHK_
3355 }
3356 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3357 ::uint8_t* V8JsCode::_InternalSerialize(
3358     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3359   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.V8JsCode)
3360   ::uint32_t cached_has_bits = 0;
3361   (void) cached_has_bits;
3362 
3363   cached_has_bits = _impl_._has_bits_[0];
3364   // optional uint64 v8_isolate_iid = 1;
3365   if (cached_has_bits & 0x00000001u) {
3366     target = stream->EnsureSpace(target);
3367     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_v8_isolate_iid(), target);
3368   }
3369 
3370   // optional uint32 tid = 2;
3371   if (cached_has_bits & 0x00000004u) {
3372     target = stream->EnsureSpace(target);
3373     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_tid(), target);
3374   }
3375 
3376   // optional uint64 v8_js_function_iid = 3;
3377   if (cached_has_bits & 0x00000002u) {
3378     target = stream->EnsureSpace(target);
3379     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_v8_js_function_iid(), target);
3380   }
3381 
3382   // optional .perfetto.protos.V8JsCode.Tier tier = 4;
3383   if (cached_has_bits & 0x00000008u) {
3384     target = stream->EnsureSpace(target);
3385     target = ::_pbi::WireFormatLite::WriteEnumToArray(
3386       4, this->_internal_tier(), target);
3387   }
3388 
3389   // optional uint64 instruction_start = 5;
3390   if (cached_has_bits & 0x00000010u) {
3391     target = stream->EnsureSpace(target);
3392     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_instruction_start(), target);
3393   }
3394 
3395   // optional uint64 instruction_size_bytes = 6;
3396   if (cached_has_bits & 0x00000020u) {
3397     target = stream->EnsureSpace(target);
3398     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_instruction_size_bytes(), target);
3399   }
3400 
3401   switch (instructions_case()) {
3402     case kMachineCode: {
3403       target = stream->WriteBytesMaybeAliased(
3404           7, this->_internal_machine_code(), target);
3405       break;
3406     }
3407     case kBytecode: {
3408       target = stream->WriteBytesMaybeAliased(
3409           8, this->_internal_bytecode(), target);
3410       break;
3411     }
3412     default: ;
3413   }
3414   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3415     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3416         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3417   }
3418   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.V8JsCode)
3419   return target;
3420 }
3421 
ByteSizeLong() const3422 size_t V8JsCode::ByteSizeLong() const {
3423 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.V8JsCode)
3424   size_t total_size = 0;
3425 
3426   ::uint32_t cached_has_bits = 0;
3427   // Prevent compiler warnings about cached_has_bits being unused
3428   (void) cached_has_bits;
3429 
3430   cached_has_bits = _impl_._has_bits_[0];
3431   if (cached_has_bits & 0x0000003fu) {
3432     // optional uint64 v8_isolate_iid = 1;
3433     if (cached_has_bits & 0x00000001u) {
3434       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_v8_isolate_iid());
3435     }
3436 
3437     // optional uint64 v8_js_function_iid = 3;
3438     if (cached_has_bits & 0x00000002u) {
3439       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_v8_js_function_iid());
3440     }
3441 
3442     // optional uint32 tid = 2;
3443     if (cached_has_bits & 0x00000004u) {
3444       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tid());
3445     }
3446 
3447     // optional .perfetto.protos.V8JsCode.Tier tier = 4;
3448     if (cached_has_bits & 0x00000008u) {
3449       total_size += 1 +
3450         ::_pbi::WireFormatLite::EnumSize(this->_internal_tier());
3451     }
3452 
3453     // optional uint64 instruction_start = 5;
3454     if (cached_has_bits & 0x00000010u) {
3455       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_instruction_start());
3456     }
3457 
3458     // optional uint64 instruction_size_bytes = 6;
3459     if (cached_has_bits & 0x00000020u) {
3460       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_instruction_size_bytes());
3461     }
3462 
3463   }
3464   switch (instructions_case()) {
3465     // bytes machine_code = 7;
3466     case kMachineCode: {
3467       total_size += 1 +
3468         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
3469           this->_internal_machine_code());
3470       break;
3471     }
3472     // bytes bytecode = 8;
3473     case kBytecode: {
3474       total_size += 1 +
3475         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
3476           this->_internal_bytecode());
3477       break;
3478     }
3479     case INSTRUCTIONS_NOT_SET: {
3480       break;
3481     }
3482   }
3483   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3484     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3485   }
3486   int cached_size = ::_pbi::ToCachedSize(total_size);
3487   SetCachedSize(cached_size);
3488   return total_size;
3489 }
3490 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3491 void V8JsCode::CheckTypeAndMergeFrom(
3492     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3493   MergeFrom(*::_pbi::DownCast<const V8JsCode*>(
3494       &from));
3495 }
3496 
MergeFrom(const V8JsCode & from)3497 void V8JsCode::MergeFrom(const V8JsCode& from) {
3498   V8JsCode* const _this = this;
3499   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.V8JsCode)
3500   GOOGLE_DCHECK_NE(&from, _this);
3501   ::uint32_t cached_has_bits = 0;
3502   (void) cached_has_bits;
3503 
3504   cached_has_bits = from._impl_._has_bits_[0];
3505   if (cached_has_bits & 0x0000003fu) {
3506     if (cached_has_bits & 0x00000001u) {
3507       _this->_impl_.v8_isolate_iid_ = from._impl_.v8_isolate_iid_;
3508     }
3509     if (cached_has_bits & 0x00000002u) {
3510       _this->_impl_.v8_js_function_iid_ = from._impl_.v8_js_function_iid_;
3511     }
3512     if (cached_has_bits & 0x00000004u) {
3513       _this->_impl_.tid_ = from._impl_.tid_;
3514     }
3515     if (cached_has_bits & 0x00000008u) {
3516       _this->_impl_.tier_ = from._impl_.tier_;
3517     }
3518     if (cached_has_bits & 0x00000010u) {
3519       _this->_impl_.instruction_start_ = from._impl_.instruction_start_;
3520     }
3521     if (cached_has_bits & 0x00000020u) {
3522       _this->_impl_.instruction_size_bytes_ = from._impl_.instruction_size_bytes_;
3523     }
3524     _this->_impl_._has_bits_[0] |= cached_has_bits;
3525   }
3526   switch (from.instructions_case()) {
3527     case kMachineCode: {
3528       _this->_internal_set_machine_code(from._internal_machine_code());
3529       break;
3530     }
3531     case kBytecode: {
3532       _this->_internal_set_bytecode(from._internal_bytecode());
3533       break;
3534     }
3535     case INSTRUCTIONS_NOT_SET: {
3536       break;
3537     }
3538   }
3539   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3540 }
3541 
CopyFrom(const V8JsCode & from)3542 void V8JsCode::CopyFrom(const V8JsCode& from) {
3543 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.V8JsCode)
3544   if (&from == this) return;
3545   Clear();
3546   MergeFrom(from);
3547 }
3548 
IsInitialized() const3549 bool V8JsCode::IsInitialized() const {
3550   return true;
3551 }
3552 
InternalSwap(V8JsCode * other)3553 void V8JsCode::InternalSwap(V8JsCode* other) {
3554   using std::swap;
3555   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3556   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3557   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3558       PROTOBUF_FIELD_OFFSET(V8JsCode, _impl_.instruction_size_bytes_)
3559       + sizeof(V8JsCode::_impl_.instruction_size_bytes_)  // NOLINT
3560       - PROTOBUF_FIELD_OFFSET(V8JsCode, _impl_.v8_isolate_iid_)>(
3561           reinterpret_cast<char*>(&_impl_.v8_isolate_iid_),
3562           reinterpret_cast<char*>(&other->_impl_.v8_isolate_iid_));
3563   swap(_impl_.instructions_, other->_impl_.instructions_);
3564   swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
3565 }
3566 
GetTypeName() const3567 std::string V8JsCode::GetTypeName() const {
3568   return "perfetto.protos.V8JsCode";
3569 }
3570 
3571 
3572 // ===================================================================
3573 
3574 class V8InternalCode::_Internal {
3575  public:
3576   using HasBits = decltype(std::declval<V8InternalCode>()._impl_._has_bits_);
set_has_v8_isolate_iid(HasBits * has_bits)3577   static void set_has_v8_isolate_iid(HasBits* has_bits) {
3578     (*has_bits)[0] |= 4u;
3579   }
set_has_tid(HasBits * has_bits)3580   static void set_has_tid(HasBits* has_bits) {
3581     (*has_bits)[0] |= 8u;
3582   }
set_has_name(HasBits * has_bits)3583   static void set_has_name(HasBits* has_bits) {
3584     (*has_bits)[0] |= 1u;
3585   }
set_has_type(HasBits * has_bits)3586   static void set_has_type(HasBits* has_bits) {
3587     (*has_bits)[0] |= 16u;
3588   }
set_has_builtin_id(HasBits * has_bits)3589   static void set_has_builtin_id(HasBits* has_bits) {
3590     (*has_bits)[0] |= 128u;
3591   }
set_has_instruction_start(HasBits * has_bits)3592   static void set_has_instruction_start(HasBits* has_bits) {
3593     (*has_bits)[0] |= 32u;
3594   }
set_has_instruction_size_bytes(HasBits * has_bits)3595   static void set_has_instruction_size_bytes(HasBits* has_bits) {
3596     (*has_bits)[0] |= 64u;
3597   }
set_has_machine_code(HasBits * has_bits)3598   static void set_has_machine_code(HasBits* has_bits) {
3599     (*has_bits)[0] |= 2u;
3600   }
3601 };
3602 
V8InternalCode(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3603 V8InternalCode::V8InternalCode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3604                          bool is_message_owned)
3605   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3606   SharedCtor(arena, is_message_owned);
3607   // @@protoc_insertion_point(arena_constructor:perfetto.protos.V8InternalCode)
3608 }
V8InternalCode(const V8InternalCode & from)3609 V8InternalCode::V8InternalCode(const V8InternalCode& from)
3610   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3611   V8InternalCode* const _this = this; (void)_this;
3612   new (&_impl_) Impl_{
3613       decltype(_impl_._has_bits_){from._impl_._has_bits_}
3614     , /*decltype(_impl_._cached_size_)*/{}
3615     , decltype(_impl_.name_){}
3616     , decltype(_impl_.machine_code_){}
3617     , decltype(_impl_.v8_isolate_iid_){}
3618     , decltype(_impl_.tid_){}
3619     , decltype(_impl_.type_){}
3620     , decltype(_impl_.instruction_start_){}
3621     , decltype(_impl_.instruction_size_bytes_){}
3622     , decltype(_impl_.builtin_id_){}};
3623 
3624   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3625   _impl_.name_.InitDefault();
3626   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3627     _impl_.name_.Set("", GetArenaForAllocation());
3628   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3629   if (from._internal_has_name()) {
3630     _this->_impl_.name_.Set(from._internal_name(),
3631       _this->GetArenaForAllocation());
3632   }
3633   _impl_.machine_code_.InitDefault();
3634   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3635     _impl_.machine_code_.Set("", GetArenaForAllocation());
3636   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3637   if (from._internal_has_machine_code()) {
3638     _this->_impl_.machine_code_.Set(from._internal_machine_code(),
3639       _this->GetArenaForAllocation());
3640   }
3641   ::memcpy(&_impl_.v8_isolate_iid_, &from._impl_.v8_isolate_iid_,
3642     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.builtin_id_) -
3643     reinterpret_cast<char*>(&_impl_.v8_isolate_iid_)) + sizeof(_impl_.builtin_id_));
3644   // @@protoc_insertion_point(copy_constructor:perfetto.protos.V8InternalCode)
3645 }
3646 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3647 inline void V8InternalCode::SharedCtor(
3648     ::_pb::Arena* arena, bool is_message_owned) {
3649   (void)arena;
3650   (void)is_message_owned;
3651   new (&_impl_) Impl_{
3652       decltype(_impl_._has_bits_){}
3653     , /*decltype(_impl_._cached_size_)*/{}
3654     , decltype(_impl_.name_){}
3655     , decltype(_impl_.machine_code_){}
3656     , decltype(_impl_.v8_isolate_iid_){::uint64_t{0u}}
3657     , decltype(_impl_.tid_){0u}
3658     , decltype(_impl_.type_){0}
3659     , decltype(_impl_.instruction_start_){::uint64_t{0u}}
3660     , decltype(_impl_.instruction_size_bytes_){::uint64_t{0u}}
3661     , decltype(_impl_.builtin_id_){0}
3662   };
3663   _impl_.name_.InitDefault();
3664   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3665     _impl_.name_.Set("", GetArenaForAllocation());
3666   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3667   _impl_.machine_code_.InitDefault();
3668   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3669     _impl_.machine_code_.Set("", GetArenaForAllocation());
3670   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3671 }
3672 
~V8InternalCode()3673 V8InternalCode::~V8InternalCode() {
3674   // @@protoc_insertion_point(destructor:perfetto.protos.V8InternalCode)
3675   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3676   (void)arena;
3677     return;
3678   }
3679   SharedDtor();
3680 }
3681 
SharedDtor()3682 inline void V8InternalCode::SharedDtor() {
3683   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3684   _impl_.name_.Destroy();
3685   _impl_.machine_code_.Destroy();
3686 }
3687 
SetCachedSize(int size) const3688 void V8InternalCode::SetCachedSize(int size) const {
3689   _impl_._cached_size_.Set(size);
3690 }
3691 
Clear()3692 void V8InternalCode::Clear() {
3693 // @@protoc_insertion_point(message_clear_start:perfetto.protos.V8InternalCode)
3694   ::uint32_t cached_has_bits = 0;
3695   // Prevent compiler warnings about cached_has_bits being unused
3696   (void) cached_has_bits;
3697 
3698   cached_has_bits = _impl_._has_bits_[0];
3699   if (cached_has_bits & 0x00000003u) {
3700     if (cached_has_bits & 0x00000001u) {
3701       _impl_.name_.ClearNonDefaultToEmpty();
3702     }
3703     if (cached_has_bits & 0x00000002u) {
3704       _impl_.machine_code_.ClearNonDefaultToEmpty();
3705     }
3706   }
3707   if (cached_has_bits & 0x000000fcu) {
3708     ::memset(&_impl_.v8_isolate_iid_, 0, static_cast<size_t>(
3709         reinterpret_cast<char*>(&_impl_.builtin_id_) -
3710         reinterpret_cast<char*>(&_impl_.v8_isolate_iid_)) + sizeof(_impl_.builtin_id_));
3711   }
3712   _impl_._has_bits_.Clear();
3713   _internal_metadata_.Clear<std::string>();
3714 }
3715 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3716 const char* V8InternalCode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3717 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3718   _Internal::HasBits has_bits{};
3719   while (!ctx->Done(&ptr)) {
3720     ::uint32_t tag;
3721     ptr = ::_pbi::ReadTag(ptr, &tag);
3722     switch (tag >> 3) {
3723       // optional uint64 v8_isolate_iid = 1;
3724       case 1:
3725         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3726           _Internal::set_has_v8_isolate_iid(&has_bits);
3727           _impl_.v8_isolate_iid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3728           CHK_(ptr);
3729         } else {
3730           goto handle_unusual;
3731         }
3732         continue;
3733       // optional uint32 tid = 2;
3734       case 2:
3735         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3736           _Internal::set_has_tid(&has_bits);
3737           _impl_.tid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3738           CHK_(ptr);
3739         } else {
3740           goto handle_unusual;
3741         }
3742         continue;
3743       // optional string name = 3;
3744       case 3:
3745         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
3746           auto str = _internal_mutable_name();
3747           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3748           CHK_(ptr);
3749         } else {
3750           goto handle_unusual;
3751         }
3752         continue;
3753       // optional .perfetto.protos.V8InternalCode.Type type = 4;
3754       case 4:
3755         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
3756           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3757           CHK_(ptr);
3758           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::V8InternalCode_Type_IsValid(val))) {
3759             _internal_set_type(static_cast<::perfetto::protos::V8InternalCode_Type>(val));
3760           } else {
3761             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
3762           }
3763         } else {
3764           goto handle_unusual;
3765         }
3766         continue;
3767       // optional int32 builtin_id = 5;
3768       case 5:
3769         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
3770           _Internal::set_has_builtin_id(&has_bits);
3771           _impl_.builtin_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3772           CHK_(ptr);
3773         } else {
3774           goto handle_unusual;
3775         }
3776         continue;
3777       // optional uint64 instruction_start = 6;
3778       case 6:
3779         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
3780           _Internal::set_has_instruction_start(&has_bits);
3781           _impl_.instruction_start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3782           CHK_(ptr);
3783         } else {
3784           goto handle_unusual;
3785         }
3786         continue;
3787       // optional uint64 instruction_size_bytes = 7;
3788       case 7:
3789         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
3790           _Internal::set_has_instruction_size_bytes(&has_bits);
3791           _impl_.instruction_size_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3792           CHK_(ptr);
3793         } else {
3794           goto handle_unusual;
3795         }
3796         continue;
3797       // optional bytes machine_code = 8;
3798       case 8:
3799         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
3800           auto str = _internal_mutable_machine_code();
3801           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3802           CHK_(ptr);
3803         } else {
3804           goto handle_unusual;
3805         }
3806         continue;
3807       default:
3808         goto handle_unusual;
3809     }  // switch
3810   handle_unusual:
3811     if ((tag == 0) || ((tag & 7) == 4)) {
3812       CHK_(ptr);
3813       ctx->SetLastTag(tag);
3814       goto message_done;
3815     }
3816     ptr = UnknownFieldParse(
3817         tag,
3818         _internal_metadata_.mutable_unknown_fields<std::string>(),
3819         ptr, ctx);
3820     CHK_(ptr != nullptr);
3821   }  // while
3822 message_done:
3823   _impl_._has_bits_.Or(has_bits);
3824   return ptr;
3825 failure:
3826   ptr = nullptr;
3827   goto message_done;
3828 #undef CHK_
3829 }
3830 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3831 ::uint8_t* V8InternalCode::_InternalSerialize(
3832     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3833   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.V8InternalCode)
3834   ::uint32_t cached_has_bits = 0;
3835   (void) cached_has_bits;
3836 
3837   cached_has_bits = _impl_._has_bits_[0];
3838   // optional uint64 v8_isolate_iid = 1;
3839   if (cached_has_bits & 0x00000004u) {
3840     target = stream->EnsureSpace(target);
3841     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_v8_isolate_iid(), target);
3842   }
3843 
3844   // optional uint32 tid = 2;
3845   if (cached_has_bits & 0x00000008u) {
3846     target = stream->EnsureSpace(target);
3847     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_tid(), target);
3848   }
3849 
3850   // optional string name = 3;
3851   if (cached_has_bits & 0x00000001u) {
3852     target = stream->WriteStringMaybeAliased(
3853         3, this->_internal_name(), target);
3854   }
3855 
3856   // optional .perfetto.protos.V8InternalCode.Type type = 4;
3857   if (cached_has_bits & 0x00000010u) {
3858     target = stream->EnsureSpace(target);
3859     target = ::_pbi::WireFormatLite::WriteEnumToArray(
3860       4, this->_internal_type(), target);
3861   }
3862 
3863   // optional int32 builtin_id = 5;
3864   if (cached_has_bits & 0x00000080u) {
3865     target = stream->EnsureSpace(target);
3866     target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_builtin_id(), target);
3867   }
3868 
3869   // optional uint64 instruction_start = 6;
3870   if (cached_has_bits & 0x00000020u) {
3871     target = stream->EnsureSpace(target);
3872     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_instruction_start(), target);
3873   }
3874 
3875   // optional uint64 instruction_size_bytes = 7;
3876   if (cached_has_bits & 0x00000040u) {
3877     target = stream->EnsureSpace(target);
3878     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_instruction_size_bytes(), target);
3879   }
3880 
3881   // optional bytes machine_code = 8;
3882   if (cached_has_bits & 0x00000002u) {
3883     target = stream->WriteBytesMaybeAliased(
3884         8, this->_internal_machine_code(), target);
3885   }
3886 
3887   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3888     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3889         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3890   }
3891   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.V8InternalCode)
3892   return target;
3893 }
3894 
ByteSizeLong() const3895 size_t V8InternalCode::ByteSizeLong() const {
3896 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.V8InternalCode)
3897   size_t total_size = 0;
3898 
3899   ::uint32_t cached_has_bits = 0;
3900   // Prevent compiler warnings about cached_has_bits being unused
3901   (void) cached_has_bits;
3902 
3903   cached_has_bits = _impl_._has_bits_[0];
3904   if (cached_has_bits & 0x000000ffu) {
3905     // optional string name = 3;
3906     if (cached_has_bits & 0x00000001u) {
3907       total_size += 1 +
3908         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3909           this->_internal_name());
3910     }
3911 
3912     // optional bytes machine_code = 8;
3913     if (cached_has_bits & 0x00000002u) {
3914       total_size += 1 +
3915         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
3916           this->_internal_machine_code());
3917     }
3918 
3919     // optional uint64 v8_isolate_iid = 1;
3920     if (cached_has_bits & 0x00000004u) {
3921       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_v8_isolate_iid());
3922     }
3923 
3924     // optional uint32 tid = 2;
3925     if (cached_has_bits & 0x00000008u) {
3926       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tid());
3927     }
3928 
3929     // optional .perfetto.protos.V8InternalCode.Type type = 4;
3930     if (cached_has_bits & 0x00000010u) {
3931       total_size += 1 +
3932         ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
3933     }
3934 
3935     // optional uint64 instruction_start = 6;
3936     if (cached_has_bits & 0x00000020u) {
3937       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_instruction_start());
3938     }
3939 
3940     // optional uint64 instruction_size_bytes = 7;
3941     if (cached_has_bits & 0x00000040u) {
3942       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_instruction_size_bytes());
3943     }
3944 
3945     // optional int32 builtin_id = 5;
3946     if (cached_has_bits & 0x00000080u) {
3947       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_builtin_id());
3948     }
3949 
3950   }
3951   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3952     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3953   }
3954   int cached_size = ::_pbi::ToCachedSize(total_size);
3955   SetCachedSize(cached_size);
3956   return total_size;
3957 }
3958 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3959 void V8InternalCode::CheckTypeAndMergeFrom(
3960     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3961   MergeFrom(*::_pbi::DownCast<const V8InternalCode*>(
3962       &from));
3963 }
3964 
MergeFrom(const V8InternalCode & from)3965 void V8InternalCode::MergeFrom(const V8InternalCode& from) {
3966   V8InternalCode* const _this = this;
3967   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.V8InternalCode)
3968   GOOGLE_DCHECK_NE(&from, _this);
3969   ::uint32_t cached_has_bits = 0;
3970   (void) cached_has_bits;
3971 
3972   cached_has_bits = from._impl_._has_bits_[0];
3973   if (cached_has_bits & 0x000000ffu) {
3974     if (cached_has_bits & 0x00000001u) {
3975       _this->_internal_set_name(from._internal_name());
3976     }
3977     if (cached_has_bits & 0x00000002u) {
3978       _this->_internal_set_machine_code(from._internal_machine_code());
3979     }
3980     if (cached_has_bits & 0x00000004u) {
3981       _this->_impl_.v8_isolate_iid_ = from._impl_.v8_isolate_iid_;
3982     }
3983     if (cached_has_bits & 0x00000008u) {
3984       _this->_impl_.tid_ = from._impl_.tid_;
3985     }
3986     if (cached_has_bits & 0x00000010u) {
3987       _this->_impl_.type_ = from._impl_.type_;
3988     }
3989     if (cached_has_bits & 0x00000020u) {
3990       _this->_impl_.instruction_start_ = from._impl_.instruction_start_;
3991     }
3992     if (cached_has_bits & 0x00000040u) {
3993       _this->_impl_.instruction_size_bytes_ = from._impl_.instruction_size_bytes_;
3994     }
3995     if (cached_has_bits & 0x00000080u) {
3996       _this->_impl_.builtin_id_ = from._impl_.builtin_id_;
3997     }
3998     _this->_impl_._has_bits_[0] |= cached_has_bits;
3999   }
4000   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4001 }
4002 
CopyFrom(const V8InternalCode & from)4003 void V8InternalCode::CopyFrom(const V8InternalCode& from) {
4004 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.V8InternalCode)
4005   if (&from == this) return;
4006   Clear();
4007   MergeFrom(from);
4008 }
4009 
IsInitialized() const4010 bool V8InternalCode::IsInitialized() const {
4011   return true;
4012 }
4013 
InternalSwap(V8InternalCode * other)4014 void V8InternalCode::InternalSwap(V8InternalCode* other) {
4015   using std::swap;
4016   auto* lhs_arena = GetArenaForAllocation();
4017   auto* rhs_arena = other->GetArenaForAllocation();
4018   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4019   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4020   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4021       &_impl_.name_, lhs_arena,
4022       &other->_impl_.name_, rhs_arena
4023   );
4024   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4025       &_impl_.machine_code_, lhs_arena,
4026       &other->_impl_.machine_code_, rhs_arena
4027   );
4028   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4029       PROTOBUF_FIELD_OFFSET(V8InternalCode, _impl_.builtin_id_)
4030       + sizeof(V8InternalCode::_impl_.builtin_id_)  // NOLINT
4031       - PROTOBUF_FIELD_OFFSET(V8InternalCode, _impl_.v8_isolate_iid_)>(
4032           reinterpret_cast<char*>(&_impl_.v8_isolate_iid_),
4033           reinterpret_cast<char*>(&other->_impl_.v8_isolate_iid_));
4034 }
4035 
GetTypeName() const4036 std::string V8InternalCode::GetTypeName() const {
4037   return "perfetto.protos.V8InternalCode";
4038 }
4039 
4040 
4041 // ===================================================================
4042 
4043 class V8WasmCode::_Internal {
4044  public:
4045   using HasBits = decltype(std::declval<V8WasmCode>()._impl_._has_bits_);
set_has_v8_isolate_iid(HasBits * has_bits)4046   static void set_has_v8_isolate_iid(HasBits* has_bits) {
4047     (*has_bits)[0] |= 4u;
4048   }
set_has_tid(HasBits * has_bits)4049   static void set_has_tid(HasBits* has_bits) {
4050     (*has_bits)[0] |= 16u;
4051   }
set_has_v8_wasm_script_iid(HasBits * has_bits)4052   static void set_has_v8_wasm_script_iid(HasBits* has_bits) {
4053     (*has_bits)[0] |= 8u;
4054   }
set_has_function_name(HasBits * has_bits)4055   static void set_has_function_name(HasBits* has_bits) {
4056     (*has_bits)[0] |= 1u;
4057   }
set_has_tier(HasBits * has_bits)4058   static void set_has_tier(HasBits* has_bits) {
4059     (*has_bits)[0] |= 32u;
4060   }
set_has_code_offset_in_module(HasBits * has_bits)4061   static void set_has_code_offset_in_module(HasBits* has_bits) {
4062     (*has_bits)[0] |= 256u;
4063   }
set_has_instruction_start(HasBits * has_bits)4064   static void set_has_instruction_start(HasBits* has_bits) {
4065     (*has_bits)[0] |= 64u;
4066   }
set_has_instruction_size_bytes(HasBits * has_bits)4067   static void set_has_instruction_size_bytes(HasBits* has_bits) {
4068     (*has_bits)[0] |= 128u;
4069   }
set_has_machine_code(HasBits * has_bits)4070   static void set_has_machine_code(HasBits* has_bits) {
4071     (*has_bits)[0] |= 2u;
4072   }
4073 };
4074 
V8WasmCode(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4075 V8WasmCode::V8WasmCode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4076                          bool is_message_owned)
4077   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4078   SharedCtor(arena, is_message_owned);
4079   // @@protoc_insertion_point(arena_constructor:perfetto.protos.V8WasmCode)
4080 }
V8WasmCode(const V8WasmCode & from)4081 V8WasmCode::V8WasmCode(const V8WasmCode& from)
4082   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4083   V8WasmCode* const _this = this; (void)_this;
4084   new (&_impl_) Impl_{
4085       decltype(_impl_._has_bits_){from._impl_._has_bits_}
4086     , /*decltype(_impl_._cached_size_)*/{}
4087     , decltype(_impl_.function_name_){}
4088     , decltype(_impl_.machine_code_){}
4089     , decltype(_impl_.v8_isolate_iid_){}
4090     , decltype(_impl_.v8_wasm_script_iid_){}
4091     , decltype(_impl_.tid_){}
4092     , decltype(_impl_.tier_){}
4093     , decltype(_impl_.instruction_start_){}
4094     , decltype(_impl_.instruction_size_bytes_){}
4095     , decltype(_impl_.code_offset_in_module_){}};
4096 
4097   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4098   _impl_.function_name_.InitDefault();
4099   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4100     _impl_.function_name_.Set("", GetArenaForAllocation());
4101   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4102   if (from._internal_has_function_name()) {
4103     _this->_impl_.function_name_.Set(from._internal_function_name(),
4104       _this->GetArenaForAllocation());
4105   }
4106   _impl_.machine_code_.InitDefault();
4107   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4108     _impl_.machine_code_.Set("", GetArenaForAllocation());
4109   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4110   if (from._internal_has_machine_code()) {
4111     _this->_impl_.machine_code_.Set(from._internal_machine_code(),
4112       _this->GetArenaForAllocation());
4113   }
4114   ::memcpy(&_impl_.v8_isolate_iid_, &from._impl_.v8_isolate_iid_,
4115     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.code_offset_in_module_) -
4116     reinterpret_cast<char*>(&_impl_.v8_isolate_iid_)) + sizeof(_impl_.code_offset_in_module_));
4117   // @@protoc_insertion_point(copy_constructor:perfetto.protos.V8WasmCode)
4118 }
4119 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4120 inline void V8WasmCode::SharedCtor(
4121     ::_pb::Arena* arena, bool is_message_owned) {
4122   (void)arena;
4123   (void)is_message_owned;
4124   new (&_impl_) Impl_{
4125       decltype(_impl_._has_bits_){}
4126     , /*decltype(_impl_._cached_size_)*/{}
4127     , decltype(_impl_.function_name_){}
4128     , decltype(_impl_.machine_code_){}
4129     , decltype(_impl_.v8_isolate_iid_){::uint64_t{0u}}
4130     , decltype(_impl_.v8_wasm_script_iid_){::uint64_t{0u}}
4131     , decltype(_impl_.tid_){0u}
4132     , decltype(_impl_.tier_){0}
4133     , decltype(_impl_.instruction_start_){::uint64_t{0u}}
4134     , decltype(_impl_.instruction_size_bytes_){::uint64_t{0u}}
4135     , decltype(_impl_.code_offset_in_module_){0}
4136   };
4137   _impl_.function_name_.InitDefault();
4138   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4139     _impl_.function_name_.Set("", GetArenaForAllocation());
4140   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4141   _impl_.machine_code_.InitDefault();
4142   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4143     _impl_.machine_code_.Set("", GetArenaForAllocation());
4144   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4145 }
4146 
~V8WasmCode()4147 V8WasmCode::~V8WasmCode() {
4148   // @@protoc_insertion_point(destructor:perfetto.protos.V8WasmCode)
4149   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4150   (void)arena;
4151     return;
4152   }
4153   SharedDtor();
4154 }
4155 
SharedDtor()4156 inline void V8WasmCode::SharedDtor() {
4157   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4158   _impl_.function_name_.Destroy();
4159   _impl_.machine_code_.Destroy();
4160 }
4161 
SetCachedSize(int size) const4162 void V8WasmCode::SetCachedSize(int size) const {
4163   _impl_._cached_size_.Set(size);
4164 }
4165 
Clear()4166 void V8WasmCode::Clear() {
4167 // @@protoc_insertion_point(message_clear_start:perfetto.protos.V8WasmCode)
4168   ::uint32_t cached_has_bits = 0;
4169   // Prevent compiler warnings about cached_has_bits being unused
4170   (void) cached_has_bits;
4171 
4172   cached_has_bits = _impl_._has_bits_[0];
4173   if (cached_has_bits & 0x00000003u) {
4174     if (cached_has_bits & 0x00000001u) {
4175       _impl_.function_name_.ClearNonDefaultToEmpty();
4176     }
4177     if (cached_has_bits & 0x00000002u) {
4178       _impl_.machine_code_.ClearNonDefaultToEmpty();
4179     }
4180   }
4181   if (cached_has_bits & 0x000000fcu) {
4182     ::memset(&_impl_.v8_isolate_iid_, 0, static_cast<size_t>(
4183         reinterpret_cast<char*>(&_impl_.instruction_size_bytes_) -
4184         reinterpret_cast<char*>(&_impl_.v8_isolate_iid_)) + sizeof(_impl_.instruction_size_bytes_));
4185   }
4186   _impl_.code_offset_in_module_ = 0;
4187   _impl_._has_bits_.Clear();
4188   _internal_metadata_.Clear<std::string>();
4189 }
4190 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4191 const char* V8WasmCode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4192 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4193   _Internal::HasBits has_bits{};
4194   while (!ctx->Done(&ptr)) {
4195     ::uint32_t tag;
4196     ptr = ::_pbi::ReadTag(ptr, &tag);
4197     switch (tag >> 3) {
4198       // optional uint64 v8_isolate_iid = 1;
4199       case 1:
4200         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4201           _Internal::set_has_v8_isolate_iid(&has_bits);
4202           _impl_.v8_isolate_iid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4203           CHK_(ptr);
4204         } else {
4205           goto handle_unusual;
4206         }
4207         continue;
4208       // optional uint32 tid = 2;
4209       case 2:
4210         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4211           _Internal::set_has_tid(&has_bits);
4212           _impl_.tid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4213           CHK_(ptr);
4214         } else {
4215           goto handle_unusual;
4216         }
4217         continue;
4218       // optional uint64 v8_wasm_script_iid = 3;
4219       case 3:
4220         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
4221           _Internal::set_has_v8_wasm_script_iid(&has_bits);
4222           _impl_.v8_wasm_script_iid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4223           CHK_(ptr);
4224         } else {
4225           goto handle_unusual;
4226         }
4227         continue;
4228       // optional string function_name = 4;
4229       case 4:
4230         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
4231           auto str = _internal_mutable_function_name();
4232           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4233           CHK_(ptr);
4234         } else {
4235           goto handle_unusual;
4236         }
4237         continue;
4238       // optional .perfetto.protos.V8WasmCode.Tier tier = 5;
4239       case 5:
4240         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
4241           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4242           CHK_(ptr);
4243           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::V8WasmCode_Tier_IsValid(val))) {
4244             _internal_set_tier(static_cast<::perfetto::protos::V8WasmCode_Tier>(val));
4245           } else {
4246             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
4247           }
4248         } else {
4249           goto handle_unusual;
4250         }
4251         continue;
4252       // optional int32 code_offset_in_module = 6;
4253       case 6:
4254         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
4255           _Internal::set_has_code_offset_in_module(&has_bits);
4256           _impl_.code_offset_in_module_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4257           CHK_(ptr);
4258         } else {
4259           goto handle_unusual;
4260         }
4261         continue;
4262       // optional uint64 instruction_start = 7;
4263       case 7:
4264         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
4265           _Internal::set_has_instruction_start(&has_bits);
4266           _impl_.instruction_start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4267           CHK_(ptr);
4268         } else {
4269           goto handle_unusual;
4270         }
4271         continue;
4272       // optional uint64 instruction_size_bytes = 8;
4273       case 8:
4274         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
4275           _Internal::set_has_instruction_size_bytes(&has_bits);
4276           _impl_.instruction_size_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4277           CHK_(ptr);
4278         } else {
4279           goto handle_unusual;
4280         }
4281         continue;
4282       // optional bytes machine_code = 9;
4283       case 9:
4284         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 74)) {
4285           auto str = _internal_mutable_machine_code();
4286           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4287           CHK_(ptr);
4288         } else {
4289           goto handle_unusual;
4290         }
4291         continue;
4292       default:
4293         goto handle_unusual;
4294     }  // switch
4295   handle_unusual:
4296     if ((tag == 0) || ((tag & 7) == 4)) {
4297       CHK_(ptr);
4298       ctx->SetLastTag(tag);
4299       goto message_done;
4300     }
4301     ptr = UnknownFieldParse(
4302         tag,
4303         _internal_metadata_.mutable_unknown_fields<std::string>(),
4304         ptr, ctx);
4305     CHK_(ptr != nullptr);
4306   }  // while
4307 message_done:
4308   _impl_._has_bits_.Or(has_bits);
4309   return ptr;
4310 failure:
4311   ptr = nullptr;
4312   goto message_done;
4313 #undef CHK_
4314 }
4315 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4316 ::uint8_t* V8WasmCode::_InternalSerialize(
4317     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4318   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.V8WasmCode)
4319   ::uint32_t cached_has_bits = 0;
4320   (void) cached_has_bits;
4321 
4322   cached_has_bits = _impl_._has_bits_[0];
4323   // optional uint64 v8_isolate_iid = 1;
4324   if (cached_has_bits & 0x00000004u) {
4325     target = stream->EnsureSpace(target);
4326     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_v8_isolate_iid(), target);
4327   }
4328 
4329   // optional uint32 tid = 2;
4330   if (cached_has_bits & 0x00000010u) {
4331     target = stream->EnsureSpace(target);
4332     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_tid(), target);
4333   }
4334 
4335   // optional uint64 v8_wasm_script_iid = 3;
4336   if (cached_has_bits & 0x00000008u) {
4337     target = stream->EnsureSpace(target);
4338     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_v8_wasm_script_iid(), target);
4339   }
4340 
4341   // optional string function_name = 4;
4342   if (cached_has_bits & 0x00000001u) {
4343     target = stream->WriteStringMaybeAliased(
4344         4, this->_internal_function_name(), target);
4345   }
4346 
4347   // optional .perfetto.protos.V8WasmCode.Tier tier = 5;
4348   if (cached_has_bits & 0x00000020u) {
4349     target = stream->EnsureSpace(target);
4350     target = ::_pbi::WireFormatLite::WriteEnumToArray(
4351       5, this->_internal_tier(), target);
4352   }
4353 
4354   // optional int32 code_offset_in_module = 6;
4355   if (cached_has_bits & 0x00000100u) {
4356     target = stream->EnsureSpace(target);
4357     target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_code_offset_in_module(), target);
4358   }
4359 
4360   // optional uint64 instruction_start = 7;
4361   if (cached_has_bits & 0x00000040u) {
4362     target = stream->EnsureSpace(target);
4363     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_instruction_start(), target);
4364   }
4365 
4366   // optional uint64 instruction_size_bytes = 8;
4367   if (cached_has_bits & 0x00000080u) {
4368     target = stream->EnsureSpace(target);
4369     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_instruction_size_bytes(), target);
4370   }
4371 
4372   // optional bytes machine_code = 9;
4373   if (cached_has_bits & 0x00000002u) {
4374     target = stream->WriteBytesMaybeAliased(
4375         9, this->_internal_machine_code(), target);
4376   }
4377 
4378   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4379     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4380         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4381   }
4382   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.V8WasmCode)
4383   return target;
4384 }
4385 
ByteSizeLong() const4386 size_t V8WasmCode::ByteSizeLong() const {
4387 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.V8WasmCode)
4388   size_t total_size = 0;
4389 
4390   ::uint32_t cached_has_bits = 0;
4391   // Prevent compiler warnings about cached_has_bits being unused
4392   (void) cached_has_bits;
4393 
4394   cached_has_bits = _impl_._has_bits_[0];
4395   if (cached_has_bits & 0x000000ffu) {
4396     // optional string function_name = 4;
4397     if (cached_has_bits & 0x00000001u) {
4398       total_size += 1 +
4399         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4400           this->_internal_function_name());
4401     }
4402 
4403     // optional bytes machine_code = 9;
4404     if (cached_has_bits & 0x00000002u) {
4405       total_size += 1 +
4406         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
4407           this->_internal_machine_code());
4408     }
4409 
4410     // optional uint64 v8_isolate_iid = 1;
4411     if (cached_has_bits & 0x00000004u) {
4412       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_v8_isolate_iid());
4413     }
4414 
4415     // optional uint64 v8_wasm_script_iid = 3;
4416     if (cached_has_bits & 0x00000008u) {
4417       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_v8_wasm_script_iid());
4418     }
4419 
4420     // optional uint32 tid = 2;
4421     if (cached_has_bits & 0x00000010u) {
4422       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tid());
4423     }
4424 
4425     // optional .perfetto.protos.V8WasmCode.Tier tier = 5;
4426     if (cached_has_bits & 0x00000020u) {
4427       total_size += 1 +
4428         ::_pbi::WireFormatLite::EnumSize(this->_internal_tier());
4429     }
4430 
4431     // optional uint64 instruction_start = 7;
4432     if (cached_has_bits & 0x00000040u) {
4433       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_instruction_start());
4434     }
4435 
4436     // optional uint64 instruction_size_bytes = 8;
4437     if (cached_has_bits & 0x00000080u) {
4438       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_instruction_size_bytes());
4439     }
4440 
4441   }
4442   // optional int32 code_offset_in_module = 6;
4443   if (cached_has_bits & 0x00000100u) {
4444     total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_code_offset_in_module());
4445   }
4446 
4447   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4448     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4449   }
4450   int cached_size = ::_pbi::ToCachedSize(total_size);
4451   SetCachedSize(cached_size);
4452   return total_size;
4453 }
4454 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4455 void V8WasmCode::CheckTypeAndMergeFrom(
4456     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4457   MergeFrom(*::_pbi::DownCast<const V8WasmCode*>(
4458       &from));
4459 }
4460 
MergeFrom(const V8WasmCode & from)4461 void V8WasmCode::MergeFrom(const V8WasmCode& from) {
4462   V8WasmCode* const _this = this;
4463   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.V8WasmCode)
4464   GOOGLE_DCHECK_NE(&from, _this);
4465   ::uint32_t cached_has_bits = 0;
4466   (void) cached_has_bits;
4467 
4468   cached_has_bits = from._impl_._has_bits_[0];
4469   if (cached_has_bits & 0x000000ffu) {
4470     if (cached_has_bits & 0x00000001u) {
4471       _this->_internal_set_function_name(from._internal_function_name());
4472     }
4473     if (cached_has_bits & 0x00000002u) {
4474       _this->_internal_set_machine_code(from._internal_machine_code());
4475     }
4476     if (cached_has_bits & 0x00000004u) {
4477       _this->_impl_.v8_isolate_iid_ = from._impl_.v8_isolate_iid_;
4478     }
4479     if (cached_has_bits & 0x00000008u) {
4480       _this->_impl_.v8_wasm_script_iid_ = from._impl_.v8_wasm_script_iid_;
4481     }
4482     if (cached_has_bits & 0x00000010u) {
4483       _this->_impl_.tid_ = from._impl_.tid_;
4484     }
4485     if (cached_has_bits & 0x00000020u) {
4486       _this->_impl_.tier_ = from._impl_.tier_;
4487     }
4488     if (cached_has_bits & 0x00000040u) {
4489       _this->_impl_.instruction_start_ = from._impl_.instruction_start_;
4490     }
4491     if (cached_has_bits & 0x00000080u) {
4492       _this->_impl_.instruction_size_bytes_ = from._impl_.instruction_size_bytes_;
4493     }
4494     _this->_impl_._has_bits_[0] |= cached_has_bits;
4495   }
4496   if (cached_has_bits & 0x00000100u) {
4497     _this->_internal_set_code_offset_in_module(from._internal_code_offset_in_module());
4498   }
4499   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4500 }
4501 
CopyFrom(const V8WasmCode & from)4502 void V8WasmCode::CopyFrom(const V8WasmCode& from) {
4503 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.V8WasmCode)
4504   if (&from == this) return;
4505   Clear();
4506   MergeFrom(from);
4507 }
4508 
IsInitialized() const4509 bool V8WasmCode::IsInitialized() const {
4510   return true;
4511 }
4512 
InternalSwap(V8WasmCode * other)4513 void V8WasmCode::InternalSwap(V8WasmCode* other) {
4514   using std::swap;
4515   auto* lhs_arena = GetArenaForAllocation();
4516   auto* rhs_arena = other->GetArenaForAllocation();
4517   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4518   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4519   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4520       &_impl_.function_name_, lhs_arena,
4521       &other->_impl_.function_name_, rhs_arena
4522   );
4523   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4524       &_impl_.machine_code_, lhs_arena,
4525       &other->_impl_.machine_code_, rhs_arena
4526   );
4527   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4528       PROTOBUF_FIELD_OFFSET(V8WasmCode, _impl_.code_offset_in_module_)
4529       + sizeof(V8WasmCode::_impl_.code_offset_in_module_)  // NOLINT
4530       - PROTOBUF_FIELD_OFFSET(V8WasmCode, _impl_.v8_isolate_iid_)>(
4531           reinterpret_cast<char*>(&_impl_.v8_isolate_iid_),
4532           reinterpret_cast<char*>(&other->_impl_.v8_isolate_iid_));
4533 }
4534 
GetTypeName() const4535 std::string V8WasmCode::GetTypeName() const {
4536   return "perfetto.protos.V8WasmCode";
4537 }
4538 
4539 
4540 // ===================================================================
4541 
4542 class V8RegExpCode::_Internal {
4543  public:
4544   using HasBits = decltype(std::declval<V8RegExpCode>()._impl_._has_bits_);
set_has_v8_isolate_iid(HasBits * has_bits)4545   static void set_has_v8_isolate_iid(HasBits* has_bits) {
4546     (*has_bits)[0] |= 4u;
4547   }
set_has_tid(HasBits * has_bits)4548   static void set_has_tid(HasBits* has_bits) {
4549     (*has_bits)[0] |= 32u;
4550   }
4551   static const ::perfetto::protos::V8String& pattern(const V8RegExpCode* msg);
set_has_pattern(HasBits * has_bits)4552   static void set_has_pattern(HasBits* has_bits) {
4553     (*has_bits)[0] |= 2u;
4554   }
set_has_instruction_start(HasBits * has_bits)4555   static void set_has_instruction_start(HasBits* has_bits) {
4556     (*has_bits)[0] |= 8u;
4557   }
set_has_instruction_size_bytes(HasBits * has_bits)4558   static void set_has_instruction_size_bytes(HasBits* has_bits) {
4559     (*has_bits)[0] |= 16u;
4560   }
set_has_machine_code(HasBits * has_bits)4561   static void set_has_machine_code(HasBits* has_bits) {
4562     (*has_bits)[0] |= 1u;
4563   }
4564 };
4565 
4566 const ::perfetto::protos::V8String&
pattern(const V8RegExpCode * msg)4567 V8RegExpCode::_Internal::pattern(const V8RegExpCode* msg) {
4568   return *msg->_impl_.pattern_;
4569 }
V8RegExpCode(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4570 V8RegExpCode::V8RegExpCode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4571                          bool is_message_owned)
4572   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4573   SharedCtor(arena, is_message_owned);
4574   // @@protoc_insertion_point(arena_constructor:perfetto.protos.V8RegExpCode)
4575 }
V8RegExpCode(const V8RegExpCode & from)4576 V8RegExpCode::V8RegExpCode(const V8RegExpCode& from)
4577   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4578   V8RegExpCode* const _this = this; (void)_this;
4579   new (&_impl_) Impl_{
4580       decltype(_impl_._has_bits_){from._impl_._has_bits_}
4581     , /*decltype(_impl_._cached_size_)*/{}
4582     , decltype(_impl_.machine_code_){}
4583     , decltype(_impl_.pattern_){nullptr}
4584     , decltype(_impl_.v8_isolate_iid_){}
4585     , decltype(_impl_.instruction_start_){}
4586     , decltype(_impl_.instruction_size_bytes_){}
4587     , decltype(_impl_.tid_){}};
4588 
4589   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4590   _impl_.machine_code_.InitDefault();
4591   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4592     _impl_.machine_code_.Set("", GetArenaForAllocation());
4593   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4594   if (from._internal_has_machine_code()) {
4595     _this->_impl_.machine_code_.Set(from._internal_machine_code(),
4596       _this->GetArenaForAllocation());
4597   }
4598   if (from._internal_has_pattern()) {
4599     _this->_impl_.pattern_ = new ::perfetto::protos::V8String(*from._impl_.pattern_);
4600   }
4601   ::memcpy(&_impl_.v8_isolate_iid_, &from._impl_.v8_isolate_iid_,
4602     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.tid_) -
4603     reinterpret_cast<char*>(&_impl_.v8_isolate_iid_)) + sizeof(_impl_.tid_));
4604   // @@protoc_insertion_point(copy_constructor:perfetto.protos.V8RegExpCode)
4605 }
4606 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4607 inline void V8RegExpCode::SharedCtor(
4608     ::_pb::Arena* arena, bool is_message_owned) {
4609   (void)arena;
4610   (void)is_message_owned;
4611   new (&_impl_) Impl_{
4612       decltype(_impl_._has_bits_){}
4613     , /*decltype(_impl_._cached_size_)*/{}
4614     , decltype(_impl_.machine_code_){}
4615     , decltype(_impl_.pattern_){nullptr}
4616     , decltype(_impl_.v8_isolate_iid_){::uint64_t{0u}}
4617     , decltype(_impl_.instruction_start_){::uint64_t{0u}}
4618     , decltype(_impl_.instruction_size_bytes_){::uint64_t{0u}}
4619     , decltype(_impl_.tid_){0u}
4620   };
4621   _impl_.machine_code_.InitDefault();
4622   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4623     _impl_.machine_code_.Set("", GetArenaForAllocation());
4624   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4625 }
4626 
~V8RegExpCode()4627 V8RegExpCode::~V8RegExpCode() {
4628   // @@protoc_insertion_point(destructor:perfetto.protos.V8RegExpCode)
4629   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4630   (void)arena;
4631     return;
4632   }
4633   SharedDtor();
4634 }
4635 
SharedDtor()4636 inline void V8RegExpCode::SharedDtor() {
4637   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4638   _impl_.machine_code_.Destroy();
4639   if (this != internal_default_instance()) delete _impl_.pattern_;
4640 }
4641 
SetCachedSize(int size) const4642 void V8RegExpCode::SetCachedSize(int size) const {
4643   _impl_._cached_size_.Set(size);
4644 }
4645 
Clear()4646 void V8RegExpCode::Clear() {
4647 // @@protoc_insertion_point(message_clear_start:perfetto.protos.V8RegExpCode)
4648   ::uint32_t cached_has_bits = 0;
4649   // Prevent compiler warnings about cached_has_bits being unused
4650   (void) cached_has_bits;
4651 
4652   cached_has_bits = _impl_._has_bits_[0];
4653   if (cached_has_bits & 0x00000003u) {
4654     if (cached_has_bits & 0x00000001u) {
4655       _impl_.machine_code_.ClearNonDefaultToEmpty();
4656     }
4657     if (cached_has_bits & 0x00000002u) {
4658       GOOGLE_DCHECK(_impl_.pattern_ != nullptr);
4659       _impl_.pattern_->Clear();
4660     }
4661   }
4662   if (cached_has_bits & 0x0000003cu) {
4663     ::memset(&_impl_.v8_isolate_iid_, 0, static_cast<size_t>(
4664         reinterpret_cast<char*>(&_impl_.tid_) -
4665         reinterpret_cast<char*>(&_impl_.v8_isolate_iid_)) + sizeof(_impl_.tid_));
4666   }
4667   _impl_._has_bits_.Clear();
4668   _internal_metadata_.Clear<std::string>();
4669 }
4670 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4671 const char* V8RegExpCode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4672 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4673   _Internal::HasBits has_bits{};
4674   while (!ctx->Done(&ptr)) {
4675     ::uint32_t tag;
4676     ptr = ::_pbi::ReadTag(ptr, &tag);
4677     switch (tag >> 3) {
4678       // optional uint64 v8_isolate_iid = 1;
4679       case 1:
4680         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4681           _Internal::set_has_v8_isolate_iid(&has_bits);
4682           _impl_.v8_isolate_iid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4683           CHK_(ptr);
4684         } else {
4685           goto handle_unusual;
4686         }
4687         continue;
4688       // optional uint32 tid = 2;
4689       case 2:
4690         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4691           _Internal::set_has_tid(&has_bits);
4692           _impl_.tid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4693           CHK_(ptr);
4694         } else {
4695           goto handle_unusual;
4696         }
4697         continue;
4698       // optional .perfetto.protos.V8String pattern = 3;
4699       case 3:
4700         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
4701           ptr = ctx->ParseMessage(_internal_mutable_pattern(), ptr);
4702           CHK_(ptr);
4703         } else {
4704           goto handle_unusual;
4705         }
4706         continue;
4707       // optional uint64 instruction_start = 4;
4708       case 4:
4709         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
4710           _Internal::set_has_instruction_start(&has_bits);
4711           _impl_.instruction_start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4712           CHK_(ptr);
4713         } else {
4714           goto handle_unusual;
4715         }
4716         continue;
4717       // optional uint64 instruction_size_bytes = 5;
4718       case 5:
4719         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
4720           _Internal::set_has_instruction_size_bytes(&has_bits);
4721           _impl_.instruction_size_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4722           CHK_(ptr);
4723         } else {
4724           goto handle_unusual;
4725         }
4726         continue;
4727       // optional bytes machine_code = 6;
4728       case 6:
4729         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
4730           auto str = _internal_mutable_machine_code();
4731           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4732           CHK_(ptr);
4733         } else {
4734           goto handle_unusual;
4735         }
4736         continue;
4737       default:
4738         goto handle_unusual;
4739     }  // switch
4740   handle_unusual:
4741     if ((tag == 0) || ((tag & 7) == 4)) {
4742       CHK_(ptr);
4743       ctx->SetLastTag(tag);
4744       goto message_done;
4745     }
4746     ptr = UnknownFieldParse(
4747         tag,
4748         _internal_metadata_.mutable_unknown_fields<std::string>(),
4749         ptr, ctx);
4750     CHK_(ptr != nullptr);
4751   }  // while
4752 message_done:
4753   _impl_._has_bits_.Or(has_bits);
4754   return ptr;
4755 failure:
4756   ptr = nullptr;
4757   goto message_done;
4758 #undef CHK_
4759 }
4760 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4761 ::uint8_t* V8RegExpCode::_InternalSerialize(
4762     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4763   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.V8RegExpCode)
4764   ::uint32_t cached_has_bits = 0;
4765   (void) cached_has_bits;
4766 
4767   cached_has_bits = _impl_._has_bits_[0];
4768   // optional uint64 v8_isolate_iid = 1;
4769   if (cached_has_bits & 0x00000004u) {
4770     target = stream->EnsureSpace(target);
4771     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_v8_isolate_iid(), target);
4772   }
4773 
4774   // optional uint32 tid = 2;
4775   if (cached_has_bits & 0x00000020u) {
4776     target = stream->EnsureSpace(target);
4777     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_tid(), target);
4778   }
4779 
4780   // optional .perfetto.protos.V8String pattern = 3;
4781   if (cached_has_bits & 0x00000002u) {
4782     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
4783       InternalWriteMessage(3, _Internal::pattern(this),
4784         _Internal::pattern(this).GetCachedSize(), target, stream);
4785   }
4786 
4787   // optional uint64 instruction_start = 4;
4788   if (cached_has_bits & 0x00000008u) {
4789     target = stream->EnsureSpace(target);
4790     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_instruction_start(), target);
4791   }
4792 
4793   // optional uint64 instruction_size_bytes = 5;
4794   if (cached_has_bits & 0x00000010u) {
4795     target = stream->EnsureSpace(target);
4796     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_instruction_size_bytes(), target);
4797   }
4798 
4799   // optional bytes machine_code = 6;
4800   if (cached_has_bits & 0x00000001u) {
4801     target = stream->WriteBytesMaybeAliased(
4802         6, this->_internal_machine_code(), target);
4803   }
4804 
4805   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4806     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4807         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4808   }
4809   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.V8RegExpCode)
4810   return target;
4811 }
4812 
ByteSizeLong() const4813 size_t V8RegExpCode::ByteSizeLong() const {
4814 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.V8RegExpCode)
4815   size_t total_size = 0;
4816 
4817   ::uint32_t cached_has_bits = 0;
4818   // Prevent compiler warnings about cached_has_bits being unused
4819   (void) cached_has_bits;
4820 
4821   cached_has_bits = _impl_._has_bits_[0];
4822   if (cached_has_bits & 0x0000003fu) {
4823     // optional bytes machine_code = 6;
4824     if (cached_has_bits & 0x00000001u) {
4825       total_size += 1 +
4826         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
4827           this->_internal_machine_code());
4828     }
4829 
4830     // optional .perfetto.protos.V8String pattern = 3;
4831     if (cached_has_bits & 0x00000002u) {
4832       total_size += 1 +
4833         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
4834           *_impl_.pattern_);
4835     }
4836 
4837     // optional uint64 v8_isolate_iid = 1;
4838     if (cached_has_bits & 0x00000004u) {
4839       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_v8_isolate_iid());
4840     }
4841 
4842     // optional uint64 instruction_start = 4;
4843     if (cached_has_bits & 0x00000008u) {
4844       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_instruction_start());
4845     }
4846 
4847     // optional uint64 instruction_size_bytes = 5;
4848     if (cached_has_bits & 0x00000010u) {
4849       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_instruction_size_bytes());
4850     }
4851 
4852     // optional uint32 tid = 2;
4853     if (cached_has_bits & 0x00000020u) {
4854       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tid());
4855     }
4856 
4857   }
4858   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4859     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4860   }
4861   int cached_size = ::_pbi::ToCachedSize(total_size);
4862   SetCachedSize(cached_size);
4863   return total_size;
4864 }
4865 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4866 void V8RegExpCode::CheckTypeAndMergeFrom(
4867     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4868   MergeFrom(*::_pbi::DownCast<const V8RegExpCode*>(
4869       &from));
4870 }
4871 
MergeFrom(const V8RegExpCode & from)4872 void V8RegExpCode::MergeFrom(const V8RegExpCode& from) {
4873   V8RegExpCode* const _this = this;
4874   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.V8RegExpCode)
4875   GOOGLE_DCHECK_NE(&from, _this);
4876   ::uint32_t cached_has_bits = 0;
4877   (void) cached_has_bits;
4878 
4879   cached_has_bits = from._impl_._has_bits_[0];
4880   if (cached_has_bits & 0x0000003fu) {
4881     if (cached_has_bits & 0x00000001u) {
4882       _this->_internal_set_machine_code(from._internal_machine_code());
4883     }
4884     if (cached_has_bits & 0x00000002u) {
4885       _this->_internal_mutable_pattern()->::perfetto::protos::V8String::MergeFrom(
4886           from._internal_pattern());
4887     }
4888     if (cached_has_bits & 0x00000004u) {
4889       _this->_impl_.v8_isolate_iid_ = from._impl_.v8_isolate_iid_;
4890     }
4891     if (cached_has_bits & 0x00000008u) {
4892       _this->_impl_.instruction_start_ = from._impl_.instruction_start_;
4893     }
4894     if (cached_has_bits & 0x00000010u) {
4895       _this->_impl_.instruction_size_bytes_ = from._impl_.instruction_size_bytes_;
4896     }
4897     if (cached_has_bits & 0x00000020u) {
4898       _this->_impl_.tid_ = from._impl_.tid_;
4899     }
4900     _this->_impl_._has_bits_[0] |= cached_has_bits;
4901   }
4902   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4903 }
4904 
CopyFrom(const V8RegExpCode & from)4905 void V8RegExpCode::CopyFrom(const V8RegExpCode& from) {
4906 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.V8RegExpCode)
4907   if (&from == this) return;
4908   Clear();
4909   MergeFrom(from);
4910 }
4911 
IsInitialized() const4912 bool V8RegExpCode::IsInitialized() const {
4913   return true;
4914 }
4915 
InternalSwap(V8RegExpCode * other)4916 void V8RegExpCode::InternalSwap(V8RegExpCode* other) {
4917   using std::swap;
4918   auto* lhs_arena = GetArenaForAllocation();
4919   auto* rhs_arena = other->GetArenaForAllocation();
4920   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4921   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4922   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4923       &_impl_.machine_code_, lhs_arena,
4924       &other->_impl_.machine_code_, rhs_arena
4925   );
4926   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4927       PROTOBUF_FIELD_OFFSET(V8RegExpCode, _impl_.tid_)
4928       + sizeof(V8RegExpCode::_impl_.tid_)  // NOLINT
4929       - PROTOBUF_FIELD_OFFSET(V8RegExpCode, _impl_.pattern_)>(
4930           reinterpret_cast<char*>(&_impl_.pattern_),
4931           reinterpret_cast<char*>(&other->_impl_.pattern_));
4932 }
4933 
GetTypeName() const4934 std::string V8RegExpCode::GetTypeName() const {
4935   return "perfetto.protos.V8RegExpCode";
4936 }
4937 
4938 
4939 // ===================================================================
4940 
4941 class V8CodeMove::_Internal {
4942  public:
4943   using HasBits = decltype(std::declval<V8CodeMove>()._impl_._has_bits_);
set_has_isolate_iid(HasBits * has_bits)4944   static void set_has_isolate_iid(HasBits* has_bits) {
4945     (*has_bits)[0] |= 1u;
4946   }
set_has_tid(HasBits * has_bits)4947   static void set_has_tid(HasBits* has_bits) {
4948     (*has_bits)[0] |= 16u;
4949   }
set_has_from_instruction_start_address(HasBits * has_bits)4950   static void set_has_from_instruction_start_address(HasBits* has_bits) {
4951     (*has_bits)[0] |= 2u;
4952   }
set_has_to_instruction_start_address(HasBits * has_bits)4953   static void set_has_to_instruction_start_address(HasBits* has_bits) {
4954     (*has_bits)[0] |= 4u;
4955   }
set_has_instruction_size_bytes(HasBits * has_bits)4956   static void set_has_instruction_size_bytes(HasBits* has_bits) {
4957     (*has_bits)[0] |= 8u;
4958   }
4959 };
4960 
V8CodeMove(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4961 V8CodeMove::V8CodeMove(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4962                          bool is_message_owned)
4963   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4964   SharedCtor(arena, is_message_owned);
4965   // @@protoc_insertion_point(arena_constructor:perfetto.protos.V8CodeMove)
4966 }
V8CodeMove(const V8CodeMove & from)4967 V8CodeMove::V8CodeMove(const V8CodeMove& from)
4968   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4969   V8CodeMove* const _this = this; (void)_this;
4970   new (&_impl_) Impl_{
4971       decltype(_impl_._has_bits_){from._impl_._has_bits_}
4972     , /*decltype(_impl_._cached_size_)*/{}
4973     , decltype(_impl_.isolate_iid_){}
4974     , decltype(_impl_.from_instruction_start_address_){}
4975     , decltype(_impl_.to_instruction_start_address_){}
4976     , decltype(_impl_.instruction_size_bytes_){}
4977     , decltype(_impl_.tid_){}
4978     , decltype(_impl_.to_instructions_){}
4979     , /*decltype(_impl_._oneof_case_)*/{}};
4980 
4981   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4982   ::memcpy(&_impl_.isolate_iid_, &from._impl_.isolate_iid_,
4983     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.tid_) -
4984     reinterpret_cast<char*>(&_impl_.isolate_iid_)) + sizeof(_impl_.tid_));
4985   clear_has_to_instructions();
4986   switch (from.to_instructions_case()) {
4987     case kToMachineCode: {
4988       _this->_internal_set_to_machine_code(from._internal_to_machine_code());
4989       break;
4990     }
4991     case kToBytecode: {
4992       _this->_internal_set_to_bytecode(from._internal_to_bytecode());
4993       break;
4994     }
4995     case TO_INSTRUCTIONS_NOT_SET: {
4996       break;
4997     }
4998   }
4999   // @@protoc_insertion_point(copy_constructor:perfetto.protos.V8CodeMove)
5000 }
5001 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5002 inline void V8CodeMove::SharedCtor(
5003     ::_pb::Arena* arena, bool is_message_owned) {
5004   (void)arena;
5005   (void)is_message_owned;
5006   new (&_impl_) Impl_{
5007       decltype(_impl_._has_bits_){}
5008     , /*decltype(_impl_._cached_size_)*/{}
5009     , decltype(_impl_.isolate_iid_){::uint64_t{0u}}
5010     , decltype(_impl_.from_instruction_start_address_){::uint64_t{0u}}
5011     , decltype(_impl_.to_instruction_start_address_){::uint64_t{0u}}
5012     , decltype(_impl_.instruction_size_bytes_){::uint64_t{0u}}
5013     , decltype(_impl_.tid_){0u}
5014     , decltype(_impl_.to_instructions_){}
5015     , /*decltype(_impl_._oneof_case_)*/{}
5016   };
5017   clear_has_to_instructions();
5018 }
5019 
~V8CodeMove()5020 V8CodeMove::~V8CodeMove() {
5021   // @@protoc_insertion_point(destructor:perfetto.protos.V8CodeMove)
5022   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5023   (void)arena;
5024     return;
5025   }
5026   SharedDtor();
5027 }
5028 
SharedDtor()5029 inline void V8CodeMove::SharedDtor() {
5030   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5031   if (has_to_instructions()) {
5032     clear_to_instructions();
5033   }
5034 }
5035 
SetCachedSize(int size) const5036 void V8CodeMove::SetCachedSize(int size) const {
5037   _impl_._cached_size_.Set(size);
5038 }
5039 
clear_to_instructions()5040 void V8CodeMove::clear_to_instructions() {
5041 // @@protoc_insertion_point(one_of_clear_start:perfetto.protos.V8CodeMove)
5042   switch (to_instructions_case()) {
5043     case kToMachineCode: {
5044       _impl_.to_instructions_.to_machine_code_.Destroy();
5045       break;
5046     }
5047     case kToBytecode: {
5048       _impl_.to_instructions_.to_bytecode_.Destroy();
5049       break;
5050     }
5051     case TO_INSTRUCTIONS_NOT_SET: {
5052       break;
5053     }
5054   }
5055   _impl_._oneof_case_[0] = TO_INSTRUCTIONS_NOT_SET;
5056 }
5057 
5058 
Clear()5059 void V8CodeMove::Clear() {
5060 // @@protoc_insertion_point(message_clear_start:perfetto.protos.V8CodeMove)
5061   ::uint32_t cached_has_bits = 0;
5062   // Prevent compiler warnings about cached_has_bits being unused
5063   (void) cached_has_bits;
5064 
5065   cached_has_bits = _impl_._has_bits_[0];
5066   if (cached_has_bits & 0x0000001fu) {
5067     ::memset(&_impl_.isolate_iid_, 0, static_cast<size_t>(
5068         reinterpret_cast<char*>(&_impl_.tid_) -
5069         reinterpret_cast<char*>(&_impl_.isolate_iid_)) + sizeof(_impl_.tid_));
5070   }
5071   clear_to_instructions();
5072   _impl_._has_bits_.Clear();
5073   _internal_metadata_.Clear<std::string>();
5074 }
5075 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5076 const char* V8CodeMove::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5077 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5078   _Internal::HasBits has_bits{};
5079   while (!ctx->Done(&ptr)) {
5080     ::uint32_t tag;
5081     ptr = ::_pbi::ReadTag(ptr, &tag);
5082     switch (tag >> 3) {
5083       // optional uint64 isolate_iid = 1;
5084       case 1:
5085         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
5086           _Internal::set_has_isolate_iid(&has_bits);
5087           _impl_.isolate_iid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
5088           CHK_(ptr);
5089         } else {
5090           goto handle_unusual;
5091         }
5092         continue;
5093       // optional uint32 tid = 2;
5094       case 2:
5095         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
5096           _Internal::set_has_tid(&has_bits);
5097           _impl_.tid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5098           CHK_(ptr);
5099         } else {
5100           goto handle_unusual;
5101         }
5102         continue;
5103       // optional uint64 from_instruction_start_address = 3;
5104       case 3:
5105         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
5106           _Internal::set_has_from_instruction_start_address(&has_bits);
5107           _impl_.from_instruction_start_address_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
5108           CHK_(ptr);
5109         } else {
5110           goto handle_unusual;
5111         }
5112         continue;
5113       // optional uint64 to_instruction_start_address = 4;
5114       case 4:
5115         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
5116           _Internal::set_has_to_instruction_start_address(&has_bits);
5117           _impl_.to_instruction_start_address_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
5118           CHK_(ptr);
5119         } else {
5120           goto handle_unusual;
5121         }
5122         continue;
5123       // optional uint64 instruction_size_bytes = 5;
5124       case 5:
5125         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
5126           _Internal::set_has_instruction_size_bytes(&has_bits);
5127           _impl_.instruction_size_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
5128           CHK_(ptr);
5129         } else {
5130           goto handle_unusual;
5131         }
5132         continue;
5133       // bytes to_machine_code = 6;
5134       case 6:
5135         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
5136           auto str = _internal_mutable_to_machine_code();
5137           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
5138           CHK_(ptr);
5139         } else {
5140           goto handle_unusual;
5141         }
5142         continue;
5143       // bytes to_bytecode = 7;
5144       case 7:
5145         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
5146           auto str = _internal_mutable_to_bytecode();
5147           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
5148           CHK_(ptr);
5149         } else {
5150           goto handle_unusual;
5151         }
5152         continue;
5153       default:
5154         goto handle_unusual;
5155     }  // switch
5156   handle_unusual:
5157     if ((tag == 0) || ((tag & 7) == 4)) {
5158       CHK_(ptr);
5159       ctx->SetLastTag(tag);
5160       goto message_done;
5161     }
5162     ptr = UnknownFieldParse(
5163         tag,
5164         _internal_metadata_.mutable_unknown_fields<std::string>(),
5165         ptr, ctx);
5166     CHK_(ptr != nullptr);
5167   }  // while
5168 message_done:
5169   _impl_._has_bits_.Or(has_bits);
5170   return ptr;
5171 failure:
5172   ptr = nullptr;
5173   goto message_done;
5174 #undef CHK_
5175 }
5176 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5177 ::uint8_t* V8CodeMove::_InternalSerialize(
5178     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5179   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.V8CodeMove)
5180   ::uint32_t cached_has_bits = 0;
5181   (void) cached_has_bits;
5182 
5183   cached_has_bits = _impl_._has_bits_[0];
5184   // optional uint64 isolate_iid = 1;
5185   if (cached_has_bits & 0x00000001u) {
5186     target = stream->EnsureSpace(target);
5187     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_isolate_iid(), target);
5188   }
5189 
5190   // optional uint32 tid = 2;
5191   if (cached_has_bits & 0x00000010u) {
5192     target = stream->EnsureSpace(target);
5193     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_tid(), target);
5194   }
5195 
5196   // optional uint64 from_instruction_start_address = 3;
5197   if (cached_has_bits & 0x00000002u) {
5198     target = stream->EnsureSpace(target);
5199     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_from_instruction_start_address(), target);
5200   }
5201 
5202   // optional uint64 to_instruction_start_address = 4;
5203   if (cached_has_bits & 0x00000004u) {
5204     target = stream->EnsureSpace(target);
5205     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_to_instruction_start_address(), target);
5206   }
5207 
5208   // optional uint64 instruction_size_bytes = 5;
5209   if (cached_has_bits & 0x00000008u) {
5210     target = stream->EnsureSpace(target);
5211     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_instruction_size_bytes(), target);
5212   }
5213 
5214   switch (to_instructions_case()) {
5215     case kToMachineCode: {
5216       target = stream->WriteBytesMaybeAliased(
5217           6, this->_internal_to_machine_code(), target);
5218       break;
5219     }
5220     case kToBytecode: {
5221       target = stream->WriteBytesMaybeAliased(
5222           7, this->_internal_to_bytecode(), target);
5223       break;
5224     }
5225     default: ;
5226   }
5227   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5228     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5229         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5230   }
5231   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.V8CodeMove)
5232   return target;
5233 }
5234 
ByteSizeLong() const5235 size_t V8CodeMove::ByteSizeLong() const {
5236 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.V8CodeMove)
5237   size_t total_size = 0;
5238 
5239   ::uint32_t cached_has_bits = 0;
5240   // Prevent compiler warnings about cached_has_bits being unused
5241   (void) cached_has_bits;
5242 
5243   cached_has_bits = _impl_._has_bits_[0];
5244   if (cached_has_bits & 0x0000001fu) {
5245     // optional uint64 isolate_iid = 1;
5246     if (cached_has_bits & 0x00000001u) {
5247       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_isolate_iid());
5248     }
5249 
5250     // optional uint64 from_instruction_start_address = 3;
5251     if (cached_has_bits & 0x00000002u) {
5252       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_from_instruction_start_address());
5253     }
5254 
5255     // optional uint64 to_instruction_start_address = 4;
5256     if (cached_has_bits & 0x00000004u) {
5257       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_to_instruction_start_address());
5258     }
5259 
5260     // optional uint64 instruction_size_bytes = 5;
5261     if (cached_has_bits & 0x00000008u) {
5262       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_instruction_size_bytes());
5263     }
5264 
5265     // optional uint32 tid = 2;
5266     if (cached_has_bits & 0x00000010u) {
5267       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tid());
5268     }
5269 
5270   }
5271   switch (to_instructions_case()) {
5272     // bytes to_machine_code = 6;
5273     case kToMachineCode: {
5274       total_size += 1 +
5275         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
5276           this->_internal_to_machine_code());
5277       break;
5278     }
5279     // bytes to_bytecode = 7;
5280     case kToBytecode: {
5281       total_size += 1 +
5282         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
5283           this->_internal_to_bytecode());
5284       break;
5285     }
5286     case TO_INSTRUCTIONS_NOT_SET: {
5287       break;
5288     }
5289   }
5290   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5291     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5292   }
5293   int cached_size = ::_pbi::ToCachedSize(total_size);
5294   SetCachedSize(cached_size);
5295   return total_size;
5296 }
5297 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5298 void V8CodeMove::CheckTypeAndMergeFrom(
5299     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5300   MergeFrom(*::_pbi::DownCast<const V8CodeMove*>(
5301       &from));
5302 }
5303 
MergeFrom(const V8CodeMove & from)5304 void V8CodeMove::MergeFrom(const V8CodeMove& from) {
5305   V8CodeMove* const _this = this;
5306   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.V8CodeMove)
5307   GOOGLE_DCHECK_NE(&from, _this);
5308   ::uint32_t cached_has_bits = 0;
5309   (void) cached_has_bits;
5310 
5311   cached_has_bits = from._impl_._has_bits_[0];
5312   if (cached_has_bits & 0x0000001fu) {
5313     if (cached_has_bits & 0x00000001u) {
5314       _this->_impl_.isolate_iid_ = from._impl_.isolate_iid_;
5315     }
5316     if (cached_has_bits & 0x00000002u) {
5317       _this->_impl_.from_instruction_start_address_ = from._impl_.from_instruction_start_address_;
5318     }
5319     if (cached_has_bits & 0x00000004u) {
5320       _this->_impl_.to_instruction_start_address_ = from._impl_.to_instruction_start_address_;
5321     }
5322     if (cached_has_bits & 0x00000008u) {
5323       _this->_impl_.instruction_size_bytes_ = from._impl_.instruction_size_bytes_;
5324     }
5325     if (cached_has_bits & 0x00000010u) {
5326       _this->_impl_.tid_ = from._impl_.tid_;
5327     }
5328     _this->_impl_._has_bits_[0] |= cached_has_bits;
5329   }
5330   switch (from.to_instructions_case()) {
5331     case kToMachineCode: {
5332       _this->_internal_set_to_machine_code(from._internal_to_machine_code());
5333       break;
5334     }
5335     case kToBytecode: {
5336       _this->_internal_set_to_bytecode(from._internal_to_bytecode());
5337       break;
5338     }
5339     case TO_INSTRUCTIONS_NOT_SET: {
5340       break;
5341     }
5342   }
5343   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5344 }
5345 
CopyFrom(const V8CodeMove & from)5346 void V8CodeMove::CopyFrom(const V8CodeMove& from) {
5347 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.V8CodeMove)
5348   if (&from == this) return;
5349   Clear();
5350   MergeFrom(from);
5351 }
5352 
IsInitialized() const5353 bool V8CodeMove::IsInitialized() const {
5354   return true;
5355 }
5356 
InternalSwap(V8CodeMove * other)5357 void V8CodeMove::InternalSwap(V8CodeMove* other) {
5358   using std::swap;
5359   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5360   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5361   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
5362       PROTOBUF_FIELD_OFFSET(V8CodeMove, _impl_.tid_)
5363       + sizeof(V8CodeMove::_impl_.tid_)  // NOLINT
5364       - PROTOBUF_FIELD_OFFSET(V8CodeMove, _impl_.isolate_iid_)>(
5365           reinterpret_cast<char*>(&_impl_.isolate_iid_),
5366           reinterpret_cast<char*>(&other->_impl_.isolate_iid_));
5367   swap(_impl_.to_instructions_, other->_impl_.to_instructions_);
5368   swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
5369 }
5370 
GetTypeName() const5371 std::string V8CodeMove::GetTypeName() const {
5372   return "perfetto.protos.V8CodeMove";
5373 }
5374 
5375 
5376 // ===================================================================
5377 
5378 class V8CodeDefaults::_Internal {
5379  public:
5380   using HasBits = decltype(std::declval<V8CodeDefaults>()._impl_._has_bits_);
set_has_tid(HasBits * has_bits)5381   static void set_has_tid(HasBits* has_bits) {
5382     (*has_bits)[0] |= 1u;
5383   }
5384 };
5385 
V8CodeDefaults(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5386 V8CodeDefaults::V8CodeDefaults(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5387                          bool is_message_owned)
5388   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5389   SharedCtor(arena, is_message_owned);
5390   // @@protoc_insertion_point(arena_constructor:perfetto.protos.V8CodeDefaults)
5391 }
V8CodeDefaults(const V8CodeDefaults & from)5392 V8CodeDefaults::V8CodeDefaults(const V8CodeDefaults& from)
5393   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5394   V8CodeDefaults* const _this = this; (void)_this;
5395   new (&_impl_) Impl_{
5396       decltype(_impl_._has_bits_){from._impl_._has_bits_}
5397     , /*decltype(_impl_._cached_size_)*/{}
5398     , decltype(_impl_.tid_){}};
5399 
5400   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5401   _this->_impl_.tid_ = from._impl_.tid_;
5402   // @@protoc_insertion_point(copy_constructor:perfetto.protos.V8CodeDefaults)
5403 }
5404 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5405 inline void V8CodeDefaults::SharedCtor(
5406     ::_pb::Arena* arena, bool is_message_owned) {
5407   (void)arena;
5408   (void)is_message_owned;
5409   new (&_impl_) Impl_{
5410       decltype(_impl_._has_bits_){}
5411     , /*decltype(_impl_._cached_size_)*/{}
5412     , decltype(_impl_.tid_){0u}
5413   };
5414 }
5415 
~V8CodeDefaults()5416 V8CodeDefaults::~V8CodeDefaults() {
5417   // @@protoc_insertion_point(destructor:perfetto.protos.V8CodeDefaults)
5418   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5419   (void)arena;
5420     return;
5421   }
5422   SharedDtor();
5423 }
5424 
SharedDtor()5425 inline void V8CodeDefaults::SharedDtor() {
5426   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5427 }
5428 
SetCachedSize(int size) const5429 void V8CodeDefaults::SetCachedSize(int size) const {
5430   _impl_._cached_size_.Set(size);
5431 }
5432 
Clear()5433 void V8CodeDefaults::Clear() {
5434 // @@protoc_insertion_point(message_clear_start:perfetto.protos.V8CodeDefaults)
5435   ::uint32_t cached_has_bits = 0;
5436   // Prevent compiler warnings about cached_has_bits being unused
5437   (void) cached_has_bits;
5438 
5439   _impl_.tid_ = 0u;
5440   _impl_._has_bits_.Clear();
5441   _internal_metadata_.Clear<std::string>();
5442 }
5443 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5444 const char* V8CodeDefaults::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5445 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5446   _Internal::HasBits has_bits{};
5447   while (!ctx->Done(&ptr)) {
5448     ::uint32_t tag;
5449     ptr = ::_pbi::ReadTag(ptr, &tag);
5450     switch (tag >> 3) {
5451       // optional uint32 tid = 1;
5452       case 1:
5453         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
5454           _Internal::set_has_tid(&has_bits);
5455           _impl_.tid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5456           CHK_(ptr);
5457         } else {
5458           goto handle_unusual;
5459         }
5460         continue;
5461       default:
5462         goto handle_unusual;
5463     }  // switch
5464   handle_unusual:
5465     if ((tag == 0) || ((tag & 7) == 4)) {
5466       CHK_(ptr);
5467       ctx->SetLastTag(tag);
5468       goto message_done;
5469     }
5470     ptr = UnknownFieldParse(
5471         tag,
5472         _internal_metadata_.mutable_unknown_fields<std::string>(),
5473         ptr, ctx);
5474     CHK_(ptr != nullptr);
5475   }  // while
5476 message_done:
5477   _impl_._has_bits_.Or(has_bits);
5478   return ptr;
5479 failure:
5480   ptr = nullptr;
5481   goto message_done;
5482 #undef CHK_
5483 }
5484 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5485 ::uint8_t* V8CodeDefaults::_InternalSerialize(
5486     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5487   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.V8CodeDefaults)
5488   ::uint32_t cached_has_bits = 0;
5489   (void) cached_has_bits;
5490 
5491   cached_has_bits = _impl_._has_bits_[0];
5492   // optional uint32 tid = 1;
5493   if (cached_has_bits & 0x00000001u) {
5494     target = stream->EnsureSpace(target);
5495     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_tid(), target);
5496   }
5497 
5498   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5499     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5500         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5501   }
5502   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.V8CodeDefaults)
5503   return target;
5504 }
5505 
ByteSizeLong() const5506 size_t V8CodeDefaults::ByteSizeLong() const {
5507 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.V8CodeDefaults)
5508   size_t total_size = 0;
5509 
5510   ::uint32_t cached_has_bits = 0;
5511   // Prevent compiler warnings about cached_has_bits being unused
5512   (void) cached_has_bits;
5513 
5514   // optional uint32 tid = 1;
5515   cached_has_bits = _impl_._has_bits_[0];
5516   if (cached_has_bits & 0x00000001u) {
5517     total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tid());
5518   }
5519 
5520   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5521     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5522   }
5523   int cached_size = ::_pbi::ToCachedSize(total_size);
5524   SetCachedSize(cached_size);
5525   return total_size;
5526 }
5527 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5528 void V8CodeDefaults::CheckTypeAndMergeFrom(
5529     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5530   MergeFrom(*::_pbi::DownCast<const V8CodeDefaults*>(
5531       &from));
5532 }
5533 
MergeFrom(const V8CodeDefaults & from)5534 void V8CodeDefaults::MergeFrom(const V8CodeDefaults& from) {
5535   V8CodeDefaults* const _this = this;
5536   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.V8CodeDefaults)
5537   GOOGLE_DCHECK_NE(&from, _this);
5538   ::uint32_t cached_has_bits = 0;
5539   (void) cached_has_bits;
5540 
5541   if (from._internal_has_tid()) {
5542     _this->_internal_set_tid(from._internal_tid());
5543   }
5544   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5545 }
5546 
CopyFrom(const V8CodeDefaults & from)5547 void V8CodeDefaults::CopyFrom(const V8CodeDefaults& from) {
5548 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.V8CodeDefaults)
5549   if (&from == this) return;
5550   Clear();
5551   MergeFrom(from);
5552 }
5553 
IsInitialized() const5554 bool V8CodeDefaults::IsInitialized() const {
5555   return true;
5556 }
5557 
InternalSwap(V8CodeDefaults * other)5558 void V8CodeDefaults::InternalSwap(V8CodeDefaults* other) {
5559   using std::swap;
5560   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5561   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5562   swap(_impl_.tid_, other->_impl_.tid_);
5563 }
5564 
GetTypeName() const5565 std::string V8CodeDefaults::GetTypeName() const {
5566   return "perfetto.protos.V8CodeDefaults";
5567 }
5568 
5569 
5570 // @@protoc_insertion_point(namespace_scope)
5571 }  // namespace protos
5572 }  // namespace perfetto
5573 PROTOBUF_NAMESPACE_OPEN
5574 template<> PROTOBUF_NOINLINE ::perfetto::protos::V8String*
CreateMaybeMessage(Arena * arena)5575 Arena::CreateMaybeMessage< ::perfetto::protos::V8String >(Arena* arena) {
5576   return Arena::CreateMessageInternal< ::perfetto::protos::V8String >(arena);
5577 }
5578 template<> PROTOBUF_NOINLINE ::perfetto::protos::InternedV8String*
CreateMaybeMessage(Arena * arena)5579 Arena::CreateMaybeMessage< ::perfetto::protos::InternedV8String >(Arena* arena) {
5580   return Arena::CreateMessageInternal< ::perfetto::protos::InternedV8String >(arena);
5581 }
5582 template<> PROTOBUF_NOINLINE ::perfetto::protos::InternedV8JsScript*
CreateMaybeMessage(Arena * arena)5583 Arena::CreateMaybeMessage< ::perfetto::protos::InternedV8JsScript >(Arena* arena) {
5584   return Arena::CreateMessageInternal< ::perfetto::protos::InternedV8JsScript >(arena);
5585 }
5586 template<> PROTOBUF_NOINLINE ::perfetto::protos::InternedV8WasmScript*
CreateMaybeMessage(Arena * arena)5587 Arena::CreateMaybeMessage< ::perfetto::protos::InternedV8WasmScript >(Arena* arena) {
5588   return Arena::CreateMessageInternal< ::perfetto::protos::InternedV8WasmScript >(arena);
5589 }
5590 template<> PROTOBUF_NOINLINE ::perfetto::protos::InternedV8JsFunction*
CreateMaybeMessage(Arena * arena)5591 Arena::CreateMaybeMessage< ::perfetto::protos::InternedV8JsFunction >(Arena* arena) {
5592   return Arena::CreateMessageInternal< ::perfetto::protos::InternedV8JsFunction >(arena);
5593 }
5594 template<> PROTOBUF_NOINLINE ::perfetto::protos::InternedV8Isolate_CodeRange*
CreateMaybeMessage(Arena * arena)5595 Arena::CreateMaybeMessage< ::perfetto::protos::InternedV8Isolate_CodeRange >(Arena* arena) {
5596   return Arena::CreateMessageInternal< ::perfetto::protos::InternedV8Isolate_CodeRange >(arena);
5597 }
5598 template<> PROTOBUF_NOINLINE ::perfetto::protos::InternedV8Isolate*
CreateMaybeMessage(Arena * arena)5599 Arena::CreateMaybeMessage< ::perfetto::protos::InternedV8Isolate >(Arena* arena) {
5600   return Arena::CreateMessageInternal< ::perfetto::protos::InternedV8Isolate >(arena);
5601 }
5602 template<> PROTOBUF_NOINLINE ::perfetto::protos::V8JsCode*
CreateMaybeMessage(Arena * arena)5603 Arena::CreateMaybeMessage< ::perfetto::protos::V8JsCode >(Arena* arena) {
5604   return Arena::CreateMessageInternal< ::perfetto::protos::V8JsCode >(arena);
5605 }
5606 template<> PROTOBUF_NOINLINE ::perfetto::protos::V8InternalCode*
CreateMaybeMessage(Arena * arena)5607 Arena::CreateMaybeMessage< ::perfetto::protos::V8InternalCode >(Arena* arena) {
5608   return Arena::CreateMessageInternal< ::perfetto::protos::V8InternalCode >(arena);
5609 }
5610 template<> PROTOBUF_NOINLINE ::perfetto::protos::V8WasmCode*
CreateMaybeMessage(Arena * arena)5611 Arena::CreateMaybeMessage< ::perfetto::protos::V8WasmCode >(Arena* arena) {
5612   return Arena::CreateMessageInternal< ::perfetto::protos::V8WasmCode >(arena);
5613 }
5614 template<> PROTOBUF_NOINLINE ::perfetto::protos::V8RegExpCode*
CreateMaybeMessage(Arena * arena)5615 Arena::CreateMaybeMessage< ::perfetto::protos::V8RegExpCode >(Arena* arena) {
5616   return Arena::CreateMessageInternal< ::perfetto::protos::V8RegExpCode >(arena);
5617 }
5618 template<> PROTOBUF_NOINLINE ::perfetto::protos::V8CodeMove*
CreateMaybeMessage(Arena * arena)5619 Arena::CreateMaybeMessage< ::perfetto::protos::V8CodeMove >(Arena* arena) {
5620   return Arena::CreateMessageInternal< ::perfetto::protos::V8CodeMove >(arena);
5621 }
5622 template<> PROTOBUF_NOINLINE ::perfetto::protos::V8CodeDefaults*
CreateMaybeMessage(Arena * arena)5623 Arena::CreateMaybeMessage< ::perfetto::protos::V8CodeDefaults >(Arena* arena) {
5624   return Arena::CreateMessageInternal< ::perfetto::protos::V8CodeDefaults >(arena);
5625 }
5626 PROTOBUF_NAMESPACE_CLOSE
5627 
5628 // @@protoc_insertion_point(global_scope)
5629 #include <google/protobuf/port_undef.inc>
5630