lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp

   1 //===-- RuntimeDyldMachO.cpp - Run-time dynamic linker for MC-JIT -*- 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 // Implementation of the MC-JIT runtime dynamic linker.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "dyld"
  15 #include "RuntimeDyldMachO.h"
  16 #include "llvm/ADT/OwningPtr.h"
  17 #include "llvm/ADT/STLExtras.h"
  18 #include "llvm/ADT/StringRef.h"
  19 using namespace llvm;
  20 using namespace llvm::object;
  21
  22 namespace llvm {
  23
  24 void RuntimeDyldMachO::resolveRelocation(const SectionEntry &Section,
  25                                          uint64_t Offset,
  26                                          uint64_t Value,
  27                                          uint32_t Type,
  28                                          int64_t Addend) {
  29   uint8_t *LocalAddress = Section.Address + Offset;
  30   uint64_t FinalAddress = Section.LoadAddress + Offset;
  31   bool isPCRel = (Type >> 24) & 1;
  32   unsigned MachoType = (Type >> 28) & 0xf;
  33   unsigned Size = 1 << ((Type >> 25) & 3);
  34
  35   DEBUG(dbgs() << "resolveRelocation LocalAddress: "
  36         << format("%p", LocalAddress)
  37         << " FinalAddress: " << format("%p", FinalAddress)
  38         << " Value: " << format("%p", Value)
  39         << " Addend: " << Addend
  40         << " isPCRel: " << isPCRel
  41         << " MachoType: " << MachoType
  42         << " Size: " << Size
  43         << "\n");
  44
  45   // This just dispatches to the proper target specific routine.
  46   switch (Arch) {
  47   default: llvm_unreachable("Unsupported CPU type!");
  48   case Triple::x86_64:
  49     resolveX86_64Relocation(LocalAddress,
  50                             FinalAddress,
  51                             (uintptr_t)Value,
  52                             isPCRel,
  53                             MachoType,
  54                             Size,
  55                             Addend);
  56     break;
  57   case Triple::x86:
  58     resolveI386Relocation(LocalAddress,
  59                           FinalAddress,
  60                           (uintptr_t)Value,
  61                           isPCRel,
  62                           MachoType,
  63                           Size,
  64                           Addend);
  65     break;
  66   case Triple::arm:    // Fall through.
  67   case Triple::thumb:
  68     resolveARMRelocation(LocalAddress,
  69                          FinalAddress,
  70                          (uintptr_t)Value,
  71                          isPCRel,
  72                          MachoType,
  73                          Size,
  74                          Addend);
  75     break;
  76   }
  77 }
  78
  79 bool RuntimeDyldMachO::resolveI386Relocation(uint8_t *LocalAddress,
  80                                              uint64_t FinalAddress,
  81                                              uint64_t Value,
  82                                              bool isPCRel,
  83                                              unsigned Type,
  84                                              unsigned Size,
  85                                              int64_t Addend) {
  86   if (isPCRel)
  87     Value -= FinalAddress + 4; // see resolveX86_64Relocation
  88
  89   switch (Type) {
  90   default:
  91     llvm_unreachable("Invalid relocation type!");
  92   case macho::RIT_Vanilla: {
  93     uint8_t *p = LocalAddress;
  94     uint64_t ValueToWrite = Value + Addend;
  95     for (unsigned i = 0; i < Size; ++i) {
  96       *p++ = (uint8_t)(ValueToWrite & 0xff);
  97       ValueToWrite >>= 8;
  98     }
  99   }
 100   case macho::RIT_Difference:
 101   case macho::RIT_Generic_LocalDifference:
 102   case macho::RIT_Generic_PreboundLazyPointer:
 103     return Error("Relocation type not implemented yet!");
 104   }
 105 }
 106
 107 bool RuntimeDyldMachO::resolveX86_64Relocation(uint8_t *LocalAddress,
 108                                                uint64_t FinalAddress,
 109                                                uint64_t Value,
 110                                                bool isPCRel,
 111                                                unsigned Type,
 112                                                unsigned Size,
 113                                                int64_t Addend) {
 114   // If the relocation is PC-relative, the value to be encoded is the
 115   // pointer difference.
 116   if (isPCRel)
 117     // FIXME: It seems this value needs to be adjusted by 4 for an effective PC
 118     // address. Is that expected? Only for branches, perhaps?
 119     Value -= FinalAddress + 4;
 120
 121   switch(Type) {
 122   default:
 123     llvm_unreachable("Invalid relocation type!");
 124   case macho::RIT_X86_64_Signed1:
 125   case macho::RIT_X86_64_Signed2:
 126   case macho::RIT_X86_64_Signed4:
 127   case macho::RIT_X86_64_Signed:
 128   case macho::RIT_X86_64_Unsigned:
 129   case macho::RIT_X86_64_Branch: {
 130     Value += Addend;
 131     // Mask in the target value a byte at a time (we don't have an alignment
 132     // guarantee for the target address, so this is safest).
 133     uint8_t *p = (uint8_t*)LocalAddress;
 134     for (unsigned i = 0; i < Size; ++i) {
 135       *p++ = (uint8_t)Value;
 136       Value >>= 8;
 137     }
 138     return false;
 139   }
 140   case macho::RIT_X86_64_GOTLoad:
 141   case macho::RIT_X86_64_GOT:
 142   case macho::RIT_X86_64_Subtractor:
 143   case macho::RIT_X86_64_TLV:
 144     return Error("Relocation type not implemented yet!");
 145   }
 146 }
 147
 148 bool RuntimeDyldMachO::resolveARMRelocation(uint8_t *LocalAddress,
 149                                             uint64_t FinalAddress,
 150                                             uint64_t Value,
 151                                             bool isPCRel,
 152                                             unsigned Type,
 153                                             unsigned Size,
 154                                             int64_t Addend) {
 155   // If the relocation is PC-relative, the value to be encoded is the
 156   // pointer difference.
 157   if (isPCRel) {
 158     Value -= FinalAddress;
 159     // ARM PCRel relocations have an effective-PC offset of two instructions
 160     // (four bytes in Thumb mode, 8 bytes in ARM mode).
 161     // FIXME: For now, assume ARM mode.
 162     Value -= 8;
 163   }
 164
 165   switch(Type) {
 166   default:
 167     llvm_unreachable("Invalid relocation type!");
 168   case macho::RIT_Vanilla: {
 169     // Mask in the target value a byte at a time (we don't have an alignment
 170     // guarantee for the target address, so this is safest).
 171     uint8_t *p = (uint8_t*)LocalAddress;
 172     for (unsigned i = 0; i < Size; ++i) {
 173       *p++ = (uint8_t)Value;
 174       Value >>= 8;
 175     }
 176     break;
 177   }
 178   case macho::RIT_ARM_Branch24Bit: {
 179     // Mask the value into the target address. We know instructions are
 180     // 32-bit aligned, so we can do it all at once.
 181     uint32_t *p = (uint32_t*)LocalAddress;
 182     // The low two bits of the value are not encoded.
 183     Value >>= 2;
 184     // Mask the value to 24 bits.
 185     Value &= 0xffffff;
 186     // FIXME: If the destination is a Thumb function (and the instruction
 187     // is a non-predicated BL instruction), we need to change it to a BLX
 188     // instruction instead.
 189
 190     // Insert the value into the instruction.
 191     *p = (*p & ~0xffffff) | Value;
 192     break;
 193   }
 194   case macho::RIT_ARM_ThumbBranch22Bit:
 195   case macho::RIT_ARM_ThumbBranch32Bit:
 196   case macho::RIT_ARM_Half:
 197   case macho::RIT_ARM_HalfDifference:
 198   case macho::RIT_Pair:
 199   case macho::RIT_Difference:
 200   case macho::RIT_ARM_LocalDifference:
 201   case macho::RIT_ARM_PreboundLazyPointer:
 202     return Error("Relocation type not implemented yet!");
 203   }
 204   return false;
 205 }
 206
 207 void RuntimeDyldMachO::processRelocationRef(const ObjRelocationInfo &Rel,
 208                                             ObjectImage &Obj,
 209                                             ObjSectionToIDMap &ObjSectionToID,
 210                                             const SymbolTableMap &Symbols,
 211                                             StubMap &Stubs) {
 212
 213   uint32_t RelType = (uint32_t) (Rel.Type & 0xffffffffL);
 214   RelocationValueRef Value;
 215   SectionEntry &Section = Sections[Rel.SectionID];
 216
 217   bool isExtern = (RelType >> 27) & 1;
 218   if (isExtern) {
 219     // Obtain the symbol name which is referenced in the relocation
 220     StringRef TargetName;
 221     const SymbolRef &Symbol = Rel.Symbol;
 222     Symbol.getName(TargetName);
 223     // First search for the symbol in the local symbol table
 224     SymbolTableMap::const_iterator lsi = Symbols.find(TargetName.data());
 225     if (lsi != Symbols.end()) {
 226       Value.SectionID = lsi->second.first;
 227       Value.Addend = lsi->second.second;
 228     } else {
 229       // Search for the symbol in the global symbol table
 230       SymbolTableMap::const_iterator gsi = GlobalSymbolTable.find(TargetName.data());
 231       if (gsi != GlobalSymbolTable.end()) {
 232         Value.SectionID = gsi->second.first;
 233         Value.Addend = gsi->second.second;
 234       } else
 235         Value.SymbolName = TargetName.data();
 236     }
 237   } else {
 238     error_code err;
 239     uint8_t sectionIndex = static_cast<uint8_t>(RelType & 0xFF);
 240     section_iterator si = Obj.begin_sections(),
 241                      se = Obj.end_sections();
 242     for (uint8_t i = 1; i < sectionIndex; i++) {
 243       error_code err;
 244       si.increment(err);
 245       if (si == se)
 246         break;
 247     }
 248     assert(si != se && "No section containing relocation!");
 249     Value.SectionID = findOrEmitSection(Obj, *si, true, ObjSectionToID);
 250     Value.Addend = 0;
 251     // FIXME: The size and type of the relocation determines if we can
 252     // encode an Addend in the target location itself, and if so, how many
 253     // bytes we should read in order to get it. We don't yet support doing
 254     // that, and just assuming it's sizeof(intptr_t) is blatantly wrong.
 255     //Value.Addend = *(const intptr_t *)Target;
 256     if (Value.Addend) {
 257       // The MachO addend is an offset from the current section.  We need it
 258       // to be an offset from the destination section
 259       Value.Addend += Section.ObjAddress - Sections[Value.SectionID].ObjAddress;
 260     }
 261   }
 262
 263   if (Arch == Triple::arm && (RelType & 0xf) == macho::RIT_ARM_Branch24Bit) {
 264     // This is an ARM branch relocation, need to use a stub function.
 265
 266     //  Look up for existing stub.
 267     StubMap::const_iterator i = Stubs.find(Value);
 268     if (i != Stubs.end())
 269       resolveRelocation(Section, Rel.Offset,
 270                         (uint64_t)Section.Address + i->second,
 271                         RelType, 0);
 272     else {
 273       // Create a new stub function.
 274       Stubs[Value] = Section.StubOffset;
 275       uint8_t *StubTargetAddr = createStubFunction(Section.Address +
 276                                                    Section.StubOffset);
 277       RelocationEntry RE(Rel.SectionID, StubTargetAddr - Section.Address,
 278                          macho::RIT_Vanilla, Value.Addend);
 279       if (Value.SymbolName)
 280         addRelocationForSymbol(RE, Value.SymbolName);
 281       else
 282         addRelocationForSection(RE, Value.SectionID);
 283       resolveRelocation(Section, Rel.Offset,
 284                         (uint64_t)Section.Address + Section.StubOffset,
 285                         RelType, 0);
 286       Section.StubOffset += getMaxStubSize();
 287     }
 288   } else {
 289     RelocationEntry RE(Rel.SectionID, Rel.Offset, RelType, Value.Addend);
 290     if (Value.SymbolName)
 291       addRelocationForSymbol(RE, Value.SymbolName);
 292     else
 293       addRelocationForSection(RE, Value.SectionID);
 294   }
 295 }
 296
 297
 298 bool RuntimeDyldMachO::isCompatibleFormat(
 299         const ObjectBuffer *InputBuffer) const {
 300   if (InputBuffer->getBufferSize() < 4)
 301     return false;
 302   StringRef Magic(InputBuffer->getBufferStart(), 4);
 303   if (Magic == "\xFE\xED\xFA\xCE") return true;
 304   if (Magic == "\xCE\xFA\xED\xFE") return true;
 305   if (Magic == "\xFE\xED\xFA\xCF") return true;
 306   if (Magic == "\xCF\xFA\xED\xFE") return true;
 307   return false;
 308 }
 309
 310 } // end namespace llvm