      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

    // 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.

    //! Utilities for parsing DWARF-encoded data streams.
    //! See http://www.dwarfstd.org,
    //! DWARF-4 standard, Section 7 - "Data Representation"

    // This module is used only by x86_64-pc-windows-gnu for now, but we
    // are compiling it everywhere to avoid regressions.
    #![allow(unused)]

    pub mod eh;

    use prelude::v1::*;
    use core::mem;

    pub struct DwarfReader {
        pub ptr : *const u8
    }

    #[repr(C,packed)]
    struct Unaligned<T>(T);

    impl DwarfReader {

        pub fn new(ptr : *const u8) -> DwarfReader {
            DwarfReader {
                ptr : ptr
            }
        }

        // DWARF streams are packed, so e.g. a u32 would not necessarily be aligned
        // on a 4-byte boundary. This may cause problems on platforms with strict
        // alignment requirements. By wrapping data in a "packed" struct, we are
        // telling the backend to generate "misalignment-safe" code.
        pub unsafe fn read<T:Copy>(&mut self) -> T {
            let Unaligned(result) = *(self.ptr as *const Unaligned<T>);
            self.ptr = self.ptr.offset(mem::size_of::<T>() as isize);
            result
        }

        // ULEB128 and SLEB128 encodings are defined in Section 7.6 - "Variable
        // Length Data".
        pub unsafe fn read_uleb128(&mut self) -> u64 {
            let mut shift : usize = 0;
            let mut result : u64 = 0;
            let mut byte : u8;
            loop {
                byte = self.read::<u8>();
                result |= ((byte & 0x7F) as u64) << shift;
                shift += 7;
                if byte & 0x80 == 0 {
                    break;
                }
            }
            result
        }

        pub unsafe fn read_sleb128(&mut self) -> i64 {
            let mut shift : usize = 0;
            let mut result : u64 = 0;
            let mut byte : u8;
            loop {
                byte = self.read::<u8>();
                result |= ((byte & 0x7F) as u64) << shift;
                shift += 7;
                if byte & 0x80 == 0 {
                    break;
                }
            }
            // sign-extend
            if shift < 8 * mem::size_of::<u64>() && (byte & 0x40) != 0 {
                result |= (!0 as u64) << shift;
            }
            result as i64
        }
    }

    #[test]
    fn dwarf_reader() {
        let encoded: &[u8] = &[1,
                               2, 3,
                               4, 5, 6, 7,
                               0xE5, 0x8E, 0x26,
                               0x9B, 0xF1, 0x59,
                               0xFF, 0xFF];

        let mut reader = DwarfReader::new(encoded.as_ptr());

        unsafe {
            assert!(reader.read::<u8>() == u8::to_be(1u8));
            assert!(reader.read::<u16>() == u16::to_be(0x0203));
            assert!(reader.read::<u32>() == u32::to_be(0x04050607));

            assert!(reader.read_uleb128() == 624485);
            assert!(reader.read_sleb128() == -624485);

            assert!(reader.read::<i8>() == i8::to_be(-1));
        }
    }

# 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` or `* -> vec`)