LCOV - code coverage report
Current view: top level - lib/ExecutionEngine/RuntimeDyld - RuntimeDyldELF.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 12 12 100.0 %
Date: 2018-02-23 15:42:53 Functions: 2 2 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- RuntimeDyldELF.h - 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             : // ELF support for MC-JIT runtime dynamic linker.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_RUNTIMEDYLDELF_H
      15             : #define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_RUNTIMEDYLDELF_H
      16             : 
      17             : #include "RuntimeDyldImpl.h"
      18             : #include "llvm/ADT/DenseMap.h"
      19             : 
      20             : using namespace llvm;
      21             : 
      22             : namespace llvm {
      23             : namespace object {
      24             : class ELFObjectFileBase;
      25             : }
      26             : 
      27             : class RuntimeDyldELF : public RuntimeDyldImpl {
      28             : 
      29             :   void resolveRelocation(const SectionEntry &Section, uint64_t Offset,
      30             :                          uint64_t Value, uint32_t Type, int64_t Addend,
      31             :                          uint64_t SymOffset = 0, SID SectionID = 0);
      32             : 
      33             :   void resolveX86_64Relocation(const SectionEntry &Section, uint64_t Offset,
      34             :                                uint64_t Value, uint32_t Type, int64_t Addend,
      35             :                                uint64_t SymOffset);
      36             : 
      37             :   void resolveX86Relocation(const SectionEntry &Section, uint64_t Offset,
      38             :                             uint32_t Value, uint32_t Type, int32_t Addend);
      39             : 
      40             :   void resolveAArch64Relocation(const SectionEntry &Section, uint64_t Offset,
      41             :                                 uint64_t Value, uint32_t Type, int64_t Addend);
      42             : 
      43             :   bool resolveAArch64ShortBranch(unsigned SectionID, relocation_iterator RelI,
      44             :                                  const RelocationValueRef &Value);
      45             : 
      46             :   void resolveAArch64Branch(unsigned SectionID, const RelocationValueRef &Value,
      47             :                             relocation_iterator RelI, StubMap &Stubs);
      48             : 
      49             :   void resolveARMRelocation(const SectionEntry &Section, uint64_t Offset,
      50             :                             uint32_t Value, uint32_t Type, int32_t Addend);
      51             : 
      52             :   void resolvePPC32Relocation(const SectionEntry &Section, uint64_t Offset,
      53             :                               uint64_t Value, uint32_t Type, int64_t Addend);
      54             : 
      55             :   void resolvePPC64Relocation(const SectionEntry &Section, uint64_t Offset,
      56             :                               uint64_t Value, uint32_t Type, int64_t Addend);
      57             : 
      58             :   void resolveSystemZRelocation(const SectionEntry &Section, uint64_t Offset,
      59             :                                 uint64_t Value, uint32_t Type, int64_t Addend);
      60             : 
      61             :   void resolveBPFRelocation(const SectionEntry &Section, uint64_t Offset,
      62             :                             uint64_t Value, uint32_t Type, int64_t Addend);
      63             : 
      64         795 :   unsigned getMaxStubSize() override {
      65         795 :     if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be)
      66             :       return 20; // movz; movk; movk; movk; br
      67         787 :     if (Arch == Triple::arm || Arch == Triple::thumb)
      68             :       return 8; // 32-bit instruction and 32-bit address
      69         785 :     else if (IsMipsO32ABI || IsMipsN32ABI)
      70             :       return 16;
      71         749 :     else if (IsMipsN64ABI)
      72             :       return 32;
      73         725 :     else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le)
      74             :       return 44;
      75         725 :     else if (Arch == Triple::x86_64)
      76             :       return 6; // 2-byte jmp instruction + 32-bit relative address
      77           5 :     else if (Arch == Triple::systemz)
      78             :       return 16;
      79             :     else
      80           2 :       return 0;
      81             :   }
      82             : 
      83        1139 :   unsigned getStubAlignment() override {
      84        1139 :     if (Arch == Triple::systemz)
      85             :       return 8;
      86             :     else
      87        1132 :       return 1;
      88             :   }
      89             : 
      90             :   void setMipsABI(const ObjectFile &Obj) override;
      91             : 
      92             :   Error findPPC64TOCSection(const ELFObjectFileBase &Obj,
      93             :                             ObjSectionToIDMap &LocalSections,
      94             :                             RelocationValueRef &Rel);
      95             :   Error findOPDEntrySection(const ELFObjectFileBase &Obj,
      96             :                             ObjSectionToIDMap &LocalSections,
      97             :                             RelocationValueRef &Rel);
      98             : protected:
      99             :   size_t getGOTEntrySize() override;
     100             : 
     101             : private:
     102             :   SectionEntry &getSection(unsigned SectionID) { return Sections[SectionID]; }
     103             : 
     104             :   // Allocate no GOT entries for use in the given section.
     105             :   uint64_t allocateGOTEntries(unsigned no);
     106             : 
     107             :   // Find GOT entry corresponding to relocation or create new one.
     108             :   uint64_t findOrAllocGOTEntry(const RelocationValueRef &Value,
     109             :                                unsigned GOTRelType);
     110             : 
     111             :   // Resolve the relvative address of GOTOffset in Section ID and place
     112             :   // it at the given Offset
     113             :   void resolveGOTOffsetRelocation(unsigned SectionID, uint64_t Offset,
     114             :                                   uint64_t GOTOffset, uint32_t Type);
     115             : 
     116             :   // For a GOT entry referenced from SectionID, compute a relocation entry
     117             :   // that will place the final resolved value in the GOT slot
     118             :   RelocationEntry computeGOTOffsetRE(uint64_t GOTOffset, uint64_t SymbolOffset,
     119             :                                      unsigned Type);
     120             : 
     121             :   // Compute the address in memory where we can find the placeholder
     122             :   void *computePlaceholderAddress(unsigned SectionID, uint64_t Offset) const;
     123             : 
     124             :   // Split out common case for createing the RelocationEntry for when the relocation requires
     125             :   // no particular advanced processing.
     126             :   void processSimpleRelocation(unsigned SectionID, uint64_t Offset, unsigned RelType, RelocationValueRef Value);
     127             : 
     128             :   // Return matching *LO16 relocation (Mips specific)
     129             :   uint32_t getMatchingLoRelocation(uint32_t RelType,
     130             :                                    bool IsLocal = false) const;
     131             : 
     132             :   // The tentative ID for the GOT section
     133             :   unsigned GOTSectionID;
     134             : 
     135             :   // Records the current number of allocated slots in the GOT
     136             :   // (This would be equivalent to GOTEntries.size() were it not for relocations
     137             :   // that consume more than one slot)
     138             :   unsigned CurrentGOTIndex;
     139             : 
     140             : protected:
     141             :   // A map from section to a GOT section that has entries for section's GOT
     142             :   // relocations. (Mips64 specific)
     143             :   DenseMap<SID, SID> SectionToGOTMap;
     144             : 
     145             : private:
     146             :   // A map to avoid duplicate got entries (Mips64 specific)
     147             :   StringMap<uint64_t> GOTSymbolOffsets;
     148             : 
     149             :   // *HI16 relocations will be added for resolving when we find matching
     150             :   // *LO16 part. (Mips specific)
     151             :   SmallVector<std::pair<RelocationValueRef, RelocationEntry>, 8> PendingRelocs;
     152             : 
     153             :   // When a module is loaded we save the SectionID of the EH frame section
     154             :   // in a table until we receive a request to register all unregistered
     155             :   // EH frame sections with the memory manager.
     156             :   SmallVector<SID, 2> UnregisteredEHFrameSections;
     157             : 
     158             :   // Map between GOT relocation value and corresponding GOT offset
     159             :   std::map<RelocationValueRef, uint64_t> GOTOffsetMap;
     160             : 
     161             :   bool relocationNeedsGot(const RelocationRef &R) const override;
     162             :   bool relocationNeedsStub(const RelocationRef &R) const override;
     163             : 
     164             : public:
     165             :   RuntimeDyldELF(RuntimeDyld::MemoryManager &MemMgr,
     166             :                  JITSymbolResolver &Resolver);
     167             :   ~RuntimeDyldELF() override;
     168             : 
     169             :   static std::unique_ptr<RuntimeDyldELF>
     170             :   create(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MemMgr,
     171             :          JITSymbolResolver &Resolver);
     172             : 
     173             :   std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
     174             :   loadObject(const object::ObjectFile &O) override;
     175             : 
     176             :   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override;
     177             :   Expected<relocation_iterator>
     178             :   processRelocationRef(unsigned SectionID, relocation_iterator RelI,
     179             :                        const ObjectFile &Obj,
     180             :                        ObjSectionToIDMap &ObjSectionToID,
     181             :                        StubMap &Stubs) override;
     182             :   bool isCompatibleFile(const object::ObjectFile &Obj) const override;
     183             :   void registerEHFrames() override;
     184             :   Error finalizeLoad(const ObjectFile &Obj,
     185             :                      ObjSectionToIDMap &SectionMap) override;
     186             : };
     187             : 
     188             : } // end namespace llvm
     189             : 
     190             : #endif

Generated by: LCOV version 1.13