src/llvm-project/llvm/lib/ExecutionEngine/JITLink/ELF_riscv.cpp - toolchain/rustc - Git at Google

 //===------- ELF_riscv.cpp -JIT linker implementation for ELF/riscv -------===//
 //
 // 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/riscv jit-link implementation.
 //
 //===----------------------------------------------------------------------===//

 #include "llvm/ExecutionEngine/JITLink/ELF_riscv.h"
 #include "llvm/ExecutionEngine/JITLink/JITLink.h"
 #include "llvm/ExecutionEngine/JITLink/riscv.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ELFObjectFile.h"

 #include "ELFLinkGraphBuilder.h"
 #include "JITLinkGeneric.h"

 #define DEBUG_TYPE "jitlink"
 using namespace llvm;

 namespace llvm {
 namespace jitlink {

 static Expected<const Edge &> getRISCVPCRelHi20(const Edge &E) {
   using namespace riscv;
   assert((E.getKind() == R_RISCV_PCREL_LO12_I ||
           E.getKind() == R_RISCV_PCREL_LO12_S) &&
          "Can only have high relocation for R_RISCV_PCREL_LO12_I or "
          "R_RISCV_PCREL_LO12_S");

   const Symbol &Sym = E.getTarget();
   const Block &B = Sym.getBlock();
   JITTargetAddress Offset = Sym.getOffset();

   struct Comp {
     bool operator()(const Edge &Lhs, JITTargetAddress Offset) {
       return Lhs.getOffset() < Offset;
     }
     bool operator()(JITTargetAddress Offset, const Edge &Rhs) {
       return Offset < Rhs.getOffset();
     }
   };

   auto Bound =
       std::equal_range(B.edges().begin(), B.edges().end(), Offset, Comp{});

   for (auto It = Bound.first; It != Bound.second; ++It) {
     if (It->getKind() == R_RISCV_PCREL_HI20)
       return *It;
   }

   return make_error<JITLinkError>(
       "No HI20 PCREL relocation type be found for LO12 PCREL relocation type");
 }

 static uint32_t extractBits(uint64_t Num, unsigned High, unsigned Low) {
   return (Num & ((1ULL << (High + 1)) - 1)) >> Low;
 }

 class ELFJITLinker_riscv : public JITLinker<ELFJITLinker_riscv> {
   friend class JITLinker<ELFJITLinker_riscv>;

 public:
   ELFJITLinker_riscv(std::unique_ptr<JITLinkContext> Ctx,
                      std::unique_ptr<LinkGraph> G, PassConfiguration PassConfig)
       : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {}

 private:
   Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
     using namespace riscv;
     using namespace llvm::support;

     char *BlockWorkingMem = B.getAlreadyMutableContent().data();
     char *FixupPtr = BlockWorkingMem + E.getOffset();
     JITTargetAddress FixupAddress = B.getAddress() + E.getOffset();
     switch (E.getKind()) {
     case R_RISCV_HI20: {
       int64_t Value = E.getTarget().getAddress() + E.getAddend();
       int32_t Hi = (Value + 0x800) & 0xFFFFF000;
       uint32_t RawInstr = *(little32_t *)FixupPtr;
       *(little32_t *)FixupPtr = (RawInstr & 0xFFF) | static_cast<uint32_t>(Hi);
       break;
     }
     case R_RISCV_LO12_I: {
       int64_t Value = E.getTarget().getAddress() + E.getAddend();
       int32_t Lo = Value & 0xFFF;
       uint32_t RawInstr = *(little32_t *)FixupPtr;
       *(little32_t *)FixupPtr =
           (RawInstr & 0xFFFFF) | (static_cast<uint32_t>(Lo & 0xFFF) << 20);
       break;
     }
     case R_RISCV_CALL: {
       int64_t Value = E.getTarget().getAddress() + E.getAddend() - FixupAddress;
       int32_t Hi = (Value + 0x800) & 0xFFFFF000;
       int32_t Lo = Value & 0xFFF;
       uint32_t RawInstrAuipc = *(little32_t *)FixupPtr;
       uint32_t RawInstrJalr = *(little32_t *)(FixupPtr + 4);
       *(little32_t *)FixupPtr = RawInstrAuipc | static_cast<uint32_t>(Hi);
       *(little32_t *)(FixupPtr + 4) =
           RawInstrJalr | (static_cast<uint32_t>(Lo) << 20);
       break;
     }
     case R_RISCV_PCREL_HI20: {
       int64_t Value = E.getTarget().getAddress() + E.getAddend() - FixupAddress;
       int32_t Hi = (Value + 0x800) & 0xFFFFF000;
       uint32_t RawInstr = *(little32_t *)FixupPtr;
       *(little32_t *)FixupPtr = (RawInstr & 0xFFF) | static_cast<uint32_t>(Hi);
       break;
     }
     case R_RISCV_PCREL_LO12_I: {
       auto RelHI20 = getRISCVPCRelHi20(E);
       if (!RelHI20)
         return RelHI20.takeError();
       int64_t Value = RelHI20->getTarget().getAddress() +
                       RelHI20->getAddend() - E.getTarget().getAddress();
       int64_t Lo = Value & 0xFFF;
       uint32_t RawInstr = *(little32_t *)FixupPtr;
       *(little32_t *)FixupPtr =
           (RawInstr & 0xFFFFF) | (static_cast<uint32_t>(Lo & 0xFFF) << 20);
       break;
     }
     case R_RISCV_PCREL_LO12_S: {
       auto RelHI20 = getRISCVPCRelHi20(E);
       int64_t Value = RelHI20->getTarget().getAddress() +
                       RelHI20->getAddend() - E.getTarget().getAddress();
       int64_t Lo = Value & 0xFFF;
       uint32_t Imm31_25 = extractBits(Lo, 11, 5) << 25;
       uint32_t Imm11_7 = extractBits(Lo, 4, 0) << 7;
       uint32_t RawInstr = *(little32_t *)FixupPtr;

       *(little32_t *)FixupPtr = (RawInstr & 0x1FFF07F) | Imm31_25 | Imm11_7;
       break;
     }
     }
     return Error::success();
   }
 };

 template <typename ELFT>
 class ELFLinkGraphBuilder_riscv : public ELFLinkGraphBuilder<ELFT> {
 private:
   static Expected<riscv::EdgeKind_riscv>
   getRelocationKind(const uint32_t Type) {
     using namespace riscv;
     switch (Type) {
     case ELF::R_RISCV_32:
       return EdgeKind_riscv::R_RISCV_32;
     case ELF::R_RISCV_64:
       return EdgeKind_riscv::R_RISCV_64;
     case ELF::R_RISCV_HI20:
       return EdgeKind_riscv::R_RISCV_HI20;
     case ELF::R_RISCV_LO12_I:
       return EdgeKind_riscv::R_RISCV_LO12_I;
     case ELF::R_RISCV_CALL:
       return EdgeKind_riscv::R_RISCV_CALL;
     case ELF::R_RISCV_PCREL_HI20:
       return EdgeKind_riscv::R_RISCV_PCREL_HI20;
     case ELF::R_RISCV_PCREL_LO12_I:
       return EdgeKind_riscv::R_RISCV_PCREL_LO12_I;
     case ELF::R_RISCV_PCREL_LO12_S:
       return EdgeKind_riscv::R_RISCV_PCREL_LO12_S;
     }

     return make_error<JITLinkError>("Unsupported riscv relocation:" +
                                     formatv("{0:d}", Type));
   }

   Error addRelocations() override {
     using Base = ELFLinkGraphBuilder<ELFT>;
     LLVM_DEBUG(dbgs() << "Adding relocations\n");

     // TODO a partern is forming of iterate some sections but only give me
     // ones I am interested, I should abstract that concept some where
     for (auto &SecRef : Base::Sections) {
       if (SecRef.sh_type != ELF::SHT_RELA && SecRef.sh_type != ELF::SHT_REL)
         continue;
       auto RelSectName = Base::Obj.getSectionName(SecRef);
       if (!RelSectName)
         return RelSectName.takeError();

       LLVM_DEBUG({
         dbgs() << "Adding relocations from section " << *RelSectName << "\n";
       });

       auto UpdateSection = Base::Obj.getSection(SecRef.sh_info);
       if (!UpdateSection)
         return UpdateSection.takeError();

       auto UpdateSectionName = Base::Obj.getSectionName(**UpdateSection);
       if (!UpdateSectionName)
         return UpdateSectionName.takeError();
       // Don't process relocations for debug sections.
       if (Base::isDwarfSection(*UpdateSectionName)) {
         LLVM_DEBUG({
           dbgs() << "  Target is dwarf section " << *UpdateSectionName
                  << ". Skipping.\n";
         });
         continue;
       } else
         LLVM_DEBUG({
           dbgs() << "  For target section " << *UpdateSectionName << "\n";
         });

       auto *JITSection = Base::G->findSectionByName(*UpdateSectionName);
       if (!JITSection)
         return make_error<llvm::StringError>(
             "Refencing a section that wasn't added to graph" +
                 *UpdateSectionName,
             llvm::inconvertibleErrorCode());

       auto Relocations = Base::Obj.relas(SecRef);
       if (!Relocations)
         return Relocations.takeError();

       for (const auto &Rela : *Relocations) {
         auto Type = Rela.getType(false);

         LLVM_DEBUG({
           dbgs() << "Relocation Type: " << Type << "\n"
                  << "Name: " << Base::Obj.getRelocationTypeName(Type) << "\n";
         });

         auto SymbolIndex = Rela.getSymbol(false);
         auto Symbol = Base::Obj.getRelocationSymbol(Rela, Base::SymTabSec);
         if (!Symbol)
           return Symbol.takeError();

         auto BlockToFix = *(JITSection->blocks().begin());
         auto *TargetSymbol = Base::getGraphSymbol(SymbolIndex);

         if (!TargetSymbol) {
           return make_error<llvm::StringError>(
               "Could not find symbol at given index, did you add it to "
               "JITSymbolTable? index: " +
                   std::to_string(SymbolIndex) + ", shndx: " +
                   std::to_string((*Symbol)->st_shndx) + " Size of table: " +
                   std::to_string(Base::GraphSymbols.size()),
               llvm::inconvertibleErrorCode());
         }
         int64_t Addend = Rela.r_addend;
         JITTargetAddress FixupAddress =
             (*UpdateSection)->sh_addr + Rela.r_offset;

         LLVM_DEBUG({
           dbgs() << "Processing relocation at "
                  << format("0x%016" PRIx64, FixupAddress) << "\n";
         });
         auto Kind = getRelocationKind(Type);
         if (!Kind)
           return Kind.takeError();

         BlockToFix->addEdge(*Kind, FixupAddress - BlockToFix->getAddress(),
                             *TargetSymbol, Addend);
       }
     }
     return Error::success();
   }

 public:
   ELFLinkGraphBuilder_riscv(StringRef FileName,
                             const object::ELFFile<ELFT> &Obj, const Triple T)
       : ELFLinkGraphBuilder<ELFT>(Obj, std::move(T), FileName,
                                   riscv::getEdgeKindName) {}
 };

 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer) {
   LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });

   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
   if (!ELFObj)
     return ELFObj.takeError();

   if ((*ELFObj)->getArch() == Triple::riscv64) {
     auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
     return ELFLinkGraphBuilder_riscv<object::ELF64LE>(
                (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
                (*ELFObj)->makeTriple())
         .buildGraph();
   } else {
     assert((*ELFObj)->getArch() == Triple::riscv32 &&
            "Invalid triple for RISCV ELF object file");
     auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj);
     return ELFLinkGraphBuilder_riscv<object::ELF32LE>(
                (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
                (*ELFObj)->makeTriple())
         .buildGraph();
   }
 }

 void link_ELF_riscv(std::unique_ptr<LinkGraph> G,
                     std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();
   if (Ctx->shouldAddDefaultTargetPasses(TT)) {
     if (auto MarkLive = Ctx->getMarkLivePass(TT))
       Config.PrePrunePasses.push_back(std::move(MarkLive));
     else
       Config.PrePrunePasses.push_back(markAllSymbolsLive);
   }
   if (auto Err = Ctx->modifyPassConfig(*G, Config))
     return Ctx->notifyFailed(std::move(Err));

   ELFJITLinker_riscv::link(std::move(Ctx), std::move(G), std::move(Config));
 }

 } // namespace jitlink
 } // namespace llvm
	//===------- ELF_riscv.cpp -JIT linker implementation for ELF/riscv -------===//
	//
	// 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/riscv jit-link implementation.
	//
	//===----------------------------------------------------------------------===//

	#include "llvm/ExecutionEngine/JITLink/ELF_riscv.h"
	#include "llvm/ExecutionEngine/JITLink/JITLink.h"
	#include "llvm/ExecutionEngine/JITLink/riscv.h"
	#include "llvm/Object/ELF.h"
	#include "llvm/Object/ELFObjectFile.h"

	#include "ELFLinkGraphBuilder.h"
	#include "JITLinkGeneric.h"

	#define DEBUG_TYPE "jitlink"
	using namespace llvm;

	namespace llvm {
	namespace jitlink {

	static Expected<const Edge &> getRISCVPCRelHi20(const Edge &E) {
	using namespace riscv;
	assert((E.getKind() == R_RISCV_PCREL_LO12_I \|\|
	E.getKind() == R_RISCV_PCREL_LO12_S) &&
	"Can only have high relocation for R_RISCV_PCREL_LO12_I or "
	"R_RISCV_PCREL_LO12_S");

	const Symbol &Sym = E.getTarget();
	const Block &B = Sym.getBlock();
	JITTargetAddress Offset = Sym.getOffset();

	struct Comp {
	bool operator()(const Edge &Lhs, JITTargetAddress Offset) {
	return Lhs.getOffset() < Offset;
	}
	bool operator()(JITTargetAddress Offset, const Edge &Rhs) {
	return Offset < Rhs.getOffset();
	}
	};

	auto Bound =
	std::equal_range(B.edges().begin(), B.edges().end(), Offset, Comp{});

	for (auto It = Bound.first; It != Bound.second; ++It) {
	if (It->getKind() == R_RISCV_PCREL_HI20)
	return *It;
	}

	return make_error<JITLinkError>(
	"No HI20 PCREL relocation type be found for LO12 PCREL relocation type");
	}

	static uint32_t extractBits(uint64_t Num, unsigned High, unsigned Low) {
	return (Num & ((1ULL << (High + 1)) - 1)) >> Low;
	}

	class ELFJITLinker_riscv : public JITLinker<ELFJITLinker_riscv> {
	friend class JITLinker<ELFJITLinker_riscv>;

	public:
	ELFJITLinker_riscv(std::unique_ptr<JITLinkContext> Ctx,
	std::unique_ptr<LinkGraph> G, PassConfiguration PassConfig)
	: JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {}

	private:
	Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
	using namespace riscv;
	using namespace llvm::support;

	char *BlockWorkingMem = B.getAlreadyMutableContent().data();
	char *FixupPtr = BlockWorkingMem + E.getOffset();
	JITTargetAddress FixupAddress = B.getAddress() + E.getOffset();
	switch (E.getKind()) {
	case R_RISCV_HI20: {
	int64_t Value = E.getTarget().getAddress() + E.getAddend();
	int32_t Hi = (Value + 0x800) & 0xFFFFF000;
	uint32_t RawInstr = (little32_t )FixupPtr;
	(little32_t )FixupPtr = (RawInstr & 0xFFF) \| static_cast<uint32_t>(Hi);
	break;
	}
	case R_RISCV_LO12_I: {
	int64_t Value = E.getTarget().getAddress() + E.getAddend();
	int32_t Lo = Value & 0xFFF;
	uint32_t RawInstr = (little32_t )FixupPtr;
	(little32_t )FixupPtr =
	(RawInstr & 0xFFFFF) \| (static_cast<uint32_t>(Lo & 0xFFF) << 20);
	break;
	}
	case R_RISCV_CALL: {
	int64_t Value = E.getTarget().getAddress() + E.getAddend() - FixupAddress;
	int32_t Hi = (Value + 0x800) & 0xFFFFF000;
	int32_t Lo = Value & 0xFFF;
	uint32_t RawInstrAuipc = (little32_t )FixupPtr;
	uint32_t RawInstrJalr = (little32_t )(FixupPtr + 4);
	(little32_t )FixupPtr = RawInstrAuipc \| static_cast<uint32_t>(Hi);
	(little32_t )(FixupPtr + 4) =
	RawInstrJalr \| (static_cast<uint32_t>(Lo) << 20);
	break;
	}
	case R_RISCV_PCREL_HI20: {
	int64_t Value = E.getTarget().getAddress() + E.getAddend() - FixupAddress;
	int32_t Hi = (Value + 0x800) & 0xFFFFF000;
	uint32_t RawInstr = (little32_t )FixupPtr;
	(little32_t )FixupPtr = (RawInstr & 0xFFF) \| static_cast<uint32_t>(Hi);
	break;
	}
	case R_RISCV_PCREL_LO12_I: {
	auto RelHI20 = getRISCVPCRelHi20(E);
	if (!RelHI20)
	return RelHI20.takeError();
	int64_t Value = RelHI20->getTarget().getAddress() +
	RelHI20->getAddend() - E.getTarget().getAddress();
	int64_t Lo = Value & 0xFFF;
	uint32_t RawInstr = (little32_t )FixupPtr;
	(little32_t )FixupPtr =
	(RawInstr & 0xFFFFF) \| (static_cast<uint32_t>(Lo & 0xFFF) << 20);
	break;
	}
	case R_RISCV_PCREL_LO12_S: {
	auto RelHI20 = getRISCVPCRelHi20(E);
	int64_t Value = RelHI20->getTarget().getAddress() +
	RelHI20->getAddend() - E.getTarget().getAddress();
	int64_t Lo = Value & 0xFFF;
	uint32_t Imm31_25 = extractBits(Lo, 11, 5) << 25;
	uint32_t Imm11_7 = extractBits(Lo, 4, 0) << 7;
	uint32_t RawInstr = (little32_t )FixupPtr;

	(little32_t )FixupPtr = (RawInstr & 0x1FFF07F) \| Imm31_25 \| Imm11_7;
	break;
	}
	}
	return Error::success();
	}
	};

	template <typename ELFT>
	class ELFLinkGraphBuilder_riscv : public ELFLinkGraphBuilder<ELFT> {
	private:
	static Expected<riscv::EdgeKind_riscv>
	getRelocationKind(const uint32_t Type) {
	using namespace riscv;
	switch (Type) {
	case ELF::R_RISCV_32:
	return EdgeKind_riscv::R_RISCV_32;
	case ELF::R_RISCV_64:
	return EdgeKind_riscv::R_RISCV_64;
	case ELF::R_RISCV_HI20:
	return EdgeKind_riscv::R_RISCV_HI20;
	case ELF::R_RISCV_LO12_I:
	return EdgeKind_riscv::R_RISCV_LO12_I;
	case ELF::R_RISCV_CALL:
	return EdgeKind_riscv::R_RISCV_CALL;
	case ELF::R_RISCV_PCREL_HI20:
	return EdgeKind_riscv::R_RISCV_PCREL_HI20;
	case ELF::R_RISCV_PCREL_LO12_I:
	return EdgeKind_riscv::R_RISCV_PCREL_LO12_I;
	case ELF::R_RISCV_PCREL_LO12_S:
	return EdgeKind_riscv::R_RISCV_PCREL_LO12_S;
	}

	return make_error<JITLinkError>("Unsupported riscv relocation:" +
	formatv("{0:d}", Type));
	}

	Error addRelocations() override {
	using Base = ELFLinkGraphBuilder<ELFT>;
	LLVM_DEBUG(dbgs() << "Adding relocations\n");

	// TODO a partern is forming of iterate some sections but only give me
	// ones I am interested, I should abstract that concept some where
	for (auto &SecRef : Base::Sections) {
	if (SecRef.sh_type != ELF::SHT_RELA && SecRef.sh_type != ELF::SHT_REL)
	continue;
	auto RelSectName = Base::Obj.getSectionName(SecRef);
	if (!RelSectName)
	return RelSectName.takeError();

	LLVM_DEBUG({
	dbgs() << "Adding relocations from section " << *RelSectName << "\n";
	});

	auto UpdateSection = Base::Obj.getSection(SecRef.sh_info);
	if (!UpdateSection)
	return UpdateSection.takeError();

	auto UpdateSectionName = Base::Obj.getSectionName(**UpdateSection);
	if (!UpdateSectionName)
	return UpdateSectionName.takeError();
	// Don't process relocations for debug sections.
	if (Base::isDwarfSection(*UpdateSectionName)) {
	LLVM_DEBUG({
	dbgs() << " Target is dwarf section " << *UpdateSectionName
	<< ". Skipping.\n";
	});
	continue;
	} else
	LLVM_DEBUG({
	dbgs() << " For target section " << *UpdateSectionName << "\n";
	});

	auto JITSection = Base::G->findSectionByName(UpdateSectionName);
	if (!JITSection)
	return make_error<llvm::StringError>(
	"Refencing a section that wasn't added to graph" +
	*UpdateSectionName,
	llvm::inconvertibleErrorCode());

	auto Relocations = Base::Obj.relas(SecRef);
	if (!Relocations)
	return Relocations.takeError();

	for (const auto &Rela : *Relocations) {
	auto Type = Rela.getType(false);

	LLVM_DEBUG({
	dbgs() << "Relocation Type: " << Type << "\n"
	<< "Name: " << Base::Obj.getRelocationTypeName(Type) << "\n";
	});

	auto SymbolIndex = Rela.getSymbol(false);
	auto Symbol = Base::Obj.getRelocationSymbol(Rela, Base::SymTabSec);
	if (!Symbol)
	return Symbol.takeError();

	auto BlockToFix = *(JITSection->blocks().begin());
	auto *TargetSymbol = Base::getGraphSymbol(SymbolIndex);

	if (!TargetSymbol) {
	return make_error<llvm::StringError>(
	"Could not find symbol at given index, did you add it to "
	"JITSymbolTable? index: " +
	std::to_string(SymbolIndex) + ", shndx: " +
	std::to_string((*Symbol)->st_shndx) + " Size of table: " +
	std::to_string(Base::GraphSymbols.size()),
	llvm::inconvertibleErrorCode());
	}
	int64_t Addend = Rela.r_addend;
	JITTargetAddress FixupAddress =
	(*UpdateSection)->sh_addr + Rela.r_offset;

	LLVM_DEBUG({
	dbgs() << "Processing relocation at "
	<< format("0x%016" PRIx64, FixupAddress) << "\n";
	});
	auto Kind = getRelocationKind(Type);
	if (!Kind)
	return Kind.takeError();

	BlockToFix->addEdge(*Kind, FixupAddress - BlockToFix->getAddress(),
	*TargetSymbol, Addend);
	}
	}
	return Error::success();
	}

	public:
	ELFLinkGraphBuilder_riscv(StringRef FileName,
	const object::ELFFile<ELFT> &Obj, const Triple T)
	: ELFLinkGraphBuilder<ELFT>(Obj, std::move(T), FileName,
	riscv::getEdgeKindName) {}
	};

	Expected<std::unique_ptr<LinkGraph>>
	createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer) {
	LLVM_DEBUG({
	dbgs() << "Building jitlink graph for new input "
	<< ObjectBuffer.getBufferIdentifier() << "...\n";
	});

	auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
	if (!ELFObj)
	return ELFObj.takeError();

	if ((*ELFObj)->getArch() == Triple::riscv64) {
	auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
	return ELFLinkGraphBuilder_riscv<object::ELF64LE>(
	(*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
	(*ELFObj)->makeTriple())
	.buildGraph();
	} else {
	assert((*ELFObj)->getArch() == Triple::riscv32 &&
	"Invalid triple for RISCV ELF object file");
	auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj);
	return ELFLinkGraphBuilder_riscv<object::ELF32LE>(
	(*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
	(*ELFObj)->makeTriple())
	.buildGraph();
	}
	}

	void link_ELF_riscv(std::unique_ptr<LinkGraph> G,
	std::unique_ptr<JITLinkContext> Ctx) {
	PassConfiguration Config;
	const Triple &TT = G->getTargetTriple();
	if (Ctx->shouldAddDefaultTargetPasses(TT)) {
	if (auto MarkLive = Ctx->getMarkLivePass(TT))
	Config.PrePrunePasses.push_back(std::move(MarkLive));
	else
	Config.PrePrunePasses.push_back(markAllSymbolsLive);
	}
	if (auto Err = Ctx->modifyPassConfig(*G, Config))
	return Ctx->notifyFailed(std::move(Err));

	ELFJITLinker_riscv::link(std::move(Ctx), std::move(G), std::move(Config));
	}

	} // namespace jitlink
	} // namespace llvm