2946cd7010
to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
1523 lines
54 KiB
C++
1523 lines
54 KiB
C++
//===- lib/FileFormat/MachO/ArchHandler_arm.cpp ---------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "ArchHandler.h"
|
|
#include "Atoms.h"
|
|
#include "MachONormalizedFileBinaryUtils.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/ADT/StringSwitch.h"
|
|
#include "llvm/ADT/Triple.h"
|
|
#include "llvm/Support/Endian.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
using namespace llvm::MachO;
|
|
using namespace lld::mach_o::normalized;
|
|
|
|
namespace lld {
|
|
namespace mach_o {
|
|
|
|
using llvm::support::ulittle32_t;
|
|
using llvm::support::little32_t;
|
|
|
|
|
|
class ArchHandler_arm : public ArchHandler {
|
|
public:
|
|
ArchHandler_arm() = default;
|
|
~ArchHandler_arm() override = default;
|
|
|
|
const Registry::KindStrings *kindStrings() override { return _sKindStrings; }
|
|
|
|
Reference::KindArch kindArch() override { return Reference::KindArch::ARM; }
|
|
|
|
const ArchHandler::StubInfo &stubInfo() override;
|
|
bool isCallSite(const Reference &) override;
|
|
bool isPointer(const Reference &) override;
|
|
bool isPairedReloc(const normalized::Relocation &) override;
|
|
bool isNonCallBranch(const Reference &) override;
|
|
|
|
bool needsCompactUnwind() override {
|
|
return false;
|
|
}
|
|
Reference::KindValue imageOffsetKind() override {
|
|
return invalid;
|
|
}
|
|
Reference::KindValue imageOffsetKindIndirect() override {
|
|
return invalid;
|
|
}
|
|
|
|
Reference::KindValue unwindRefToPersonalityFunctionKind() override {
|
|
return invalid;
|
|
}
|
|
|
|
Reference::KindValue unwindRefToCIEKind() override {
|
|
return invalid;
|
|
}
|
|
|
|
Reference::KindValue unwindRefToFunctionKind() override {
|
|
return invalid;
|
|
}
|
|
|
|
Reference::KindValue unwindRefToEhFrameKind() override {
|
|
return invalid;
|
|
}
|
|
|
|
Reference::KindValue lazyImmediateLocationKind() override {
|
|
return lazyImmediateLocation;
|
|
}
|
|
|
|
Reference::KindValue pointerKind() override {
|
|
return invalid;
|
|
}
|
|
|
|
uint32_t dwarfCompactUnwindType() override {
|
|
// FIXME
|
|
return -1;
|
|
}
|
|
|
|
llvm::Error getReferenceInfo(const normalized::Relocation &reloc,
|
|
const DefinedAtom *inAtom,
|
|
uint32_t offsetInAtom,
|
|
uint64_t fixupAddress, bool swap,
|
|
FindAtomBySectionAndAddress atomFromAddress,
|
|
FindAtomBySymbolIndex atomFromSymbolIndex,
|
|
Reference::KindValue *kind,
|
|
const lld::Atom **target,
|
|
Reference::Addend *addend) override;
|
|
llvm::Error
|
|
getPairReferenceInfo(const normalized::Relocation &reloc1,
|
|
const normalized::Relocation &reloc2,
|
|
const DefinedAtom *inAtom,
|
|
uint32_t offsetInAtom,
|
|
uint64_t fixupAddress, bool swap, bool scatterable,
|
|
FindAtomBySectionAndAddress atomFromAddress,
|
|
FindAtomBySymbolIndex atomFromSymbolIndex,
|
|
Reference::KindValue *kind,
|
|
const lld::Atom **target,
|
|
Reference::Addend *addend) override;
|
|
|
|
void generateAtomContent(const DefinedAtom &atom, bool relocatable,
|
|
FindAddressForAtom findAddress,
|
|
FindAddressForAtom findSectionAddress,
|
|
uint64_t imageBaseAddress,
|
|
llvm::MutableArrayRef<uint8_t> atomContentBuffer) override;
|
|
|
|
void appendSectionRelocations(const DefinedAtom &atom,
|
|
uint64_t atomSectionOffset,
|
|
const Reference &ref,
|
|
FindSymbolIndexForAtom,
|
|
FindSectionIndexForAtom,
|
|
FindAddressForAtom,
|
|
normalized::Relocations &) override;
|
|
|
|
void addAdditionalReferences(MachODefinedAtom &atom) override;
|
|
|
|
bool isDataInCodeTransition(Reference::KindValue refKind) override {
|
|
switch (refKind) {
|
|
case modeThumbCode:
|
|
case modeArmCode:
|
|
case modeData:
|
|
return true;
|
|
default:
|
|
return false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
Reference::KindValue dataInCodeTransitionStart(
|
|
const MachODefinedAtom &atom) override {
|
|
return modeData;
|
|
}
|
|
|
|
Reference::KindValue dataInCodeTransitionEnd(
|
|
const MachODefinedAtom &atom) override {
|
|
return atom.isThumb() ? modeThumbCode : modeArmCode;
|
|
}
|
|
|
|
bool isThumbFunction(const DefinedAtom &atom) override;
|
|
const DefinedAtom *createShim(MachOFile &file, bool thumbToArm,
|
|
const DefinedAtom &) override;
|
|
|
|
private:
|
|
friend class Thumb2ToArmShimAtom;
|
|
friend class ArmToThumbShimAtom;
|
|
|
|
static const Registry::KindStrings _sKindStrings[];
|
|
static const StubInfo _sStubInfoArmPIC;
|
|
|
|
enum ArmKind : Reference::KindValue {
|
|
invalid, /// for error condition
|
|
|
|
modeThumbCode, /// Content starting at this offset is thumb.
|
|
modeArmCode, /// Content starting at this offset is arm.
|
|
modeData, /// Content starting at this offset is data.
|
|
|
|
// Kinds found in mach-o .o files:
|
|
thumb_bl22, /// ex: bl _foo
|
|
thumb_b22, /// ex: b _foo
|
|
thumb_movw, /// ex: movw r1, :lower16:_foo
|
|
thumb_movt, /// ex: movt r1, :lower16:_foo
|
|
thumb_movw_funcRel, /// ex: movw r1, :lower16:(_foo-(L1+4))
|
|
thumb_movt_funcRel, /// ex: movt r1, :upper16:(_foo-(L1+4))
|
|
arm_bl24, /// ex: bl _foo
|
|
arm_b24, /// ex: b _foo
|
|
arm_movw, /// ex: movw r1, :lower16:_foo
|
|
arm_movt, /// ex: movt r1, :lower16:_foo
|
|
arm_movw_funcRel, /// ex: movw r1, :lower16:(_foo-(L1+4))
|
|
arm_movt_funcRel, /// ex: movt r1, :upper16:(_foo-(L1+4))
|
|
pointer32, /// ex: .long _foo
|
|
delta32, /// ex: .long _foo - .
|
|
|
|
// Kinds introduced by Passes:
|
|
lazyPointer, /// Location contains a lazy pointer.
|
|
lazyImmediateLocation, /// Location contains immediate value used in stub.
|
|
};
|
|
|
|
// Utility functions for inspecting/updating instructions.
|
|
static bool isThumbMovw(uint32_t instruction);
|
|
static bool isThumbMovt(uint32_t instruction);
|
|
static bool isArmMovw(uint32_t instruction);
|
|
static bool isArmMovt(uint32_t instruction);
|
|
static int32_t getDisplacementFromThumbBranch(uint32_t instruction, uint32_t);
|
|
static int32_t getDisplacementFromArmBranch(uint32_t instruction);
|
|
static uint16_t getWordFromThumbMov(uint32_t instruction);
|
|
static uint16_t getWordFromArmMov(uint32_t instruction);
|
|
static uint32_t clearThumbBit(uint32_t value, const Atom *target);
|
|
static uint32_t setDisplacementInArmBranch(uint32_t instr, int32_t disp,
|
|
bool targetIsThumb);
|
|
static uint32_t setDisplacementInThumbBranch(uint32_t instr, uint32_t ia,
|
|
int32_t disp, bool targetThumb);
|
|
static uint32_t setWordFromThumbMov(uint32_t instruction, uint16_t word);
|
|
static uint32_t setWordFromArmMov(uint32_t instruction, uint16_t word);
|
|
|
|
StringRef stubName(const DefinedAtom &);
|
|
bool useExternalRelocationTo(const Atom &target);
|
|
|
|
void applyFixupFinal(const Reference &ref, uint8_t *location,
|
|
uint64_t fixupAddress, uint64_t targetAddress,
|
|
uint64_t inAtomAddress, bool &thumbMode,
|
|
bool targetIsThumb);
|
|
|
|
void applyFixupRelocatable(const Reference &ref, uint8_t *location,
|
|
uint64_t fixupAddress,
|
|
uint64_t targetAddress,
|
|
uint64_t inAtomAddress, bool &thumbMode,
|
|
bool targetIsThumb);
|
|
};
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ArchHandler_arm
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
const Registry::KindStrings ArchHandler_arm::_sKindStrings[] = {
|
|
LLD_KIND_STRING_ENTRY(invalid),
|
|
LLD_KIND_STRING_ENTRY(modeThumbCode),
|
|
LLD_KIND_STRING_ENTRY(modeArmCode),
|
|
LLD_KIND_STRING_ENTRY(modeData),
|
|
LLD_KIND_STRING_ENTRY(thumb_bl22),
|
|
LLD_KIND_STRING_ENTRY(thumb_b22),
|
|
LLD_KIND_STRING_ENTRY(thumb_movw),
|
|
LLD_KIND_STRING_ENTRY(thumb_movt),
|
|
LLD_KIND_STRING_ENTRY(thumb_movw_funcRel),
|
|
LLD_KIND_STRING_ENTRY(thumb_movt_funcRel),
|
|
LLD_KIND_STRING_ENTRY(arm_bl24),
|
|
LLD_KIND_STRING_ENTRY(arm_b24),
|
|
LLD_KIND_STRING_ENTRY(arm_movw),
|
|
LLD_KIND_STRING_ENTRY(arm_movt),
|
|
LLD_KIND_STRING_ENTRY(arm_movw_funcRel),
|
|
LLD_KIND_STRING_ENTRY(arm_movt_funcRel),
|
|
LLD_KIND_STRING_ENTRY(pointer32),
|
|
LLD_KIND_STRING_ENTRY(delta32),
|
|
LLD_KIND_STRING_ENTRY(lazyPointer),
|
|
LLD_KIND_STRING_ENTRY(lazyImmediateLocation),
|
|
LLD_KIND_STRING_END
|
|
};
|
|
|
|
const ArchHandler::StubInfo ArchHandler_arm::_sStubInfoArmPIC = {
|
|
"dyld_stub_binder",
|
|
|
|
// References in lazy pointer
|
|
{ Reference::KindArch::ARM, pointer32, 0, 0 },
|
|
{ Reference::KindArch::ARM, lazyPointer, 0, 0 },
|
|
|
|
// GOT pointer to dyld_stub_binder
|
|
{ Reference::KindArch::ARM, pointer32, 0, 0 },
|
|
|
|
// arm code alignment 2^2
|
|
2,
|
|
|
|
// Stub size and code
|
|
16,
|
|
{ 0x04, 0xC0, 0x9F, 0xE5, // ldr ip, pc + 12
|
|
0x0C, 0xC0, 0x8F, 0xE0, // add ip, pc, ip
|
|
0x00, 0xF0, 0x9C, 0xE5, // ldr pc, [ip]
|
|
0x00, 0x00, 0x00, 0x00 }, // .long L_foo$lazy_ptr - (L1$scv + 8)
|
|
{ Reference::KindArch::ARM, delta32, 12, 0 },
|
|
{ false, 0, 0, 0 },
|
|
|
|
// Stub Helper size and code
|
|
12,
|
|
{ 0x00, 0xC0, 0x9F, 0xE5, // ldr ip, [pc, #0]
|
|
0x00, 0x00, 0x00, 0xEA, // b _helperhelper
|
|
0x00, 0x00, 0x00, 0x00 }, // .long lazy-info-offset
|
|
{ Reference::KindArch::ARM, lazyImmediateLocation, 8, 0 },
|
|
{ Reference::KindArch::ARM, arm_b24, 4, 0 },
|
|
|
|
// Stub helper image cache content type
|
|
DefinedAtom::typeGOT,
|
|
|
|
// Stub Helper-Common size and code
|
|
36,
|
|
// Stub helper alignment
|
|
2,
|
|
{ // push lazy-info-offset
|
|
0x04, 0xC0, 0x2D, 0xE5, // str ip, [sp, #-4]!
|
|
// push address of dyld_mageLoaderCache
|
|
0x10, 0xC0, 0x9F, 0xE5, // ldr ip, L1
|
|
0x0C, 0xC0, 0x8F, 0xE0, // add ip, pc, ip
|
|
0x04, 0xC0, 0x2D, 0xE5, // str ip, [sp, #-4]!
|
|
// jump through dyld_stub_binder
|
|
0x08, 0xC0, 0x9F, 0xE5, // ldr ip, L2
|
|
0x0C, 0xC0, 0x8F, 0xE0, // add ip, pc, ip
|
|
0x00, 0xF0, 0x9C, 0xE5, // ldr pc, [ip]
|
|
0x00, 0x00, 0x00, 0x00, // L1: .long fFastStubGOTAtom - (helper+16)
|
|
0x00, 0x00, 0x00, 0x00 }, // L2: .long dyld_stub_binder - (helper+28)
|
|
{ Reference::KindArch::ARM, delta32, 28, 0xC },
|
|
{ false, 0, 0, 0 },
|
|
{ Reference::KindArch::ARM, delta32, 32, 0x04 },
|
|
{ false, 0, 0, 0 }
|
|
};
|
|
|
|
const ArchHandler::StubInfo &ArchHandler_arm::stubInfo() {
|
|
// If multiple kinds of stubs are supported, select which StubInfo here.
|
|
return _sStubInfoArmPIC;
|
|
}
|
|
|
|
bool ArchHandler_arm::isCallSite(const Reference &ref) {
|
|
switch (ref.kindValue()) {
|
|
case thumb_b22:
|
|
case thumb_bl22:
|
|
case arm_b24:
|
|
case arm_bl24:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ArchHandler_arm::isPointer(const Reference &ref) {
|
|
return (ref.kindValue() == pointer32);
|
|
}
|
|
|
|
bool ArchHandler_arm::isNonCallBranch(const Reference &ref) {
|
|
switch (ref.kindValue()) {
|
|
case thumb_b22:
|
|
case arm_b24:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ArchHandler_arm::isPairedReloc(const Relocation &reloc) {
|
|
switch (reloc.type) {
|
|
case ARM_RELOC_SECTDIFF:
|
|
case ARM_RELOC_LOCAL_SECTDIFF:
|
|
case ARM_RELOC_HALF_SECTDIFF:
|
|
case ARM_RELOC_HALF:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// Trace references from stub atom to lazy pointer to target and get its name.
|
|
StringRef ArchHandler_arm::stubName(const DefinedAtom &stubAtom) {
|
|
assert(stubAtom.contentType() == DefinedAtom::typeStub);
|
|
for (const Reference *ref : stubAtom) {
|
|
if (const DefinedAtom* lp = dyn_cast<DefinedAtom>(ref->target())) {
|
|
if (lp->contentType() != DefinedAtom::typeLazyPointer)
|
|
continue;
|
|
for (const Reference *ref2 : *lp) {
|
|
if (ref2->kindValue() != lazyPointer)
|
|
continue;
|
|
return ref2->target()->name();
|
|
}
|
|
}
|
|
}
|
|
return "stub";
|
|
}
|
|
|
|
/// Extract displacement from an ARM b/bl/blx instruction.
|
|
int32_t ArchHandler_arm::getDisplacementFromArmBranch(uint32_t instruction) {
|
|
// Sign-extend imm24
|
|
int32_t displacement = (instruction & 0x00FFFFFF) << 2;
|
|
if ((displacement & 0x02000000) != 0)
|
|
displacement |= 0xFC000000;
|
|
// If this is BLX and H bit set, add 2.
|
|
if ((instruction & 0xFF000000) == 0xFB000000)
|
|
displacement += 2;
|
|
return displacement;
|
|
}
|
|
|
|
/// Update an ARM b/bl/blx instruction, switching bl <-> blx as needed.
|
|
uint32_t ArchHandler_arm::setDisplacementInArmBranch(uint32_t instruction,
|
|
int32_t displacement,
|
|
bool targetIsThumb) {
|
|
assert((displacement <= 33554428) && (displacement > (-33554432))
|
|
&& "arm branch out of range");
|
|
bool is_blx = ((instruction & 0xF0000000) == 0xF0000000);
|
|
uint32_t newInstruction = (instruction & 0xFF000000);
|
|
uint32_t h = 0;
|
|
if (targetIsThumb) {
|
|
// Force use of BLX.
|
|
newInstruction = 0xFA000000;
|
|
if (!is_blx) {
|
|
assert(((instruction & 0xF0000000) == 0xE0000000)
|
|
&& "no conditional arm blx");
|
|
assert(((instruction & 0xFF000000) == 0xEB000000)
|
|
&& "no arm pc-rel BX instruction");
|
|
}
|
|
if (displacement & 2)
|
|
h = 1;
|
|
}
|
|
else {
|
|
// Force use of B/BL.
|
|
if (is_blx)
|
|
newInstruction = 0xEB000000;
|
|
}
|
|
newInstruction |= (h << 24) | ((displacement >> 2) & 0x00FFFFFF);
|
|
return newInstruction;
|
|
}
|
|
|
|
/// Extract displacement from a thumb b/bl/blx instruction.
|
|
int32_t ArchHandler_arm::getDisplacementFromThumbBranch(uint32_t instruction,
|
|
uint32_t instrAddr) {
|
|
bool is_blx = ((instruction & 0xD000F800) == 0xC000F000);
|
|
uint32_t s = (instruction >> 10) & 0x1;
|
|
uint32_t j1 = (instruction >> 29) & 0x1;
|
|
uint32_t j2 = (instruction >> 27) & 0x1;
|
|
uint32_t imm10 = instruction & 0x3FF;
|
|
uint32_t imm11 = (instruction >> 16) & 0x7FF;
|
|
uint32_t i1 = (j1 == s);
|
|
uint32_t i2 = (j2 == s);
|
|
uint32_t dis =
|
|
(s << 24) | (i1 << 23) | (i2 << 22) | (imm10 << 12) | (imm11 << 1);
|
|
int32_t sdis = dis;
|
|
int32_t result = s ? (sdis | 0xFE000000) : sdis;
|
|
if (is_blx && (instrAddr & 0x2)) {
|
|
// The thumb blx instruction always has low bit of imm11 as zero. The way
|
|
// a 2-byte aligned blx can branch to a 4-byte aligned ARM target is that
|
|
// the blx instruction always 4-byte aligns the pc before adding the
|
|
// displacement from the blx. We must emulate that when decoding this.
|
|
result -= 2;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// Update a thumb b/bl/blx instruction, switching bl <-> blx as needed.
|
|
uint32_t ArchHandler_arm::setDisplacementInThumbBranch(uint32_t instruction,
|
|
uint32_t instrAddr,
|
|
int32_t displacement,
|
|
bool targetIsThumb) {
|
|
assert((displacement <= 16777214) && (displacement > (-16777216))
|
|
&& "thumb branch out of range");
|
|
bool is_bl = ((instruction & 0xD000F800) == 0xD000F000);
|
|
bool is_blx = ((instruction & 0xD000F800) == 0xC000F000);
|
|
bool is_b = ((instruction & 0xD000F800) == 0x9000F000);
|
|
uint32_t newInstruction = (instruction & 0xD000F800);
|
|
if (is_bl || is_blx) {
|
|
if (targetIsThumb) {
|
|
newInstruction = 0xD000F000; // Use bl
|
|
} else {
|
|
newInstruction = 0xC000F000; // Use blx
|
|
// See note in getDisplacementFromThumbBranch() about blx.
|
|
if (instrAddr & 0x2)
|
|
displacement += 2;
|
|
}
|
|
} else if (is_b) {
|
|
assert(targetIsThumb && "no pc-rel thumb branch instruction that "
|
|
"switches to arm mode");
|
|
}
|
|
else {
|
|
llvm_unreachable("thumb branch22 reloc on a non-branch instruction");
|
|
}
|
|
uint32_t s = (uint32_t)(displacement >> 24) & 0x1;
|
|
uint32_t i1 = (uint32_t)(displacement >> 23) & 0x1;
|
|
uint32_t i2 = (uint32_t)(displacement >> 22) & 0x1;
|
|
uint32_t imm10 = (uint32_t)(displacement >> 12) & 0x3FF;
|
|
uint32_t imm11 = (uint32_t)(displacement >> 1) & 0x7FF;
|
|
uint32_t j1 = (i1 == s);
|
|
uint32_t j2 = (i2 == s);
|
|
uint32_t nextDisp = (j1 << 13) | (j2 << 11) | imm11;
|
|
uint32_t firstDisp = (s << 10) | imm10;
|
|
newInstruction |= (nextDisp << 16) | firstDisp;
|
|
return newInstruction;
|
|
}
|
|
|
|
bool ArchHandler_arm::isThumbMovw(uint32_t instruction) {
|
|
return (instruction & 0x8000FBF0) == 0x0000F240;
|
|
}
|
|
|
|
bool ArchHandler_arm::isThumbMovt(uint32_t instruction) {
|
|
return (instruction & 0x8000FBF0) == 0x0000F2C0;
|
|
}
|
|
|
|
bool ArchHandler_arm::isArmMovw(uint32_t instruction) {
|
|
return (instruction & 0x0FF00000) == 0x03000000;
|
|
}
|
|
|
|
bool ArchHandler_arm::isArmMovt(uint32_t instruction) {
|
|
return (instruction & 0x0FF00000) == 0x03400000;
|
|
}
|
|
|
|
uint16_t ArchHandler_arm::getWordFromThumbMov(uint32_t instruction) {
|
|
assert(isThumbMovw(instruction) || isThumbMovt(instruction));
|
|
uint32_t i = ((instruction & 0x00000400) >> 10);
|
|
uint32_t imm4 = (instruction & 0x0000000F);
|
|
uint32_t imm3 = ((instruction & 0x70000000) >> 28);
|
|
uint32_t imm8 = ((instruction & 0x00FF0000) >> 16);
|
|
return (imm4 << 12) | (i << 11) | (imm3 << 8) | imm8;
|
|
}
|
|
|
|
uint16_t ArchHandler_arm::getWordFromArmMov(uint32_t instruction) {
|
|
assert(isArmMovw(instruction) || isArmMovt(instruction));
|
|
uint32_t imm4 = ((instruction & 0x000F0000) >> 16);
|
|
uint32_t imm12 = (instruction & 0x00000FFF);
|
|
return (imm4 << 12) | imm12;
|
|
}
|
|
|
|
uint32_t ArchHandler_arm::setWordFromThumbMov(uint32_t instr, uint16_t word) {
|
|
assert(isThumbMovw(instr) || isThumbMovt(instr));
|
|
uint32_t imm4 = (word & 0xF000) >> 12;
|
|
uint32_t i = (word & 0x0800) >> 11;
|
|
uint32_t imm3 = (word & 0x0700) >> 8;
|
|
uint32_t imm8 = word & 0x00FF;
|
|
return (instr & 0x8F00FBF0) | imm4 | (i << 10) | (imm3 << 28) | (imm8 << 16);
|
|
}
|
|
|
|
uint32_t ArchHandler_arm::setWordFromArmMov(uint32_t instr, uint16_t word) {
|
|
assert(isArmMovw(instr) || isArmMovt(instr));
|
|
uint32_t imm4 = (word & 0xF000) >> 12;
|
|
uint32_t imm12 = word & 0x0FFF;
|
|
return (instr & 0xFFF0F000) | (imm4 << 16) | imm12;
|
|
}
|
|
|
|
uint32_t ArchHandler_arm::clearThumbBit(uint32_t value, const Atom *target) {
|
|
// The assembler often adds one to the address of a thumb function.
|
|
// We need to undo that so it does not look like an addend.
|
|
if (value & 1) {
|
|
if (isa<DefinedAtom>(target)) {
|
|
const MachODefinedAtom *machoTarget =
|
|
reinterpret_cast<const MachODefinedAtom *>(target);
|
|
if (machoTarget->isThumb())
|
|
value &= -2; // mask off thumb-bit
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
llvm::Error ArchHandler_arm::getReferenceInfo(
|
|
const Relocation &reloc, const DefinedAtom *inAtom, uint32_t offsetInAtom,
|
|
uint64_t fixupAddress, bool isBig,
|
|
FindAtomBySectionAndAddress atomFromAddress,
|
|
FindAtomBySymbolIndex atomFromSymbolIndex, Reference::KindValue *kind,
|
|
const lld::Atom **target, Reference::Addend *addend) {
|
|
const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
|
|
uint64_t targetAddress;
|
|
uint32_t instruction = *(const ulittle32_t *)fixupContent;
|
|
int32_t displacement;
|
|
switch (relocPattern(reloc)) {
|
|
case ARM_THUMB_RELOC_BR22 | rPcRel | rExtern | rLength4:
|
|
// ex: bl _foo (and _foo is undefined)
|
|
if ((instruction & 0xD000F800) == 0x9000F000)
|
|
*kind = thumb_b22;
|
|
else
|
|
*kind = thumb_bl22;
|
|
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
|
|
return ec;
|
|
// Instruction contains branch to addend.
|
|
displacement = getDisplacementFromThumbBranch(instruction, fixupAddress);
|
|
*addend = fixupAddress + 4 + displacement;
|
|
return llvm::Error::success();
|
|
case ARM_THUMB_RELOC_BR22 | rPcRel | rLength4:
|
|
// ex: bl _foo (and _foo is defined)
|
|
if ((instruction & 0xD000F800) == 0x9000F000)
|
|
*kind = thumb_b22;
|
|
else
|
|
*kind = thumb_bl22;
|
|
displacement = getDisplacementFromThumbBranch(instruction, fixupAddress);
|
|
targetAddress = fixupAddress + 4 + displacement;
|
|
return atomFromAddress(reloc.symbol, targetAddress, target, addend);
|
|
case ARM_THUMB_RELOC_BR22 | rScattered | rPcRel | rLength4:
|
|
// ex: bl _foo+4 (and _foo is defined)
|
|
if ((instruction & 0xD000F800) == 0x9000F000)
|
|
*kind = thumb_b22;
|
|
else
|
|
*kind = thumb_bl22;
|
|
displacement = getDisplacementFromThumbBranch(instruction, fixupAddress);
|
|
targetAddress = fixupAddress + 4 + displacement;
|
|
if (auto ec = atomFromAddress(0, reloc.value, target, addend))
|
|
return ec;
|
|
// reloc.value is target atom's address. Instruction contains branch
|
|
// to atom+addend.
|
|
*addend += (targetAddress - reloc.value);
|
|
return llvm::Error::success();
|
|
case ARM_RELOC_BR24 | rPcRel | rExtern | rLength4:
|
|
// ex: bl _foo (and _foo is undefined)
|
|
if (((instruction & 0x0F000000) == 0x0A000000)
|
|
&& ((instruction & 0xF0000000) != 0xF0000000))
|
|
*kind = arm_b24;
|
|
else
|
|
*kind = arm_bl24;
|
|
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
|
|
return ec;
|
|
// Instruction contains branch to addend.
|
|
displacement = getDisplacementFromArmBranch(instruction);
|
|
*addend = fixupAddress + 8 + displacement;
|
|
return llvm::Error::success();
|
|
case ARM_RELOC_BR24 | rPcRel | rLength4:
|
|
// ex: bl _foo (and _foo is defined)
|
|
if (((instruction & 0x0F000000) == 0x0A000000)
|
|
&& ((instruction & 0xF0000000) != 0xF0000000))
|
|
*kind = arm_b24;
|
|
else
|
|
*kind = arm_bl24;
|
|
displacement = getDisplacementFromArmBranch(instruction);
|
|
targetAddress = fixupAddress + 8 + displacement;
|
|
return atomFromAddress(reloc.symbol, targetAddress, target, addend);
|
|
case ARM_RELOC_BR24 | rScattered | rPcRel | rLength4:
|
|
// ex: bl _foo+4 (and _foo is defined)
|
|
if (((instruction & 0x0F000000) == 0x0A000000)
|
|
&& ((instruction & 0xF0000000) != 0xF0000000))
|
|
*kind = arm_b24;
|
|
else
|
|
*kind = arm_bl24;
|
|
displacement = getDisplacementFromArmBranch(instruction);
|
|
targetAddress = fixupAddress + 8 + displacement;
|
|
if (auto ec = atomFromAddress(0, reloc.value, target, addend))
|
|
return ec;
|
|
// reloc.value is target atom's address. Instruction contains branch
|
|
// to atom+addend.
|
|
*addend += (targetAddress - reloc.value);
|
|
return llvm::Error::success();
|
|
case ARM_RELOC_VANILLA | rExtern | rLength4:
|
|
// ex: .long _foo (and _foo is undefined)
|
|
*kind = pointer32;
|
|
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
|
|
return ec;
|
|
*addend = instruction;
|
|
return llvm::Error::success();
|
|
case ARM_RELOC_VANILLA | rLength4:
|
|
// ex: .long _foo (and _foo is defined)
|
|
*kind = pointer32;
|
|
if (auto ec = atomFromAddress(reloc.symbol, instruction, target, addend))
|
|
return ec;
|
|
*addend = clearThumbBit((uint32_t) * addend, *target);
|
|
return llvm::Error::success();
|
|
case ARM_RELOC_VANILLA | rScattered | rLength4:
|
|
// ex: .long _foo+a (and _foo is defined)
|
|
*kind = pointer32;
|
|
if (auto ec = atomFromAddress(0, reloc.value, target, addend))
|
|
return ec;
|
|
*addend += (clearThumbBit(instruction, *target) - reloc.value);
|
|
return llvm::Error::success();
|
|
default:
|
|
return llvm::make_error<GenericError>("unsupported arm relocation type");
|
|
}
|
|
return llvm::Error::success();
|
|
}
|
|
|
|
llvm::Error
|
|
ArchHandler_arm::getPairReferenceInfo(const normalized::Relocation &reloc1,
|
|
const normalized::Relocation &reloc2,
|
|
const DefinedAtom *inAtom,
|
|
uint32_t offsetInAtom,
|
|
uint64_t fixupAddress, bool isBig,
|
|
bool scatterable,
|
|
FindAtomBySectionAndAddress atomFromAddr,
|
|
FindAtomBySymbolIndex atomFromSymbolIndex,
|
|
Reference::KindValue *kind,
|
|
const lld::Atom **target,
|
|
Reference::Addend *addend) {
|
|
bool pointerDiff = false;
|
|
bool funcRel;
|
|
bool top;
|
|
bool thumbReloc;
|
|
switch(relocPattern(reloc1) << 16 | relocPattern(reloc2)) {
|
|
case ((ARM_RELOC_HALF_SECTDIFF | rScattered | rLenThmbLo) << 16 |
|
|
ARM_RELOC_PAIR | rScattered | rLenThmbLo):
|
|
// ex: movw r1, :lower16:(_x-L1) [thumb mode]
|
|
*kind = thumb_movw_funcRel;
|
|
funcRel = true;
|
|
top = false;
|
|
thumbReloc = true;
|
|
break;
|
|
case ((ARM_RELOC_HALF_SECTDIFF | rScattered | rLenThmbHi) << 16 |
|
|
ARM_RELOC_PAIR | rScattered | rLenThmbHi):
|
|
// ex: movt r1, :upper16:(_x-L1) [thumb mode]
|
|
*kind = thumb_movt_funcRel;
|
|
funcRel = true;
|
|
top = true;
|
|
thumbReloc = true;
|
|
break;
|
|
case ((ARM_RELOC_HALF_SECTDIFF | rScattered | rLenArmLo) << 16 |
|
|
ARM_RELOC_PAIR | rScattered | rLenArmLo):
|
|
// ex: movw r1, :lower16:(_x-L1) [arm mode]
|
|
*kind = arm_movw_funcRel;
|
|
funcRel = true;
|
|
top = false;
|
|
thumbReloc = false;
|
|
break;
|
|
case ((ARM_RELOC_HALF_SECTDIFF | rScattered | rLenArmHi) << 16 |
|
|
ARM_RELOC_PAIR | rScattered | rLenArmHi):
|
|
// ex: movt r1, :upper16:(_x-L1) [arm mode]
|
|
*kind = arm_movt_funcRel;
|
|
funcRel = true;
|
|
top = true;
|
|
thumbReloc = false;
|
|
break;
|
|
case ((ARM_RELOC_HALF | rLenThmbLo) << 16 |
|
|
ARM_RELOC_PAIR | rLenThmbLo):
|
|
// ex: movw r1, :lower16:_x [thumb mode]
|
|
*kind = thumb_movw;
|
|
funcRel = false;
|
|
top = false;
|
|
thumbReloc = true;
|
|
break;
|
|
case ((ARM_RELOC_HALF | rLenThmbHi) << 16 |
|
|
ARM_RELOC_PAIR | rLenThmbHi):
|
|
// ex: movt r1, :upper16:_x [thumb mode]
|
|
*kind = thumb_movt;
|
|
funcRel = false;
|
|
top = true;
|
|
thumbReloc = true;
|
|
break;
|
|
case ((ARM_RELOC_HALF | rLenArmLo) << 16 |
|
|
ARM_RELOC_PAIR | rLenArmLo):
|
|
// ex: movw r1, :lower16:_x [arm mode]
|
|
*kind = arm_movw;
|
|
funcRel = false;
|
|
top = false;
|
|
thumbReloc = false;
|
|
break;
|
|
case ((ARM_RELOC_HALF | rLenArmHi) << 16 |
|
|
ARM_RELOC_PAIR | rLenArmHi):
|
|
// ex: movt r1, :upper16:_x [arm mode]
|
|
*kind = arm_movt;
|
|
funcRel = false;
|
|
top = true;
|
|
thumbReloc = false;
|
|
break;
|
|
case ((ARM_RELOC_HALF | rScattered | rLenThmbLo) << 16 |
|
|
ARM_RELOC_PAIR | rLenThmbLo):
|
|
// ex: movw r1, :lower16:_x+a [thumb mode]
|
|
*kind = thumb_movw;
|
|
funcRel = false;
|
|
top = false;
|
|
thumbReloc = true;
|
|
break;
|
|
case ((ARM_RELOC_HALF | rScattered | rLenThmbHi) << 16 |
|
|
ARM_RELOC_PAIR | rLenThmbHi):
|
|
// ex: movt r1, :upper16:_x+a [thumb mode]
|
|
*kind = thumb_movt;
|
|
funcRel = false;
|
|
top = true;
|
|
thumbReloc = true;
|
|
break;
|
|
case ((ARM_RELOC_HALF | rScattered | rLenArmLo) << 16 |
|
|
ARM_RELOC_PAIR | rLenArmLo):
|
|
// ex: movw r1, :lower16:_x+a [arm mode]
|
|
*kind = arm_movw;
|
|
funcRel = false;
|
|
top = false;
|
|
thumbReloc = false;
|
|
break;
|
|
case ((ARM_RELOC_HALF | rScattered | rLenArmHi) << 16 |
|
|
ARM_RELOC_PAIR | rLenArmHi):
|
|
// ex: movt r1, :upper16:_x+a [arm mode]
|
|
*kind = arm_movt;
|
|
funcRel = false;
|
|
top = true;
|
|
thumbReloc = false;
|
|
break;
|
|
case ((ARM_RELOC_HALF | rExtern | rLenThmbLo) << 16 |
|
|
ARM_RELOC_PAIR | rLenThmbLo):
|
|
// ex: movw r1, :lower16:_undef [thumb mode]
|
|
*kind = thumb_movw;
|
|
funcRel = false;
|
|
top = false;
|
|
thumbReloc = true;
|
|
break;
|
|
case ((ARM_RELOC_HALF | rExtern | rLenThmbHi) << 16 |
|
|
ARM_RELOC_PAIR | rLenThmbHi):
|
|
// ex: movt r1, :upper16:_undef [thumb mode]
|
|
*kind = thumb_movt;
|
|
funcRel = false;
|
|
top = true;
|
|
thumbReloc = true;
|
|
break;
|
|
case ((ARM_RELOC_HALF | rExtern | rLenArmLo) << 16 |
|
|
ARM_RELOC_PAIR | rLenArmLo):
|
|
// ex: movw r1, :lower16:_undef [arm mode]
|
|
*kind = arm_movw;
|
|
funcRel = false;
|
|
top = false;
|
|
thumbReloc = false;
|
|
break;
|
|
case ((ARM_RELOC_HALF | rExtern | rLenArmHi) << 16 |
|
|
ARM_RELOC_PAIR | rLenArmHi):
|
|
// ex: movt r1, :upper16:_undef [arm mode]
|
|
*kind = arm_movt;
|
|
funcRel = false;
|
|
top = true;
|
|
thumbReloc = false;
|
|
break;
|
|
case ((ARM_RELOC_SECTDIFF | rScattered | rLength4) << 16 |
|
|
ARM_RELOC_PAIR | rScattered | rLength4):
|
|
case ((ARM_RELOC_LOCAL_SECTDIFF | rScattered | rLength4) << 16 |
|
|
ARM_RELOC_PAIR | rScattered | rLength4):
|
|
// ex: .long _foo - .
|
|
pointerDiff = true;
|
|
break;
|
|
default:
|
|
return llvm::make_error<GenericError>("unsupported arm relocation pair");
|
|
}
|
|
const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
|
|
uint32_t instruction = *(const ulittle32_t *)fixupContent;
|
|
uint32_t value;
|
|
uint32_t fromAddress;
|
|
uint32_t toAddress;
|
|
uint16_t instruction16;
|
|
uint16_t other16;
|
|
const lld::Atom *fromTarget;
|
|
Reference::Addend offsetInTo;
|
|
Reference::Addend offsetInFrom;
|
|
if (pointerDiff) {
|
|
toAddress = reloc1.value;
|
|
fromAddress = reloc2.value;
|
|
if (auto ec = atomFromAddr(0, toAddress, target, &offsetInTo))
|
|
return ec;
|
|
if (auto ec = atomFromAddr(0, fromAddress, &fromTarget, &offsetInFrom))
|
|
return ec;
|
|
if (scatterable && (fromTarget != inAtom))
|
|
return llvm::make_error<GenericError>(
|
|
"SECTDIFF relocation where subtrahend label is not in atom");
|
|
*kind = delta32;
|
|
value = clearThumbBit(instruction, *target);
|
|
*addend = (int32_t)(value - (toAddress - fixupAddress));
|
|
} else if (funcRel) {
|
|
toAddress = reloc1.value;
|
|
fromAddress = reloc2.value;
|
|
if (auto ec = atomFromAddr(0, toAddress, target, &offsetInTo))
|
|
return ec;
|
|
if (auto ec = atomFromAddr(0, fromAddress, &fromTarget, &offsetInFrom))
|
|
return ec;
|
|
if (fromTarget != inAtom)
|
|
return llvm::make_error<GenericError>("ARM_RELOC_HALF_SECTDIFF relocation"
|
|
" where subtrahend label is not in atom");
|
|
other16 = (reloc2.offset & 0xFFFF);
|
|
if (thumbReloc) {
|
|
if (top) {
|
|
if (!isThumbMovt(instruction))
|
|
return llvm::make_error<GenericError>("expected movt instruction");
|
|
}
|
|
else {
|
|
if (!isThumbMovw(instruction))
|
|
return llvm::make_error<GenericError>("expected movw instruction");
|
|
}
|
|
instruction16 = getWordFromThumbMov(instruction);
|
|
}
|
|
else {
|
|
if (top) {
|
|
if (!isArmMovt(instruction))
|
|
return llvm::make_error<GenericError>("expected movt instruction");
|
|
}
|
|
else {
|
|
if (!isArmMovw(instruction))
|
|
return llvm::make_error<GenericError>("expected movw instruction");
|
|
}
|
|
instruction16 = getWordFromArmMov(instruction);
|
|
}
|
|
if (top)
|
|
value = (instruction16 << 16) | other16;
|
|
else
|
|
value = (other16 << 16) | instruction16;
|
|
value = clearThumbBit(value, *target);
|
|
int64_t ta = (int64_t) value - (toAddress - fromAddress);
|
|
*addend = ta - offsetInFrom;
|
|
return llvm::Error::success();
|
|
} else {
|
|
uint32_t sectIndex;
|
|
if (thumbReloc) {
|
|
if (top) {
|
|
if (!isThumbMovt(instruction))
|
|
return llvm::make_error<GenericError>("expected movt instruction");
|
|
}
|
|
else {
|
|
if (!isThumbMovw(instruction))
|
|
return llvm::make_error<GenericError>("expected movw instruction");
|
|
}
|
|
instruction16 = getWordFromThumbMov(instruction);
|
|
}
|
|
else {
|
|
if (top) {
|
|
if (!isArmMovt(instruction))
|
|
return llvm::make_error<GenericError>("expected movt instruction");
|
|
}
|
|
else {
|
|
if (!isArmMovw(instruction))
|
|
return llvm::make_error<GenericError>("expected movw instruction");
|
|
}
|
|
instruction16 = getWordFromArmMov(instruction);
|
|
}
|
|
other16 = (reloc2.offset & 0xFFFF);
|
|
if (top)
|
|
value = (instruction16 << 16) | other16;
|
|
else
|
|
value = (other16 << 16) | instruction16;
|
|
if (reloc1.isExtern) {
|
|
if (auto ec = atomFromSymbolIndex(reloc1.symbol, target))
|
|
return ec;
|
|
*addend = value;
|
|
} else {
|
|
if (reloc1.scattered) {
|
|
toAddress = reloc1.value;
|
|
sectIndex = 0;
|
|
} else {
|
|
toAddress = value;
|
|
sectIndex = reloc1.symbol;
|
|
}
|
|
if (auto ec = atomFromAddr(sectIndex, toAddress, target, &offsetInTo))
|
|
return ec;
|
|
*addend = value - toAddress;
|
|
}
|
|
}
|
|
|
|
return llvm::Error::success();
|
|
}
|
|
|
|
void ArchHandler_arm::applyFixupFinal(const Reference &ref, uint8_t *loc,
|
|
uint64_t fixupAddress,
|
|
uint64_t targetAddress,
|
|
uint64_t inAtomAddress,
|
|
bool &thumbMode, bool targetIsThumb) {
|
|
if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
|
|
return;
|
|
assert(ref.kindArch() == Reference::KindArch::ARM);
|
|
ulittle32_t *loc32 = reinterpret_cast<ulittle32_t *>(loc);
|
|
int32_t displacement;
|
|
uint16_t value16;
|
|
uint32_t value32;
|
|
switch (static_cast<ArmKind>(ref.kindValue())) {
|
|
case modeThumbCode:
|
|
thumbMode = true;
|
|
break;
|
|
case modeArmCode:
|
|
thumbMode = false;
|
|
break;
|
|
case modeData:
|
|
break;
|
|
case thumb_b22:
|
|
case thumb_bl22:
|
|
assert(thumbMode);
|
|
displacement = (targetAddress - (fixupAddress + 4)) + ref.addend();
|
|
value32 = setDisplacementInThumbBranch(*loc32, fixupAddress,
|
|
displacement, targetIsThumb);
|
|
*loc32 = value32;
|
|
break;
|
|
case thumb_movw:
|
|
assert(thumbMode);
|
|
value16 = (targetAddress + ref.addend()) & 0xFFFF;
|
|
if (targetIsThumb)
|
|
value16 |= 1;
|
|
*loc32 = setWordFromThumbMov(*loc32, value16);
|
|
break;
|
|
case thumb_movt:
|
|
assert(thumbMode);
|
|
value16 = (targetAddress + ref.addend()) >> 16;
|
|
*loc32 = setWordFromThumbMov(*loc32, value16);
|
|
break;
|
|
case thumb_movw_funcRel:
|
|
assert(thumbMode);
|
|
value16 = (targetAddress - inAtomAddress + ref.addend()) & 0xFFFF;
|
|
if (targetIsThumb)
|
|
value16 |= 1;
|
|
*loc32 = setWordFromThumbMov(*loc32, value16);
|
|
break;
|
|
case thumb_movt_funcRel:
|
|
assert(thumbMode);
|
|
value16 = (targetAddress - inAtomAddress + ref.addend()) >> 16;
|
|
*loc32 = setWordFromThumbMov(*loc32, value16);
|
|
break;
|
|
case arm_b24:
|
|
case arm_bl24:
|
|
assert(!thumbMode);
|
|
displacement = (targetAddress - (fixupAddress + 8)) + ref.addend();
|
|
value32 = setDisplacementInArmBranch(*loc32, displacement, targetIsThumb);
|
|
*loc32 = value32;
|
|
break;
|
|
case arm_movw:
|
|
assert(!thumbMode);
|
|
value16 = (targetAddress + ref.addend()) & 0xFFFF;
|
|
if (targetIsThumb)
|
|
value16 |= 1;
|
|
*loc32 = setWordFromArmMov(*loc32, value16);
|
|
break;
|
|
case arm_movt:
|
|
assert(!thumbMode);
|
|
value16 = (targetAddress + ref.addend()) >> 16;
|
|
*loc32 = setWordFromArmMov(*loc32, value16);
|
|
break;
|
|
case arm_movw_funcRel:
|
|
assert(!thumbMode);
|
|
value16 = (targetAddress - inAtomAddress + ref.addend()) & 0xFFFF;
|
|
if (targetIsThumb)
|
|
value16 |= 1;
|
|
*loc32 = setWordFromArmMov(*loc32, value16);
|
|
break;
|
|
case arm_movt_funcRel:
|
|
assert(!thumbMode);
|
|
value16 = (targetAddress - inAtomAddress + ref.addend()) >> 16;
|
|
*loc32 = setWordFromArmMov(*loc32, value16);
|
|
break;
|
|
case pointer32:
|
|
if (targetIsThumb)
|
|
*loc32 = targetAddress + ref.addend() + 1;
|
|
else
|
|
*loc32 = targetAddress + ref.addend();
|
|
break;
|
|
case delta32:
|
|
if (targetIsThumb)
|
|
*loc32 = targetAddress - fixupAddress + ref.addend() + 1;
|
|
else
|
|
*loc32 = targetAddress - fixupAddress + ref.addend();
|
|
break;
|
|
case lazyPointer:
|
|
// do nothing
|
|
break;
|
|
case lazyImmediateLocation:
|
|
*loc32 = ref.addend();
|
|
break;
|
|
case invalid:
|
|
llvm_unreachable("invalid ARM Reference Kind");
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ArchHandler_arm::generateAtomContent(const DefinedAtom &atom,
|
|
bool relocatable,
|
|
FindAddressForAtom findAddress,
|
|
FindAddressForAtom findSectionAddress,
|
|
uint64_t imageBaseAddress,
|
|
llvm::MutableArrayRef<uint8_t> atomContentBuffer) {
|
|
// Copy raw bytes.
|
|
std::copy(atom.rawContent().begin(), atom.rawContent().end(),
|
|
atomContentBuffer.begin());
|
|
// Apply fix-ups.
|
|
bool thumbMode = false;
|
|
for (const Reference *ref : atom) {
|
|
uint32_t offset = ref->offsetInAtom();
|
|
const Atom *target = ref->target();
|
|
uint64_t targetAddress = 0;
|
|
bool targetIsThumb = false;
|
|
if (const DefinedAtom *defTarg = dyn_cast<DefinedAtom>(target)) {
|
|
targetAddress = findAddress(*target);
|
|
targetIsThumb = isThumbFunction(*defTarg);
|
|
}
|
|
uint64_t atomAddress = findAddress(atom);
|
|
uint64_t fixupAddress = atomAddress + offset;
|
|
if (relocatable) {
|
|
applyFixupRelocatable(*ref, &atomContentBuffer[offset], fixupAddress,
|
|
targetAddress, atomAddress, thumbMode,
|
|
targetIsThumb);
|
|
} else {
|
|
applyFixupFinal(*ref, &atomContentBuffer[offset], fixupAddress,
|
|
targetAddress, atomAddress, thumbMode, targetIsThumb);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ArchHandler_arm::useExternalRelocationTo(const Atom &target) {
|
|
// Undefined symbols are referenced via external relocations.
|
|
if (isa<UndefinedAtom>(&target))
|
|
return true;
|
|
if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(&target)) {
|
|
switch (defAtom->merge()) {
|
|
case DefinedAtom::mergeAsTentative:
|
|
// Tentative definitions are referenced via external relocations.
|
|
return true;
|
|
case DefinedAtom::mergeAsWeak:
|
|
case DefinedAtom::mergeAsWeakAndAddressUsed:
|
|
// Global weak-defs are referenced via external relocations.
|
|
return (defAtom->scope() == DefinedAtom::scopeGlobal);
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
// Everything else is reference via an internal relocation.
|
|
return false;
|
|
}
|
|
|
|
void ArchHandler_arm::applyFixupRelocatable(const Reference &ref, uint8_t *loc,
|
|
uint64_t fixupAddress,
|
|
uint64_t targetAddress,
|
|
uint64_t inAtomAddress,
|
|
bool &thumbMode,
|
|
bool targetIsThumb) {
|
|
if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
|
|
return;
|
|
assert(ref.kindArch() == Reference::KindArch::ARM);
|
|
bool useExternalReloc = useExternalRelocationTo(*ref.target());
|
|
ulittle32_t *loc32 = reinterpret_cast<ulittle32_t *>(loc);
|
|
int32_t displacement;
|
|
uint16_t value16;
|
|
uint32_t value32;
|
|
bool targetIsUndef = isa<UndefinedAtom>(ref.target());
|
|
switch (static_cast<ArmKind>(ref.kindValue())) {
|
|
case modeThumbCode:
|
|
thumbMode = true;
|
|
break;
|
|
case modeArmCode:
|
|
thumbMode = false;
|
|
break;
|
|
case modeData:
|
|
break;
|
|
case thumb_b22:
|
|
case thumb_bl22:
|
|
assert(thumbMode);
|
|
if (useExternalReloc)
|
|
displacement = (ref.addend() - (fixupAddress + 4));
|
|
else
|
|
displacement = (targetAddress - (fixupAddress + 4)) + ref.addend();
|
|
value32 = setDisplacementInThumbBranch(*loc32, fixupAddress,
|
|
displacement,
|
|
targetIsUndef || targetIsThumb);
|
|
*loc32 = value32;
|
|
break;
|
|
case thumb_movw:
|
|
assert(thumbMode);
|
|
if (useExternalReloc)
|
|
value16 = ref.addend() & 0xFFFF;
|
|
else
|
|
value16 = (targetAddress + ref.addend()) & 0xFFFF;
|
|
*loc32 = setWordFromThumbMov(*loc32, value16);
|
|
break;
|
|
case thumb_movt:
|
|
assert(thumbMode);
|
|
if (useExternalReloc)
|
|
value16 = ref.addend() >> 16;
|
|
else
|
|
value16 = (targetAddress + ref.addend()) >> 16;
|
|
*loc32 = setWordFromThumbMov(*loc32, value16);
|
|
break;
|
|
case thumb_movw_funcRel:
|
|
assert(thumbMode);
|
|
value16 = (targetAddress - inAtomAddress + ref.addend()) & 0xFFFF;
|
|
*loc32 = setWordFromThumbMov(*loc32, value16);
|
|
break;
|
|
case thumb_movt_funcRel:
|
|
assert(thumbMode);
|
|
value16 = (targetAddress - inAtomAddress + ref.addend()) >> 16;
|
|
*loc32 = setWordFromThumbMov(*loc32, value16);
|
|
break;
|
|
case arm_b24:
|
|
case arm_bl24:
|
|
assert(!thumbMode);
|
|
if (useExternalReloc)
|
|
displacement = (ref.addend() - (fixupAddress + 8));
|
|
else
|
|
displacement = (targetAddress - (fixupAddress + 8)) + ref.addend();
|
|
value32 = setDisplacementInArmBranch(*loc32, displacement,
|
|
targetIsThumb);
|
|
*loc32 = value32;
|
|
break;
|
|
case arm_movw:
|
|
assert(!thumbMode);
|
|
if (useExternalReloc)
|
|
value16 = ref.addend() & 0xFFFF;
|
|
else
|
|
value16 = (targetAddress + ref.addend()) & 0xFFFF;
|
|
*loc32 = setWordFromArmMov(*loc32, value16);
|
|
break;
|
|
case arm_movt:
|
|
assert(!thumbMode);
|
|
if (useExternalReloc)
|
|
value16 = ref.addend() >> 16;
|
|
else
|
|
value16 = (targetAddress + ref.addend()) >> 16;
|
|
*loc32 = setWordFromArmMov(*loc32, value16);
|
|
break;
|
|
case arm_movw_funcRel:
|
|
assert(!thumbMode);
|
|
value16 = (targetAddress - inAtomAddress + ref.addend()) & 0xFFFF;
|
|
*loc32 = setWordFromArmMov(*loc32, value16);
|
|
break;
|
|
case arm_movt_funcRel:
|
|
assert(!thumbMode);
|
|
value16 = (targetAddress - inAtomAddress + ref.addend()) >> 16;
|
|
*loc32 = setWordFromArmMov(*loc32, value16);
|
|
break;
|
|
case pointer32:
|
|
*loc32 = targetAddress + ref.addend();
|
|
break;
|
|
case delta32:
|
|
*loc32 = targetAddress - fixupAddress + ref.addend();
|
|
break;
|
|
case lazyPointer:
|
|
case lazyImmediateLocation:
|
|
// do nothing
|
|
break;
|
|
case invalid:
|
|
llvm_unreachable("invalid ARM Reference Kind");
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ArchHandler_arm::appendSectionRelocations(
|
|
const DefinedAtom &atom,
|
|
uint64_t atomSectionOffset,
|
|
const Reference &ref,
|
|
FindSymbolIndexForAtom symbolIndexForAtom,
|
|
FindSectionIndexForAtom sectionIndexForAtom,
|
|
FindAddressForAtom addressForAtom,
|
|
normalized::Relocations &relocs) {
|
|
if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
|
|
return;
|
|
assert(ref.kindArch() == Reference::KindArch::ARM);
|
|
uint32_t sectionOffset = atomSectionOffset + ref.offsetInAtom();
|
|
bool useExternalReloc = useExternalRelocationTo(*ref.target());
|
|
uint32_t targetAtomAddress;
|
|
uint32_t fromAtomAddress;
|
|
uint16_t other16;
|
|
switch (static_cast<ArmKind>(ref.kindValue())) {
|
|
case modeThumbCode:
|
|
case modeArmCode:
|
|
case modeData:
|
|
// Do nothing.
|
|
break;
|
|
case thumb_b22:
|
|
case thumb_bl22:
|
|
if (useExternalReloc) {
|
|
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
|
|
ARM_THUMB_RELOC_BR22 | rExtern | rPcRel | rLength4);
|
|
} else {
|
|
if (ref.addend() != 0)
|
|
appendReloc(relocs, sectionOffset, 0, addressForAtom(*ref.target()),
|
|
ARM_THUMB_RELOC_BR22 | rScattered | rPcRel | rLength4);
|
|
else
|
|
appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()),0,
|
|
ARM_THUMB_RELOC_BR22 | rPcRel | rLength4);
|
|
}
|
|
break;
|
|
case thumb_movw:
|
|
if (useExternalReloc) {
|
|
other16 = ref.addend() >> 16;
|
|
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
|
|
ARM_RELOC_HALF | rExtern | rLenThmbLo);
|
|
appendReloc(relocs, other16, 0, 0,
|
|
ARM_RELOC_PAIR | rLenThmbLo);
|
|
} else {
|
|
targetAtomAddress = addressForAtom(*ref.target());
|
|
if (ref.addend() != 0) {
|
|
other16 = (targetAtomAddress + ref.addend()) >> 16;
|
|
appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
|
|
ARM_RELOC_HALF | rScattered | rLenThmbLo);
|
|
appendReloc(relocs, other16, 0, 0,
|
|
ARM_RELOC_PAIR | rLenThmbLo);
|
|
} else {
|
|
other16 = (targetAtomAddress + ref.addend()) >> 16;
|
|
appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()),0,
|
|
ARM_RELOC_HALF | rLenThmbLo);
|
|
appendReloc(relocs, other16, 0, 0,
|
|
ARM_RELOC_PAIR | rLenThmbLo);
|
|
}
|
|
}
|
|
break;
|
|
case thumb_movt:
|
|
if (useExternalReloc) {
|
|
other16 = ref.addend() & 0xFFFF;
|
|
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
|
|
ARM_RELOC_HALF | rExtern | rLenThmbHi);
|
|
appendReloc(relocs, other16, 0, 0,
|
|
ARM_RELOC_PAIR | rLenThmbHi);
|
|
} else {
|
|
targetAtomAddress = addressForAtom(*ref.target());
|
|
if (ref.addend() != 0) {
|
|
other16 = (targetAtomAddress + ref.addend()) & 0xFFFF;
|
|
appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
|
|
ARM_RELOC_HALF | rScattered | rLenThmbHi);
|
|
appendReloc(relocs, other16, 0, 0,
|
|
ARM_RELOC_PAIR | rLenThmbHi);
|
|
} else {
|
|
other16 = (targetAtomAddress + ref.addend()) & 0xFFFF;
|
|
appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()),0,
|
|
ARM_RELOC_HALF | rLenThmbHi);
|
|
appendReloc(relocs, other16, 0, 0,
|
|
ARM_RELOC_PAIR | rLenThmbHi);
|
|
}
|
|
}
|
|
break;
|
|
case thumb_movw_funcRel:
|
|
fromAtomAddress = addressForAtom(atom);
|
|
targetAtomAddress = addressForAtom(*ref.target());
|
|
other16 = (targetAtomAddress - fromAtomAddress + ref.addend()) >> 16;
|
|
appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
|
|
ARM_RELOC_HALF_SECTDIFF | rScattered | rLenThmbLo);
|
|
appendReloc(relocs, other16, 0, fromAtomAddress,
|
|
ARM_RELOC_PAIR | rScattered | rLenThmbLo);
|
|
break;
|
|
case thumb_movt_funcRel:
|
|
fromAtomAddress = addressForAtom(atom);
|
|
targetAtomAddress = addressForAtom(*ref.target());
|
|
other16 = (targetAtomAddress - fromAtomAddress + ref.addend()) & 0xFFFF;
|
|
appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
|
|
ARM_RELOC_HALF_SECTDIFF | rScattered | rLenThmbHi);
|
|
appendReloc(relocs, other16, 0, fromAtomAddress,
|
|
ARM_RELOC_PAIR | rScattered | rLenThmbHi);
|
|
break;
|
|
case arm_b24:
|
|
case arm_bl24:
|
|
if (useExternalReloc) {
|
|
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
|
|
ARM_RELOC_BR24 | rExtern | rPcRel | rLength4);
|
|
} else {
|
|
if (ref.addend() != 0)
|
|
appendReloc(relocs, sectionOffset, 0, addressForAtom(*ref.target()),
|
|
ARM_RELOC_BR24 | rScattered | rPcRel | rLength4);
|
|
else
|
|
appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()),0,
|
|
ARM_RELOC_BR24 | rPcRel | rLength4);
|
|
}
|
|
break;
|
|
case arm_movw:
|
|
if (useExternalReloc) {
|
|
other16 = ref.addend() >> 16;
|
|
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
|
|
ARM_RELOC_HALF | rExtern | rLenArmLo);
|
|
appendReloc(relocs, other16, 0, 0,
|
|
ARM_RELOC_PAIR | rLenArmLo);
|
|
} else {
|
|
targetAtomAddress = addressForAtom(*ref.target());
|
|
if (ref.addend() != 0) {
|
|
other16 = (targetAtomAddress + ref.addend()) >> 16;
|
|
appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
|
|
ARM_RELOC_HALF | rScattered | rLenArmLo);
|
|
appendReloc(relocs, other16, 0, 0,
|
|
ARM_RELOC_PAIR | rLenArmLo);
|
|
} else {
|
|
other16 = (targetAtomAddress + ref.addend()) >> 16;
|
|
appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()),0,
|
|
ARM_RELOC_HALF | rLenArmLo);
|
|
appendReloc(relocs, other16, 0, 0,
|
|
ARM_RELOC_PAIR | rLenArmLo);
|
|
}
|
|
}
|
|
break;
|
|
case arm_movt:
|
|
if (useExternalReloc) {
|
|
other16 = ref.addend() & 0xFFFF;
|
|
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
|
|
ARM_RELOC_HALF | rExtern | rLenArmHi);
|
|
appendReloc(relocs, other16, 0, 0,
|
|
ARM_RELOC_PAIR | rLenArmHi);
|
|
} else {
|
|
targetAtomAddress = addressForAtom(*ref.target());
|
|
if (ref.addend() != 0) {
|
|
other16 = (targetAtomAddress + ref.addend()) & 0xFFFF;
|
|
appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
|
|
ARM_RELOC_HALF | rScattered | rLenArmHi);
|
|
appendReloc(relocs, other16, 0, 0,
|
|
ARM_RELOC_PAIR | rLenArmHi);
|
|
} else {
|
|
other16 = (targetAtomAddress + ref.addend()) & 0xFFFF;
|
|
appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()),0,
|
|
ARM_RELOC_HALF | rLenArmHi);
|
|
appendReloc(relocs, other16, 0, 0,
|
|
ARM_RELOC_PAIR | rLenArmHi);
|
|
}
|
|
}
|
|
break;
|
|
case arm_movw_funcRel:
|
|
fromAtomAddress = addressForAtom(atom);
|
|
targetAtomAddress = addressForAtom(*ref.target());
|
|
other16 = (targetAtomAddress - fromAtomAddress + ref.addend()) >> 16;
|
|
appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
|
|
ARM_RELOC_HALF_SECTDIFF | rScattered | rLenArmLo);
|
|
appendReloc(relocs, other16, 0, fromAtomAddress,
|
|
ARM_RELOC_PAIR | rScattered | rLenArmLo);
|
|
break;
|
|
case arm_movt_funcRel:
|
|
fromAtomAddress = addressForAtom(atom);
|
|
targetAtomAddress = addressForAtom(*ref.target());
|
|
other16 = (targetAtomAddress - fromAtomAddress + ref.addend()) & 0xFFFF;
|
|
appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
|
|
ARM_RELOC_HALF_SECTDIFF | rScattered | rLenArmHi);
|
|
appendReloc(relocs, other16, 0, fromAtomAddress,
|
|
ARM_RELOC_PAIR | rScattered | rLenArmHi);
|
|
break;
|
|
case pointer32:
|
|
if (useExternalReloc) {
|
|
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
|
|
ARM_RELOC_VANILLA | rExtern | rLength4);
|
|
}
|
|
else {
|
|
if (ref.addend() != 0)
|
|
appendReloc(relocs, sectionOffset, 0, addressForAtom(*ref.target()),
|
|
ARM_RELOC_VANILLA | rScattered | rLength4);
|
|
else
|
|
appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()),0,
|
|
ARM_RELOC_VANILLA | rLength4);
|
|
}
|
|
break;
|
|
case delta32:
|
|
appendReloc(relocs, sectionOffset, 0, addressForAtom(*ref.target()),
|
|
ARM_RELOC_SECTDIFF | rScattered | rLength4);
|
|
appendReloc(relocs, sectionOffset, 0, addressForAtom(atom) +
|
|
ref.offsetInAtom(),
|
|
ARM_RELOC_PAIR | rScattered | rLength4);
|
|
break;
|
|
case lazyPointer:
|
|
case lazyImmediateLocation:
|
|
// do nothing
|
|
break;
|
|
case invalid:
|
|
llvm_unreachable("invalid ARM Reference Kind");
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ArchHandler_arm::addAdditionalReferences(MachODefinedAtom &atom) {
|
|
if (atom.isThumb()) {
|
|
atom.addReference(Reference::KindNamespace::mach_o,
|
|
Reference::KindArch::ARM, modeThumbCode, 0, &atom, 0);
|
|
}
|
|
}
|
|
|
|
bool ArchHandler_arm::isThumbFunction(const DefinedAtom &atom) {
|
|
for (const Reference *ref : atom) {
|
|
if (ref->offsetInAtom() != 0)
|
|
return false;
|
|
if (ref->kindNamespace() != Reference::KindNamespace::mach_o)
|
|
continue;
|
|
assert(ref->kindArch() == Reference::KindArch::ARM);
|
|
if (ref->kindValue() == modeThumbCode)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
class Thumb2ToArmShimAtom : public SimpleDefinedAtom {
|
|
public:
|
|
Thumb2ToArmShimAtom(MachOFile &file, StringRef targetName,
|
|
const DefinedAtom &target)
|
|
: SimpleDefinedAtom(file) {
|
|
addReference(Reference::KindNamespace::mach_o, Reference::KindArch::ARM,
|
|
ArchHandler_arm::modeThumbCode, 0, this, 0);
|
|
addReference(Reference::KindNamespace::mach_o, Reference::KindArch::ARM,
|
|
ArchHandler_arm::delta32, 8, &target, 0);
|
|
std::string name = std::string(targetName) + "$shim";
|
|
StringRef tmp(name);
|
|
_name = tmp.copy(file.allocator());
|
|
}
|
|
|
|
~Thumb2ToArmShimAtom() override = default;
|
|
|
|
StringRef name() const override {
|
|
return _name;
|
|
}
|
|
|
|
ContentType contentType() const override {
|
|
return DefinedAtom::typeCode;
|
|
}
|
|
|
|
Alignment alignment() const override { return 4; }
|
|
|
|
uint64_t size() const override {
|
|
return 12;
|
|
}
|
|
|
|
ContentPermissions permissions() const override {
|
|
return DefinedAtom::permR_X;
|
|
}
|
|
|
|
ArrayRef<uint8_t> rawContent() const override {
|
|
static const uint8_t bytes[] =
|
|
{ 0xDF, 0xF8, 0x04, 0xC0, // ldr ip, pc + 4
|
|
0xFF, 0x44, // add ip, pc, ip
|
|
0x60, 0x47, // ldr pc, [ip]
|
|
0x00, 0x00, 0x00, 0x00 }; // .long target - this
|
|
assert(sizeof(bytes) == size());
|
|
return llvm::makeArrayRef(bytes, sizeof(bytes));
|
|
}
|
|
private:
|
|
StringRef _name;
|
|
};
|
|
|
|
class ArmToThumbShimAtom : public SimpleDefinedAtom {
|
|
public:
|
|
ArmToThumbShimAtom(MachOFile &file, StringRef targetName,
|
|
const DefinedAtom &target)
|
|
: SimpleDefinedAtom(file) {
|
|
addReference(Reference::KindNamespace::mach_o, Reference::KindArch::ARM,
|
|
ArchHandler_arm::delta32, 12, &target, 0);
|
|
std::string name = std::string(targetName) + "$shim";
|
|
StringRef tmp(name);
|
|
_name = tmp.copy(file.allocator());
|
|
}
|
|
|
|
~ArmToThumbShimAtom() override = default;
|
|
|
|
StringRef name() const override {
|
|
return _name;
|
|
}
|
|
|
|
ContentType contentType() const override {
|
|
return DefinedAtom::typeCode;
|
|
}
|
|
|
|
Alignment alignment() const override { return 4; }
|
|
|
|
uint64_t size() const override {
|
|
return 16;
|
|
}
|
|
|
|
ContentPermissions permissions() const override {
|
|
return DefinedAtom::permR_X;
|
|
}
|
|
|
|
ArrayRef<uint8_t> rawContent() const override {
|
|
static const uint8_t bytes[] =
|
|
{ 0x04, 0xC0, 0x9F, 0xE5, // ldr ip, pc + 4
|
|
0x0C, 0xC0, 0x8F, 0xE0, // add ip, pc, ip
|
|
0x1C, 0xFF, 0x2F, 0xE1, // ldr pc, [ip]
|
|
0x00, 0x00, 0x00, 0x00 }; // .long target - this
|
|
assert(sizeof(bytes) == size());
|
|
return llvm::makeArrayRef(bytes, sizeof(bytes));
|
|
}
|
|
private:
|
|
StringRef _name;
|
|
};
|
|
|
|
const DefinedAtom *ArchHandler_arm::createShim(MachOFile &file,
|
|
bool thumbToArm,
|
|
const DefinedAtom &target) {
|
|
bool isStub = (target.contentType() == DefinedAtom::typeStub);
|
|
StringRef targetName = isStub ? stubName(target) : target.name();
|
|
if (thumbToArm)
|
|
return new (file.allocator()) Thumb2ToArmShimAtom(file, targetName, target);
|
|
else
|
|
return new (file.allocator()) ArmToThumbShimAtom(file, targetName, target);
|
|
}
|
|
|
|
std::unique_ptr<mach_o::ArchHandler> ArchHandler::create_arm() {
|
|
return std::unique_ptr<mach_o::ArchHandler>(new ArchHandler_arm());
|
|
}
|
|
|
|
} // namespace mach_o
|
|
} // namespace lld
|