lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOI386.h

   1 //===---- RuntimeDyldMachOI386.h ---- MachO/I386 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_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOI386_H
  11 #define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOI386_H
  12
  13 #include "../RuntimeDyldMachO.h"
  14
  15 #define DEBUG_TYPE "dyld"
  16
  17 namespace llvm {
  18
  19 class RuntimeDyldMachOI386
  20     : public RuntimeDyldMachOCRTPBase<RuntimeDyldMachOI386> {
  21 public:
  22
  23   typedef uint32_t TargetPtrT;
  24
  25   RuntimeDyldMachOI386(RuntimeDyld::MemoryManager &MM,
  26                        RuntimeDyld::SymbolResolver &Resolver)
  27       : RuntimeDyldMachOCRTPBase(MM, Resolver) {}
  28
  29   unsigned getMaxStubSize() override { return 0; }
  30
  31   unsigned getStubAlignment() override { return 1; }
  32
  33   relocation_iterator
  34   processRelocationRef(unsigned SectionID, relocation_iterator RelI,
  35                        const ObjectFile &BaseObjT,
  36                        ObjSectionToIDMap &ObjSectionToID,
  37                        StubMap &Stubs) override {
  38     const MachOObjectFile &Obj =
  39         static_cast<const MachOObjectFile &>(BaseObjT);
  40     MachO::any_relocation_info RelInfo =
  41         Obj.getRelocation(RelI->getRawDataRefImpl());
  42     uint32_t RelType = Obj.getAnyRelocationType(RelInfo);
  43
  44     if (Obj.isRelocationScattered(RelInfo)) {
  45       if (RelType == MachO::GENERIC_RELOC_SECTDIFF ||
  46           RelType == MachO::GENERIC_RELOC_LOCAL_SECTDIFF)
  47         return processSECTDIFFRelocation(SectionID, RelI, Obj,
  48                                          ObjSectionToID);
  49       else if (RelType == MachO::GENERIC_RELOC_VANILLA)
  50         return processI386ScatteredVANILLA(SectionID, RelI, Obj,
  51                                            ObjSectionToID);
  52       llvm_unreachable("Unhandled scattered relocation.");
  53     }
  54
  55     RelocationEntry RE(getRelocationEntry(SectionID, Obj, RelI));
  56     RE.Addend = memcpyAddend(RE);
  57     RelocationValueRef Value(
  58         getRelocationValueRef(Obj, RelI, RE, ObjSectionToID));
  59
  60     // Addends for external, PC-rel relocations on i386 point back to the zero
  61     // offset. Calculate the final offset from the relocation target instead.
  62     // This allows us to use the same logic for both external and internal
  63     // relocations in resolveI386RelocationRef.
  64     // bool IsExtern = Obj.getPlainRelocationExternal(RelInfo);
  65     // if (IsExtern && RE.IsPCRel) {
  66     //   uint64_t RelocAddr = 0;
  67     //   RelI->getAddress(RelocAddr);
  68     //   Value.Addend += RelocAddr + 4;
  69     // }
  70     if (RE.IsPCRel)
  71       makeValueAddendPCRel(Value, Obj, RelI, 1 << RE.Size);
  72
  73     RE.Addend = Value.Offset;
  74
  75     if (Value.SymbolName)
  76       addRelocationForSymbol(RE, Value.SymbolName);
  77     else
  78       addRelocationForSection(RE, Value.SectionID);
  79
  80     return ++RelI;
  81   }
  82
  83   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
  84     DEBUG(dumpRelocationToResolve(RE, Value));
  85
  86     const SectionEntry &Section = Sections[RE.SectionID];
  87     uint8_t *LocalAddress = Section.Address + RE.Offset;
  88
  89     if (RE.IsPCRel) {
  90       uint64_t FinalAddress = Section.LoadAddress + RE.Offset;
  91       Value -= FinalAddress + 4; // see MachOX86_64::resolveRelocation.
  92     }
  93
  94     switch (RE.RelType) {
  95     default:
  96       llvm_unreachable("Invalid relocation type!");
  97     case MachO::GENERIC_RELOC_VANILLA:
  98       writeBytesUnaligned(Value + RE.Addend, LocalAddress, 1 << RE.Size);
  99       break;
 100     case MachO::GENERIC_RELOC_SECTDIFF:
 101     case MachO::GENERIC_RELOC_LOCAL_SECTDIFF: {
 102       uint64_t SectionABase = Sections[RE.Sections.SectionA].LoadAddress;
 103       uint64_t SectionBBase = Sections[RE.Sections.SectionB].LoadAddress;
 104       assert((Value == SectionABase || Value == SectionBBase) &&
 105              "Unexpected SECTDIFF relocation value.");
 106       Value = SectionABase - SectionBBase + RE.Addend;
 107       writeBytesUnaligned(Value, LocalAddress, 1 << RE.Size);
 108       break;
 109     }
 110     case MachO::GENERIC_RELOC_PB_LA_PTR:
 111       Error("Relocation type not implemented yet!");
 112     }
 113   }
 114
 115   void finalizeSection(const ObjectFile &Obj, unsigned SectionID,
 116                        const SectionRef &Section) {
 117     StringRef Name;
 118     Section.getName(Name);
 119
 120     if (Name == "__jump_table")
 121       populateJumpTable(cast<MachOObjectFile>(Obj), Section, SectionID);
 122     else if (Name == "__pointers")
 123       populateIndirectSymbolPointersSection(cast<MachOObjectFile>(Obj),
 124                                             Section, SectionID);
 125   }
 126
 127 private:
 128   relocation_iterator
 129   processSECTDIFFRelocation(unsigned SectionID, relocation_iterator RelI,
 130                             const ObjectFile &BaseObjT,
 131                             ObjSectionToIDMap &ObjSectionToID) {
 132     const MachOObjectFile &Obj =
 133         static_cast<const MachOObjectFile&>(BaseObjT);
 134     MachO::any_relocation_info RE =
 135         Obj.getRelocation(RelI->getRawDataRefImpl());
 136
 137     SectionEntry &Section = Sections[SectionID];
 138     uint32_t RelocType = Obj.getAnyRelocationType(RE);
 139     bool IsPCRel = Obj.getAnyRelocationPCRel(RE);
 140     unsigned Size = Obj.getAnyRelocationLength(RE);
 141     uint64_t Offset = RelI->getOffset();
 142     uint8_t *LocalAddress = Section.Address + Offset;
 143     unsigned NumBytes = 1 << Size;
 144     uint64_t Addend = readBytesUnaligned(LocalAddress, NumBytes);
 145
 146     ++RelI;
 147     MachO::any_relocation_info RE2 =
 148         Obj.getRelocation(RelI->getRawDataRefImpl());
 149
 150     uint32_t AddrA = Obj.getScatteredRelocationValue(RE);
 151     section_iterator SAI = getSectionByAddress(Obj, AddrA);
 152     assert(SAI != Obj.section_end() && "Can't find section for address A");
 153     uint64_t SectionABase = SAI->getAddress();
 154     uint64_t SectionAOffset = AddrA - SectionABase;
 155     SectionRef SectionA = *SAI;
 156     bool IsCode = SectionA.isText();
 157     uint32_t SectionAID =
 158         findOrEmitSection(Obj, SectionA, IsCode, ObjSectionToID);
 159
 160     uint32_t AddrB = Obj.getScatteredRelocationValue(RE2);
 161     section_iterator SBI = getSectionByAddress(Obj, AddrB);
 162     assert(SBI != Obj.section_end() && "Can't find section for address B");
 163     uint64_t SectionBBase = SBI->getAddress();
 164     uint64_t SectionBOffset = AddrB - SectionBBase;
 165     SectionRef SectionB = *SBI;
 166     uint32_t SectionBID =
 167         findOrEmitSection(Obj, SectionB, IsCode, ObjSectionToID);
 168
 169     // Compute the addend 'C' from the original expression 'A - B + C'.
 170     Addend -= AddrA - AddrB;
 171
 172     DEBUG(dbgs() << "Found SECTDIFF: AddrA: " << AddrA << ", AddrB: " << AddrB
 173                  << ", Addend: " << Addend << ", SectionA ID: " << SectionAID
 174                  << ", SectionAOffset: " << SectionAOffset
 175                  << ", SectionB ID: " << SectionBID
 176                  << ", SectionBOffset: " << SectionBOffset << "\n");
 177     RelocationEntry R(SectionID, Offset, RelocType, Addend, SectionAID,
 178                       SectionAOffset, SectionBID, SectionBOffset,
 179                       IsPCRel, Size);
 180
 181     addRelocationForSection(R, SectionAID);
 182
 183     return ++RelI;
 184   }
 185
 186   relocation_iterator processI386ScatteredVANILLA(
 187       unsigned SectionID, relocation_iterator RelI,
 188       const ObjectFile &BaseObjT,
 189       RuntimeDyldMachO::ObjSectionToIDMap &ObjSectionToID) {
 190     const MachOObjectFile &Obj =
 191         static_cast<const MachOObjectFile&>(BaseObjT);
 192     MachO::any_relocation_info RE =
 193         Obj.getRelocation(RelI->getRawDataRefImpl());
 194
 195     SectionEntry &Section = Sections[SectionID];
 196     uint32_t RelocType = Obj.getAnyRelocationType(RE);
 197     bool IsPCRel = Obj.getAnyRelocationPCRel(RE);
 198     unsigned Size = Obj.getAnyRelocationLength(RE);
 199     uint64_t Offset = RelI->getOffset();
 200     uint8_t *LocalAddress = Section.Address + Offset;
 201     unsigned NumBytes = 1 << Size;
 202     int64_t Addend = readBytesUnaligned(LocalAddress, NumBytes);
 203
 204     unsigned SymbolBaseAddr = Obj.getScatteredRelocationValue(RE);
 205     section_iterator TargetSI = getSectionByAddress(Obj, SymbolBaseAddr);
 206     assert(TargetSI != Obj.section_end() && "Can't find section for symbol");
 207     uint64_t SectionBaseAddr = TargetSI->getAddress();
 208     SectionRef TargetSection = *TargetSI;
 209     bool IsCode = TargetSection.isText();
 210     uint32_t TargetSectionID =
 211         findOrEmitSection(Obj, TargetSection, IsCode, ObjSectionToID);
 212
 213     Addend -= SectionBaseAddr;
 214     RelocationEntry R(SectionID, Offset, RelocType, Addend, IsPCRel, Size);
 215
 216     addRelocationForSection(R, TargetSectionID);
 217
 218     return ++RelI;
 219   }
 220
 221   // Populate stubs in __jump_table section.
 222   void populateJumpTable(const MachOObjectFile &Obj, const SectionRef &JTSection,
 223                          unsigned JTSectionID) {
 224     assert(!Obj.is64Bit() &&
 225            "__jump_table section not supported in 64-bit MachO.");
 226
 227     MachO::dysymtab_command DySymTabCmd = Obj.getDysymtabLoadCommand();
 228     MachO::section Sec32 = Obj.getSection(JTSection.getRawDataRefImpl());
 229     uint32_t JTSectionSize = Sec32.size;
 230     unsigned FirstIndirectSymbol = Sec32.reserved1;
 231     unsigned JTEntrySize = Sec32.reserved2;
 232     unsigned NumJTEntries = JTSectionSize / JTEntrySize;
 233     uint8_t *JTSectionAddr = getSectionAddress(JTSectionID);
 234     unsigned JTEntryOffset = 0;
 235
 236     assert((JTSectionSize % JTEntrySize) == 0 &&
 237            "Jump-table section does not contain a whole number of stubs?");
 238
 239     for (unsigned i = 0; i < NumJTEntries; ++i) {
 240       unsigned SymbolIndex =
 241           Obj.getIndirectSymbolTableEntry(DySymTabCmd, FirstIndirectSymbol + i);
 242       symbol_iterator SI = Obj.getSymbolByIndex(SymbolIndex);
 243       StringRef IndirectSymbolName;
 244       SI->getName(IndirectSymbolName);
 245       uint8_t *JTEntryAddr = JTSectionAddr + JTEntryOffset;
 246       createStubFunction(JTEntryAddr);
 247       RelocationEntry RE(JTSectionID, JTEntryOffset + 1,
 248                          MachO::GENERIC_RELOC_VANILLA, 0, true, 2);
 249       addRelocationForSymbol(RE, IndirectSymbolName);
 250       JTEntryOffset += JTEntrySize;
 251     }
 252   }
 253
 254 };
 255 }
 256
 257 #undef DEBUG_TYPE
 258
 259 #endif