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
|
//===- lib/ReaderWriter/PECOFF/PECOFFLinkingContext.cpp -------------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "Atoms.h"
#include "GroupedSectionsPass.h"
#include "IdataPass.h"
#include "LinkerGeneratedSymbolFile.h"
#include "lld/Core/PassManager.h"
#include "lld/Passes/LayoutPass.h"
#include "lld/Passes/RoundTripNativePass.h"
#include "lld/Passes/RoundTripYAMLPass.h"
#include "lld/ReaderWriter/PECOFFLinkingContext.h"
#include "lld/ReaderWriter/Reader.h"
#include "lld/ReaderWriter/Simple.h"
#include "lld/ReaderWriter/Writer.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/Path.h"
#include <bitset>
#include <set>
namespace lld {
namespace {} // anonymous namespace
bool PECOFFLinkingContext::validateImpl(raw_ostream &diagnostics) {
if (_stackReserve < _stackCommit) {
diagnostics << "Invalid stack size: reserve size must be equal to or "
<< "greater than commit size, but got " << _stackCommit
<< " and " << _stackReserve << ".\n";
return false;
}
if (_heapReserve < _heapCommit) {
diagnostics << "Invalid heap size: reserve size must be equal to or "
<< "greater than commit size, but got " << _heapCommit
<< " and " << _heapReserve << ".\n";
return false;
}
// It's an error if the base address is not multiple of 64K.
if (_baseAddress & 0xffff) {
diagnostics << "Base address have to be multiple of 64K, but got "
<< _baseAddress << "\n";
return false;
}
std::bitset<64> alignment(_sectionAlignment);
if (alignment.count() != 1) {
diagnostics << "Section alignment must be a power of 2, but got "
<< _sectionAlignment << "\n";
return false;
}
// Architectures other than i386 is not supported yet.
if (_machineType != llvm::COFF::IMAGE_FILE_MACHINE_I386) {
diagnostics << "Machine type other than x86 is not supported.\n";
return false;
}
_reader = createReaderPECOFF(*this);
_writer = createWriterPECOFF(*this);
return true;
}
std::unique_ptr<File> PECOFFLinkingContext::createEntrySymbolFile() const {
if (entrySymbolName().empty())
return nullptr;
std::unique_ptr<SimpleFile> entryFile(
new SimpleFile(*this, "command line option /entry"));
entryFile->addAtom(
*(new (_allocator) SimpleUndefinedAtom(*entryFile, entrySymbolName())));
return std::move(entryFile);
}
std::unique_ptr<File> PECOFFLinkingContext::createUndefinedSymbolFile() const {
if (_initialUndefinedSymbols.empty())
return nullptr;
std::unique_ptr<SimpleFile> undefinedSymFile(
new SimpleFile(*this, "command line option /c (or) /include"));
for (auto undefSymStr : _initialUndefinedSymbols)
undefinedSymFile->addAtom(*(new (_allocator) SimpleUndefinedAtom(
*undefinedSymFile, undefSymStr)));
return std::move(undefinedSymFile);
}
bool PECOFFLinkingContext::createImplicitFiles(
std::vector<std::unique_ptr<File> > &) const {
std::unique_ptr<SimpleFileNode> fileNode(
new SimpleFileNode("Implicit Files"));
std::unique_ptr<File> linkerGeneratedSymFile(
new coff::LinkerGeneratedSymbolFile(*this));
fileNode->appendInputFile(std::move(linkerGeneratedSymFile));
inputGraph().insertOneElementAt(std::move(fileNode),
InputGraph::Position::END);
return true;
}
/// Returns the section name in the resulting executable.
///
/// Sections in object files are usually output to the executable with the same
/// name, but you can rename by command line option. /merge:from=to makes the
/// linker to combine "from" section contents to "to" section in the
/// executable. We have a mapping for the renaming. This method looks up the
/// table and returns a new section name if renamed.
StringRef
PECOFFLinkingContext::getFinalSectionName(StringRef sectionName) const {
auto it = _renamedSections.find(sectionName);
if (it == _renamedSections.end())
return sectionName;
return getFinalSectionName(it->second);
}
/// Adds a mapping to the section renaming table. This method will be used for
/// /merge command line option.
bool PECOFFLinkingContext::addSectionRenaming(raw_ostream &diagnostics,
StringRef from, StringRef to) {
auto it = _renamedSections.find(from);
if (it != _renamedSections.end()) {
if (it->second == to)
// There's already the same mapping.
return true;
diagnostics << "Section \"" << from << "\" is already mapped to \""
<< it->second << ", so it cannot be mapped to \"" << to << "\".";
return true;
}
// Add a mapping, and check if there's no cycle in the renaming mapping. The
// cycle detection algorithm we use here is naive, but that's OK because the
// number of mapping is usually less than 10.
_renamedSections[from] = to;
for (auto elem : _renamedSections) {
StringRef sectionName = elem.first;
std::set<StringRef> visited;
visited.insert(sectionName);
for (;;) {
auto it = _renamedSections.find(sectionName);
if (it == _renamedSections.end())
break;
if (visited.count(it->second)) {
diagnostics << "/merge:" << from << "=" << to << " makes a cycle";
return false;
}
sectionName = it->second;
visited.insert(sectionName);
}
}
return true;
}
/// Try to find the input library file from the search paths and append it to
/// the input file list. Returns true if the library file is found.
StringRef PECOFFLinkingContext::searchLibraryFile(StringRef filename) const {
// Current directory always takes precedence over the search paths.
if (llvm::sys::path::is_absolute(filename) || llvm::sys::fs::exists(filename))
return filename;
// Iterate over the search paths.
for (StringRef dir : _inputSearchPaths) {
SmallString<128> path = dir;
llvm::sys::path::append(path, filename);
if (llvm::sys::fs::exists(path.str()))
return allocateString(path.str());
}
return filename;
}
Writer &PECOFFLinkingContext::writer() const { return *_writer; }
#define LLD_CASE(name) .Case(#name, llvm::COFF::name)
ErrorOr<Reference::Kind>
PECOFFLinkingContext::relocKindFromString(StringRef str) const {
int32_t ret = llvm::StringSwitch<int32_t>(str)
LLD_CASE(IMAGE_REL_I386_ABSOLUTE)
LLD_CASE(IMAGE_REL_I386_DIR32)
LLD_CASE(IMAGE_REL_I386_DIR32NB)
LLD_CASE(IMAGE_REL_I386_REL32)
.Default(-1);
if (ret == -1)
return make_error_code(YamlReaderError::illegal_value);
return ret;
}
#undef LLD_CASE
#define LLD_CASE(name) \
case llvm::COFF::name: \
return std::string(#name);
ErrorOr<std::string>
PECOFFLinkingContext::stringFromRelocKind(Reference::Kind kind) const {
switch (kind) {
LLD_CASE(IMAGE_REL_I386_ABSOLUTE)
LLD_CASE(IMAGE_REL_I386_DIR32)
LLD_CASE(IMAGE_REL_I386_DIR32NB)
LLD_CASE(IMAGE_REL_I386_REL32)
}
return make_error_code(YamlReaderError::illegal_value);
}
void PECOFFLinkingContext::addPasses(PassManager &pm) {
pm.add(std::unique_ptr<Pass>(new pecoff::GroupedSectionsPass()));
pm.add(std::unique_ptr<Pass>(new pecoff::IdataPass(*this)));
pm.add(std::unique_ptr<Pass>(new LayoutPass()));
}
} // end namespace lld
|
