lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

   1 //===-- RuntimeDyldELF.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 ELF support for the MC-JIT runtime dynamic linker.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "dyld"
  15 #include "llvm/ADT/OwningPtr.h"
  16 #include "llvm/ADT/StringRef.h"
  17 #include "llvm/ADT/STLExtras.h"
  18 #include "llvm/ADT/IntervalMap.h"
  19 #include "RuntimeDyldImpl.h"
  20 #include "llvm/Object/ObjectFile.h"
  21 #include "llvm/Support/ELF.h"
  22 #include "llvm/ADT/Triple.h"
  23 using namespace llvm;
  24 using namespace llvm::object;
  25
  26 namespace llvm {
  27
  28 namespace {
  29
  30 // FIXME: this function should probably not live here...
  31 //
  32 // Returns the name and address of an unrelocated symbol in an ELF section
  33 void getSymbolInfo(symbol_iterator Sym, uint64_t &Addr, StringRef &Name) {
  34   //FIXME: error checking here required to catch corrupt ELF objects...
  35   error_code Err = Sym->getName(Name);
  36
  37   uint64_t AddrInSection;
  38   Err = Sym->getAddress(AddrInSection);
  39
  40   SectionRef empty_section;
  41   section_iterator Section(empty_section);
  42   Err = Sym->getSection(Section);
  43
  44   StringRef SectionContents;
  45   Section->getContents(SectionContents);
  46
  47   Addr = reinterpret_cast<uint64_t>(SectionContents.data()) + AddrInSection;
  48 }
  49
  50 }
  51
  52 bool RuntimeDyldELF::loadObject(MemoryBuffer *InputBuffer) {
  53   if (!isCompatibleFormat(InputBuffer))
  54     return true;
  55
  56   OwningPtr<ObjectFile> Obj(ObjectFile::createELFObjectFile(InputBuffer));
  57
  58   Arch = Obj->getArch();
  59
  60   // Map address in the Object file image to function names
  61   IntervalMap<uint64_t, StringRef>::Allocator A;
  62   IntervalMap<uint64_t, StringRef> FuncMap(A);
  63
  64   // This is a bit of a hack.  The ObjectFile we've just loaded reports
  65   // section addresses as 0 and doesn't provide access to the section
  66   // offset (from which we could calculate the address.  Instead,
  67   // we're storing the address when it comes up in the ST_Debug case
  68   // below.
  69   //
  70   StringMap<uint64_t> DebugSymbolMap;
  71
  72   symbol_iterator SymEnd = Obj->end_symbols();
  73   error_code Err;
  74   for (symbol_iterator Sym = Obj->begin_symbols();
  75        Sym != SymEnd; Sym.increment(Err)) {
  76     SymbolRef::Type Type;
  77     Sym->getType(Type);
  78     if (Type == SymbolRef::ST_Function) {
  79       StringRef Name;
  80       uint64_t Addr;
  81       getSymbolInfo(Sym, Addr, Name);
  82
  83       uint64_t Size;
  84       Err = Sym->getSize(Size);
  85
  86       uint8_t *Start;
  87       uint8_t *End;
  88       Start = reinterpret_cast<uint8_t*>(Addr);
  89       End   = reinterpret_cast<uint8_t*>(Addr + Size - 1);
  90
  91       extractFunction(Name, Start, End);
  92       FuncMap.insert(Addr, Addr + Size - 1, Name);
  93     } else if (Type == SymbolRef::ST_Debug) {
  94       // This case helps us find section addresses
  95       StringRef Name;
  96       uint64_t Addr;
  97       getSymbolInfo(Sym, Addr, Name);
  98       DebugSymbolMap[Name] = Addr;
  99     }
 100   }
 101
 102   // Iterate through the relocations for this object
 103   section_iterator SecEnd = Obj->end_sections();
 104   for (section_iterator Sec = Obj->begin_sections();
 105        Sec != SecEnd; Sec.increment(Err)) {
 106     StringRef SecName;
 107     uint64_t  SecAddr;
 108     Sec->getName(SecName);
 109     // Ignore sections that aren't in our map
 110     if (DebugSymbolMap.find(SecName) == DebugSymbolMap.end()) {
 111       continue;
 112     }
 113     SecAddr = DebugSymbolMap[SecName];
 114     relocation_iterator RelEnd = Sec->end_relocations();
 115     for (relocation_iterator Rel = Sec->begin_relocations();
 116          Rel != RelEnd; Rel.increment(Err)) {
 117       uint64_t RelOffset;
 118       uint64_t RelType;
 119       int64_t RelAddend;
 120       SymbolRef RelSym;
 121       StringRef SymName;
 122       uint64_t SymAddr;
 123       uint64_t SymOffset;
 124
 125       Rel->getAddress(RelOffset);
 126       Rel->getType(RelType);
 127       Rel->getAdditionalInfo(RelAddend);
 128       Rel->getSymbol(RelSym);
 129       RelSym.getName(SymName);
 130       RelSym.getAddress(SymAddr);
 131       RelSym.getFileOffset(SymOffset);
 132
 133       // If this relocation is inside a function, we want to store the
 134       // function name and a function-relative offset
 135       IntervalMap<uint64_t, StringRef>::iterator ContainingFunc
 136         = FuncMap.find(SecAddr + RelOffset);
 137       if (ContainingFunc.valid()) {
 138         // Re-base the relocation to make it relative to the target function
 139         RelOffset = (SecAddr + RelOffset) - ContainingFunc.start();
 140         Relocations[SymName].push_back(RelocationEntry(ContainingFunc.value(),
 141                                                        RelOffset,
 142                                                        RelType,
 143                                                        RelAddend,
 144                                                        true));
 145       } else {
 146         Relocations[SymName].push_back(RelocationEntry(SecName,
 147                                                        RelOffset,
 148                                                        RelType,
 149                                                        RelAddend,
 150                                                        false));
 151       }
 152     }
 153   }
 154   return false;
 155 }
 156
 157 void RuntimeDyldELF::resolveX86_64Relocation(StringRef Name,
 158                                              uint8_t *Addr,
 159                                              const RelocationEntry &RE) {
 160   uint8_t *TargetAddr;
 161   if (RE.IsFunctionRelative) {
 162     StringMap<sys::MemoryBlock>::iterator ContainingFunc
 163       = Functions.find(RE.Target);
 164     assert(ContainingFunc != Functions.end()
 165            && "Function for relocation not found");
 166     TargetAddr = reinterpret_cast<uint8_t*>(ContainingFunc->getValue().base()) +
 167                  RE.Offset;
 168   } else {
 169     // FIXME: Get the address of the target section and add that to RE.Offset
 170     assert(0 && ("Non-function relocation not implemented yet!"));
 171   }
 172
 173   switch (RE.Type) {
 174   default:
 175     assert(0 && ("Relocation type not implemented yet!"));
 176   break;
 177   case ELF::R_X86_64_64: {
 178     uint8_t **Target = reinterpret_cast<uint8_t**>(TargetAddr);
 179     *Target = Addr + RE.Addend;
 180     break;
 181   }
 182   case ELF::R_X86_64_32:
 183   case ELF::R_X86_64_32S: {
 184     uint64_t Value = reinterpret_cast<uint64_t>(Addr) + RE.Addend;
 185     // FIXME: Handle the possibility of this assertion failing
 186     assert((RE.Type == ELF::R_X86_64_32 && !(Value & 0xFFFFFFFF00000000ULL)) ||
 187            (RE.Type == ELF::R_X86_64_32S &&
 188             (Value & 0xFFFFFFFF00000000ULL) == 0xFFFFFFFF00000000ULL));
 189     uint32_t TruncatedAddr = (Value & 0xFFFFFFFF);
 190     uint32_t *Target = reinterpret_cast<uint32_t*>(TargetAddr);
 191     *Target = TruncatedAddr;
 192     break;
 193   }
 194   case ELF::R_X86_64_PC32: {
 195     uint32_t *Placeholder = reinterpret_cast<uint32_t*>(TargetAddr);
 196     uint64_t RealOffset = *Placeholder +
 197                            reinterpret_cast<uint64_t>(Addr) +
 198                            RE.Addend - reinterpret_cast<uint64_t>(TargetAddr);
 199     assert((RealOffset & 0xFFFFFFFF) == RealOffset);
 200     uint32_t TruncOffset = (RealOffset & 0xFFFFFFFF);
 201     *Placeholder = TruncOffset;
 202     break;
 203   }
 204   }
 205 }
 206
 207 void RuntimeDyldELF::resolveX86Relocation(StringRef Name,
 208                                           uint8_t *Addr,
 209                                           const RelocationEntry &RE) {
 210   uint8_t *TargetAddr;
 211   if (RE.IsFunctionRelative) {
 212     StringMap<sys::MemoryBlock>::iterator ContainingFunc
 213       = Functions.find(RE.Target);
 214     assert(ContainingFunc != Functions.end()
 215            && "Function for relocation not found");
 216     TargetAddr = reinterpret_cast<uint8_t*>(
 217       ContainingFunc->getValue().base()) + RE.Offset;
 218   } else {
 219     // FIXME: Get the address of the target section and add that to RE.Offset
 220     assert(0 && ("Non-function relocation not implemented yet!"));
 221   }
 222
 223   switch (RE.Type) {
 224   case ELF::R_386_32: {
 225     uint8_t **Target = reinterpret_cast<uint8_t**>(TargetAddr);
 226     *Target = Addr + RE.Addend;
 227     break;
 228   }
 229   case ELF::R_386_PC32: {
 230     uint32_t *Placeholder = reinterpret_cast<uint32_t*>(TargetAddr);
 231     uint32_t RealOffset = *Placeholder + reinterpret_cast<uintptr_t>(Addr) +
 232                            RE.Addend - reinterpret_cast<uintptr_t>(TargetAddr);
 233     *Placeholder = RealOffset;
 234     break;
 235     }
 236     default:
 237       // There are other relocation types, but it appears these are the
 238       //  only ones currently used by the LLVM ELF object writer
 239       assert(0 && ("Relocation type not implemented yet!"));
 240       break;
 241   }
 242 }
 243
 244 void RuntimeDyldELF::resolveArmRelocation(StringRef Name,
 245                                           uint8_t *Addr,
 246                                           const RelocationEntry &RE) {
 247 }
 248
 249 void RuntimeDyldELF::resolveRelocation(StringRef Name,
 250                                        uint8_t *Addr,
 251                                        const RelocationEntry &RE) {
 252   switch (Arch) {
 253   case Triple::x86_64:
 254     resolveX86_64Relocation(Name, Addr, RE);
 255     break;
 256   case Triple::x86:
 257     resolveX86Relocation(Name, Addr, RE);
 258     break;
 259   case Triple::arm:
 260     resolveArmRelocation(Name, Addr, RE);
 261     break;
 262   default:
 263     assert(0 && "Unsupported CPU type!");
 264     break;
 265   }
 266 }
 267
 268 void RuntimeDyldELF::reassignSymbolAddress(StringRef Name, uint8_t *Addr) {
 269   SymbolTable[Name] = Addr;
 270
 271   RelocationList &Relocs = Relocations[Name];
 272   for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
 273     RelocationEntry &RE = Relocs[i];
 274     resolveRelocation(Name, Addr, RE);
 275   }
 276 }
 277
 278 bool RuntimeDyldELF::isCompatibleFormat(const MemoryBuffer *InputBuffer) const {
 279   StringRef Magic = InputBuffer->getBuffer().slice(0, ELF::EI_NIDENT);
 280   return (memcmp(Magic.data(), ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0;
 281 }
 282 } // namespace llvm