blob: fccfd28dff8a38a4873f1997a2d53416cb380378 (
plain)
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
|
//===- SymbolListFile.cpp -------------------------------------------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the parser/evaluator of the linker script.
// It does not construct an AST but consume linker script directives directly.
// Results are written to Driver or Config object.
//
//===----------------------------------------------------------------------===//
#include "SymbolListFile.h"
#include "Config.h"
#include "ScriptParser.h"
#include "llvm/Support/MemoryBuffer.h"
using namespace llvm;
using namespace lld;
using namespace lld::elf;
// Parse the --dynamic-list argument. A dynamic list is in the form
//
// { symbol1; symbol2; [...]; symbolN };
//
// Multiple groups can be defined in the same file and they are merged
// in only one definition.
class DynamicListParser final : public ScriptParserBase {
public:
DynamicListParser(StringRef S) : ScriptParserBase(S) {}
void run();
private:
void readGroup();
};
// Parse the default group definition using C language symbol name.
void DynamicListParser::readGroup() {
expect("{");
while (!Error) {
Config->DynamicList.push_back(next());
expect(";");
if (peek() == "}") {
next();
break;
}
}
expect(";");
}
void DynamicListParser::run() {
while (!atEOF())
readGroup();
}
void elf::parseDynamicList(MemoryBufferRef MB) {
DynamicListParser(MB.getBuffer()).run();
}
// Parse the --version-script argument. We currently only accept the following
// version script syntax:
//
// { [ global: symbol1; symbol2; [...]; symbolN; ] local: *; };
//
// No wildcards are supported, other than for the local entry. Symbol versioning
// is also not supported.
class VersionScriptParser final : public ScriptParserBase {
public:
VersionScriptParser(StringRef S) : ScriptParserBase(S) {}
void run();
private:
void parseVersion(StringRef Version);
void parseLocal();
void parseVersionSymbols(StringRef Version);
};
void VersionScriptParser::parseVersion(StringRef Version) {
expect("{");
if (peek() == "global:") {
next();
parseVersionSymbols(Version);
}
if (peek() == "local:")
parseLocal();
else if (peek() != "}")
parseVersionSymbols(Version);
expect("}");
if (!Version.empty() && peek() != ";")
Config->SymbolVersions.back().Parent = next();
expect(";");
}
void VersionScriptParser::parseLocal() {
expect("local:");
expect("*");
expect(";");
Config->VersionScriptGlobalByDefault = false;
}
void VersionScriptParser::parseVersionSymbols(StringRef Version) {
std::vector<StringRef> *Globals;
if (Version.empty()) {
Globals = &Config->VersionScriptGlobals;
} else {
Config->SymbolVersions.push_back(elf::Version(Version));
Globals = &Config->SymbolVersions.back().Globals;
}
for (;;) {
StringRef Cur = peek();
if (Cur == "extern")
setError("extern keyword is not supported");
if (Cur == "}" || Cur == "local:" || Error)
return;
next();
Globals->push_back(Cur);
expect(";");
}
}
void VersionScriptParser::run() {
StringRef Msg = "anonymous version definition is used in "
"combination with other version definitions";
if (peek() == "{") {
parseVersion("");
if (!atEOF())
setError(Msg);
return;
}
while (!atEOF() && !Error) {
if (peek() == "{") {
setError(Msg);
return;
}
parseVersion(next());
}
}
void elf::parseVersionScript(MemoryBufferRef MB) {
VersionScriptParser(MB.getBuffer()).run();
}
|
