std/sys/personality/dwarf/
eh.rs1#![allow(non_upper_case_globals)]
13#![allow(unused)]
14
15use core::{mem, ptr};
16
17use super::DwarfReader;
18
19pub const DW_EH_PE_omit: u8 = 0xFF;
20pub const DW_EH_PE_absptr: u8 = 0x00;
21
22pub const DW_EH_PE_uleb128: u8 = 0x01;
23pub const DW_EH_PE_udata2: u8 = 0x02;
24pub const DW_EH_PE_udata4: u8 = 0x03;
25pub const DW_EH_PE_udata8: u8 = 0x04;
26pub const DW_EH_PE_sleb128: u8 = 0x09;
27pub const DW_EH_PE_sdata2: u8 = 0x0A;
28pub const DW_EH_PE_sdata4: u8 = 0x0B;
29pub const DW_EH_PE_sdata8: u8 = 0x0C;
30
31pub const DW_EH_PE_pcrel: u8 = 0x10;
32pub const DW_EH_PE_textrel: u8 = 0x20;
33pub const DW_EH_PE_datarel: u8 = 0x30;
34pub const DW_EH_PE_funcrel: u8 = 0x40;
35pub const DW_EH_PE_aligned: u8 = 0x50;
36
37pub const DW_EH_PE_indirect: u8 = 0x80;
38
39#[derive(Copy, Clone)]
40pub struct EHContext<'a> {
41    pub ip: *const u8,                             pub func_start: *const u8,                     pub get_text_start: &'a dyn Fn() -> *const u8, pub get_data_start: &'a dyn Fn() -> *const u8, }
46
47type LPad = *const u8;
49pub enum EHAction {
50    None,
51    Cleanup(LPad),
52    Catch(LPad),
53    Filter(LPad),
54    Terminate,
55}
56
57pub const USING_SJLJ_EXCEPTIONS: bool =
64    cfg!(all(target_vendor = "apple", not(target_os = "watchos"), target_arch = "arm"));
65
66pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext<'_>) -> Result<EHAction, ()> {
67    if lsda.is_null() {
68        return Ok(EHAction::None);
69    }
70
71    let func_start = context.func_start;
72    let mut reader = DwarfReader::new(lsda);
73    let lpad_base = unsafe {
74        let start_encoding = reader.read::<u8>();
75        if start_encoding != DW_EH_PE_omit {
77            read_encoded_pointer(&mut reader, context, start_encoding)?
78        } else {
79            func_start
80        }
81    };
82    let call_site_encoding = unsafe {
83        let ttype_encoding = reader.read::<u8>();
84        if ttype_encoding != DW_EH_PE_omit {
85            reader.read_uleb128();
87        }
88
89        reader.read::<u8>()
90    };
91    let action_table = unsafe {
92        let call_site_table_length = reader.read_uleb128();
93        reader.ptr.add(call_site_table_length as usize)
94    };
95    let ip = context.ip;
96
97    if !USING_SJLJ_EXCEPTIONS {
98        while reader.ptr < action_table {
100            unsafe {
101                let cs_start = read_encoded_offset(&mut reader, call_site_encoding)?;
103                let cs_len = read_encoded_offset(&mut reader, call_site_encoding)?;
104                let cs_lpad = read_encoded_offset(&mut reader, call_site_encoding)?;
105                let cs_action_entry = reader.read_uleb128();
106                if ip < func_start.wrapping_add(cs_start) {
109                    break;
110                }
111                if ip < func_start.wrapping_add(cs_start + cs_len) {
112                    if cs_lpad == 0 {
113                        return Ok(EHAction::None);
114                    } else {
115                        let lpad = lpad_base.wrapping_add(cs_lpad);
116                        return Ok(interpret_cs_action(action_table, cs_action_entry, lpad));
117                    }
118                }
119            }
120        }
121        Ok(EHAction::Terminate)
123    } else {
124        match ip.addr() as isize {
128            -1 => return Ok(EHAction::None),
129            0 => return Ok(EHAction::Terminate),
130            _ => (),
131        }
132        let mut idx = ip.addr();
133        loop {
134            let cs_lpad = unsafe { reader.read_uleb128() };
135            let cs_action_entry = unsafe { reader.read_uleb128() };
136            idx -= 1;
137            if idx == 0 {
138                let lpad = ptr::with_exposed_provenance((cs_lpad + 1) as usize);
142                return Ok(unsafe { interpret_cs_action(action_table, cs_action_entry, lpad) });
143            }
144        }
145    }
146}
147
148unsafe fn interpret_cs_action(
149    action_table: *const u8,
150    cs_action_entry: u64,
151    lpad: LPad,
152) -> EHAction {
153    if cs_action_entry == 0 {
154        EHAction::Cleanup(lpad)
157    } else {
158        let action_record = unsafe { action_table.offset(cs_action_entry as isize - 1) };
161        let mut action_reader = DwarfReader::new(action_record);
162        let ttype_index = unsafe { action_reader.read_sleb128() };
163        if ttype_index == 0 {
164            EHAction::Cleanup(lpad)
165        } else if ttype_index > 0 {
166            EHAction::Catch(lpad)
168        } else {
169            EHAction::Filter(lpad)
170        }
171    }
172}
173
174#[inline]
175fn round_up(unrounded: usize, align: usize) -> Result<usize, ()> {
176    if align.is_power_of_two() { Ok((unrounded + align - 1) & !(align - 1)) } else { Err(()) }
177}
178
179unsafe fn read_encoded_offset(reader: &mut DwarfReader, encoding: u8) -> Result<usize, ()> {
192    if encoding == DW_EH_PE_omit || encoding & 0xF0 != 0 {
193        return Err(());
194    }
195    let result = unsafe {
196        match encoding & 0x0F {
197            DW_EH_PE_absptr => reader.read::<usize>(),
199            DW_EH_PE_uleb128 => reader.read_uleb128() as usize,
200            DW_EH_PE_udata2 => reader.read::<u16>() as usize,
201            DW_EH_PE_udata4 => reader.read::<u32>() as usize,
202            DW_EH_PE_udata8 => reader.read::<u64>() as usize,
203            DW_EH_PE_sleb128 => reader.read_sleb128() as usize,
204            DW_EH_PE_sdata2 => reader.read::<i16>() as usize,
205            DW_EH_PE_sdata4 => reader.read::<i32>() as usize,
206            DW_EH_PE_sdata8 => reader.read::<i64>() as usize,
207            _ => return Err(()),
208        }
209    };
210    Ok(result)
211}
212
213unsafe fn read_encoded_pointer(
226    reader: &mut DwarfReader,
227    context: &EHContext<'_>,
228    encoding: u8,
229) -> Result<*const u8, ()> {
230    if encoding == DW_EH_PE_omit {
231        return Err(());
232    }
233
234    let base_ptr = match encoding & 0x70 {
235        DW_EH_PE_absptr => core::ptr::null(),
236        DW_EH_PE_pcrel => reader.ptr,
238        DW_EH_PE_funcrel => {
239            if context.func_start.is_null() {
240                return Err(());
241            }
242            context.func_start
243        }
244        DW_EH_PE_textrel => (*context.get_text_start)(),
245        DW_EH_PE_datarel => (*context.get_data_start)(),
246        DW_EH_PE_aligned => {
248            reader.ptr =
249                reader.ptr.with_addr(round_up(reader.ptr.addr(), mem::size_of::<*const u8>())?);
250            core::ptr::null()
251        }
252        _ => return Err(()),
253    };
254
255    let mut ptr = if base_ptr.is_null() {
256        if encoding & 0x0F != DW_EH_PE_absptr {
259            return Err(());
260        }
261        unsafe { reader.read::<*const u8>() }
262    } else {
263        let offset = unsafe { read_encoded_offset(reader, encoding & 0x0F)? };
264        base_ptr.wrapping_add(offset)
265    };
266
267    if encoding & DW_EH_PE_indirect != 0 {
268        ptr = unsafe { *(ptr.cast::<*const u8>()) };
269    }
270
271    Ok(ptr)
272}