61d7f97000
COFF supports a feature similar to ELF's section groups. This patch implements it. In ELF, section groups are identified by their names, and they are treated somewhat differently from regular symbols. In COFF, the feature is realized in a more straightforward way. A section can have an annotation saying "if Nth section is linked, link this section too." I added a new reference type, kindAssociate. If a target atom is coalesced away, the referring atom is removed by Resolver, so that they are treated as a group. Differential Revision: http://reviews.llvm.org/D4028 llvm-svn: 211106
115 lines
3.7 KiB
C++
115 lines
3.7 KiB
C++
//===- lib/ReaderWriter/Reader.cpp ----------------------------------------===//
|
|
//
|
|
// The LLVM Linker
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lld/ReaderWriter/Reader.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/Support/Errc.h"
|
|
#include "llvm/Support/FileUtilities.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/Path.h"
|
|
#include <memory>
|
|
#include <system_error>
|
|
|
|
namespace lld {
|
|
|
|
YamlIOTaggedDocumentHandler::~YamlIOTaggedDocumentHandler() {}
|
|
|
|
void Registry::add(std::unique_ptr<Reader> reader) {
|
|
_readers.push_back(std::move(reader));
|
|
}
|
|
|
|
void Registry::add(std::unique_ptr<YamlIOTaggedDocumentHandler> handler) {
|
|
_yamlHandlers.push_back(std::move(handler));
|
|
}
|
|
|
|
std::error_code
|
|
Registry::parseFile(std::unique_ptr<MemoryBuffer> &mb,
|
|
std::vector<std::unique_ptr<File>> &result) const {
|
|
// Get file type.
|
|
StringRef content(mb->getBufferStart(), mb->getBufferSize());
|
|
llvm::sys::fs::file_magic fileType = llvm::sys::fs::identify_magic(content);
|
|
// Get file extension.
|
|
StringRef extension = llvm::sys::path::extension(mb->getBufferIdentifier());
|
|
|
|
// Ask each registered reader if it can handle this file type or extension.
|
|
for (const std::unique_ptr<Reader> &reader : _readers)
|
|
if (reader->canParse(fileType, extension, *mb))
|
|
return reader->parseFile(mb, *this, result);
|
|
|
|
// No Reader could parse this file.
|
|
return make_error_code(llvm::errc::executable_format_error);
|
|
}
|
|
|
|
static const Registry::KindStrings kindStrings[] = {
|
|
{Reference::kindInGroup, "in-group"},
|
|
{Reference::kindLayoutAfter, "layout-after"},
|
|
{Reference::kindLayoutBefore, "layout-before"},
|
|
{Reference::kindGroupChild, "group-child"},
|
|
{Reference::kindAssociate, "associate"},
|
|
LLD_KIND_STRING_END};
|
|
|
|
Registry::Registry() {
|
|
addKindTable(Reference::KindNamespace::all, Reference::KindArch::all,
|
|
kindStrings);
|
|
}
|
|
|
|
bool Registry::handleTaggedDoc(llvm::yaml::IO &io,
|
|
const lld::File *&file) const {
|
|
for (const std::unique_ptr<YamlIOTaggedDocumentHandler> &h : _yamlHandlers)
|
|
if (h->handledDocTag(io, file))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
|
|
void Registry::addKindTable(Reference::KindNamespace ns,
|
|
Reference::KindArch arch,
|
|
const KindStrings array[]) {
|
|
KindEntry entry = { ns, arch, array };
|
|
_kindEntries.push_back(entry);
|
|
}
|
|
|
|
bool Registry::referenceKindFromString(StringRef inputStr,
|
|
Reference::KindNamespace &ns,
|
|
Reference::KindArch &arch,
|
|
Reference::KindValue &value) const {
|
|
for (const KindEntry &entry : _kindEntries) {
|
|
for (const KindStrings *pair = entry.array; !pair->name.empty(); ++pair) {
|
|
if (!inputStr.equals(pair->name))
|
|
continue;
|
|
ns = entry.ns;
|
|
arch = entry.arch;
|
|
value = pair->value;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Registry::referenceKindToString(Reference::KindNamespace ns,
|
|
Reference::KindArch arch,
|
|
Reference::KindValue value,
|
|
StringRef &str) const {
|
|
for (const KindEntry &entry : _kindEntries) {
|
|
if (entry.ns != ns)
|
|
continue;
|
|
if (entry.arch != arch)
|
|
continue;
|
|
for (const KindStrings *pair = entry.array; !pair->name.empty(); ++pair) {
|
|
if (pair->value != value)
|
|
continue;
|
|
str = pair->name;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
} // end namespace lld
|