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/// Address region that corresponds to an executable segment in an ELF module.
15#[derive(Clone, Debug, Default, PartialEq)]
16pub struct ExecutableSegment {
17    /// Start of the region as mapped in memory.
18    pub start_address: Option<u64>,
19    /// Size of the range of addresses that are part of the region.
20    pub size: Option<u64>,
21    /// Offset of the region in the ELF binary before loading.
22    pub relative_address: Option<u64>,
23    #[doc(hidden)]
24    pub __source_breaking: fidl::marker::SourceBreaking,
25}
26
27impl fidl::Persistable for ExecutableSegment {}
28
29/// Information necessary for the symbolization of a module.
30/// Represents the subset of an ELF module relevant for the purposes of
31/// the profiler. The main use case for this map is the symbolization of stack traces.
32#[derive(Clone, Debug, Default, PartialEq)]
33pub struct ModuleMap {
34    /// Build ID, a string which uniquely identifies a module build.
35    pub build_id: Option<Vec<u8>>,
36    /// Collection of executable segments.
37    pub executable_segments: Option<Vec<ExecutableSegment>>,
38    #[doc(hidden)]
39    pub __source_breaking: fidl::marker::SourceBreaking,
40}
41
42impl fidl::Persistable for ModuleMap {}
43
44#[derive(Clone, Debug, Default, PartialEq)]
45pub struct SamplerRecordAllocationRequest {
46    /// Address of the allocation, to uniquely identify it.
47    pub address: Option<u64>,
48    /// Stack frames collected at the allocation point.
49    ///
50    /// A client is free to truncate their stack traces to a size below the
51    /// maximum size of a message that can be sent over the channel. If a
52    /// client sends a StackTrace that causes to exceed the maximum size of
53    /// the message, then the record will be dropped until RFC-0196 is
54    /// implemented.
55    pub stack_trace: Option<StackTrace>,
56    /// Size (in bytes) of this allocation.
57    pub size: Option<u64>,
58    #[doc(hidden)]
59    pub __source_breaking: fidl::marker::SourceBreaking,
60}
61
62impl fidl::Persistable for SamplerRecordAllocationRequest {}
63
64#[derive(Clone, Debug, Default, PartialEq)]
65pub struct SamplerRecordDeallocationRequest {
66    /// Address of the deallocation, to uniquely identify it.
67    pub address: Option<u64>,
68    /// Stack frames collected at the deallocation point.
69    ///
70    /// A client is free to truncate their stack traces to a size below the
71    /// maximum size of a message that can be sent over the channel. If a
72    /// client sends a StackTrace that causes to exceed the maximum size of
73    /// the message, then the record will be dropped until RFC-0196 is
74    /// implemented.
75    pub stack_trace: Option<StackTrace>,
76    #[doc(hidden)]
77    pub __source_breaking: fidl::marker::SourceBreaking,
78}
79
80impl fidl::Persistable for SamplerRecordDeallocationRequest {}
81
82#[derive(Clone, Debug, Default, PartialEq)]
83pub struct SamplerSetProcessInfoRequest {
84    /// Name of the instrumented process.
85    pub process_name: Option<String>,
86    /// Current module layout, for symbolization.
87    pub module_map: Option<Vec<ModuleMap>>,
88    #[doc(hidden)]
89    pub __source_breaking: fidl::marker::SourceBreaking,
90}
91
92impl fidl::Persistable for SamplerSetProcessInfoRequest {}
93
94/// A stack trace, as a collection of stack frames.
95#[derive(Clone, Debug, Default, PartialEq)]
96pub struct StackTrace {
97    /// Ordered vector of frame pointers, from the narrower to the wider location.
98    pub stack_frames: Option<Vec<u64>>,
99    #[doc(hidden)]
100    pub __source_breaking: fidl::marker::SourceBreaking,
101}
102
103impl fidl::Persistable for StackTrace {}
104
105pub mod sampler_ordinals {
106    pub const RECORD_ALLOCATION: u64 = 0x6b0add9f7769824d;
107    pub const RECORD_DEALLOCATION: u64 = 0x503bff5ec34dbeeb;
108    pub const SET_PROCESS_INFO: u64 = 0x68a0557106e51783;
109}
110
111mod internal {
112    use super::*;
113
114    impl ExecutableSegment {
115        #[inline(always)]
116        fn max_ordinal_present(&self) -> u64 {
117            if let Some(_) = self.relative_address {
118                return 3;
119            }
120            if let Some(_) = self.size {
121                return 2;
122            }
123            if let Some(_) = self.start_address {
124                return 1;
125            }
126            0
127        }
128    }
129
130    impl fidl::encoding::ValueTypeMarker for ExecutableSegment {
131        type Borrowed<'a> = &'a Self;
132        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
133            value
134        }
135    }
136
137    unsafe impl fidl::encoding::TypeMarker for ExecutableSegment {
138        type Owned = Self;
139
140        #[inline(always)]
141        fn inline_align(_context: fidl::encoding::Context) -> usize {
142            8
143        }
144
145        #[inline(always)]
146        fn inline_size(_context: fidl::encoding::Context) -> usize {
147            16
148        }
149    }
150
151    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExecutableSegment, D>
152        for &ExecutableSegment
153    {
154        unsafe fn encode(
155            self,
156            encoder: &mut fidl::encoding::Encoder<'_, D>,
157            offset: usize,
158            mut depth: fidl::encoding::Depth,
159        ) -> fidl::Result<()> {
160            encoder.debug_check_bounds::<ExecutableSegment>(offset);
161            // Vector header
162            let max_ordinal: u64 = self.max_ordinal_present();
163            encoder.write_num(max_ordinal, offset);
164            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
165            // Calling encoder.out_of_line_offset(0) is not allowed.
166            if max_ordinal == 0 {
167                return Ok(());
168            }
169            depth.increment()?;
170            let envelope_size = 8;
171            let bytes_len = max_ordinal as usize * envelope_size;
172            #[allow(unused_variables)]
173            let offset = encoder.out_of_line_offset(bytes_len);
174            let mut _prev_end_offset: usize = 0;
175            if 1 > max_ordinal {
176                return Ok(());
177            }
178
179            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
180            // are envelope_size bytes.
181            let cur_offset: usize = (1 - 1) * envelope_size;
182
183            // Zero reserved fields.
184            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
185
186            // Safety:
187            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
188            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
189            //   envelope_size bytes, there is always sufficient room.
190            fidl::encoding::encode_in_envelope_optional::<u64, D>(
191                self.start_address.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
192                encoder,
193                offset + cur_offset,
194                depth,
195            )?;
196
197            _prev_end_offset = cur_offset + envelope_size;
198            if 2 > max_ordinal {
199                return Ok(());
200            }
201
202            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
203            // are envelope_size bytes.
204            let cur_offset: usize = (2 - 1) * envelope_size;
205
206            // Zero reserved fields.
207            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
208
209            // Safety:
210            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
211            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
212            //   envelope_size bytes, there is always sufficient room.
213            fidl::encoding::encode_in_envelope_optional::<u64, D>(
214                self.size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
215                encoder,
216                offset + cur_offset,
217                depth,
218            )?;
219
220            _prev_end_offset = cur_offset + envelope_size;
221            if 3 > max_ordinal {
222                return Ok(());
223            }
224
225            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
226            // are envelope_size bytes.
227            let cur_offset: usize = (3 - 1) * envelope_size;
228
229            // Zero reserved fields.
230            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
231
232            // Safety:
233            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
234            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
235            //   envelope_size bytes, there is always sufficient room.
236            fidl::encoding::encode_in_envelope_optional::<u64, D>(
237                self.relative_address
238                    .as_ref()
239                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
240                encoder,
241                offset + cur_offset,
242                depth,
243            )?;
244
245            _prev_end_offset = cur_offset + envelope_size;
246
247            Ok(())
248        }
249    }
250
251    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExecutableSegment {
252        #[inline(always)]
253        fn new_empty() -> Self {
254            Self::default()
255        }
256
257        unsafe fn decode(
258            &mut self,
259            decoder: &mut fidl::encoding::Decoder<'_, D>,
260            offset: usize,
261            mut depth: fidl::encoding::Depth,
262        ) -> fidl::Result<()> {
263            decoder.debug_check_bounds::<Self>(offset);
264            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
265                None => return Err(fidl::Error::NotNullable),
266                Some(len) => len,
267            };
268            // Calling decoder.out_of_line_offset(0) is not allowed.
269            if len == 0 {
270                return Ok(());
271            };
272            depth.increment()?;
273            let envelope_size = 8;
274            let bytes_len = len * envelope_size;
275            let offset = decoder.out_of_line_offset(bytes_len)?;
276            // Decode the envelope for each type.
277            let mut _next_ordinal_to_read = 0;
278            let mut next_offset = offset;
279            let end_offset = offset + bytes_len;
280            _next_ordinal_to_read += 1;
281            if next_offset >= end_offset {
282                return Ok(());
283            }
284
285            // Decode unknown envelopes for gaps in ordinals.
286            while _next_ordinal_to_read < 1 {
287                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
288                _next_ordinal_to_read += 1;
289                next_offset += envelope_size;
290            }
291
292            let next_out_of_line = decoder.next_out_of_line();
293            let handles_before = decoder.remaining_handles();
294            if let Some((inlined, num_bytes, num_handles)) =
295                fidl::encoding::decode_envelope_header(decoder, next_offset)?
296            {
297                let member_inline_size =
298                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
299                if inlined != (member_inline_size <= 4) {
300                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
301                }
302                let inner_offset;
303                let mut inner_depth = depth.clone();
304                if inlined {
305                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
306                    inner_offset = next_offset;
307                } else {
308                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
309                    inner_depth.increment()?;
310                }
311                let val_ref = self.start_address.get_or_insert_with(|| fidl::new_empty!(u64, D));
312                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
313                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
314                {
315                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
316                }
317                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
318                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
319                }
320            }
321
322            next_offset += envelope_size;
323            _next_ordinal_to_read += 1;
324            if next_offset >= end_offset {
325                return Ok(());
326            }
327
328            // Decode unknown envelopes for gaps in ordinals.
329            while _next_ordinal_to_read < 2 {
330                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
331                _next_ordinal_to_read += 1;
332                next_offset += envelope_size;
333            }
334
335            let next_out_of_line = decoder.next_out_of_line();
336            let handles_before = decoder.remaining_handles();
337            if let Some((inlined, num_bytes, num_handles)) =
338                fidl::encoding::decode_envelope_header(decoder, next_offset)?
339            {
340                let member_inline_size =
341                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
342                if inlined != (member_inline_size <= 4) {
343                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
344                }
345                let inner_offset;
346                let mut inner_depth = depth.clone();
347                if inlined {
348                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
349                    inner_offset = next_offset;
350                } else {
351                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
352                    inner_depth.increment()?;
353                }
354                let val_ref = self.size.get_or_insert_with(|| fidl::new_empty!(u64, D));
355                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
356                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
357                {
358                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
359                }
360                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
361                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
362                }
363            }
364
365            next_offset += envelope_size;
366            _next_ordinal_to_read += 1;
367            if next_offset >= end_offset {
368                return Ok(());
369            }
370
371            // Decode unknown envelopes for gaps in ordinals.
372            while _next_ordinal_to_read < 3 {
373                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
374                _next_ordinal_to_read += 1;
375                next_offset += envelope_size;
376            }
377
378            let next_out_of_line = decoder.next_out_of_line();
379            let handles_before = decoder.remaining_handles();
380            if let Some((inlined, num_bytes, num_handles)) =
381                fidl::encoding::decode_envelope_header(decoder, next_offset)?
382            {
383                let member_inline_size =
384                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
385                if inlined != (member_inline_size <= 4) {
386                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
387                }
388                let inner_offset;
389                let mut inner_depth = depth.clone();
390                if inlined {
391                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
392                    inner_offset = next_offset;
393                } else {
394                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
395                    inner_depth.increment()?;
396                }
397                let val_ref = self.relative_address.get_or_insert_with(|| fidl::new_empty!(u64, D));
398                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
399                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
400                {
401                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
402                }
403                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
404                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
405                }
406            }
407
408            next_offset += envelope_size;
409
410            // Decode the remaining unknown envelopes.
411            while next_offset < end_offset {
412                _next_ordinal_to_read += 1;
413                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
414                next_offset += envelope_size;
415            }
416
417            Ok(())
418        }
419    }
420
421    impl ModuleMap {
422        #[inline(always)]
423        fn max_ordinal_present(&self) -> u64 {
424            if let Some(_) = self.executable_segments {
425                return 2;
426            }
427            if let Some(_) = self.build_id {
428                return 1;
429            }
430            0
431        }
432    }
433
434    impl fidl::encoding::ValueTypeMarker for ModuleMap {
435        type Borrowed<'a> = &'a Self;
436        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
437            value
438        }
439    }
440
441    unsafe impl fidl::encoding::TypeMarker for ModuleMap {
442        type Owned = Self;
443
444        #[inline(always)]
445        fn inline_align(_context: fidl::encoding::Context) -> usize {
446            8
447        }
448
449        #[inline(always)]
450        fn inline_size(_context: fidl::encoding::Context) -> usize {
451            16
452        }
453    }
454
455    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ModuleMap, D>
456        for &ModuleMap
457    {
458        unsafe fn encode(
459            self,
460            encoder: &mut fidl::encoding::Encoder<'_, D>,
461            offset: usize,
462            mut depth: fidl::encoding::Depth,
463        ) -> fidl::Result<()> {
464            encoder.debug_check_bounds::<ModuleMap>(offset);
465            // Vector header
466            let max_ordinal: u64 = self.max_ordinal_present();
467            encoder.write_num(max_ordinal, offset);
468            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
469            // Calling encoder.out_of_line_offset(0) is not allowed.
470            if max_ordinal == 0 {
471                return Ok(());
472            }
473            depth.increment()?;
474            let envelope_size = 8;
475            let bytes_len = max_ordinal as usize * envelope_size;
476            #[allow(unused_variables)]
477            let offset = encoder.out_of_line_offset(bytes_len);
478            let mut _prev_end_offset: usize = 0;
479            if 1 > max_ordinal {
480                return Ok(());
481            }
482
483            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
484            // are envelope_size bytes.
485            let cur_offset: usize = (1 - 1) * envelope_size;
486
487            // Zero reserved fields.
488            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
489
490            // Safety:
491            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
492            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
493            //   envelope_size bytes, there is always sufficient room.
494            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 20>, D>(
495                self.build_id.as_ref().map(
496                    <fidl::encoding::Vector<u8, 20> as fidl::encoding::ValueTypeMarker>::borrow,
497                ),
498                encoder,
499                offset + cur_offset,
500                depth,
501            )?;
502
503            _prev_end_offset = cur_offset + envelope_size;
504            if 2 > max_ordinal {
505                return Ok(());
506            }
507
508            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
509            // are envelope_size bytes.
510            let cur_offset: usize = (2 - 1) * envelope_size;
511
512            // Zero reserved fields.
513            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
514
515            // Safety:
516            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
517            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
518            //   envelope_size bytes, there is always sufficient room.
519            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ExecutableSegment>, D>(
520            self.executable_segments.as_ref().map(<fidl::encoding::UnboundedVector<ExecutableSegment> as fidl::encoding::ValueTypeMarker>::borrow),
521            encoder, offset + cur_offset, depth
522        )?;
523
524            _prev_end_offset = cur_offset + envelope_size;
525
526            Ok(())
527        }
528    }
529
530    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ModuleMap {
531        #[inline(always)]
532        fn new_empty() -> Self {
533            Self::default()
534        }
535
536        unsafe fn decode(
537            &mut self,
538            decoder: &mut fidl::encoding::Decoder<'_, D>,
539            offset: usize,
540            mut depth: fidl::encoding::Depth,
541        ) -> fidl::Result<()> {
542            decoder.debug_check_bounds::<Self>(offset);
543            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
544                None => return Err(fidl::Error::NotNullable),
545                Some(len) => len,
546            };
547            // Calling decoder.out_of_line_offset(0) is not allowed.
548            if len == 0 {
549                return Ok(());
550            };
551            depth.increment()?;
552            let envelope_size = 8;
553            let bytes_len = len * envelope_size;
554            let offset = decoder.out_of_line_offset(bytes_len)?;
555            // Decode the envelope for each type.
556            let mut _next_ordinal_to_read = 0;
557            let mut next_offset = offset;
558            let end_offset = offset + bytes_len;
559            _next_ordinal_to_read += 1;
560            if next_offset >= end_offset {
561                return Ok(());
562            }
563
564            // Decode unknown envelopes for gaps in ordinals.
565            while _next_ordinal_to_read < 1 {
566                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
567                _next_ordinal_to_read += 1;
568                next_offset += envelope_size;
569            }
570
571            let next_out_of_line = decoder.next_out_of_line();
572            let handles_before = decoder.remaining_handles();
573            if let Some((inlined, num_bytes, num_handles)) =
574                fidl::encoding::decode_envelope_header(decoder, next_offset)?
575            {
576                let member_inline_size =
577                    <fidl::encoding::Vector<u8, 20> as fidl::encoding::TypeMarker>::inline_size(
578                        decoder.context,
579                    );
580                if inlined != (member_inline_size <= 4) {
581                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
582                }
583                let inner_offset;
584                let mut inner_depth = depth.clone();
585                if inlined {
586                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
587                    inner_offset = next_offset;
588                } else {
589                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
590                    inner_depth.increment()?;
591                }
592                let val_ref = self
593                    .build_id
594                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 20>, D));
595                fidl::decode!(fidl::encoding::Vector<u8, 20>, D, val_ref, decoder, inner_offset, inner_depth)?;
596                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
597                {
598                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
599                }
600                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
601                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
602                }
603            }
604
605            next_offset += envelope_size;
606            _next_ordinal_to_read += 1;
607            if next_offset >= end_offset {
608                return Ok(());
609            }
610
611            // Decode unknown envelopes for gaps in ordinals.
612            while _next_ordinal_to_read < 2 {
613                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
614                _next_ordinal_to_read += 1;
615                next_offset += envelope_size;
616            }
617
618            let next_out_of_line = decoder.next_out_of_line();
619            let handles_before = decoder.remaining_handles();
620            if let Some((inlined, num_bytes, num_handles)) =
621                fidl::encoding::decode_envelope_header(decoder, next_offset)?
622            {
623                let member_inline_size = <fidl::encoding::UnboundedVector<ExecutableSegment> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
624                if inlined != (member_inline_size <= 4) {
625                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
626                }
627                let inner_offset;
628                let mut inner_depth = depth.clone();
629                if inlined {
630                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
631                    inner_offset = next_offset;
632                } else {
633                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
634                    inner_depth.increment()?;
635                }
636                let val_ref = self.executable_segments.get_or_insert_with(|| {
637                    fidl::new_empty!(fidl::encoding::UnboundedVector<ExecutableSegment>, D)
638                });
639                fidl::decode!(
640                    fidl::encoding::UnboundedVector<ExecutableSegment>,
641                    D,
642                    val_ref,
643                    decoder,
644                    inner_offset,
645                    inner_depth
646                )?;
647                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
648                {
649                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
650                }
651                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
652                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
653                }
654            }
655
656            next_offset += envelope_size;
657
658            // Decode the remaining unknown envelopes.
659            while next_offset < end_offset {
660                _next_ordinal_to_read += 1;
661                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
662                next_offset += envelope_size;
663            }
664
665            Ok(())
666        }
667    }
668
669    impl SamplerRecordAllocationRequest {
670        #[inline(always)]
671        fn max_ordinal_present(&self) -> u64 {
672            if let Some(_) = self.size {
673                return 3;
674            }
675            if let Some(_) = self.stack_trace {
676                return 2;
677            }
678            if let Some(_) = self.address {
679                return 1;
680            }
681            0
682        }
683    }
684
685    impl fidl::encoding::ValueTypeMarker for SamplerRecordAllocationRequest {
686        type Borrowed<'a> = &'a Self;
687        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
688            value
689        }
690    }
691
692    unsafe impl fidl::encoding::TypeMarker for SamplerRecordAllocationRequest {
693        type Owned = Self;
694
695        #[inline(always)]
696        fn inline_align(_context: fidl::encoding::Context) -> usize {
697            8
698        }
699
700        #[inline(always)]
701        fn inline_size(_context: fidl::encoding::Context) -> usize {
702            16
703        }
704    }
705
706    unsafe impl<D: fidl::encoding::ResourceDialect>
707        fidl::encoding::Encode<SamplerRecordAllocationRequest, D>
708        for &SamplerRecordAllocationRequest
709    {
710        unsafe fn encode(
711            self,
712            encoder: &mut fidl::encoding::Encoder<'_, D>,
713            offset: usize,
714            mut depth: fidl::encoding::Depth,
715        ) -> fidl::Result<()> {
716            encoder.debug_check_bounds::<SamplerRecordAllocationRequest>(offset);
717            // Vector header
718            let max_ordinal: u64 = self.max_ordinal_present();
719            encoder.write_num(max_ordinal, offset);
720            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
721            // Calling encoder.out_of_line_offset(0) is not allowed.
722            if max_ordinal == 0 {
723                return Ok(());
724            }
725            depth.increment()?;
726            let envelope_size = 8;
727            let bytes_len = max_ordinal as usize * envelope_size;
728            #[allow(unused_variables)]
729            let offset = encoder.out_of_line_offset(bytes_len);
730            let mut _prev_end_offset: usize = 0;
731            if 1 > max_ordinal {
732                return Ok(());
733            }
734
735            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
736            // are envelope_size bytes.
737            let cur_offset: usize = (1 - 1) * envelope_size;
738
739            // Zero reserved fields.
740            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
741
742            // Safety:
743            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
744            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
745            //   envelope_size bytes, there is always sufficient room.
746            fidl::encoding::encode_in_envelope_optional::<u64, D>(
747                self.address.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
748                encoder,
749                offset + cur_offset,
750                depth,
751            )?;
752
753            _prev_end_offset = cur_offset + envelope_size;
754            if 2 > max_ordinal {
755                return Ok(());
756            }
757
758            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
759            // are envelope_size bytes.
760            let cur_offset: usize = (2 - 1) * envelope_size;
761
762            // Zero reserved fields.
763            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
764
765            // Safety:
766            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
767            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
768            //   envelope_size bytes, there is always sufficient room.
769            fidl::encoding::encode_in_envelope_optional::<StackTrace, D>(
770                self.stack_trace
771                    .as_ref()
772                    .map(<StackTrace as fidl::encoding::ValueTypeMarker>::borrow),
773                encoder,
774                offset + cur_offset,
775                depth,
776            )?;
777
778            _prev_end_offset = cur_offset + envelope_size;
779            if 3 > max_ordinal {
780                return Ok(());
781            }
782
783            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
784            // are envelope_size bytes.
785            let cur_offset: usize = (3 - 1) * envelope_size;
786
787            // Zero reserved fields.
788            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
789
790            // Safety:
791            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
792            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
793            //   envelope_size bytes, there is always sufficient room.
794            fidl::encoding::encode_in_envelope_optional::<u64, D>(
795                self.size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
796                encoder,
797                offset + cur_offset,
798                depth,
799            )?;
800
801            _prev_end_offset = cur_offset + envelope_size;
802
803            Ok(())
804        }
805    }
806
807    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
808        for SamplerRecordAllocationRequest
809    {
810        #[inline(always)]
811        fn new_empty() -> Self {
812            Self::default()
813        }
814
815        unsafe fn decode(
816            &mut self,
817            decoder: &mut fidl::encoding::Decoder<'_, D>,
818            offset: usize,
819            mut depth: fidl::encoding::Depth,
820        ) -> fidl::Result<()> {
821            decoder.debug_check_bounds::<Self>(offset);
822            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
823                None => return Err(fidl::Error::NotNullable),
824                Some(len) => len,
825            };
826            // Calling decoder.out_of_line_offset(0) is not allowed.
827            if len == 0 {
828                return Ok(());
829            };
830            depth.increment()?;
831            let envelope_size = 8;
832            let bytes_len = len * envelope_size;
833            let offset = decoder.out_of_line_offset(bytes_len)?;
834            // Decode the envelope for each type.
835            let mut _next_ordinal_to_read = 0;
836            let mut next_offset = offset;
837            let end_offset = offset + bytes_len;
838            _next_ordinal_to_read += 1;
839            if next_offset >= end_offset {
840                return Ok(());
841            }
842
843            // Decode unknown envelopes for gaps in ordinals.
844            while _next_ordinal_to_read < 1 {
845                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
846                _next_ordinal_to_read += 1;
847                next_offset += envelope_size;
848            }
849
850            let next_out_of_line = decoder.next_out_of_line();
851            let handles_before = decoder.remaining_handles();
852            if let Some((inlined, num_bytes, num_handles)) =
853                fidl::encoding::decode_envelope_header(decoder, next_offset)?
854            {
855                let member_inline_size =
856                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
857                if inlined != (member_inline_size <= 4) {
858                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
859                }
860                let inner_offset;
861                let mut inner_depth = depth.clone();
862                if inlined {
863                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
864                    inner_offset = next_offset;
865                } else {
866                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
867                    inner_depth.increment()?;
868                }
869                let val_ref = self.address.get_or_insert_with(|| fidl::new_empty!(u64, D));
870                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
871                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
872                {
873                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
874                }
875                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
876                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
877                }
878            }
879
880            next_offset += envelope_size;
881            _next_ordinal_to_read += 1;
882            if next_offset >= end_offset {
883                return Ok(());
884            }
885
886            // Decode unknown envelopes for gaps in ordinals.
887            while _next_ordinal_to_read < 2 {
888                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
889                _next_ordinal_to_read += 1;
890                next_offset += envelope_size;
891            }
892
893            let next_out_of_line = decoder.next_out_of_line();
894            let handles_before = decoder.remaining_handles();
895            if let Some((inlined, num_bytes, num_handles)) =
896                fidl::encoding::decode_envelope_header(decoder, next_offset)?
897            {
898                let member_inline_size =
899                    <StackTrace as fidl::encoding::TypeMarker>::inline_size(decoder.context);
900                if inlined != (member_inline_size <= 4) {
901                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
902                }
903                let inner_offset;
904                let mut inner_depth = depth.clone();
905                if inlined {
906                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
907                    inner_offset = next_offset;
908                } else {
909                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
910                    inner_depth.increment()?;
911                }
912                let val_ref =
913                    self.stack_trace.get_or_insert_with(|| fidl::new_empty!(StackTrace, D));
914                fidl::decode!(StackTrace, D, val_ref, decoder, inner_offset, inner_depth)?;
915                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
916                {
917                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
918                }
919                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
920                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
921                }
922            }
923
924            next_offset += envelope_size;
925            _next_ordinal_to_read += 1;
926            if next_offset >= end_offset {
927                return Ok(());
928            }
929
930            // Decode unknown envelopes for gaps in ordinals.
931            while _next_ordinal_to_read < 3 {
932                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
933                _next_ordinal_to_read += 1;
934                next_offset += envelope_size;
935            }
936
937            let next_out_of_line = decoder.next_out_of_line();
938            let handles_before = decoder.remaining_handles();
939            if let Some((inlined, num_bytes, num_handles)) =
940                fidl::encoding::decode_envelope_header(decoder, next_offset)?
941            {
942                let member_inline_size =
943                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
944                if inlined != (member_inline_size <= 4) {
945                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
946                }
947                let inner_offset;
948                let mut inner_depth = depth.clone();
949                if inlined {
950                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
951                    inner_offset = next_offset;
952                } else {
953                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
954                    inner_depth.increment()?;
955                }
956                let val_ref = self.size.get_or_insert_with(|| fidl::new_empty!(u64, D));
957                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
958                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
959                {
960                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
961                }
962                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
963                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
964                }
965            }
966
967            next_offset += envelope_size;
968
969            // Decode the remaining unknown envelopes.
970            while next_offset < end_offset {
971                _next_ordinal_to_read += 1;
972                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
973                next_offset += envelope_size;
974            }
975
976            Ok(())
977        }
978    }
979
980    impl SamplerRecordDeallocationRequest {
981        #[inline(always)]
982        fn max_ordinal_present(&self) -> u64 {
983            if let Some(_) = self.stack_trace {
984                return 2;
985            }
986            if let Some(_) = self.address {
987                return 1;
988            }
989            0
990        }
991    }
992
993    impl fidl::encoding::ValueTypeMarker for SamplerRecordDeallocationRequest {
994        type Borrowed<'a> = &'a Self;
995        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
996            value
997        }
998    }
999
1000    unsafe impl fidl::encoding::TypeMarker for SamplerRecordDeallocationRequest {
1001        type Owned = Self;
1002
1003        #[inline(always)]
1004        fn inline_align(_context: fidl::encoding::Context) -> usize {
1005            8
1006        }
1007
1008        #[inline(always)]
1009        fn inline_size(_context: fidl::encoding::Context) -> usize {
1010            16
1011        }
1012    }
1013
1014    unsafe impl<D: fidl::encoding::ResourceDialect>
1015        fidl::encoding::Encode<SamplerRecordDeallocationRequest, D>
1016        for &SamplerRecordDeallocationRequest
1017    {
1018        unsafe fn encode(
1019            self,
1020            encoder: &mut fidl::encoding::Encoder<'_, D>,
1021            offset: usize,
1022            mut depth: fidl::encoding::Depth,
1023        ) -> fidl::Result<()> {
1024            encoder.debug_check_bounds::<SamplerRecordDeallocationRequest>(offset);
1025            // Vector header
1026            let max_ordinal: u64 = self.max_ordinal_present();
1027            encoder.write_num(max_ordinal, offset);
1028            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1029            // Calling encoder.out_of_line_offset(0) is not allowed.
1030            if max_ordinal == 0 {
1031                return Ok(());
1032            }
1033            depth.increment()?;
1034            let envelope_size = 8;
1035            let bytes_len = max_ordinal as usize * envelope_size;
1036            #[allow(unused_variables)]
1037            let offset = encoder.out_of_line_offset(bytes_len);
1038            let mut _prev_end_offset: usize = 0;
1039            if 1 > max_ordinal {
1040                return Ok(());
1041            }
1042
1043            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1044            // are envelope_size bytes.
1045            let cur_offset: usize = (1 - 1) * envelope_size;
1046
1047            // Zero reserved fields.
1048            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1049
1050            // Safety:
1051            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1052            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1053            //   envelope_size bytes, there is always sufficient room.
1054            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1055                self.address.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1056                encoder,
1057                offset + cur_offset,
1058                depth,
1059            )?;
1060
1061            _prev_end_offset = cur_offset + envelope_size;
1062            if 2 > max_ordinal {
1063                return Ok(());
1064            }
1065
1066            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1067            // are envelope_size bytes.
1068            let cur_offset: usize = (2 - 1) * envelope_size;
1069
1070            // Zero reserved fields.
1071            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1072
1073            // Safety:
1074            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1075            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1076            //   envelope_size bytes, there is always sufficient room.
1077            fidl::encoding::encode_in_envelope_optional::<StackTrace, D>(
1078                self.stack_trace
1079                    .as_ref()
1080                    .map(<StackTrace as fidl::encoding::ValueTypeMarker>::borrow),
1081                encoder,
1082                offset + cur_offset,
1083                depth,
1084            )?;
1085
1086            _prev_end_offset = cur_offset + envelope_size;
1087
1088            Ok(())
1089        }
1090    }
1091
1092    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1093        for SamplerRecordDeallocationRequest
1094    {
1095        #[inline(always)]
1096        fn new_empty() -> Self {
1097            Self::default()
1098        }
1099
1100        unsafe fn decode(
1101            &mut self,
1102            decoder: &mut fidl::encoding::Decoder<'_, D>,
1103            offset: usize,
1104            mut depth: fidl::encoding::Depth,
1105        ) -> fidl::Result<()> {
1106            decoder.debug_check_bounds::<Self>(offset);
1107            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1108                None => return Err(fidl::Error::NotNullable),
1109                Some(len) => len,
1110            };
1111            // Calling decoder.out_of_line_offset(0) is not allowed.
1112            if len == 0 {
1113                return Ok(());
1114            };
1115            depth.increment()?;
1116            let envelope_size = 8;
1117            let bytes_len = len * envelope_size;
1118            let offset = decoder.out_of_line_offset(bytes_len)?;
1119            // Decode the envelope for each type.
1120            let mut _next_ordinal_to_read = 0;
1121            let mut next_offset = offset;
1122            let end_offset = offset + bytes_len;
1123            _next_ordinal_to_read += 1;
1124            if next_offset >= end_offset {
1125                return Ok(());
1126            }
1127
1128            // Decode unknown envelopes for gaps in ordinals.
1129            while _next_ordinal_to_read < 1 {
1130                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1131                _next_ordinal_to_read += 1;
1132                next_offset += envelope_size;
1133            }
1134
1135            let next_out_of_line = decoder.next_out_of_line();
1136            let handles_before = decoder.remaining_handles();
1137            if let Some((inlined, num_bytes, num_handles)) =
1138                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1139            {
1140                let member_inline_size =
1141                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1142                if inlined != (member_inline_size <= 4) {
1143                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1144                }
1145                let inner_offset;
1146                let mut inner_depth = depth.clone();
1147                if inlined {
1148                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1149                    inner_offset = next_offset;
1150                } else {
1151                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1152                    inner_depth.increment()?;
1153                }
1154                let val_ref = self.address.get_or_insert_with(|| fidl::new_empty!(u64, D));
1155                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1156                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1157                {
1158                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1159                }
1160                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1161                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1162                }
1163            }
1164
1165            next_offset += envelope_size;
1166            _next_ordinal_to_read += 1;
1167            if next_offset >= end_offset {
1168                return Ok(());
1169            }
1170
1171            // Decode unknown envelopes for gaps in ordinals.
1172            while _next_ordinal_to_read < 2 {
1173                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1174                _next_ordinal_to_read += 1;
1175                next_offset += envelope_size;
1176            }
1177
1178            let next_out_of_line = decoder.next_out_of_line();
1179            let handles_before = decoder.remaining_handles();
1180            if let Some((inlined, num_bytes, num_handles)) =
1181                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1182            {
1183                let member_inline_size =
1184                    <StackTrace as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1185                if inlined != (member_inline_size <= 4) {
1186                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1187                }
1188                let inner_offset;
1189                let mut inner_depth = depth.clone();
1190                if inlined {
1191                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1192                    inner_offset = next_offset;
1193                } else {
1194                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1195                    inner_depth.increment()?;
1196                }
1197                let val_ref =
1198                    self.stack_trace.get_or_insert_with(|| fidl::new_empty!(StackTrace, D));
1199                fidl::decode!(StackTrace, D, val_ref, decoder, inner_offset, inner_depth)?;
1200                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1201                {
1202                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1203                }
1204                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1205                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1206                }
1207            }
1208
1209            next_offset += envelope_size;
1210
1211            // Decode the remaining unknown envelopes.
1212            while next_offset < end_offset {
1213                _next_ordinal_to_read += 1;
1214                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1215                next_offset += envelope_size;
1216            }
1217
1218            Ok(())
1219        }
1220    }
1221
1222    impl SamplerSetProcessInfoRequest {
1223        #[inline(always)]
1224        fn max_ordinal_present(&self) -> u64 {
1225            if let Some(_) = self.module_map {
1226                return 2;
1227            }
1228            if let Some(_) = self.process_name {
1229                return 1;
1230            }
1231            0
1232        }
1233    }
1234
1235    impl fidl::encoding::ValueTypeMarker for SamplerSetProcessInfoRequest {
1236        type Borrowed<'a> = &'a Self;
1237        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1238            value
1239        }
1240    }
1241
1242    unsafe impl fidl::encoding::TypeMarker for SamplerSetProcessInfoRequest {
1243        type Owned = Self;
1244
1245        #[inline(always)]
1246        fn inline_align(_context: fidl::encoding::Context) -> usize {
1247            8
1248        }
1249
1250        #[inline(always)]
1251        fn inline_size(_context: fidl::encoding::Context) -> usize {
1252            16
1253        }
1254    }
1255
1256    unsafe impl<D: fidl::encoding::ResourceDialect>
1257        fidl::encoding::Encode<SamplerSetProcessInfoRequest, D> for &SamplerSetProcessInfoRequest
1258    {
1259        unsafe fn encode(
1260            self,
1261            encoder: &mut fidl::encoding::Encoder<'_, D>,
1262            offset: usize,
1263            mut depth: fidl::encoding::Depth,
1264        ) -> fidl::Result<()> {
1265            encoder.debug_check_bounds::<SamplerSetProcessInfoRequest>(offset);
1266            // Vector header
1267            let max_ordinal: u64 = self.max_ordinal_present();
1268            encoder.write_num(max_ordinal, offset);
1269            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1270            // Calling encoder.out_of_line_offset(0) is not allowed.
1271            if max_ordinal == 0 {
1272                return Ok(());
1273            }
1274            depth.increment()?;
1275            let envelope_size = 8;
1276            let bytes_len = max_ordinal as usize * envelope_size;
1277            #[allow(unused_variables)]
1278            let offset = encoder.out_of_line_offset(bytes_len);
1279            let mut _prev_end_offset: usize = 0;
1280            if 1 > max_ordinal {
1281                return Ok(());
1282            }
1283
1284            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1285            // are envelope_size bytes.
1286            let cur_offset: usize = (1 - 1) * envelope_size;
1287
1288            // Zero reserved fields.
1289            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1290
1291            // Safety:
1292            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1293            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1294            //   envelope_size bytes, there is always sufficient room.
1295            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
1296                self.process_name.as_ref().map(
1297                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
1298                ),
1299                encoder,
1300                offset + cur_offset,
1301                depth,
1302            )?;
1303
1304            _prev_end_offset = cur_offset + envelope_size;
1305            if 2 > max_ordinal {
1306                return Ok(());
1307            }
1308
1309            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1310            // are envelope_size bytes.
1311            let cur_offset: usize = (2 - 1) * envelope_size;
1312
1313            // Zero reserved fields.
1314            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1315
1316            // Safety:
1317            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1318            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1319            //   envelope_size bytes, there is always sufficient room.
1320            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ModuleMap>, D>(
1321            self.module_map.as_ref().map(<fidl::encoding::UnboundedVector<ModuleMap> as fidl::encoding::ValueTypeMarker>::borrow),
1322            encoder, offset + cur_offset, depth
1323        )?;
1324
1325            _prev_end_offset = cur_offset + envelope_size;
1326
1327            Ok(())
1328        }
1329    }
1330
1331    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1332        for SamplerSetProcessInfoRequest
1333    {
1334        #[inline(always)]
1335        fn new_empty() -> Self {
1336            Self::default()
1337        }
1338
1339        unsafe fn decode(
1340            &mut self,
1341            decoder: &mut fidl::encoding::Decoder<'_, D>,
1342            offset: usize,
1343            mut depth: fidl::encoding::Depth,
1344        ) -> fidl::Result<()> {
1345            decoder.debug_check_bounds::<Self>(offset);
1346            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1347                None => return Err(fidl::Error::NotNullable),
1348                Some(len) => len,
1349            };
1350            // Calling decoder.out_of_line_offset(0) is not allowed.
1351            if len == 0 {
1352                return Ok(());
1353            };
1354            depth.increment()?;
1355            let envelope_size = 8;
1356            let bytes_len = len * envelope_size;
1357            let offset = decoder.out_of_line_offset(bytes_len)?;
1358            // Decode the envelope for each type.
1359            let mut _next_ordinal_to_read = 0;
1360            let mut next_offset = offset;
1361            let end_offset = offset + bytes_len;
1362            _next_ordinal_to_read += 1;
1363            if next_offset >= end_offset {
1364                return Ok(());
1365            }
1366
1367            // Decode unknown envelopes for gaps in ordinals.
1368            while _next_ordinal_to_read < 1 {
1369                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1370                _next_ordinal_to_read += 1;
1371                next_offset += envelope_size;
1372            }
1373
1374            let next_out_of_line = decoder.next_out_of_line();
1375            let handles_before = decoder.remaining_handles();
1376            if let Some((inlined, num_bytes, num_handles)) =
1377                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1378            {
1379                let member_inline_size =
1380                    <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
1381                        decoder.context,
1382                    );
1383                if inlined != (member_inline_size <= 4) {
1384                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1385                }
1386                let inner_offset;
1387                let mut inner_depth = depth.clone();
1388                if inlined {
1389                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1390                    inner_offset = next_offset;
1391                } else {
1392                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1393                    inner_depth.increment()?;
1394                }
1395                let val_ref = self
1396                    .process_name
1397                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
1398                fidl::decode!(
1399                    fidl::encoding::BoundedString<32>,
1400                    D,
1401                    val_ref,
1402                    decoder,
1403                    inner_offset,
1404                    inner_depth
1405                )?;
1406                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1407                {
1408                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1409                }
1410                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1411                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1412                }
1413            }
1414
1415            next_offset += envelope_size;
1416            _next_ordinal_to_read += 1;
1417            if next_offset >= end_offset {
1418                return Ok(());
1419            }
1420
1421            // Decode unknown envelopes for gaps in ordinals.
1422            while _next_ordinal_to_read < 2 {
1423                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1424                _next_ordinal_to_read += 1;
1425                next_offset += envelope_size;
1426            }
1427
1428            let next_out_of_line = decoder.next_out_of_line();
1429            let handles_before = decoder.remaining_handles();
1430            if let Some((inlined, num_bytes, num_handles)) =
1431                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1432            {
1433                let member_inline_size = <fidl::encoding::UnboundedVector<ModuleMap> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1434                if inlined != (member_inline_size <= 4) {
1435                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1436                }
1437                let inner_offset;
1438                let mut inner_depth = depth.clone();
1439                if inlined {
1440                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1441                    inner_offset = next_offset;
1442                } else {
1443                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1444                    inner_depth.increment()?;
1445                }
1446                let val_ref = self.module_map.get_or_insert_with(|| {
1447                    fidl::new_empty!(fidl::encoding::UnboundedVector<ModuleMap>, D)
1448                });
1449                fidl::decode!(
1450                    fidl::encoding::UnboundedVector<ModuleMap>,
1451                    D,
1452                    val_ref,
1453                    decoder,
1454                    inner_offset,
1455                    inner_depth
1456                )?;
1457                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1458                {
1459                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1460                }
1461                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1462                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1463                }
1464            }
1465
1466            next_offset += envelope_size;
1467
1468            // Decode the remaining unknown envelopes.
1469            while next_offset < end_offset {
1470                _next_ordinal_to_read += 1;
1471                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1472                next_offset += envelope_size;
1473            }
1474
1475            Ok(())
1476        }
1477    }
1478
1479    impl StackTrace {
1480        #[inline(always)]
1481        fn max_ordinal_present(&self) -> u64 {
1482            if let Some(_) = self.stack_frames {
1483                return 1;
1484            }
1485            0
1486        }
1487    }
1488
1489    impl fidl::encoding::ValueTypeMarker for StackTrace {
1490        type Borrowed<'a> = &'a Self;
1491        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1492            value
1493        }
1494    }
1495
1496    unsafe impl fidl::encoding::TypeMarker for StackTrace {
1497        type Owned = Self;
1498
1499        #[inline(always)]
1500        fn inline_align(_context: fidl::encoding::Context) -> usize {
1501            8
1502        }
1503
1504        #[inline(always)]
1505        fn inline_size(_context: fidl::encoding::Context) -> usize {
1506            16
1507        }
1508    }
1509
1510    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StackTrace, D>
1511        for &StackTrace
1512    {
1513        unsafe fn encode(
1514            self,
1515            encoder: &mut fidl::encoding::Encoder<'_, D>,
1516            offset: usize,
1517            mut depth: fidl::encoding::Depth,
1518        ) -> fidl::Result<()> {
1519            encoder.debug_check_bounds::<StackTrace>(offset);
1520            // Vector header
1521            let max_ordinal: u64 = self.max_ordinal_present();
1522            encoder.write_num(max_ordinal, offset);
1523            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1524            // Calling encoder.out_of_line_offset(0) is not allowed.
1525            if max_ordinal == 0 {
1526                return Ok(());
1527            }
1528            depth.increment()?;
1529            let envelope_size = 8;
1530            let bytes_len = max_ordinal as usize * envelope_size;
1531            #[allow(unused_variables)]
1532            let offset = encoder.out_of_line_offset(bytes_len);
1533            let mut _prev_end_offset: usize = 0;
1534            if 1 > max_ordinal {
1535                return Ok(());
1536            }
1537
1538            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1539            // are envelope_size bytes.
1540            let cur_offset: usize = (1 - 1) * envelope_size;
1541
1542            // Zero reserved fields.
1543            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1544
1545            // Safety:
1546            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1547            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1548            //   envelope_size bytes, there is always sufficient room.
1549            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u64>, D>(
1550            self.stack_frames.as_ref().map(<fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow),
1551            encoder, offset + cur_offset, depth
1552        )?;
1553
1554            _prev_end_offset = cur_offset + envelope_size;
1555
1556            Ok(())
1557        }
1558    }
1559
1560    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StackTrace {
1561        #[inline(always)]
1562        fn new_empty() -> Self {
1563            Self::default()
1564        }
1565
1566        unsafe fn decode(
1567            &mut self,
1568            decoder: &mut fidl::encoding::Decoder<'_, D>,
1569            offset: usize,
1570            mut depth: fidl::encoding::Depth,
1571        ) -> fidl::Result<()> {
1572            decoder.debug_check_bounds::<Self>(offset);
1573            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1574                None => return Err(fidl::Error::NotNullable),
1575                Some(len) => len,
1576            };
1577            // Calling decoder.out_of_line_offset(0) is not allowed.
1578            if len == 0 {
1579                return Ok(());
1580            };
1581            depth.increment()?;
1582            let envelope_size = 8;
1583            let bytes_len = len * envelope_size;
1584            let offset = decoder.out_of_line_offset(bytes_len)?;
1585            // Decode the envelope for each type.
1586            let mut _next_ordinal_to_read = 0;
1587            let mut next_offset = offset;
1588            let end_offset = offset + bytes_len;
1589            _next_ordinal_to_read += 1;
1590            if next_offset >= end_offset {
1591                return Ok(());
1592            }
1593
1594            // Decode unknown envelopes for gaps in ordinals.
1595            while _next_ordinal_to_read < 1 {
1596                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1597                _next_ordinal_to_read += 1;
1598                next_offset += envelope_size;
1599            }
1600
1601            let next_out_of_line = decoder.next_out_of_line();
1602            let handles_before = decoder.remaining_handles();
1603            if let Some((inlined, num_bytes, num_handles)) =
1604                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1605            {
1606                let member_inline_size = <fidl::encoding::UnboundedVector<u64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1607                if inlined != (member_inline_size <= 4) {
1608                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1609                }
1610                let inner_offset;
1611                let mut inner_depth = depth.clone();
1612                if inlined {
1613                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1614                    inner_offset = next_offset;
1615                } else {
1616                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1617                    inner_depth.increment()?;
1618                }
1619                let val_ref = self.stack_frames.get_or_insert_with(|| {
1620                    fidl::new_empty!(fidl::encoding::UnboundedVector<u64>, D)
1621                });
1622                fidl::decode!(
1623                    fidl::encoding::UnboundedVector<u64>,
1624                    D,
1625                    val_ref,
1626                    decoder,
1627                    inner_offset,
1628                    inner_depth
1629                )?;
1630                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1631                {
1632                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1633                }
1634                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1635                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1636                }
1637            }
1638
1639            next_offset += envelope_size;
1640
1641            // Decode the remaining unknown envelopes.
1642            while next_offset < end_offset {
1643                _next_ordinal_to_read += 1;
1644                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1645                next_offset += envelope_size;
1646            }
1647
1648            Ok(())
1649        }
1650    }
1651}
fidl_fuchsia_memory_sampler__common/fidl_fuchsia_memory_sampler__common.rs

fidl_fuchsia_memory_sampler__common/
fidl_fuchsia_memory_sampler__common.rs
