1 | //===- LookupResult.h -------------------------------------------*- C++ -*-===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #ifndef LLVM_DEBUGINFO_GSYM_LOOKUPRESULT_H |
10 | #define LLVM_DEBUGINFO_GSYM_LOOKUPRESULT_H |
11 | |
12 | #include "llvm/ADT/AddressRanges.h" |
13 | #include "llvm/ADT/StringRef.h" |
14 | #include <inttypes.h> |
15 | #include <vector> |
16 | |
17 | namespace llvm { |
18 | class raw_ostream; |
19 | namespace gsym { |
20 | |
21 | struct SourceLocation { |
22 | StringRef Name; ///< Function or symbol name. |
23 | StringRef Dir; ///< Line entry source file directory path. |
24 | StringRef Base; ///< Line entry source file basename. |
25 | uint32_t Line = 0; ///< Source file line number. |
26 | uint32_t Offset = 0; ///< Byte size offset within the named function. |
27 | }; |
28 | |
29 | inline bool operator==(const SourceLocation &LHS, const SourceLocation &RHS) { |
30 | return LHS.Name == RHS.Name && LHS.Dir == RHS.Dir && LHS.Base == RHS.Base && |
31 | LHS.Line == RHS.Line && LHS.Offset == RHS.Offset; |
32 | } |
33 | |
34 | raw_ostream &operator<<(raw_ostream &OS, const SourceLocation &R); |
35 | |
36 | using SourceLocations = std::vector<SourceLocation>; |
37 | |
38 | struct LookupResult { |
39 | uint64_t LookupAddr = 0; ///< The address that this lookup pertains to. |
40 | AddressRange FuncRange; ///< The concrete function address range. |
41 | StringRef FuncName; ///< The concrete function name that contains LookupAddr. |
42 | /// The source locations that match this address. This information will only |
43 | /// be filled in if the FunctionInfo contains a line table. If an address is |
44 | /// for a concrete function with no inlined functions, this array will have |
45 | /// one entry. If an address points to an inline function, there will be one |
46 | /// SourceLocation for each inlined function with the last entry pointing to |
47 | /// the concrete function itself. This allows one address to generate |
48 | /// multiple locations and allows unwinding of inline call stacks. The |
49 | /// deepest inline function will appear at index zero in the source locations |
50 | /// array, and the concrete function will appear at the end of the array. |
51 | SourceLocations Locations; |
52 | std::string getSourceFile(uint32_t Index) const; |
53 | }; |
54 | |
55 | inline bool operator==(const LookupResult &LHS, const LookupResult &RHS) { |
56 | if (LHS.LookupAddr != RHS.LookupAddr) |
57 | return false; |
58 | if (LHS.FuncRange != RHS.FuncRange) |
59 | return false; |
60 | if (LHS.FuncName != RHS.FuncName) |
61 | return false; |
62 | return LHS.Locations == RHS.Locations; |
63 | } |
64 | |
65 | raw_ostream &operator<<(raw_ostream &OS, const LookupResult &R); |
66 | |
67 | } // namespace gsym |
68 | } // namespace llvm |
69 | |
70 | #endif // LLVM_DEBUGINFO_GSYM_LOOKUPRESULT_H |
71 | |