OrcJit Class Reference

#include <llvmexpr/runtime/llvm/Jit.hpp>

Public Member Functions
	OrcJit (bool no_nans_fp_math)
const llvm::DataLayout &	getDataLayout () const
const llvm::Triple &	getTargetTriple () const
void	addModule (std::unique_ptr< llvm::Module > m, std::unique_ptr< llvm::LLVMContext > ctx)
void *	getFunctionAddress (const std::string &name)

Detailed Description

Definition at line 42 of file Jit.hpp.

Constructor & Destructor Documentation

OrcJit()

OrcJit::OrcJit ( bool no_nans_fp_math )

explicit

Definition at line 66 of file Jit.cpp.

                                   {
    static struct LLVMInitializer {
        LLVMInitializer() { // NOLINT(modernize-use-equals-default)
            llvm::InitializeNativeTarget();
            llvm::InitializeNativeTargetAsmPrinter();
            llvm::InitializeNativeTargetAsmParser();
        }
        LLVMInitializer(const LLVMInitializer&) = delete;
        LLVMInitializer& operator=(const LLVMInitializer&) = delete;
        LLVMInitializer(LLVMInitializer&&) = delete;
        LLVMInitializer& operator=(LLVMInitializer&&) = delete;
        ~LLVMInitializer() = default;
    } initializer;
 
    auto jtmb =
        llvm::cantFail(llvm::orc::JITTargetMachineBuilder::detectHost());
    jtmb.setCodeGenOptLevel(llvm::CodeGenOptLevel::Aggressive);
 
    llvm::StringMap<bool> host_features = llvm::sys::getHostCPUFeatures();
    if (host_features.size() > 0) {
        std::vector<std::string> features;
        for (auto& f : host_features) {
            if (f.getValue()) {
                features.push_back("+" + f.getKey().str());
            }
        }
        jtmb.addFeatures(features);
    }
 
    llvm::TargetOptions opts;
    opts.AllowFPOpFusion = llvm::FPOpFusion::Fast;
#if LLVM_VERSION_MAJOR < 22
    opts.UnsafeFPMath = true;
#endif
    opts.NoInfsFPMath = true;
    opts.NoNaNsFPMath = no_nans_fp_math;
    jtmb.setOptions(opts);
 
    auto jit_builder = llvm::orc::LLJITBuilder();
    jit_builder.setJITTargetMachineBuilder(std::move(jtmb));
    auto temp_jit = jit_builder.create();
    if (!temp_jit) {
        llvm::errs() << "Failed to create LLJIT instance: "
                     << llvm::toString(temp_jit.takeError()) << "\n";
        throw std::runtime_error("LLJIT creation failed");
    }
    lljit = std::move(*temp_jit);
 
    // Register Host API symbols for dynamic array management
    auto& main_jd = lljit->getMainJITDylib();
    llvm::orc::SymbolMap symbols;
 
    symbols[lljit->mangleAndIntern("llvmexpr_ensure_buffer")] =
        llvm::orc::ExecutorSymbolDef(
            llvm::orc::ExecutorAddr(
                llvm::pointerToJITTargetAddress(&llvmexpr_ensure_buffer)),
            llvm::JITSymbolFlags::Callable | llvm::JITSymbolFlags::Exported);
 
    symbols[lljit->mangleAndIntern("llvmexpr_get_buffer_size")] =
        llvm::orc::ExecutorSymbolDef(
            llvm::orc::ExecutorAddr(
                llvm::pointerToJITTargetAddress(&llvmexpr_get_buffer_size)),
            llvm::JITSymbolFlags::Callable | llvm::JITSymbolFlags::Exported);
 
#ifdef _WIN32
    symbols[lljit->mangleAndIntern("sincosf")] = llvm::orc::ExecutorSymbolDef(
        llvm::orc::ExecutorAddr(
            llvm::pointerToJITTargetAddress(&llvmexpr_sincosf)),
        llvm::JITSymbolFlags::Callable | llvm::JITSymbolFlags::Exported);
 
    symbols[lljit->mangleAndIntern("sincos")] = llvm::orc::ExecutorSymbolDef(
        llvm::orc::ExecutorAddr(
            llvm::pointerToJITTargetAddress(&llvmexpr_sincos)),
        llvm::JITSymbolFlags::Callable | llvm::JITSymbolFlags::Exported);
#endif
 
    if (auto err = main_jd.define(llvm::orc::absoluteSymbols(symbols))) {
        llvm::errs() << "Failed to define host call symbols: "
                     << llvm::toString(std::move(err)) << "\n";
        throw std::runtime_error("Failed to define host call symbols in JIT");
    }
}

References llvmexpr_ensure_buffer(), and llvmexpr_get_buffer_size().

Member Function Documentation

addModule()

void OrcJit::addModule	(	std::unique_ptr< llvm::Module >	m,
		std::unique_ptr< llvm::LLVMContext >	ctx )

Definition at line 157 of file Jit.cpp.

                                                           {
    std::vector<llvm::Function*> functions_to_remove;
    for (auto& f : *m) {
        if (!f.isDeclaration()) {
            std::string func_name = f.getName().str();
 
            if (!func_name.starts_with("process_plane_")) {
                if (func_name.starts_with("fast_") ||
                    func_name.find("_v4") != std::string::npos ||
                    func_name.find("_v8") != std::string::npos ||
                    func_name.find("_v16") != std::string::npos) {
 
                    // Try a test lookup to see if symbol exists
                    auto test_sym = lljit->lookup(func_name);
                    if (test_sym) {
                        // Symbol already exists, mark for removal
                        functions_to_remove.push_back(&f);
                        continue;
                    }
                    // If test lookup failed, the symbol doesn't exist, so we can add it
                    llvm::consumeError(test_sym.takeError());
                }
            }
        }
    }
 
    // Remove duplicate functions from the module
    for (auto* f : functions_to_remove) {
        f->eraseFromParent();
    }
 
    auto tsm = llvm::orc::ThreadSafeModule(std::move(m), std::move(ctx));
    auto err = lljit->addIRModule(std::move(tsm));
    if (err) {
        llvm::errs() << "Failed to add IR module: "
                     << llvm::toString(std::move(err)) << "\n";
        throw std::runtime_error("Failed to add IR module to JIT");
    }
}

getDataLayout()

const llvm::DataLayout & OrcJit::getDataLayout ( ) const

nodiscard

Definition at line 149 of file Jit.cpp.

                                                  {
    return lljit->getDataLayout();
}

getFunctionAddress()

void * OrcJit::getFunctionAddress

(

const std::string &

name

)

Definition at line 198 of file Jit.cpp.

                                                      {
    // Try to lookup the symbol
    auto sym = lljit->lookup(name);
    if (!sym) {
        llvm::errs() << "Failed to find symbol '" << name
                     << "': " << llvm::toString(sym.takeError()) << "\n";
        return nullptr;
    }
    return sym->toPtr<void*>();
}

getTargetTriple()

const llvm::Triple & OrcJit::getTargetTriple ( ) const

nodiscard

Definition at line 153 of file Jit.cpp.

                                                {
    return lljit->getTargetTriple();
}

---

The documentation for this class was generated from the following files:

• llvmexpr/runtime/llvm/Jit.hpp
• llvmexpr/runtime/llvm/Jit.cpp