lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h

   1 //===----- RuntimeDyldMachOARM.h ---- MachO/ARM specific code. ----*- C++ -*-=//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLVM_RUNTIMEDYLDMACHOARM_H
  11 #define LLVM_RUNTIMEDYLDMACHOARM_H
  12
  13 #include "../RuntimeDyldMachO.h"
  14
  15 #define DEBUG_TYPE "dyld"
  16
  17 namespace llvm {
  18
  19 class RuntimeDyldMachOARM
  20     : public RuntimeDyldMachOCRTPBase<RuntimeDyldMachOARM> {
  21 private:
  22   typedef RuntimeDyldMachOCRTPBase<RuntimeDyldMachOARM> ParentT;
  23
  24 public:
  25   RuntimeDyldMachOARM(RTDyldMemoryManager *MM) : RuntimeDyldMachOCRTPBase(MM) {}
  26
  27   unsigned getMaxStubSize() override { return 8; }
  28
  29   unsigned getStubAlignment() override { return 4; }
  30
  31   int64_t decodeAddend(uint8_t *LocalAddress, unsigned NumBytes,
  32                        MachO::RelocationInfoType RelType) const {
  33     switch (RelType) {
  34       default:
  35         return ParentT::decodeAddend(LocalAddress, NumBytes, RelType);
  36       case MachO::ARM_RELOC_BR24: {
  37         uint32_t Temp;
  38         memcpy(&Temp, LocalAddress, 4);
  39         Temp &= 0x00ffffff; // Mask out the opcode.
  40         // Now we've got the shifted immediate, shift by 2, sign extend and ret.
  41         return SignExtend32<26>(Temp << 2);
  42       }
  43     }
  44   }
  45
  46   relocation_iterator
  47   processRelocationRef(unsigned SectionID, relocation_iterator RelI,
  48                        ObjectImage &ObjImg, ObjSectionToIDMap &ObjSectionToID,
  49                        const SymbolTableMap &Symbols, StubMap &Stubs) override {
  50     const MachOObjectFile &Obj =
  51         static_cast<const MachOObjectFile &>(*ObjImg.getObjectFile());
  52     MachO::any_relocation_info RelInfo =
  53         Obj.getRelocation(RelI->getRawDataRefImpl());
  54
  55     if (Obj.isRelocationScattered(RelInfo))
  56       return ++++RelI;
  57
  58     RelocationEntry RE(getBasicRelocationEntry(SectionID, ObjImg, RelI));
  59     RelocationValueRef Value(
  60         getRelocationValueRef(ObjImg, RelI, RE, ObjSectionToID, Symbols));
  61
  62     if (RE.IsPCRel)
  63       makeValueAddendPCRel(Value, ObjImg, RelI, 8);
  64
  65     if ((RE.RelType & 0xf) == MachO::ARM_RELOC_BR24)
  66       processBranchRelocation(RE, Value, Stubs);
  67     else {
  68       RE.Addend = Value.Addend;
  69       if (Value.SymbolName)
  70         addRelocationForSymbol(RE, Value.SymbolName);
  71       else
  72         addRelocationForSection(RE, Value.SectionID);
  73     }
  74
  75     return ++RelI;
  76   }
  77
  78   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) {
  79     DEBUG(dumpRelocationToResolve(RE, Value));
  80     const SectionEntry &Section = Sections[RE.SectionID];
  81     uint8_t *LocalAddress = Section.Address + RE.Offset;
  82
  83     // If the relocation is PC-relative, the value to be encoded is the
  84     // pointer difference.
  85     if (RE.IsPCRel) {
  86       uint64_t FinalAddress = Section.LoadAddress + RE.Offset;
  87       Value -= FinalAddress;
  88       // ARM PCRel relocations have an effective-PC offset of two instructions
  89       // (four bytes in Thumb mode, 8 bytes in ARM mode).
  90       // FIXME: For now, assume ARM mode.
  91       Value -= 8;
  92     }
  93
  94     switch (RE.RelType) {
  95     default:
  96       llvm_unreachable("Invalid relocation type!");
  97     case MachO::ARM_RELOC_VANILLA:
  98       writeBytesUnaligned(LocalAddress, Value, 1 << RE.Size);
  99       break;
 100     case MachO::ARM_RELOC_BR24: {
 101       // Mask the value into the target address. We know instructions are
 102       // 32-bit aligned, so we can do it all at once.
 103       uint32_t *p = (uint32_t *)LocalAddress;
 104       // The low two bits of the value are not encoded.
 105       Value >>= 2;
 106       // Mask the value to 24 bits.
 107       uint64_t FinalValue = Value & 0xffffff;
 108       // FIXME: If the destination is a Thumb function (and the instruction
 109       // is a non-predicated BL instruction), we need to change it to a BLX
 110       // instruction instead.
 111
 112       // Insert the value into the instruction.
 113       *p = (*p & ~0xffffff) | FinalValue;
 114       break;
 115     }
 116     case MachO::ARM_THUMB_RELOC_BR22:
 117     case MachO::ARM_THUMB_32BIT_BRANCH:
 118     case MachO::ARM_RELOC_HALF:
 119     case MachO::ARM_RELOC_HALF_SECTDIFF:
 120     case MachO::ARM_RELOC_PAIR:
 121     case MachO::ARM_RELOC_SECTDIFF:
 122     case MachO::ARM_RELOC_LOCAL_SECTDIFF:
 123     case MachO::ARM_RELOC_PB_LA_PTR:
 124       Error("Relocation type not implemented yet!");
 125       return;
 126     }
 127   }
 128
 129   void finalizeSection(ObjectImage &ObjImg, unsigned SectionID,
 130                        const SectionRef &Section) {}
 131
 132 private:
 133   void processBranchRelocation(const RelocationEntry &RE,
 134                                const RelocationValueRef &Value,
 135                                StubMap &Stubs) {
 136     // This is an ARM branch relocation, need to use a stub function.
 137     // Look up for existing stub.
 138     SectionEntry &Section = Sections[RE.SectionID];
 139     RuntimeDyldMachO::StubMap::const_iterator i = Stubs.find(Value);
 140     uint8_t *Addr;
 141     if (i != Stubs.end()) {
 142       Addr = Section.Address + i->second;
 143     } else {
 144       // Create a new stub function.
 145       Stubs[Value] = Section.StubOffset;
 146       uint8_t *StubTargetAddr =
 147           createStubFunction(Section.Address + Section.StubOffset);
 148       RelocationEntry StubRE(RE.SectionID, StubTargetAddr - Section.Address,
 149                              MachO::GENERIC_RELOC_VANILLA, Value.Addend, false,
 150                              2);
 151       if (Value.SymbolName)
 152         addRelocationForSymbol(StubRE, Value.SymbolName);
 153       else
 154         addRelocationForSection(StubRE, Value.SectionID);
 155       Addr = Section.Address + Section.StubOffset;
 156       Section.StubOffset += getMaxStubSize();
 157     }
 158     RelocationEntry TargetRE(RE.SectionID, RE.Offset, RE.RelType, 0,
 159                              RE.IsPCRel, RE.Size);
 160     resolveRelocation(TargetRE, (uint64_t)Addr);
 161   }
 162 };
 163 }
 164
 165 #undef DEBUG_TYPE
 166
 167 #endif // LLVM_RUNTIMEDYLDMACHOARM_H