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

use std::fmt;

use failure::Fail;

use symbolic_common::derive_failure;
use symbolic_debuginfo::ObjectError;

#[doc(hidden)]
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub enum ValueKind {
    Symbol,
    Function,
    File,
    Line,
    ParentOffset,
    Language,
}

impl fmt::Display for ValueKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match *self {
            ValueKind::Symbol => write!(f, "symbol"),
            ValueKind::Function => write!(f, "function"),
            ValueKind::File => write!(f, "file"),
            ValueKind::Line => write!(f, "line record"),
            ValueKind::ParentOffset => write!(f, "inline parent offset"),
            ValueKind::Language => write!(f, "language"),
        }
    }
}

/// Variants of `SymCacheError`.
#[derive(Clone, Copy, Debug, Eq, Fail, PartialEq)]
pub enum SymCacheErrorKind {
    /// Invalid magic bytes in the symcache header.
    #[fail(display = "bad symcache magic")]
    BadFileMagic,

    /// Invalid flags or fields in the symcache header.
    #[fail(display = "invalid symcache header")]
    BadFileHeader,

    /// A segment could not be read, likely due to IO errors.
    #[fail(display = "cannot read symcache segment")]
    BadSegment,

    /// Contents in the symcache file are malformed.
    #[fail(display = "malformed symcache file")]
    BadCacheFile,

    /// The symcache version is not known.
    #[fail(display = "unsupported symcache version")]
    UnsupportedVersion,

    /// The `Object` contains invalid data and cannot be converted.
    #[fail(display = "malformed debug info file")]
    BadDebugFile,

    /// A required debug section is missing in the `Object` file.
    #[fail(display = "missing debug section")]
    MissingDebugSection,

    /// The `Object` file was stripped of debug information.
    #[fail(display = "no debug information found in file")]
    MissingDebugInfo,

    /// The debug information in the `Object` file is not supported.
    #[fail(display = "unsupported debug information")]
    UnsupportedDebugKind,

    /// A value cannot be written to symcache as it overflows the record size.
    #[fail(display = "{} too large for symcache file format", _0)]
    ValueTooLarge(ValueKind),

    /// A value cannot be written to symcache as it overflows the segment counter.
    #[fail(display = "too many {}s for symcache", _0)]
    TooManyValues(ValueKind),

    /// Generic error when writing a symcache, most likely IO.
    #[fail(display = "failed to write symcache")]
    WriteFailed,
}

derive_failure!(
    SymCacheError,
    SymCacheErrorKind,
    doc = "An error returned when handling `SymCaches`.",
);

impl From<ObjectError> for SymCacheError {
    fn from(error: ObjectError) -> SymCacheError {
        error.context(SymCacheErrorKind::BadDebugFile).into()
    }
}