forked from OSchip/llvm-project
433 lines
17 KiB
C++
433 lines
17 KiB
C++
//===----- RuntimeDyldMachOARM.h ---- MachO/ARM specific code. ----*- C++ -*-=//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOARM_H
|
|
#define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOARM_H
|
|
|
|
#include "../RuntimeDyldMachO.h"
|
|
#include <string>
|
|
|
|
#define DEBUG_TYPE "dyld"
|
|
|
|
namespace llvm {
|
|
|
|
class RuntimeDyldMachOARM
|
|
: public RuntimeDyldMachOCRTPBase<RuntimeDyldMachOARM> {
|
|
private:
|
|
typedef RuntimeDyldMachOCRTPBase<RuntimeDyldMachOARM> ParentT;
|
|
|
|
public:
|
|
|
|
typedef uint32_t TargetPtrT;
|
|
|
|
RuntimeDyldMachOARM(RuntimeDyld::MemoryManager &MM,
|
|
JITSymbolResolver &Resolver)
|
|
: RuntimeDyldMachOCRTPBase(MM, Resolver) {}
|
|
|
|
unsigned getMaxStubSize() const override { return 8; }
|
|
|
|
unsigned getStubAlignment() override { return 4; }
|
|
|
|
Expected<JITSymbolFlags> getJITSymbolFlags(const SymbolRef &SR) override {
|
|
auto Flags = RuntimeDyldImpl::getJITSymbolFlags(SR);
|
|
if (!Flags)
|
|
return Flags.takeError();
|
|
Flags->getTargetFlags() = ARMJITSymbolFlags::fromObjectSymbol(SR);
|
|
return Flags;
|
|
}
|
|
|
|
uint64_t modifyAddressBasedOnFlags(uint64_t Addr,
|
|
JITSymbolFlags Flags) const override {
|
|
if (Flags.getTargetFlags() & ARMJITSymbolFlags::Thumb)
|
|
Addr |= 0x1;
|
|
return Addr;
|
|
}
|
|
|
|
bool isAddrTargetThumb(unsigned SectionID, uint64_t Offset) {
|
|
auto TargetObjAddr = Sections[SectionID].getObjAddress() + Offset;
|
|
for (auto &KV : GlobalSymbolTable) {
|
|
auto &Entry = KV.second;
|
|
auto SymbolObjAddr =
|
|
Sections[Entry.getSectionID()].getObjAddress() + Entry.getOffset();
|
|
if (TargetObjAddr == SymbolObjAddr)
|
|
return (Entry.getFlags().getTargetFlags() & ARMJITSymbolFlags::Thumb);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Expected<int64_t> decodeAddend(const RelocationEntry &RE) const {
|
|
const SectionEntry &Section = Sections[RE.SectionID];
|
|
uint8_t *LocalAddress = Section.getAddressWithOffset(RE.Offset);
|
|
|
|
switch (RE.RelType) {
|
|
default:
|
|
return memcpyAddend(RE);
|
|
case MachO::ARM_RELOC_BR24: {
|
|
uint32_t Temp = readBytesUnaligned(LocalAddress, 4);
|
|
Temp &= 0x00ffffff; // Mask out the opcode.
|
|
// Now we've got the shifted immediate, shift by 2, sign extend and ret.
|
|
return SignExtend32<26>(Temp << 2);
|
|
}
|
|
|
|
case MachO::ARM_THUMB_RELOC_BR22: {
|
|
// This is a pair of instructions whose operands combine to provide 22
|
|
// bits of displacement:
|
|
// Encoding for high bits 1111 0XXX XXXX XXXX
|
|
// Encoding for low bits 1111 1XXX XXXX XXXX
|
|
uint16_t HighInsn = readBytesUnaligned(LocalAddress, 2);
|
|
if ((HighInsn & 0xf800) != 0xf000)
|
|
return make_error<StringError>("Unrecognized thumb branch encoding "
|
|
"(BR22 high bits)",
|
|
inconvertibleErrorCode());
|
|
|
|
uint16_t LowInsn = readBytesUnaligned(LocalAddress + 2, 2);
|
|
if ((LowInsn & 0xf800) != 0xf800)
|
|
return make_error<StringError>("Unrecognized thumb branch encoding "
|
|
"(BR22 low bits)",
|
|
inconvertibleErrorCode());
|
|
|
|
return SignExtend64<23>(((HighInsn & 0x7ff) << 12) |
|
|
((LowInsn & 0x7ff) << 1));
|
|
}
|
|
}
|
|
}
|
|
|
|
Expected<relocation_iterator>
|
|
processRelocationRef(unsigned SectionID, relocation_iterator RelI,
|
|
const ObjectFile &BaseObjT,
|
|
ObjSectionToIDMap &ObjSectionToID,
|
|
StubMap &Stubs) override {
|
|
const MachOObjectFile &Obj =
|
|
static_cast<const MachOObjectFile &>(BaseObjT);
|
|
MachO::any_relocation_info RelInfo =
|
|
Obj.getRelocation(RelI->getRawDataRefImpl());
|
|
uint32_t RelType = Obj.getAnyRelocationType(RelInfo);
|
|
|
|
// Set to true for thumb functions in this (or previous) TUs.
|
|
// Will be used to set the TargetIsThumbFunc member on the relocation entry.
|
|
bool TargetIsLocalThumbFunc = false;
|
|
if (Obj.getPlainRelocationExternal(RelInfo)) {
|
|
auto Symbol = RelI->getSymbol();
|
|
StringRef TargetName;
|
|
if (auto TargetNameOrErr = Symbol->getName())
|
|
TargetName = *TargetNameOrErr;
|
|
else
|
|
return TargetNameOrErr.takeError();
|
|
|
|
// If the target is external but the value doesn't have a name then we've
|
|
// converted the value to a section/offset pair, but we still need to set
|
|
// the IsTargetThumbFunc bit, so look the value up in the globla symbol table.
|
|
auto EntryItr = GlobalSymbolTable.find(TargetName);
|
|
if (EntryItr != GlobalSymbolTable.end()) {
|
|
TargetIsLocalThumbFunc =
|
|
EntryItr->second.getFlags().getTargetFlags() &
|
|
ARMJITSymbolFlags::Thumb;
|
|
}
|
|
}
|
|
|
|
if (Obj.isRelocationScattered(RelInfo)) {
|
|
if (RelType == MachO::ARM_RELOC_HALF_SECTDIFF)
|
|
return processHALFSECTDIFFRelocation(SectionID, RelI, Obj,
|
|
ObjSectionToID);
|
|
else if (RelType == MachO::GENERIC_RELOC_VANILLA)
|
|
return processScatteredVANILLA(SectionID, RelI, Obj, ObjSectionToID,
|
|
TargetIsLocalThumbFunc);
|
|
else
|
|
return ++RelI;
|
|
}
|
|
|
|
// Sanity check relocation type.
|
|
switch (RelType) {
|
|
UNIMPLEMENTED_RELOC(MachO::ARM_RELOC_PAIR);
|
|
UNIMPLEMENTED_RELOC(MachO::ARM_RELOC_SECTDIFF);
|
|
UNIMPLEMENTED_RELOC(MachO::ARM_RELOC_LOCAL_SECTDIFF);
|
|
UNIMPLEMENTED_RELOC(MachO::ARM_RELOC_PB_LA_PTR);
|
|
UNIMPLEMENTED_RELOC(MachO::ARM_THUMB_32BIT_BRANCH);
|
|
UNIMPLEMENTED_RELOC(MachO::ARM_RELOC_HALF);
|
|
default:
|
|
if (RelType > MachO::ARM_RELOC_HALF_SECTDIFF)
|
|
return make_error<RuntimeDyldError>(("MachO ARM relocation type " +
|
|
Twine(RelType) +
|
|
" is out of range").str());
|
|
break;
|
|
}
|
|
|
|
RelocationEntry RE(getRelocationEntry(SectionID, Obj, RelI));
|
|
if (auto AddendOrErr = decodeAddend(RE))
|
|
RE.Addend = *AddendOrErr;
|
|
else
|
|
return AddendOrErr.takeError();
|
|
RE.IsTargetThumbFunc = TargetIsLocalThumbFunc;
|
|
|
|
RelocationValueRef Value;
|
|
if (auto ValueOrErr = getRelocationValueRef(Obj, RelI, RE, ObjSectionToID))
|
|
Value = *ValueOrErr;
|
|
else
|
|
return ValueOrErr.takeError();
|
|
|
|
// If this is a branch from a thumb function (BR22) then make sure we mark
|
|
// the value as being a thumb stub: we don't want to mix it up with an ARM
|
|
// stub targeting the same function.
|
|
if (RE.RelType == MachO::ARM_THUMB_RELOC_BR22)
|
|
Value.IsStubThumb = true;
|
|
|
|
if (RE.IsPCRel)
|
|
makeValueAddendPCRel(Value, RelI,
|
|
(RE.RelType == MachO::ARM_THUMB_RELOC_BR22) ? 4 : 8);
|
|
|
|
// If this is a non-external branch target check whether Value points to a
|
|
// thumb func.
|
|
if (!Value.SymbolName && (RelType == MachO::ARM_RELOC_BR24 ||
|
|
RelType == MachO::ARM_THUMB_RELOC_BR22))
|
|
RE.IsTargetThumbFunc = isAddrTargetThumb(Value.SectionID, Value.Offset);
|
|
|
|
if (RE.RelType == MachO::ARM_RELOC_BR24 ||
|
|
RE.RelType == MachO::ARM_THUMB_RELOC_BR22)
|
|
processBranchRelocation(RE, Value, Stubs);
|
|
else {
|
|
RE.Addend = Value.Offset;
|
|
if (Value.SymbolName)
|
|
addRelocationForSymbol(RE, Value.SymbolName);
|
|
else
|
|
addRelocationForSection(RE, Value.SectionID);
|
|
}
|
|
|
|
return ++RelI;
|
|
}
|
|
|
|
void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
|
|
LLVM_DEBUG(dumpRelocationToResolve(RE, Value));
|
|
const SectionEntry &Section = Sections[RE.SectionID];
|
|
uint8_t *LocalAddress = Section.getAddressWithOffset(RE.Offset);
|
|
|
|
// If the relocation is PC-relative, the value to be encoded is the
|
|
// pointer difference.
|
|
if (RE.IsPCRel) {
|
|
uint64_t FinalAddress = Section.getLoadAddressWithOffset(RE.Offset);
|
|
Value -= FinalAddress;
|
|
// ARM PCRel relocations have an effective-PC offset of two instructions
|
|
// (four bytes in Thumb mode, 8 bytes in ARM mode).
|
|
Value -= (RE.RelType == MachO::ARM_THUMB_RELOC_BR22) ? 4 : 8;
|
|
}
|
|
|
|
switch (RE.RelType) {
|
|
case MachO::ARM_THUMB_RELOC_BR22: {
|
|
Value += RE.Addend;
|
|
uint16_t HighInsn = readBytesUnaligned(LocalAddress, 2);
|
|
assert((HighInsn & 0xf800) == 0xf000 &&
|
|
"Unrecognized thumb branch encoding (BR22 high bits)");
|
|
HighInsn = (HighInsn & 0xf800) | ((Value >> 12) & 0x7ff);
|
|
|
|
uint16_t LowInsn = readBytesUnaligned(LocalAddress + 2, 2);
|
|
assert((LowInsn & 0xf800) == 0xf800 &&
|
|
"Unrecognized thumb branch encoding (BR22 low bits)");
|
|
LowInsn = (LowInsn & 0xf800) | ((Value >> 1) & 0x7ff);
|
|
|
|
writeBytesUnaligned(HighInsn, LocalAddress, 2);
|
|
writeBytesUnaligned(LowInsn, LocalAddress + 2, 2);
|
|
break;
|
|
}
|
|
|
|
case MachO::ARM_RELOC_VANILLA:
|
|
if (RE.IsTargetThumbFunc)
|
|
Value |= 0x01;
|
|
writeBytesUnaligned(Value + RE.Addend, LocalAddress, 1 << RE.Size);
|
|
break;
|
|
case MachO::ARM_RELOC_BR24: {
|
|
// Mask the value into the target address. We know instructions are
|
|
// 32-bit aligned, so we can do it all at once.
|
|
Value += RE.Addend;
|
|
// The low two bits of the value are not encoded.
|
|
Value >>= 2;
|
|
// Mask the value to 24 bits.
|
|
uint64_t FinalValue = Value & 0xffffff;
|
|
// FIXME: If the destination is a Thumb function (and the instruction
|
|
// is a non-predicated BL instruction), we need to change it to a BLX
|
|
// instruction instead.
|
|
|
|
// Insert the value into the instruction.
|
|
uint32_t Temp = readBytesUnaligned(LocalAddress, 4);
|
|
writeBytesUnaligned((Temp & ~0xffffff) | FinalValue, LocalAddress, 4);
|
|
|
|
break;
|
|
}
|
|
case MachO::ARM_RELOC_HALF_SECTDIFF: {
|
|
uint64_t SectionABase = Sections[RE.Sections.SectionA].getLoadAddress();
|
|
uint64_t SectionBBase = Sections[RE.Sections.SectionB].getLoadAddress();
|
|
assert((Value == SectionABase || Value == SectionBBase) &&
|
|
"Unexpected HALFSECTDIFF relocation value.");
|
|
Value = SectionABase - SectionBBase + RE.Addend;
|
|
if (RE.Size & 0x1) // :upper16:
|
|
Value = (Value >> 16);
|
|
|
|
bool IsThumb = RE.Size & 0x2;
|
|
|
|
Value &= 0xffff;
|
|
|
|
uint32_t Insn = readBytesUnaligned(LocalAddress, 4);
|
|
|
|
if (IsThumb)
|
|
Insn = (Insn & 0x8f00fbf0) | ((Value & 0xf000) >> 12) |
|
|
((Value & 0x0800) >> 1) | ((Value & 0x0700) << 20) |
|
|
((Value & 0x00ff) << 16);
|
|
else
|
|
Insn = (Insn & 0xfff0f000) | ((Value & 0xf000) << 4) | (Value & 0x0fff);
|
|
writeBytesUnaligned(Insn, LocalAddress, 4);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
llvm_unreachable("Invalid relocation type");
|
|
}
|
|
}
|
|
|
|
Error finalizeSection(const ObjectFile &Obj, unsigned SectionID,
|
|
const SectionRef &Section) {
|
|
StringRef Name;
|
|
if (Expected<StringRef> NameOrErr = Section.getName())
|
|
Name = *NameOrErr;
|
|
else
|
|
consumeError(NameOrErr.takeError());
|
|
|
|
if (Name == "__nl_symbol_ptr")
|
|
return populateIndirectSymbolPointersSection(cast<MachOObjectFile>(Obj),
|
|
Section, SectionID);
|
|
return Error::success();
|
|
}
|
|
|
|
private:
|
|
|
|
void processBranchRelocation(const RelocationEntry &RE,
|
|
const RelocationValueRef &Value,
|
|
StubMap &Stubs) {
|
|
// This is an ARM branch relocation, need to use a stub function.
|
|
// Look up for existing stub.
|
|
SectionEntry &Section = Sections[RE.SectionID];
|
|
RuntimeDyldMachO::StubMap::const_iterator i = Stubs.find(Value);
|
|
uint8_t *Addr;
|
|
if (i != Stubs.end()) {
|
|
Addr = Section.getAddressWithOffset(i->second);
|
|
} else {
|
|
// Create a new stub function.
|
|
assert(Section.getStubOffset() % 4 == 0 && "Misaligned stub");
|
|
Stubs[Value] = Section.getStubOffset();
|
|
uint32_t StubOpcode = 0;
|
|
if (RE.RelType == MachO::ARM_RELOC_BR24)
|
|
StubOpcode = 0xe51ff004; // ldr pc, [pc, #-4]
|
|
else if (RE.RelType == MachO::ARM_THUMB_RELOC_BR22)
|
|
StubOpcode = 0xf000f8df; // ldr pc, [pc]
|
|
else
|
|
llvm_unreachable("Unrecognized relocation");
|
|
Addr = Section.getAddressWithOffset(Section.getStubOffset());
|
|
writeBytesUnaligned(StubOpcode, Addr, 4);
|
|
uint8_t *StubTargetAddr = Addr + 4;
|
|
RelocationEntry StubRE(
|
|
RE.SectionID, StubTargetAddr - Section.getAddress(),
|
|
MachO::GENERIC_RELOC_VANILLA, Value.Offset, false, 2);
|
|
StubRE.IsTargetThumbFunc = RE.IsTargetThumbFunc;
|
|
if (Value.SymbolName)
|
|
addRelocationForSymbol(StubRE, Value.SymbolName);
|
|
else
|
|
addRelocationForSection(StubRE, Value.SectionID);
|
|
Section.advanceStubOffset(getMaxStubSize());
|
|
}
|
|
RelocationEntry TargetRE(RE.SectionID, RE.Offset, RE.RelType, 0,
|
|
RE.IsPCRel, RE.Size);
|
|
resolveRelocation(TargetRE, (uint64_t)Addr);
|
|
}
|
|
|
|
Expected<relocation_iterator>
|
|
processHALFSECTDIFFRelocation(unsigned SectionID, relocation_iterator RelI,
|
|
const ObjectFile &BaseTObj,
|
|
ObjSectionToIDMap &ObjSectionToID) {
|
|
const MachOObjectFile &MachO =
|
|
static_cast<const MachOObjectFile&>(BaseTObj);
|
|
MachO::any_relocation_info RE =
|
|
MachO.getRelocation(RelI->getRawDataRefImpl());
|
|
|
|
// For a half-diff relocation the length bits actually record whether this
|
|
// is a movw/movt, and whether this is arm or thumb.
|
|
// Bit 0 indicates movw (b0 == 0) or movt (b0 == 1).
|
|
// Bit 1 indicates arm (b1 == 0) or thumb (b1 == 1).
|
|
unsigned HalfDiffKindBits = MachO.getAnyRelocationLength(RE);
|
|
bool IsThumb = HalfDiffKindBits & 0x2;
|
|
|
|
SectionEntry &Section = Sections[SectionID];
|
|
uint32_t RelocType = MachO.getAnyRelocationType(RE);
|
|
bool IsPCRel = MachO.getAnyRelocationPCRel(RE);
|
|
uint64_t Offset = RelI->getOffset();
|
|
uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
|
|
int64_t Immediate = readBytesUnaligned(LocalAddress, 4); // Copy the whole instruction out.
|
|
|
|
if (IsThumb)
|
|
Immediate = ((Immediate & 0x0000000f) << 12) |
|
|
((Immediate & 0x00000400) << 1) |
|
|
((Immediate & 0x70000000) >> 20) |
|
|
((Immediate & 0x00ff0000) >> 16);
|
|
else
|
|
Immediate = ((Immediate >> 4) & 0xf000) | (Immediate & 0xfff);
|
|
|
|
++RelI;
|
|
MachO::any_relocation_info RE2 =
|
|
MachO.getRelocation(RelI->getRawDataRefImpl());
|
|
uint32_t AddrA = MachO.getScatteredRelocationValue(RE);
|
|
section_iterator SAI = getSectionByAddress(MachO, AddrA);
|
|
assert(SAI != MachO.section_end() && "Can't find section for address A");
|
|
uint64_t SectionABase = SAI->getAddress();
|
|
uint64_t SectionAOffset = AddrA - SectionABase;
|
|
SectionRef SectionA = *SAI;
|
|
bool IsCode = SectionA.isText();
|
|
uint32_t SectionAID = ~0U;
|
|
if (auto SectionAIDOrErr =
|
|
findOrEmitSection(MachO, SectionA, IsCode, ObjSectionToID))
|
|
SectionAID = *SectionAIDOrErr;
|
|
else
|
|
return SectionAIDOrErr.takeError();
|
|
|
|
uint32_t AddrB = MachO.getScatteredRelocationValue(RE2);
|
|
section_iterator SBI = getSectionByAddress(MachO, AddrB);
|
|
assert(SBI != MachO.section_end() && "Can't find section for address B");
|
|
uint64_t SectionBBase = SBI->getAddress();
|
|
uint64_t SectionBOffset = AddrB - SectionBBase;
|
|
SectionRef SectionB = *SBI;
|
|
uint32_t SectionBID = ~0U;
|
|
if (auto SectionBIDOrErr =
|
|
findOrEmitSection(MachO, SectionB, IsCode, ObjSectionToID))
|
|
SectionBID = *SectionBIDOrErr;
|
|
else
|
|
return SectionBIDOrErr.takeError();
|
|
|
|
uint32_t OtherHalf = MachO.getAnyRelocationAddress(RE2) & 0xffff;
|
|
unsigned Shift = (HalfDiffKindBits & 0x1) ? 16 : 0;
|
|
uint32_t FullImmVal = (Immediate << Shift) | (OtherHalf << (16 - Shift));
|
|
int64_t Addend = FullImmVal - (AddrA - AddrB);
|
|
|
|
// addend = Encoded - Expected
|
|
// = Encoded - (AddrA - AddrB)
|
|
|
|
LLVM_DEBUG(dbgs() << "Found SECTDIFF: AddrA: " << AddrA
|
|
<< ", AddrB: " << AddrB << ", Addend: " << Addend
|
|
<< ", SectionA ID: " << SectionAID << ", SectionAOffset: "
|
|
<< SectionAOffset << ", SectionB ID: " << SectionBID
|
|
<< ", SectionBOffset: " << SectionBOffset << "\n");
|
|
RelocationEntry R(SectionID, Offset, RelocType, Addend, SectionAID,
|
|
SectionAOffset, SectionBID, SectionBOffset, IsPCRel,
|
|
HalfDiffKindBits);
|
|
|
|
addRelocationForSection(R, SectionAID);
|
|
|
|
return ++RelI;
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
#undef DEBUG_TYPE
|
|
|
|
#endif
|