fidl_fuchsia_memory_sampler__common/
fidl_fuchsia_memory_sampler__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![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
11/// A build ID is a 20 bytes long sequence.
12pub const BUILD_ID_BYTES: u32 = 20;
13
14#[derive(Clone, Debug, PartialEq)]
15pub struct SamplerRecordAllocationRequest {
16    /// Address of the allocation, to uniquely identify it.
17    pub address: u64,
18    /// Stack frames collected at the allocation point.
19    ///
20    /// A client is free to truncate their stack traces to a size below the
21    /// maximum size of a message that can be sent over the channel. If a
22    /// client sends a StackTrace that causes to exceed the maximum size of
23    /// the message, then the record will be dropped until RFC-0196 is
24    /// implemented.
25    pub stack_trace: StackTrace,
26    /// Size (in bytes) of this allocation.
27    pub size: u64,
28}
29
30impl fidl::Persistable for SamplerRecordAllocationRequest {}
31
32#[derive(Clone, Debug, PartialEq)]
33pub struct SamplerRecordDeallocationRequest {
34    /// Address of the deallocation, to uniquely identify it.
35    pub address: u64,
36    /// Stack frames collected at the deallocation point.
37    ///
38    /// A client is free to truncate their stack traces to a size below the
39    /// maximum size of a message that can be sent over the channel. If a
40    /// client sends a StackTrace that causes to exceed the maximum size of
41    /// the message, then the record will be dropped until RFC-0196 is
42    /// implemented.
43    pub stack_trace: StackTrace,
44}
45
46impl fidl::Persistable for SamplerRecordDeallocationRequest {}
47
48/// Address region that corresponds to an executable segment in an ELF module.
49#[derive(Clone, Debug, Default, PartialEq)]
50pub struct ExecutableSegment {
51    /// Start of the region as mapped in memory.
52    pub start_address: Option<u64>,
53    /// Size of the range of addresses that are part of the region.
54    pub size: Option<u64>,
55    /// Offset of the region in the ELF binary before loading.
56    pub relative_address: Option<u64>,
57    #[doc(hidden)]
58    pub __source_breaking: fidl::marker::SourceBreaking,
59}
60
61impl fidl::Persistable for ExecutableSegment {}
62
63/// Information necessary for the symbolization of a module.
64/// Represents the subset of an ELF module relevant for the purposes of
65/// the profiler. The main use case for this map is the symbolization of stack traces.
66#[derive(Clone, Debug, Default, PartialEq)]
67pub struct ModuleMap {
68    /// Build ID, a string which uniquely identifies a module build.
69    pub build_id: Option<Vec<u8>>,
70    /// Collection of executable segments.
71    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    /// Name of the instrumented process.
81    pub process_name: Option<String>,
82    /// Current module layout, for symbolization.
83    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/// A stack trace, as a collection of stack frames.
91#[derive(Clone, Debug, Default, PartialEq)]
92pub struct StackTrace {
93    /// Ordered vector of frame pointers, from the narrower to the wider location.
94    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            // Delegate to tuple encoding.
144            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            // Zero out padding regions. There's no need to apply masks
172            // because the unmasked parts will be overwritten by fields.
173            // Write the fields.
174            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            // Verify that padding bytes are zero.
202            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            // Delegate to tuple encoding.
243            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            // Zero out padding regions. There's no need to apply masks
269            // because the unmasked parts will be overwritten by fields.
270            // Write the fields.
271            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            // Verify that padding bytes are zero.
294            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            // Vector header
348            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            // Calling encoder.out_of_line_offset(0) is not allowed.
352            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
366            // are envelope_size bytes.
367            let cur_offset: usize = (1 - 1) * envelope_size;
368
369            // Zero reserved fields.
370            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
371
372            // Safety:
373            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
374            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
375            //   envelope_size bytes, there is always sufficient room.
376            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
389            // are envelope_size bytes.
390            let cur_offset: usize = (2 - 1) * envelope_size;
391
392            // Zero reserved fields.
393            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
394
395            // Safety:
396            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
397            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
398            //   envelope_size bytes, there is always sufficient room.
399            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
412            // are envelope_size bytes.
413            let cur_offset: usize = (3 - 1) * envelope_size;
414
415            // Zero reserved fields.
416            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
417
418            // Safety:
419            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
420            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
421            //   envelope_size bytes, there is always sufficient room.
422            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            // Calling decoder.out_of_line_offset(0) is not allowed.
455            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            // Decode the envelope for each type.
463            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            // Decode unknown envelopes for gaps in ordinals.
472            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            // Decode unknown envelopes for gaps in ordinals.
515            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            // Decode unknown envelopes for gaps in ordinals.
558            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            // Decode the remaining unknown envelopes.
597            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            // Vector header
652            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            // Calling encoder.out_of_line_offset(0) is not allowed.
656            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
670            // are envelope_size bytes.
671            let cur_offset: usize = (1 - 1) * envelope_size;
672
673            // Zero reserved fields.
674            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
675
676            // Safety:
677            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
678            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
679            //   envelope_size bytes, there is always sufficient room.
680            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
695            // are envelope_size bytes.
696            let cur_offset: usize = (2 - 1) * envelope_size;
697
698            // Zero reserved fields.
699            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
700
701            // Safety:
702            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
703            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
704            //   envelope_size bytes, there is always sufficient room.
705            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            // Calling decoder.out_of_line_offset(0) is not allowed.
734            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            // Decode the envelope for each type.
742            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            // Decode unknown envelopes for gaps in ordinals.
751            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            // Decode unknown envelopes for gaps in ordinals.
798            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            // Decode the remaining unknown envelopes.
845            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            // Vector header
900            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            // Calling encoder.out_of_line_offset(0) is not allowed.
904            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
918            // are envelope_size bytes.
919            let cur_offset: usize = (1 - 1) * envelope_size;
920
921            // Zero reserved fields.
922            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
923
924            // Safety:
925            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
926            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
927            //   envelope_size bytes, there is always sufficient room.
928            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
943            // are envelope_size bytes.
944            let cur_offset: usize = (2 - 1) * envelope_size;
945
946            // Zero reserved fields.
947            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
948
949            // Safety:
950            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
951            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
952            //   envelope_size bytes, there is always sufficient room.
953            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            // Calling decoder.out_of_line_offset(0) is not allowed.
984            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            // Decode the envelope for each type.
992            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            // Decode unknown envelopes for gaps in ordinals.
1001            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            // Decode unknown envelopes for gaps in ordinals.
1055            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            // Decode the remaining unknown envelopes.
1102            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            // Vector header
1154            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            // Calling encoder.out_of_line_offset(0) is not allowed.
1158            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1172            // are envelope_size bytes.
1173            let cur_offset: usize = (1 - 1) * envelope_size;
1174
1175            // Zero reserved fields.
1176            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1177
1178            // Safety:
1179            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1180            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1181            //   envelope_size bytes, there is always sufficient room.
1182            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            // Calling decoder.out_of_line_offset(0) is not allowed.
1211            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            // Decode the envelope for each type.
1219            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            // Decode unknown envelopes for gaps in ordinals.
1228            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            // Decode the remaining unknown envelopes.
1275            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}