1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub const BUILD_ID_BYTES: u32 = 20;
13
14#[derive(Clone, Debug, PartialEq)]
15pub struct SamplerRecordAllocationRequest {
16 pub address: u64,
18 pub stack_trace: StackTrace,
26 pub size: u64,
28}
29
30impl fidl::Persistable for SamplerRecordAllocationRequest {}
31
32#[derive(Clone, Debug, PartialEq)]
33pub struct SamplerRecordDeallocationRequest {
34 pub address: u64,
36 pub stack_trace: StackTrace,
44}
45
46impl fidl::Persistable for SamplerRecordDeallocationRequest {}
47
48#[derive(Clone, Debug, Default, PartialEq)]
50pub struct ExecutableSegment {
51 pub start_address: Option<u64>,
53 pub size: Option<u64>,
55 pub relative_address: Option<u64>,
57 #[doc(hidden)]
58 pub __source_breaking: fidl::marker::SourceBreaking,
59}
60
61impl fidl::Persistable for ExecutableSegment {}
62
63#[derive(Clone, Debug, Default, PartialEq)]
67pub struct ModuleMap {
68 pub build_id: Option<Vec<u8>>,
70 pub executable_segments: Option<Vec<ExecutableSegment>>,
72 #[doc(hidden)]
73 pub __source_breaking: fidl::marker::SourceBreaking,
74}
75
76impl fidl::Persistable for ModuleMap {}
77
78#[derive(Clone, Debug, Default, PartialEq)]
79pub struct SamplerSetProcessInfoRequest {
80 pub process_name: Option<String>,
82 pub module_map: Option<Vec<ModuleMap>>,
84 #[doc(hidden)]
85 pub __source_breaking: fidl::marker::SourceBreaking,
86}
87
88impl fidl::Persistable for SamplerSetProcessInfoRequest {}
89
90#[derive(Clone, Debug, Default, PartialEq)]
92pub struct StackTrace {
93 pub stack_frames: Option<Vec<u64>>,
95 #[doc(hidden)]
96 pub __source_breaking: fidl::marker::SourceBreaking,
97}
98
99impl fidl::Persistable for StackTrace {}
100
101pub mod sampler_ordinals {
102 pub const RECORD_ALLOCATION: u64 = 0x6b0add9f7769824d;
103 pub const RECORD_DEALLOCATION: u64 = 0x503bff5ec34dbeeb;
104 pub const SET_PROCESS_INFO: u64 = 0x68a0557106e51783;
105}
106
107mod internal {
108 use super::*;
109
110 impl fidl::encoding::ValueTypeMarker for SamplerRecordAllocationRequest {
111 type Borrowed<'a> = &'a Self;
112 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
113 value
114 }
115 }
116
117 unsafe impl fidl::encoding::TypeMarker for SamplerRecordAllocationRequest {
118 type Owned = Self;
119
120 #[inline(always)]
121 fn inline_align(_context: fidl::encoding::Context) -> usize {
122 8
123 }
124
125 #[inline(always)]
126 fn inline_size(_context: fidl::encoding::Context) -> usize {
127 32
128 }
129 }
130
131 unsafe impl<D: fidl::encoding::ResourceDialect>
132 fidl::encoding::Encode<SamplerRecordAllocationRequest, D>
133 for &SamplerRecordAllocationRequest
134 {
135 #[inline]
136 unsafe fn encode(
137 self,
138 encoder: &mut fidl::encoding::Encoder<'_, D>,
139 offset: usize,
140 _depth: fidl::encoding::Depth,
141 ) -> fidl::Result<()> {
142 encoder.debug_check_bounds::<SamplerRecordAllocationRequest>(offset);
143 fidl::encoding::Encode::<SamplerRecordAllocationRequest, D>::encode(
145 (
146 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
147 <StackTrace as fidl::encoding::ValueTypeMarker>::borrow(&self.stack_trace),
148 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.size),
149 ),
150 encoder,
151 offset,
152 _depth,
153 )
154 }
155 }
156 unsafe impl<
157 D: fidl::encoding::ResourceDialect,
158 T0: fidl::encoding::Encode<u64, D>,
159 T1: fidl::encoding::Encode<StackTrace, D>,
160 T2: fidl::encoding::Encode<u64, D>,
161 > fidl::encoding::Encode<SamplerRecordAllocationRequest, D> for (T0, T1, T2)
162 {
163 #[inline]
164 unsafe fn encode(
165 self,
166 encoder: &mut fidl::encoding::Encoder<'_, D>,
167 offset: usize,
168 depth: fidl::encoding::Depth,
169 ) -> fidl::Result<()> {
170 encoder.debug_check_bounds::<SamplerRecordAllocationRequest>(offset);
171 self.0.encode(encoder, offset + 0, depth)?;
175 self.1.encode(encoder, offset + 8, depth)?;
176 self.2.encode(encoder, offset + 24, depth)?;
177 Ok(())
178 }
179 }
180
181 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
182 for SamplerRecordAllocationRequest
183 {
184 #[inline(always)]
185 fn new_empty() -> Self {
186 Self {
187 address: fidl::new_empty!(u64, D),
188 stack_trace: fidl::new_empty!(StackTrace, D),
189 size: fidl::new_empty!(u64, D),
190 }
191 }
192
193 #[inline]
194 unsafe fn decode(
195 &mut self,
196 decoder: &mut fidl::encoding::Decoder<'_, D>,
197 offset: usize,
198 _depth: fidl::encoding::Depth,
199 ) -> fidl::Result<()> {
200 decoder.debug_check_bounds::<Self>(offset);
201 fidl::decode!(u64, D, &mut self.address, decoder, offset + 0, _depth)?;
203 fidl::decode!(StackTrace, D, &mut self.stack_trace, decoder, offset + 8, _depth)?;
204 fidl::decode!(u64, D, &mut self.size, decoder, offset + 24, _depth)?;
205 Ok(())
206 }
207 }
208
209 impl fidl::encoding::ValueTypeMarker for SamplerRecordDeallocationRequest {
210 type Borrowed<'a> = &'a Self;
211 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
212 value
213 }
214 }
215
216 unsafe impl fidl::encoding::TypeMarker for SamplerRecordDeallocationRequest {
217 type Owned = Self;
218
219 #[inline(always)]
220 fn inline_align(_context: fidl::encoding::Context) -> usize {
221 8
222 }
223
224 #[inline(always)]
225 fn inline_size(_context: fidl::encoding::Context) -> usize {
226 24
227 }
228 }
229
230 unsafe impl<D: fidl::encoding::ResourceDialect>
231 fidl::encoding::Encode<SamplerRecordDeallocationRequest, D>
232 for &SamplerRecordDeallocationRequest
233 {
234 #[inline]
235 unsafe fn encode(
236 self,
237 encoder: &mut fidl::encoding::Encoder<'_, D>,
238 offset: usize,
239 _depth: fidl::encoding::Depth,
240 ) -> fidl::Result<()> {
241 encoder.debug_check_bounds::<SamplerRecordDeallocationRequest>(offset);
242 fidl::encoding::Encode::<SamplerRecordDeallocationRequest, D>::encode(
244 (
245 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
246 <StackTrace as fidl::encoding::ValueTypeMarker>::borrow(&self.stack_trace),
247 ),
248 encoder,
249 offset,
250 _depth,
251 )
252 }
253 }
254 unsafe impl<
255 D: fidl::encoding::ResourceDialect,
256 T0: fidl::encoding::Encode<u64, D>,
257 T1: fidl::encoding::Encode<StackTrace, D>,
258 > fidl::encoding::Encode<SamplerRecordDeallocationRequest, D> for (T0, T1)
259 {
260 #[inline]
261 unsafe fn encode(
262 self,
263 encoder: &mut fidl::encoding::Encoder<'_, D>,
264 offset: usize,
265 depth: fidl::encoding::Depth,
266 ) -> fidl::Result<()> {
267 encoder.debug_check_bounds::<SamplerRecordDeallocationRequest>(offset);
268 self.0.encode(encoder, offset + 0, depth)?;
272 self.1.encode(encoder, offset + 8, depth)?;
273 Ok(())
274 }
275 }
276
277 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
278 for SamplerRecordDeallocationRequest
279 {
280 #[inline(always)]
281 fn new_empty() -> Self {
282 Self { address: fidl::new_empty!(u64, D), stack_trace: fidl::new_empty!(StackTrace, D) }
283 }
284
285 #[inline]
286 unsafe fn decode(
287 &mut self,
288 decoder: &mut fidl::encoding::Decoder<'_, D>,
289 offset: usize,
290 _depth: fidl::encoding::Depth,
291 ) -> fidl::Result<()> {
292 decoder.debug_check_bounds::<Self>(offset);
293 fidl::decode!(u64, D, &mut self.address, decoder, offset + 0, _depth)?;
295 fidl::decode!(StackTrace, D, &mut self.stack_trace, decoder, offset + 8, _depth)?;
296 Ok(())
297 }
298 }
299
300 impl ExecutableSegment {
301 #[inline(always)]
302 fn max_ordinal_present(&self) -> u64 {
303 if let Some(_) = self.relative_address {
304 return 3;
305 }
306 if let Some(_) = self.size {
307 return 2;
308 }
309 if let Some(_) = self.start_address {
310 return 1;
311 }
312 0
313 }
314 }
315
316 impl fidl::encoding::ValueTypeMarker for ExecutableSegment {
317 type Borrowed<'a> = &'a Self;
318 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
319 value
320 }
321 }
322
323 unsafe impl fidl::encoding::TypeMarker for ExecutableSegment {
324 type Owned = Self;
325
326 #[inline(always)]
327 fn inline_align(_context: fidl::encoding::Context) -> usize {
328 8
329 }
330
331 #[inline(always)]
332 fn inline_size(_context: fidl::encoding::Context) -> usize {
333 16
334 }
335 }
336
337 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExecutableSegment, D>
338 for &ExecutableSegment
339 {
340 unsafe fn encode(
341 self,
342 encoder: &mut fidl::encoding::Encoder<'_, D>,
343 offset: usize,
344 mut depth: fidl::encoding::Depth,
345 ) -> fidl::Result<()> {
346 encoder.debug_check_bounds::<ExecutableSegment>(offset);
347 let max_ordinal: u64 = self.max_ordinal_present();
349 encoder.write_num(max_ordinal, offset);
350 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
351 if max_ordinal == 0 {
353 return Ok(());
354 }
355 depth.increment()?;
356 let envelope_size = 8;
357 let bytes_len = max_ordinal as usize * envelope_size;
358 #[allow(unused_variables)]
359 let offset = encoder.out_of_line_offset(bytes_len);
360 let mut _prev_end_offset: usize = 0;
361 if 1 > max_ordinal {
362 return Ok(());
363 }
364
365 let cur_offset: usize = (1 - 1) * envelope_size;
368
369 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
371
372 fidl::encoding::encode_in_envelope_optional::<u64, D>(
377 self.start_address.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
378 encoder,
379 offset + cur_offset,
380 depth,
381 )?;
382
383 _prev_end_offset = cur_offset + envelope_size;
384 if 2 > max_ordinal {
385 return Ok(());
386 }
387
388 let cur_offset: usize = (2 - 1) * envelope_size;
391
392 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
394
395 fidl::encoding::encode_in_envelope_optional::<u64, D>(
400 self.size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
401 encoder,
402 offset + cur_offset,
403 depth,
404 )?;
405
406 _prev_end_offset = cur_offset + envelope_size;
407 if 3 > max_ordinal {
408 return Ok(());
409 }
410
411 let cur_offset: usize = (3 - 1) * envelope_size;
414
415 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
417
418 fidl::encoding::encode_in_envelope_optional::<u64, D>(
423 self.relative_address
424 .as_ref()
425 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
426 encoder,
427 offset + cur_offset,
428 depth,
429 )?;
430
431 _prev_end_offset = cur_offset + envelope_size;
432
433 Ok(())
434 }
435 }
436
437 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExecutableSegment {
438 #[inline(always)]
439 fn new_empty() -> Self {
440 Self::default()
441 }
442
443 unsafe fn decode(
444 &mut self,
445 decoder: &mut fidl::encoding::Decoder<'_, D>,
446 offset: usize,
447 mut depth: fidl::encoding::Depth,
448 ) -> fidl::Result<()> {
449 decoder.debug_check_bounds::<Self>(offset);
450 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
451 None => return Err(fidl::Error::NotNullable),
452 Some(len) => len,
453 };
454 if len == 0 {
456 return Ok(());
457 };
458 depth.increment()?;
459 let envelope_size = 8;
460 let bytes_len = len * envelope_size;
461 let offset = decoder.out_of_line_offset(bytes_len)?;
462 let mut _next_ordinal_to_read = 0;
464 let mut next_offset = offset;
465 let end_offset = offset + bytes_len;
466 _next_ordinal_to_read += 1;
467 if next_offset >= end_offset {
468 return Ok(());
469 }
470
471 while _next_ordinal_to_read < 1 {
473 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
474 _next_ordinal_to_read += 1;
475 next_offset += envelope_size;
476 }
477
478 let next_out_of_line = decoder.next_out_of_line();
479 let handles_before = decoder.remaining_handles();
480 if let Some((inlined, num_bytes, num_handles)) =
481 fidl::encoding::decode_envelope_header(decoder, next_offset)?
482 {
483 let member_inline_size =
484 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
485 if inlined != (member_inline_size <= 4) {
486 return Err(fidl::Error::InvalidInlineBitInEnvelope);
487 }
488 let inner_offset;
489 let mut inner_depth = depth.clone();
490 if inlined {
491 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
492 inner_offset = next_offset;
493 } else {
494 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
495 inner_depth.increment()?;
496 }
497 let val_ref = self.start_address.get_or_insert_with(|| fidl::new_empty!(u64, D));
498 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
499 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
500 {
501 return Err(fidl::Error::InvalidNumBytesInEnvelope);
502 }
503 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
504 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
505 }
506 }
507
508 next_offset += envelope_size;
509 _next_ordinal_to_read += 1;
510 if next_offset >= end_offset {
511 return Ok(());
512 }
513
514 while _next_ordinal_to_read < 2 {
516 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
517 _next_ordinal_to_read += 1;
518 next_offset += envelope_size;
519 }
520
521 let next_out_of_line = decoder.next_out_of_line();
522 let handles_before = decoder.remaining_handles();
523 if let Some((inlined, num_bytes, num_handles)) =
524 fidl::encoding::decode_envelope_header(decoder, next_offset)?
525 {
526 let member_inline_size =
527 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
528 if inlined != (member_inline_size <= 4) {
529 return Err(fidl::Error::InvalidInlineBitInEnvelope);
530 }
531 let inner_offset;
532 let mut inner_depth = depth.clone();
533 if inlined {
534 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
535 inner_offset = next_offset;
536 } else {
537 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
538 inner_depth.increment()?;
539 }
540 let val_ref = self.size.get_or_insert_with(|| fidl::new_empty!(u64, D));
541 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
542 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
543 {
544 return Err(fidl::Error::InvalidNumBytesInEnvelope);
545 }
546 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
547 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
548 }
549 }
550
551 next_offset += envelope_size;
552 _next_ordinal_to_read += 1;
553 if next_offset >= end_offset {
554 return Ok(());
555 }
556
557 while _next_ordinal_to_read < 3 {
559 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
560 _next_ordinal_to_read += 1;
561 next_offset += envelope_size;
562 }
563
564 let next_out_of_line = decoder.next_out_of_line();
565 let handles_before = decoder.remaining_handles();
566 if let Some((inlined, num_bytes, num_handles)) =
567 fidl::encoding::decode_envelope_header(decoder, next_offset)?
568 {
569 let member_inline_size =
570 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
571 if inlined != (member_inline_size <= 4) {
572 return Err(fidl::Error::InvalidInlineBitInEnvelope);
573 }
574 let inner_offset;
575 let mut inner_depth = depth.clone();
576 if inlined {
577 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
578 inner_offset = next_offset;
579 } else {
580 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
581 inner_depth.increment()?;
582 }
583 let val_ref = self.relative_address.get_or_insert_with(|| fidl::new_empty!(u64, D));
584 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
585 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
586 {
587 return Err(fidl::Error::InvalidNumBytesInEnvelope);
588 }
589 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
590 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
591 }
592 }
593
594 next_offset += envelope_size;
595
596 while next_offset < end_offset {
598 _next_ordinal_to_read += 1;
599 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
600 next_offset += envelope_size;
601 }
602
603 Ok(())
604 }
605 }
606
607 impl ModuleMap {
608 #[inline(always)]
609 fn max_ordinal_present(&self) -> u64 {
610 if let Some(_) = self.executable_segments {
611 return 2;
612 }
613 if let Some(_) = self.build_id {
614 return 1;
615 }
616 0
617 }
618 }
619
620 impl fidl::encoding::ValueTypeMarker for ModuleMap {
621 type Borrowed<'a> = &'a Self;
622 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
623 value
624 }
625 }
626
627 unsafe impl fidl::encoding::TypeMarker for ModuleMap {
628 type Owned = Self;
629
630 #[inline(always)]
631 fn inline_align(_context: fidl::encoding::Context) -> usize {
632 8
633 }
634
635 #[inline(always)]
636 fn inline_size(_context: fidl::encoding::Context) -> usize {
637 16
638 }
639 }
640
641 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ModuleMap, D>
642 for &ModuleMap
643 {
644 unsafe fn encode(
645 self,
646 encoder: &mut fidl::encoding::Encoder<'_, D>,
647 offset: usize,
648 mut depth: fidl::encoding::Depth,
649 ) -> fidl::Result<()> {
650 encoder.debug_check_bounds::<ModuleMap>(offset);
651 let max_ordinal: u64 = self.max_ordinal_present();
653 encoder.write_num(max_ordinal, offset);
654 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
655 if max_ordinal == 0 {
657 return Ok(());
658 }
659 depth.increment()?;
660 let envelope_size = 8;
661 let bytes_len = max_ordinal as usize * envelope_size;
662 #[allow(unused_variables)]
663 let offset = encoder.out_of_line_offset(bytes_len);
664 let mut _prev_end_offset: usize = 0;
665 if 1 > max_ordinal {
666 return Ok(());
667 }
668
669 let cur_offset: usize = (1 - 1) * envelope_size;
672
673 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
675
676 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 20>, D>(
681 self.build_id.as_ref().map(
682 <fidl::encoding::Vector<u8, 20> as fidl::encoding::ValueTypeMarker>::borrow,
683 ),
684 encoder,
685 offset + cur_offset,
686 depth,
687 )?;
688
689 _prev_end_offset = cur_offset + envelope_size;
690 if 2 > max_ordinal {
691 return Ok(());
692 }
693
694 let cur_offset: usize = (2 - 1) * envelope_size;
697
698 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
700
701 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ExecutableSegment>, D>(
706 self.executable_segments.as_ref().map(<fidl::encoding::UnboundedVector<ExecutableSegment> as fidl::encoding::ValueTypeMarker>::borrow),
707 encoder, offset + cur_offset, depth
708 )?;
709
710 _prev_end_offset = cur_offset + envelope_size;
711
712 Ok(())
713 }
714 }
715
716 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ModuleMap {
717 #[inline(always)]
718 fn new_empty() -> Self {
719 Self::default()
720 }
721
722 unsafe fn decode(
723 &mut self,
724 decoder: &mut fidl::encoding::Decoder<'_, D>,
725 offset: usize,
726 mut depth: fidl::encoding::Depth,
727 ) -> fidl::Result<()> {
728 decoder.debug_check_bounds::<Self>(offset);
729 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
730 None => return Err(fidl::Error::NotNullable),
731 Some(len) => len,
732 };
733 if len == 0 {
735 return Ok(());
736 };
737 depth.increment()?;
738 let envelope_size = 8;
739 let bytes_len = len * envelope_size;
740 let offset = decoder.out_of_line_offset(bytes_len)?;
741 let mut _next_ordinal_to_read = 0;
743 let mut next_offset = offset;
744 let end_offset = offset + bytes_len;
745 _next_ordinal_to_read += 1;
746 if next_offset >= end_offset {
747 return Ok(());
748 }
749
750 while _next_ordinal_to_read < 1 {
752 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
753 _next_ordinal_to_read += 1;
754 next_offset += envelope_size;
755 }
756
757 let next_out_of_line = decoder.next_out_of_line();
758 let handles_before = decoder.remaining_handles();
759 if let Some((inlined, num_bytes, num_handles)) =
760 fidl::encoding::decode_envelope_header(decoder, next_offset)?
761 {
762 let member_inline_size =
763 <fidl::encoding::Vector<u8, 20> as fidl::encoding::TypeMarker>::inline_size(
764 decoder.context,
765 );
766 if inlined != (member_inline_size <= 4) {
767 return Err(fidl::Error::InvalidInlineBitInEnvelope);
768 }
769 let inner_offset;
770 let mut inner_depth = depth.clone();
771 if inlined {
772 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
773 inner_offset = next_offset;
774 } else {
775 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
776 inner_depth.increment()?;
777 }
778 let val_ref = self
779 .build_id
780 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 20>, D));
781 fidl::decode!(fidl::encoding::Vector<u8, 20>, D, val_ref, decoder, inner_offset, inner_depth)?;
782 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
783 {
784 return Err(fidl::Error::InvalidNumBytesInEnvelope);
785 }
786 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
787 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
788 }
789 }
790
791 next_offset += envelope_size;
792 _next_ordinal_to_read += 1;
793 if next_offset >= end_offset {
794 return Ok(());
795 }
796
797 while _next_ordinal_to_read < 2 {
799 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
800 _next_ordinal_to_read += 1;
801 next_offset += envelope_size;
802 }
803
804 let next_out_of_line = decoder.next_out_of_line();
805 let handles_before = decoder.remaining_handles();
806 if let Some((inlined, num_bytes, num_handles)) =
807 fidl::encoding::decode_envelope_header(decoder, next_offset)?
808 {
809 let member_inline_size = <fidl::encoding::UnboundedVector<ExecutableSegment> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
810 if inlined != (member_inline_size <= 4) {
811 return Err(fidl::Error::InvalidInlineBitInEnvelope);
812 }
813 let inner_offset;
814 let mut inner_depth = depth.clone();
815 if inlined {
816 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
817 inner_offset = next_offset;
818 } else {
819 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
820 inner_depth.increment()?;
821 }
822 let val_ref = self.executable_segments.get_or_insert_with(|| {
823 fidl::new_empty!(fidl::encoding::UnboundedVector<ExecutableSegment>, D)
824 });
825 fidl::decode!(
826 fidl::encoding::UnboundedVector<ExecutableSegment>,
827 D,
828 val_ref,
829 decoder,
830 inner_offset,
831 inner_depth
832 )?;
833 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
834 {
835 return Err(fidl::Error::InvalidNumBytesInEnvelope);
836 }
837 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
838 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
839 }
840 }
841
842 next_offset += envelope_size;
843
844 while next_offset < end_offset {
846 _next_ordinal_to_read += 1;
847 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
848 next_offset += envelope_size;
849 }
850
851 Ok(())
852 }
853 }
854
855 impl SamplerSetProcessInfoRequest {
856 #[inline(always)]
857 fn max_ordinal_present(&self) -> u64 {
858 if let Some(_) = self.module_map {
859 return 2;
860 }
861 if let Some(_) = self.process_name {
862 return 1;
863 }
864 0
865 }
866 }
867
868 impl fidl::encoding::ValueTypeMarker for SamplerSetProcessInfoRequest {
869 type Borrowed<'a> = &'a Self;
870 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
871 value
872 }
873 }
874
875 unsafe impl fidl::encoding::TypeMarker for SamplerSetProcessInfoRequest {
876 type Owned = Self;
877
878 #[inline(always)]
879 fn inline_align(_context: fidl::encoding::Context) -> usize {
880 8
881 }
882
883 #[inline(always)]
884 fn inline_size(_context: fidl::encoding::Context) -> usize {
885 16
886 }
887 }
888
889 unsafe impl<D: fidl::encoding::ResourceDialect>
890 fidl::encoding::Encode<SamplerSetProcessInfoRequest, D> for &SamplerSetProcessInfoRequest
891 {
892 unsafe fn encode(
893 self,
894 encoder: &mut fidl::encoding::Encoder<'_, D>,
895 offset: usize,
896 mut depth: fidl::encoding::Depth,
897 ) -> fidl::Result<()> {
898 encoder.debug_check_bounds::<SamplerSetProcessInfoRequest>(offset);
899 let max_ordinal: u64 = self.max_ordinal_present();
901 encoder.write_num(max_ordinal, offset);
902 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
903 if max_ordinal == 0 {
905 return Ok(());
906 }
907 depth.increment()?;
908 let envelope_size = 8;
909 let bytes_len = max_ordinal as usize * envelope_size;
910 #[allow(unused_variables)]
911 let offset = encoder.out_of_line_offset(bytes_len);
912 let mut _prev_end_offset: usize = 0;
913 if 1 > max_ordinal {
914 return Ok(());
915 }
916
917 let cur_offset: usize = (1 - 1) * envelope_size;
920
921 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
923
924 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
929 self.process_name.as_ref().map(
930 <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
931 ),
932 encoder,
933 offset + cur_offset,
934 depth,
935 )?;
936
937 _prev_end_offset = cur_offset + envelope_size;
938 if 2 > max_ordinal {
939 return Ok(());
940 }
941
942 let cur_offset: usize = (2 - 1) * envelope_size;
945
946 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
948
949 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ModuleMap>, D>(
954 self.module_map.as_ref().map(<fidl::encoding::UnboundedVector<ModuleMap> as fidl::encoding::ValueTypeMarker>::borrow),
955 encoder, offset + cur_offset, depth
956 )?;
957
958 _prev_end_offset = cur_offset + envelope_size;
959
960 Ok(())
961 }
962 }
963
964 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
965 for SamplerSetProcessInfoRequest
966 {
967 #[inline(always)]
968 fn new_empty() -> Self {
969 Self::default()
970 }
971
972 unsafe fn decode(
973 &mut self,
974 decoder: &mut fidl::encoding::Decoder<'_, D>,
975 offset: usize,
976 mut depth: fidl::encoding::Depth,
977 ) -> fidl::Result<()> {
978 decoder.debug_check_bounds::<Self>(offset);
979 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
980 None => return Err(fidl::Error::NotNullable),
981 Some(len) => len,
982 };
983 if len == 0 {
985 return Ok(());
986 };
987 depth.increment()?;
988 let envelope_size = 8;
989 let bytes_len = len * envelope_size;
990 let offset = decoder.out_of_line_offset(bytes_len)?;
991 let mut _next_ordinal_to_read = 0;
993 let mut next_offset = offset;
994 let end_offset = offset + bytes_len;
995 _next_ordinal_to_read += 1;
996 if next_offset >= end_offset {
997 return Ok(());
998 }
999
1000 while _next_ordinal_to_read < 1 {
1002 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1003 _next_ordinal_to_read += 1;
1004 next_offset += envelope_size;
1005 }
1006
1007 let next_out_of_line = decoder.next_out_of_line();
1008 let handles_before = decoder.remaining_handles();
1009 if let Some((inlined, num_bytes, num_handles)) =
1010 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1011 {
1012 let member_inline_size =
1013 <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
1014 decoder.context,
1015 );
1016 if inlined != (member_inline_size <= 4) {
1017 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1018 }
1019 let inner_offset;
1020 let mut inner_depth = depth.clone();
1021 if inlined {
1022 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1023 inner_offset = next_offset;
1024 } else {
1025 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1026 inner_depth.increment()?;
1027 }
1028 let val_ref = self
1029 .process_name
1030 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
1031 fidl::decode!(
1032 fidl::encoding::BoundedString<32>,
1033 D,
1034 val_ref,
1035 decoder,
1036 inner_offset,
1037 inner_depth
1038 )?;
1039 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1040 {
1041 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1042 }
1043 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1044 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1045 }
1046 }
1047
1048 next_offset += envelope_size;
1049 _next_ordinal_to_read += 1;
1050 if next_offset >= end_offset {
1051 return Ok(());
1052 }
1053
1054 while _next_ordinal_to_read < 2 {
1056 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1057 _next_ordinal_to_read += 1;
1058 next_offset += envelope_size;
1059 }
1060
1061 let next_out_of_line = decoder.next_out_of_line();
1062 let handles_before = decoder.remaining_handles();
1063 if let Some((inlined, num_bytes, num_handles)) =
1064 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1065 {
1066 let member_inline_size = <fidl::encoding::UnboundedVector<ModuleMap> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1067 if inlined != (member_inline_size <= 4) {
1068 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1069 }
1070 let inner_offset;
1071 let mut inner_depth = depth.clone();
1072 if inlined {
1073 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1074 inner_offset = next_offset;
1075 } else {
1076 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1077 inner_depth.increment()?;
1078 }
1079 let val_ref = self.module_map.get_or_insert_with(|| {
1080 fidl::new_empty!(fidl::encoding::UnboundedVector<ModuleMap>, D)
1081 });
1082 fidl::decode!(
1083 fidl::encoding::UnboundedVector<ModuleMap>,
1084 D,
1085 val_ref,
1086 decoder,
1087 inner_offset,
1088 inner_depth
1089 )?;
1090 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1091 {
1092 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1093 }
1094 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1095 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1096 }
1097 }
1098
1099 next_offset += envelope_size;
1100
1101 while next_offset < end_offset {
1103 _next_ordinal_to_read += 1;
1104 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1105 next_offset += envelope_size;
1106 }
1107
1108 Ok(())
1109 }
1110 }
1111
1112 impl StackTrace {
1113 #[inline(always)]
1114 fn max_ordinal_present(&self) -> u64 {
1115 if let Some(_) = self.stack_frames {
1116 return 1;
1117 }
1118 0
1119 }
1120 }
1121
1122 impl fidl::encoding::ValueTypeMarker for StackTrace {
1123 type Borrowed<'a> = &'a Self;
1124 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1125 value
1126 }
1127 }
1128
1129 unsafe impl fidl::encoding::TypeMarker for StackTrace {
1130 type Owned = Self;
1131
1132 #[inline(always)]
1133 fn inline_align(_context: fidl::encoding::Context) -> usize {
1134 8
1135 }
1136
1137 #[inline(always)]
1138 fn inline_size(_context: fidl::encoding::Context) -> usize {
1139 16
1140 }
1141 }
1142
1143 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StackTrace, D>
1144 for &StackTrace
1145 {
1146 unsafe fn encode(
1147 self,
1148 encoder: &mut fidl::encoding::Encoder<'_, D>,
1149 offset: usize,
1150 mut depth: fidl::encoding::Depth,
1151 ) -> fidl::Result<()> {
1152 encoder.debug_check_bounds::<StackTrace>(offset);
1153 let max_ordinal: u64 = self.max_ordinal_present();
1155 encoder.write_num(max_ordinal, offset);
1156 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1157 if max_ordinal == 0 {
1159 return Ok(());
1160 }
1161 depth.increment()?;
1162 let envelope_size = 8;
1163 let bytes_len = max_ordinal as usize * envelope_size;
1164 #[allow(unused_variables)]
1165 let offset = encoder.out_of_line_offset(bytes_len);
1166 let mut _prev_end_offset: usize = 0;
1167 if 1 > max_ordinal {
1168 return Ok(());
1169 }
1170
1171 let cur_offset: usize = (1 - 1) * envelope_size;
1174
1175 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1177
1178 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u64>, D>(
1183 self.stack_frames.as_ref().map(<fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow),
1184 encoder, offset + cur_offset, depth
1185 )?;
1186
1187 _prev_end_offset = cur_offset + envelope_size;
1188
1189 Ok(())
1190 }
1191 }
1192
1193 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StackTrace {
1194 #[inline(always)]
1195 fn new_empty() -> Self {
1196 Self::default()
1197 }
1198
1199 unsafe fn decode(
1200 &mut self,
1201 decoder: &mut fidl::encoding::Decoder<'_, D>,
1202 offset: usize,
1203 mut depth: fidl::encoding::Depth,
1204 ) -> fidl::Result<()> {
1205 decoder.debug_check_bounds::<Self>(offset);
1206 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1207 None => return Err(fidl::Error::NotNullable),
1208 Some(len) => len,
1209 };
1210 if len == 0 {
1212 return Ok(());
1213 };
1214 depth.increment()?;
1215 let envelope_size = 8;
1216 let bytes_len = len * envelope_size;
1217 let offset = decoder.out_of_line_offset(bytes_len)?;
1218 let mut _next_ordinal_to_read = 0;
1220 let mut next_offset = offset;
1221 let end_offset = offset + bytes_len;
1222 _next_ordinal_to_read += 1;
1223 if next_offset >= end_offset {
1224 return Ok(());
1225 }
1226
1227 while _next_ordinal_to_read < 1 {
1229 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1230 _next_ordinal_to_read += 1;
1231 next_offset += envelope_size;
1232 }
1233
1234 let next_out_of_line = decoder.next_out_of_line();
1235 let handles_before = decoder.remaining_handles();
1236 if let Some((inlined, num_bytes, num_handles)) =
1237 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1238 {
1239 let member_inline_size = <fidl::encoding::UnboundedVector<u64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1240 if inlined != (member_inline_size <= 4) {
1241 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1242 }
1243 let inner_offset;
1244 let mut inner_depth = depth.clone();
1245 if inlined {
1246 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1247 inner_offset = next_offset;
1248 } else {
1249 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1250 inner_depth.increment()?;
1251 }
1252 let val_ref = self.stack_frames.get_or_insert_with(|| {
1253 fidl::new_empty!(fidl::encoding::UnboundedVector<u64>, D)
1254 });
1255 fidl::decode!(
1256 fidl::encoding::UnboundedVector<u64>,
1257 D,
1258 val_ref,
1259 decoder,
1260 inner_offset,
1261 inner_depth
1262 )?;
1263 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1264 {
1265 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1266 }
1267 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1268 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1269 }
1270 }
1271
1272 next_offset += envelope_size;
1273
1274 while next_offset < end_offset {
1276 _next_ordinal_to_read += 1;
1277 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1278 next_offset += envelope_size;
1279 }
1280
1281 Ok(())
1282 }
1283 }
1284}