2015-07-14 03:11:44 +02:00
|
|
|
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
|
|
|
//! 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)]
|
|
|
|
|
rustc: Implement custom panic runtimes
This commit is an implementation of [RFC 1513] which allows applications to
alter the behavior of panics at compile time. A new compiler flag, `-C panic`,
is added and accepts the values `unwind` or `panic`, with the default being
`unwind`. This model affects how code is generated for the local crate, skipping
generation of landing pads with `-C panic=abort`.
[RFC 1513]: https://github.com/rust-lang/rfcs/blob/master/text/1513-less-unwinding.md
Panic implementations are then provided by crates tagged with
`#![panic_runtime]` and lazily required by crates with
`#![needs_panic_runtime]`. The panic strategy (`-C panic` value) of the panic
runtime must match the final product, and if the panic strategy is not `abort`
then the entire DAG must have the same panic strategy.
With the `-C panic=abort` strategy, users can expect a stable method to disable
generation of landing pads, improving optimization in niche scenarios,
decreasing compile time, and decreasing output binary size. With the `-C
panic=unwind` strategy users can expect the existing ability to isolate failure
in Rust code from the outside world.
Organizationally, this commit dismantles the `sys_common::unwind` module in
favor of some bits moving part of it to `libpanic_unwind` and the rest into the
`panicking` module in libstd. The custom panic runtime support is pretty similar
to the custom allocator support with the only major difference being how the
panic runtime is injected (takes the `-C panic` flag into account).
2016-04-09 01:18:40 +02:00
|
|
|
use dwarf::DwarfReader;
|
2015-07-14 03:11:44 +02:00
|
|
|
use core::mem;
|
|
|
|
|
2016-05-29 12:36:29 +02: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;
|
2015-07-14 03:11:44 +02:00
|
|
|
|
|
|
|
#[derive(Copy, Clone)]
|
2016-07-22 23:57:54 +02:00
|
|
|
pub struct EHContext<'a> {
|
2016-05-29 12:36:29 +02:00
|
|
|
pub ip: usize, // Current instruction pointer
|
2015-07-14 03:11:44 +02:00
|
|
|
pub func_start: usize, // Address of the current function
|
2016-07-22 23:57:54 +02:00
|
|
|
pub get_text_start: &'a Fn() -> usize, // Get address of the code section
|
|
|
|
pub get_data_start: &'a Fn() -> usize, // Get address of the data section
|
2015-07-14 03:11:44 +02:00
|
|
|
}
|
|
|
|
|
2016-07-22 23:57:54 +02:00
|
|
|
pub enum EHAction {
|
|
|
|
None,
|
|
|
|
Cleanup(usize),
|
|
|
|
Catch(usize),
|
|
|
|
Terminate,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub const USING_SJLJ_EXCEPTIONS: bool = cfg!(all(target_os = "ios", target_arch = "arm"));
|
|
|
|
|
|
|
|
pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext) -> EHAction {
|
2015-07-14 03:11:44 +02:00
|
|
|
if lsda.is_null() {
|
2016-07-22 23:57:54 +02:00
|
|
|
return EHAction::None;
|
2015-07-14 03:11:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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>();
|
|
|
|
if ttype_encoding != DW_EH_PE_omit {
|
|
|
|
// Rust doesn't analyze exception types, so we don't care about the type table
|
|
|
|
reader.read_uleb128();
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2016-07-22 23:57:54 +02:00
|
|
|
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 {
|
|
|
|
if cs_lpad == 0 {
|
|
|
|
return EHAction::None;
|
|
|
|
} else {
|
|
|
|
let lpad = lpad_base + cs_lpad;
|
|
|
|
return interpret_cs_action(cs_action, lpad);
|
|
|
|
}
|
|
|
|
}
|
2015-07-14 03:11:44 +02:00
|
|
|
}
|
2016-07-27 03:53:47 +02:00
|
|
|
// Ip is not present in the table. This should not happen... but it does: issue #35011.
|
2016-07-25 07:09:56 +02:00
|
|
|
// So rather than returning EHAction::Terminate, we do this.
|
|
|
|
EHAction::None
|
2016-07-22 23:57:54 +02:00
|
|
|
} else {
|
|
|
|
// SjLj version:
|
|
|
|
// 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 EHAction::None,
|
|
|
|
0 => return 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 interpret_cs_action(cs_action, lpad);
|
2015-07-14 03:11:44 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-07-22 23:57:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
fn interpret_cs_action(cs_action: u64, lpad: usize) -> EHAction {
|
|
|
|
if cs_action == 0 {
|
|
|
|
EHAction::Cleanup(lpad)
|
|
|
|
} else {
|
|
|
|
EHAction::Catch(lpad)
|
|
|
|
}
|
2015-07-14 03:11:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn round_up(unrounded: usize, align: usize) -> usize {
|
|
|
|
assert!(align.is_power_of_two());
|
|
|
|
(unrounded + align - 1) & !(align - 1)
|
|
|
|
}
|
|
|
|
|
|
|
|
unsafe fn read_encoded_pointer(reader: &mut DwarfReader,
|
|
|
|
context: &EHContext,
|
2016-05-29 12:36:29 +02:00
|
|
|
encoding: u8)
|
|
|
|
-> usize {
|
2015-07-14 03:11:44 +02:00
|
|
|
assert!(encoding != DW_EH_PE_omit);
|
|
|
|
|
|
|
|
// DW_EH_PE_aligned implies it's an absolute pointer value
|
|
|
|
if encoding == DW_EH_PE_aligned {
|
2016-05-29 12:36:29 +02:00
|
|
|
reader.ptr = round_up(reader.ptr as usize, mem::size_of::<usize>()) as *const u8;
|
2015-07-14 03:11:44 +02:00
|
|
|
return 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,
|
2016-05-29 12:36:29 +02:00
|
|
|
_ => panic!(),
|
2015-07-14 03:11:44 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
result += match encoding & 0x70 {
|
|
|
|
DW_EH_PE_absptr => 0,
|
|
|
|
// relative to address of the encoded value, despite the name
|
|
|
|
DW_EH_PE_pcrel => reader.ptr as usize,
|
2016-05-29 12:36:29 +02:00
|
|
|
DW_EH_PE_funcrel => {
|
|
|
|
assert!(context.func_start != 0);
|
|
|
|
context.func_start
|
|
|
|
}
|
2016-07-22 23:57:54 +02:00
|
|
|
DW_EH_PE_textrel => {
|
|
|
|
(*context.get_text_start)()
|
|
|
|
}
|
|
|
|
DW_EH_PE_datarel => {
|
|
|
|
(*context.get_data_start)()
|
|
|
|
}
|
2016-05-29 12:36:29 +02:00
|
|
|
_ => panic!(),
|
2015-07-14 03:11:44 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
if encoding & DW_EH_PE_indirect != 0 {
|
|
|
|
result = *(result as *const usize);
|
|
|
|
}
|
|
|
|
|
|
|
|
result
|
|
|
|
}
|