Elfedit: correct reallocation of dynstr/dynamic

pmeunier

Apr 11, 2025, 5:36 AM

5PJAXSZ7AV7WEGMHTKWFOYWN5YUFRFZDZUXNIMLRPRTADZQEN4JAC

Dependencies

• [2] WGAKJ25E Adding a debug_svg command
• [3] AR2X3TLA Initial commit: introducing elfedit

Change contents

• replacement in elfedit/src/lib.rs at line 52
  [3.2005]→[3.2005:2079](∅→∅)
  − //! assert_eq!(p.interpreter().unwrap().to_bytes_with_nul(), new_interp);
  [3.2005]

  [3.2079]
  + //! assert_eq!(p.interpreter().unwrap().unwrap().to_bytes_with_nul(), new_interp);
• edit in elfedit/src/lib.rs at line 80
  [3.2912]

  [3.2912]
  + #[error("Wrong file type")]

  + WrongMagic,
• replacement in elfedit/src/lib.rs at line 148
  [3.4407]→[3.4407:4429](∅→∅)
  − data: Endianness,
  [3.4407]

  [3.4429]
  + pub data: Endianness,
• replacement in elfedit/src/lib.rs at line 155
  [3.4508]→[3.4508:4538](∅→∅)
  − #[derive(Debug, Copy, Clone)]
  [3.4508]

  [3.4538]
  + #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
• edit in elfedit/src/lib.rs at line 204
  [3.5708]

  [3.5708]
  + } else {

  + panic!()

  + }

  + }

  + }

  +

  + impl Endian<u16> {

  + fn from(id: Endianness, u: u16) -> Self {

  + if id == Endianness::LITTLE {

  + Endian(u.to_le())

  + } else if id == Endianness::BIG {

  + Endian(u.to_be())
• edit in elfedit/src/lib.rs at line 240
  [3.6232]

  [3.6232]
  + } else {

  + panic!()

  + }

  + }

  + }

  +

  + impl Endian<Pht> {

  + fn from(id: Endianness, u: Pht) -> Self {

  + if id == Endianness::LITTLE {

  + Endian(Pht(u.0.to_le()))

  + } else if id == Endianness::BIG {

  + Endian(Pht(u.0.to_be()))

  + } else {

  + panic!()

  + }

  + }

  + }

  +

  + impl Endian<DynTag64> {

  + fn from(id: Endianness, u: DynTag64) -> Self {

  + if id == Endianness::LITTLE {

  + Endian(DynTag64(u.0.to_le()))

  + } else if id == Endianness::BIG {

  + Endian(DynTag64(u.0.to_be()))

  + } else {

  + panic!()

  + }

  + }

  + }

  +

  + impl Endian<DynTag32> {

  + fn from(id: Endianness, u: DynTag32) -> Self {

  + if id == Endianness::LITTLE {

  + Endian(DynTag32(u.0.to_le()))

  + } else if id == Endianness::BIG {

  + Endian(DynTag32(u.0.to_be()))
• edit in elfedit/src/lib.rs at line 282
  [3.6289]

  [3.6289]
  + impl EndianT for Pht {

  + fn endian(e: Endian<Self>, id: Endianness) -> Self {

  + if id == Endianness::LITTLE {

  + Pht(u32::from_le(e.0 .0))

  + } else if id == Endianness::BIG {

  + Pht(u32::from_be(e.0 .0))

  + } else {

  + panic!()

  + }

  + }

  + }

  +
• replacement in elfedit/src/lib.rs at line 358
  [3.7679]→[3.7679:7735](∅→∅)
  − fn set_offset(&mut self, h: Endianness, u: usize) {
  [3.7679]

  [3.7735]
  + pub fn set_offset(&mut self, h: Endianness, u: usize) {
• edit in elfedit/src/lib.rs at line 362
  [3.7928]

  [3.7928]
  + }

  + }

  + pub fn set_addr(&mut self, h: Endianness, u: usize) {

  + match self {

  + SectionHeaderMut_::B32(s) => s.addr = <Endian<u32>>::from(h, u as u32),

  + SectionHeaderMut_::B64(s) => s.addr = <Endian<u64>>::from(h, u as u64),

  + }

  + }

  + pub fn offset(&self, h: Endianness) -> u64 {

  + match self {

  + SectionHeaderMut_::B32(s) => EndianT::endian(s.offset, h) as u64,

  + SectionHeaderMut_::B64(s) => EndianT::endian(s.offset, h),
• edit in elfedit/src/lib.rs at line 376
  [3.7944]

  [3.7944]
  + pub fn addr(&self, h: Endianness) -> u64 {

  + match self {

  + SectionHeaderMut_::B32(s) => EndianT::endian(s.addr, h) as u64,

  + SectionHeaderMut_::B64(s) => EndianT::endian(s.addr, h),

  + }

  + }
• replacement in elfedit/src/lib.rs at line 385
  [3.7980]→[3.7980:8025](∅→∅)
  − fn offset(&self, h: Endianness) -> u64 {
  [3.7980]

  [3.8025]
  + fn set_filesz(&mut self, h: Endianness, u: usize) {
• replacement in elfedit/src/lib.rs at line 387
  [3.8046]→[3.8046:8195](∅→∅)
  − ProgramHeaderMut_::B32(s) => EndianT::endian(s.offset, h) as u64,

  − ProgramHeaderMut_::B64(s) => EndianT::endian(s.offset, h),
  [3.8046]

  [3.8195]
  + ProgramHeaderMut_::B32(s) => s.filesz = <Endian<u32>>::from(h, u as u32),

  + ProgramHeaderMut_::B64(s) => s.filesz = <Endian<u64>>::from(h, u as u64),
• replacement in elfedit/src/lib.rs at line 391
  [3.8211]→[3.8211:8267](∅→∅)
  − fn set_filesz(&mut self, h: Endianness, u: usize) {
  [3.8211]

  [3.8267]
  + pub fn set_vaddr(&mut self, h: Endianness, u: usize) {
• replacement in elfedit/src/lib.rs at line 393
  [3.8288]→[3.8288:8460](∅→∅)
  − ProgramHeaderMut_::B32(s) => s.filesz = <Endian<u32>>::from(h, u as u32),

  − ProgramHeaderMut_::B64(s) => s.filesz = <Endian<u64>>::from(h, u as u64),
  [3.8288]

  [3.8460]
  + ProgramHeaderMut_::B32(s) => s.vaddr = <Endian<u32>>::from(h, u as u32),

  + ProgramHeaderMut_::B64(s) => s.vaddr = <Endian<u64>>::from(h, u as u64),
• replacement in elfedit/src/lib.rs at line 403
  [3.8738]→[3.8738:8794](∅→∅)
  − fn set_offset(&mut self, h: Endianness, u: usize) {
  [3.8738]

  [3.8794]
  + pub fn set_offset(&mut self, h: Endianness, u: usize) {
• edit in elfedit/src/lib.rs at line 407
  [3.8987]

  [2.116]
  + }

  + }

  + pub fn set_type(&mut self, h: Endianness, u: Pht) {

  + match self {

  + ProgramHeaderMut_::B32(s) => s.type_ = <Endian<Pht>>::from(h, u),

  + ProgramHeaderMut_::B64(s) => s.type_ = <Endian<Pht>>::from(h, u),

  + }

  + }

  + pub fn set_flags(&mut self, h: Endianness, u: u32) {

  + match self {

  + ProgramHeaderMut_::B32(s) => s.flags32 = <Endian<u32>>::from(h, u),

  + ProgramHeaderMut_::B64(s) => s.flags64 = <Endian<u32>>::from(h, u),

  + }

  + }

  + pub fn set_align(&mut self, h: Endianness, u: u64) {

  + match self {

  + ProgramHeaderMut_::B32(s) => s.align = <Endian<u32>>::from(h, u as u32),

  + ProgramHeaderMut_::B64(s) => s.align = <Endian<u64>>::from(h, u),

  + }

  + }

  +

  + fn type_(&self, id: Endianness) -> Pht {

  + match self {

  + ProgramHeaderMut_::B32(h) => EndianT::endian(h.type_, id),

  + ProgramHeaderMut_::B64(h) => EndianT::endian(h.type_, id),

  + }

  + }

  + pub fn filesz(&self, h: Endianness) -> u64 {

  + match self {

  + ProgramHeaderMut_::B32(s) => EndianT::endian(s.filesz, h) as u64,

  + ProgramHeaderMut_::B64(s) => EndianT::endian(s.filesz, h),

  + }

  + }

  + pub fn memsz(&self, h: Endianness) -> u64 {

  + match self {

  + ProgramHeaderMut_::B32(s) => EndianT::endian(s.memsz, h) as u64,

  + ProgramHeaderMut_::B64(s) => EndianT::endian(s.memsz, h),
• edit in elfedit/src/lib.rs at line 453
  [2.383]

  [2.383]
  + }

  + }

  +

  + fn type_(&self, id: Endianness) -> Pht {

  + match self {

  + ProgramHeaderBits::B32(h) => EndianT::endian(h.type_, id),

  + ProgramHeaderBits::B64(h) => EndianT::endian(h.type_, id),
• edit in elfedit/src/lib.rs at line 486
  [2.1296]

  [3.9003]
  + pub fn align(&self, h: Endianness) -> u64 {

  + match self {

  + ProgramHeaderBits::B32(s) => EndianT::endian(s.align, h) as u64,

  + ProgramHeaderBits::B64(s) => EndianT::endian(s.align, h),

  + }

  + }
• edit in elfedit/src/lib.rs at line 505
  [3.9464]

  [3.9464]
  + }

  + }

  + pub fn addr(&self, h: Endianness) -> u64 {

  + match self {

  + SectionHeader_::B32(s) => EndianT::endian(s.addr, h) as u64,

  + SectionHeader_::B64(s) => EndianT::endian(s.addr, h),
• replacement in elfedit/src/lib.rs at line 569
  [3.11008]→[3.11008:11042](∅→∅)
  − f: Option<&'a std::fs::File>,
  [3.11008]

  [3.11042]
  + f: &'a std::fs::File,
• replacement in elfedit/src/lib.rs at line 577
  [3.11227]→[3.11227:11302](∅→∅)
  − pub fn open(file: &'f std::fs::File) -> Result<Self, std::io::Error> {
  [3.11227]

  [3.11302]
  + pub fn open(file: &'f std::fs::File) -> Result<Self, Error> {
• replacement in elfedit/src/lib.rs at line 579
  [3.11383]→[3.11383:11400](∅→∅)
  − Ok(Elf {
  [3.11383]

  [3.11400]
  + let e = Elf {
• replacement in elfedit/src/lib.rs at line 581
  [3.11417]→[3.11417:11444](∅→∅)
  − f: Some(file),
  [3.11417]

  [3.11444]
  + f: file,
• replacement in elfedit/src/lib.rs at line 585
  [3.11547]→[3.11547:11558](∅→∅)
  − })
  [3.11547]

  [2.1297]
  + };

  + if e.id().magic == [0x7f, 0x45, 0x4c, 0x46] {

  + Ok(e)

  + } else {

  + Err(Error::WrongMagic)

  + }
• edit in elfedit/src/lib.rs at line 652
  [2.3479]

  [2.3479]
  + x = x.max(off as usize + sz as usize);
• replacement in elfedit/src/lib.rs at line 901
  [3.18067]→[3.18067:18146](∅→∅)
  − /// Paress the sections relevant for linking (.interp, .dynstr, .dynamic).
  [3.18067]

  [3.18146]
  + /// Parses the sections relevant for linking (.interp, .dynstr, .dynamic).
• replacement in elfedit/src/lib.rs at line 911
  [3.18539]→[3.18539:18573](∅→∅)
  − let mut interp = &[][..];
  [3.18539]

  [3.18573]
  + let mut interp = None;
• replacement in elfedit/src/lib.rs at line 918
  [3.18882]→[3.18882:18941](∅→∅)
  − interp = &self.map[offset..offset + size];
  [3.18882]

  [3.18941]
  + interp = Some(&self.map[offset..offset + size]);
• replacement in elfedit/src/lib.rs at line 930
  [3.19354]→[3.19354:19514](∅→∅),[3.19514]→[3.19514:19580](∅→∅),[3.19580]→[3.19580:19626](∅→∅),[3.19626]→[2.6576:6632](∅→∅),[2.6632]→[2.6632:6727](∅→∅),[2.6727]→[2.6727:6829](∅→∅),[2.6829]→[3.19863:19890](∅→∅),[3.19863]→[3.19863:19890](∅→∅),[3.19890]→[2.6830:6907](∅→∅),[2.6907]→[3.19969:20051](∅→∅),[3.19969]→[3.19969:20051](∅→∅),[3.20051]→[3.20051:20117](∅→∅),[3.20117]→[3.20117:20169](∅→∅),[3.20169]→[3.20169:20260](∅→∅),[3.20260]→[3.20260:20354](∅→∅),[3.20354]→[2.6908:6932](∅→∅),[2.6932]→[3.20400:20454](∅→∅),[3.20400]→[3.20400:20454](∅→∅)
  − dynamic = match id.class {

  − Bits::B32 => {

  − assert_eq!(offset % std::mem::align_of::<Elf32Dyn>(), 0);

  − assert!(offset + size <= self.map.len());

  − Dynamic::B32(unsafe {

  − std::slice::from_raw_parts(

  − self.map.as_ptr().add(offset) as *const u8 as *const Elf32Dyn,

  − size / std::mem::size_of::<Elf32Dyn>(),

  − )

  − })

  − }

  − Bits::B64 => Dynamic::B64(unsafe {

  − assert_eq!(offset % std::mem::align_of::<Elf64Dyn>(), 0);

  − assert!(offset + size <= self.map.len());

  − std::slice::from_raw_parts(

  − self.map.as_ptr().add(offset) as *const u8 as *const Elf64Dyn,

  − size / std::mem::size_of::<Elf64Dyn>(),

  − )

  − }),

  − _ => panic!(),

  − };
  [3.19354]

  [3.20454]
  + assert!(offset + size <= self.map.len());

  + dynamic =

  + unsafe { dynamic_from_raw(id.class, self.map.as_ptr().add(offset), size) };
• edit in elfedit/src/lib.rs at line 937
  [3.20499]

  [3.20499]
  + data: id.data,
• replacement in elfedit/src/lib.rs at line 949
  [3.20840]→[3.20840:20861](∅→∅)
  − if names
  [3.20840]

  [3.20861]
  + let n = names
• replacement in elfedit/src/lib.rs at line 951
  [3.20924]→[3.20924:20990](∅→∅)
  − .to_bytes()

  − == name

  − {
  [3.20924]

  [3.20990]
  + .to_bytes();

  + if n == name {
• replacement in elfedit/src/lib.rs at line 962
  [3.21221]→[3.21221:21373](∅→∅)
  − let mut next_off = header.shoff(id);

  − for sec in self.sections::<U>() {

  − let s: u64 = EndianT::endian(sec.offset, id).into();
  [3.21221]

  [3.21373]
  + let mut next_off = self.f.metadata().unwrap().len();

  + for s in self

  + .sections::<U>()

  + .iter()

  + .map(|sec| EndianT::endian(sec.offset, id).into())

  + .chain(std::iter::once(header.shoff(id)))

  + {
• replacement in elfedit/src/lib.rs at line 978
  [3.21596]→[3.21596:21684](∅→∅)
  − pub fn update_section(&mut self, name: &[u8], new: &[u8]) -> Result<usize, Error> {
  [3.21596]

  [3.21684]
  + fn update_section(&mut self, name: &[u8], new: &[u8]) -> Result<(), Error> {
• replacement in elfedit/src/lib.rs at line 985
  [3.21863]→[3.21863:21907](∅→∅)
  − self.find_section::<u64>(name)?
  [3.21863]

  [3.21907]
  + self.find_section::<u32>(name)?
• replacement in elfedit/src/lib.rs at line 1018
  [3.23018]→[3.23018:23036](∅→∅)
  − Ok(0)
  [3.23018]

  [3.23036]
  + Ok(())
• replacement in elfedit/src/lib.rs at line 1020
  [3.23053]→[3.23053:23129](∅→∅)
  − Ok(self.update_section_allocate(id, new, interp_i, off as u64))
  [3.23053]

  [3.23129]
  + Ok(self.update_section_allocate(id, new, interp_i))
• replacement in elfedit/src/lib.rs at line 1029
  [3.23266]→[3.23266:23301](∅→∅)
  − off: u64,

  − ) -> usize {
  [3.23266]

  [3.23301]
  + ) {
• edit in elfedit/src/lib.rs at line 1032
  [3.23365]→[3.23365:23435](∅→∅)
  − let shnum = h.shnum(id);

  − let class = self.id().class;
• replacement in elfedit/src/lib.rs at line 1033
  [3.23436]→[3.23436:23524](∅→∅)
  − // First find a large enough deleted section = gap

  − // between sections.
  [3.23436]

  [3.23524]
  + let mut sections: Vec<_> = (0..h.shnum(id))

  + .map(|p_| {

  + let sh = self.section(p_ as usize);

  + (sh.offset(id) as usize, sh.size(id) as usize, p_ as isize)

  + })

  + .collect();

  + sections.push((

  + h.shoff(id) as usize,

  + h.shentsize(id) as usize * h.shnum(id) as usize,

  + -1,

  + ));

  + sections.sort_by_key(|(o, _, _)| *o);
• replacement in elfedit/src/lib.rs at line 1046
  [3.23525]→[3.23525:24241](∅→∅)
  − let mut sections: Vec<_> = if class == Bits::B32 {

  − self.sections::<u32>()

  − .iter()

  − .map(|s| {

  − (

  − EndianT::endian(s.offset, id) as usize,

  − EndianT::endian(s.size, id) as usize,

  − )

  − })

  − .collect()

  − } else {

  − self.sections::<u64>()

  − .iter()

  − .map(|s| {

  − (

  − EndianT::endian(s.offset, id) as usize,

  − EndianT::endian(s.size, id) as usize,

  − )

  − })

  − .collect()

  − };

  − sections.sort();
  [3.23525]

  [3.24241]
  + let s = sections

  + .iter()

  + .position(|(_, _, i)| *i == interp_i as isize)

  + .unwrap();

  +

  + let mut last_vaddr = 0;

  + let mut page_size = 0;

  + let mut programs: Vec<_> = (0..h.phnum(id))

  + .map(|p_| {

  + let sh = self.program(p_ as usize);

  + last_vaddr = last_vaddr.max((sh.vaddr(id) + sh.memsz(id)) as usize);

  + let type_ = sh.type_(id);

  + if type_ == Pht::LOAD {

  + page_size = sh.align(id) as usize;

  + }

  + (

  + sh.offset(id) as usize,

  + sh.filesz(id) as usize,

  + type_,

  + sh.flags(id),

  + p_ as isize,

  + )

  + })

  + .collect();

  +

  + let rounded_last_vaddr = align_next(last_vaddr as usize, page_size);
• replacement in elfedit/src/lib.rs at line 1073
  [3.24242]→[3.24242:24449](∅→∅)
  − let extra_size = new_len;

  − let extra_size = match class {

  − Bits::B32 => (extra_size + 3) & !3,

  − Bits::B64 => (extra_size + 7) & !7,

  − _ => panic!(),

  − };
  [3.24242]

  [3.24449]
  + programs.sort_by_key(|(o, _, _, _, _)| *o);
• replacement in elfedit/src/lib.rs at line 1075
  [3.24450]→[3.24450:24560](∅→∅)
  − let mut end = 0;

  − let mut new_offset = h.shoff(id) as usize;

  − let mut gap = usize::MAX;
  [3.24450]

  [3.24560]
  + let s_off = sections[s].0;

  + let p = programs

  + .iter()

  + .position(|(o, e, t, _, _)| *o <= s_off && *o + *e > s_off && *t == Pht::LOAD)

  + .expect("Section isn't loaded, no need to do anything");
• replacement in elfedit/src/lib.rs at line 1081
  [3.24561]→[3.24561:24843](∅→∅)
  − for (off, len) in sections.iter() {

  − if end > 0 && *off >= end + extra_size && *off - (end + extra_size) < gap {

  − new_offset = end;

  − gap = *off - (end + extra_size)

  − }

  − end = align_next(*off + len, 8)

  − }
  [3.24561]

  [3.24843]
  + let s_len = sections[s].1;
• replacement in elfedit/src/lib.rs at line 1083
  [3.24844]→[3.24844:24954](∅→∅)
  − let shentsize = h.shentsize(id);

  − let section_table_len = shnum as usize * shentsize as usize;
  [3.24844]

  [3.24954]
  + let end0 = s_off + s_len;

  + let mut end = end0;
• replacement in elfedit/src/lib.rs at line 1086
  [3.24996]→[3.24996:25043](∅→∅)
  − let total = shoff + section_table_len;
  [3.24996]

  [3.25043]
  + let mut new_offset = shoff;
• replacement in elfedit/src/lib.rs at line 1088
  [3.25044]→[3.25044:25099](∅→∅)
  − assert!(extra_size + total <= self.map.len());
  [3.25044]

  [3.25099]
  + for (off, len, _) in sections.iter().skip(s + 1) {

  + if *off >= end + new_len {

  + // Is this the same segment ?

  + if end <= programs[p].0 + programs[p].1 {

  + new_offset = end;

  + break;

  + }

  + }

  + end = end.max(*off + *len)

  + }
• replacement in elfedit/src/lib.rs at line 1099
  [3.25100]→[3.25100:25168](∅→∅),[3.25168]→[3.25168:25256](∅→∅)
  − if new_offset == shoff {

  − // No space was found.

  − assert!(shoff as usize + extra_size + section_table_len <= self.map.len());
  [3.25100]

  [3.25256]
  + if new_offset < shoff {

  + // Just write the section here and return.
• edit in elfedit/src/lib.rs at line 1102
  [3.25277]→[3.25277:25333](∅→∅)
  − // Moving just the section header table
• replacement in elfedit/src/lib.rs at line 1103
  [3.25365]→[3.25365:25539](∅→∅)
  − self.map.as_ptr().add(shoff as usize),

  − self.map.as_mut_ptr().add(shoff as usize + extra_size),

  − section_table_len,
  [3.25365]

  [3.25539]
  + new.as_ptr(),

  + self.map.as_mut_ptr().add(new_offset),

  + new.len(),

  + )

  + }

  + let mut sec = self.section_mut(interp_i);

  + let addr = new_offset + sec.addr(id) as usize - sec.offset(id) as usize;

  + sec.set_addr(id, addr);

  + sec.set_offset(id, new_offset);

  + sec.set_size(id, new.len());

  + if new_offset == programs[p].0 + programs[p].1 {

  + // Extend segment

  + let mut p = self.program_mut(programs[p].4 as usize);

  + p.set_filesz(id, p.filesz(id) as usize + new.len());

  + p.set_memsz(id, p.memsz(id) as usize + new.len());

  + }

  + // If the section has its own segment, update that too.

  + for (o, l, _, _, p) in &programs {

  + if *o == s_off && *l == s_len {

  + let mut p = self.program_mut(*p as usize);

  + p.set_offset(id, new_offset);

  + p.set_filesz(id, new.len());

  + p.set_memsz(id, new.len());

  + p.set_vaddr(id, addr);

  + }

  + }

  + } else {

  + // Add a segment at the end, possibly moving the first

  + // section after the section header table.

  + let pht_end = h.phoff(id) as usize + h.phentsize(id) as usize * h.phnum(id) as usize;

  +

  + // Combien de sections doit-on déplacer pour ajouter notre

  + // segment ?

  +

  + let first_section_after_pht = sections

  + .iter()

  + .filter_map(|(o, _, _)| {

  + if *o >= pht_end as usize {

  + Some(*o)

  + } else {

  + None

  + }

  + })

  + .min()

  + .unwrap_or(0);

  +

  + let new_offset;

  +

  + if first_section_after_pht < pht_end + h.phentsize(id) as usize {

  + // In the absolute worst case, we need 3 new LOAD

  + // segments: our new one, and then one for each end of

  + // the sequence of sections we need to move to make

  + // room for the program headers.

  + let new_segments = 3;

  + let limit = pht_end + new_segments * h.phentsize(id) as usize;

  + let mut init = 0;

  + let mut end = 0;

  + let mut init_off = 0;

  + let mut end_off = 0;

  + for (n, (o, _, _)) in sections.iter().enumerate() {

  + if *o >= pht_end && init == 0 {

  + init = n;

  + init_off = *o;

  + }

  + if *o >= limit && end == 0 {

  + end = n;

  + end_off = *o;

  + }

  + }

  + let current_len = self.f.metadata().unwrap().len() as usize;

  + let rounded_len = align_next(current_len, page_size);

  + let rounded_moved =

  + align_next(end_off - init_off, page_size as usize);

  +

  + new_offset = rounded_len as usize + rounded_moved;

  + // New pages for the moved + new pages for new.

  + self.f

  + .set_len((rounded_len + rounded_moved + new.len()) as u64)

  + .unwrap();

  + self.map = unsafe { memmap::MmapOptions::new().map_mut(self.f).unwrap() };

  + unsafe {

  + std::ptr::copy(

  + self.map.as_ptr().add(init_off),

  + self.map.as_mut_ptr().add(rounded_len as usize),

  + end_off - init_off,

  + );

  + }

  + let mut pi = 0;

  + for s in init..end {

  + let sec_n = sections[s].2;

  + let mut sec = self.section_mut(sec_n as usize);

  + let new_offset = rounded_len as usize + sec.offset(id) as usize - init_off;

  + sec.set_offset(id, new_offset);

  + sec.set_addr(

  + id,

  + new_offset + rounded_last_vaddr - rounded_len as usize,

  + );

  + while pi < programs.len() && programs[pi].0 <= sections[s].0 {

  + if programs[pi].0 == sections[s].0 && programs[pi].2 != Pht::LOAD {

  + let mut p = self.program_mut(programs[pi].4 as usize);

  + p.set_offset(id, new_offset);

  + p.set_vaddr(

  + id,

  + new_offset + rounded_last_vaddr - rounded_len as usize,

  + );

  + }

  + pi += 1;

  + }

  + }

  +

  + self.add_load_segment(

  + id,

  + rounded_len as usize,

  + end_off - init_off,

  + rounded_last_vaddr,

  + 4,

  + page_size,
• replacement in elfedit/src/lib.rs at line 1221
  [3.25558]→[3.25558:25636](∅→∅)
  − self.header_mut().set_shoff(id, shoff as usize + extra_size);
  [3.25558]

  [3.25636]
  + last_vaddr = rounded_last_vaddr + rounded_moved as usize;

  + } else {

  + let current_len = self.f.metadata().unwrap().len() as usize;

  + let rounded_len = align_next(current_len, page_size);

  + new_offset = rounded_len;

  + // New pages for new.

  + self.f.set_len((rounded_len + new.len()) as u64).unwrap();

  + self.map = unsafe { memmap::MmapOptions::new().map_mut(self.f).unwrap() };
• edit in elfedit/src/lib.rs at line 1230
  [3.25650]→[3.25650:25660](∅→∅)
  − }
• replacement in elfedit/src/lib.rs at line 1231
  [3.25661]→[3.25661:25729](∅→∅),[3.25729]→[3.25729:26107](∅→∅)
  − assert!(new_offset as usize + new.len() <= self.map.len());

  − unsafe {

  − // Write the new value

  − self.map

  − .as_mut_ptr()

  − .add(new_offset as usize)

  − .write_bytes(0, extra_size);

  − std::ptr::copy(

  − new.as_ptr() as *const i8,

  − self.map.as_mut_ptr().add(new_offset as usize) as *mut i8,

  − new.len(),

  − );
  [3.25661]

  [3.26107]
  + let mut sec = self.section_mut(interp_i);

  + sec.set_offset(id, new_offset);

  + sec.set_size(id, new.len());

  + sec.set_addr(id, last_vaddr as usize);

  + unsafe {

  + std::ptr::copy(

  + new.as_ptr(),

  + self.map.as_mut_ptr().add(new_offset),

  + new.len(),

  + )

  + }

  +

  + self.add_load_segment(id, new_offset, new.len(), last_vaddr as usize, 4, page_size);
• edit in elfedit/src/lib.rs at line 1245
  [3.26117]

  [3.26117]
  + }
• replacement in elfedit/src/lib.rs at line 1247
  [3.26118]→[3.26118:26205](∅→∅),[3.26205]→[3.26205:26243](∅→∅),[3.26243]→[3.26243:26373](∅→∅),[3.26373]→[3.26373:26401](∅→∅),[3.26401]→[3.26401:26629](∅→∅),[3.26629]→[3.26629:26714](∅→∅)
  − // Update the section

  − let mut s = self.section_mut(interp_i as usize);

  − s.set_offset(id, new_offset);

  − s.set_size(id, new_len);

  −

  − // Do the same in the program header table

  − let phnum = self.header().phnum(id);

  − for i in 0..phnum {

  − let mut p = self.program_mut(i as usize);

  − let p_off = p.offset(id);

  − if p_off == off {

  − // the new offset is the old shoff

  − p.set_offset(id, new_offset as usize);

  − p.set_filesz(id, new_len);

  − p.set_memsz(id, new_len);
  [3.26118]

  [3.26714]
  + fn add_load_segment(

  + &mut self,

  + id: Endianness,

  + offset: usize,

  + len: usize,

  + vaddr: usize,

  + flags: u32,

  + align: usize,

  + ) {

  + let mut hh = self.header_mut();

  + let phentsize = hh.phentsize(id) as usize;

  + let phnum = hh.phnum(id);

  + hh.set_phnum(id, phnum + 1);

  + let mut p = self.program_mut(phnum as usize);

  + p.set_offset(id, offset);

  + p.set_memsz(id, len);

  + p.set_filesz(id, len);

  + p.set_vaddr(id, vaddr);

  + p.set_type(id, Pht::LOAD);

  + p.set_flags(id, flags);

  + p.set_align(id, align as u64);

  + for p in 0..phnum {

  + let mut p = self.program_mut(p as usize);

  + if p.type_(id) == Pht::PHDR {

  + p.set_filesz(id, p.filesz(id) as usize + phentsize);

  + p.set_memsz(id, p.memsz(id) as usize + phentsize);

  + break;
• edit in elfedit/src/lib.rs at line 1276
  [3.26738]→[3.26738:26757](∅→∅)
  − extra_size
• replacement in elfedit/src/lib.rs at line 1329
  [3.28615]→[3.28615:28672](∅→∅)
  − remove_trailing_needed_runpath(dynstr, dynamic);
  [3.28615]

  [3.28672]
  + remove_trailing_needed_runpath(parsed.data, dynstr, dynamic);

  + let id = self.id().data;
• replacement in elfedit/src/lib.rs at line 1333
  [3.28758]→[3.28758:28813](∅→∅)
  − set_runpath(dynstr, dynamic, &runpath)
  [3.28758]

  [3.28813]
  + set_runpath(id, dynstr, dynamic, &runpath)
• replacement in elfedit/src/lib.rs at line 1336
  [3.28844]→[3.28844:28904](∅→∅)
  − set_runpath(dynstr, dynamic, &self.new_runpath)
  [3.28844]

  [3.28904]
  + set_runpath(id, dynstr, dynamic, &self.new_runpath)
• edit in elfedit/src/lib.rs at line 1339
  [3.28915]

  [3.28915]
  + let id = self.id().data;
• replacement in elfedit/src/lib.rs at line 1341
  [3.28971]→[3.28971:29023](∅→∅)
  − retain_needed(dynstr, dynamic, needed);
  [3.28971]

  [3.29023]
  + retain_needed(id, dynstr, dynamic, needed);
• edit in elfedit/src/lib.rs at line 1346
  [3.29055]

  [3.29055]
  + /// Run the updates, potentially extending the underlying ELF file.
• edit in elfedit/src/lib.rs at line 1353
  [3.29314]→[3.29314:29453](∅→∅),[3.29453]→[3.29453:29493](∅→∅),[3.29493]→[3.29493:29494](∅→∅)
  − let extra_room = ((self.new_interp.len() + 7) & !7)

  − + dynstr_owned.len()

  − + dynamic_owned.as_bytes().len();

  − let f = self.f.take().unwrap();

  −
• replacement in elfedit/src/lib.rs at line 1356
  [3.29724]→[3.29724:29725](∅→∅),[3.29725]→[3.29725:29755](∅→∅),[3.29755]→[3.29755:29756](∅→∅),[3.29756]→[3.29756:29894](∅→∅)
  −

  − std::mem::drop(self);

  −

  − let current_len = f.metadata()?.len();

  − f.set_len(current_len + extra_room as u64)?;

  −

  − let mut elf = Elf::open(f)?;
  [3.29724]

  [3.29894]
  + let id = self.id().data;

  + if !new_runpath.is_empty() {

  + set_runpath(id, &mut dynstr_owned, &mut dynamic_owned, &new_runpath)

  + }
• edit in elfedit/src/lib.rs at line 1361
  [3.29895]→[3.29895:29922](∅→∅)
  − let mut extra = 0;
• replacement in elfedit/src/lib.rs at line 1362
  [3.29958]→[3.29958:30032](∅→∅)
  − extra += elf.update_section(b".interp", &new_interp).unwrap()
  [3.29958]

  [3.30032]
  + self.update_section(b".interp", &new_interp).unwrap()
• replacement in elfedit/src/lib.rs at line 1364
  [3.30042]→[3.30042:30156](∅→∅)
  − if !new_runpath.is_empty() {

  − set_runpath(&mut dynstr_owned, &mut dynamic_owned, &new_runpath)
  [3.30042]

  [3.30156]
  + if new_needed.is_some() || !new_runpath.is_empty() {

  + self.update_section(b".dynstr", &dynstr_owned).unwrap();

  + self

  + .update_section(b".dynamic", dynamic_owned.as_bytes())

  + .unwrap();
• replacement in elfedit/src/lib.rs at line 1371
  [3.30167]→[3.30167:30228](∅→∅),[3.30228]→[3.30228:30432](∅→∅)
  − if new_needed.is_some() || !new_runpath.is_empty() {

  − extra += elf.update_section(b".dynstr", &dynstr_owned).unwrap()

  − + elf

  − .update_section(b".dynamic", dynamic_owned.as_bytes())

  − .unwrap();
  [3.30167]

  [3.30432]
  + let id = self.id().data;

  +

  + match dynamic_owned {

  + OwnedDynamic::B32(ref mut v) => {

  + for t in v.iter_mut() {

  + self.update_dynamic::<u32>(id, t)

  + }

  + }

  + OwnedDynamic::B64(ref mut v) => {

  + for t in v.iter_mut() {

  + self.update_dynamic::<u64>(id, t)

  + }

  + }
• replacement in elfedit/src/lib.rs at line 1385
  [3.30442]→[3.30442:30490](∅→∅)
  − f.set_len(current_len + extra as u64)?;
  [3.30442]

  [3.30490]
  + self.update_section(b".dynamic", dynamic_owned.as_bytes())

  + .unwrap();

  +

  + // f.set_len(current_len + extra as u64)?;
• edit in elfedit/src/lib.rs at line 1392
  [3.30512]

  [3.30512]
  + fn update_dynamic<F: Flags>(&self, id: Endianness, f: &mut F::Dyn) {

  + if F::tag(id, *f) == F::dt_strtab() {

  + let s = self.find_section::<F>(b".dynstr").unwrap().unwrap();

  + let sec = self.section(s);

  + F::set_d_un(id, f, sec.addr(id) as usize)

  + } else if F::tag(id, *f) == F::dt_strsz() {

  + let s = self.find_section::<F>(b".dynstr").unwrap().unwrap();

  + let sec = self.section(s);

  + F::set_d_un(id, f, sec.size(id) as usize)

  + }

  + }

  +
• edit in elfedit/src/lib.rs at line 1418
  [3.30961]

  [3.30961]
  + data: Endianness,
• replacement in elfedit/src/lib.rs at line 1421
  [3.31010]→[3.31010:31032](∅→∅)
  − interp: &'a [u8],
  [3.31010]

  [3.31032]
  + interp: Option<&'a [u8]>,
• replacement in elfedit/src/lib.rs at line 1460
  [3.32039]→[3.32039:32135](∅→∅)
  − fn remove_trailing_needed_runpath_<F: Flags>(dynstr: &mut Vec<u8>, dynamic: &mut Vec<F::Dyn>) {
  [3.32039]

  [3.32135]
  + fn remove_trailing_needed_runpath_<F: Flags>(

  + id: Endianness,

  + dynstr: &mut Vec<u8>,

  + dynamic: &mut Vec<F::Dyn>,

  + ) {
• replacement in elfedit/src/lib.rs at line 1469
  [3.32241]→[3.32241:32320](∅→∅)
  − if F::tag(*x) == F::dt_needed() || F::tag(*x) == F::dt_runpath() {
  [3.32241]

  [3.32320]
  + if F::tag(id, *x) == F::dt_needed() || F::tag(id, *x) == F::dt_runpath() {
• replacement in elfedit/src/lib.rs at line 1476
  [3.32432]→[3.32432:32470](∅→∅)
  − off.sort_by_key(|x| F::d_un(*x));
  [3.32432]

  [3.32470]
  + off.sort_by_key(|x| F::d_un(id, *x));
• replacement in elfedit/src/lib.rs at line 1479
  [3.32562]→[3.32562:32647](∅→∅)
  − let c = CStr::from_bytes_until_nul(&dynstr[F::d_un(p) as usize..]).unwrap();
  [3.32562]

  [3.32647]
  + let c = CStr::from_bytes_until_nul(&dynstr[F::d_un(id, p) as usize..]).unwrap();
• replacement in elfedit/src/lib.rs at line 1481
  [3.32686]→[3.32686:32791](∅→∅)
  − if F::d_un(p) as usize + len >= dynstr.len() {

  − dynstr.truncate(F::d_un(p) as usize);
  [3.32686]

  [3.32791]
  + if F::d_un(id, p) as usize + len >= dynstr.len() {

  + dynstr.truncate(F::d_un(id, p) as usize);
• replacement in elfedit/src/lib.rs at line 1493
  [3.32948]→[3.32948:33034](∅→∅)
  − fn remove_trailing_needed_runpath(dynstr: &mut Vec<u8>, dynamic: &mut OwnedDynamic) {
  [3.32948]

  [3.33034]
  + fn remove_trailing_needed_runpath(

  + id: Endianness,

  + dynstr: &mut Vec<u8>,

  + dynamic: &mut OwnedDynamic,

  + ) {
• replacement in elfedit/src/lib.rs at line 1499
  [3.33054]→[3.33054:33220](∅→∅)
  − OwnedDynamic::B32(b) => remove_trailing_needed_runpath_::<u32>(dynstr, b),

  − OwnedDynamic::B64(b) => remove_trailing_needed_runpath_::<u64>(dynstr, b),
  [3.33054]

  [3.33220]
  + OwnedDynamic::B32(b) => remove_trailing_needed_runpath_::<u32>(id, dynstr, b),

  + OwnedDynamic::B64(b) => remove_trailing_needed_runpath_::<u64>(id, dynstr, b),
• replacement in elfedit/src/lib.rs at line 1504
  [3.33229]→[3.33229:33320](∅→∅)
  − fn set_runpath_<F: Flags>(dynstr: &mut Vec<u8>, dynamic: &mut Vec<F::Dyn>, rpath: &[u8]) {
  [3.33229]

  [3.33320]
  + fn set_runpath_<F: Flags>(

  + id: Endianness,

  + dynstr: &mut Vec<u8>,

  + dynamic: &mut Vec<F::Dyn>,

  + rpath: &[u8],

  + ) {
• replacement in elfedit/src/lib.rs at line 1512
  [3.33390]→[3.33390:33433](∅→∅)
  − if F::tag(*x) == F::dt_runpath() {
  [3.33390]

  [3.33433]
  + if F::tag(id, *x) == F::dt_runpath() {
• replacement in elfedit/src/lib.rs at line 1514
  [3.33468]→[3.33468:33522](∅→∅)
  − let current = &mut dynstr[F::d_un(*x)..];
  [3.33468]

  [3.33522]
  + let current = &mut dynstr[F::d_un(id, *x)..];
• replacement in elfedit/src/lib.rs at line 1525
  [3.34012]→[3.34012:34052](∅→∅)
  − F::set_d_un(x, offset);
  [3.34012]

  [3.34052]
  + F::set_d_un(id, x, offset);
• replacement in elfedit/src/lib.rs at line 1528
  [3.34086]→[3.34086:34133](∅→∅)
  − } else if F::tag(*x) != F::tag_nul() {
  [3.34086]

  [3.34133]
  + } else if F::tag(id, *x) != F::tag_nul() {
• replacement in elfedit/src/lib.rs at line 1534
  [3.34224]→[3.34224:34280](∅→∅)
  − dynamic.insert(n, F::dyn_(F::dt_runpath(), offset))
  [3.34224]

  [3.34280]
  + if F::tag(id, dynamic[dynamic.len() - 2]) == F::tag_nul() {

  + dynamic.pop();

  + }

  + dynamic.insert(n + 1, F::dyn_(id, F::dt_runpath(), offset));
• replacement in elfedit/src/lib.rs at line 1540
  [3.34283]→[3.34283:34379](∅→∅)
  − fn retain_needed(dynstr: &mut Vec<u8>, dynamic: &mut OwnedDynamic, needed: &mut Vec<Vec<u8>>) {
  [3.34283]

  [3.34379]
  + fn retain_needed(

  + id: Endianness,

  + dynstr: &mut Vec<u8>,

  + dynamic: &mut OwnedDynamic,

  + needed: &mut Vec<Vec<u8>>,

  + ) {
• replacement in elfedit/src/lib.rs at line 1547
  [3.34399]→[3.34399:34547](∅→∅)
  − OwnedDynamic::B32(b) => retain_needed_::<u32>(dynstr, b, needed),

  − OwnedDynamic::B64(b) => retain_needed_::<u64>(dynstr, b, needed),
  [3.34399]

  [3.34547]
  + OwnedDynamic::B32(b) => retain_needed_::<u32>(id, dynstr, b, needed),

  + OwnedDynamic::B64(b) => retain_needed_::<u64>(id, dynstr, b, needed),
• replacement in elfedit/src/lib.rs at line 1552
  [3.34556]→[3.34556:34655](∅→∅)
  − fn retain_needed_<F: Flags>(dynstr: &mut Vec<u8>, dynamic: &mut Vec<F::Dyn>, needed: &[Vec<u8>]) {
  [3.34556]

  [3.34655]
  + fn retain_needed_<F: Flags>(

  + id: Endianness,

  + dynstr: &mut Vec<u8>,

  + dynamic: &mut Vec<F::Dyn>,

  + needed: &[Vec<u8>],

  + ) {
• replacement in elfedit/src/lib.rs at line 1561
  [3.34778]→[3.34778:34855](∅→∅)
  − if F::tag(*d) == F::dt_needed() {

  − let off = F::d_un(*d);
  [3.34778]

  [3.34855]
  + if F::tag(id, *d) == F::dt_needed() {

  + let off = F::d_un(id, *d);
• replacement in elfedit/src/lib.rs at line 1575
  [3.35297]→[3.35297:35336](∅→∅)
  − if F::tag(d) == F::tag_nul() {
  [3.35297]

  [3.35336]
  + if F::tag(id, d) == F::tag_nul() {
• replacement in elfedit/src/lib.rs at line 1577
  [3.35355]→[3.35355:35403](∅→∅)
  − } else if F::tag(d) != F::dt_needed() {
  [3.35355]

  [3.35403]
  + } else if F::tag(id, d) != F::dt_needed() {
• replacement in elfedit/src/lib.rs at line 1581
  [3.35556]→[3.35556:35599](∅→∅)
  − F::set_d_un(&mut d, *off);
  [3.35556]

  [3.35599]
  + F::set_d_un(id, &mut d, *off);
• replacement in elfedit/src/lib.rs at line 1584
  [3.35656]→[3.35656:35728](∅→∅)
  − F::set_d_un(&mut d, dynstr.len() + extra_dynstr.len());
  [3.35656]

  [3.35728]
  + F::set_d_un(id, &mut d, dynstr.len() + extra_dynstr.len());
• replacement in elfedit/src/lib.rs at line 1593
  [3.35941]→[3.35941:36001](∅→∅)
  − new_dynamic.push(F::dyn_(F::dt_needed(), *off))
  [3.35941]

  [3.36001]
  + new_dynamic.push(F::dyn_(id, F::dt_needed(), *off))
• replacement in elfedit/src/lib.rs at line 1595
  [3.36018]→[3.36018:36108](∅→∅)
  − new_dynamic.push(F::dyn_(F::dt_needed(), dynstr.len() + extra_dynstr.len()));
  [3.36018]

  [3.36108]
  + new_dynamic.push(F::dyn_(

  + id,

  + F::dt_needed(),

  + dynstr.len() + extra_dynstr.len(),

  + ));
• replacement in elfedit/src/lib.rs at line 1605
  [3.36211]→[3.36211:36259](∅→∅)
  − new_dynamic.push(F::dyn_(F::tag_nul(), 0));
  [3.36211]

  [3.36259]
  + new_dynamic.push(F::dyn_(id, F::tag_nul(), 0));
• replacement in elfedit/src/lib.rs at line 1609
  [3.36396]→[3.36396:36448](∅→∅)
  − new_dynamic.push(F::dyn_(F::tag_nul(), 0));
  [3.36396]

  [3.36448]
  + new_dynamic.push(F::dyn_(id, F::tag_nul(), 0));
• replacement in elfedit/src/lib.rs at line 1614
  [3.36485]→[3.36485:36566](∅→∅)
  − fn set_runpath(dynstr: &mut Vec<u8>, dynamic: &mut OwnedDynamic, rpath: &[u8]) {
  [3.36485]

  [3.36566]
  + fn set_runpath(id: Endianness, dynstr: &mut Vec<u8>, dynamic: &mut OwnedDynamic, rpath: &[u8]) {
• replacement in elfedit/src/lib.rs at line 1616
  [3.36586]→[3.36586:36728](∅→∅)
  − OwnedDynamic::B32(b) => set_runpath_::<u32>(dynstr, b, rpath),

  − OwnedDynamic::B64(b) => set_runpath_::<u64>(dynstr, b, rpath),
  [3.36586]

  [3.36728]
  + OwnedDynamic::B32(b) => set_runpath_::<u32>(id, dynstr, b, rpath),

  + OwnedDynamic::B64(b) => set_runpath_::<u64>(id, dynstr, b, rpath),
• replacement in elfedit/src/lib.rs at line 1651
  [3.37730]→[3.37730:37867](∅→∅)
  − if d.tag == <u64 as Flags>::dt_runpath() {

  − rpath = Some(self.dynstr.name(d.d_un as usize)?);
  [3.37730]

  [3.37867]
  + if EndianT::endian(d.tag, self.data) == <u64 as Flags>::dt_runpath() {

  + rpath = Some(

  + self.dynstr

  + .name(EndianT::endian(d.d_un, self.data) as usize)?,

  + );
• replacement in elfedit/src/lib.rs at line 1661
  [3.37989]→[3.37989:38126](∅→∅)
  − if d.tag == <u32 as Flags>::dt_runpath() {

  − rpath = Some(self.dynstr.name(d.d_un as usize)?);
  [3.37989]

  [3.38126]
  + if EndianT::endian(d.tag, self.data) == <u32 as Flags>::dt_runpath() {

  + rpath = Some(

  + self.dynstr

  + .name(EndianT::endian(d.d_un, self.data) as usize)?,

  + );
• replacement in elfedit/src/lib.rs at line 1683
  [3.38671]→[3.38671:38789](∅→∅)
  − if d.tag == <u64 as Flags>::dt_needed() {

  − Some(self.dynstr.name(d.d_un as usize))
  [3.38671]

  [3.38789]
  + if EndianT::endian(d.tag, self.data) == <u64 as Flags>::dt_needed() {

  + Some(

  + self.dynstr

  + .name(EndianT::endian(d.d_un, self.data) as usize),

  + )
• replacement in elfedit/src/lib.rs at line 1693
  [3.38947]→[3.38947:39065](∅→∅)
  − if d.tag == <u32 as Flags>::dt_needed() {

  − Some(self.dynstr.name(d.d_un as usize))
  [3.38947]

  [3.39065]
  + if EndianT::endian(d.tag, self.data) == <u32 as Flags>::dt_needed() {

  + Some(

  + self.dynstr

  + .name(EndianT::endian(d.d_un, self.data) as usize),

  + )
• replacement in elfedit/src/lib.rs at line 1718
  [3.39642]→[3.39642:39762](∅→∅)
  − pub fn interpreter(&self) -> Result<&'a CStr, Error> {

  − Ok(CStr::from_bytes_until_nul(self.interp).unwrap())
  [3.39642]

  [3.39762]
  + pub fn interpreter(&self) -> Result<Option<&'a CStr>, Error> {

  + Ok(self.interp.map(|x| CStr::from_bytes_until_nul(x).unwrap()))
• edit in elfedit/src/lib.rs at line 1729
  [3.39860]→[3.39860:40680](∅→∅),[3.40680]→[3.40680:40683](∅→∅)
  − impl<'a> Iterator for Dynamic<'a> {

  − type Item = Elf64Dyn;

  − fn next(&mut self) -> Option<Self::Item> {

  − match self {

  − Dynamic::B32(x) => {

  − if x.is_empty() {

  − None

  − } else {

  − let (a, b) = x.split_at(1);

  − *x = b;

  − let a = a[0];

  − Some(Elf64Dyn {

  − tag: DynTag64(a.tag.0 as u64),

  − d_un: a.d_un as u64,

  − })

  − }

  − }

  − Dynamic::B64(x) => {

  − if x.is_empty() {

  − None

  − } else {

  − let (a, b) = x.split_at(1);

  − *x = b;

  − Some(a[0])

  − }

  − }

  − }

  − }

  − }

  −
• replacement in elfedit/src/lib.rs at line 1744
  [3.41093]→[3.41093:41151](∅→∅)
  − fn dyn_(tag: Self::DynTag, d_un: usize) -> Self::Dyn;
  [3.41093]

  [3.41151]
  + fn dyn_(id: Endianness, tag: Self::DynTag, d_un: usize) -> Self::Dyn;
• replacement in elfedit/src/lib.rs at line 1746
  [3.41152]→[3.41152:41276](∅→∅)
  − fn d_un(_: Self::Dyn) -> usize;

  − fn set_d_un(_: &mut Self::Dyn, _: usize);

  − fn tag(_: Self::Dyn) -> Self::DynTag;
  [3.41152]

  [3.41276]
  + fn d_un(id: Endianness, _: Self::Dyn) -> usize;

  + fn set_d_un(id: Endianness, _: &mut Self::Dyn, _: usize);

  + fn tag(id: Endianness, _: Self::Dyn) -> Self::DynTag;
• edit in elfedit/src/lib.rs at line 1753
  [3.41378]

  [3.41378]
  + }

  +

  + fn dt_strsz() -> Self::DynTag {

  + Self::DynTag::from(0x0a)
• edit in elfedit/src/lib.rs at line 1759
  [3.41385]

  [3.41385]
  + fn dt_strtab() -> Self::DynTag {

  + Self::DynTag::from(0x5)

  + }

  +
• replacement in elfedit/src/lib.rs at line 1764
  [3.41423]→[3.41423:41454](∅→∅)
  − Self::DynTag::from(29)
  [3.41423]

  [3.41454]
  + Self::DynTag::from(0x1d)
• edit in elfedit/src/lib.rs at line 1771
  [3.41537]

  [3.41537]
  + impl EndianT for DynTag32 {

  + fn endian(e: Endian<Self>, id: Endianness) -> Self {

  + DynTag32(EndianT::endian(Endian(e.0 .0), id))

  + }

  + }

  +
• edit in elfedit/src/lib.rs at line 1780
  [3.41634]

  [3.41634]
  + }

  + }

  +

  + impl EndianT for DynTag64 {

  + fn endian(e: Endian<Self>, id: Endianness) -> Self {

  + DynTag64(EndianT::endian(Endian(e.0 .0), id))
• replacement in elfedit/src/lib.rs at line 1804
  [3.41930]→[3.41930:41989](∅→∅)
  − fn dyn_(tag: Self::DynTag, d_un: usize) -> Self::Dyn {
  [3.41930]

  [3.41989]
  + fn dyn_(id: Endianness, tag: Self::DynTag, d_un: usize) -> Self::Dyn {
• replacement in elfedit/src/lib.rs at line 1806
  [3.42008]→[3.42008:42056](∅→∅)
  − tag,

  − d_un: d_un as u32,
  [3.42008]

  [3.42056]
  + tag: <Endian<DynTag32>>::from(id, tag),

  + d_un: <Endian<u32>>::from(id, d_un as u32),
• replacement in elfedit/src/lib.rs at line 1810
  [3.42072]→[3.42072:42149](∅→∅)
  − fn set_d_un(x: &mut Self::Dyn, val: usize) {

  − x.d_un = val as u32
  [3.42072]

  [3.42149]
  + fn set_d_un(id: Endianness, x: &mut Self::Dyn, val: usize) {

  + x.d_un = <Endian<u32>>::from(id, val as u32)
• replacement in elfedit/src/lib.rs at line 1817
  [3.42217]→[3.42217:42278](∅→∅)
  − fn d_un(x: Self::Dyn) -> usize {

  − x.d_un as usize
  [3.42217]

  [3.42278]
  + fn d_un(id: Endianness, x: Self::Dyn) -> usize {

  + EndianT::endian(x.d_un, id) as usize
• replacement in elfedit/src/lib.rs at line 1820
  [3.42284]→[3.42284:42341](∅→∅)
  − fn tag(x: Self::Dyn) -> Self::DynTag {

  − x.tag
  [3.42284]

  [3.42341]
  + fn tag(id: Endianness, x: Self::Dyn) -> Self::DynTag {

  + EndianT::endian(x.tag, id)
• replacement in elfedit/src/lib.rs at line 1831
  [3.42464]→[3.42464:42523](∅→∅)
  − fn dyn_(tag: Self::DynTag, d_un: usize) -> Self::Dyn {
  [3.42464]

  [3.42523]
  + fn dyn_(e: Endianness, tag: Self::DynTag, d_un: usize) -> Self::Dyn {
• replacement in elfedit/src/lib.rs at line 1833
  [3.42542]→[3.42542:42590](∅→∅)
  − tag,

  − d_un: d_un as u64,
  [3.42542]

  [3.42590]
  + tag: <Endian<DynTag64>>::from(e, tag),

  + d_un: <Endian<u64>>::from(e, d_un as u64),
• replacement in elfedit/src/lib.rs at line 1837
  [3.42606]→[3.42606:42683](∅→∅)
  − fn set_d_un(x: &mut Self::Dyn, val: usize) {

  − x.d_un = val as u64
  [3.42606]

  [3.42683]
  + fn set_d_un(id: Endianness, x: &mut Self::Dyn, val: usize) {

  + x.d_un = <Endian<u64>>::from(id, val as u64)
• replacement in elfedit/src/lib.rs at line 1844
  [3.42751]→[3.42751:42812](∅→∅)
  − fn d_un(x: Self::Dyn) -> usize {

  − x.d_un as usize
  [3.42751]

  [3.42812]
  + fn d_un(id: Endianness, x: Self::Dyn) -> usize {

  + EndianT::endian(x.d_un, id) as usize
• replacement in elfedit/src/lib.rs at line 1847
  [3.42818]→[3.42818:42875](∅→∅)
  − fn tag(x: Self::Dyn) -> Self::DynTag {

  − x.tag
  [3.42818]

  [3.42875]
  + fn tag(id: Endianness, x: Self::Dyn) -> Self::DynTag {

  + EndianT::endian(x.tag, id)
• replacement in elfedit/src/lib.rs at line 1854
  [3.42953]→[3.42953:42987](∅→∅)
  − tag: DynTag32,

  − d_un: u32,
  [3.42953]

  [3.42987]
  + tag: Endian<DynTag32>,

  + d_un: Endian<u32>,
• replacement in elfedit/src/lib.rs at line 1860
  [3.43059]→[3.43059:43093](∅→∅)
  − tag: DynTag64,

  − d_un: u64,
  [3.43059]

  [3.43093]
  + tag: Endian<DynTag64>,

  + d_un: Endian<u64>,
• replacement in elfedit/src/lib.rs at line 1892
  [3.43684]→[3.43684:43742](∅→∅)
  − fn set_shoff(&mut self, id: Endianness, off: usize) {
  [3.43684]

  [3.43742]
  + pub fn set_phnum(&mut self, id: Endianness, off: u16) {

  + match self {

  + HeaderMut_::B32(h) => h.phnum = <Endian<u16>>::from(id, off),

  + HeaderMut_::B64(h) => h.phnum = <Endian<u16>>::from(id, off),

  + }

  + }

  +

  + pub fn phnum(&self, id: Endianness) -> u16 {

  + match self {

  + HeaderMut_::B32(h) => EndianT::endian(h.phnum, id),

  + HeaderMut_::B64(h) => EndianT::endian(h.phnum, id),

  + }

  + }

  + pub fn phentsize(&self, id: Endianness) -> u16 {
• replacement in elfedit/src/lib.rs at line 1907
  [3.43763]→[3.43763:43925](∅→∅)
  − HeaderMut_::B32(h) => h.shoff = <Endian<u32>>::from(id, off as u32),

  − HeaderMut_::B64(h) => h.shoff = <Endian<u64>>::from(id, off as u64),
  [3.43763]

  [3.43925]
  + HeaderMut_::B32(h) => EndianT::endian(h.phentsize, id),

  + HeaderMut_::B64(h) => EndianT::endian(h.phentsize, id),
• replacement in elfedit/src/lib.rs at line 1928
  [3.44386]→[3.44386:44431](∅→∅)
  − fn shoff(&self, id: Endianness) -> u64 {
  [3.44386]

  [3.44431]
  + pub fn shoff(&self, id: Endianness) -> u64 {
• edit in elfedit/src/lib.rs at line 1963
  [3.45450]
  +

  + unsafe fn dynamic_from_raw<'a>(class: Bits, ptr: *const u8, size: usize) -> Dynamic<'a> {

  + match class {

  + Bits::B32 => {

  + assert_eq!((ptr as usize) % std::mem::align_of::<Elf32Dyn>(), 0);

  + Dynamic::B32(unsafe { std::slice::from_raw_parts(

  + ptr as *const Elf32Dyn,

  + size / std::mem::size_of::<Elf32Dyn>(),

  + ) })

  + }

  + Bits::B64 => {

  + assert_eq!((ptr as usize) % std::mem::align_of::<Elf64Dyn>(), 0);

  + Dynamic::B64(unsafe {std::slice::from_raw_parts(

  + ptr as *const Elf64Dyn,

  + size / std::mem::size_of::<Elf64Dyn>(),

  + )})

  + }

  + _ => panic!(),

  + }

  + }
• edit in elfedit/Cargo.toml at line 12
  [3.46701]

  [3.46701]
  +
• edit in elfedit/Cargo.toml at line 15
  [3.46733]→[3.46733:46753](∅→∅)
  − tempfile = "3.19.1"