blob: 27997f636dfdb742b3d90a525006e878678efd5b (
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
|
//===- lib/ReaderWriter/ELF/Mips/MipsExecutableWriter.h -------------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLD_READER_WRITER_ELF_MIPS_MIPS_EXECUTABLE_WRITER_H
#define LLD_READER_WRITER_ELF_MIPS_MIPS_EXECUTABLE_WRITER_H
#include "ExecutableWriter.h"
#include "MipsDynamicTable.h"
#include "MipsELFWriters.h"
#include "MipsLinkingContext.h"
namespace lld {
namespace elf {
template <typename ELFT> class MipsTargetLayout;
template <class ELFT>
class MipsExecutableWriter : public ExecutableWriter<ELFT> {
public:
MipsExecutableWriter(MipsLinkingContext &context,
MipsTargetLayout<ELFT> &layout);
protected:
void buildDynamicSymbolTable(const File &file) override;
// Add any runtime files and their atoms to the output
bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
void finalizeDefaultAtomValues() override;
error_code setELFHeader() override {
ExecutableWriter<ELFT>::setELFHeader();
_writeHelper.setELFHeader(*this->_elfHeader);
return error_code::success();
}
LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>) createDynamicTable();
LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<ELFT>) createDynamicSymbolTable();
private:
MipsELFWriter<ELFT> _writeHelper;
MipsLinkingContext &_mipsContext;
MipsTargetLayout<Mips32ElELFType> &_mipsTargetLayout;
};
template <class ELFT>
MipsExecutableWriter<ELFT>::MipsExecutableWriter(MipsLinkingContext &context,
MipsTargetLayout<ELFT> &layout)
: ExecutableWriter<ELFT>(context, layout), _writeHelper(context, layout),
_mipsContext(context), _mipsTargetLayout(layout) {}
template <class ELFT>
void MipsExecutableWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
// MIPS ABI requires to add to dynsym even undefined symbols
// if they have a corresponding entries in a global part of GOT.
for (const UndefinedAtom *a : file.undefined())
// FIXME (simon): Consider to move this check to the
// MipsELFUndefinedAtom class method. That allows to
// handle more complex coditions in the future.
if (_writeHelper.hasGlobalGOTEntry(a))
this->_dynamicSymbolTable->addSymbol(a, ELF::SHN_UNDEF);
ExecutableWriter<ELFT>::buildDynamicSymbolTable(file);
}
template <class ELFT>
bool MipsExecutableWriter<ELFT>::createImplicitFiles(
std::vector<std::unique_ptr<File>> &result) {
ExecutableWriter<ELFT>::createImplicitFiles(result);
result.push_back(std::move(_writeHelper.createRuntimeFile()));
return true;
}
template <class ELFT>
void MipsExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
// Finalize the atom values that are part of the parent.
ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
_writeHelper.finalizeMipsRuntimeAtomValues();
}
/// \brief create dynamic table
template <class ELFT>
LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>)
MipsExecutableWriter<ELFT>::createDynamicTable() {
return LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>)(new (
this->_alloc) MipsDynamicTable<ELFT>(_mipsContext, _mipsTargetLayout));
}
/// \brief create dynamic symbol table
template <class ELFT>
LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<ELFT>)
MipsExecutableWriter<ELFT>::createDynamicSymbolTable() {
return LLD_UNIQUE_BUMP_PTR(
DynamicSymbolTable<ELFT>)(new (this->_alloc) MipsDynamicSymbolTable<ELFT>(
_mipsContext, _mipsTargetLayout));
}
} // namespace elf
} // namespace lld
#endif
|
