Initial commit for the elf x86 implementation for jitlink

[jaredwy]

Summary

This is the first commit(and my first commit to LLVM :D) of many to come for the elf x86 jit linker. This just gets a very basic c program working with the execution engine.
e.g.

int main() return 42;

I plan to continue the rest of the work in tree. To that point there is a lot of clean up that will continue to happen as this evolves and the code state reflects that. For example there is commented out code, and some variables unused that are there for future work.

This is my first time using many of these apis so I welcome any improvements or suggestions if I am using them wrong or missed any utility methods to make life easier.
Thanks!

[lhames]

This is great stuff -- thanks Jared!

I've included some style comments inline.

This should also have an llvm-jitlink regression test case along the lines of llvm/test/ExecutionEngine/JITLink/X86/MachO_x86-64_relocations.s. Since this initial version doesn't support relocations your test case should just be a sanity check for ELF magic recognition, and section and symbol parsing. E.g.

# RUN: rm -rf %t && mkdir -p %t
# RUN: llvm-mc -triple=x86_64-unknown-linux -filetype=obj -o %t/elf_reloc.o %s
# RUN: llvm-jitlink -noexec -slab-allocate 100Kb -slab-address 0xfff00000 \
# RUN:    -define-abs external_data=0x1 -define-abs external_func=0x2 \
# RUN:    -check=%s %t/elf_reloc.o
#
# Test standard ELF relocations.

        .text
        .file   "testcase.c"
        .globl  main
        .p2align        4, 0x90
        .type   main,@function
main:
        movl    $42, %eax
        retq
.Lfunc_end0:
        .size   main, .Lfunc_end0-main

        .ident  "clang version 10.0.0-4ubuntu1 "
        .section        ".note.GNU-stack","",@progbits
        .addrsig

(Testcase not actually tested yet: I'm still building your branch)

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

160

MachO only has 256 sections indexes (the section index field is 8-bit), but I thought ELF had more?

244–255

This could use a clear TODO comment.

270–272

The LLVM style guide opts for no braces around single conditional statements, so this should be:

if (isRelocatable())
  return make_error<JITLinkError>("Object is not a relocatable ELF");

320–322

This should probably have a "TODO: add relocation handling" comment, even if it's obvious.

[lhames]

Just got a chance to look at the build messages for this. There are a few warnings (noted inline). I also noticed that this patch is against 2e42cc7a50e which is from late January. I don't think the JITLink APIs have changed too much: if you're happy to rebase against top of tree then go for it, otherwise I'm happy to do that before committing.

Finally, I got a chance to check out my suggested test line and realized that you don't need most of it for now. The following will do:

# RUN: rm -rf %t && mkdir -p %t
# RUN: llvm-mc -triple=x86_64-unknown-linux -filetype=obj -o %t/elf_reloc.o %s
# RUN: llvm-jitlink -noexec %t/elf_reloc.o
#
# Test standard ELF relocations.

        .text
        .file   "testcase.c"
        .globl  main
        .p2align        4, 0x90
        .type   main,@function
main:
        movl    $42, %eax
        retq
.Lfunc_end0:
        .size   main, .Lfunc_end0-main

        .ident  "clang version 10.0.0-4ubuntu1 "
        .section        ".note.GNU-stack","",@progbits
        .addrsig

Once those warnings are taken care of and the test case is in this looks good to me.

llvm/lib/ExecutionEngine/JITLink/ELF.cpp

30

debug_prefix is currently unused.

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

71–72

This should error out rather than continuing.

84–86

Other and Size are unused here.

172–173

Ditto here.

[jaredwy]

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

71–72

I have this fixed this locally. As discussed this now outputs the error to dgbs() rather than just dropping it.

160

I have removed this locally as I found out that the elf object can handle this lookup for me.

[lhames]

Ok. This looks good to me!

If you don't have commit access just let me know and I will commit on your behalf.

[jaredwy]

I will try and get commit status but I think to get this into tree, lets just have you commit it for now.

[abhinavgaba]

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

101

Binding and Value are read only inside this LLVM_DEBUG, making them unread if debug messages are disabled.

error: variable ‘Binding’ set but not used [-Werror=unused-but-set-variable]

[dblaikie]

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

101

Usually easier to commit fixes for things like this directly, rather than going through a round of feedback, waiting for someone to fix, etc.

I've fixed this in fca76b79456c916fd2ce193ef76d6e795bd9c105

llvm/include/llvm/ExecutionEngine/JITLink/ELF.h

+//===------- ELF.h - Generic JIT link function for ELF ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Generic jit-link functions for ELF.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_ELF_H
+#define LLVM_EXECUTIONENGINE_JITLINK_ELF_H
+
+#include "llvm/ExecutionEngine/JITLink/ELF.h"
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+
+namespace llvm {
+namespace jitlink {
+
+/// jit-link the given ObjBuffer, which must be a ELF object file.
+///
+/// Uses conservative defaults for GOT and stub handling based on the target
+/// platform.
+void jitLink_ELF(std::unique_ptr<JITLinkContext> Ctx);
+
+} // end namespace jitlink
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_H

llvm/include/llvm/ExecutionEngine/JITLink/ELF_x86_64.h

+//===--- ELF_x86_64.h - JIT link functions for ELF/x86-64 ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// jit-link functions for ELF/x86-64.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_ELF_X86_64_H
+#define LLVM_EXECUTIONENGINE_JITLINK_ELF_X86_64_H
+
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+
+namespace llvm {
+namespace jitlink {
+
+namespace ELF_x86_64_Edges {
+
+enum ELFX86RelocationKind : Edge::Kind {
+  R_AMD64_NONE = Edge::FirstRelocation,
+  R_AMD64_64,
+  R_AMD64_PC32,
+  R_AMD64_GOT32,
+  R_AMD64_PLT32,
+  R_AMD64_COPY,
+  R_AMD64_GLOB_DAT,
+  R_AMD64_JUMP_SLOT,
+  R_AMD64_RELATIVE,
+  R_AMD64_GOTPCREL,
+  R_AMD64_32,
+  R_AMD64_32S,
+  R_AMD64_16,
+  R_AMD64_PC16,
+  R_AMD64_8,
+  R_AMD64_PC8,
+  R_AMD64_PC64,
+  R_AMD64_GOTOFF64,
+  R_AMD64_GOTPC32,
+  R_AMD64_SIZE32,
+  R_AMD64_SIZE64
+};
+
+} // end namespace ELF_x86_64_Edges
+
+/// jit-link the given object buffer, which must be a ELF x86-64 object file.
+void jitLink_ELF_x86_64(std::unique_ptr<JITLinkContext> Ctx);
+StringRef getELFX86RelocationKindName(Edge::Kind R);
+} // end namespace jitlink
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_X86_64_H

llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt

   JITLinkGeneric.cpp
   JITLinkMemoryManager.cpp
   EHFrameSupport.cpp
+  #macho
   MachO.cpp
   MachO_arm64.cpp
   MachO_x86_64.cpp
   MachOLinkGraphBuilder.cpp
-
+  #elf
+  ELF.cpp
+  ELF_x86_64.cpp
   DEPENDS
   intrinsics_gen
   )

llvm/lib/ExecutionEngine/JITLink/ELF.cpp

+//===-------------- ELF.cpp - JIT linker function for ELF -------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// ELF jit-link function.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/JITLink/ELF.h"
+
+#include "llvm/BinaryFormat/ELF.h"
+#include "llvm/ExecutionEngine/JITLink/ELF_x86_64.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include <cstring>
+
+using namespace llvm;
+
+#define DEBUG_TYPE "jitlink"
+
+namespace llvm {
+namespace jitlink {
+
+constexpr char debug_prefix[] = "jitLink_ELF: ";
+
+void jitLink_ELF(std::unique_ptr<JITLinkContext> Ctx) {
+
+  // We don't want to do full ELF validation here. We just verify it is elf'ish.
+  // Probably should parse into an elf header when we support more than x86 :)
+
+  StringRef Data = Ctx->getObjectBuffer().getBuffer();
+  if (Data.size() < llvm::ELF::EI_MAG3 + 1) {
+    Ctx->notifyFailed(make_error<JITLinkError>("Truncated ELF buffer"));
+    return;
+  }
+
+  if (!memcmp(Data.data(), llvm::ELF::ElfMagic, strlen(llvm::ELF::ElfMagic))) {
+    if (Data.data()[llvm::ELF::EI_CLASS] == ELF::ELFCLASS64) {
+      return jitLink_ELF_x86_64(std::move(Ctx));
+    }
+  }
+
+  Ctx->notifyFailed(make_error<JITLinkError>("ELF magic not valid"));
+}
+
+} // end namespace jitlink
+} // end namespace llvm

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

+//===---- ELF_x86_64.cpp -JIT linker implementation for ELF/x86-64 ----===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// ELF/x86-64 jit-link implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/JITLink/ELF_x86_64.h"
+#include "JITLinkGeneric.h"
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+#include "llvm/Object/ELFObjectFile.h"
+
+#define DEBUG_TYPE "jitlink"
+
+using namespace llvm;
+using namespace llvm::jitlink;
+
+static const char *CommonSectionName = "__common";
+
+namespace llvm {
+namespace jitlink {
+// This should become a template as the ELFFile is so a lot of this could become
+// generic
+class ELFLinkGraphBuilder_x86_64 {
+
+private:
+  Section *CommonSection = nullptr;
+  Section &getCommonSection() {
+    if (!CommonSection) {
+      auto Prot = static_cast<sys::Memory::ProtectionFlags>(
+          sys::Memory::MF_READ | sys::Memory::MF_WRITE);
+      CommonSection = &G->createSection(CommonSectionName, Prot);
+    }
+    return *CommonSection;
+  }
+
+  std::unique_ptr<LinkGraph> G;
+  // This could be a template
+  const object::ELFFile<object::ELF64LE> &Obj;
+  object::ELFFile<object::ELF64LE>::Elf_Shdr_Range sections;
+
+  bool isRelocatable() { return Obj.getHeader()->e_type == llvm::ELF::ET_REL; }
+
+  support::endianness
+  getEndianness(const object::ELFFile<object::ELF64LE> &Obj) {
+    return Obj.isLE() ? support::little : support::big;
+  }
+
+  // This could also just become part of a template
+  unsigned getPointerSize(const object::ELFFile<object::ELF64LE> &Obj) {
+    return Obj.getHeader()->getFileClass() == ELF::ELFCLASS64 ? 8 : 4;
+  }
+
+  // We don't technically need this right now
+  // But for now going to keep it as it helps me to debug things
+
+  Error createNormalizedSymbols() {
+    LLVM_DEBUG(dbgs() << "Creating normalized symbols...\n");
+
+    for (auto SecRef : sections) {
+      if (SecRef.sh_type != ELF::SHT_SYMTAB &&
+          SecRef.sh_type != ELF::SHT_DYNSYM)
+        continue;
+
+      auto Symbols = Obj.symbols(&SecRef);
+      if (errorToBool(std::move(Symbols.takeError())))
+        continue;
+
+      auto StrTabSec = Obj.getSection(SecRef.sh_link);
+      if (!StrTabSec)
+        return StrTabSec.takeError();
+      auto StringTable = Obj.getStringTable(*StrTabSec);
+      if (!StringTable)
+        return StringTable.takeError();
+
+      for (auto SymRef : *Symbols) {
+        Optional<StringRef> Name;
+        unsigned char Binding;
+        uint8_t Other;
+        uint64_t Value;
+        uint64_t Size;
+        if (auto NameOrErr = SymRef.getName(*StringTable)) {
+          Name = *NameOrErr;
+        } else {
+          return NameOrErr.takeError();
+        }
+        Binding = SymRef.getBinding();
+        Value = SymRef.getValue();
+        LLVM_DEBUG({
+          dbgs() << "  ";
+          if (!Name)
+            dbgs() << "<anonymous symbol>";
+          else
+            dbgs() << *Name;
+          dbgs() << ": value = " << formatv("{0:x16}", Value)
+                 << ", type = " << formatv("{0:x2}", SymRef.getType());
+          dbgs() << "\n";
+        });
+      }
+    }
+    return Error::success();
+  }
+
+  Error createNormalizedSections() {
+    LLVM_DEBUG(dbgs() << "Creating normalized sections...\n");
+    for (auto &SecRef : sections) {
+      auto Name = Obj.getSectionName(&SecRef);
+      if (!Name)
+        return Name.takeError();
+      sys::Memory::ProtectionFlags Prot;
+      if (SecRef.sh_flags & ELF::SHF_EXECINSTR) {
+        Prot = static_cast<sys::Memory::ProtectionFlags>(sys::Memory::MF_READ |
+                                                         sys::Memory::MF_EXEC);
+      } else {
+        Prot = static_cast<sys::Memory::ProtectionFlags>(sys::Memory::MF_READ |
+                                                         sys::Memory::MF_WRITE);
+      }
+      uint64_t Address = SecRef.sh_addr;
+      uint64_t Size = SecRef.sh_size;
+      uint64_t Flags = SecRef.sh_flags;
+      uint64_t Alignment = SecRef.sh_addralign;
+      const char *Data = nullptr;
+      // TODO: figure out what it is that has 0 size no name and address
+      // 0000-0000
+      if (Size == 0)
+        continue;
+      LLVM_DEBUG({
+        dbgs() << "  " << *Name << ": " << formatv("{0:x16}", Address) << " -- "
+               << formatv("{0:x16}", Address + Size) << ", align: " << Alignment
+               << " Flags:" << Flags << "\n";
+      });
+
+      if (SecRef.sh_type != ELF::SHT_NOBITS) {
+        // .sections() already checks that the data is not beyond the end of
+        // file
+        auto contents = Obj.getSectionContentsAsArray<char>(&SecRef);
+        if (!contents)
+          return contents.takeError();
+
+        Data = contents->data();
+        // TODO protection flags.
+        // for now everything is
+        auto &section = G->createSection(*Name, Prot);
+        // Do this here because we have it, but move it into graphify later
+        G->createContentBlock(section, StringRef(Data, Size), Address,
+                              Alignment, 0);
+      }
+    }
+
+    return Error::success();
+  }
+
+  Error graphifyRegularSymbols() {
+
+    /// We only have 256 section indexes: Use a vector rather than a map.
+    std::vector<std::vector<object::ELFFile<object::ELF64LE>::Elf_Shdr_Range *>>
+        SecIndexToSymbols;
+
+    LLVM_DEBUG(dbgs() << "Creating graph symbols...\n");
+
+    for (auto SecRef : sections) {
+
+      if (SecRef.sh_type != ELF::SHT_SYMTAB &&
+          SecRef.sh_type != ELF::SHT_DYNSYM)
+        continue;
+      auto Symbols = Obj.symbols(&SecRef);
+      if (errorToBool(std::move(Symbols.takeError())))
+        continue;
+
+      auto StrTabSec = Obj.getSection(SecRef.sh_link);
+      if (!StrTabSec)
+        return StrTabSec.takeError();
+      auto StringTable = Obj.getStringTable(*StrTabSec);
+      if (!StringTable)
+        return StringTable.takeError();
+      auto Name = Obj.getSectionName(&SecRef);
+      if (!Name)
+        return Name.takeError();
+      auto Section = G->findSectionByName(*Name);
+      if (!Section)
+        return make_error<llvm::StringError>("Could not find a section",
+                                             llvm::inconvertibleErrorCode());
+      // we only have one for now
+      auto blocks = Section->blocks();
+      if (blocks.empty())
+        return make_error<llvm::StringError>("Section has no block",
+                                             llvm::inconvertibleErrorCode());
+
+      for (auto SymRef : *Symbols) {
+        auto Type = SymRef.getType();
+        if (Type == ELF::STT_NOTYPE || Type == ELF::STT_FILE)
+          continue;
+        // these should do it for now
+        // if(Type != ELF::STT_NOTYPE &&
+        //   Type != ELF::STT_OBJECT &&
+        //   Type != ELF::STT_FUNC    &&
+        //   Type != ELF::STT_SECTION &&
+        //   Type != ELF::STT_COMMON) {
+        //     continue;
+        //   }
+        std::pair<Linkage, Scope> bindings;
+        auto Name = SymRef.getName(*StringTable);
+        // I am not sure on If this is going to hold as an invariant. Revisit.
+        if (!Name)
+          return Name.takeError();
+        // TODO: weak and hidden
+        if (SymRef.isExternal()) {
+          bindings = {Linkage::Strong, Scope::Default};
+        } else {
+          bindings = {Linkage::Strong, Scope::Local};
+        }
+
+        if (SymRef.isDefined() &&
+            (Type == ELF::STT_FUNC || Type == ELF::STT_OBJECT)) {
+
+          auto DefinedSection = Obj.getSection(SymRef.st_shndx);
+          if (!DefinedSection)
+            return DefinedSection.takeError();
+          auto sectName = Obj.getSectionName(*DefinedSection);
+          if (!sectName)
+            return Name.takeError();
+
+          auto JitSection = G->findSectionByName(*sectName);
+          if (!JitSection)
+            return make_error<llvm::StringError>(
+                "Could not find a section", llvm::inconvertibleErrorCode());
+          auto bs = JitSection->blocks();
+          if (bs.empty())
+            return make_error<llvm::StringError>(
+                "Section has no block", llvm::inconvertibleErrorCode());
+
+          auto B = *bs.begin();
+          LLVM_DEBUG({ dbgs() << "  " << *Name << ": "; });
+
+          G->addDefinedSymbol(*B, SymRef.getValue(), *Name, SymRef.st_size,
+                              bindings.first, bindings.second,
+                              SymRef.getType() == ELF::STT_FUNC, false);
+        }
+        /*
+          G->addAbsoluteSymbol(*Name, SymRef.getValue(), SymRef.st_size,
+          Linkage::Strong, Scope::Default, false);
+
+          if(SymRef.isCommon()) {
+            G->addCommonSymbol(*Name, Scope::Default, getCommonSection(), 0, 0,
+          SymRef.getValue(), false);
+          }
+
+
+          //G->addExternalSymbol(*Name, SymRef.st_size, Linkage::Strong);
+  */
+      }
+    }
+    return Error::success();
+  }
+
+public:
+  ELFLinkGraphBuilder_x86_64(std::string filename,
+                             const object::ELFFile<object::ELF64LE> &Obj)
+      : G(std::make_unique<LinkGraph>(filename, getPointerSize(Obj),
+                                      getEndianness(Obj))),
+        Obj(Obj) {}
+
+  Expected<std::unique_ptr<LinkGraph>> buildGraph() {
+    // Sanity check: we only operate on relocatable objects.
+    if (!isRelocatable()) {
+      return make_error<JITLinkError>("Object is not a relocatable ELF");
+    }
+
+    auto Secs = Obj.sections();
+
+    if (!Secs) {
+      return Secs.takeError();
+    }
+    sections = *Secs;
+
+    if (auto Err = createNormalizedSections())
+      return std::move(Err);
+
+    if (auto Err = createNormalizedSymbols())
+      return std::move(Err);
+
+    if (auto Err = graphifyRegularSymbols())
+      return std::move(Err);
+
+    return std::move(G);
+  }
+};
+
+class ELFJITLinker_x86_64 : public JITLinker<ELFJITLinker_x86_64> {
+  friend class JITLinker<ELFJITLinker_x86_64>;
+
+public:
+  ELFJITLinker_x86_64(std::unique_ptr<JITLinkContext> Ctx,
+                      PassConfiguration PassConfig)
+      : JITLinker(std::move(Ctx), std::move(PassConfig)) {}
+
+private:
+  StringRef getEdgeKindName(Edge::Kind R) const override {
+    return getELFX86RelocationKindName(R);
+  }
+
+  Expected<std::unique_ptr<LinkGraph>>
+  buildGraph(MemoryBufferRef ObjBuffer) override {
+    auto ELFObj = object::ObjectFile::createELFObjectFile(ObjBuffer);
+    if (!ELFObj)
+      return ELFObj.takeError();
+
+    auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
+    std::string fileName(ELFObj->get()->getFileName());
+    return ELFLinkGraphBuilder_x86_64(std::move(fileName),
+                                      *ELFObjFile.getELFFile())
+        .buildGraph();
+  }
+
+  Error applyFixup(Block &B, const Edge &E, char *BlockWorkingMem) const {
+    return Error::success();
+  }
+};
+
+void jitLink_ELF_x86_64(std::unique_ptr<JITLinkContext> Ctx) {
+  PassConfiguration Config;
+  Triple TT("x86_64-linux");
+  // Construct a JITLinker and run the link function.
+  // Add a mark-live pass.
+  if (auto MarkLive = Ctx->getMarkLivePass(TT))
+    Config.PrePrunePasses.push_back(std::move(MarkLive));
+  else
+    Config.PrePrunePasses.push_back(markAllSymbolsLive);
+
+  ELFJITLinker_x86_64::link(std::move(Ctx), std::move(Config));
+}
+
+StringRef getELFX86RelocationKindName(Edge::Kind R) {
+  switch (R) {
+    //     case R_AMD64_NONE:
+    //         return "None";
+    //   case R_AMD64_PC32:
+    //   case R_AMD64_GOT32:
+    //   caseR_AMD64_PLT32,
+    //   R_AMD64_COPY,
+    //   R_AMD64_GLOB_DAT,
+    //   R_AMD64_JUMP_SLOT,
+    //   R_AMD64_RELATIVE,
+    //   R_AMD64_GOTPCREL,
+    //   R_AMD64_32,
+    //   R_AMD64_32S,
+    //   R_AMD64_16,
+    //   R_AMD64_PC16,
+    //   R_AMD64_8,
+    //   R_AMD64_PC8,
+    //   R_AMD64_PC64,
+    //   R_AMD64_GOTOFF64,
+    //   R_AMD64_GOTPC32,
+    //   R_AMD64_SIZE32,
+    //   R_AMD64_SIZE64
+  default:
+    return getGenericEdgeKindName(static_cast<Edge::Kind>(R));
+  }
+}
+} // end namespace jitlink
+} // end namespace llvm

llvm/lib/ExecutionEngine/JITLink/JITLink.cpp

 #include "llvm/ExecutionEngine/JITLink/JITLink.h"
 
 #include "llvm/BinaryFormat/Magic.h"
+#include "llvm/ExecutionEngine/JITLink/ELF.h"
 #include "llvm/ExecutionEngine/JITLink/MachO.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"

   switch (Magic) {
   case file_magic::macho_object:
     return jitLink_MachO(std::move(Ctx));
+  case file_magic::elf_relocatable:
+    return jitLink_ELF(std::move(Ctx));
   default:
     Ctx->notifyFailed(make_error<JITLinkError>("Unsupported file format"));
   };