3a52eb0054
Thunks are now implemented by redirecting the relocation to the
symbol S, to a symbol TS in a Thunk. The Thunk will transfer control
to S. This has the following implications:
- All the side-effects of Thunks happen within createThunks()
- Thunks are no longer stored in InputSections and Symbols no longer
need to hold a pointer to a Thunk
- The synthetic Thunk sections need to be merged into OutputSections
This implementation is almost a direct conversion of the existing
Thunks with the following exceptions:
- Mips LA25 Thunks are placed before the InputSection that defines
the symbol that needs a Thunk.
- All ARM Thunks are placed at the end of the OutputSection of the
first caller to the Thunk.
Range extension Thunks are not supported yet so it is optimistically
assumed that all Thunks can be reused.
This is a recommit of r293283 with a fixed comparison predicate as
std::merge requires a strict weak ordering.
Differential revision: https://reviews.llvm.org/D29327
llvm-svn: 293757
284 lines
10 KiB
C++
284 lines
10 KiB
C++
//===- Thunks.cpp --------------------------------------------------------===//
|
|
//
|
|
// The LLVM Linker
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===---------------------------------------------------------------------===//
|
|
//
|
|
// This file contains Thunk subclasses.
|
|
//
|
|
// A thunk is a small piece of code written after an input section
|
|
// which is used to jump between "incompatible" functions
|
|
// such as MIPS PIC and non-PIC or ARM non-Thumb and Thumb functions.
|
|
//
|
|
// If a jump target is too far and its address doesn't fit to a
|
|
// short jump instruction, we need to create a thunk too, but we
|
|
// haven't supported it yet.
|
|
//
|
|
// i386 and x86-64 don't need thunks.
|
|
//
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
#include "Thunks.h"
|
|
#include "Config.h"
|
|
#include "Error.h"
|
|
#include "InputSection.h"
|
|
#include "Memory.h"
|
|
#include "OutputSections.h"
|
|
#include "Symbols.h"
|
|
#include "SyntheticSections.h"
|
|
#include "Target.h"
|
|
#include "llvm/Support/Casting.h"
|
|
#include "llvm/Support/ELF.h"
|
|
#include "llvm/Support/Endian.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/MathExtras.h"
|
|
#include <cstdint>
|
|
#include <cstring>
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::object;
|
|
using namespace llvm::support::endian;
|
|
using namespace llvm::ELF;
|
|
|
|
namespace lld {
|
|
namespace elf {
|
|
|
|
namespace {
|
|
|
|
// Specific ARM Thunk implementations. The naming convention is:
|
|
// Source State, TargetState, Target Requirement, ABS or PI, Range
|
|
template <class ELFT>
|
|
class ARMToThumbV7ABSLongThunk final : public Thunk<ELFT> {
|
|
public:
|
|
ARMToThumbV7ABSLongThunk(const SymbolBody &Dest) : Thunk<ELFT>(Dest) {}
|
|
|
|
uint32_t size() const override { return 12; }
|
|
void writeTo(uint8_t *Buf, ThunkSection<ELFT> &IS) const override;
|
|
void addSymbols(ThunkSection<ELFT> &IS) override;
|
|
};
|
|
|
|
template <class ELFT> class ARMToThumbV7PILongThunk final : public Thunk<ELFT> {
|
|
public:
|
|
ARMToThumbV7PILongThunk(const SymbolBody &Dest) : Thunk<ELFT>(Dest) {}
|
|
|
|
uint32_t size() const override { return 16; }
|
|
void writeTo(uint8_t *Buf, ThunkSection<ELFT> &IS) const override;
|
|
void addSymbols(ThunkSection<ELFT> &IS) override;
|
|
};
|
|
|
|
template <class ELFT>
|
|
class ThumbToARMV7ABSLongThunk final : public Thunk<ELFT> {
|
|
public:
|
|
ThumbToARMV7ABSLongThunk(const SymbolBody &Dest) : Thunk<ELFT>(Dest) {
|
|
this->alignment = 2;
|
|
}
|
|
|
|
uint32_t size() const override { return 10; }
|
|
void writeTo(uint8_t *Buf, ThunkSection<ELFT> &IS) const override;
|
|
void addSymbols(ThunkSection<ELFT> &IS) override;
|
|
};
|
|
|
|
template <class ELFT> class ThumbToARMV7PILongThunk final : public Thunk<ELFT> {
|
|
public:
|
|
ThumbToARMV7PILongThunk(const SymbolBody &Dest) : Thunk<ELFT>(Dest) {
|
|
this->alignment = 2;
|
|
}
|
|
|
|
uint32_t size() const override { return 12; }
|
|
void writeTo(uint8_t *Buf, ThunkSection<ELFT> &IS) const override;
|
|
void addSymbols(ThunkSection<ELFT> &IS) override;
|
|
};
|
|
|
|
// MIPS LA25 thunk
|
|
template <class ELFT> class MipsThunk final : public Thunk<ELFT> {
|
|
public:
|
|
MipsThunk(const SymbolBody &Dest) : Thunk<ELFT>(Dest) {}
|
|
|
|
uint32_t size() const override { return 16; }
|
|
void writeTo(uint8_t *Buf, ThunkSection<ELFT> &IS) const override;
|
|
void addSymbols(ThunkSection<ELFT> &IS) override;
|
|
InputSection<ELFT> *getTargetInputSection() const override;
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
// ARM Target Thunks
|
|
template <class ELFT> static uint64_t getARMThunkDestVA(const SymbolBody &S) {
|
|
uint64_t V = S.isInPlt() ? S.getPltVA<ELFT>() : S.getVA<ELFT>();
|
|
return SignExtend64<32>(V);
|
|
}
|
|
|
|
template <class ELFT>
|
|
void ARMToThumbV7ABSLongThunk<ELFT>::writeTo(uint8_t *Buf,
|
|
ThunkSection<ELFT> &IS) const {
|
|
const uint8_t Data[] = {
|
|
0x00, 0xc0, 0x00, 0xe3, // movw ip,:lower16:S
|
|
0x00, 0xc0, 0x40, 0xe3, // movt ip,:upper16:S
|
|
0x1c, 0xff, 0x2f, 0xe1, // bx ip
|
|
};
|
|
uint64_t S = getARMThunkDestVA<ELFT>(this->Destination);
|
|
memcpy(Buf, Data, sizeof(Data));
|
|
Target->relocateOne(Buf, R_ARM_MOVW_ABS_NC, S);
|
|
Target->relocateOne(Buf + 4, R_ARM_MOVT_ABS, S);
|
|
}
|
|
|
|
template <class ELFT>
|
|
void ARMToThumbV7ABSLongThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
|
|
this->ThunkSym = addSyntheticLocal(
|
|
Saver.save("__ARMToThumbv7ABSLongThunk_" + this->Destination.getName()),
|
|
STT_FUNC, this->Offset, size(), &IS);
|
|
addSyntheticLocal("$a", STT_NOTYPE, this->Offset, 0, &IS);
|
|
}
|
|
|
|
template <class ELFT>
|
|
void ThumbToARMV7ABSLongThunk<ELFT>::writeTo(uint8_t *Buf,
|
|
ThunkSection<ELFT> &IS) const {
|
|
const uint8_t Data[] = {
|
|
0x40, 0xf2, 0x00, 0x0c, // movw ip, :lower16:S
|
|
0xc0, 0xf2, 0x00, 0x0c, // movt ip, :upper16:S
|
|
0x60, 0x47, // bx ip
|
|
};
|
|
uint64_t S = getARMThunkDestVA<ELFT>(this->Destination);
|
|
memcpy(Buf, Data, sizeof(Data));
|
|
Target->relocateOne(Buf, R_ARM_THM_MOVW_ABS_NC, S);
|
|
Target->relocateOne(Buf + 4, R_ARM_THM_MOVT_ABS, S);
|
|
}
|
|
|
|
template <class ELFT>
|
|
void ThumbToARMV7ABSLongThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
|
|
this->ThunkSym = addSyntheticLocal(
|
|
Saver.save("__ThumbToARMv7ABSLongThunk_" + this->Destination.getName()),
|
|
STT_FUNC, this->Offset, size(), &IS);
|
|
addSyntheticLocal("$t", STT_NOTYPE, this->Offset, 0, &IS);
|
|
}
|
|
|
|
template <class ELFT>
|
|
void ARMToThumbV7PILongThunk<ELFT>::writeTo(uint8_t *Buf,
|
|
ThunkSection<ELFT> &IS) const {
|
|
const uint8_t Data[] = {
|
|
0xf0, 0xcf, 0x0f, 0xe3, // P: movw ip,:lower16:S - (P + (L1-P) +8)
|
|
0x00, 0xc0, 0x40, 0xe3, // movt ip,:upper16:S - (P + (L1-P+4) +8)
|
|
0x0f, 0xc0, 0x8c, 0xe0, // L1: add ip, ip, pc
|
|
0x1c, 0xff, 0x2f, 0xe1, // bx r12
|
|
};
|
|
uint64_t S = getARMThunkDestVA<ELFT>(this->Destination);
|
|
uint64_t P = this->ThunkSym->template getVA<ELFT>();
|
|
memcpy(Buf, Data, sizeof(Data));
|
|
Target->relocateOne(Buf, R_ARM_MOVW_PREL_NC, S - P - 16);
|
|
Target->relocateOne(Buf + 4, R_ARM_MOVT_PREL, S - P - 12);
|
|
}
|
|
|
|
template <class ELFT>
|
|
void ARMToThumbV7PILongThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
|
|
this->ThunkSym = addSyntheticLocal(
|
|
Saver.save("__ARMToThumbV7PILongThunk_" + this->Destination.getName()),
|
|
STT_FUNC, this->Offset, size(), &IS);
|
|
addSyntheticLocal("$a", STT_NOTYPE, this->Offset, 0, &IS);
|
|
}
|
|
|
|
template <class ELFT>
|
|
void ThumbToARMV7PILongThunk<ELFT>::writeTo(uint8_t *Buf,
|
|
ThunkSection<ELFT> &IS) const {
|
|
const uint8_t Data[] = {
|
|
0x4f, 0xf6, 0xf4, 0x7c, // P: movw ip,:lower16:S - (P + (L1-P) + 4)
|
|
0xc0, 0xf2, 0x00, 0x0c, // movt ip,:upper16:S - (P + (L1-P+4) + 4)
|
|
0xfc, 0x44, // L1: add r12, pc
|
|
0x60, 0x47, // bx r12
|
|
};
|
|
uint64_t S = getARMThunkDestVA<ELFT>(this->Destination);
|
|
uint64_t P = this->ThunkSym->template getVA<ELFT>();
|
|
memcpy(Buf, Data, sizeof(Data));
|
|
Target->relocateOne(Buf, R_ARM_THM_MOVW_PREL_NC, S - P - 12);
|
|
Target->relocateOne(Buf + 4, R_ARM_THM_MOVT_PREL, S - P - 8);
|
|
}
|
|
|
|
template <class ELFT>
|
|
void ThumbToARMV7PILongThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
|
|
this->ThunkSym = addSyntheticLocal(
|
|
Saver.save("__ThumbToARMV7PILongThunk_" + this->Destination.getName()),
|
|
STT_FUNC, this->Offset, size(), &IS);
|
|
addSyntheticLocal("$t", STT_NOTYPE, this->Offset, 0, &IS);
|
|
}
|
|
|
|
// Write MIPS LA25 thunk code to call PIC function from the non-PIC one.
|
|
template <class ELFT>
|
|
void MipsThunk<ELFT>::writeTo(uint8_t *Buf, ThunkSection<ELFT> &) const {
|
|
const endianness E = ELFT::TargetEndianness;
|
|
|
|
uint64_t S = this->Destination.template getVA<ELFT>();
|
|
write32<E>(Buf, 0x3c190000); // lui $25, %hi(func)
|
|
write32<E>(Buf + 4, 0x08000000 | (S >> 2)); // j func
|
|
write32<E>(Buf + 8, 0x27390000); // addiu $25, $25, %lo(func)
|
|
write32<E>(Buf + 12, 0x00000000); // nop
|
|
Target->relocateOne(Buf, R_MIPS_HI16, S);
|
|
Target->relocateOne(Buf + 8, R_MIPS_LO16, S);
|
|
}
|
|
|
|
template <class ELFT> void MipsThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
|
|
this->ThunkSym = addSyntheticLocal(
|
|
Saver.save("__LA25Thunk_" + this->Destination.getName()), STT_FUNC,
|
|
this->Offset, size(), &IS);
|
|
}
|
|
|
|
template <class ELFT>
|
|
InputSection<ELFT> *MipsThunk<ELFT>::getTargetInputSection() const {
|
|
auto *DR = dyn_cast<DefinedRegular<ELFT>>(&this->Destination);
|
|
return dyn_cast<InputSection<ELFT>>(DR->Section);
|
|
}
|
|
|
|
template <class ELFT>
|
|
Thunk<ELFT>::Thunk(const SymbolBody &D) : Destination(D), Offset(0) {}
|
|
|
|
template <class ELFT> Thunk<ELFT>::~Thunk() = default;
|
|
|
|
// Creates a thunk for Thumb-ARM interworking.
|
|
template <class ELFT>
|
|
static Thunk<ELFT> *addThunkArm(uint32_t Reloc, SymbolBody &S) {
|
|
// ARM relocations need ARM to Thumb interworking Thunks.
|
|
// Thumb relocations need Thumb to ARM relocations.
|
|
// Use position independent Thunks if we require position independent code.
|
|
switch (Reloc) {
|
|
case R_ARM_PC24:
|
|
case R_ARM_PLT32:
|
|
case R_ARM_JUMP24:
|
|
if (Config->Pic)
|
|
return make<ARMToThumbV7PILongThunk<ELFT>>(S);
|
|
return make<ARMToThumbV7ABSLongThunk<ELFT>>(S);
|
|
case R_ARM_THM_JUMP19:
|
|
case R_ARM_THM_JUMP24:
|
|
if (Config->Pic)
|
|
return make<ThumbToARMV7PILongThunk<ELFT>>(S);
|
|
return make<ThumbToARMV7ABSLongThunk<ELFT>>(S);
|
|
}
|
|
fatal("unrecognized relocation type");
|
|
}
|
|
|
|
template <class ELFT> static Thunk<ELFT> *addThunkMips(SymbolBody &S) {
|
|
return make<MipsThunk<ELFT>>(S);
|
|
}
|
|
|
|
template <class ELFT> Thunk<ELFT> *addThunk(uint32_t RelocType, SymbolBody &S) {
|
|
if (Config->EMachine == EM_ARM)
|
|
return addThunkArm<ELFT>(RelocType, S);
|
|
else if (Config->EMachine == EM_MIPS)
|
|
return addThunkMips<ELFT>(S);
|
|
llvm_unreachable("add Thunk only supported for ARM and Mips");
|
|
return nullptr;
|
|
}
|
|
|
|
template Thunk<ELF32LE> *addThunk<ELF32LE>(uint32_t, SymbolBody &);
|
|
template Thunk<ELF32BE> *addThunk<ELF32BE>(uint32_t, SymbolBody &);
|
|
template Thunk<ELF64LE> *addThunk<ELF64LE>(uint32_t, SymbolBody &);
|
|
template Thunk<ELF64BE> *addThunk<ELF64BE>(uint32_t, SymbolBody &);
|
|
|
|
template class Thunk<ELF32LE>;
|
|
template class Thunk<ELF32BE>;
|
|
template class Thunk<ELF64LE>;
|
|
template class Thunk<ELF64BE>;
|
|
|
|
} // end namespace elf
|
|
} // end namespace lld
|