forked from OSchip/llvm-project
506 lines
18 KiB
C++
506 lines
18 KiB
C++
//===- Core/Resolver.cpp - Resolves Atom References -----------------------===//
|
|
//
|
|
// The LLVM Linker
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lld/Core/Atom.h"
|
|
#include "lld/Core/ArchiveLibraryFile.h"
|
|
#include "lld/Core/File.h"
|
|
#include "lld/Core/Instrumentation.h"
|
|
#include "lld/Core/LLVM.h"
|
|
#include "lld/Core/LinkingContext.h"
|
|
#include "lld/Core/Resolver.h"
|
|
#include "lld/Core/SharedLibraryFile.h"
|
|
#include "lld/Core/SymbolTable.h"
|
|
#include "lld/Core/UndefinedAtom.h"
|
|
#include "llvm/ADT/iterator_range.h"
|
|
#include "llvm/Support/Debug.h"
|
|
#include "llvm/Support/Error.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/Format.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
namespace lld {
|
|
|
|
llvm::Expected<bool> Resolver::handleFile(File &file) {
|
|
if (auto ec = _ctx.handleLoadedFile(file))
|
|
return std::move(ec);
|
|
bool undefAdded = false;
|
|
for (auto &atom : file.defined().owning_ptrs())
|
|
doDefinedAtom(std::move(atom));
|
|
for (auto &atom : file.undefined().owning_ptrs()) {
|
|
if (doUndefinedAtom(std::move(atom)))
|
|
undefAdded = true;
|
|
}
|
|
for (auto &atom : file.sharedLibrary().owning_ptrs())
|
|
doSharedLibraryAtom(std::move(atom));
|
|
for (auto &atom : file.absolute().owning_ptrs())
|
|
doAbsoluteAtom(std::move(atom));
|
|
return undefAdded;
|
|
}
|
|
|
|
llvm::Expected<bool> Resolver::forEachUndefines(File &file,
|
|
UndefCallback callback) {
|
|
size_t i = _undefineIndex[&file];
|
|
bool undefAdded = false;
|
|
do {
|
|
for (; i < _undefines.size(); ++i) {
|
|
StringRef undefName = _undefines[i];
|
|
if (undefName.empty())
|
|
continue;
|
|
const Atom *atom = _symbolTable.findByName(undefName);
|
|
if (!isa<UndefinedAtom>(atom) || _symbolTable.isCoalescedAway(atom)) {
|
|
// The symbol was resolved by some other file. Cache the result.
|
|
_undefines[i] = "";
|
|
continue;
|
|
}
|
|
auto undefAddedOrError = callback(undefName);
|
|
if (auto ec = undefAddedOrError.takeError())
|
|
return std::move(ec);
|
|
undefAdded |= undefAddedOrError.get();
|
|
}
|
|
} while (i < _undefines.size());
|
|
_undefineIndex[&file] = i;
|
|
return undefAdded;
|
|
}
|
|
|
|
llvm::Expected<bool> Resolver::handleArchiveFile(File &file) {
|
|
ArchiveLibraryFile *archiveFile = cast<ArchiveLibraryFile>(&file);
|
|
return forEachUndefines(file,
|
|
[&](StringRef undefName) -> llvm::Expected<bool> {
|
|
if (File *member = archiveFile->find(undefName)) {
|
|
member->setOrdinal(_ctx.getNextOrdinalAndIncrement());
|
|
return handleFile(*member);
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
|
|
llvm::Error Resolver::handleSharedLibrary(File &file) {
|
|
// Add all the atoms from the shared library
|
|
SharedLibraryFile *sharedLibrary = cast<SharedLibraryFile>(&file);
|
|
auto undefAddedOrError = handleFile(*sharedLibrary);
|
|
if (auto ec = undefAddedOrError.takeError())
|
|
return ec;
|
|
undefAddedOrError =
|
|
forEachUndefines(file, [&](StringRef undefName) -> llvm::Expected<bool> {
|
|
auto atom = sharedLibrary->exports(undefName);
|
|
if (atom.get())
|
|
doSharedLibraryAtom(std::move(atom));
|
|
return false;
|
|
});
|
|
|
|
if (auto ec = undefAddedOrError.takeError())
|
|
return ec;
|
|
return llvm::Error::success();
|
|
}
|
|
|
|
bool Resolver::doUndefinedAtom(OwningAtomPtr<UndefinedAtom> atom) {
|
|
DEBUG_WITH_TYPE("resolver", llvm::dbgs()
|
|
<< " UndefinedAtom: "
|
|
<< llvm::format("0x%09lX", atom.get())
|
|
<< ", name=" << atom.get()->name() << "\n");
|
|
|
|
// tell symbol table
|
|
bool newUndefAdded = _symbolTable.add(*atom.get());
|
|
if (newUndefAdded)
|
|
_undefines.push_back(atom.get()->name());
|
|
|
|
// add to list of known atoms
|
|
_atoms.push_back(OwningAtomPtr<Atom>(atom.release()));
|
|
|
|
return newUndefAdded;
|
|
}
|
|
|
|
// Called on each atom when a file is added. Returns true if a given
|
|
// atom is added to the symbol table.
|
|
void Resolver::doDefinedAtom(OwningAtomPtr<DefinedAtom> atom) {
|
|
DEBUG_WITH_TYPE("resolver", llvm::dbgs()
|
|
<< " DefinedAtom: "
|
|
<< llvm::format("0x%09lX", atom.get())
|
|
<< ", file=#"
|
|
<< atom.get()->file().ordinal()
|
|
<< ", atom=#"
|
|
<< atom.get()->ordinal()
|
|
<< ", name="
|
|
<< atom.get()->name()
|
|
<< ", type="
|
|
<< atom.get()->contentType()
|
|
<< "\n");
|
|
|
|
// An atom that should never be dead-stripped is a dead-strip root.
|
|
if (_ctx.deadStrip() &&
|
|
atom.get()->deadStrip() == DefinedAtom::deadStripNever) {
|
|
_deadStripRoots.insert(atom.get());
|
|
}
|
|
|
|
// add to list of known atoms
|
|
_symbolTable.add(*atom.get());
|
|
_atoms.push_back(OwningAtomPtr<Atom>(atom.release()));
|
|
}
|
|
|
|
void Resolver::doSharedLibraryAtom(OwningAtomPtr<SharedLibraryAtom> atom) {
|
|
DEBUG_WITH_TYPE("resolver", llvm::dbgs()
|
|
<< " SharedLibraryAtom: "
|
|
<< llvm::format("0x%09lX", atom.get())
|
|
<< ", name="
|
|
<< atom.get()->name()
|
|
<< "\n");
|
|
|
|
// tell symbol table
|
|
_symbolTable.add(*atom.get());
|
|
|
|
// add to list of known atoms
|
|
_atoms.push_back(OwningAtomPtr<Atom>(atom.release()));
|
|
}
|
|
|
|
void Resolver::doAbsoluteAtom(OwningAtomPtr<AbsoluteAtom> atom) {
|
|
DEBUG_WITH_TYPE("resolver", llvm::dbgs()
|
|
<< " AbsoluteAtom: "
|
|
<< llvm::format("0x%09lX", atom.get())
|
|
<< ", name="
|
|
<< atom.get()->name()
|
|
<< "\n");
|
|
|
|
// tell symbol table
|
|
if (atom.get()->scope() != Atom::scopeTranslationUnit)
|
|
_symbolTable.add(*atom.get());
|
|
|
|
// add to list of known atoms
|
|
_atoms.push_back(OwningAtomPtr<Atom>(atom.release()));
|
|
}
|
|
|
|
// Returns true if at least one of N previous files has created an
|
|
// undefined symbol.
|
|
bool Resolver::undefinesAdded(int begin, int end) {
|
|
std::vector<std::unique_ptr<Node>> &inputs = _ctx.getNodes();
|
|
for (int i = begin; i < end; ++i)
|
|
if (FileNode *node = dyn_cast<FileNode>(inputs[i].get()))
|
|
if (_newUndefinesAdded[node->getFile()])
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
File *Resolver::getFile(int &index) {
|
|
std::vector<std::unique_ptr<Node>> &inputs = _ctx.getNodes();
|
|
if ((size_t)index >= inputs.size())
|
|
return nullptr;
|
|
if (GroupEnd *group = dyn_cast<GroupEnd>(inputs[index].get())) {
|
|
// We are at the end of the current group. If one or more new
|
|
// undefined atom has been added in the last groupSize files, we
|
|
// reiterate over the files.
|
|
int size = group->getSize();
|
|
if (undefinesAdded(index - size, index)) {
|
|
index -= size;
|
|
return getFile(index);
|
|
}
|
|
++index;
|
|
return getFile(index);
|
|
}
|
|
return cast<FileNode>(inputs[index++].get())->getFile();
|
|
}
|
|
|
|
// Keep adding atoms until _ctx.getNextFile() returns an error. This
|
|
// function is where undefined atoms are resolved.
|
|
bool Resolver::resolveUndefines() {
|
|
DEBUG_WITH_TYPE("resolver",
|
|
llvm::dbgs() << "******** Resolving undefines:\n");
|
|
ScopedTask task(getDefaultDomain(), "resolveUndefines");
|
|
int index = 0;
|
|
std::set<File *> seen;
|
|
for (;;) {
|
|
bool undefAdded = false;
|
|
DEBUG_WITH_TYPE("resolver",
|
|
llvm::dbgs() << "Loading file #" << index << "\n");
|
|
File *file = getFile(index);
|
|
if (!file)
|
|
return true;
|
|
if (std::error_code ec = file->parse()) {
|
|
llvm::errs() << "Cannot open " + file->path()
|
|
<< ": " << ec.message() << "\n";
|
|
return false;
|
|
}
|
|
DEBUG_WITH_TYPE("resolver",
|
|
llvm::dbgs() << "Loaded file: " << file->path() << "\n");
|
|
switch (file->kind()) {
|
|
case File::kindErrorObject:
|
|
case File::kindNormalizedObject:
|
|
case File::kindMachObject:
|
|
case File::kindCEntryObject:
|
|
case File::kindHeaderObject:
|
|
case File::kindEntryObject:
|
|
case File::kindUndefinedSymsObject:
|
|
case File::kindStubHelperObject:
|
|
case File::kindResolverMergedObject:
|
|
case File::kindSectCreateObject: {
|
|
// The same file may be visited more than once if the file is
|
|
// in --start-group and --end-group. Only library files should
|
|
// be processed more than once.
|
|
if (seen.count(file))
|
|
break;
|
|
seen.insert(file);
|
|
assert(!file->hasOrdinal());
|
|
file->setOrdinal(_ctx.getNextOrdinalAndIncrement());
|
|
auto undefAddedOrError = handleFile(*file);
|
|
if (auto EC = undefAddedOrError.takeError()) {
|
|
// FIXME: This should be passed to logAllUnhandledErrors but it needs
|
|
// to be passed a Twine instead of a string.
|
|
llvm::errs() << "Error in " + file->path() << ": ";
|
|
logAllUnhandledErrors(std::move(EC), llvm::errs(), std::string());
|
|
return false;
|
|
}
|
|
undefAdded = undefAddedOrError.get();
|
|
break;
|
|
}
|
|
case File::kindArchiveLibrary: {
|
|
if (!file->hasOrdinal())
|
|
file->setOrdinal(_ctx.getNextOrdinalAndIncrement());
|
|
auto undefAddedOrError = handleArchiveFile(*file);
|
|
if (auto EC = undefAddedOrError.takeError()) {
|
|
// FIXME: This should be passed to logAllUnhandledErrors but it needs
|
|
// to be passed a Twine instead of a string.
|
|
llvm::errs() << "Error in " + file->path() << ": ";
|
|
logAllUnhandledErrors(std::move(EC), llvm::errs(), std::string());
|
|
return false;
|
|
}
|
|
undefAdded = undefAddedOrError.get();
|
|
break;
|
|
}
|
|
case File::kindSharedLibrary:
|
|
if (!file->hasOrdinal())
|
|
file->setOrdinal(_ctx.getNextOrdinalAndIncrement());
|
|
if (auto EC = handleSharedLibrary(*file)) {
|
|
// FIXME: This should be passed to logAllUnhandledErrors but it needs
|
|
// to be passed a Twine instead of a string.
|
|
llvm::errs() << "Error in " + file->path() << ": ";
|
|
logAllUnhandledErrors(std::move(EC), llvm::errs(), std::string());
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
_newUndefinesAdded[file] = undefAdded;
|
|
}
|
|
}
|
|
|
|
// switch all references to undefined or coalesced away atoms
|
|
// to the new defined atom
|
|
void Resolver::updateReferences() {
|
|
DEBUG_WITH_TYPE("resolver",
|
|
llvm::dbgs() << "******** Updating references:\n");
|
|
ScopedTask task(getDefaultDomain(), "updateReferences");
|
|
for (const OwningAtomPtr<Atom> &atom : _atoms) {
|
|
if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(atom.get())) {
|
|
for (const Reference *ref : *defAtom) {
|
|
// A reference of type kindAssociate should't be updated.
|
|
// Instead, an atom having such reference will be removed
|
|
// if the target atom is coalesced away, so that they will
|
|
// go away as a group.
|
|
if (ref->kindNamespace() == lld::Reference::KindNamespace::all &&
|
|
ref->kindValue() == lld::Reference::kindAssociate) {
|
|
if (_symbolTable.isCoalescedAway(atom.get()))
|
|
_deadAtoms.insert(ref->target());
|
|
continue;
|
|
}
|
|
const Atom *newTarget = _symbolTable.replacement(ref->target());
|
|
const_cast<Reference *>(ref)->setTarget(newTarget);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// For dead code stripping, recursively mark atoms "live"
|
|
void Resolver::markLive(const Atom *atom) {
|
|
// Mark the atom is live. If it's already marked live, then stop recursion.
|
|
auto exists = _liveAtoms.insert(atom);
|
|
if (!exists.second)
|
|
return;
|
|
|
|
// Mark all atoms it references as live
|
|
if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(atom)) {
|
|
for (const Reference *ref : *defAtom)
|
|
markLive(ref->target());
|
|
for (auto &p : llvm::make_range(_reverseRef.equal_range(defAtom))) {
|
|
const Atom *target = p.second;
|
|
markLive(target);
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool isBackref(const Reference *ref) {
|
|
if (ref->kindNamespace() != lld::Reference::KindNamespace::all)
|
|
return false;
|
|
return (ref->kindValue() == lld::Reference::kindLayoutAfter);
|
|
}
|
|
|
|
// remove all atoms not actually used
|
|
void Resolver::deadStripOptimize() {
|
|
DEBUG_WITH_TYPE("resolver",
|
|
llvm::dbgs() << "******** Dead stripping unused atoms:\n");
|
|
ScopedTask task(getDefaultDomain(), "deadStripOptimize");
|
|
// only do this optimization with -dead_strip
|
|
if (!_ctx.deadStrip())
|
|
return;
|
|
|
|
// Some type of references prevent referring atoms to be dead-striped.
|
|
// Make a reverse map of such references before traversing the graph.
|
|
// While traversing the list of atoms, mark AbsoluteAtoms as live
|
|
// in order to avoid reclaim.
|
|
for (const OwningAtomPtr<Atom> &atom : _atoms) {
|
|
if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(atom.get()))
|
|
for (const Reference *ref : *defAtom)
|
|
if (isBackref(ref))
|
|
_reverseRef.insert(std::make_pair(ref->target(), atom.get()));
|
|
if (const AbsoluteAtom *absAtom = dyn_cast<AbsoluteAtom>(atom.get()))
|
|
markLive(absAtom);
|
|
}
|
|
|
|
// By default, shared libraries are built with all globals as dead strip roots
|
|
if (_ctx.globalsAreDeadStripRoots())
|
|
for (const OwningAtomPtr<Atom> &atom : _atoms)
|
|
if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(atom.get()))
|
|
if (defAtom->scope() == DefinedAtom::scopeGlobal)
|
|
_deadStripRoots.insert(defAtom);
|
|
|
|
// Or, use list of names that are dead strip roots.
|
|
for (const StringRef &name : _ctx.deadStripRoots()) {
|
|
const Atom *symAtom = _symbolTable.findByName(name);
|
|
assert(symAtom);
|
|
_deadStripRoots.insert(symAtom);
|
|
}
|
|
|
|
// mark all roots as live, and recursively all atoms they reference
|
|
for (const Atom *dsrAtom : _deadStripRoots)
|
|
markLive(dsrAtom);
|
|
|
|
// now remove all non-live atoms from _atoms
|
|
_atoms.erase(std::remove_if(_atoms.begin(), _atoms.end(),
|
|
[&](OwningAtomPtr<Atom> &a) {
|
|
return _liveAtoms.count(a.get()) == 0;
|
|
}),
|
|
_atoms.end());
|
|
}
|
|
|
|
// error out if some undefines remain
|
|
bool Resolver::checkUndefines() {
|
|
DEBUG_WITH_TYPE("resolver",
|
|
llvm::dbgs() << "******** Checking for undefines:\n");
|
|
|
|
// build vector of remaining undefined symbols
|
|
std::vector<const UndefinedAtom *> undefinedAtoms = _symbolTable.undefines();
|
|
if (_ctx.deadStrip()) {
|
|
// When dead code stripping, we don't care if dead atoms are undefined.
|
|
undefinedAtoms.erase(
|
|
std::remove_if(undefinedAtoms.begin(), undefinedAtoms.end(),
|
|
[&](const Atom *a) { return _liveAtoms.count(a) == 0; }),
|
|
undefinedAtoms.end());
|
|
}
|
|
|
|
if (undefinedAtoms.empty())
|
|
return false;
|
|
|
|
// Warn about unresolved symbols.
|
|
bool foundUndefines = false;
|
|
for (const UndefinedAtom *undef : undefinedAtoms) {
|
|
// Skip over a weak symbol.
|
|
if (undef->canBeNull() != UndefinedAtom::canBeNullNever)
|
|
continue;
|
|
|
|
// If this is a library and undefined symbols are allowed on the
|
|
// target platform, skip over it.
|
|
if (isa<SharedLibraryFile>(undef->file()) && _ctx.allowShlibUndefines())
|
|
continue;
|
|
|
|
// If the undefine is coalesced away, skip over it.
|
|
if (_symbolTable.isCoalescedAway(undef))
|
|
continue;
|
|
|
|
// Seems like this symbol is undefined. Warn that.
|
|
foundUndefines = true;
|
|
if (_ctx.printRemainingUndefines()) {
|
|
llvm::errs() << "Undefined symbol: " << undef->file().path()
|
|
<< ": " << _ctx.demangle(undef->name())
|
|
<< "\n";
|
|
}
|
|
}
|
|
if (!foundUndefines)
|
|
return false;
|
|
if (_ctx.printRemainingUndefines())
|
|
llvm::errs() << "symbol(s) not found\n";
|
|
return true;
|
|
}
|
|
|
|
// remove from _atoms all coaleseced away atoms
|
|
void Resolver::removeCoalescedAwayAtoms() {
|
|
DEBUG_WITH_TYPE("resolver",
|
|
llvm::dbgs() << "******** Removing coalesced away atoms:\n");
|
|
ScopedTask task(getDefaultDomain(), "removeCoalescedAwayAtoms");
|
|
_atoms.erase(std::remove_if(_atoms.begin(), _atoms.end(),
|
|
[&](OwningAtomPtr<Atom> &a) {
|
|
return _symbolTable.isCoalescedAway(a.get()) ||
|
|
_deadAtoms.count(a.get());
|
|
}),
|
|
_atoms.end());
|
|
}
|
|
|
|
bool Resolver::resolve() {
|
|
DEBUG_WITH_TYPE("resolver",
|
|
llvm::dbgs() << "******** Resolving atom references:\n");
|
|
if (!resolveUndefines())
|
|
return false;
|
|
updateReferences();
|
|
deadStripOptimize();
|
|
if (checkUndefines()) {
|
|
DEBUG_WITH_TYPE("resolver", llvm::dbgs() << "Found undefines... ");
|
|
if (!_ctx.allowRemainingUndefines()) {
|
|
DEBUG_WITH_TYPE("resolver", llvm::dbgs() << "which we don't allow\n");
|
|
return false;
|
|
}
|
|
DEBUG_WITH_TYPE("resolver", llvm::dbgs() << "which we are ok with\n");
|
|
}
|
|
removeCoalescedAwayAtoms();
|
|
_result->addAtoms(_atoms);
|
|
DEBUG_WITH_TYPE("resolver", llvm::dbgs() << "******** Finished resolver\n");
|
|
return true;
|
|
}
|
|
|
|
void Resolver::MergedFile::addAtoms(
|
|
llvm::MutableArrayRef<OwningAtomPtr<Atom>> all) {
|
|
ScopedTask task(getDefaultDomain(), "addAtoms");
|
|
DEBUG_WITH_TYPE("resolver", llvm::dbgs() << "Resolver final atom list:\n");
|
|
|
|
for (OwningAtomPtr<Atom> &atom : all) {
|
|
#ifndef NDEBUG
|
|
if (auto *definedAtom = dyn_cast<DefinedAtom>(atom.get())) {
|
|
DEBUG_WITH_TYPE("resolver", llvm::dbgs()
|
|
<< llvm::format(" 0x%09lX", definedAtom)
|
|
<< ", file=#"
|
|
<< definedAtom->file().ordinal()
|
|
<< ", atom=#"
|
|
<< definedAtom->ordinal()
|
|
<< ", name="
|
|
<< definedAtom->name()
|
|
<< ", type="
|
|
<< definedAtom->contentType()
|
|
<< "\n");
|
|
} else {
|
|
DEBUG_WITH_TYPE("resolver", llvm::dbgs()
|
|
<< llvm::format(" 0x%09lX", atom.get())
|
|
<< ", name="
|
|
<< atom.get()->name()
|
|
<< "\n");
|
|
}
|
|
#endif
|
|
addAtom(*atom.release());
|
|
}
|
|
}
|
|
|
|
} // namespace lld
|