      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159

    // 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)]

    use prelude::v1::*;
    use sys_common::dwarf::DwarfReader;
    use core::mem;

    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 {
        pub ip: usize,         // Current instruction pointer
        pub func_start: usize, // Address of the current function
        pub text_start: usize, // Address of the code section
        pub data_start: usize, // Address of the data section
    }

    pub unsafe fn find_landing_pad(lsda: *const u8, context: &EHContext)
                                   -> Option<usize> {
        if lsda.is_null() {
            return 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>();
        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);
        // Return addresses point 1 byte past the call instruction, which could
        // be in the next IP range.
        let ip = context.ip-1;

        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 Some(lpad_base + cs_lpad);
                } else {
                    return None;
                }
            }
        }
        // IP range not found: gcc's C++ personality calls terminate() here,
        // however the rest of the languages treat this the same as cs_lpad == 0.
        // We follow this suit.
        None
    }

    #[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,
                                   encoding: u8) -> usize {
        assert!(encoding != DW_EH_PE_omit);

        // 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 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,
            _ => panic!()
        };

        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,
            DW_EH_PE_textrel => { assert!(context.text_start != 0);
                                  context.text_start },
            DW_EH_PE_datarel => { assert!(context.data_start != 0);
                                  context.data_start },
            DW_EH_PE_funcrel => { assert!(context.func_start != 0);
                                  context.func_start },
            _ => panic!()
        };

        if encoding & DW_EH_PE_indirect != 0 {
            result = *(result as *const usize);
        }

        result
    }

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize`)