-
Notifications
You must be signed in to change notification settings - Fork 10.8k
/
LinkerScript.h
216 lines (175 loc) · 6.26 KB
/
LinkerScript.h
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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
//===- LinkerScript.h -------------------------------------------*- C++ -*-===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLD_ELF_LINKER_SCRIPT_H
#define LLD_ELF_LINKER_SCRIPT_H
#include "Strings.h"
#include "Writer.h"
#include "lld/Core/LLVM.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Regex.h"
#include <functional>
namespace lld {
namespace elf {
class DefinedCommon;
class ScriptParser;
class SymbolBody;
template <class ELFT> class InputSectionBase;
template <class ELFT> class OutputSectionBase;
template <class ELFT> class OutputSectionFactory;
class InputSectionData;
typedef std::function<uint64_t(uint64_t)> Expr;
// Parses a linker script. Calling this function updates
// Config and ScriptConfig.
void readLinkerScript(MemoryBufferRef MB);
void readVersionScript(MemoryBufferRef MB);
// This enum is used to implement linker script SECTIONS command.
// https://sourceware.org/binutils/docs/ld/SECTIONS.html#SECTIONS
enum SectionsCommandKind {
AssignmentKind,
OutputSectionKind,
InputSectionKind,
AssertKind
};
struct BaseCommand {
BaseCommand(int K) : Kind(K) {}
virtual ~BaseCommand() {}
int Kind;
};
struct SymbolAssignment : BaseCommand {
SymbolAssignment(StringRef Name, Expr E, bool IsAbsolute)
: BaseCommand(AssignmentKind), Name(Name), Expression(E),
IsAbsolute(IsAbsolute) {}
static bool classof(const BaseCommand *C);
// The LHS of an expression. Name is either a symbol name or ".".
StringRef Name;
SymbolBody *Sym = nullptr;
// The RHS of an expression.
Expr Expression;
// Command attributes for PROVIDE, HIDDEN and PROVIDE_HIDDEN.
bool Provide = false;
bool Hidden = false;
bool IsAbsolute;
InputSectionData *GoesAfter = nullptr;
};
// Linker scripts allow additional constraints to be put on ouput sections.
// An output section will only be created if all of its input sections are
// read-only
// or all of its input sections are read-write by using the keyword ONLY_IF_RO
// and ONLY_IF_RW respectively.
enum class ConstraintKind { NoConstraint, ReadOnly, ReadWrite };
struct OutputSectionCommand : BaseCommand {
OutputSectionCommand(StringRef Name)
: BaseCommand(OutputSectionKind), Name(Name) {}
static bool classof(const BaseCommand *C);
StringRef Name;
Expr AddrExpr;
Expr AlignExpr;
Expr LmaExpr;
Expr SubalignExpr;
std::vector<std::unique_ptr<BaseCommand>> Commands;
std::vector<StringRef> Phdrs;
std::vector<uint8_t> Filler;
ConstraintKind Constraint = ConstraintKind::NoConstraint;
};
enum SortKind { SortNone, SortByName, SortByAlignment };
struct InputSectionDescription : BaseCommand {
InputSectionDescription(StringRef FilePattern)
: BaseCommand(InputSectionKind),
FileRe(compileGlobPatterns({FilePattern})) {}
static bool classof(const BaseCommand *C);
llvm::Regex FileRe;
SortKind SortOuter = SortNone;
SortKind SortInner = SortNone;
llvm::Regex ExcludedFileRe;
llvm::Regex SectionRe;
};
struct AssertCommand : BaseCommand {
AssertCommand(Expr E) : BaseCommand(AssertKind), Expression(E) {}
static bool classof(const BaseCommand *C);
Expr Expression;
};
struct PhdrsCommand {
StringRef Name;
unsigned Type;
bool HasFilehdr;
bool HasPhdrs;
unsigned Flags;
Expr LMAExpr;
};
class LinkerScriptBase {
protected:
~LinkerScriptBase() = default;
public:
virtual uint64_t getOutputSectionAddress(StringRef Name) = 0;
virtual uint64_t getOutputSectionSize(StringRef Name) = 0;
virtual uint64_t getOutputSectionAlign(StringRef Name) = 0;
virtual uint64_t getHeaderSize() = 0;
virtual uint64_t getSymbolValue(StringRef S) = 0;
};
// ScriptConfiguration holds linker script parse results.
struct ScriptConfiguration {
// Used to create symbol assignments outside SECTIONS command.
std::vector<std::unique_ptr<SymbolAssignment>> Assignments;
// Used to assign addresses to sections.
std::vector<std::unique_ptr<BaseCommand>> Commands;
// Used to assign sections to headers.
std::vector<PhdrsCommand> PhdrsCommands;
bool HasContents = false;
llvm::BumpPtrAllocator Alloc;
// List of section patterns specified with KEEP commands. They will
// be kept even if they are unused and --gc-sections is specified.
std::vector<llvm::Regex *> KeptSections;
};
extern ScriptConfiguration *ScriptConfig;
// This is a runner of the linker script.
template <class ELFT> class LinkerScript final : public LinkerScriptBase {
typedef typename ELFT::uint uintX_t;
public:
LinkerScript();
~LinkerScript();
void createAssignments();
void createSections(OutputSectionFactory<ELFT> &Factory);
std::vector<PhdrEntry<ELFT>> createPhdrs();
bool ignoreInterpSection();
ArrayRef<uint8_t> getFiller(StringRef Name);
Expr getLma(StringRef Name);
bool shouldKeep(InputSectionBase<ELFT> *S);
void assignAddresses();
int compareSections(StringRef A, StringRef B);
bool hasPhdrsCommands();
uint64_t getOutputSectionAddress(StringRef Name) override;
uint64_t getOutputSectionSize(StringRef Name) override;
uint64_t getOutputSectionAlign(StringRef Name) override;
uint64_t getHeaderSize() override;
uint64_t getSymbolValue(StringRef S) override;
std::vector<OutputSectionBase<ELFT> *> *OutputSections;
private:
std::vector<InputSectionBase<ELFT> *>
getInputSections(const InputSectionDescription *);
void discard(OutputSectionCommand &Cmd);
std::vector<InputSectionBase<ELFT> *>
createInputSectionList(OutputSectionCommand &Cmd);
// "ScriptConfig" is a bit too long, so define a short name for it.
ScriptConfiguration &Opt = *ScriptConfig;
int getSectionIndex(StringRef Name);
std::vector<size_t> getPhdrIndices(StringRef SectionName);
size_t getPhdrIndex(StringRef PhdrName);
uintX_t Dot;
};
// Variable template is a C++14 feature, so we can't template
// a global variable. Use a struct to workaround.
template <class ELFT> struct Script { static LinkerScript<ELFT> *X; };
template <class ELFT> LinkerScript<ELFT> *Script<ELFT>::X;
extern LinkerScriptBase *ScriptBase;
} // namespace elf
} // namespace lld
#endif