JITLink.cpp | Explore in Territory

//===------------- JITLink.cpp - Core Run-time JIT linker APIs ------------===//
//
// 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
//
//===----------------------------------------------------------------------===//

#include "llvm/ExecutionEngine/JITLink/JITLink.h"

#include "llvm/ADT/StringExtras.h"
#include "llvm/BinaryFormat/Magic.h"
#include "llvm/ExecutionEngine/JITLink/COFF.h"
#include "llvm/ExecutionEngine/JITLink/ELF.h"
#include "llvm/ExecutionEngine/JITLink/MachO.h"
#include "llvm/ExecutionEngine/JITLink/aarch64.h"
#include "llvm/ExecutionEngine/JITLink/i386.h"
#include "llvm/ExecutionEngine/JITLink/loongarch.h"
#include "llvm/ExecutionEngine/JITLink/x86_64.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/raw_ostream.h"

usingnamespacellvm;
usingnamespacellvm::object;

#define DEBUG_TYPE …

namespace {

enum JITLinkErrorCode { … };

// FIXME: This class is only here to support the transition to llvm::Error. It
// will be removed once this transition is complete. Clients should prefer to
// deal with the Error value directly, rather than converting to error_code.
class JITLinkerErrorCategory : public std::error_category { … };

} // namespace

namespace llvm {
namespace jitlink {

char JITLinkError::ID = …;

void JITLinkError::log(raw_ostream &OS) const { … }

std::error_code JITLinkError::convertToErrorCode() const { … }

const char *getGenericEdgeKindName(Edge::Kind K) { … }

const char *getLinkageName(Linkage L) { … }

const char *getScopeName(Scope S) { … }

bool isCStringBlock(Block &B) { … }

raw_ostream &operator<<(raw_ostream &OS, const Block &B) { … }

raw_ostream &operator<<(raw_ostream &OS, const Symbol &Sym) { … }

void printEdge(raw_ostream &OS, const Block &B, const Edge &E,
               StringRef EdgeKindName) { … }

Section::~Section() { … }

std::vector<Block *> LinkGraph::splitBlockImpl(std::vector<Block *> Blocks,
                                               SplitBlockCache *Cache) { … }

void LinkGraph::dump(raw_ostream &OS) { … }

raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupFlags &LF) { … }

void JITLinkAsyncLookupContinuation::anchor() { … }

JITLinkContext::~JITLinkContext() = default;

bool JITLinkContext::shouldAddDefaultTargetPasses(const Triple &TT) const { … }

LinkGraphPassFunction JITLinkContext::getMarkLivePass(const Triple &TT) const { … }

Error JITLinkContext::modifyPassConfig(LinkGraph &G,
                                       PassConfiguration &Config) { … }

Error markAllSymbolsLive(LinkGraph &G) { … }

Error makeTargetOutOfRangeError(const LinkGraph &G, const Block &B,
                                const Edge &E) { … }

Error makeAlignmentError(llvm::orc::ExecutorAddr Loc, uint64_t Value, int N,
                         const Edge &E) { … }

AnonymousPointerCreator getAnonymousPointerCreator(const Triple &TT) { … }

PointerJumpStubCreator getPointerJumpStubCreator(const Triple &TT) { … }

Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromObject(MemoryBufferRef ObjectBuffer) { … }

std::unique_ptr<LinkGraph> absoluteSymbolsLinkGraph(const Triple &TT,
                                                    orc::SymbolMap Symbols) { … }

void link(std::unique_ptr<LinkGraph> G, std::unique_ptr<JITLinkContext> Ctx) { … }

} // end namespace jitlink
} // end namespace llvm
llvm/llvm/lib/ExecutionEngine/JITLink/JITLink.cpp
