compiler/rustc_serialize/src/opaque.rs

   1 use crate::leb128::{self, max_leb128_len};
   2 use crate::serialize::{Decodable, Decoder, Encodable, Encoder};
   3 use std::convert::TryInto;
   4 use std::fs::File;
   5 use std::io::{self, Write};
   6 use std::mem::MaybeUninit;
   7 use std::path::Path;
   8 use std::ptr;
   9
  10 // -----------------------------------------------------------------------------
  11 // Encoder
  12 // -----------------------------------------------------------------------------
  13
  14 pub struct MemEncoder {
  15     pub data: Vec<u8>,
  16 }
  17
  18 impl MemEncoder {
  19     pub fn new() -> MemEncoder {
  20         MemEncoder { data: vec![] }
  21     }
  22
  23     #[inline]
  24     pub fn position(&self) -> usize {
  25         self.data.len()
  26     }
  27
  28     pub fn finish(self) -> Vec<u8> {
  29         self.data
  30     }
  31 }
  32
  33 macro_rules! write_leb128 {
  34     ($enc:expr, $value:expr, $int_ty:ty, $fun:ident) => {{
  35         const MAX_ENCODED_LEN: usize = max_leb128_len!($int_ty);
  36         let old_len = $enc.data.len();
  37
  38         if MAX_ENCODED_LEN > $enc.data.capacity() - old_len {
  39             $enc.data.reserve(MAX_ENCODED_LEN);
  40         }
  41
  42         // SAFETY: The above check and `reserve` ensures that there is enough
  43         // room to write the encoded value to the vector's internal buffer.
  44         unsafe {
  45             let buf = &mut *($enc.data.as_mut_ptr().add(old_len)
  46                 as *mut [MaybeUninit<u8>; MAX_ENCODED_LEN]);
  47             let encoded = leb128::$fun(buf, $value);
  48             $enc.data.set_len(old_len + encoded.len());
  49         }
  50     }};
  51 }
  52
  53 /// A byte that [cannot occur in UTF8 sequences][utf8]. Used to mark the end of a string.
  54 /// This way we can skip validation and still be relatively sure that deserialization
  55 /// did not desynchronize.
  56 ///
  57 /// [utf8]: https://en.wikipedia.org/w/index.php?title=UTF-8&oldid=1058865525#Codepage_layout
  58 const STR_SENTINEL: u8 = 0xC1;
  59
  60 impl Encoder for MemEncoder {
  61     #[inline]
  62     fn emit_usize(&mut self, v: usize) {
  63         write_leb128!(self, v, usize, write_usize_leb128)
  64     }
  65
  66     #[inline]
  67     fn emit_u128(&mut self, v: u128) {
  68         write_leb128!(self, v, u128, write_u128_leb128);
  69     }
  70
  71     #[inline]
  72     fn emit_u64(&mut self, v: u64) {
  73         write_leb128!(self, v, u64, write_u64_leb128);
  74     }
  75
  76     #[inline]
  77     fn emit_u32(&mut self, v: u32) {
  78         write_leb128!(self, v, u32, write_u32_leb128);
  79     }
  80
  81     #[inline]
  82     fn emit_u16(&mut self, v: u16) {
  83         self.data.extend_from_slice(&v.to_le_bytes());
  84     }
  85
  86     #[inline]
  87     fn emit_u8(&mut self, v: u8) {
  88         self.data.push(v);
  89     }
  90
  91     #[inline]
  92     fn emit_isize(&mut self, v: isize) {
  93         write_leb128!(self, v, isize, write_isize_leb128)
  94     }
  95
  96     #[inline]
  97     fn emit_i128(&mut self, v: i128) {
  98         write_leb128!(self, v, i128, write_i128_leb128)
  99     }
 100
 101     #[inline]
 102     fn emit_i64(&mut self, v: i64) {
 103         write_leb128!(self, v, i64, write_i64_leb128)
 104     }
 105
 106     #[inline]
 107     fn emit_i32(&mut self, v: i32) {
 108         write_leb128!(self, v, i32, write_i32_leb128)
 109     }
 110
 111     #[inline]
 112     fn emit_i16(&mut self, v: i16) {
 113         self.data.extend_from_slice(&v.to_le_bytes());
 114     }
 115
 116     #[inline]
 117     fn emit_i8(&mut self, v: i8) {
 118         self.emit_u8(v as u8);
 119     }
 120
 121     #[inline]
 122     fn emit_bool(&mut self, v: bool) {
 123         self.emit_u8(if v { 1 } else { 0 });
 124     }
 125
 126     #[inline]
 127     fn emit_f64(&mut self, v: f64) {
 128         let as_u64: u64 = v.to_bits();
 129         self.emit_u64(as_u64);
 130     }
 131
 132     #[inline]
 133     fn emit_f32(&mut self, v: f32) {
 134         let as_u32: u32 = v.to_bits();
 135         self.emit_u32(as_u32);
 136     }
 137
 138     #[inline]
 139     fn emit_char(&mut self, v: char) {
 140         self.emit_u32(v as u32);
 141     }
 142
 143     #[inline]
 144     fn emit_str(&mut self, v: &str) {
 145         self.emit_usize(v.len());
 146         self.emit_raw_bytes(v.as_bytes());
 147         self.emit_u8(STR_SENTINEL);
 148     }
 149
 150     #[inline]
 151     fn emit_raw_bytes(&mut self, s: &[u8]) {
 152         self.data.extend_from_slice(s);
 153     }
 154 }
 155
 156 pub type FileEncodeResult = Result<usize, io::Error>;
 157
 158 // `FileEncoder` encodes data to file via fixed-size buffer.
 159 //
 160 // When encoding large amounts of data to a file, using `FileEncoder` may be
 161 // preferred over using `MemEncoder` to encode to a `Vec`, and then writing the
 162 // `Vec` to file, as the latter uses as much memory as there is encoded data,
 163 // while the former uses the fixed amount of memory allocated to the buffer.
 164 // `FileEncoder` also has the advantage of not needing to reallocate as data
 165 // is appended to it, but the disadvantage of requiring more error handling,
 166 // which has some runtime overhead.
 167 pub struct FileEncoder {
 168     // The input buffer. For adequate performance, we need more control over
 169     // buffering than `BufWriter` offers. If `BufWriter` ever offers a raw
 170     // buffer access API, we can use it, and remove `buf` and `buffered`.
 171     buf: Box<[MaybeUninit<u8>]>,
 172     buffered: usize,
 173     flushed: usize,
 174     file: File,
 175     // This is used to implement delayed error handling, as described in the
 176     // comment on `trait Encoder`.
 177     res: Result<(), io::Error>,
 178 }
 179
 180 impl FileEncoder {
 181     pub fn new<P: AsRef<Path>>(path: P) -> io::Result<Self> {
 182         const DEFAULT_BUF_SIZE: usize = 8192;
 183         FileEncoder::with_capacity(path, DEFAULT_BUF_SIZE)
 184     }
 185
 186     pub fn with_capacity<P: AsRef<Path>>(path: P, capacity: usize) -> io::Result<Self> {
 187         // Require capacity at least as large as the largest LEB128 encoding
 188         // here, so that we don't have to check or handle this on every write.
 189         assert!(capacity >= max_leb128_len());
 190
 191         // Require capacity small enough such that some capacity checks can be
 192         // done using guaranteed non-overflowing add rather than sub, which
 193         // shaves an instruction off those code paths (on x86 at least).
 194         assert!(capacity <= usize::MAX - max_leb128_len());
 195
 196         // Create the file for reading and writing, because some encoders do both
 197         // (e.g. the metadata encoder when -Zmeta-stats is enabled)
 198         let file = File::options().read(true).write(true).create(true).truncate(true).open(path)?;
 199
 200         Ok(FileEncoder {
 201             buf: Box::new_uninit_slice(capacity),
 202             buffered: 0,
 203             flushed: 0,
 204             file,
 205             res: Ok(()),
 206         })
 207     }
 208
 209     #[inline]
 210     pub fn position(&self) -> usize {
 211         // Tracking position this way instead of having a `self.position` field
 212         // means that we don't have to update the position on every write call.
 213         self.flushed + self.buffered
 214     }
 215
 216     pub fn flush(&mut self) {
 217         // This is basically a copy of `BufWriter::flush`. If `BufWriter` ever
 218         // offers a raw buffer access API, we can use it, and remove this.
 219
 220         /// Helper struct to ensure the buffer is updated after all the writes
 221         /// are complete. It tracks the number of written bytes and drains them
 222         /// all from the front of the buffer when dropped.
 223         struct BufGuard<'a> {
 224             buffer: &'a mut [u8],
 225             encoder_buffered: &'a mut usize,
 226             encoder_flushed: &'a mut usize,
 227             flushed: usize,
 228         }
 229
 230         impl<'a> BufGuard<'a> {
 231             fn new(
 232                 buffer: &'a mut [u8],
 233                 encoder_buffered: &'a mut usize,
 234                 encoder_flushed: &'a mut usize,
 235             ) -> Self {
 236                 assert_eq!(buffer.len(), *encoder_buffered);
 237                 Self { buffer, encoder_buffered, encoder_flushed, flushed: 0 }
 238             }
 239
 240             /// The unwritten part of the buffer
 241             fn remaining(&self) -> &[u8] {
 242                 &self.buffer[self.flushed..]
 243             }
 244
 245             /// Flag some bytes as removed from the front of the buffer
 246             fn consume(&mut self, amt: usize) {
 247                 self.flushed += amt;
 248             }
 249
 250             /// true if all of the bytes have been written
 251             fn done(&self) -> bool {
 252                 self.flushed >= *self.encoder_buffered
 253             }
 254         }
 255
 256         impl Drop for BufGuard<'_> {
 257             fn drop(&mut self) {
 258                 if self.flushed > 0 {
 259                     if self.done() {
 260                         *self.encoder_flushed += *self.encoder_buffered;
 261                         *self.encoder_buffered = 0;
 262                     } else {
 263                         self.buffer.copy_within(self.flushed.., 0);
 264                         *self.encoder_flushed += self.flushed;
 265                         *self.encoder_buffered -= self.flushed;
 266                     }
 267                 }
 268             }
 269         }
 270
 271         // If we've already had an error, do nothing. It'll get reported after
 272         // `finish` is called.
 273         if self.res.is_err() {
 274             return;
 275         }
 276
 277         let mut guard = BufGuard::new(
 278             unsafe { MaybeUninit::slice_assume_init_mut(&mut self.buf[..self.buffered]) },
 279             &mut self.buffered,
 280             &mut self.flushed,
 281         );
 282
 283         while !guard.done() {
 284             match self.file.write(guard.remaining()) {
 285                 Ok(0) => {
 286                     self.res = Err(io::Error::new(
 287                         io::ErrorKind::WriteZero,
 288                         "failed to write the buffered data",
 289                     ));
 290                     return;
 291                 }
 292                 Ok(n) => guard.consume(n),
 293                 Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
 294                 Err(e) => {
 295                     self.res = Err(e);
 296                     return;
 297                 }
 298             }
 299         }
 300     }
 301
 302     pub fn file(&self) -> &File {
 303         &self.file
 304     }
 305
 306     #[inline]
 307     fn capacity(&self) -> usize {
 308         self.buf.len()
 309     }
 310
 311     #[inline]
 312     fn write_one(&mut self, value: u8) {
 313         // We ensure this during `FileEncoder` construction.
 314         debug_assert!(self.capacity() >= 1);
 315
 316         let mut buffered = self.buffered;
 317
 318         if std::intrinsics::unlikely(buffered >= self.capacity()) {
 319             self.flush();
 320             buffered = 0;
 321         }
 322
 323         // SAFETY: The above check and `flush` ensures that there is enough
 324         // room to write the input to the buffer.
 325         unsafe {
 326             *MaybeUninit::slice_as_mut_ptr(&mut self.buf).add(buffered) = value;
 327         }
 328
 329         self.buffered = buffered + 1;
 330     }
 331
 332     #[inline]
 333     fn write_all(&mut self, buf: &[u8]) {
 334         let capacity = self.capacity();
 335         let buf_len = buf.len();
 336
 337         if std::intrinsics::likely(buf_len <= capacity) {
 338             let mut buffered = self.buffered;
 339
 340             if std::intrinsics::unlikely(buf_len > capacity - buffered) {
 341                 self.flush();
 342                 buffered = 0;
 343             }
 344
 345             // SAFETY: The above check and `flush` ensures that there is enough
 346             // room to write the input to the buffer.
 347             unsafe {
 348                 let src = buf.as_ptr();
 349                 let dst = MaybeUninit::slice_as_mut_ptr(&mut self.buf).add(buffered);
 350                 ptr::copy_nonoverlapping(src, dst, buf_len);
 351             }
 352
 353             self.buffered = buffered + buf_len;
 354         } else {
 355             self.write_all_unbuffered(buf);
 356         }
 357     }
 358
 359     fn write_all_unbuffered(&mut self, mut buf: &[u8]) {
 360         // If we've already had an error, do nothing. It'll get reported after
 361         // `finish` is called.
 362         if self.res.is_err() {
 363             return;
 364         }
 365
 366         if self.buffered > 0 {
 367             self.flush();
 368         }
 369
 370         // This is basically a copy of `Write::write_all` but also updates our
 371         // `self.flushed`. It's necessary because `Write::write_all` does not
 372         // return the number of bytes written when an error is encountered, and
 373         // without that, we cannot accurately update `self.flushed` on error.
 374         while !buf.is_empty() {
 375             match self.file.write(buf) {
 376                 Ok(0) => {
 377                     self.res = Err(io::Error::new(
 378                         io::ErrorKind::WriteZero,
 379                         "failed to write whole buffer",
 380                     ));
 381                     return;
 382                 }
 383                 Ok(n) => {
 384                     buf = &buf[n..];
 385                     self.flushed += n;
 386                 }
 387                 Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
 388                 Err(e) => {
 389                     self.res = Err(e);
 390                     return;
 391                 }
 392             }
 393         }
 394     }
 395
 396     pub fn finish(mut self) -> Result<usize, io::Error> {
 397         self.flush();
 398
 399         let res = std::mem::replace(&mut self.res, Ok(()));
 400         res.map(|()| self.position())
 401     }
 402 }
 403
 404 impl Drop for FileEncoder {
 405     fn drop(&mut self) {
 406         // Likely to be a no-op, because `finish` should have been called and
 407         // it also flushes. But do it just in case.
 408         let _result = self.flush();
 409     }
 410 }
 411
 412 macro_rules! file_encoder_write_leb128 {
 413     ($enc:expr, $value:expr, $int_ty:ty, $fun:ident) => {{
 414         const MAX_ENCODED_LEN: usize = max_leb128_len!($int_ty);
 415
 416         // We ensure this during `FileEncoder` construction.
 417         debug_assert!($enc.capacity() >= MAX_ENCODED_LEN);
 418
 419         let mut buffered = $enc.buffered;
 420
 421         // This can't overflow. See assertion in `FileEncoder::with_capacity`.
 422         if std::intrinsics::unlikely(buffered + MAX_ENCODED_LEN > $enc.capacity()) {
 423             $enc.flush();
 424             buffered = 0;
 425         }
 426
 427         // SAFETY: The above check and flush ensures that there is enough
 428         // room to write the encoded value to the buffer.
 429         let buf = unsafe {
 430             &mut *($enc.buf.as_mut_ptr().add(buffered) as *mut [MaybeUninit<u8>; MAX_ENCODED_LEN])
 431         };
 432
 433         let encoded = leb128::$fun(buf, $value);
 434         $enc.buffered = buffered + encoded.len();
 435     }};
 436 }
 437
 438 impl Encoder for FileEncoder {
 439     #[inline]
 440     fn emit_usize(&mut self, v: usize) {
 441         file_encoder_write_leb128!(self, v, usize, write_usize_leb128)
 442     }
 443
 444     #[inline]
 445     fn emit_u128(&mut self, v: u128) {
 446         file_encoder_write_leb128!(self, v, u128, write_u128_leb128)
 447     }
 448
 449     #[inline]
 450     fn emit_u64(&mut self, v: u64) {
 451         file_encoder_write_leb128!(self, v, u64, write_u64_leb128)
 452     }
 453
 454     #[inline]
 455     fn emit_u32(&mut self, v: u32) {
 456         file_encoder_write_leb128!(self, v, u32, write_u32_leb128)
 457     }
 458
 459     #[inline]
 460     fn emit_u16(&mut self, v: u16) {
 461         self.write_all(&v.to_le_bytes());
 462     }
 463
 464     #[inline]
 465     fn emit_u8(&mut self, v: u8) {
 466         self.write_one(v);
 467     }
 468
 469     #[inline]
 470     fn emit_isize(&mut self, v: isize) {
 471         file_encoder_write_leb128!(self, v, isize, write_isize_leb128)
 472     }
 473
 474     #[inline]
 475     fn emit_i128(&mut self, v: i128) {
 476         file_encoder_write_leb128!(self, v, i128, write_i128_leb128)
 477     }
 478
 479     #[inline]
 480     fn emit_i64(&mut self, v: i64) {
 481         file_encoder_write_leb128!(self, v, i64, write_i64_leb128)
 482     }
 483
 484     #[inline]
 485     fn emit_i32(&mut self, v: i32) {
 486         file_encoder_write_leb128!(self, v, i32, write_i32_leb128)
 487     }
 488
 489     #[inline]
 490     fn emit_i16(&mut self, v: i16) {
 491         self.write_all(&v.to_le_bytes());
 492     }
 493
 494     #[inline]
 495     fn emit_i8(&mut self, v: i8) {
 496         self.emit_u8(v as u8);
 497     }
 498
 499     #[inline]
 500     fn emit_bool(&mut self, v: bool) {
 501         self.emit_u8(if v { 1 } else { 0 });
 502     }
 503
 504     #[inline]
 505     fn emit_f64(&mut self, v: f64) {
 506         let as_u64: u64 = v.to_bits();
 507         self.emit_u64(as_u64);
 508     }
 509
 510     #[inline]
 511     fn emit_f32(&mut self, v: f32) {
 512         let as_u32: u32 = v.to_bits();
 513         self.emit_u32(as_u32);
 514     }
 515
 516     #[inline]
 517     fn emit_char(&mut self, v: char) {
 518         self.emit_u32(v as u32);
 519     }
 520
 521     #[inline]
 522     fn emit_str(&mut self, v: &str) {
 523         self.emit_usize(v.len());
 524         self.emit_raw_bytes(v.as_bytes());
 525         self.emit_u8(STR_SENTINEL);
 526     }
 527
 528     #[inline]
 529     fn emit_raw_bytes(&mut self, s: &[u8]) {
 530         self.write_all(s);
 531     }
 532 }
 533
 534 // -----------------------------------------------------------------------------
 535 // Decoder
 536 // -----------------------------------------------------------------------------
 537
 538 pub struct MemDecoder<'a> {
 539     pub data: &'a [u8],
 540     position: usize,
 541 }
 542
 543 impl<'a> MemDecoder<'a> {
 544     #[inline]
 545     pub fn new(data: &'a [u8], position: usize) -> MemDecoder<'a> {
 546         MemDecoder { data, position }
 547     }
 548
 549     #[inline]
 550     pub fn position(&self) -> usize {
 551         self.position
 552     }
 553
 554     #[inline]
 555     pub fn set_position(&mut self, pos: usize) {
 556         self.position = pos
 557     }
 558
 559     #[inline]
 560     pub fn advance(&mut self, bytes: usize) {
 561         self.position += bytes;
 562     }
 563 }
 564
 565 macro_rules! read_leb128 {
 566     ($dec:expr, $fun:ident) => {{ leb128::$fun($dec.data, &mut $dec.position) }};
 567 }
 568
 569 impl<'a> Decoder for MemDecoder<'a> {
 570     #[inline]
 571     fn read_u128(&mut self) -> u128 {
 572         read_leb128!(self, read_u128_leb128)
 573     }
 574
 575     #[inline]
 576     fn read_u64(&mut self) -> u64 {
 577         read_leb128!(self, read_u64_leb128)
 578     }
 579
 580     #[inline]
 581     fn read_u32(&mut self) -> u32 {
 582         read_leb128!(self, read_u32_leb128)
 583     }
 584
 585     #[inline]
 586     fn read_u16(&mut self) -> u16 {
 587         let bytes = [self.data[self.position], self.data[self.position + 1]];
 588         let value = u16::from_le_bytes(bytes);
 589         self.position += 2;
 590         value
 591     }
 592
 593     #[inline]
 594     fn read_u8(&mut self) -> u8 {
 595         let value = self.data[self.position];
 596         self.position += 1;
 597         value
 598     }
 599
 600     #[inline]
 601     fn read_usize(&mut self) -> usize {
 602         read_leb128!(self, read_usize_leb128)
 603     }
 604
 605     #[inline]
 606     fn read_i128(&mut self) -> i128 {
 607         read_leb128!(self, read_i128_leb128)
 608     }
 609
 610     #[inline]
 611     fn read_i64(&mut self) -> i64 {
 612         read_leb128!(self, read_i64_leb128)
 613     }
 614
 615     #[inline]
 616     fn read_i32(&mut self) -> i32 {
 617         read_leb128!(self, read_i32_leb128)
 618     }
 619
 620     #[inline]
 621     fn read_i16(&mut self) -> i16 {
 622         let bytes = [self.data[self.position], self.data[self.position + 1]];
 623         let value = i16::from_le_bytes(bytes);
 624         self.position += 2;
 625         value
 626     }
 627
 628     #[inline]
 629     fn read_i8(&mut self) -> i8 {
 630         let value = self.data[self.position];
 631         self.position += 1;
 632         value as i8
 633     }
 634
 635     #[inline]
 636     fn read_isize(&mut self) -> isize {
 637         read_leb128!(self, read_isize_leb128)
 638     }
 639
 640     #[inline]
 641     fn read_bool(&mut self) -> bool {
 642         let value = self.read_u8();
 643         value != 0
 644     }
 645
 646     #[inline]
 647     fn read_f64(&mut self) -> f64 {
 648         let bits = self.read_u64();
 649         f64::from_bits(bits)
 650     }
 651
 652     #[inline]
 653     fn read_f32(&mut self) -> f32 {
 654         let bits = self.read_u32();
 655         f32::from_bits(bits)
 656     }
 657
 658     #[inline]
 659     fn read_char(&mut self) -> char {
 660         let bits = self.read_u32();
 661         std::char::from_u32(bits).unwrap()
 662     }
 663
 664     #[inline]
 665     fn read_str(&mut self) -> &'a str {
 666         let len = self.read_usize();
 667         let sentinel = self.data[self.position + len];
 668         assert!(sentinel == STR_SENTINEL);
 669         let s = unsafe {
 670             std::str::from_utf8_unchecked(&self.data[self.position..self.position + len])
 671         };
 672         self.position += len + 1;
 673         s
 674     }
 675
 676     #[inline]
 677     fn read_raw_bytes(&mut self, bytes: usize) -> &'a [u8] {
 678         let start = self.position;
 679         self.position += bytes;
 680         &self.data[start..self.position]
 681     }
 682 }
 683
 684 // Specializations for contiguous byte sequences follow. The default implementations for slices
 685 // encode and decode each element individually. This isn't necessary for `u8` slices when using
 686 // opaque encoders and decoders, because each `u8` is unchanged by encoding and decoding.
 687 // Therefore, we can use more efficient implementations that process the entire sequence at once.
 688
 689 // Specialize encoding byte slices. This specialization also applies to encoding `Vec<u8>`s, etc.,
 690 // since the default implementations call `encode` on their slices internally.
 691 impl Encodable<MemEncoder> for [u8] {
 692     fn encode(&self, e: &mut MemEncoder) {
 693         Encoder::emit_usize(e, self.len());
 694         e.emit_raw_bytes(self);
 695     }
 696 }
 697
 698 impl Encodable<FileEncoder> for [u8] {
 699     fn encode(&self, e: &mut FileEncoder) {
 700         Encoder::emit_usize(e, self.len());
 701         e.emit_raw_bytes(self);
 702     }
 703 }
 704
 705 // Specialize decoding `Vec<u8>`. This specialization also applies to decoding `Box<[u8]>`s, etc.,
 706 // since the default implementations call `decode` to produce a `Vec<u8>` internally.
 707 impl<'a> Decodable<MemDecoder<'a>> for Vec<u8> {
 708     fn decode(d: &mut MemDecoder<'a>) -> Self {
 709         let len = Decoder::read_usize(d);
 710         d.read_raw_bytes(len).to_owned()
 711     }
 712 }
 713
 714 // An integer that will always encode to 8 bytes.
 715 pub struct IntEncodedWithFixedSize(pub u64);
 716
 717 impl IntEncodedWithFixedSize {
 718     pub const ENCODED_SIZE: usize = 8;
 719 }
 720
 721 impl Encodable<MemEncoder> for IntEncodedWithFixedSize {
 722     #[inline]
 723     fn encode(&self, e: &mut MemEncoder) {
 724         let _start_pos = e.position();
 725         e.emit_raw_bytes(&self.0.to_le_bytes());
 726         let _end_pos = e.position();
 727         debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE);
 728     }
 729 }
 730
 731 impl Encodable<FileEncoder> for IntEncodedWithFixedSize {
 732     #[inline]
 733     fn encode(&self, e: &mut FileEncoder) {
 734         let _start_pos = e.position();
 735         e.emit_raw_bytes(&self.0.to_le_bytes());
 736         let _end_pos = e.position();
 737         debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE);
 738     }
 739 }
 740
 741 impl<'a> Decodable<MemDecoder<'a>> for IntEncodedWithFixedSize {
 742     #[inline]
 743     fn decode(decoder: &mut MemDecoder<'a>) -> IntEncodedWithFixedSize {
 744         let _start_pos = decoder.position();
 745         let bytes = decoder.read_raw_bytes(IntEncodedWithFixedSize::ENCODED_SIZE);
 746         let value = u64::from_le_bytes(bytes.try_into().unwrap());
 747         let _end_pos = decoder.position();
 748         debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE);
 749
 750         IntEncodedWithFixedSize(value)
 751     }
 752 }