1 files changed, 441 insertions, 0 deletions
diff --git a/vendor/backtrace/src/print/fuchsia.rs b/vendor/backtrace/src/print/fuchsia.rs
new file mode 100644
index 0000000..cb87269
--- /dev/null
+++ b/vendor/backtrace/src/print/fuchsia.rs
@@ -0,0 +1,441 @@
+use core::fmt::{self, Write};
+use core::mem::{size_of, transmute};
+use core::slice::from_raw_parts;
+use libc::c_char;
+
+extern "C" {
+    // dl_iterate_phdr takes a callback that will receive a dl_phdr_info pointer
+    // for every DSO that has been linked into the process. dl_iterate_phdr also
+    // ensures that the dynamic linker is locked from start to finish of the
+    // iteration. If the callback returns a non-zero value the iteration is
+    // terminated early. 'data' will be passed as the third argument to the
+    // callback on each call. 'size' gives the size of the dl_phdr_info.
+    #[allow(improper_ctypes)]
+    fn dl_iterate_phdr(
+        f: extern "C" fn(info: &dl_phdr_info, size: usize, data: &mut DsoPrinter<'_, '_>) -> i32,
+        data: &mut DsoPrinter<'_, '_>,
+    ) -> i32;
+}
+
+// We need to parse out the build ID and some basic program header data
+// which means that we need a bit of stuff from the ELF spec as well.
+
+const PT_LOAD: u32 = 1;
+const PT_NOTE: u32 = 4;
+
+// Now we have to replicate, bit for bit, the structure of the dl_phdr_info
+// type used by fuchsia's current dynamic linker. Chromium also has this ABI
+// boundary as well as crashpad. Eventually we'd like to move these cases to
+// use elf-search but we'd need to provide that in the SDK and that has not
+// yet been done. Thus we (and they) are stuck having to use this method
+// which incurs a tight coupling with the fuchsia libc.
+
+#[allow(non_camel_case_types)]
+#[repr(C)]
+struct dl_phdr_info {
+    addr: *const u8,
+    name: *const c_char,
+    phdr: *const Elf_Phdr,
+    phnum: u16,
+    adds: u64,
+    subs: u64,
+    tls_modid: usize,
+    tls_data: *const u8,
+}
+
+impl dl_phdr_info {
+    fn program_headers(&self) -> PhdrIter<'_> {
+        PhdrIter {
+            phdrs: self.phdr_slice(),
+            base: self.addr,
+        }
+    }
+    // We have no way of knowing of checking if e_phoff and e_phnum are valid.
+    // libc should ensure this for us however so it's safe to form a slice here.
+    fn phdr_slice(&self) -> &[Elf_Phdr] {
+        unsafe { from_raw_parts(self.phdr, self.phnum as usize) }
+    }
+}
+
+struct PhdrIter<'a> {
+    phdrs: &'a [Elf_Phdr],
+    base: *const u8,
+}
+
+impl<'a> Iterator for PhdrIter<'a> {
+    type Item = Phdr<'a>;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.phdrs.split_first().map(|(phdr, new_phdrs)| {
+            self.phdrs = new_phdrs;
+            Phdr {
+                phdr,
+                base: self.base,
+            }
+        })
+    }
+}
+
+// Elf_Phdr represents a 64-bit ELF program header in the endianness of the target
+// architecture.
+#[allow(non_camel_case_types)]
+#[derive(Clone, Debug)]
+#[repr(C)]
+struct Elf_Phdr {
+    p_type: u32,
+    p_flags: u32,
+    p_offset: u64,
+    p_vaddr: u64,
+    p_paddr: u64,
+    p_filesz: u64,
+    p_memsz: u64,
+    p_align: u64,
+}
+
+// Phdr represents a valid ELF program header and its contents.
+struct Phdr<'a> {
+    phdr: &'a Elf_Phdr,
+    base: *const u8,
+}
+
+impl<'a> Phdr<'a> {
+    // We have no way of checking if p_addr or p_memsz are valid. Fuchsia's libc
+    // parses the notes first however so by virtue of being here these headers
+    // must be valid. NoteIter does not require the underlying data to be valid
+    // but it does require the bounds to be valid. We trust that libc has ensured
+    // that this is the case for us here.
+    fn notes(&self) -> NoteIter<'a> {
+        unsafe {
+            NoteIter::new(
+                self.base.add(self.phdr.p_offset as usize),
+                self.phdr.p_memsz as usize,
+            )
+        }
+    }
+}
+
+// The note type for build IDs.
+const NT_GNU_BUILD_ID: u32 = 3;
+
+// Elf_Nhdr represents an ELF note header in the endianness of the target.
+#[allow(non_camel_case_types)]
+#[repr(C)]
+struct Elf_Nhdr {
+    n_namesz: u32,
+    n_descsz: u32,
+    n_type: u32,
+}
+
+// Note represents an ELF note (header + contents). The name is left as a u8
+// slice because it is not always null terminated and rust makes it easy enough
+// to check that the bytes match eitherway.
+struct Note<'a> {
+    name: &'a [u8],
+    desc: &'a [u8],
+    tipe: u32,
+}
+
+// NoteIter lets you safely iterate over a note segment. It terminates as soon
+// as an error occurs or there are no more notes. If you iterate over invalid
+// data it will function as though no notes were found.
+struct NoteIter<'a> {
+    base: &'a [u8],
+    error: bool,
+}
+
+impl<'a> NoteIter<'a> {
+    // It is an invariant of function that the pointer and size given denote a
+    // valid range of bytes that can all be read. The contents of these bytes
+    // can be anything but the range must be valid for this to be safe.
+    unsafe fn new(base: *const u8, size: usize) -> Self {
+        NoteIter {
+            base: from_raw_parts(base, size),
+            error: false,
+        }
+    }
+}
+
+// align_to aligns 'x' to 'to'-byte alignment assuming 'to' is a power of 2.
+// This follows a standard pattern in C/C++ ELF parsing code where
+// (x + to - 1) & -to is used. Rust does not let you negate usize so I use
+// 2's-complement conversion to recreate that.
+fn align_to(x: usize, to: usize) -> usize {
+    (x + to - 1) & (!to + 1)
+}
+
+// take_bytes_align4 consumes num bytes from the slice (if present) and
+// additionally ensures that the final slice is properlly aligned. If an
+// either the number of bytes requested is too large or the slice can't be
+// realigned afterwards due to not enough remaining bytes existing, None is
+// returned and the slice is not modified.
+fn take_bytes_align4<'a>(num: usize, bytes: &mut &'a [u8]) -> Option<&'a [u8]> {
+    if bytes.len() < align_to(num, 4) {
+        return None;
+    }
+    let (out, bytes_new) = bytes.split_at(num);
+    *bytes = &bytes_new[align_to(num, 4) - num..];
+    Some(out)
+}
+
+// This function has no real invariants the caller must uphold other than
+// perhaps that 'bytes' should be aligned for performance (and on some
+// architectures correctness). The values in the Elf_Nhdr fields might
+// be nonsense but this function ensures no such thing.
+fn take_nhdr<'a>(bytes: &mut &'a [u8]) -> Option<&'a Elf_Nhdr> {
+    if size_of::<Elf_Nhdr>() > bytes.len() {
+        return None;
+    }
+    // This is safe as long as there is enough space and we just confirmed that
+    // in the if statement above so this should not be unsafe.
+    let out = unsafe { transmute::<*const u8, &'a Elf_Nhdr>(bytes.as_ptr()) };
+    // Note that sice_of::<Elf_Nhdr>() is always 4-byte aligned.
+    *bytes = &bytes[size_of::<Elf_Nhdr>()..];
+    Some(out)
+}
+
+impl<'a> Iterator for NoteIter<'a> {
+    type Item = Note<'a>;
+    fn next(&mut self) -> Option<Self::Item> {
+        // Check if we've reached the end.
+        if self.base.len() == 0 || self.error {
+            return None;
+        }
+        // We transmute out an nhdr but we carefully consider the resulting
+        // struct. We don't trust the namesz or descsz and we make no unsafe
+        // decisions based on the type. So even if we get out complete garbage
+        // we should still be safe.
+        let nhdr = take_nhdr(&mut self.base)?;
+        let name = take_bytes_align4(nhdr.n_namesz as usize, &mut self.base)?;
+        let desc = take_bytes_align4(nhdr.n_descsz as usize, &mut self.base)?;
+        Some(Note {
+            name: name,
+            desc: desc,
+            tipe: nhdr.n_type,
+        })
+    }
+}
+
+struct Perm(u32);
+
+/// Indicates that a segment is executable.
+const PERM_X: u32 = 0b00000001;
+/// Indicates that a segment is writable.
+const PERM_W: u32 = 0b00000010;
+/// Indicates that a segment is readable.
+const PERM_R: u32 = 0b00000100;
+
+impl core::fmt::Display for Perm {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let v = self.0;
+        if v & PERM_R != 0 {
+            f.write_char('r')?
+        }
+        if v & PERM_W != 0 {
+            f.write_char('w')?
+        }
+        if v & PERM_X != 0 {
+            f.write_char('x')?
+        }
+        Ok(())
+    }
+}
+
+/// Represents an ELF segment at runtime.
+struct Segment {
+    /// Gives the runtime virtual address of this segment's contents.
+    addr: usize,
+    /// Gives the memory size of this segment's contents.
+    size: usize,
+    /// Gives the module virtual address of this segment with the ELF file.
+    mod_rel_addr: usize,
+    /// Gives the permissions found in the ELF file. These permissions are not
+    /// necessarily the permissions present at runtime however.
+    flags: Perm,
+}
+
+/// Lets one iterate over Segments from a DSO.
+struct SegmentIter<'a> {
+    phdrs: &'a [Elf_Phdr],
+    base: usize,
+}
+
+impl Iterator for SegmentIter<'_> {
+    type Item = Segment;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.phdrs.split_first().and_then(|(phdr, new_phdrs)| {
+            self.phdrs = new_phdrs;
+            if phdr.p_type != PT_LOAD {
+                self.next()
+            } else {
+                Some(Segment {
+                    addr: phdr.p_vaddr as usize + self.base,
+                    size: phdr.p_memsz as usize,
+                    mod_rel_addr: phdr.p_vaddr as usize,
+                    flags: Perm(phdr.p_flags),
+                })
+            }
+        })
+    }
+}
+
+/// Represents an ELF DSO (Dynamic Shared Object). This type references
+/// the data stored in the actual DSO rather than making its own copy.
+struct Dso<'a> {
+    /// The dynamic linker always gives us a name, even if the name is empty.
+    /// In the case of the main executable this name will be empty. In the case
+    /// of a shared object it will be the soname (see DT_SONAME).
+    name: &'a str,
+    /// On Fuchsia virtually all binaries have build IDs but this is not a strict
+    /// requirement. There's no way to match up DSO information with a real ELF
+    /// file afterwards if there is no build_id so we require that every DSO
+    /// have one here. DSO's without a build_id are ignored.
+    build_id: &'a [u8],
+
+    base: usize,
+    phdrs: &'a [Elf_Phdr],
+}
+
+impl Dso<'_> {
+    /// Returns an iterator over Segments in this DSO.
+    fn segments(&self) -> SegmentIter<'_> {
+        SegmentIter {
+            phdrs: self.phdrs.as_ref(),
+            base: self.base,
+        }
+    }
+}
+
+struct HexSlice<'a> {
+    bytes: &'a [u8],
+}
+
+impl fmt::Display for HexSlice<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for byte in self.bytes {
+            write!(f, "{:02x}", byte)?;
+        }
+        Ok(())
+    }
+}
+
+fn get_build_id<'a>(info: &'a dl_phdr_info) -> Option<&'a [u8]> {
+    for phdr in info.program_headers() {
+        if phdr.phdr.p_type == PT_NOTE {
+            for note in phdr.notes() {
+                if note.tipe == NT_GNU_BUILD_ID && (note.name == b"GNU\0" || note.name == b"GNU") {
+                    return Some(note.desc);
+                }
+            }
+        }
+    }
+    None
+}
+
+/// These errors encode issues that arise while parsing information about
+/// each DSO.
+enum Error {
+    /// NameError means that an error occurred while converting a C style string
+    /// into a rust string.
+    NameError(core::str::Utf8Error),
+    /// BuildIDError means that we didn't find a build ID. This could either be
+    /// because the DSO had no build ID or because the segment containing the
+    /// build ID was malformed.
+    BuildIDError,
+}
+
+/// Calls either 'dso' or 'error' for each DSO linked into the process by the
+/// dynamic linker.
+///
+/// # Arguments
+///
+/// * `visitor` - A DsoPrinter that will have one of eats methods called foreach DSO.
+fn for_each_dso(mut visitor: &mut DsoPrinter<'_, '_>) {
+    extern "C" fn callback(
+        info: &dl_phdr_info,
+        _size: usize,
+        visitor: &mut DsoPrinter<'_, '_>,
+    ) -> i32 {
+        // dl_iterate_phdr ensures that info.name will point to a valid
+        // location.
+        let name_len = unsafe { libc::strlen(info.name) };
+        let name_slice: &[u8] =
+            unsafe { core::slice::from_raw_parts(info.name as *const u8, name_len) };
+        let name = match core::str::from_utf8(name_slice) {
+            Ok(name) => name,
+            Err(err) => {
+                return visitor.error(Error::NameError(err)) as i32;
+            }
+        };
+        let build_id = match get_build_id(info) {
+            Some(build_id) => build_id,
+            None => {
+                return visitor.error(Error::BuildIDError) as i32;
+            }
+        };
+        visitor.dso(Dso {
+            name: name,
+            build_id: build_id,
+            phdrs: info.phdr_slice(),
+            base: info.addr as usize,
+        }) as i32
+    }
+    unsafe { dl_iterate_phdr(callback, &mut visitor) };
+}
+
+struct DsoPrinter<'a, 'b> {
+    writer: &'a mut core::fmt::Formatter<'b>,
+    module_count: usize,
+    error: core::fmt::Result,
+}
+
+impl DsoPrinter<'_, '_> {
+    fn dso(&mut self, dso: Dso<'_>) -> bool {
+        let mut write = || {
+            write!(
+                self.writer,
+                "{{{{{{module:{:#x}:{}:elf:{}}}}}}}\n",
+                self.module_count,
+                dso.name,
+                HexSlice {
+                    bytes: dso.build_id.as_ref()
+                }
+            )?;
+            for seg in dso.segments() {
+                write!(
+                    self.writer,
+                    "{{{{{{mmap:{:#x}:{:#x}:load:{:#x}:{}:{:#x}}}}}}}\n",
+                    seg.addr, seg.size, self.module_count, seg.flags, seg.mod_rel_addr
+                )?;
+            }
+            self.module_count += 1;
+            Ok(())
+        };
+        match write() {
+            Ok(()) => false,
+            Err(err) => {
+                self.error = Err(err);
+                true
+            }
+        }
+    }
+    fn error(&mut self, _error: Error) -> bool {
+        false
+    }
+}
+
+/// This function prints the Fuchsia symbolizer markup for all information contained in a DSO.
+pub fn print_dso_context(out: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    out.write_str("{{{reset:begin}}}\n")?;
+    let mut visitor = DsoPrinter {
+        writer: out,
+        module_count: 0,
+        error: Ok(()),
+    };
+    for_each_dso(&mut visitor);
+    visitor.error
+}
+
+/// This function prints the Fuchsia symbolizer markup to end the backtrace.
+pub fn finish_context(out: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    out.write_str("{{{reset:end}}}\n")
+}