From d8361e853d073507d94639a3a7d4fda093a02201 Mon Sep 17 00:00:00 2001
From: Philip Craig <philipjcraig@gmail.com>
Date: Thu, 14 Mar 2024 16:57:10 +1000
Subject: [PATCH] read/cfi: replace Expression with UnwindExpression containing
 offset/length (#703)

This avoids the need to store `Reader` in the `UnwindContext`,
which simplifies lifetime management for reuse of the context.
---
 src/read/cfi.rs  | 380 ++++++++++++++++++++++++++++-------------------
 src/write/cfi.rs |  24 ++-
 2 files changed, 247 insertions(+), 157 deletions(-)

diff --git a/src/read/cfi.rs b/src/read/cfi.rs
index 37728ac3..d764219c 100644
--- a/src/read/cfi.rs
+++ b/src/read/cfi.rs
@@ -459,14 +459,14 @@ impl<'a, R: Reader + 'a> EhHdrTable<'a, R> {
     ///
     /// You must provide a function to get the associated CIE. See
     /// `PartialFrameDescriptionEntry::parse` for more information.
-    pub fn unwind_info_for_address<'ctx, F, A: UnwindContextStorage<R>>(
+    pub fn unwind_info_for_address<'ctx, F, A: UnwindContextStorage<R::Offset>>(
         &self,
         frame: &EhFrame<R>,
         bases: &BaseAddresses,
-        ctx: &'ctx mut UnwindContext<R, A>,
+        ctx: &'ctx mut UnwindContext<R::Offset, A>,
         address: u64,
         get_cie: F,
-    ) -> Result<&'ctx UnwindTableRow<R, A>>
+    ) -> Result<&'ctx UnwindTableRow<R::Offset, A>>
     where
         F: FnMut(
             &EhFrame<R>,
@@ -778,13 +778,13 @@ pub trait UnwindSection<R: Reader>: Clone + Debug + _UnwindSectionPrivate<R> {
     /// # }
     /// ```
     #[inline]
-    fn unwind_info_for_address<'ctx, F, A: UnwindContextStorage<R>>(
+    fn unwind_info_for_address<'ctx, F, A: UnwindContextStorage<R::Offset>>(
         &self,
         bases: &BaseAddresses,
-        ctx: &'ctx mut UnwindContext<R, A>,
+        ctx: &'ctx mut UnwindContext<R::Offset, A>,
         address: u64,
         get_cie: F,
-    ) -> Result<&'ctx UnwindTableRow<R, A>>
+    ) -> Result<&'ctx UnwindTableRow<R::Offset, A>>
     where
         F: FnMut(&Self, &BaseAddresses, Self::Offset) -> Result<CommonInformationEntry<R>>,
     {
@@ -1734,11 +1734,11 @@ impl<R: Reader> FrameDescriptionEntry<R> {
 
     /// Return the table of unwind information for this FDE.
     #[inline]
-    pub fn rows<'a, 'ctx, Section: UnwindSection<R>, A: UnwindContextStorage<R>>(
+    pub fn rows<'a, 'ctx, Section: UnwindSection<R>, A: UnwindContextStorage<R::Offset>>(
         &self,
         section: &'a Section,
         bases: &'a BaseAddresses,
-        ctx: &'ctx mut UnwindContext<R, A>,
+        ctx: &'ctx mut UnwindContext<R::Offset, A>,
     ) -> Result<UnwindTable<'a, 'ctx, R, A>> {
         UnwindTable::new(section, bases, ctx, self)
     }
@@ -1749,13 +1749,17 @@ impl<R: Reader> FrameDescriptionEntry<R> {
     /// context in the form `Ok((unwind_info, context))`. If not found,
     /// `Err(gimli::Error::NoUnwindInfoForAddress)` is returned. If parsing or
     /// CFI evaluation fails, the error is returned.
-    pub fn unwind_info_for_address<'ctx, Section: UnwindSection<R>, A: UnwindContextStorage<R>>(
+    pub fn unwind_info_for_address<
+        'ctx,
+        Section: UnwindSection<R>,
+        A: UnwindContextStorage<R::Offset>,
+    >(
         &self,
         section: &Section,
         bases: &BaseAddresses,
-        ctx: &'ctx mut UnwindContext<R, A>,
+        ctx: &'ctx mut UnwindContext<R::Offset, A>,
         address: u64,
-    ) -> Result<&'ctx UnwindTableRow<R, A>> {
+    ) -> Result<&'ctx UnwindTableRow<R::Offset, A>> {
         let mut table = self.rows(section, bases, ctx)?;
         while let Some(row) = table.next_row()? {
             if row.contains(address) {
@@ -1894,9 +1898,9 @@ You may want to supply your own storage type for one of the following reasons:
 /// #
 /// struct StoreOnStack;
 ///
-/// impl<R: Reader> UnwindContextStorage<R> for StoreOnStack {
-///     type Rules = [(Register, RegisterRule<R>); 192];
-///     type Stack = [UnwindTableRow<R, Self>; 4];
+/// impl<T: ReaderOffset> UnwindContextStorage<T> for StoreOnStack {
+///     type Rules = [(Register, RegisterRule<T>); 192];
+///     type Stack = [UnwindTableRow<T, Self>; 4];
 /// }
 ///
 /// let mut ctx = UnwindContext::<_, StoreOnStack>::new_in();
@@ -1911,14 +1915,14 @@ You may want to supply your own storage type for one of the following reasons:
 /// # unreachable!()
 /// # }
 /// ```
-pub trait UnwindContextStorage<R: Reader>: Sized {
+pub trait UnwindContextStorage<T: ReaderOffset>: Sized {
     /// The storage used for register rules in a unwind table row.
     ///
     /// Note that this is nested within the stack.
-    type Rules: ArrayLike<Item = (Register, RegisterRule<R>)>;
+    type Rules: ArrayLike<Item = (Register, RegisterRule<T>)>;
 
     /// The storage used for unwind table row stack.
-    type Stack: ArrayLike<Item = UnwindTableRow<R, Self>>;
+    type Stack: ArrayLike<Item = UnwindTableRow<T, Self>>;
 }
 
 #[cfg(feature = "read")]
@@ -1927,9 +1931,9 @@ const MAX_RULES: usize = 192;
 const MAX_UNWIND_STACK_DEPTH: usize = 4;
 
 #[cfg(feature = "read")]
-impl<R: Reader> UnwindContextStorage<R> for StoreOnHeap {
-    type Rules = [(Register, RegisterRule<R>); MAX_RULES];
-    type Stack = Box<[UnwindTableRow<R, Self>; MAX_UNWIND_STACK_DEPTH]>;
+impl<T: ReaderOffset> UnwindContextStorage<T> for StoreOnHeap {
+    type Rules = [(Register, RegisterRule<T>); MAX_RULES];
+    type Stack = Box<[UnwindTableRow<T, Self>; MAX_UNWIND_STACK_DEPTH]>;
 }
 
 /// Common context needed when evaluating the call frame unwinding information.
@@ -1966,7 +1970,7 @@ impl<R: Reader> UnwindContextStorage<R> for StoreOnHeap {
 /// # }
 /// ```
 #[derive(Clone, PartialEq, Eq)]
-pub struct UnwindContext<R: Reader, A: UnwindContextStorage<R> = StoreOnHeap> {
+pub struct UnwindContext<T: ReaderOffset, A: UnwindContextStorage<T> = StoreOnHeap> {
     // Stack of rows. The last row is the row currently being built by the
     // program. There is always at least one row. The vast majority of CFI
     // programs will only ever have one row on the stack.
@@ -1980,12 +1984,12 @@ pub struct UnwindContext<R: Reader, A: UnwindContextStorage<R> = StoreOnHeap> {
     // `DW_CFA_restore`. Otherwise, when we are currently evaluating a CIE's
     // initial instructions, `is_initialized` will be `false` and initial rules
     // cannot be read.
-    initial_rule: Option<(Register, RegisterRule<R>)>,
+    initial_rule: Option<(Register, RegisterRule<T>)>,
 
     is_initialized: bool,
 }
 
-impl<R: Reader, S: UnwindContextStorage<R>> Debug for UnwindContext<R, S> {
+impl<T: ReaderOffset, S: UnwindContextStorage<T>> Debug for UnwindContext<T, S> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("UnwindContext")
             .field("stack", &self.stack)
@@ -1995,14 +1999,14 @@ impl<R: Reader, S: UnwindContextStorage<R>> Debug for UnwindContext<R, S> {
     }
 }
 
-impl<R: Reader, A: UnwindContextStorage<R>> Default for UnwindContext<R, A> {
+impl<T: ReaderOffset, A: UnwindContextStorage<T>> Default for UnwindContext<T, A> {
     fn default() -> Self {
         Self::new_in()
     }
 }
 
 #[cfg(feature = "read")]
-impl<R: Reader> UnwindContext<R> {
+impl<T: ReaderOffset> UnwindContext<T> {
     /// Construct a new call frame unwinding context.
     pub fn new() -> Self {
         Self::new_in()
@@ -2013,7 +2017,7 @@ impl<R: Reader> UnwindContext<R> {
 ///
 /// These methods are guaranteed not to allocate, acquire locks, or perform any
 /// other signal-unsafe operations, if an non-allocating storage is used.
-impl<R: Reader, A: UnwindContextStorage<R>> UnwindContext<R, A> {
+impl<T: ReaderOffset, A: UnwindContextStorage<T>> UnwindContext<T, A> {
     /// Construct a new call frame unwinding context.
     pub fn new_in() -> Self {
         let mut ctx = UnwindContext {
@@ -2026,12 +2030,16 @@ impl<R: Reader, A: UnwindContextStorage<R>> UnwindContext<R, A> {
     }
 
     /// Run the CIE's initial instructions and initialize this `UnwindContext`.
-    fn initialize<Section: UnwindSection<R>>(
+    fn initialize<Section, R>(
         &mut self,
         section: &Section,
         bases: &BaseAddresses,
         cie: &CommonInformationEntry<R>,
-    ) -> Result<()> {
+    ) -> Result<()>
+    where
+        R: Reader<Offset = T>,
+        Section: UnwindSection<R>,
+    {
         // Always reset because previous initialization failure may leave dirty state.
         self.reset();
 
@@ -2050,11 +2058,11 @@ impl<R: Reader, A: UnwindContextStorage<R>> UnwindContext<R, A> {
         self.is_initialized = false;
     }
 
-    fn row(&self) -> &UnwindTableRow<R, A> {
+    fn row(&self) -> &UnwindTableRow<T, A> {
         self.stack.last().unwrap()
     }
 
-    fn row_mut(&mut self) -> &mut UnwindTableRow<R, A> {
+    fn row_mut(&mut self) -> &mut UnwindTableRow<T, A> {
         self.stack.last_mut().unwrap()
     }
 
@@ -2086,14 +2094,14 @@ impl<R: Reader, A: UnwindContextStorage<R>> UnwindContext<R, A> {
         row.start_address = start_address;
     }
 
-    fn set_register_rule(&mut self, register: Register, rule: RegisterRule<R>) -> Result<()> {
+    fn set_register_rule(&mut self, register: Register, rule: RegisterRule<T>) -> Result<()> {
         let row = self.row_mut();
         row.registers.set(register, rule)
     }
 
     /// Returns `None` if we have not completed evaluation of a CIE's initial
     /// instructions.
-    fn get_initial_rule(&self, register: Register) -> Option<RegisterRule<R>> {
+    fn get_initial_rule(&self, register: Register) -> Option<RegisterRule<T>> {
         if !self.is_initialized {
             return None;
         }
@@ -2104,11 +2112,11 @@ impl<R: Reader, A: UnwindContextStorage<R>> UnwindContext<R, A> {
         })
     }
 
-    fn set_cfa(&mut self, cfa: CfaRule<R>) {
+    fn set_cfa(&mut self, cfa: CfaRule<T>) {
         self.row_mut().cfa = cfa;
     }
 
-    fn cfa_mut(&mut self) -> &mut CfaRule<R> {
+    fn cfa_mut(&mut self) -> &mut CfaRule<T> {
         &mut self.row_mut().cfa
     }
 
@@ -2188,7 +2196,7 @@ impl<R: Reader, A: UnwindContextStorage<R>> UnwindContext<R, A> {
 /// > recording just the differences starting at the beginning address of each
 /// > subroutine in the program.
 #[derive(Debug)]
-pub struct UnwindTable<'a, 'ctx, R: Reader, A: UnwindContextStorage<R> = StoreOnHeap> {
+pub struct UnwindTable<'a, 'ctx, R: Reader, A: UnwindContextStorage<R::Offset> = StoreOnHeap> {
     code_alignment_factor: Wrapping<u64>,
     data_alignment_factor: Wrapping<i64>,
     next_start_address: u64,
@@ -2196,20 +2204,20 @@ pub struct UnwindTable<'a, 'ctx, R: Reader, A: UnwindContextStorage<R> = StoreOn
     returned_last_row: bool,
     current_row_valid: bool,
     instructions: CallFrameInstructionIter<'a, R>,
-    ctx: &'ctx mut UnwindContext<R, A>,
+    ctx: &'ctx mut UnwindContext<R::Offset, A>,
 }
 
 /// # Signal Safe Methods
 ///
 /// These methods are guaranteed not to allocate, acquire locks, or perform any
 /// other signal-unsafe operations.
-impl<'a, 'ctx, R: Reader, A: UnwindContextStorage<R>> UnwindTable<'a, 'ctx, R, A> {
+impl<'a, 'ctx, R: Reader, A: UnwindContextStorage<R::Offset>> UnwindTable<'a, 'ctx, R, A> {
     /// Construct a new `UnwindTable` for the given
     /// `FrameDescriptionEntry`'s CFI unwinding program.
     pub fn new<Section: UnwindSection<R>>(
         section: &'a Section,
         bases: &'a BaseAddresses,
-        ctx: &'ctx mut UnwindContext<R, A>,
+        ctx: &'ctx mut UnwindContext<R::Offset, A>,
         fde: &FrameDescriptionEntry<R>,
     ) -> Result<Self> {
         ctx.initialize(section, bases, fde.cie())?;
@@ -2219,7 +2227,7 @@ impl<'a, 'ctx, R: Reader, A: UnwindContextStorage<R>> UnwindTable<'a, 'ctx, R, A
     fn new_for_fde<Section: UnwindSection<R>>(
         section: &'a Section,
         bases: &'a BaseAddresses,
-        ctx: &'ctx mut UnwindContext<R, A>,
+        ctx: &'ctx mut UnwindContext<R::Offset, A>,
         fde: &FrameDescriptionEntry<R>,
     ) -> Self {
         assert!(ctx.stack.len() >= 1);
@@ -2238,7 +2246,7 @@ impl<'a, 'ctx, R: Reader, A: UnwindContextStorage<R>> UnwindTable<'a, 'ctx, R, A
     fn new_for_cie<Section: UnwindSection<R>>(
         section: &'a Section,
         bases: &'a BaseAddresses,
-        ctx: &'ctx mut UnwindContext<R, A>,
+        ctx: &'ctx mut UnwindContext<R::Offset, A>,
         cie: &CommonInformationEntry<R>,
     ) -> Self {
         assert!(ctx.stack.len() >= 1);
@@ -2259,7 +2267,7 @@ impl<'a, 'ctx, R: Reader, A: UnwindContextStorage<R>> UnwindTable<'a, 'ctx, R, A
     ///
     /// Unfortunately, this cannot be used with `FallibleIterator` because of
     /// the restricted lifetime of the yielded item.
-    pub fn next_row(&mut self) -> Result<Option<&UnwindTableRow<R, A>>> {
+    pub fn next_row(&mut self) -> Result<Option<&UnwindTableRow<R::Offset, A>>> {
         assert!(self.ctx.stack.len() >= 1);
         self.ctx.set_start_address(self.next_start_address);
         self.current_row_valid = false;
@@ -2292,7 +2300,7 @@ impl<'a, 'ctx, R: Reader, A: UnwindContextStorage<R>> UnwindTable<'a, 'ctx, R, A
     }
 
     /// Returns the current row with the lifetime of the context.
-    pub fn into_current_row(self) -> Option<&'ctx UnwindTableRow<R, A>> {
+    pub fn into_current_row(self) -> Option<&'ctx UnwindTableRow<R::Offset, A>> {
         if self.current_row_valid {
             Some(self.ctx.row())
         } else {
@@ -2302,7 +2310,7 @@ impl<'a, 'ctx, R: Reader, A: UnwindContextStorage<R>> UnwindTable<'a, 'ctx, R, A
 
     /// Evaluate one call frame instruction. Return `Ok(true)` if the row is
     /// complete, `Ok(false)` otherwise.
-    fn evaluate(&mut self, instruction: CallFrameInstruction<R>) -> Result<bool> {
+    fn evaluate(&mut self, instruction: CallFrameInstruction<R::Offset>) -> Result<bool> {
         use crate::CallFrameInstruction::*;
 
         match instruction {
@@ -2511,11 +2519,11 @@ impl<'a, 'ctx, R: Reader, A: UnwindContextStorage<R>> UnwindTable<'a, 'ctx, R, A
 // - https://github.com/libunwind/libunwind/blob/11fd461095ea98f4b3e3a361f5a8a558519363fa/include/tdep-aarch64/dwarf-config.h#L32
 // - https://github.com/libunwind/libunwind/blob/11fd461095ea98f4b3e3a361f5a8a558519363fa/include/tdep-arm/dwarf-config.h#L31
 // - https://github.com/libunwind/libunwind/blob/11fd461095ea98f4b3e3a361f5a8a558519363fa/include/tdep-mips/dwarf-config.h#L31
-struct RegisterRuleMap<R: Reader, S: UnwindContextStorage<R> = StoreOnHeap> {
+struct RegisterRuleMap<T: ReaderOffset, S: UnwindContextStorage<T> = StoreOnHeap> {
     rules: ArrayVec<S::Rules>,
 }
 
-impl<R: Reader, S: UnwindContextStorage<R>> Debug for RegisterRuleMap<R, S> {
+impl<T: ReaderOffset, S: UnwindContextStorage<T>> Debug for RegisterRuleMap<T, S> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("RegisterRuleMap")
             .field("rules", &self.rules)
@@ -2523,7 +2531,7 @@ impl<R: Reader, S: UnwindContextStorage<R>> Debug for RegisterRuleMap<R, S> {
     }
 }
 
-impl<R: Reader, S: UnwindContextStorage<R>> Clone for RegisterRuleMap<R, S> {
+impl<T: ReaderOffset, S: UnwindContextStorage<T>> Clone for RegisterRuleMap<T, S> {
     fn clone(&self) -> Self {
         Self {
             rules: self.rules.clone(),
@@ -2531,7 +2539,7 @@ impl<R: Reader, S: UnwindContextStorage<R>> Clone for RegisterRuleMap<R, S> {
     }
 }
 
-impl<R: Reader, S: UnwindContextStorage<R>> Default for RegisterRuleMap<R, S> {
+impl<T: ReaderOffset, S: UnwindContextStorage<T>> Default for RegisterRuleMap<T, S> {
     fn default() -> Self {
         RegisterRuleMap {
             rules: Default::default(),
@@ -2543,12 +2551,12 @@ impl<R: Reader, S: UnwindContextStorage<R>> Default for RegisterRuleMap<R, S> {
 ///
 /// These methods are guaranteed not to allocate, acquire locks, or perform any
 /// other signal-unsafe operations.
-impl<R: Reader, S: UnwindContextStorage<R>> RegisterRuleMap<R, S> {
+impl<T: ReaderOffset, S: UnwindContextStorage<T>> RegisterRuleMap<T, S> {
     fn is_default(&self) -> bool {
         self.rules.is_empty()
     }
 
-    fn get(&self, register: Register) -> RegisterRule<R> {
+    fn get(&self, register: Register) -> RegisterRule<T> {
         self.rules
             .iter()
             .find(|rule| rule.0 == register)
@@ -2559,7 +2567,7 @@ impl<R: Reader, S: UnwindContextStorage<R>> RegisterRuleMap<R, S> {
             .unwrap_or(RegisterRule::Undefined)
     }
 
-    fn set(&mut self, register: Register, rule: RegisterRule<R>) -> Result<()> {
+    fn set(&mut self, register: Register, rule: RegisterRule<T>) -> Result<()> {
         if !rule.is_defined() {
             let idx = self
                 .rules
@@ -2586,7 +2594,7 @@ impl<R: Reader, S: UnwindContextStorage<R>> RegisterRuleMap<R, S> {
             .map_err(|_| Error::TooManyRegisterRules)
     }
 
-    fn iter(&self) -> RegisterRuleIter<R> {
+    fn iter(&self) -> RegisterRuleIter<T> {
         RegisterRuleIter(self.rules.iter())
     }
 }
@@ -2594,7 +2602,7 @@ impl<R: Reader, S: UnwindContextStorage<R>> RegisterRuleMap<R, S> {
 impl<'a, R, S: UnwindContextStorage<R>> FromIterator<&'a (Register, RegisterRule<R>)>
     for RegisterRuleMap<R, S>
 where
-    R: 'a + Reader,
+    R: 'a + ReaderOffset,
 {
     fn from_iter<T>(iter: T) -> Self
     where
@@ -2612,9 +2620,9 @@ where
     }
 }
 
-impl<R, S: UnwindContextStorage<R>> PartialEq for RegisterRuleMap<R, S>
+impl<T, S: UnwindContextStorage<T>> PartialEq for RegisterRuleMap<T, S>
 where
-    R: Reader + PartialEq,
+    T: ReaderOffset + PartialEq,
 {
     fn eq(&self, rhs: &Self) -> bool {
         for &(reg, ref rule) in &*self.rules {
@@ -2635,16 +2643,16 @@ where
     }
 }
 
-impl<R, S: UnwindContextStorage<R>> Eq for RegisterRuleMap<R, S> where R: Reader + Eq {}
+impl<T, S: UnwindContextStorage<T>> Eq for RegisterRuleMap<T, S> where T: ReaderOffset + Eq {}
 
 /// An unordered iterator for register rules.
 #[derive(Debug, Clone)]
-pub struct RegisterRuleIter<'iter, R>(::core::slice::Iter<'iter, (Register, RegisterRule<R>)>)
+pub struct RegisterRuleIter<'iter, T>(::core::slice::Iter<'iter, (Register, RegisterRule<T>)>)
 where
-    R: Reader;
+    T: ReaderOffset;
 
-impl<'iter, R: Reader> Iterator for RegisterRuleIter<'iter, R> {
-    type Item = &'iter (Register, RegisterRule<R>);
+impl<'iter, T: ReaderOffset> Iterator for RegisterRuleIter<'iter, T> {
+    type Item = &'iter (Register, RegisterRule<T>);
 
     fn next(&mut self) -> Option<Self::Item> {
         self.0.next()
@@ -2654,15 +2662,15 @@ impl<'iter, R: Reader> Iterator for RegisterRuleIter<'iter, R> {
 /// A row in the virtual unwind table that describes how to find the values of
 /// the registers in the *previous* frame for a range of PC addresses.
 #[derive(PartialEq, Eq)]
-pub struct UnwindTableRow<R: Reader, S: UnwindContextStorage<R> = StoreOnHeap> {
+pub struct UnwindTableRow<T: ReaderOffset, S: UnwindContextStorage<T> = StoreOnHeap> {
     start_address: u64,
     end_address: u64,
     saved_args_size: u64,
-    cfa: CfaRule<R>,
-    registers: RegisterRuleMap<R, S>,
+    cfa: CfaRule<T>,
+    registers: RegisterRuleMap<T, S>,
 }
 
-impl<R: Reader, S: UnwindContextStorage<R>> Debug for UnwindTableRow<R, S> {
+impl<T: ReaderOffset, S: UnwindContextStorage<T>> Debug for UnwindTableRow<T, S> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("UnwindTableRow")
             .field("start_address", &self.start_address)
@@ -2674,7 +2682,7 @@ impl<R: Reader, S: UnwindContextStorage<R>> Debug for UnwindTableRow<R, S> {
     }
 }
 
-impl<R: Reader, S: UnwindContextStorage<R>> Clone for UnwindTableRow<R, S> {
+impl<T: ReaderOffset, S: UnwindContextStorage<T>> Clone for UnwindTableRow<T, S> {
     fn clone(&self) -> Self {
         Self {
             start_address: self.start_address,
@@ -2686,7 +2694,7 @@ impl<R: Reader, S: UnwindContextStorage<R>> Clone for UnwindTableRow<R, S> {
     }
 }
 
-impl<R: Reader, S: UnwindContextStorage<R>> Default for UnwindTableRow<R, S> {
+impl<T: ReaderOffset, S: UnwindContextStorage<T>> Default for UnwindTableRow<T, S> {
     fn default() -> Self {
         UnwindTableRow {
             start_address: 0,
@@ -2698,7 +2706,7 @@ impl<R: Reader, S: UnwindContextStorage<R>> Default for UnwindTableRow<R, S> {
     }
 }
 
-impl<R: Reader, S: UnwindContextStorage<R>> UnwindTableRow<R, S> {
+impl<T: ReaderOffset, S: UnwindContextStorage<T>> UnwindTableRow<T, S> {
     fn is_default(&self) -> bool {
         self.start_address == 0
             && self.end_address == 0
@@ -2737,7 +2745,7 @@ impl<R: Reader, S: UnwindContextStorage<R>> UnwindTableRow<R, S> {
     }
 
     /// Get the canonical frame address (CFA) recovery rule for this row.
-    pub fn cfa(&self) -> &CfaRule<R> {
+    pub fn cfa(&self) -> &CfaRule<T> {
         &self.cfa
     }
 
@@ -2785,7 +2793,7 @@ impl<R: Reader, S: UnwindContextStorage<R>> UnwindTableRow<R, S> {
     /// >   <tr><td>Vector Mask Registers 0–7</td>        <td>118-125</td> <td>%k0–%k7</td></tr>
     /// >   <tr><td>Reserved</td>                         <td>126-129</td> <td></td></tr>
     /// > </table>
-    pub fn register(&self, register: Register) -> RegisterRule<R> {
+    pub fn register(&self, register: Register) -> RegisterRule<T> {
         self.registers.get(register)
     }
 
@@ -2797,21 +2805,21 @@ impl<R: Reader, S: UnwindContextStorage<R>> UnwindTableRow<R, S> {
     ///
     /// ```
     /// # use gimli::{EndianSlice, LittleEndian, UnwindTableRow};
-    /// # fn foo<'input>(unwind_table_row: UnwindTableRow<EndianSlice<'input, LittleEndian>>) {
+    /// # fn foo<'input>(unwind_table_row: UnwindTableRow<usize>) {
     /// for &(register, ref rule) in unwind_table_row.registers() {
     ///     // ...
     ///     # drop(register); drop(rule);
     /// }
     /// # }
     /// ```
-    pub fn registers(&self) -> RegisterRuleIter<R> {
+    pub fn registers(&self) -> RegisterRuleIter<T> {
         self.registers.iter()
     }
 }
 
 /// The canonical frame address (CFA) recovery rules.
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub enum CfaRule<R: Reader> {
+pub enum CfaRule<T: ReaderOffset> {
     /// The CFA is given offset from the given register's value.
     RegisterAndOffset {
         /// The register containing the base value.
@@ -2821,10 +2829,10 @@ pub enum CfaRule<R: Reader> {
     },
     /// The CFA is obtained by evaluating this `Reader` as a DWARF expression
     /// program.
-    Expression(Expression<R>),
+    Expression(UnwindExpression<T>),
 }
 
-impl<R: Reader> Default for CfaRule<R> {
+impl<T: ReaderOffset> Default for CfaRule<T> {
     fn default() -> Self {
         CfaRule::RegisterAndOffset {
             register: Register(0),
@@ -2833,7 +2841,7 @@ impl<R: Reader> Default for CfaRule<R> {
     }
 }
 
-impl<R: Reader> CfaRule<R> {
+impl<T: ReaderOffset> CfaRule<T> {
     fn is_default(&self) -> bool {
         match *self {
             CfaRule::RegisterAndOffset { register, offset } => {
@@ -2852,7 +2860,7 @@ impl<R: Reader> CfaRule<R> {
 /// previous frame."
 #[derive(Clone, Debug, PartialEq, Eq)]
 #[non_exhaustive]
-pub enum RegisterRule<R: Reader> {
+pub enum RegisterRule<T: ReaderOffset> {
     /// > A register that has this rule has no recoverable value in the previous
     /// > frame. (By convention, it is not preserved by a callee.)
     Undefined,
@@ -2876,11 +2884,11 @@ pub enum RegisterRule<R: Reader> {
 
     /// "The previous value of this register is located at the address produced
     /// by executing the DWARF expression."
-    Expression(Expression<R>),
+    Expression(UnwindExpression<T>),
 
     /// "The previous value of this register is the value produced by executing
     /// the DWARF expression."
-    ValExpression(Expression<R>),
+    ValExpression(UnwindExpression<T>),
 
     /// "The rule is defined externally to this specification by the augmenter."
     Architectural,
@@ -2889,7 +2897,7 @@ pub enum RegisterRule<R: Reader> {
     Constant(u64),
 }
 
-impl<R: Reader> RegisterRule<R> {
+impl<T: ReaderOffset> RegisterRule<T> {
     fn is_defined(&self) -> bool {
         !matches!(*self, RegisterRule::Undefined)
     }
@@ -2898,7 +2906,7 @@ impl<R: Reader> RegisterRule<R> {
 /// A parsed call frame instruction.
 #[derive(Clone, Debug, PartialEq, Eq)]
 #[non_exhaustive]
-pub enum CallFrameInstruction<R: Reader> {
+pub enum CallFrameInstruction<T: ReaderOffset> {
     // 6.4.2.1 Row Creation Methods
     /// > 1. DW_CFA_set_loc
     /// >
@@ -3002,8 +3010,8 @@ pub enum CallFrameInstruction<R: Reader> {
     /// > expression. The required action is to establish that expression as the
     /// > means by which the current CFA is computed.
     DefCfaExpression {
-        /// The DWARF expression.
-        expression: Expression<R>,
+        /// The location of the DWARF expression.
+        expression: UnwindExpression<T>,
     },
 
     // 6.4.2.3 Register Rule Instructions
@@ -3113,8 +3121,8 @@ pub enum CallFrameInstruction<R: Reader> {
     Expression {
         /// The target register's number.
         register: Register,
-        /// The DWARF expression.
-        expression: Expression<R>,
+        /// The location of the DWARF expression.
+        expression: UnwindExpression<T>,
     },
 
     /// > 10. DW_CFA_val_expression
@@ -3130,8 +3138,8 @@ pub enum CallFrameInstruction<R: Reader> {
     ValExpression {
         /// The target register's number.
         register: Register,
-        /// The DWARF expression.
-        expression: Expression<R>,
+        /// The location of the DWARF expression.
+        expression: UnwindExpression<T>,
     },
 
     /// The `Restore` instruction represents both `DW_CFA_restore` and
@@ -3197,13 +3205,13 @@ pub enum CallFrameInstruction<R: Reader> {
 const CFI_INSTRUCTION_HIGH_BITS_MASK: u8 = 0b1100_0000;
 const CFI_INSTRUCTION_LOW_BITS_MASK: u8 = !CFI_INSTRUCTION_HIGH_BITS_MASK;
 
-impl<R: Reader> CallFrameInstruction<R> {
-    fn parse(
+impl<T: ReaderOffset> CallFrameInstruction<T> {
+    fn parse<R: Reader<Offset = T>>(
         input: &mut R,
         address_encoding: Option<DwEhPe>,
         parameters: &PointerEncodingParameters<R>,
         vendor: Vendor,
-    ) -> Result<CallFrameInstruction<R>> {
+    ) -> Result<CallFrameInstruction<T>> {
         let instruction = input.read_u8()?;
         let high_bits = instruction & CFI_INSTRUCTION_HIGH_BITS_MASK;
 
@@ -3316,20 +3324,22 @@ impl<R: Reader> CallFrameInstruction<R> {
             }
 
             constants::DW_CFA_def_cfa_expression => {
-                let len = input.read_uleb128().and_then(R::Offset::from_u64)?;
-                let expression = input.split(len)?;
+                let length = input.read_uleb128().and_then(R::Offset::from_u64)?;
+                let offset = input.offset_from(parameters.section);
+                input.skip(length)?;
                 Ok(CallFrameInstruction::DefCfaExpression {
-                    expression: Expression(expression),
+                    expression: UnwindExpression { offset, length },
                 })
             }
 
             constants::DW_CFA_expression => {
                 let register = input.read_uleb128().and_then(Register::from_u64)?;
-                let len = input.read_uleb128().and_then(R::Offset::from_u64)?;
-                let expression = input.split(len)?;
+                let length = input.read_uleb128().and_then(R::Offset::from_u64)?;
+                let offset = input.offset_from(parameters.section);
+                input.skip(length)?;
                 Ok(CallFrameInstruction::Expression {
                     register,
-                    expression: Expression(expression),
+                    expression: UnwindExpression { offset, length },
                 })
             }
 
@@ -3378,11 +3388,12 @@ impl<R: Reader> CallFrameInstruction<R> {
 
             constants::DW_CFA_val_expression => {
                 let register = input.read_uleb128().and_then(Register::from_u64)?;
-                let len = input.read_uleb128().and_then(R::Offset::from_u64)?;
-                let expression = input.split(len)?;
+                let length = input.read_uleb128().and_then(R::Offset::from_u64)?;
+                let offset = input.offset_from(parameters.section);
+                input.skip(length)?;
                 Ok(CallFrameInstruction::ValExpression {
                     register,
-                    expression: Expression(expression),
+                    expression: UnwindExpression { offset, length },
                 })
             }
 
@@ -3414,7 +3425,7 @@ pub struct CallFrameInstructionIter<'a, R: Reader> {
 
 impl<'a, R: Reader> CallFrameInstructionIter<'a, R> {
     /// Parse the next call frame instruction.
-    pub fn next(&mut self) -> Result<Option<CallFrameInstruction<R>>> {
+    pub fn next(&mut self) -> Result<Option<CallFrameInstruction<R::Offset>>> {
         if self.input.is_empty() {
             return Ok(None);
         }
@@ -3436,7 +3447,7 @@ impl<'a, R: Reader> CallFrameInstructionIter<'a, R> {
 
 #[cfg(feature = "fallible-iterator")]
 impl<'a, R: Reader> fallible_iterator::FallibleIterator for CallFrameInstructionIter<'a, R> {
-    type Item = CallFrameInstruction<R>;
+    type Item = CallFrameInstruction<R::Offset>;
     type Error = Error;
 
     fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
@@ -3444,6 +3455,34 @@ impl<'a, R: Reader> fallible_iterator::FallibleIterator for CallFrameInstruction
     }
 }
 
+/// The location of a DWARF expression within an unwind section.
+///
+/// This is stored as an offset and length within the section instead of as a
+/// `Reader` to avoid lifetime issues when reusing [`UnwindContext`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct UnwindExpression<T: ReaderOffset> {
+    /// The offset of the expression within the section.
+    pub offset: T,
+    /// The length of the expression.
+    pub length: T,
+}
+
+impl<T: ReaderOffset> UnwindExpression<T> {
+    /// Get the expression from the section.
+    ///
+    /// The offset and length were previously validated when the
+    /// `UnwindExpression` was created, so this should not fail.
+    pub fn get<R: Reader<Offset = T>, S: UnwindSection<R>>(
+        &self,
+        section: &S,
+    ) -> Result<Expression<R>> {
+        let input = &mut section.section().clone();
+        input.skip(self.offset)?;
+        let data = input.split(self.length)?;
+        Ok(Expression(data))
+    }
+}
+
 /// Parse a `DW_EH_PE_*` pointer encoding.
 #[doc(hidden)]
 #[inline]
@@ -3597,7 +3636,7 @@ mod tests {
     use crate::constants;
     use crate::endianity::{BigEndian, Endianity, LittleEndian, NativeEndian};
     use crate::read::{
-        EndianSlice, Error, Expression, Pointer, ReaderOffsetId, Result, Section as ReadSection,
+        EndianSlice, Error, Pointer, ReaderOffsetId, Result, Section as ReadSection,
     };
     use crate::test_util::GimliSectionMethods;
     use alloc::boxed::Box;
@@ -4537,12 +4576,13 @@ mod tests {
     fn parse_cfi_instruction<R: Reader + Default>(
         input: &mut R,
         address_size: u8,
-    ) -> Result<CallFrameInstruction<R>> {
+    ) -> Result<CallFrameInstruction<R::Offset>> {
+        let section = input.clone();
         let parameters = &PointerEncodingParameters {
             bases: &SectionBaseAddresses::default(),
             func_base: None,
             address_size,
-            section: &R::default(),
+            section: &section,
         };
         CallFrameInstruction::parse(input, None, parameters, Vendor::Default)
     }
@@ -4936,13 +4976,17 @@ mod tests {
             .append_bytes(&expected_rest);
 
         length.set_const((&end - &start) as u64);
+        let expected_expression = UnwindExpression {
+            offset: (&start - &section.start()) as usize,
+            length: (&end - &start) as usize,
+        };
         let contents = section.get_contents().unwrap();
         let input = &mut EndianSlice::new(&contents, LittleEndian);
 
         assert_eq!(
             parse_cfi_instruction(input, 8),
             Ok(CallFrameInstruction::DefCfaExpression {
-                expression: Expression(EndianSlice::new(&expected_expr, LittleEndian)),
+                expression: expected_expression,
             })
         );
         assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
@@ -4968,6 +5012,10 @@ mod tests {
             .append_bytes(&expected_rest);
 
         length.set_const((&end - &start) as u64);
+        let expected_expression = UnwindExpression {
+            offset: (&start - &section.start()) as usize,
+            length: (&end - &start) as usize,
+        };
         let contents = section.get_contents().unwrap();
         let input = &mut EndianSlice::new(&contents, LittleEndian);
 
@@ -4975,7 +5023,7 @@ mod tests {
             parse_cfi_instruction(input, 8),
             Ok(CallFrameInstruction::Expression {
                 register: Register(expected_reg),
-                expression: Expression(EndianSlice::new(&expected_expr, LittleEndian)),
+                expression: expected_expression,
             })
         );
         assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
@@ -5108,6 +5156,10 @@ mod tests {
             .append_bytes(&expected_rest);
 
         length.set_const((&end - &start) as u64);
+        let expected_expression = UnwindExpression {
+            offset: (&start - &section.start()) as usize,
+            length: (&end - &start) as usize,
+        };
         let contents = section.get_contents().unwrap();
         let input = &mut EndianSlice::new(&contents, LittleEndian);
 
@@ -5115,7 +5167,7 @@ mod tests {
             parse_cfi_instruction(input, 8),
             Ok(CallFrameInstruction::ValExpression {
                 register: Register(expected_reg),
-                expression: Expression(EndianSlice::new(&expected_expr, LittleEndian)),
+                expression: expected_expression,
             })
         );
         assert_eq!(*input, EndianSlice::new(&expected_rest, LittleEndian));
@@ -5178,13 +5230,17 @@ mod tests {
             .D8(expected_delta);
 
         length.set_const((&end - &start) as u64);
+        let expected_expression = UnwindExpression {
+            offset: (&start - &section.start()) as usize,
+            length: (&end - &start) as usize,
+        };
         let contents = section.get_contents().unwrap();
         let input = EndianSlice::new(&contents, BigEndian);
         let parameters = PointerEncodingParameters {
             bases: &SectionBaseAddresses::default(),
             func_base: None,
             address_size: 8,
-            section: &EndianSlice::default(),
+            section: &input,
         };
         let mut iter = CallFrameInstructionIter {
             input,
@@ -5197,7 +5253,7 @@ mod tests {
             iter.next(),
             Ok(Some(CallFrameInstruction::ValExpression {
                 register: Register(expected_reg),
-                expression: Expression(EndianSlice::new(&expected_expr, BigEndian)),
+                expression: expected_expression,
             }))
         );
 
@@ -5239,18 +5295,13 @@ mod tests {
     }
 
     fn assert_eval<'a, I>(
-        mut initial_ctx: UnwindContext<EndianSlice<'a, LittleEndian>>,
-        expected_ctx: UnwindContext<EndianSlice<'a, LittleEndian>>,
+        mut initial_ctx: UnwindContext<usize>,
+        expected_ctx: UnwindContext<usize>,
         cie: CommonInformationEntry<EndianSlice<'a, LittleEndian>>,
         fde: Option<FrameDescriptionEntry<EndianSlice<'a, LittleEndian>>>,
         instructions: I,
     ) where
-        I: AsRef<
-            [(
-                Result<bool>,
-                CallFrameInstruction<EndianSlice<'a, LittleEndian>>,
-            )],
-        >,
+        I: AsRef<[(Result<bool>, CallFrameInstruction<usize>)]>,
     {
         {
             let section = &DebugFrame::from(EndianSlice::default());
@@ -5392,10 +5443,10 @@ mod tests {
     fn test_eval_def_cfa_register_invalid_context() {
         let cie = make_test_cie();
         let mut ctx = UnwindContext::new();
-        ctx.set_cfa(CfaRule::Expression(Expression(EndianSlice::new(
-            &[],
-            LittleEndian,
-        ))));
+        ctx.set_cfa(CfaRule::Expression(UnwindExpression {
+            offset: 0,
+            length: 0,
+        }));
         let expected = ctx.clone();
         let instructions = [(
             Err(Error::CfiInstructionInInvalidContext),
@@ -5427,10 +5478,10 @@ mod tests {
     fn test_eval_def_cfa_offset_invalid_context() {
         let cie = make_test_cie();
         let mut ctx = UnwindContext::new();
-        ctx.set_cfa(CfaRule::Expression(Expression(EndianSlice::new(
-            &[],
-            LittleEndian,
-        ))));
+        ctx.set_cfa(CfaRule::Expression(UnwindExpression {
+            offset: 10,
+            length: 11,
+        }));
         let expected = ctx.clone();
         let instructions = [(
             Err(Error::CfiInstructionInInvalidContext),
@@ -5441,19 +5492,17 @@ mod tests {
 
     #[test]
     fn test_eval_def_cfa_expression() {
-        let expr = [1, 2, 3, 4];
+        let expr = UnwindExpression {
+            offset: 10,
+            length: 11,
+        };
         let cie = make_test_cie();
         let ctx = UnwindContext::new();
         let mut expected = ctx.clone();
-        expected.set_cfa(CfaRule::Expression(Expression(EndianSlice::new(
-            &expr,
-            LittleEndian,
-        ))));
+        expected.set_cfa(CfaRule::Expression(expr));
         let instructions = [(
             Ok(false),
-            CallFrameInstruction::DefCfaExpression {
-                expression: Expression(EndianSlice::new(&expr, LittleEndian)),
-            },
+            CallFrameInstruction::DefCfaExpression { expression: expr },
         )];
         assert_eval(ctx, expected, cie, None, instructions);
     }
@@ -5578,21 +5627,21 @@ mod tests {
 
     #[test]
     fn test_eval_expression() {
-        let expr = [1, 2, 3, 4];
+        let expr = UnwindExpression {
+            offset: 10,
+            length: 11,
+        };
         let cie = make_test_cie();
         let ctx = UnwindContext::new();
         let mut expected = ctx.clone();
         expected
-            .set_register_rule(
-                Register(9),
-                RegisterRule::Expression(Expression(EndianSlice::new(&expr, LittleEndian))),
-            )
+            .set_register_rule(Register(9), RegisterRule::Expression(expr))
             .unwrap();
         let instructions = [(
             Ok(false),
             CallFrameInstruction::Expression {
                 register: Register(9),
-                expression: Expression(EndianSlice::new(&expr, LittleEndian)),
+                expression: expr,
             },
         )];
         assert_eval(ctx, expected, cie, None, instructions);
@@ -5600,21 +5649,21 @@ mod tests {
 
     #[test]
     fn test_eval_val_expression() {
-        let expr = [1, 2, 3, 4];
+        let expr = UnwindExpression {
+            offset: 10,
+            length: 11,
+        };
         let cie = make_test_cie();
         let ctx = UnwindContext::new();
         let mut expected = ctx.clone();
         expected
-            .set_register_rule(
-                Register(9),
-                RegisterRule::ValExpression(Expression(EndianSlice::new(&expr, LittleEndian))),
-            )
+            .set_register_rule(Register(9), RegisterRule::ValExpression(expr))
             .unwrap();
         let instructions = [(
             Ok(false),
             CallFrameInstruction::ValExpression {
                 register: Register(9),
-                expression: Expression(EndianSlice::new(&expr, LittleEndian)),
+                expression: expr,
             },
         )];
         assert_eval(ctx, expected, cie, None, instructions);
@@ -7212,13 +7261,13 @@ mod tests {
     #[test]
     fn register_rule_map_eq() {
         // Different order, but still equal.
-        let map1: RegisterRuleMap<EndianSlice<LittleEndian>> = [
+        let map1: RegisterRuleMap<usize> = [
             (Register(0), RegisterRule::SameValue),
             (Register(3), RegisterRule::Offset(1)),
         ]
         .iter()
         .collect();
-        let map2: RegisterRuleMap<EndianSlice<LittleEndian>> = [
+        let map2: RegisterRuleMap<usize> = [
             (Register(3), RegisterRule::Offset(1)),
             (Register(0), RegisterRule::SameValue),
         ]
@@ -7228,13 +7277,13 @@ mod tests {
         assert_eq!(map2, map1);
 
         // Not equal.
-        let map3: RegisterRuleMap<EndianSlice<LittleEndian>> = [
+        let map3: RegisterRuleMap<usize> = [
             (Register(0), RegisterRule::SameValue),
             (Register(2), RegisterRule::Offset(1)),
         ]
         .iter()
         .collect();
-        let map4: RegisterRuleMap<EndianSlice<LittleEndian>> = [
+        let map4: RegisterRuleMap<usize> = [
             (Register(3), RegisterRule::Offset(1)),
             (Register(0), RegisterRule::SameValue),
         ]
@@ -7244,17 +7293,17 @@ mod tests {
         assert!(map4 != map3);
 
         // One has undefined explicitly set, other implicitly has undefined.
-        let mut map5 = RegisterRuleMap::<EndianSlice<LittleEndian>>::default();
+        let mut map5 = RegisterRuleMap::<usize>::default();
         map5.set(Register(0), RegisterRule::SameValue).unwrap();
         map5.set(Register(0), RegisterRule::Undefined).unwrap();
-        let map6 = RegisterRuleMap::<EndianSlice<LittleEndian>>::default();
+        let map6 = RegisterRuleMap::<usize>::default();
         assert_eq!(map5, map6);
         assert_eq!(map6, map5);
     }
 
     #[test]
     fn iter_register_rules() {
-        let row = UnwindTableRow::<EndianSlice<LittleEndian>> {
+        let row = UnwindTableRow::<usize> {
             registers: [
                 (Register(0), RegisterRule::SameValue),
                 (Register(1), RegisterRule::Offset(1)),
@@ -7299,7 +7348,7 @@ mod tests {
     #[cfg(target_pointer_width = "64")]
     fn size_of_unwind_ctx() {
         use core::mem;
-        let size = mem::size_of::<UnwindContext<EndianSlice<NativeEndian>>>();
+        let size = mem::size_of::<UnwindContext<usize>>();
         let max_size = 30968;
         if size > max_size {
             assert_eq!(size, max_size);
@@ -7310,7 +7359,7 @@ mod tests {
     #[cfg(target_pointer_width = "64")]
     fn size_of_register_rule_map() {
         use core::mem;
-        let size = mem::size_of::<RegisterRuleMap<EndianSlice<NativeEndian>>>();
+        let size = mem::size_of::<RegisterRuleMap<usize>>();
         let max_size = 6152;
         if size > max_size {
             assert_eq!(size, max_size);
@@ -7852,4 +7901,31 @@ mod tests {
         );
         assert_eq!(rest, EndianSlice::new(&expected_rest, LittleEndian));
     }
+
+    #[test]
+    fn test_unwind_context_reuse() {
+        fn unwind_one(ctx: &mut UnwindContext<usize>, data: &[u8]) {
+            let debug_frame = DebugFrame::new(data, NativeEndian);
+            let bases = Default::default();
+            let result = debug_frame.unwind_info_for_address(
+                &bases,
+                ctx,
+                0xbadb_ad99,
+                DebugFrame::cie_from_offset,
+            );
+            assert!(result.is_err());
+            assert_eq!(result.unwrap_err(), Error::NoUnwindInfoForAddress);
+        }
+
+        // Use the same context for two different data lifetimes.
+        let mut ctx: UnwindContext<usize> = UnwindContext::new();
+        {
+            let data1 = vec![];
+            unwind_one(&mut ctx, &data1);
+        }
+        {
+            let data2 = vec![];
+            unwind_one(&mut ctx, &data2);
+        }
+    }
 }
diff --git a/src/write/cfi.rs b/src/write/cfi.rs
index 5e108f15..2ac62313 100644
--- a/src/write/cfi.rs
+++ b/src/write/cfi.rs
@@ -690,6 +690,7 @@ pub(crate) mod convert {
                 if let Some(instruction) = CallFrameInstruction::from(
                     from_instruction,
                     from_cie,
+                    frame,
                     convert_address,
                     &mut offset,
                 )? {
@@ -734,6 +735,7 @@ pub(crate) mod convert {
                 if let Some(instruction) = CallFrameInstruction::from(
                     from_instruction,
                     from_cie,
+                    frame,
                     convert_address,
                     &mut offset,
                 )? {
@@ -746,12 +748,17 @@ pub(crate) mod convert {
     }
 
     impl CallFrameInstruction {
-        fn from<R: Reader<Offset = usize>>(
-            from_instruction: read::CallFrameInstruction<R>,
+        fn from<R, Section>(
+            from_instruction: read::CallFrameInstruction<R::Offset>,
             from_cie: &read::CommonInformationEntry<R>,
+            frame: &Section,
             convert_address: &dyn Fn(u64) -> Option<Address>,
             offset: &mut u32,
-        ) -> ConvertResult<Option<CallFrameInstruction>> {
+        ) -> ConvertResult<Option<CallFrameInstruction>>
+        where
+            R: Reader<Offset = usize>,
+            Section: read::UnwindSection<R>,
+        {
             let convert_expression =
                 |x| Expression::from(x, from_cie.encoding(), None, None, None, convert_address);
             // TODO: validate integer type conversions
@@ -785,6 +792,7 @@ pub(crate) mod convert {
                     CallFrameInstruction::CfaOffset(offset as i32)
                 }
                 read::CallFrameInstruction::DefCfaExpression { expression } => {
+                    let expression = expression.get(frame)?;
                     CallFrameInstruction::CfaExpression(convert_expression(expression)?)
                 }
                 read::CallFrameInstruction::Undefined { register } => {
@@ -828,11 +836,17 @@ pub(crate) mod convert {
                 read::CallFrameInstruction::Expression {
                     register,
                     expression,
-                } => CallFrameInstruction::Expression(register, convert_expression(expression)?),
+                } => {
+                    let expression = expression.get(frame)?;
+                    CallFrameInstruction::Expression(register, convert_expression(expression)?)
+                }
                 read::CallFrameInstruction::ValExpression {
                     register,
                     expression,
-                } => CallFrameInstruction::ValExpression(register, convert_expression(expression)?),
+                } => {
+                    let expression = expression.get(frame)?;
+                    CallFrameInstruction::ValExpression(register, convert_expression(expression)?)
+                }
                 read::CallFrameInstruction::Restore { register } => {
                     CallFrameInstruction::Restore(register)
                 }