replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add Pass to instantiate GOT entries 

llvm-svn: 152874
This commit is contained in:
Nick Kledzik 2012-03-15 23:36:24 +00:00
parent 6f87b44fe3
commit f4e2c73fa7
12 changed files with 454 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
lld/include/lld/Core/Pass.h
View File

@ -60,6 +60,20 @@ public:
};
///
/// Pass for adding GOT entries for pointers to functions/data
/// outside the linkage unit.
///
class GOTPass : public Pass {
public:
GOTPass(File& f, Platform& p) : Pass(f, p) {}
/// Scans all Atoms looking for pointer to SharedLibraryAtoms
/// and transfroms them to a pointer to a GOT entry.
virtual void perform();
};
} // namespace lld
#endif // LLD_CORE_PASS_H_

4
lld/include/lld/Core/Reference.h
View File

@ -39,6 +39,10 @@ public:
/// What sort of reference this is.
virtual Kind kind() const = 0;
/// During linking, some optimizations may change the code gen and
/// hence the reference kind.
virtual void setKind(Kind) = 0;
/// If the reference is a fixup in the Atom, then this returns the
/// byte offset into the Atom's content to do the fix up.
virtual uint64_t offsetInAtom() const = 0;

32
lld/include/lld/Platform/Platform.h
View File

@ -102,9 +102,6 @@ public:
/// @brief last chance for platform to tweak atoms
virtual void postResolveTweaks(std::vector<const Atom *>& all) = 0;
/// If the output being generated uses needs stubs for external calls
virtual bool outputUsesStubs() = 0;
/// Converts a reference kind string to a in-memory numeric value.
/// For use with parsing YAML encoded object files.
virtual Reference::Kind kindFromString(llvm::StringRef) = 0;
@ -113,13 +110,34 @@ public:
/// For use with writing YAML encoded object files.
virtual llvm::StringRef kindToString(Reference::Kind) = 0;
/// If Reference is a branch instruction that might need to be changed
/// to target a stub (PLT entry).
virtual bool isBranch(const Reference*) = 0;
/// If true, the linker will use stubs and GOT entries for
/// references to shared library symbols. If false, the linker
/// will generate relocations on the text segment which the
/// runtime loader will use to patch the program at runtime.
virtual bool noTextRelocs() = 0;
/// Returns if the Reference kind is for a call site. The "stubs" Pass uses
/// this to find calls that need to be indirected through a stub.
virtual bool isCallSite(Reference::Kind) = 0;
/// Returns if the Reference kind is a pre-instantiated GOT access.
/// The "got" Pass uses this to figure out what GOT entries to instantiate.
virtual bool isGOTAccess(Reference::Kind, bool& canBypassGOT) = 0;
/// The platform needs to alter the reference kind from a pre-instantiated
/// GOT access to an actual access. If targetIsNowGOT is true, the "got"
/// Pass has instantiated a GOT atom and altered the reference's target
/// to point to that atom. If targetIsNowGOT is false, the "got" Pass
/// determined a GOT entry is not needed because the reference site can
/// directly access the target.
virtual void updateReferenceToGOT(const Reference*, bool targetIsNowGOT) = 0;
/// Create a platform specific atom which contains a stub/PLT entry
/// targeting the specified shared library atom.
virtual const Atom* makeStub(const SharedLibraryAtom&, File&) = 0;
virtual const DefinedAtom* makeStub(const Atom&, File&) = 0;
/// Create a platform specific GOT atom.
virtual const DefinedAtom* makeGOTEntry(const Atom&, File&) = 0;
};

16
lld/lib/Core/NativeReader.cpp
View File

@ -200,11 +200,22 @@ public:
return _ivarData->kind;
}
virtual void setKind(Kind);
virtual const Atom* target() const;
virtual Addend addend() const;
virtual void setTarget(const Atom* newAtom);
private:
// Used in rare cases when Reference is modified,
// since ivar data is mapped read-only.
void cloneIvarData() {
// TODO: do nothing on second call
NativeReferenceIvarsV1* niv = reinterpret_cast<NativeReferenceIvarsV1*>
(operator new(sizeof(NativeReferenceIvarsV1),
std::nothrow));
memcpy(niv, _ivarData, sizeof(NativeReferenceIvarsV1));
}
const NativeFile* _file;
const NativeReferenceIvarsV1* _ivarData;
};
@ -785,6 +796,11 @@ inline Reference::Addend NativeReferenceV1::addend() const {
return _file->addend(_ivarData->addendIndex);
}
inline void NativeReferenceV1::setKind(Kind k) {
this->cloneIvarData();
const_cast<NativeReferenceIvarsV1*>(_ivarData)->kind = k;
}
inline void NativeReferenceV1::setTarget(const Atom* newAtom) {
return _file->setTarget(_ivarData->targetIndex, newAtom);
}

1
lld/lib/Core/YamlKeyValues.cpp
View File

@ -150,6 +150,7 @@ static const ContentTypeMapping typeMappings[] = {
{ "data", DefinedAtom::typeData },
{ "zero-fill", DefinedAtom::typeZeroFill },
{ "cf-string", DefinedAtom::typeCFString },
{ "got", DefinedAtom::typeGOT },
{ "initializer-ptr",DefinedAtom::typeInitializerPtr },
{ "terminator-ptr", DefinedAtom::typeTerminatorPtr },
{ "c-string-ptr", DefinedAtom::typeCStringPtr },

4
lld/lib/Core/YamlReader.cpp
View File

@ -271,6 +271,10 @@ public:
return _kind;
}
virtual void setKind(Kind k) {
_kind = k;
}
virtual const Atom* target() const {
return _target;
}

3
lld/lib/Core/YamlWriter.cpp
View File

@ -305,6 +305,9 @@ public:
for (unsigned int i=0; i < arr.size(); ++i) {
if ( needComma )
out << ", ";
if ( ((i % 12) == 0) && (i != 0) ) {
out << "\n ";
}
out << hexdigit(arr[i] >> 4);
out << hexdigit(arr[i] & 0x0F);
needComma = true;

1
lld/lib/Passes/CMakeLists.txt
View File

@ -1,3 +1,4 @@
add_lld_library(lldPasses
GOTPass.cpp
StubsPass.cpp
)

116
lld/lib/Passes/GOTPass.cpp Normal file
View File

@ -0,0 +1,116 @@
//===- Passes/GOTPass.cpp - Adds GOT entries ------------------------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This linker pass transforms all GOT kind references to real references.
// That is, in assembly you can write something like:
// movq foo@GOTPCREL(%rip), %rax
// which means you want to load a pointer to "foo" out of the GOT (global
// Offsets Table). In the object file, the Atom containing this instruction
// has a Reference whose target is an Atom named "foo" and the Reference
// kind is a GOT load. The linker needs to instantiate a pointer sized
// GOT entry. This is done be creating a GOT Atom to represent that pointer
// sized data in this pass, and altering the Atom graph so the Reference now
// points to the GOT Atom entry (corresponding to "foo") and changing the
// Reference Kind to reflect it is now pointing to a GOT entry (rather
// then needing a GOT entry).
//
// There is one optimization the linker can do here. If the target of the GOT
// is in the same linkage unit and does not need to be interposable, and
// the GOT use is just a load (not some other operation), this pass can
// transform that load into an LEA (add). This optimizes away one memory load
// at runtime that could stall the pipeline. This optimization only works
// for architectures in which a (GOT) load instruction can be change to an
// LEA instruction that is the same size. The platform method isGOTAccess()
// should only return true for "canBypassGOT" if this optimization is supported.
//
#include "llvm/ADT/DenseMap.h"
#include "lld/Core/DefinedAtom.h"
#include "lld/Core/Pass.h"
#include "lld/Core/File.h"
#include "lld/Core/Reference.h"
#include "lld/Platform/Platform.h"
namespace lld {
void GOTPass::perform() {
// Use map so all pointers to same symbol use same GOT entry.
llvm::DenseMap<const Atom*, const DefinedAtom*> targetToGOT;
// Scan all references in all atoms.
for(auto ait=_file.definedAtomsBegin(), aend=_file.definedAtomsEnd();
ait != aend; ++ait) {
const DefinedAtom* atom = *ait;
for (auto rit=atom->referencesBegin(), rend=atom->referencesEnd();
rit != rend; ++rit) {
const Reference* ref = *rit;
// Look at instructions accessing the GOT.
bool canBypassGOT;
if ( _platform.isGOTAccess(ref->kind(), canBypassGOT) ) {
const Atom* target = ref->target();
assert(target != NULL);
const DefinedAtom* defTarget = target->definedAtom();
bool replaceTargetWithGOTAtom = false;
if ( target->definition() == Atom::definitionSharedLibrary ) {
// Accesses to shared library symbols must go through GOT.
replaceTargetWithGOTAtom = true;
}
else if ( (defTarget != NULL)
&& (defTarget->interposable() != DefinedAtom::interposeNo) ) {
// Accesses to interposable symbols in same linkage unit
// must also go through GOT.
assert(defTarget->scope() != DefinedAtom::scopeTranslationUnit);
replaceTargetWithGOTAtom = true;
}
else {
// Target does not require indirection. So, if instruction allows
// GOT to be by-passed, do that optimization and don't create
// GOT entry.
replaceTargetWithGOTAtom = !canBypassGOT;
}
if ( replaceTargetWithGOTAtom ) {
// Replace the target with a reference to a GOT entry.
const DefinedAtom* gotEntry = NULL;
auto pos = targetToGOT.find(target);
if ( pos == targetToGOT.end() ) {
// This is no existing GOT entry. Create a new one.
gotEntry = _platform.makeGOTEntry(*target, _file);
assert(gotEntry != NULL);
assert(gotEntry->contentType() == DefinedAtom::typeGOT);
targetToGOT[target] = gotEntry;
}
else {
// Reuse an existing GOT entry.
gotEntry = pos->second;
assert(gotEntry != NULL);
}
// Switch reference to GOT atom.
(const_cast<Reference*>(ref))->setTarget(gotEntry);
}
// Platform needs to update reference kind to reflect
// that target is a GOT entry or a direct accesss.
_platform.updateReferenceToGOT(ref, replaceTargetWithGOTAtom);
}
}
}
// add all created GOT Atoms to master file
for (auto it=targetToGOT.begin(), end=targetToGOT.end(); it != end; ++it) {
_file.addAtom(*it->second);
}
}
}

63
lld/lib/Passes/StubsPass.cpp
View File

@ -8,15 +8,16 @@
//===----------------------------------------------------------------------===//
//
// This linker pass is
//
//
//
// This linker pass updates call sites which have references to shared library
// atoms to instead have a reference to a stub (PLT entry) for the specified
// symbol. The platform object does the work of creating the platform-specific
// StubAtom.
//
#include "llvm/ADT/DenseMap.h"
#include "lld/Core/DefinedAtom.h"
#include "lld/Core/Pass.h"
#include "lld/Core/File.h"
#include "lld/Core/Reference.h"
@ -26,12 +27,12 @@
namespace lld {
void StubsPass::perform() {
// Skip this pass if output format does not need stubs.
if ( !_platform.outputUsesStubs() )
// Skip this pass if output format uses text relocations instead of stubs.
if ( !_platform.noTextRelocs() )
return;
// Use map so all call sites to same shlib symbol use same stub
llvm::DenseMap<const SharedLibraryAtom*, const Atom*> shlibToStub;
// Use map so all call sites to same shlib symbol use same stub.
llvm::DenseMap<const Atom*, const DefinedAtom*> targetToStub;
// Scan all references in all atoms.
for(auto ait=_file.definedAtomsBegin(), aend=_file.definedAtomsEnd();
@ -40,26 +41,40 @@ void StubsPass::perform() {
for (auto rit=atom->referencesBegin(), rend=atom->referencesEnd();
rit != rend; ++rit) {
const Reference* ref = *rit;
const Atom* target = ref->target();
assert(target != NULL);
// If the target of this reference is in a shared library
if ( const SharedLibraryAtom* shlbTarget = target->sharedLibraryAtom() ) {
// and this is a call to that shared library symbol.
if ( _platform.isBranch(ref) ) {
const Atom* stub;
// Replace the target with a reference to a stub
auto pos = shlibToStub.find(shlbTarget);
if ( pos == shlibToStub.end() ) {
// Look at call-sites.
if ( _platform.isCallSite(ref->kind()) ) {
const Atom* target = ref->target();
assert(target != NULL);
bool replaceCalleeWithStub = false;
if ( target->definition() == Atom::definitionSharedLibrary ) {
// Calls to shared libraries go through stubs.
replaceCalleeWithStub = true;
}
else if ( const DefinedAtom* defTarget = target->definedAtom() ) {
if ( defTarget->interposable() != DefinedAtom::interposeNo ) {
// Calls to interposable functions in same linkage unit
// must also go through a stub.
assert(defTarget->scope() != DefinedAtom::scopeTranslationUnit);
replaceCalleeWithStub = true;
}
}
if ( replaceCalleeWithStub ) {
// Replace the reference's target with a stub.
const DefinedAtom* stub;
auto pos = targetToStub.find(target);
if ( pos == targetToStub.end() ) {
// This is no existing stub. Create a new one.
stub = _platform.makeStub(*shlbTarget, _file);
shlibToStub[shlbTarget] = stub;
stub = _platform.makeStub(*target, _file);
assert(stub != NULL);
assert(stub->contentType() == DefinedAtom::typeStub);
targetToStub[target] = stub;
}
else {
// Reuse and existing stub
// Reuse an existing stub.
stub = pos->second;
assert(stub != NULL);
}
assert(stub != NULL);
// Switch call site in atom to refrence stub instead of shlib atom.
// Switch call site to reference stub atom.
(const_cast<Reference*>(ref))->setTarget(stub);
}
}
@ -67,7 +82,7 @@ void StubsPass::perform() {
}
// add all created stubs to file
for (auto it=shlibToStub.begin(), end=shlibToStub.end(); it != end; ++it) {
for (auto it=targetToStub.begin(), end=targetToStub.end(); it != end; ++it) {
_file.addAtom(*it->second);
}

81
lld/test/pass-got-basic.objtxt Normal file
View File

@ -0,0 +1,81 @@
# RUN: lld-core %s -got_pass | FileCheck %s
#
# Test that GOT pass instantiates GOT entires and alters references
#
---
atoms:
- name: foo
type: code
content: [ 48, 8B, 0D, 00, 00, 00, 00,
48, 8B, 0D, 00, 00, 00, 00,
48, 8B, 0D, 00, 00, 00, 00,
48, 83, 3D, 00, 00, 00, 00, 00,
48, 83, 3D, 00, 00, 00, 00, 00,
48, 83, 3D, 00, 00, 00, 00, 00,
48, 83, 3D, 00, 00, 00, 00, 00 ]
fixups:
- offset: 3
kind: gotLoad32
target: malloc
- offset: 10
kind: gotLoad32
target: myPrivate
- offset: 17
kind: gotLoad32
target: myInterposable
- offset: 24
kind: gotUse32
target: malloc
- offset: 32
kind: gotUse32
target: myPrivate
- offset: 40
kind: gotUse32
target: myInterposable
- name: myPrivate
scope: global
interposable: no
- name: myInterposable
scope: global
interposable: yes
- name: malloc
definition: shared-library
load-name: libc.so
...
# CHECK: name: foo
# CHECK: fixups:
# CHECK: offset: 3
# CHECK: kind: pcrel32
# CHECK: target: L
# CHECK: offset: 10
# CHECK: kind: lea32wasGot
# CHECK: target: myPrivate
# CHECK: offset: 17
# CHECK: kind: pcrel32
# CHECK: target: L
# CHECK: offset: 24
# CHECK: kind: pcrel32
# CHECK: target: L
# CHECK: offset: 32
# CHECK: kind: pcrel32
# CHECK: target: L
# CHECK: offset: 40
# CHECK: kind: pcrel32
# CHECK: target: L
# CHECK: name: myPrivate
# CHECK: name: myInterposable
# CHECK: interposable: yes
# CHECK: name: L
# CHECK: type: got
# CHECK: type: got
# CHECK: type: got
# CHECK: name: malloc
# CHECK: definition: shared-library
# CHECK: ...

161
lld/tools/lld-core/lld-core.cpp
View File

@ -54,11 +54,11 @@ namespace {
//
// Simple atoms created by the stubs pass.
// Simple atom created by the stubs pass.
//
class TestingStubAtom : public DefinedAtom {
public:
TestingStubAtom(const File& f, const SharedLibraryAtom& shlib) :
TestingStubAtom(const File& f, const Atom& shlib) :
_file(f), _shlib(shlib) {
static uint32_t lastOrdinal = 0;
_ordinal = lastOrdinal++;
@ -145,11 +145,109 @@ public:
private:
const File& _file;
const SharedLibraryAtom& _shlib;
const Atom& _shlib;
uint32_t _ordinal;
};
//
// Simple atom created by the GOT pass.
//
class TestingGOTAtom : public DefinedAtom {
public:
TestingGOTAtom(const File& f, const Atom& shlib) :
_file(f), _shlib(shlib) {
static uint32_t lastOrdinal = 0;
_ordinal = lastOrdinal++;
}
virtual const File& file() const {
return _file;
}
virtual llvm::StringRef name() const {
return llvm::StringRef();
}
virtual uint64_t ordinal() const {
return _ordinal;
}
virtual uint64_t size() const {
return 0;
}
virtual Scope scope() const {
return DefinedAtom::scopeLinkageUnit;
}
virtual Interposable interposable() const {
return DefinedAtom::interposeNo;
}
virtual Merge merge() const {
return DefinedAtom::mergeNo;
}
virtual ContentType contentType() const {
return DefinedAtom::typeGOT;
}
virtual Alignment alignment() const {
return Alignment(3,0);
}
virtual SectionChoice sectionChoice() const {
return DefinedAtom::sectionBasedOnContent;
}
virtual llvm::StringRef customSectionName() const {
return llvm::StringRef();
}
virtual DeadStripKind deadStrip() const {
return DefinedAtom::deadStripNormal;
}
virtual ContentPermissions permissions() const {
return DefinedAtom::permRW_;
}
virtual bool isThumb() const {
return false;
}
virtual bool isAlias() const {
return false;
}
virtual llvm::ArrayRef<uint8_t> rawContent() const {
return llvm::ArrayRef<uint8_t>();
}
virtual reference_iterator referencesBegin() const {
return reference_iterator(*this, NULL);
}
virtual reference_iterator referencesEnd() const {
return reference_iterator(*this, NULL);
}
virtual const Reference* derefIterator(const void* iter) const {
return NULL;
}
virtual void incrementIterator(const void*& iter) const {
}
private:
const File& _file;
const Atom& _shlib;
uint32_t _ordinal;
};
//
// A simple platform for testing.
//
@ -252,13 +350,13 @@ public:
// last chance for platform to tweak atoms
virtual void postResolveTweaks(std::vector<const Atom *> &all) {}
virtual bool outputUsesStubs() { return true; };
struct KindMapping {
const char* string;
Reference::Kind value;
bool isBranch;
bool isGotLoad;
bool isGotUse;
};
static const KindMapping _s_kindMappings[];
@ -282,19 +380,45 @@ public:
return llvm::StringRef("???");
}
virtual bool noTextRelocs() {
return true;
}
virtual bool isBranch(const Reference* ref) {
Reference::Kind value = ref->kind();
virtual bool isCallSite(Reference::Kind kind) {
for (const KindMapping* p = _s_kindMappings; p->string != NULL; ++p) {
if ( value == p->value )
if ( kind == p->value )
return p->isBranch;
}
return false;
}
virtual const Atom* makeStub(const SharedLibraryAtom& shlibAtom, File& file) {
virtual bool isGOTAccess(Reference::Kind kind, bool& canBypassGOT) {
for (const KindMapping* p = _s_kindMappings; p->string != NULL; ++p) {
if ( kind == p->value ) {
canBypassGOT = p->isGotLoad;
return p->isGotUse;
}
}
return false;
}
virtual void updateReferenceToGOT(const Reference* ref, bool targetIsNowGOT) {
if ( targetIsNowGOT )
(const_cast<Reference*>(ref))->setKind(kindFromString("pcrel32"));
else
(const_cast<Reference*>(ref))->setKind(kindFromString("lea32wasGot"));
}
virtual const DefinedAtom* makeStub(const Atom& shlibAtom, File& file) {
return new TestingStubAtom(file, shlibAtom);
}
virtual const DefinedAtom* makeGOTEntry(const Atom& shlibAtom, File& file) {
return new TestingGOTAtom(file, shlibAtom);
}
};
@ -302,13 +426,16 @@ public:
// Table of fixup kinds in YAML documents used for testing
//
const TestingPlatform::KindMapping TestingPlatform::_s_kindMappings[] = {
{ "call32", 1, true },
{ "pcrel32", 2, false },
{ "gotLoad32", 3, false },
{ NULL, 0, false }
{ "call32", 1, true, false, false},
{ "pcrel32", 2, false, false, false },
{ "gotLoad32", 3, false, true, true },
{ "gotUse32", 4, false, false, true },
{ "lea32wasGot", 5, false, false, false },
{ NULL, 0, false, false, false }
};
//
// A simple input files wrapper for testing.
//
@ -372,6 +499,9 @@ llvm::cl::opt<bool>
gDoStubsPass("stubs_pass",
llvm::cl::desc("Run pass to create stub atoms"));
llvm::cl::opt<bool>
gDoGotPass("got_pass",
llvm::cl::desc("Run pass to create GOT atoms"));
int main(int argc, char *argv[]) {
// Print a stack trace if we signal out.
@ -400,11 +530,16 @@ int main(int argc, char *argv[]) {
resolver.resolve();
// run passes
if ( gDoGotPass ) {
GOTPass addGot(resolver.resultFile(), testingPlatform);
addGot.perform();
}
if ( gDoStubsPass ) {
StubsPass addStubs(resolver.resultFile(), testingPlatform);
addStubs.perform();
}
// write new atom graph out as YAML doc
std::string errorInfo;
const char* outPath = gOutputFilePath.empty() ? "-" : gOutputFilePath.c_str();