diff --git a/crates/examples/src/bin/convert.rs b/crates/examples/src/bin/convert.rs
index b673106d..7bdc9f9c 100644
--- a/crates/examples/src/bin/convert.rs
+++ b/crates/examples/src/bin/convert.rs
@@ -9,7 +9,10 @@
 use gimli::write::Writer;
 use object::{Object, ObjectSection};
 use std::io::Write;
-use std::{borrow, env, error, fs, io};
+use std::{borrow, env, error, fmt, fs, io};
+
+trait Reader: gimli::Reader<Offset = usize> + fmt::Debug {}
+impl<T: gimli::Reader<Offset = usize> + fmt::Debug> Reader for T {}
 
 fn main() -> Result<(), Box<dyn error::Error>> {
     let mut args = env::args_os();
@@ -126,7 +129,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
     Ok(())
 }
 
-fn convert_dwarf<R: gimli::Reader<Offset = usize>, W: gimli::write::Writer>(
+fn convert_dwarf<R: Reader, W: gimli::write::Writer>(
     read_dwarf: &gimli::Dwarf<R>,
     dwp: Option<&gimli::DwarfPackage<R>>,
     write_sections: &mut gimli::write::Sections<W>,
@@ -169,7 +172,7 @@ fn convert_dwarf<R: gimli::Reader<Offset = usize>, W: gimli::write::Writer>(
     Ok(())
 }
 
-fn convert_unit<'a, R: gimli::Reader<Offset = usize>, W: gimli::write::Writer>(
+fn convert_unit<'a, R: Reader, W: gimli::write::Writer>(
     unit: &mut gimli::write::ConvertUnit<'a, R>,
     root_entry: gimli::write::ConvertUnitEntry<'a, R>,
     skeleton_root_entry: Option<&gimli::write::ConvertUnitEntry<'_, R>>,
@@ -210,7 +213,7 @@ fn convert_unit<'a, R: gimli::Reader<Offset = usize>, W: gimli::write::Writer>(
     Ok(())
 }
 
-fn convert_attributes<R: gimli::Reader<Offset = usize>>(
+fn convert_attributes<R: Reader>(
     unit: &mut gimli::write::ConvertUnit<'_, R>,
     id: gimli::write::UnitEntryId,
     entry: &gimli::write::ConvertUnitEntry<'_, R>,
@@ -234,7 +237,7 @@ fn convert_attributes<R: gimli::Reader<Offset = usize>>(
     }
 }
 
-fn filter_dwarf<R: gimli::Reader<Offset = usize>>(
+fn filter_dwarf<R: Reader>(
     dwarf: &gimli::read::Dwarf<R>,
 ) -> gimli::write::ConvertResult<gimli::write::FilterUnitSection<'_, R>> {
     // Walk the DIE tree. This will automatically record relationships between DIEs based
@@ -256,7 +259,7 @@ fn filter_dwarf<R: gimli::Reader<Offset = usize>>(
 }
 
 /// Use heuristics to determine if an entry is dead code.
-fn need_entry<R: gimli::Reader<Offset = usize>>(
+fn need_entry<R: Reader>(
     entry: &gimli::write::FilterUnitEntry<'_, R>,
 ) -> gimli::write::ConvertResult<bool> {
     match entry.parent_tag {
@@ -371,7 +374,7 @@ fn need_entry<R: gimli::Reader<Offset = usize>>(
     Ok(false)
 }
 
-fn is_tombstone_address<R: gimli::Reader<Offset = usize>>(
+fn is_tombstone_address<R: Reader>(
     entry: &gimli::write::FilterUnitEntry<'_, R>,
     address: u64,
 ) -> bool {
diff --git a/crates/examples/src/bin/dwarfdump.rs b/crates/examples/src/bin/dwarfdump.rs
index d69c1513..13cd7b3a 100644
--- a/crates/examples/src/bin/dwarfdump.rs
+++ b/crates/examples/src/bin/dwarfdump.rs
@@ -197,7 +197,6 @@ struct Flags<'a> {
     dwp: bool,
     dwo_parent: Option<object::File<'a>>,
     sup: Option<object::File<'a>>,
-    raw: bool,
     info_offset: Option<gimli::DebugInfoOffset>,
     match_units: Option<Regex>,
 }
@@ -240,7 +239,6 @@ fn main() {
         "use the specified file as the parent of the dwo or dwp (e.g. for .debug_addr)",
         "library path",
     );
-    opts.optflag("", "raw", "print raw data values");
     opts.optopt(
         "u",
         "match-units",
@@ -320,9 +318,6 @@ fn main() {
     if matches.opt_present("dwp") {
         flags.dwp = true;
     }
-    if matches.opt_present("raw") {
-        flags.raw = true;
-    }
     if all {
         // .eh_frame is excluded even when printing all information.
         // cosmetic flags like -G must be set explicitly too.
@@ -1241,25 +1236,19 @@ fn dump_entries<R: Reader, W: Write>(
             } else {
                 write!(w, "{:27} ", attr.name())?;
             }
-            if flags.raw {
-                writeln!(w, "{:?}", attr.raw_value())?;
-            } else {
-                match dump_attr_value(w, &attr, unit) {
-                    Ok(_) => (),
-                    Err(err) => {
-                        writeln_error(w, unit.dwarf, err, "Failed to dump attribute value")?
-                    }
-                };
-                // dump_attr_value only prints the offset for the macro info attribute.
-                // The content is too long to print inline, so store the offset to print later.
-                if attr.name() == gimli::DW_AT_macro_info {
-                    if let gimli::AttributeValue::DebugMacinfoRef(offset) = attr.value() {
-                        deferred_macinfo.push(offset);
-                    }
-                } else if attr.name() == gimli::DW_AT_macros {
-                    if let gimli::AttributeValue::DebugMacroRef(offset) = attr.value() {
-                        deferred_macros.push(offset);
-                    }
+            match dump_attr_value(w, &attr, unit) {
+                Ok(_) => (),
+                Err(err) => writeln_error(w, unit.dwarf, err, "Failed to dump attribute value")?,
+            };
+            // dump_attr_value only prints the offset for the macro info attribute.
+            // The content is too long to print inline, so store the offset to print later.
+            if attr.name() == gimli::DW_AT_macro_info {
+                if let gimli::AttributeValue::DebugMacinfoRef(offset) = attr.value() {
+                    deferred_macinfo.push(offset);
+                }
+            } else if attr.name() == gimli::DW_AT_macros {
+                if let gimli::AttributeValue::DebugMacroRef(offset) = attr.value() {
+                    deferred_macros.push(offset);
                 }
             }
         }
@@ -1299,18 +1288,18 @@ fn dump_attr_value<R: Reader, W: Write>(
         gimli::AttributeValue::Data1(_)
         | gimli::AttributeValue::Data2(_)
         | gimli::AttributeValue::Data4(_)
-        | gimli::AttributeValue::Data8(_)
-        | gimli::AttributeValue::Data16(_) => {
-            if let (Some(udata), Some(sdata)) = (attr.udata_value(), attr.sdata_value()) {
-                if sdata >= 0 {
-                    writeln!(w, "{}", udata)?;
-                } else {
-                    writeln!(w, "{} ({})", udata, sdata)?;
-                }
+        | gimli::AttributeValue::Data8(_) => {
+            let udata = attr.udata_value().unwrap();
+            let sdata = attr.sdata_value().unwrap();
+            if sdata >= 0 {
+                writeln!(w, "{}", udata)?;
             } else {
-                writeln!(w, "{:?}", value)?;
+                writeln!(w, "{} ({})", udata, sdata)?;
             }
         }
+        gimli::AttributeValue::Data16(data) => {
+            writeln!(w, "0x{:x}", data)?;
+        }
         gimli::AttributeValue::Sdata(data) => {
             match attr.name() {
                 gimli::DW_AT_data_member_location => {
@@ -2158,7 +2147,7 @@ fn dump_line_program<R: Reader, W: Write>(w: &mut W, unit: gimli::UnitRef<R>) ->
                         write!(w, "Unknown {} with operand {}", opcode, arg)
                     }
                     LineInstruction::UnknownStandardN(opcode, ref args) => {
-                        write!(w, "Unknown {} with operands {:?}", opcode, args)
+                        write!(w, "Unknown {} with operands {:?}", opcode, args.to_slice()?)
                     }
                     LineInstruction::EndSequence => write!(w, "{}", constants::DW_LNE_end_sequence),
                     LineInstruction::SetAddress(address) => {
diff --git a/src/read/cfi.rs b/src/read/cfi.rs
index 81fa455b..f8d7b709 100644
--- a/src/read/cfi.rs
+++ b/src/read/cfi.rs
@@ -565,7 +565,7 @@ pub enum CieOffsetEncoding {
 /// An offset into an `UnwindSection`.
 //
 // Needed to avoid conflicting implementations of `Into<T>`.
-pub trait UnwindOffset<T = usize>: Copy + Debug + Eq + From<T>
+pub trait UnwindOffset<T = usize>: Copy + Eq + From<T>
 where
     T: ReaderOffset,
 {
@@ -632,10 +632,14 @@ pub trait _UnwindSectionPrivate<R: Reader> {
 /// A section holding unwind information: either `.debug_frame` or
 /// `.eh_frame`. See [`DebugFrame`](./struct.DebugFrame.html) and
 /// [`EhFrame`](./struct.EhFrame.html) respectively.
-pub trait UnwindSection<R: Reader>: Clone + Debug + _UnwindSectionPrivate<R> {
+pub trait UnwindSection<R, O = <R as Reader>::Offset>: Clone + _UnwindSectionPrivate<R>
+where
+    R: Reader<Offset = O>,
+    O: ReaderOffset,
+{
     /// The offset type associated with this CFI section. Either
     /// `DebugFrameOffset` or `EhFrameOffset`.
-    type Offset: UnwindOffset<R::Offset>;
+    type Offset: UnwindOffset<O>;
 
     /// Iterate over the `CommonInformationEntry`s and `FrameDescriptionEntry`s
     /// in this `.debug_frame` section.
@@ -989,10 +993,11 @@ impl BaseAddresses {
 /// # }
 /// ```
 #[derive(Clone, Debug)]
-pub struct CfiEntriesIter<'bases, Section, R>
+pub struct CfiEntriesIter<'bases, Section, R, Offset = <R as Reader>::Offset>
 where
-    R: Reader,
-    Section: UnwindSection<R>,
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+    Section: UnwindSection<R, Offset>,
 {
     section: Section,
     bases: &'bases BaseAddresses,
@@ -1062,17 +1067,24 @@ where
 
 /// Either a `CommonInformationEntry` (CIE) or a `FrameDescriptionEntry` (FDE).
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub enum CieOrFde<'bases, Section, R>
-where
-    R: Reader,
-    Section: UnwindSection<R>,
+pub enum CieOrFde<
+    'bases,
+    Section,
+    R,
+    Offset = <R as Reader>::Offset,
+    SectionOffset = <Section as UnwindSection<R, Offset>>::Offset,
+> where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+    Section: UnwindSection<R, Offset, Offset = SectionOffset>,
+    SectionOffset: UnwindOffset<Offset>,
 {
     /// This CFI entry is a `CommonInformationEntry`.
-    Cie(CommonInformationEntry<R>),
+    Cie(CommonInformationEntry<R, Offset>),
     /// This CFI entry is a `FrameDescriptionEntry`, however fully parsing it
     /// requires parsing its CIE first, so it is left in a partially parsed
     /// state.
-    Fde(PartialFrameDescriptionEntry<'bases, Section, R>),
+    Fde(PartialFrameDescriptionEntry<'bases, Section, R, Offset, SectionOffset>),
 }
 
 fn parse_cfi_entry<'bases, Section, R>(
@@ -1520,15 +1532,22 @@ impl<R: Reader> CommonInformationEntry<R> {
 ///
 /// Fully parsing this FDE requires first parsing its CIE.
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct PartialFrameDescriptionEntry<'bases, Section, R>
-where
-    R: Reader,
-    Section: UnwindSection<R>,
+pub struct PartialFrameDescriptionEntry<
+    'bases,
+    Section,
+    R,
+    Offset = <R as Reader>::Offset,
+    SectionOffset = <Section as UnwindSection<R, Offset>>::Offset,
+> where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+    Section: UnwindSection<R, Offset, Offset = SectionOffset>,
+    SectionOffset: UnwindOffset<Offset>,
 {
-    offset: R::Offset,
-    length: R::Offset,
+    offset: Offset,
+    length: Offset,
     format: Format,
-    cie_offset: Section::Offset,
+    cie_offset: SectionOffset,
     rest: R,
     section: Section,
     bases: &'bases BaseAddresses,
@@ -1973,7 +1992,7 @@ where
 
 impl<T, S> Debug for UnwindContext<T, S>
 where
-    T: ReaderOffset,
+    T: ReaderOffset + Debug,
     S: UnwindContextStorage<T>,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -2537,7 +2556,7 @@ where
 
 impl<T, S> Debug for RegisterRuleMap<T, S>
 where
-    T: ReaderOffset,
+    T: ReaderOffset + Debug,
     S: UnwindContextStorage<T>,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -2710,7 +2729,7 @@ where
 
 impl<T, S> Debug for UnwindTableRow<T, S>
 where
-    T: ReaderOffset,
+    T: ReaderOffset + Debug,
     S: UnwindContextStorage<T>,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -3743,7 +3762,7 @@ mod tests {
         fn endian<'input, E>(self) -> Endian
         where
             E: Endianity,
-            T: UnwindSection<EndianSlice<'input, E>>,
+            T: UnwindSection<EndianSlice<'input, E>, usize>,
             T::Offset: UnwindOffset<usize>,
         {
             if E::default().is_big_endian() {
@@ -3756,7 +3775,7 @@ mod tests {
         fn section<'input, E>(self, contents: &'input [u8]) -> T
         where
             E: Endianity,
-            T: UnwindSection<EndianSlice<'input, E>> + ReadSection<EndianSlice<'input, E>>,
+            T: UnwindSection<EndianSlice<'input, E>, usize> + ReadSection<EndianSlice<'input, E>>,
             T::Offset: UnwindOffset<usize>,
         {
             EndianSlice::new(contents, E::default()).into()
@@ -3805,7 +3824,7 @@ mod tests {
         ) -> Self
         where
             E: Endianity,
-            T: UnwindSection<EndianSlice<'input, E>>,
+            T: UnwindSection<EndianSlice<'input, E>, usize>,
             T::Offset: UnwindOffset;
         fn fde<'a, 'input, E, T, L>(
             self,
@@ -3815,7 +3834,7 @@ mod tests {
         ) -> Self
         where
             E: Endianity,
-            T: UnwindSection<EndianSlice<'input, E>>,
+            T: UnwindSection<EndianSlice<'input, E>, usize>,
             T::Offset: UnwindOffset,
             L: ToLabelOrNum<'a, u64>;
     }
@@ -3829,7 +3848,7 @@ mod tests {
         ) -> Self
         where
             E: Endianity,
-            T: UnwindSection<EndianSlice<'input, E>>,
+            T: UnwindSection<EndianSlice<'input, E>, usize>,
             T::Offset: UnwindOffset,
         {
             cie.offset = self.size() as _;
@@ -3881,7 +3900,7 @@ mod tests {
         ) -> Self
         where
             E: Endianity,
-            T: UnwindSection<EndianSlice<'input, E>>,
+            T: UnwindSection<EndianSlice<'input, E>, usize>,
             T::Offset: UnwindOffset,
             L: ToLabelOrNum<'a, u64>,
         {
diff --git a/src/read/dwarf.rs b/src/read/dwarf.rs
index 4a725fb7..b5147213 100644
--- a/src/read/dwarf.rs
+++ b/src/read/dwarf.rs
@@ -1425,7 +1425,7 @@ pub struct UnitRef<'a, R: Reader> {
     pub dwarf: &'a Dwarf<R>,
 
     /// The `Unit` being referenced.
-    pub unit: &'a Unit<R>,
+    pub unit: &'a Unit<R, R::Offset>,
 }
 
 impl<'a, R: Reader> Clone for UnitRef<'a, R> {
@@ -1610,12 +1610,12 @@ impl<'a, R: Reader> UnitRef<'a, R> {
 ///
 /// Returned by `Dwarf::die_ranges` and `Dwarf::unit_ranges`.
 #[derive(Debug)]
-pub struct RangeIter<R: Reader>(RangeIterInner<R>);
+pub struct RangeIter<R: Reader, Offset = <R as Reader>::Offset>(RangeIterInner<R, Offset>);
 
 #[derive(Debug)]
-enum RangeIterInner<R: Reader> {
+enum RangeIterInner<R: Reader, Offset = <R as Reader>::Offset> {
     Single(Option<Range>),
-    List(RngListIter<R>),
+    List(RngListIter<R, Offset>),
 }
 
 impl<R: Reader> Default for RangeIter<R> {
diff --git a/src/read/endian_reader.rs b/src/read/endian_reader.rs
index 5e65b4d1..96753344 100644
--- a/src/read/endian_reader.rs
+++ b/src/read/endian_reader.rs
@@ -118,11 +118,7 @@ pub type EndianArcSlice<Endian> = EndianReader<Endian, Arc<[u8]>>;
 /// # fn test(_: &MmapFileReader<gimli::NativeEndian>) { }
 /// ```
 #[derive(Debug, Clone, Copy)]
-pub struct EndianReader<Endian, T>
-where
-    Endian: Endianity,
-    T: CloneStableDeref<Target = [u8]> + Debug,
-{
+pub struct EndianReader<Endian, T> {
     range: SubRange<T>,
     endian: Endian,
 }
@@ -130,8 +126,8 @@ where
 impl<Endian, T1, T2> PartialEq<EndianReader<Endian, T2>> for EndianReader<Endian, T1>
 where
     Endian: Endianity,
-    T1: CloneStableDeref<Target = [u8]> + Debug,
-    T2: CloneStableDeref<Target = [u8]> + Debug,
+    T1: CloneStableDeref<Target = [u8]>,
+    T2: CloneStableDeref<Target = [u8]>,
 {
     fn eq(&self, rhs: &EndianReader<Endian, T2>) -> bool {
         self.bytes() == rhs.bytes()
@@ -141,14 +137,14 @@ where
 impl<Endian, T> Eq for EndianReader<Endian, T>
 where
     Endian: Endianity,
-    T: CloneStableDeref<Target = [u8]> + Debug,
+    T: CloneStableDeref<Target = [u8]>,
 {
 }
 
 impl<Endian, T> Hash for EndianReader<Endian, T>
 where
     Endian: Endianity,
-    T: CloneStableDeref<Target = [u8]> + Debug,
+    T: CloneStableDeref<Target = [u8]>,
 {
     fn hash<H: Hasher>(&self, state: &mut H) {
         // This must match the `PartialEq` implementation.
@@ -169,22 +165,19 @@ where
 // `CloneStableDeref` ensures these bytes never move.  The `ptr` and `len`
 // members point inside `bytes`, and are updated during read operations.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-struct SubRange<T>
-where
-    T: CloneStableDeref<Target = [u8]> + Debug,
-{
+struct SubRange<T> {
     bytes: T,
     ptr: *const u8,
     len: usize,
 }
 
-unsafe impl<T> Send for SubRange<T> where T: CloneStableDeref<Target = [u8]> + Debug + Send {}
+unsafe impl<T: Send> Send for SubRange<T> {}
 
-unsafe impl<T> Sync for SubRange<T> where T: CloneStableDeref<Target = [u8]> + Debug + Sync {}
+unsafe impl<T: Sync> Sync for SubRange<T> {}
 
 impl<T> SubRange<T>
 where
-    T: CloneStableDeref<Target = [u8]> + Debug,
+    T: CloneStableDeref<Target = [u8]>,
 {
     #[inline]
     fn new(bytes: T) -> Self {
@@ -234,7 +227,7 @@ where
 impl<Endian, T> EndianReader<Endian, T>
 where
     Endian: Endianity,
-    T: CloneStableDeref<Target = [u8]> + Debug,
+    T: CloneStableDeref<Target = [u8]>,
 {
     /// Construct a new `EndianReader` with the given bytes.
     #[inline]
@@ -261,7 +254,7 @@ where
 impl<Endian, T> EndianReader<Endian, T>
 where
     Endian: Endianity,
-    T: CloneStableDeref<Target = [u8]> + Debug,
+    T: CloneStableDeref<Target = [u8]>,
 {
     /// Take the given `start..end` range of the underlying buffer and return a
     /// new `EndianReader`.
@@ -340,7 +333,7 @@ where
 impl<Endian, T> Index<usize> for EndianReader<Endian, T>
 where
     Endian: Endianity,
-    T: CloneStableDeref<Target = [u8]> + Debug,
+    T: CloneStableDeref<Target = [u8]>,
 {
     type Output = u8;
     fn index(&self, idx: usize) -> &Self::Output {
@@ -351,7 +344,7 @@ where
 impl<Endian, T> Index<RangeFrom<usize>> for EndianReader<Endian, T>
 where
     Endian: Endianity,
-    T: CloneStableDeref<Target = [u8]> + Debug,
+    T: CloneStableDeref<Target = [u8]>,
 {
     type Output = [u8];
     fn index(&self, idx: RangeFrom<usize>) -> &Self::Output {
@@ -362,7 +355,7 @@ where
 impl<Endian, T> Deref for EndianReader<Endian, T>
 where
     Endian: Endianity,
-    T: CloneStableDeref<Target = [u8]> + Debug,
+    T: CloneStableDeref<Target = [u8]>,
 {
     type Target = [u8];
     fn deref(&self) -> &Self::Target {
@@ -495,7 +488,7 @@ mod tests {
     use crate::endianity::NativeEndian;
     use crate::read::Reader;
 
-    fn native_reader<T: CloneStableDeref<Target = [u8]> + Debug>(
+    fn native_reader<T: CloneStableDeref<Target = [u8]>>(
         bytes: T,
     ) -> EndianReader<NativeEndian, T> {
         EndianReader::new(bytes, NativeEndian)
diff --git a/src/read/names.rs b/src/read/names.rs
index 6699edeb..5642c85e 100644
--- a/src/read/names.rs
+++ b/src/read/names.rs
@@ -553,7 +553,7 @@ impl<R: Reader> NameIndex<R> {
     /// Parse the entry at the given entry pool offset.
     ///
     /// This is useful for reading the entry referenced by a `DW_IDX_parent` attribute.
-    pub fn name_entry(&self, offset: NameEntryOffset<R::Offset>) -> Result<NameEntry<R>> {
+    pub fn name_entry(&self, offset: NameEntryOffset<R::Offset>) -> Result<NameEntry<R::Offset>> {
         let mut entries = self.entry_pool.clone();
         entries.skip(offset.0)?;
         NameEntry::parse(&mut entries, offset, &self.abbreviations)?.ok_or(Error::UnexpectedNull)
@@ -743,7 +743,7 @@ impl<'a, R: Reader> NameEntryIter<'a, R> {
     }
 
     /// Advance the iterator and return the next name entry.
-    pub fn next(&mut self) -> Result<Option<NameEntry<R>>> {
+    pub fn next(&mut self) -> Result<Option<NameEntry<R::Offset>>> {
         if self.entries.is_empty() {
             return Ok(None);
         }
@@ -767,7 +767,7 @@ impl<'a, R: Reader> NameEntryIter<'a, R> {
 
 #[cfg(feature = "fallible-iterator")]
 impl<'a, R: Reader> fallible_iterator::FallibleIterator for NameEntryIter<'a, R> {
-    type Item = NameEntry<R>;
+    type Item = NameEntry<R::Offset>;
     type Error = Error;
 
     fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
@@ -776,7 +776,7 @@ impl<'a, R: Reader> fallible_iterator::FallibleIterator for NameEntryIter<'a, R>
 }
 
 impl<'a, R: Reader> Iterator for NameEntryIter<'a, R> {
-    type Item = Result<NameEntry<R>>;
+    type Item = Result<NameEntry<R::Offset>>;
 
     fn next(&mut self) -> Option<Self::Item> {
         NameEntryIter::next(self).transpose()
@@ -789,9 +789,9 @@ pub struct NameEntryOffset<T = usize>(pub T);
 
 /// A parsed entry from the `.debug_names` section.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct NameEntry<R: Reader> {
+pub struct NameEntry<Offset: ReaderOffset> {
     /// The offset of the entry in the entries pool.
-    pub offset: NameEntryOffset<R::Offset>,
+    pub offset: NameEntryOffset<Offset>,
 
     /// The abbreviation code for this entry.
     pub abbrev_code: u64,
@@ -800,10 +800,10 @@ pub struct NameEntry<R: Reader> {
     pub tag: constants::DwTag,
 
     /// The attributes for this entry.
-    pub attrs: Vec<NameAttribute<R>>,
+    pub attrs: Vec<NameAttribute<Offset>>,
 }
 
-impl<R: Reader> NameEntry<R> {
+impl<Offset: ReaderOffset> NameEntry<Offset> {
     /// Get the value of the `DW_IDX_compile_unit` attribute, if any.
     ///
     /// If neither `DW_IDX_compile_unit` nor `DW_IDX_type_unit` exist then you should use
@@ -812,7 +812,10 @@ impl<R: Reader> NameEntry<R> {
     /// If both `DW_IDX_compile_unit` and `DW_IDX_type_unit` exist then this value is for
     /// a skeleton CU that may be used to locate a split DWARF object file containing
     /// the type unit.
-    pub fn compile_unit(&self, names: &NameIndex<R>) -> Result<Option<DebugInfoOffset<R::Offset>>> {
+    pub fn compile_unit<R: Reader<Offset = Offset>>(
+        &self,
+        names: &NameIndex<R>,
+    ) -> Result<Option<DebugInfoOffset<Offset>>> {
         for attr in &self.attrs {
             if attr.name == constants::DW_IDX_compile_unit {
                 return attr.compile_unit(names).map(Some);
@@ -822,7 +825,10 @@ impl<R: Reader> NameEntry<R> {
     }
 
     /// Get the value of the `DW_IDX_type_unit` attribute, if any.
-    pub fn type_unit(&self, names: &NameIndex<R>) -> Result<Option<NameTypeUnit<R::Offset>>> {
+    pub fn type_unit<R: Reader<Offset = Offset>>(
+        &self,
+        names: &NameIndex<R>,
+    ) -> Result<Option<NameTypeUnit<Offset>>> {
         for attr in &self.attrs {
             if attr.name == constants::DW_IDX_type_unit {
                 return attr.type_unit(names).map(Some);
@@ -834,7 +840,7 @@ impl<R: Reader> NameEntry<R> {
     /// Get the value of the `DW_IDX_die_offset` attribute, if any.
     ///
     /// This is the offset of the DIE within the compile unit or type unit.
-    pub fn die_offset(&self) -> Result<Option<UnitOffset<R::Offset>>> {
+    pub fn die_offset(&self) -> Result<Option<UnitOffset<Offset>>> {
         for attr in &self.attrs {
             if attr.name == constants::DW_IDX_die_offset {
                 return attr.die_offset().map(Some);
@@ -849,7 +855,7 @@ impl<R: Reader> NameEntry<R> {
     /// Returns `Ok(Some(None))` if the DIE parent is not indexed.
     /// Returns `Ok(None)` if it is unknown whether the DIE parent is indexed
     /// because the producer did not generate a `DW_IDX_parent` attribute.
-    pub fn parent(&self) -> Result<Option<Option<NameEntryOffset<R::Offset>>>> {
+    pub fn parent(&self) -> Result<Option<Option<NameEntryOffset<Offset>>>> {
         for attr in &self.attrs {
             if attr.name == constants::DW_IDX_parent {
                 return attr.parent().map(Some);
@@ -869,11 +875,11 @@ impl<R: Reader> NameEntry<R> {
     }
 
     /// Parse a single entry from the entry pool.
-    fn parse(
+    fn parse<R: Reader<Offset = Offset>>(
         entry_reader: &mut R,
-        offset: NameEntryOffset<R::Offset>,
+        offset: NameEntryOffset<Offset>,
         abbreviations: &NameAbbreviations,
-    ) -> Result<Option<NameEntry<R>>> {
+    ) -> Result<Option<NameEntry<Offset>>> {
         let abbrev_code = entry_reader.read_uleb128()?;
         if abbrev_code == 0 {
             return Ok(None);
@@ -902,13 +908,13 @@ impl<R: Reader> NameEntry<R> {
 
 /// A parsed attribute for a [`NameEntry`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct NameAttribute<R: Reader> {
+pub struct NameAttribute<Offset: ReaderOffset> {
     name: constants::DwIdx,
     form: constants::DwForm,
-    value: NameAttributeValue<R>,
+    value: NameAttributeValue<Offset>,
 }
 
-impl<R: Reader> NameAttribute<R> {
+impl<Offset: ReaderOffset> NameAttribute<Offset> {
     /// Get the attribute name.
     pub fn name(&self) -> constants::DwIdx {
         self.name
@@ -922,12 +928,15 @@ impl<R: Reader> NameAttribute<R> {
     /// Get the attribute value.
     ///
     /// Interpretation of this value depends on the name and form.
-    pub fn value(&self) -> &NameAttributeValue<R> {
+    pub fn value(&self) -> &NameAttributeValue<Offset> {
         &self.value
     }
 
     /// Get the value of a `DW_IDX_compile_unit` attribute.
-    pub fn compile_unit(&self, names: &NameIndex<R>) -> Result<DebugInfoOffset<R::Offset>> {
+    pub fn compile_unit<R: Reader<Offset = Offset>>(
+        &self,
+        names: &NameIndex<R>,
+    ) -> Result<DebugInfoOffset<Offset>> {
         match self.value {
             NameAttributeValue::Unsigned(val) => {
                 let index =
@@ -939,7 +948,10 @@ impl<R: Reader> NameAttribute<R> {
     }
 
     /// Get the value of a `DW_IDX_type_unit` attribute.
-    pub fn type_unit(&self, names: &NameIndex<R>) -> Result<NameTypeUnit<R::Offset>> {
+    pub fn type_unit<R: Reader<Offset = Offset>>(
+        &self,
+        names: &NameIndex<R>,
+    ) -> Result<NameTypeUnit<Offset>> {
         match self.value {
             NameAttributeValue::Unsigned(val) => {
                 let index =
@@ -951,7 +963,7 @@ impl<R: Reader> NameAttribute<R> {
     }
 
     /// Get the value of a `DW_IDX_die_offset` attribute.
-    pub fn die_offset(&self) -> Result<UnitOffset<R::Offset>> {
+    pub fn die_offset(&self) -> Result<UnitOffset<Offset>> {
         match self.value {
             NameAttributeValue::Offset(val) => Ok(UnitOffset(val)),
             _ => Err(Error::UnsupportedAttributeForm),
@@ -962,7 +974,7 @@ impl<R: Reader> NameAttribute<R> {
     ///
     /// Returns `Ok(Some(offset))` if the DIE parent is indexed.
     /// Returns `Ok(None)` if the DIE parent is not indexed.
-    pub fn parent(&self) -> Result<Option<NameEntryOffset<R::Offset>>> {
+    pub fn parent(&self) -> Result<Option<NameEntryOffset<Offset>>> {
         match self.value {
             NameAttributeValue::Offset(val) => Ok(Some(NameEntryOffset(val))),
             NameAttributeValue::Flag(true) => Ok(None),
@@ -981,7 +993,7 @@ impl<R: Reader> NameAttribute<R> {
 
 /// A parsed attribute value for a [`NameEntry`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum NameAttributeValue<R: Reader> {
+pub enum NameAttributeValue<Offset: ReaderOffset> {
     /// An unsigned integer.
     ///
     /// This can be from the following forms:
@@ -991,7 +1003,7 @@ pub enum NameAttributeValue<R: Reader> {
     ///
     /// This can be from the following forms:
     /// `DW_FORM_ref1`, `DW_FORM_ref2`, `DW_FORM_ref4`, `DW_FORM_ref8`, `DW_FORM_ref_udata`
-    Offset(R::Offset),
+    Offset(Offset),
     /// A boolean flag.
     ///
     /// This can be from the following forms:
@@ -1006,7 +1018,7 @@ pub enum NameAttributeValue<R: Reader> {
 fn read_debug_names_form_value<R: Reader>(
     input: &mut R,
     form: constants::DwForm,
-) -> Result<NameAttributeValue<R>> {
+) -> Result<NameAttributeValue<R::Offset>> {
     Ok(match form {
         constants::DW_FORM_flag => {
             let present = input.read_u8()?;
diff --git a/src/read/op.rs b/src/read/op.rs
index 585b182d..3f4564ff 100644
--- a/src/read/op.rs
+++ b/src/read/op.rs
@@ -304,11 +304,15 @@ where
 }
 
 #[derive(Debug)]
-enum OperationEvaluationResult<R: Reader> {
+enum OperationEvaluationResult<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
     Piece,
     Incomplete,
-    Complete { location: Location<R> },
-    Waiting(EvaluationWaiting<R>, EvaluationResult<R>),
+    Complete { location: Location<R, Offset> },
+    Waiting(EvaluationWaiting<R>, EvaluationResult<R, Offset>),
 }
 
 /// A single location of a piece of the result of a DWARF expression.
@@ -860,7 +864,11 @@ enum EvaluationWaiting<R: Reader> {
 /// The evaluation is either `Complete`, or it requires more data
 /// to continue, as described by the variant.
 #[derive(Debug, PartialEq)]
-pub enum EvaluationResult<R: Reader> {
+pub enum EvaluationResult<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
     /// The `Evaluation` is complete, and `Evaluation::result()` can be called.
     Complete,
     /// The `Evaluation` needs a value from memory to proceed further.  Once the
@@ -875,7 +883,7 @@ pub enum EvaluationResult<R: Reader> {
         /// If not `None`, a target-specific address space value.
         space: Option<u64>,
         /// The DIE of the base type or 0 to indicate the generic type
-        base_type: UnitOffset<R::Offset>,
+        base_type: UnitOffset<Offset>,
     },
     /// The `Evaluation` needs a value from a register to proceed further.  Once
     /// the caller determines what value to provide it should resume the
@@ -884,7 +892,7 @@ pub enum EvaluationResult<R: Reader> {
         /// The register number.
         register: Register,
         /// The DIE of the base type or 0 to indicate the generic type
-        base_type: UnitOffset<R::Offset>,
+        base_type: UnitOffset<Offset>,
     },
     /// The `Evaluation` needs the frame base address to proceed further.  Once
     /// the caller determines what value to provide it should resume the
@@ -904,7 +912,7 @@ pub enum EvaluationResult<R: Reader> {
     /// proceed further.  Once the caller determines what value to provide it
     /// should resume the `Evaluation` by calling
     /// `Evaluation::resume_with_at_location`.
-    RequiresAtLocation(DieReference<R::Offset>),
+    RequiresAtLocation(DieReference<Offset>),
     /// The `Evaluation` needs the value produced by evaluating a DWARF
     /// expression at the entry point of the current subprogram.  Once the
     /// caller determines what value to provide it should resume the
@@ -914,7 +922,7 @@ pub enum EvaluationResult<R: Reader> {
     /// in the current function's caller.  Once the caller determines what value
     /// to provide it should resume the `Evaluation` by calling
     /// `Evaluation::resume_with_parameter_ref`.
-    RequiresParameterRef(UnitOffset<R::Offset>),
+    RequiresParameterRef(UnitOffset<Offset>),
     /// The `Evaluation` needs an address to be relocated to proceed further.
     /// Once the caller determines what value to provide it should resume the
     /// `Evaluation` by calling `Evaluation::resume_with_relocated_address`.
@@ -926,7 +934,7 @@ pub enum EvaluationResult<R: Reader> {
     RequiresIndexedAddress {
         /// The index of the address in the `.debug_addr` section,
         /// relative to the `DW_AT_addr_base` of the compilation unit.
-        index: DebugAddrIndex<R::Offset>,
+        index: DebugAddrIndex<Offset>,
         /// Whether the address also needs to be relocated.
         relocate: bool,
     },
@@ -934,7 +942,7 @@ pub enum EvaluationResult<R: Reader> {
     /// the give unit offset.  Once the caller determines what value to provide it
     /// should resume the `Evaluation` by calling
     /// `Evaluation::resume_with_base_type`.
-    RequiresBaseType(UnitOffset<R::Offset>),
+    RequiresBaseType(UnitOffset<Offset>),
 }
 
 /// The bytecode for a DWARF expression or location description.
@@ -1067,13 +1075,17 @@ on the heap using [`Vec`]. This is the default storage type parameter for [`Eval
 /// let result = eval.as_result();
 /// println!("{:?}", result);
 /// ```
-pub trait EvaluationStorage<R: Reader> {
+pub trait EvaluationStorage<R: Reader, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
     /// The storage used for the evaluation stack.
     type Stack: ArrayLike<Item = Value>;
     /// The storage used for the expression stack.
     type ExpressionStack: ArrayLike<Item = (R, R)>;
     /// The storage used for the results.
-    type Result: ArrayLike<Item = Piece<R>>;
+    type Result: ArrayLike<Item = Piece<R, Offset>>;
 }
 
 #[cfg(feature = "read")]
@@ -1129,7 +1141,12 @@ impl<R: Reader> EvaluationStorage<R> for StoreOnHeap {
 /// println!("{:?}", result);
 /// ```
 #[derive(Debug)]
-pub struct Evaluation<R: Reader, S: EvaluationStorage<R> = StoreOnHeap> {
+pub struct Evaluation<R, S = StoreOnHeap, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    S: EvaluationStorage<R, Offset>,
+    Offset: ReaderOffset,
+{
     bytecode: R,
     encoding: Encoding,
     object_address: Option<u64>,
diff --git a/src/read/pubnames.rs b/src/read/pubnames.rs
index fd9b5545..6d12f6c1 100644
--- a/src/read/pubnames.rs
+++ b/src/read/pubnames.rs
@@ -1,13 +1,17 @@
 use crate::common::{DebugInfoOffset, SectionId};
 use crate::endianity::Endianity;
 use crate::read::lookup::{DebugLookup, LookupEntryIter, PubStuffEntry, PubStuffParser};
-use crate::read::{EndianSlice, Reader, Result, Section, UnitOffset};
+use crate::read::{EndianSlice, Reader, ReaderOffset, Result, Section, UnitOffset};
 
 /// A single parsed pubname.
 #[derive(Debug, Clone)]
-pub struct PubNamesEntry<R: Reader> {
-    unit_header_offset: DebugInfoOffset<R::Offset>,
-    die_offset: UnitOffset<R::Offset>,
+pub struct PubNamesEntry<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    unit_header_offset: DebugInfoOffset<Offset>,
+    die_offset: UnitOffset<Offset>,
     name: R,
 }
 
@@ -47,7 +51,12 @@ impl<R: Reader> PubStuffEntry<R> for PubNamesEntry<R> {
 /// The `DebugPubNames` struct represents the DWARF public names information
 /// found in the `.debug_pubnames` section.
 #[derive(Debug, Clone)]
-pub struct DebugPubNames<R: Reader>(DebugLookup<R, PubStuffParser<R, PubNamesEntry<R>>>);
+pub struct DebugPubNames<R, Offset = <R as Reader>::Offset>(
+    DebugLookup<R, PubStuffParser<R, PubNamesEntry<R, Offset>>>,
+)
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset;
 
 impl<'input, Endian> DebugPubNames<EndianSlice<'input, Endian>>
 where
@@ -112,7 +121,12 @@ impl<R: Reader> From<R> for DebugPubNames<R> {
 
 /// An iterator over the pubnames from a `.debug_pubnames` section.
 #[derive(Debug, Clone)]
-pub struct PubNamesEntryIter<R: Reader>(LookupEntryIter<R, PubStuffParser<R, PubNamesEntry<R>>>);
+pub struct PubNamesEntryIter<R, Offset = <R as Reader>::Offset>(
+    LookupEntryIter<R, PubStuffParser<R, PubNamesEntry<R, Offset>>>,
+)
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset;
 
 impl<R: Reader> PubNamesEntryIter<R> {
     /// Advance the iterator and return the next pubname.
diff --git a/src/read/pubtypes.rs b/src/read/pubtypes.rs
index e5774e0d..3d4876bb 100644
--- a/src/read/pubtypes.rs
+++ b/src/read/pubtypes.rs
@@ -1,13 +1,17 @@
 use crate::common::{DebugInfoOffset, SectionId};
 use crate::endianity::Endianity;
 use crate::read::lookup::{DebugLookup, LookupEntryIter, PubStuffEntry, PubStuffParser};
-use crate::read::{EndianSlice, Reader, Result, Section, UnitOffset};
+use crate::read::{EndianSlice, Reader, ReaderOffset, Result, Section, UnitOffset};
 
 /// A single parsed pubtype.
 #[derive(Debug, Clone)]
-pub struct PubTypesEntry<R: Reader> {
-    unit_header_offset: DebugInfoOffset<R::Offset>,
-    die_offset: UnitOffset<R::Offset>,
+pub struct PubTypesEntry<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    unit_header_offset: DebugInfoOffset<Offset>,
+    die_offset: UnitOffset<Offset>,
     name: R,
 }
 
@@ -47,7 +51,12 @@ impl<R: Reader> PubStuffEntry<R> for PubTypesEntry<R> {
 /// The `DebugPubTypes` struct represents the DWARF public types information
 /// found in the `.debug_info` section.
 #[derive(Debug, Clone)]
-pub struct DebugPubTypes<R: Reader>(DebugLookup<R, PubStuffParser<R, PubTypesEntry<R>>>);
+pub struct DebugPubTypes<R, Offset = <R as Reader>::Offset>(
+    DebugLookup<R, PubStuffParser<R, PubTypesEntry<R, Offset>>>,
+)
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset;
 
 impl<'input, Endian> DebugPubTypes<EndianSlice<'input, Endian>>
 where
@@ -112,7 +121,12 @@ impl<R: Reader> From<R> for DebugPubTypes<R> {
 
 /// An iterator over the pubtypes from a `.debug_pubtypes` section.
 #[derive(Debug, Clone)]
-pub struct PubTypesEntryIter<R: Reader>(LookupEntryIter<R, PubStuffParser<R, PubTypesEntry<R>>>);
+pub struct PubTypesEntryIter<R, Offset = <R as Reader>::Offset>(
+    LookupEntryIter<R, PubStuffParser<R, PubTypesEntry<R, Offset>>>,
+)
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset;
 
 impl<R: Reader> PubTypesEntryIter<R> {
     /// Advance the iterator and return the next pubtype.
diff --git a/src/read/reader.rs b/src/read/reader.rs
index c4ba4396..493788ca 100644
--- a/src/read/reader.rs
+++ b/src/read/reader.rs
@@ -1,7 +1,6 @@
 #[cfg(feature = "read")]
 use alloc::borrow::Cow;
 use core::convert::TryInto;
-use core::fmt::Debug;
 use core::hash::Hash;
 use core::ops::{Add, AddAssign, Sub};
 
@@ -22,7 +21,7 @@ pub struct ReaderOffsetId(pub u64);
 ///
 /// This allows consumers to choose a size that is appropriate for their address space.
 pub trait ReaderOffset:
-    Debug + Copy + Eq + Ord + Hash + Add<Output = Self> + AddAssign + Sub<Output = Self>
+    Copy + Eq + Ord + Hash + Add<Output = Self> + AddAssign + Sub<Output = Self>
 {
     /// Convert a u8 to an offset.
     fn from_u8(offset: u8) -> Self;
@@ -282,7 +281,7 @@ pub(crate) mod seal_if_no_alloc {
 /// | [`EndianRcSlice`](./struct.EndianRcSlice.html)    | Reference counted | No          | Shared ownership via reference counting, which alleviates the borrow restrictions of `EndianSlice` but imposes reference counting increments and decrements. Cannot be sent across threads, because the reference count is not atomic. |
 /// | [`EndianArcSlice`](./struct.EndianArcSlice.html)  | Reference counted | Yes         | The same as `EndianRcSlice`, but uses atomic reference counting, and therefore reference counting operations are slower but `EndianArcSlice`s may be sent across threads. |
 /// | [`EndianReader<T>`](./struct.EndianReader.html)   | Same as `T`       | Same as `T` | Escape hatch for easily defining your own type of `Reader`. |
-pub trait Reader: Debug + Clone {
+pub trait Reader: Clone {
     /// The endianity of bytes that are read.
     type Endian: Endianity;
 
diff --git a/src/read/relocate.rs b/src/read/relocate.rs
index 7549c118..5e846d30 100644
--- a/src/read/relocate.rs
+++ b/src/read/relocate.rs
@@ -49,7 +49,7 @@ where
 
 impl<R, T> fmt::Debug for RelocateReader<R, T>
 where
-    R: Reader,
+    R: Reader + fmt::Debug,
     T: Relocate<R::Offset>,
 {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> core::result::Result<(), fmt::Error> {
diff --git a/src/read/rnglists.rs b/src/read/rnglists.rs
index 49cbe0bb..8fb195d9 100644
--- a/src/read/rnglists.rs
+++ b/src/read/rnglists.rs
@@ -472,11 +472,11 @@ impl<R: Reader> Iterator for RawRngListIter<R> {
 /// entry types.  Thus, it only returns range entries that are valid
 /// and already adjusted for the base address.
 #[derive(Debug)]
-pub struct RngListIter<R: Reader> {
+pub struct RngListIter<R: Reader, Offset = <R as Reader>::Offset> {
     raw: RawRngListIter<R>,
     base_address: u64,
     debug_addr: DebugAddr<R>,
-    debug_addr_base: DebugAddrBase<R::Offset>,
+    debug_addr_base: DebugAddrBase<Offset>,
 }
 
 impl<R: Reader> RngListIter<R> {
diff --git a/src/read/unit.rs b/src/read/unit.rs
index 7c20ecea..65d9a530 100644
--- a/src/read/unit.rs
+++ b/src/read/unit.rs
@@ -1121,10 +1121,14 @@ where
 /// An attribute in a `DebuggingInformationEntry`, consisting of a name and
 /// associated value.
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct Attribute<R: Reader> {
+pub struct Attribute<R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
     name: constants::DwAt,
     form: constants::DwForm,
-    value: AttributeValue<R>,
+    value: AttributeValue<R, Offset>,
 }
 
 impl<R: Reader> Attribute<R> {
@@ -2330,14 +2334,15 @@ pub(crate) fn skip_attributes<R: Reader>(
 /// # }
 /// ```
 #[derive(Clone, Debug)]
-pub struct EntriesRaw<'abbrev, R>
+pub struct EntriesRaw<'abbrev, R, Offset = <R as Reader>::Offset>
 where
-    R: Reader,
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
 {
     input: R,
     encoding: Encoding,
     abbreviations: &'abbrev Abbreviations,
-    end_offset: UnitOffset<R::Offset>,
+    end_offset: UnitOffset<Offset>,
     depth: isize,
 }
 
@@ -2506,12 +2511,13 @@ impl<'abbrev, R: Reader> EntriesRaw<'abbrev, R> {
 /// to read entries at a specific depth, such as moving to the first child prior to using
 /// [`Self::next_sibling`].
 #[derive(Clone, Debug)]
-pub struct EntriesCursor<'abbrev, R>
+pub struct EntriesCursor<'abbrev, R, Offset = <R as Reader>::Offset>
 where
-    R: Reader,
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
 {
-    input: EntriesRaw<'abbrev, R>,
-    cached_current: DebuggingInformationEntry<R>,
+    input: EntriesRaw<'abbrev, R, Offset>,
+    cached_current: DebuggingInformationEntry<R, Offset>,
 }
 
 impl<'abbrev, R: Reader> EntriesCursor<'abbrev, R> {
@@ -2874,12 +2880,13 @@ impl<'abbrev, R: Reader> EntriesCursor<'abbrev, R> {
 /// }
 /// ```
 #[derive(Clone, Debug)]
-pub struct EntriesTree<'abbrev, R>
+pub struct EntriesTree<'abbrev, R, Offset = <R as Reader>::Offset>
 where
-    R: Reader,
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
 {
     root: R,
-    input: EntriesRaw<'abbrev, R>,
+    input: EntriesRaw<'abbrev, R, Offset>,
     entry: DebuggingInformationEntry<R>,
 }
 
@@ -2970,7 +2977,11 @@ impl<'abbrev, R: Reader> EntriesTree<'abbrev, R> {
 /// The root node of a tree can be obtained
 /// via [`EntriesTree::root`](./struct.EntriesTree.html#method.root).
 #[derive(Debug)]
-pub struct EntriesTreeNode<'abbrev, 'tree, R: Reader> {
+pub struct EntriesTreeNode<'abbrev, 'tree, R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
     tree: &'tree mut EntriesTree<'abbrev, R>,
     depth: isize,
 }
@@ -3005,8 +3016,12 @@ impl<'abbrev, 'tree, R: Reader> EntriesTreeNode<'abbrev, 'tree, R> {
 /// The items returned by this iterator are also `EntriesTreeNode`s,
 /// which allow recursive traversal of grandchildren, etc.
 #[derive(Debug)]
-pub struct EntriesTreeIter<'abbrev, 'tree, R: Reader> {
-    tree: &'tree mut EntriesTree<'abbrev, R>,
+pub struct EntriesTreeIter<'abbrev, 'tree, R, Offset = <R as Reader>::Offset>
+where
+    R: Reader<Offset = Offset>,
+    Offset: ReaderOffset,
+{
+    tree: &'tree mut EntriesTree<'abbrev, R, Offset>,
     depth: isize,
     empty: bool,
 }
diff --git a/src/write/cfi.rs b/src/write/cfi.rs
index 8d11b112..a7124282 100644
--- a/src/write/cfi.rs
+++ b/src/write/cfi.rs
@@ -614,7 +614,7 @@ pub(crate) mod convert {
         ) -> ConvertResult<FrameTable>
         where
             R: Reader<Offset = usize>,
-            Section: read::UnwindSection<R>,
+            Section: read::UnwindSection<R, usize>,
             Section::Offset: read::UnwindOffset<usize>,
         {
             let bases = read::BaseAddresses::default().set_eh_frame(0);
@@ -660,7 +660,7 @@ pub(crate) mod convert {
         ) -> ConvertResult<CommonInformationEntry>
         where
             R: Reader<Offset = usize>,
-            Section: read::UnwindSection<R>,
+            Section: read::UnwindSection<R, usize>,
             Section::Offset: read::UnwindOffset<usize>,
         {
             let mut cie = CommonInformationEntry::new(
@@ -712,7 +712,7 @@ pub(crate) mod convert {
         ) -> ConvertResult<FrameDescriptionEntry>
         where
             R: Reader<Offset = usize>,
-            Section: read::UnwindSection<R>,
+            Section: read::UnwindSection<R, usize>,
             Section::Offset: read::UnwindOffset<usize>,
         {
             let address =
@@ -759,7 +759,7 @@ pub(crate) mod convert {
         ) -> ConvertResult<Option<CallFrameInstruction>>
         where
             R: Reader<Offset = usize>,
-            Section: read::UnwindSection<R>,
+            Section: read::UnwindSection<R, usize>,
         {
             let convert_expression = |x| {
                 Expression::from(
diff --git a/src/write/line.rs b/src/write/line.rs
index 3a861996..6802555a 100644
--- a/src/write/line.rs
+++ b/src/write/line.rs
@@ -1037,7 +1037,7 @@ pub use convert::*;
 #[cfg(feature = "read")]
 mod convert {
     use super::*;
-    use crate::read::{self, Reader};
+    use crate::read::{self, Reader, ReaderOffset};
     use crate::write::{self, ConvertError, ConvertResult};
 
     /// The result of [`ConvertLineProgram::read_row`].
@@ -1151,9 +1151,13 @@ mod convert {
     /// # }
     /// ```
     #[derive(Debug)]
-    pub struct ConvertLineProgram<'a, R: Reader> {
+    pub struct ConvertLineProgram<'a, R, Offset = <R as Reader>::Offset>
+    where
+        R: Reader<Offset = Offset>,
+        Offset: ReaderOffset,
+    {
         from_dwarf: &'a read::Dwarf<R>,
-        from_program: read::IncompleteLineProgram<R>,
+        from_program: read::IncompleteLineProgram<R, Offset>,
         from_row: read::LineRow,
         from_instructions: read::LineInstructions<R>,
         files: Vec<FileId>,