using namespace llvm::object;
namespace {
-// \brief Read a binary, find out based on the symbol table contents what kind
-// of symbol it is and create corresponding atoms for it
-template<class ELFT>
-class FileELF: public File {
+/// \brief Read a binary, find out based on the symbol table contents what kind
+/// of symbol it is and create corresponding atoms for it
+template <class ELFT> class FileELF : public File {
typedef Elf_Sym_Impl<ELFT> Elf_Sym;
typedef Elf_Shdr_Impl<ELFT> Elf_Shdr;
typedef Elf_Rel_Impl<ELFT, false> Elf_Rel;
public:
FileELF(std::unique_ptr<llvm::MemoryBuffer> MB, llvm::error_code &EC)
- : File(MB->getBufferIdentifier()) {
+ : File(MB->getBufferIdentifier()) {
llvm::OwningPtr<Binary> binaryFile;
EC = createBinary(MB.release(), binaryFile);
if (EC)
binaryFile.take();
- std::map< const Elf_Shdr *, std::vector<const Elf_Sym *>> sectionSymbols;
+ std::map<const Elf_Shdr *, std::vector<const Elf_Sym *>> sectionSymbols;
// Handle: SHT_REL and SHT_RELA sections:
// Increment over the sections, when REL/RELA section types are found add
auto rae(_objFile->endELFRela(section));
auto &Ref = _relocationAddendRefences[sectionName];
- for (; rai != rae; rai++) {
+ for (; rai != rae; ++rai) {
Ref.push_back(&*rai);
}
}
auto re(_objFile->endELFRel(section));
auto &Ref = _relocationReferences[sectionName];
- for (; ri != re; ri++) {
+ for (; ri != re; ++ri) {
Ref.push_back(&*ri);
}
}
return;
const Elf_Shdr *section = _objFile->getElfSection(sit);
- const Elf_Sym *symbol = _objFile->getElfSymbol(it);
+ const Elf_Sym *symbol = _objFile->getElfSymbol(it);
llvm::StringRef symbolName;
if ((EC = _objFile->getSymbolName(section, symbol, symbolName)))
if (symbol->st_shndx == llvm::ELF::SHN_ABS) {
// Create an absolute atom.
- auto *newAtom = new (_readerStorage.Allocate<
- ELFAbsoluteAtom<ELFT> > ())
- ELFAbsoluteAtom<ELFT>(
- *this, symbolName, symbol, symbol->st_value);
+ auto *newAtom = new (_readerStorage.Allocate<ELFAbsoluteAtom<ELFT>>())
+ ELFAbsoluteAtom<ELFT>(*this, symbolName, symbol,
+ symbol->st_value);
_absoluteAtoms._atoms.push_back(newAtom);
_symbolToAtomMapping.insert(std::make_pair(symbol, newAtom));
} else if (symbol->st_shndx == llvm::ELF::SHN_UNDEF) {
// Create an undefined atom.
- auto *newAtom = new (_readerStorage.Allocate<
- ELFUndefinedAtom<ELFT> > ())
- ELFUndefinedAtom<ELFT>(
- *this, symbolName, symbol);
+ auto *newAtom = new (_readerStorage.Allocate<ELFUndefinedAtom<ELFT>>())
+ ELFUndefinedAtom<ELFT>(*this, symbolName, symbol);
_undefinedAtoms._atoms.push_back(newAtom);
_symbolToAtomMapping.insert(std::make_pair(symbol, newAtom));
} else {
// This is actually a defined symbol. Add it to its section's list of
// symbols.
- if (symbol->getType() == llvm::ELF::STT_NOTYPE
- || symbol->getType() == llvm::ELF::STT_OBJECT
- || symbol->getType() == llvm::ELF::STT_FUNC
- || symbol->getType() == llvm::ELF::STT_GNU_IFUNC
- || symbol->getType() == llvm::ELF::STT_SECTION
- || symbol->getType() == llvm::ELF::STT_FILE
- || symbol->getType() == llvm::ELF::STT_TLS
- || symbol->getType() == llvm::ELF::STT_COMMON
- || symbol->st_shndx == llvm::ELF::SHN_COMMON) {
+ if (symbol->getType() == llvm::ELF::STT_NOTYPE ||
+ symbol->getType() == llvm::ELF::STT_OBJECT ||
+ symbol->getType() == llvm::ELF::STT_FUNC ||
+ symbol->getType() == llvm::ELF::STT_GNU_IFUNC ||
+ symbol->getType() == llvm::ELF::STT_SECTION ||
+ symbol->getType() == llvm::ELF::STT_FILE ||
+ symbol->getType() == llvm::ELF::STT_TLS ||
+ symbol->getType() == llvm::ELF::STT_COMMON ||
+ symbol->st_shndx == llvm::ELF::SHN_COMMON) {
sectionSymbols[section].push_back(symbol);
} else {
llvm::errs() << "Unable to create atom for: " << symbolName << "\n";
uint64_t contentSize;
if (si + 1 == se) {
// if this is the last symbol, take up the remaining data.
- contentSize = (isCommon) ? 0
- : ((i.first)->sh_size - (*si)->st_value);
+ contentSize = isCommon ? 0
+ : i.first->sh_size - (*si)->st_value;
} else {
- contentSize = (isCommon) ? 0
- : (*(si + 1))->st_value - (*si)->st_value;
+ contentSize = isCommon ? 0
+ : (*(si + 1))->st_value - (*si)->st_value;
}
-
// Don't allocate content to a weak symbol, as they may be merged away.
// Create an anonymous atom to hold the data.
ELFDefinedAtom<ELFT> *anonAtom = nullptr;
*sym = **si;
sym->setBinding(llvm::ELF::STB_GLOBAL);
anonAtom = createDefinedAtomAndAssignRelocations(
- "", sectionName, sym, i.first,
- ArrayRef<uint8_t>(
- (uint8_t *)sectionContents.data() + (*si)->st_value, contentSize));
+ "", sectionName, sym, i.first,
+ ArrayRef<uint8_t>((uint8_t *)sectionContents.data() +
+ (*si)->st_value, contentSize));
contentSize = 0;
}
ArrayRef<uint8_t> symbolData = ArrayRef<uint8_t>(
- (uint8_t *)sectionContents.data() + (*si)->st_value, contentSize);
+ (uint8_t *)sectionContents.data() +
+ (*si)->st_value, contentSize);
auto newAtom = createDefinedAtomAndAssignRelocations(
- symbolName, sectionName, *si, i.first, symbolData);
+ symbolName, sectionName, *si, i.first, symbolData);
_definedAtoms._atoms.push_back(newAtom);
_symbolToAtomMapping.insert(std::make_pair((*si), newAtom));
}
private:
- ELFDefinedAtom<ELFT> *
- createDefinedAtomAndAssignRelocations(StringRef symbolName,
- StringRef sectionName,
- const Elf_Sym *symbol,
- const Elf_Shdr *section,
- ArrayRef<uint8_t> content) {
+ ELFDefinedAtom<ELFT> *createDefinedAtomAndAssignRelocations(
+ StringRef symbolName, StringRef sectionName, const Elf_Sym *symbol,
+ const Elf_Shdr *section, ArrayRef<uint8_t> content) {
unsigned int referenceStart = _references.size();
// Only relocations that are inside the domain of the atom are added.
// Add Rela (those with r_addend) references:
for (auto &rai : _relocationAddendRefences[sectionName]) {
if (!((rai->r_offset >= symbol->st_value) &&
- (rai->r_offset < symbol->st_value + content.size())))
+ (rai->r_offset < symbol->st_value + content.size())))
continue;
- auto *ERef = new (_readerStorage.Allocate<ELFReference<ELFT>> ())
- ELFReference<ELFT>(rai, rai->r_offset - symbol->st_value, nullptr);
+ auto *ERef = new (_readerStorage.Allocate<ELFReference<ELFT>>())
+ ELFReference<ELFT>(rai, rai->r_offset - symbol->st_value,
+ nullptr);
_references.push_back(ERef);
}
if ((ri->r_offset >= symbol->st_value) &&
(ri->r_offset < symbol->st_value + content.size())) {
auto *ERef = new (_readerStorage.Allocate<ELFReference<ELFT>>())
- ELFReference<ELFT>(ri, ri->r_offset - symbol->st_value, nullptr);
+ ELFReference<ELFT>(ri, ri->r_offset - symbol->st_value,
+ nullptr);
_references.push_back(ERef);
}
}
// Create the DefinedAtom and add it to the list of DefinedAtoms.
return new (_readerStorage.Allocate<ELFDefinedAtom<ELFT>>())
- ELFDefinedAtom<ELFT>(*this,
- symbolName,
- sectionName,
- symbol,
- section,
- content,
- referenceStart,
- _references.size(),
- _references);
+ ELFDefinedAtom<ELFT>(*this, symbolName, sectionName, symbol, section,
+ content, referenceStart, _references.size(),
+ _references);
}
- std::unique_ptr<ELFObjectFile<ELFT>> _objFile;
- atom_collection_vector<DefinedAtom> _definedAtoms;
- atom_collection_vector<UndefinedAtom> _undefinedAtoms;
+ std::unique_ptr<ELFObjectFile<ELFT>> _objFile;
+ atom_collection_vector<DefinedAtom> _definedAtoms;
+ atom_collection_vector<UndefinedAtom> _undefinedAtoms;
atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms;
- atom_collection_vector<AbsoluteAtom> _absoluteAtoms;
+ atom_collection_vector<AbsoluteAtom> _absoluteAtoms;
/// \brief _relocationAddendRefences and _relocationReferences contain the
/// list of relocations references. In ELF, if a section named, ".text" has
/// relocations will also have a section named ".rel.text" or ".rela.text"
/// which will hold the entries. -- .rel or .rela is prepended to create
/// the SHT_REL(A) section name.
- std::map<llvm::StringRef, std::vector<const Elf_Rela *>>
- _relocationAddendRefences;
- std::map<llvm::StringRef, std::vector<const Elf_Rel *>>
- _relocationReferences;
+ std::map<llvm::StringRef,
+ std::vector<const Elf_Rela *>> _relocationAddendRefences;
+ std::map<llvm::StringRef,
+ std::vector<const Elf_Rel *>> _relocationReferences;
std::vector<ELFReference<ELFT> *> _references;
llvm::DenseMap<const Elf_Sym *, Atom *> _symbolToAtomMapping;
llvm::BumpPtrAllocator _readerStorage;
};
-// \brief A reader object that will instantiate correct FileELF by examining the
-// memory buffer for ELF class and bit width
-class ReaderELF: public Reader {
+/// \brief A reader object that will instantiate correct FileELF by examining the
+/// memory buffer for ELF class and bit width
+class ReaderELF : public Reader {
public:
ReaderELF(const ReaderOptionsELF &,
ReaderOptionsArchive &readerOptionsArchive)
- : _readerOptionsArchive(readerOptionsArchive)
- , _readerArchive(_readerOptionsArchive) {
+ : _readerOptionsArchive(readerOptionsArchive),
+ _readerArchive(_readerOptionsArchive) {
_readerOptionsArchive.setReader(this);
}
std::vector<std::unique_ptr<File>> &result) {
using llvm::object::ELFType;
llvm::sys::LLVMFileType fileType =
- llvm::sys::IdentifyFileType(mb->getBufferStart(),
- static_cast<unsigned>(mb->getBufferSize()));
+ llvm::sys::IdentifyFileType(mb->getBufferStart(),
+ static_cast<unsigned>(mb->getBufferSize()));
std::size_t MaxAlignment =
- 1ULL << llvm::CountTrailingZeros_64(uintptr_t(mb->getBufferStart()));
+ 1ULL << llvm::CountTrailingZeros_64(uintptr_t(mb->getBufferStart()));
llvm::error_code ec;
switch (fileType) {
// Instantiate the correct FileELF template instance based on the Ident
// pair. Once the File is created we push the file to the vector of files
// already created during parser's life.
- if (Ident.first == llvm::ELF::ELFCLASS32 && Ident.second
- == llvm::ELF::ELFDATA2LSB) {
+ if (Ident.first == llvm::ELF::ELFCLASS32 &&
+ Ident.second == llvm::ELF::ELFDATA2LSB) {
if (MaxAlignment >= 4)
f.reset(new FileELF<ELFType<llvm::support::little, 4, false>>(
- std::move(mb), ec));
+ std::move(mb), ec));
else if (MaxAlignment >= 2)
f.reset(new FileELF<ELFType<llvm::support::little, 2, false>>(
- std::move(mb), ec));
+ std::move(mb), ec));
else
llvm_unreachable("Invalid alignment for ELF file!");
- } else if (Ident.first == llvm::ELF::ELFCLASS32 && Ident.second
- == llvm::ELF::ELFDATA2MSB) {
+ } else if (Ident.first == llvm::ELF::ELFCLASS32 &&
+ Ident.second == llvm::ELF::ELFDATA2MSB) {
if (MaxAlignment >= 4)
f.reset(new FileELF<ELFType<llvm::support::big, 4, false>>(
- std::move(mb), ec));
+ std::move(mb), ec));
else if (MaxAlignment >= 2)
f.reset(new FileELF<ELFType<llvm::support::big, 2, false>>(
- std::move(mb), ec));
+ std::move(mb), ec));
else
llvm_unreachable("Invalid alignment for ELF file!");
- } else if (Ident.first == llvm::ELF::ELFCLASS64 && Ident.second
- == llvm::ELF::ELFDATA2MSB) {
+ } else if (Ident.first == llvm::ELF::ELFCLASS64 &&
+ Ident.second == llvm::ELF::ELFDATA2MSB) {
if (MaxAlignment >= 8)
f.reset(new FileELF<ELFType<llvm::support::big, 8, true>>(
- std::move(mb), ec));
+ std::move(mb), ec));
else if (MaxAlignment >= 2)
f.reset(new FileELF<ELFType<llvm::support::big, 2, true>>(
- std::move(mb), ec));
+ std::move(mb), ec));
else
llvm_unreachable("Invalid alignment for ELF file!");
- } else if (Ident.first == llvm::ELF::ELFCLASS64 && Ident.second
- == llvm::ELF::ELFDATA2LSB) {
+ } else if (Ident.first == llvm::ELF::ELFCLASS64 &&
+ Ident.second == llvm::ELF::ELFDATA2LSB) {
if (MaxAlignment >= 8)
f.reset(new FileELF<ELFType<llvm::support::little, 8, true>>(
- std::move(mb), ec));
+ std::move(mb), ec));
else if (MaxAlignment >= 2)
f.reset(new FileELF<ELFType<llvm::support::little, 2, true>>(
- std::move(mb), ec));
+ std::move(mb), ec));
else
llvm_unreachable("Invalid alignment for ELF file!");
}
} // end anon namespace.
namespace lld {
-ReaderOptionsELF::ReaderOptionsELF() {
-}
+ReaderOptionsELF::ReaderOptionsELF() {}
-ReaderOptionsELF::~ReaderOptionsELF() {
-}
+ReaderOptionsELF::~ReaderOptionsELF() {}
Reader *createReaderELF(const ReaderOptionsELF &options,
ReaderOptionsArchive &optionsArchive) {
projects / platform / upstream / llvm.git / commitdiff