2020-06-30 17:22:44 +08:00
|
|
|
//! Parsing of GCC-style Language-Specific Data Area (LSDA)
|
|
|
|
//! For details see:
|
|
|
|
//! http://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-PDA/LSB-PDA/ehframechpt.html
|
|
|
|
//! http://mentorembedded.github.io/cxx-abi/exceptions.pdf
|
|
|
|
//! http://www.airs.com/blog/archives/460
|
|
|
|
//! http://www.airs.com/blog/archives/464
|
|
|
|
//!
|
|
|
|
//! A reference implementation may be found in the GCC source tree
|
|
|
|
//! (`<root>/libgcc/unwind-c.c` as of this writing).
|
|
|
|
|
|
|
|
#![allow(non_upper_case_globals)]
|
|
|
|
#![allow(unused)]
|
|
|
|
|
|
|
|
use crate::DwarfReader;
|
|
|
|
use core::mem;
|
2022-01-06 01:54:34 +08:00
|
|
|
use cslice::CSlice;
|
2020-06-30 17:22:44 +08:00
|
|
|
|
|
|
|
pub const DW_EH_PE_omit: u8 = 0xFF;
|
|
|
|
pub const DW_EH_PE_absptr: u8 = 0x00;
|
|
|
|
|
|
|
|
pub const DW_EH_PE_uleb128: u8 = 0x01;
|
|
|
|
pub const DW_EH_PE_udata2: u8 = 0x02;
|
|
|
|
pub const DW_EH_PE_udata4: u8 = 0x03;
|
|
|
|
pub const DW_EH_PE_udata8: u8 = 0x04;
|
|
|
|
pub const DW_EH_PE_sleb128: u8 = 0x09;
|
|
|
|
pub const DW_EH_PE_sdata2: u8 = 0x0A;
|
|
|
|
pub const DW_EH_PE_sdata4: u8 = 0x0B;
|
|
|
|
pub const DW_EH_PE_sdata8: u8 = 0x0C;
|
|
|
|
|
|
|
|
pub const DW_EH_PE_pcrel: u8 = 0x10;
|
|
|
|
pub const DW_EH_PE_textrel: u8 = 0x20;
|
|
|
|
pub const DW_EH_PE_datarel: u8 = 0x30;
|
|
|
|
pub const DW_EH_PE_funcrel: u8 = 0x40;
|
|
|
|
pub const DW_EH_PE_aligned: u8 = 0x50;
|
|
|
|
|
|
|
|
pub const DW_EH_PE_indirect: u8 = 0x80;
|
|
|
|
|
|
|
|
#[derive(Copy, Clone)]
|
|
|
|
pub struct EHContext<'a> {
|
|
|
|
pub ip: usize, // Current instruction pointer
|
|
|
|
pub func_start: usize, // Address of the current function
|
|
|
|
pub get_text_start: &'a dyn Fn() -> usize, // Get address of the code section
|
|
|
|
pub get_data_start: &'a dyn Fn() -> usize, // Get address of the data section
|
|
|
|
}
|
|
|
|
|
|
|
|
pub enum EHAction {
|
|
|
|
None,
|
|
|
|
Cleanup(usize),
|
|
|
|
Catch(usize),
|
|
|
|
Terminate,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub const USING_SJLJ_EXCEPTIONS: bool = cfg!(all(target_os = "ios", target_arch = "arm"));
|
|
|
|
|
2022-01-06 01:54:34 +08:00
|
|
|
fn size_of_encoded_value(encoding: u8) -> usize {
|
|
|
|
if encoding == DW_EH_PE_omit {
|
|
|
|
0
|
|
|
|
} else {
|
|
|
|
let encoding = encoding & 0x07;
|
|
|
|
match encoding {
|
|
|
|
DW_EH_PE_absptr => core::mem::size_of::<*const ()>(),
|
|
|
|
DW_EH_PE_udata2 => 2,
|
|
|
|
DW_EH_PE_udata4 => 4,
|
|
|
|
DW_EH_PE_udata8 => 8,
|
|
|
|
_ => unreachable!(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unsafe fn get_ttype_entry(
|
|
|
|
offset: usize,
|
|
|
|
encoding: u8,
|
|
|
|
ttype_base: usize,
|
|
|
|
ttype: *const u8,
|
|
|
|
) -> Result<*const u8, ()> {
|
|
|
|
let i = (offset * size_of_encoded_value(encoding)) as isize;
|
|
|
|
read_encoded_pointer_with_base(
|
|
|
|
&mut DwarfReader::new(ttype.offset(-i)),
|
|
|
|
// the DW_EH_PE_pcrel is a hack.
|
|
|
|
// It seems that the default encoding is absolute, but we have to take reallocation into
|
|
|
|
// account. Unsure if we can fix this in the compiler setting or if this would be affected
|
|
|
|
// by updating the compiler
|
|
|
|
encoding | DW_EH_PE_pcrel,
|
|
|
|
ttype_base,
|
|
|
|
)
|
|
|
|
.map(|v| v as *const u8)
|
|
|
|
}
|
|
|
|
|
2020-06-30 17:22:44 +08:00
|
|
|
pub unsafe fn find_eh_action(
|
|
|
|
lsda: *const u8,
|
|
|
|
context: &EHContext<'_>,
|
|
|
|
foreign_exception: bool,
|
2022-01-06 01:54:34 +08:00
|
|
|
name: *const u8,
|
|
|
|
len: usize,
|
2020-06-30 17:22:44 +08:00
|
|
|
) -> Result<EHAction, ()> {
|
|
|
|
if lsda.is_null() {
|
|
|
|
return Ok(EHAction::None);
|
|
|
|
}
|
|
|
|
|
|
|
|
let func_start = context.func_start;
|
|
|
|
let mut reader = DwarfReader::new(lsda);
|
|
|
|
|
|
|
|
let start_encoding = reader.read::<u8>();
|
|
|
|
// base address for landing pad offsets
|
|
|
|
let lpad_base = if start_encoding != DW_EH_PE_omit {
|
|
|
|
read_encoded_pointer(&mut reader, context, start_encoding)?
|
|
|
|
} else {
|
|
|
|
func_start
|
|
|
|
};
|
|
|
|
|
|
|
|
let ttype_encoding = reader.read::<u8>();
|
2022-01-06 01:54:34 +08:00
|
|
|
// we do care about the type table
|
|
|
|
let ttype_offset = if ttype_encoding != DW_EH_PE_omit {
|
|
|
|
reader.read_uleb128()
|
|
|
|
} else {
|
|
|
|
0
|
|
|
|
};
|
|
|
|
// for rust functions, it seems that there is no type table, so I just put whatever value here.
|
|
|
|
// we should not return an error, otherwise we would abort unwinding and cannot unwind through
|
|
|
|
// rust functions
|
|
|
|
let ttype_base = get_base(ttype_encoding, context).unwrap_or(1);
|
|
|
|
let ttype_table = reader.ptr.offset(ttype_offset as isize);
|
2020-06-30 17:22:44 +08:00
|
|
|
|
|
|
|
let call_site_encoding = reader.read::<u8>();
|
|
|
|
let call_site_table_length = reader.read_uleb128();
|
|
|
|
let action_table = reader.ptr.offset(call_site_table_length as isize);
|
|
|
|
let ip = context.ip;
|
|
|
|
|
|
|
|
if !USING_SJLJ_EXCEPTIONS {
|
|
|
|
while reader.ptr < action_table {
|
|
|
|
let cs_start = read_encoded_pointer(&mut reader, context, call_site_encoding)?;
|
|
|
|
let cs_len = read_encoded_pointer(&mut reader, context, call_site_encoding)?;
|
|
|
|
let cs_lpad = read_encoded_pointer(&mut reader, context, call_site_encoding)?;
|
|
|
|
let cs_action = reader.read_uleb128();
|
|
|
|
// Callsite table is sorted by cs_start, so if we've passed the ip, we
|
|
|
|
// may stop searching.
|
|
|
|
if ip < func_start + cs_start {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ip < func_start + cs_start + cs_len {
|
2022-01-06 01:54:34 +08:00
|
|
|
// https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/eh_personality.cc#L528
|
|
|
|
let lpad = lpad_base + cs_lpad;
|
2020-06-30 17:22:44 +08:00
|
|
|
if cs_lpad == 0 {
|
2022-01-06 01:54:34 +08:00
|
|
|
// no cleanups/handler
|
|
|
|
return Ok(EHAction::None);
|
|
|
|
} else if cs_action == 0 {
|
|
|
|
return Ok(EHAction::Cleanup(lpad));
|
|
|
|
} else if foreign_exception {
|
2020-06-30 17:22:44 +08:00
|
|
|
return Ok(EHAction::None);
|
|
|
|
} else {
|
2022-01-06 01:54:34 +08:00
|
|
|
let mut saw_cleanup = false;
|
|
|
|
let mut action_record = action_table.offset(cs_action as isize - 1);
|
|
|
|
loop {
|
|
|
|
let mut reader = DwarfReader::new(action_record);
|
|
|
|
let ar_filter = reader.read_sleb128();
|
|
|
|
action_record = reader.ptr;
|
|
|
|
let ar_disp = reader.read_sleb128();
|
|
|
|
if ar_filter == 0 {
|
|
|
|
saw_cleanup = true;
|
|
|
|
} else if ar_filter > 0 {
|
|
|
|
let catch_type = get_ttype_entry(
|
|
|
|
ar_filter as usize,
|
|
|
|
ttype_encoding,
|
|
|
|
ttype_base,
|
|
|
|
ttype_table,
|
|
|
|
)?;
|
|
|
|
let clause_ptr = *(catch_type as *const *const CSlice<u8>);
|
|
|
|
if clause_ptr.is_null() {
|
|
|
|
return Ok(EHAction::Catch(lpad));
|
|
|
|
}
|
|
|
|
let clause_name_ptr = (*clause_ptr).as_ptr();
|
|
|
|
let clause_name_len = (*clause_ptr).len();
|
|
|
|
if (clause_name_ptr == core::ptr::null() ||
|
|
|
|
clause_name_ptr == name ||
|
|
|
|
// somehow their name pointers might differ, but the content is the
|
|
|
|
// same
|
|
|
|
core::slice::from_raw_parts(clause_name_ptr, clause_name_len) ==
|
|
|
|
core::slice::from_raw_parts(name, len))
|
|
|
|
{
|
|
|
|
return Ok(EHAction::Catch(lpad));
|
|
|
|
}
|
|
|
|
} else if ar_filter < 0 {
|
|
|
|
// FIXME: how to handle this?
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ar_disp == 0 {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
action_record = action_record.offset((ar_disp as usize) as isize);
|
|
|
|
}
|
|
|
|
if saw_cleanup {
|
|
|
|
return Ok(EHAction::Cleanup(lpad));
|
|
|
|
} else {
|
|
|
|
return Ok(EHAction::None);
|
|
|
|
}
|
2020-06-30 17:22:44 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Ip is not present in the table. This should not happen... but it does: issue #35011.
|
|
|
|
// So rather than returning EHAction::Terminate, we do this.
|
|
|
|
Ok(EHAction::None)
|
|
|
|
} else {
|
2022-01-06 01:54:34 +08:00
|
|
|
// SjLj version: (not yet modified)
|
2020-06-30 17:22:44 +08:00
|
|
|
// The "IP" is an index into the call-site table, with two exceptions:
|
|
|
|
// -1 means 'no-action', and 0 means 'terminate'.
|
|
|
|
match ip as isize {
|
|
|
|
-1 => return Ok(EHAction::None),
|
|
|
|
0 => return Ok(EHAction::Terminate),
|
|
|
|
_ => (),
|
|
|
|
}
|
|
|
|
let mut idx = ip;
|
|
|
|
loop {
|
|
|
|
let cs_lpad = reader.read_uleb128();
|
|
|
|
let cs_action = reader.read_uleb128();
|
|
|
|
idx -= 1;
|
|
|
|
if idx == 0 {
|
|
|
|
// Can never have null landing pad for sjlj -- that would have
|
|
|
|
// been indicated by a -1 call site index.
|
|
|
|
let lpad = (cs_lpad + 1) as usize;
|
|
|
|
return Ok(interpret_cs_action(cs_action, lpad, foreign_exception));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn interpret_cs_action(cs_action: u64, lpad: usize, foreign_exception: bool) -> EHAction {
|
|
|
|
if cs_action == 0 {
|
|
|
|
// If cs_action is 0 then this is a cleanup (Drop::drop). We run these
|
|
|
|
// for both Rust panics and foreign exceptions.
|
|
|
|
EHAction::Cleanup(lpad)
|
|
|
|
} else if foreign_exception {
|
|
|
|
// catch_unwind should not catch foreign exceptions, only Rust panics.
|
|
|
|
// Instead just continue unwinding.
|
|
|
|
EHAction::None
|
|
|
|
} else {
|
|
|
|
// Stop unwinding Rust panics at catch_unwind.
|
|
|
|
EHAction::Catch(lpad)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn round_up(unrounded: usize, align: usize) -> Result<usize, ()> {
|
2022-01-06 01:54:34 +08:00
|
|
|
if align.is_power_of_two() {
|
|
|
|
Ok((unrounded + align - 1) & !(align - 1))
|
|
|
|
} else {
|
|
|
|
Err(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_base(encoding: u8, context: &EHContext<'_>) -> Result<usize, ()> {
|
|
|
|
match encoding & 0x70 {
|
|
|
|
DW_EH_PE_absptr | DW_EH_PE_pcrel | DW_EH_PE_aligned => Ok(0),
|
|
|
|
DW_EH_PE_textrel => Ok((*context.get_text_start)()),
|
|
|
|
DW_EH_PE_datarel => Ok((*context.get_data_start)()),
|
|
|
|
DW_EH_PE_funcrel if context.func_start != 0 => Ok(context.func_start),
|
|
|
|
_ => return Err(()),
|
|
|
|
}
|
2020-06-30 17:22:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
unsafe fn read_encoded_pointer(
|
|
|
|
reader: &mut DwarfReader,
|
|
|
|
context: &EHContext<'_>,
|
|
|
|
encoding: u8,
|
2022-01-06 01:54:34 +08:00
|
|
|
) -> Result<usize, ()> {
|
|
|
|
read_encoded_pointer_with_base(reader, encoding, get_base(encoding, context)?)
|
|
|
|
}
|
|
|
|
|
|
|
|
unsafe fn read_encoded_pointer_with_base(
|
|
|
|
reader: &mut DwarfReader,
|
|
|
|
encoding: u8,
|
|
|
|
base: usize,
|
2020-06-30 17:22:44 +08:00
|
|
|
) -> Result<usize, ()> {
|
|
|
|
if encoding == DW_EH_PE_omit {
|
|
|
|
return Err(());
|
|
|
|
}
|
|
|
|
|
2022-01-06 01:54:34 +08:00
|
|
|
let original_ptr = reader.ptr;
|
2020-06-30 17:22:44 +08:00
|
|
|
// DW_EH_PE_aligned implies it's an absolute pointer value
|
|
|
|
if encoding == DW_EH_PE_aligned {
|
|
|
|
reader.ptr = round_up(reader.ptr as usize, mem::size_of::<usize>())? as *const u8;
|
|
|
|
return Ok(reader.read::<usize>());
|
|
|
|
}
|
|
|
|
|
|
|
|
let mut result = match encoding & 0x0F {
|
|
|
|
DW_EH_PE_absptr => reader.read::<usize>(),
|
|
|
|
DW_EH_PE_uleb128 => reader.read_uleb128() as usize,
|
|
|
|
DW_EH_PE_udata2 => reader.read::<u16>() as usize,
|
|
|
|
DW_EH_PE_udata4 => reader.read::<u32>() as usize,
|
|
|
|
DW_EH_PE_udata8 => reader.read::<u64>() as usize,
|
|
|
|
DW_EH_PE_sleb128 => reader.read_sleb128() as usize,
|
|
|
|
DW_EH_PE_sdata2 => reader.read::<i16>() as usize,
|
|
|
|
DW_EH_PE_sdata4 => reader.read::<i32>() as usize,
|
|
|
|
DW_EH_PE_sdata8 => reader.read::<i64>() as usize,
|
|
|
|
_ => return Err(()),
|
|
|
|
};
|
|
|
|
|
2022-01-06 01:54:34 +08:00
|
|
|
result += if (encoding & 0x70) == DW_EH_PE_pcrel {
|
|
|
|
original_ptr as usize
|
|
|
|
} else {
|
|
|
|
base
|
2020-06-30 17:22:44 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
if encoding & DW_EH_PE_indirect != 0 {
|
|
|
|
result = *(result as *const usize);
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(result)
|
|
|
|
}
|