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
160
|
//===- tools/dsymutil/RelocationMap.h -------------------------- *- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
/// \file
///
/// This file contains the class declaration of the RelocationMap
/// entity. RelocationMap lists all the relocations of all the
/// atoms used in the object files linked together to
/// produce an executable.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_DSYMUTIL_RELOCATIONMAP_H
#define LLVM_TOOLS_DSYMUTIL_RELOCATIONMAP_H
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/Support/YAMLTraits.h"
#include "llvm/TargetParser/Triple.h"
#include <optional>
#include <string>
#include <vector>
namespace llvm {
class raw_ostream;
namespace dsymutil {
struct SymbolMapping {
std::optional<yaml::Hex64> ObjectAddress;
yaml::Hex64 BinaryAddress;
yaml::Hex32 Size;
SymbolMapping(std::optional<uint64_t> ObjectAddr, uint64_t BinaryAddress,
uint32_t Size)
: BinaryAddress(BinaryAddress), Size(Size) {
if (ObjectAddr)
ObjectAddress = *ObjectAddr;
}
/// For YAML IO support
SymbolMapping() = default;
};
/// ValidReloc represents one relocation entry described by the RelocationMap.
/// It contains a list of DWARF relocations to apply to a linked binary.
class ValidReloc {
public:
yaml::Hex64 Offset;
yaml::Hex32 Size;
yaml::Hex64 Addend;
std::string SymbolName;
struct SymbolMapping SymbolMapping;
struct SymbolMapping getSymbolMapping() const { return SymbolMapping; }
ValidReloc(uint64_t Offset, uint32_t Size, uint64_t Addend,
StringRef SymbolName, struct SymbolMapping SymbolMapping)
: Offset(Offset), Size(Size), Addend(Addend), SymbolName(SymbolName),
SymbolMapping(SymbolMapping) {}
bool operator<(const ValidReloc &RHS) const { return Offset < RHS.Offset; }
/// For YAMLIO support.
ValidReloc() = default;
};
/// The RelocationMap object stores the list of relocation entries for a binary
class RelocationMap {
Triple BinaryTriple;
std::string BinaryPath;
using RelocContainer = std::vector<ValidReloc>;
RelocContainer Relocations;
/// For YAML IO support.
///@{
friend yaml::MappingTraits<std::unique_ptr<RelocationMap>>;
friend yaml::MappingTraits<RelocationMap>;
RelocationMap() = default;
///@}
public:
RelocationMap(const Triple &BinaryTriple, StringRef BinaryPath)
: BinaryTriple(BinaryTriple), BinaryPath(std::string(BinaryPath)) {}
using const_iterator = RelocContainer::const_iterator;
iterator_range<const_iterator> relocations() const {
return make_range(begin(), end());
}
const_iterator begin() const { return Relocations.begin(); }
const_iterator end() const { return Relocations.end(); }
size_t getNumberOfEntries() const { return Relocations.size(); }
/// This function adds a ValidReloc to the list owned by this
/// relocation map.
void addRelocationMapEntry(const ValidReloc &Relocation);
const Triple &getTriple() const { return BinaryTriple; }
StringRef getBinaryPath() const { return BinaryPath; }
void print(raw_ostream &OS) const;
#ifndef NDEBUG
void dump() const;
#endif
/// Read a relocation map from \a InputFile.
static ErrorOr<std::unique_ptr<RelocationMap>>
parseYAMLRelocationMap(StringRef InputFile, StringRef PrependPath);
};
} // end namespace dsymutil
} // end namespace llvm
LLVM_YAML_IS_SEQUENCE_VECTOR(dsymutil::ValidReloc)
namespace llvm {
namespace yaml {
using namespace llvm::dsymutil;
template <> struct MappingTraits<dsymutil::ValidReloc> {
static void mapping(IO &io, dsymutil::ValidReloc &VR);
static const bool flow = true;
};
template <> struct MappingTraits<dsymutil::RelocationMap> {
struct YamlRM;
static void mapping(IO &io, dsymutil::RelocationMap &RM);
};
template <> struct MappingTraits<std::unique_ptr<dsymutil::RelocationMap>> {
struct YamlRM;
static void mapping(IO &io, std::unique_ptr<dsymutil::RelocationMap> &RM);
};
template <> struct ScalarTraits<Triple> {
static void output(const Triple &val, void *, raw_ostream &out);
static StringRef input(StringRef scalar, void *, Triple &value);
static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
};
} // end namespace yaml
} // end namespace llvm
#endif // LLVM_TOOLS_DSYMUTIL_RELOCATIONMAP_H
|
