From d36c3e79da0f253d51593304822951907a49bd65 Mon Sep 17 00:00:00 2001 From: leelee Date: Mon, 11 May 2026 19:57:38 +0800 Subject: [PATCH 1/2] JIT: remove jit dlopen global --- codon/compiler/engine.cpp | 16 ++++++--- codon/compiler/engine.h | 7 ++++ codon/compiler/jit.cpp | 74 +++++++++++++++++++++++++++++++++++++++ jit/codon/decorator.py | 3 -- 4 files changed, 93 insertions(+), 7 deletions(-) diff --git a/codon/compiler/engine.cpp b/codon/compiler/engine.cpp index 2c6e67d6d..9a272e373 100644 --- a/codon/compiler/engine.cpp +++ b/codon/compiler/engine.cpp @@ -8,7 +8,7 @@ namespace codon { namespace jit { -Engine::Engine() : jit(), debug(nullptr) { +Engine::Engine() : jit(), debug(nullptr), globalPrefix('\0') { auto eb = llvm::EngineBuilder(); eb.setMArch(llvm::codegen::getMArch()); eb.setMCPU(llvm::codegen::getCPUStr()); @@ -39,10 +39,10 @@ Engine::Engine() : jit(), debug(nullptr) { builder.setJITTargetMachineBuilder( llvm::orc::JITTargetMachineBuilder(target->getTargetTriple())); jit = llvm::cantFail(builder.create()); + globalPrefix = layout.getGlobalPrefix(); - jit->getMainJITDylib().addGenerator( - llvm::cantFail(llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess( - layout.getGlobalPrefix()))); + jit->getMainJITDylib().addGenerator(llvm::cantFail( + llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(globalPrefix))); jit->getIRTransformLayer().setTransform( [&](llvm::orc::ThreadSafeModule module, @@ -66,5 +66,13 @@ llvm::Expected Engine::lookup(llvm::StringRef name) { return jit->lookup(name); } +llvm::Error Engine::addDynamicLibrary(const std::string &path) { + auto gen = llvm::orc::DynamicLibrarySearchGenerator::Load(path.c_str(), globalPrefix); + if (!gen) + return gen.takeError(); + jit->getMainJITDylib().addGenerator(std::move(*gen)); + return llvm::Error::success(); +} + } // namespace jit } // namespace codon diff --git a/codon/compiler/engine.h b/codon/compiler/engine.h index bd1827843..a1bb66fc9 100644 --- a/codon/compiler/engine.h +++ b/codon/compiler/engine.h @@ -3,6 +3,7 @@ #pragma once #include +#include #include #include "codon/cir/llvm/llvm.h" @@ -15,6 +16,7 @@ class Engine { private: std::unique_ptr jit; DebugPlugin *debug; + char globalPrefix; public: Engine(); @@ -29,6 +31,11 @@ class Engine { llvm::orc::ResourceTrackerSP rt = nullptr); llvm::Expected lookup(llvm::StringRef name); + + /// Load a dynamic library and register it with the JIT for symbol resolution. + /// @param path Path to the dynamic library file (.so/.dll/.dylib) + /// @return llvm::Error::success() on success, error code on failure + llvm::Error addDynamicLibrary(const std::string &path); }; } // namespace jit diff --git a/codon/compiler/jit.cpp b/codon/compiler/jit.cpp index ebf6cd6ac..3c426731f 100644 --- a/codon/compiler/jit.cpp +++ b/codon/compiler/jit.cpp @@ -4,6 +4,9 @@ #include +#include "llvm/Support/FileSystem.h" +#include "llvm/Support/Path.h" + #include "codon/parser/common.h" #include "codon/parser/peg/peg.h" #include "codon/parser/visitors/doc/doc.h" @@ -374,11 +377,82 @@ JIT::JITResult JIT::executePython(const std::string &name, } } +namespace { + +#ifdef __APPLE__ +constexpr const char *kCodonRTBaseName = "libcodonrt.dylib"; +#else +constexpr const char *kCodonRTBaseName = "libcodonrt.so"; +#endif + +} // namespace + +// Locate the absolute path of the Codon runtime shared library +// (libcodonrt.so / .dylib). Tries, in order: +// 1. /../ (libcodonrt sits next to libcodonc) +// 2. / +// 3. $CODON_DIR/lib/codon/ +// 4. bare soname (let the dynamic linker resolve it) +// Returns canonicalized path on success; bare soname on failure. +std::string findCodonRuntime() { + std::vector candidates; + + const std::string libcodonc = codon::ast::library_path(); + if (!libcodonc.empty()) { + auto dir = llvm::sys::path::parent_path(libcodonc); + if (!dir.empty()) { + llvm::SmallString<256> p1(dir); + llvm::sys::path::append(p1, kCodonRTBaseName); + candidates.emplace_back(p1.str()); + + llvm::SmallString<256> p2(dir); + llvm::sys::path::append(p2, "..", "lib", "codon", kCodonRTBaseName); + candidates.emplace_back(p2.str()); + } + } + + if (const char *codonDir = std::getenv("CODON_DIR")) { + llvm::SmallString<256> p(codonDir); + llvm::sys::path::append(p, "lib", "codon", kCodonRTBaseName); + candidates.emplace_back(p.str()); + } + + for (const auto &c : candidates) { + if (!llvm::sys::fs::exists(c)) + continue; + // Canonicalize to prevent the dynamic linker from treating two different + // paths to the same physical file as distinct shared objects (which would + // otherwise cause the runtime / Boehm GC to be loaded twice). + llvm::SmallString<256> real; + if (!llvm::sys::fs::real_path(c, real)) + return std::string(real.str()); + return c; + } + + // Last resort: bare soname; rely on RUNPATH / LD_LIBRARY_PATH / ldconfig. + return std::string(kCodonRTBaseName); +} + } // namespace jit } // namespace codon void *jit_init(char *name) { auto jit = new codon::jit::JIT(std::string(name)); + + // Register libcodonrt so the JIT can resolve runtime symbols + // (seq_*, GC_*, ...) without requiring RTLD_GLOBAL on the Python + // extension. Failure here is fatal: without the runtime the JIT cannot + // link any compiled code. + const std::string rt = codon::jit::findCodonRuntime(); + if (auto err = jit->getEngine()->addDynamicLibrary(rt)) { + auto info = llvm::toString(std::move(err)); + llvm::report_fatal_error( + llvm::StringRef("cannot load codon runtime '" + rt + "': " + info), + /*gen_crash_diag=*/false); + } + if (std::getenv("CODON_JIT_DEBUG")) + fmt::print(stderr, "[codon::jit] loaded runtime: {}\n", rt); + llvm::cantFail(jit->init()); return jit; } diff --git a/jit/codon/decorator.py b/jit/codon/decorator.py index f7a33ecd9..d2773aab2 100644 --- a/jit/codon/decorator.py +++ b/jit/codon/decorator.py @@ -1,7 +1,6 @@ # Copyright (C) 2022-2026 Exaloop Inc. from argparse import ArgumentError -import ctypes import inspect import sys import os @@ -13,8 +12,6 @@ import numpy as np from pathlib import Path -sys.setdlopenflags(sys.getdlopenflags() | ctypes.RTLD_GLOBAL) - from .codon_jit import JITWrapper, JITError, codon_library if "CODON_PATH" not in os.environ: From 19184f3f2d37504011986556931d8a05a629c474 Mon Sep 17 00:00:00 2001 From: leelee Date: Wed, 20 May 2026 20:40:59 +0800 Subject: [PATCH 2/2] JIT: isolate JIT runtime symbols via explicit symbol mapping --- codon/cir/llvm/llvm.h | 2 + codon/compiler/engine.cpp | 82 ++++++++++++++++++++-- codon/compiler/engine.h | 24 ++++++- codon/compiler/jit.cpp | 13 ++-- codon/runtime/lib.cpp | 130 +++++++++++++++++++++++++++++++++++ codon/runtime/lib.h | 139 ++++++++++++++++++++++++++++++++++++++ codon/runtime/re.cpp | 6 -- 7 files changed, 377 insertions(+), 19 deletions(-) diff --git a/codon/cir/llvm/llvm.h b/codon/cir/llvm/llvm.h index ac2b54350..30cf6e3eb 100644 --- a/codon/cir/llvm/llvm.h +++ b/codon/cir/llvm/llvm.h @@ -31,6 +31,7 @@ #include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h" #include "llvm/ExecutionEngine/JITSymbol.h" #include "llvm/ExecutionEngine/MCJIT.h" +#include "llvm/ExecutionEngine/Orc/AbsoluteSymbols.h" #include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h" #include "llvm/ExecutionEngine/Orc/CompileUtils.h" #include "llvm/ExecutionEngine/Orc/Core.h" @@ -49,6 +50,7 @@ #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h" #include "llvm/ExecutionEngine/Orc/LLJIT.h" #include "llvm/ExecutionEngine/Orc/MachOPlatform.h" +#include "llvm/ExecutionEngine/Orc/Mangling.h" #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h" #include "llvm/ExecutionEngine/Orc/Shared/AllocationActions.h" #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h" diff --git a/codon/compiler/engine.cpp b/codon/compiler/engine.cpp index 9a272e373..4be366faa 100644 --- a/codon/compiler/engine.cpp +++ b/codon/compiler/engine.cpp @@ -2,12 +2,22 @@ #include "engine.h" +#include + #include "codon/cir/llvm/optimize.h" #include "codon/compiler/memory_manager.h" namespace codon { namespace jit { +namespace { + +llvm::Error makeRuntimeLoadError(const std::string &message) { + return llvm::make_error(message, llvm::inconvertibleErrorCode()); +} + +} // namespace + Engine::Engine() : jit(), debug(nullptr), globalPrefix('\0') { auto eb = llvm::EngineBuilder(); eb.setMArch(llvm::codegen::getMArch()); @@ -43,6 +53,9 @@ Engine::Engine() : jit(), debug(nullptr), globalPrefix('\0') { jit->getMainJITDylib().addGenerator(llvm::cantFail( llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(globalPrefix))); + jit->getMainJITDylib().addGenerator(llvm::cantFail( + llvm::orc::DynamicLibrarySearchGenerator::Load(kLibgcc_sName, globalPrefix))); + tryAddDynamicLibrarySearchGenerator(kLibstdcxxName); jit->getIRTransformLayer().setTransform( [&](llvm::orc::ThreadSafeModule module, @@ -54,6 +67,12 @@ Engine::Engine() : jit(), debug(nullptr), globalPrefix('\0') { }); } +Engine::~Engine() { + jit.reset(); + for (auto *handle : runtimeHandles) + dlclose(handle); +} + llvm::Error Engine::addModule(llvm::orc::ThreadSafeModule module, llvm::orc::ResourceTrackerSP rt) { if (!rt) @@ -66,11 +85,66 @@ llvm::Expected Engine::lookup(llvm::StringRef name) { return jit->lookup(name); } -llvm::Error Engine::addDynamicLibrary(const std::string &path) { - auto gen = llvm::orc::DynamicLibrarySearchGenerator::Load(path.c_str(), globalPrefix); - if (!gen) - return gen.takeError(); +llvm::Error Engine::registerSymbols( + llvm::function_ref symbolMap) { + auto &mainJitDylib = jit->getMainJITDylib(); + return mainJitDylib.define( + llvm::orc::absoluteSymbols(symbolMap(llvm::orc::MangleAndInterner( + mainJitDylib.getExecutionSession(), jit->getDataLayout())))); +} + +void Engine::tryAddDynamicLibrarySearchGenerator(const char *path) { + auto gen = llvm::orc::DynamicLibrarySearchGenerator::Load(path, globalPrefix); + if (!gen) { + llvm::consumeError(gen.takeError()); + return; + } jit->getMainJITDylib().addGenerator(std::move(*gen)); +} + +llvm::Error Engine::addRuntimeSymbolMap(const std::string &path) { + void *handle = dlopen(path.c_str(), RTLD_NOW | RTLD_LOCAL); + if (!handle) { + const char *err = dlerror(); + return makeRuntimeLoadError("cannot load codon runtime '" + path + + "': " + (err ? err : "unknown error")); + } + + llvm::sys::DynamicLibrary lib(handle); + void *initSym = lib.getAddressOfSymbol(kRuntimeInitFnName); + + if (!initSym) { + const char *err = dlerror(); + dlclose(handle); + return makeRuntimeLoadError("cannot find " + std::string(kRuntimeInitFnName) + + " in '" + path + "': " + (err ? err : "unknown error")); + } + + RuntimeSymbolMap runtimeSymbols; + auto initFn = reinterpret_cast(initSym); + initFn( + [](void *ctx, const char *name, void *address) { + if (!ctx || !name || !address) + return; + auto *symbols = static_cast(ctx); + (*symbols)[name] = address; + }, + &runtimeSymbols); + + // Build a runtime symbol map from the exported symbols and register them. + auto runtimeSymbolMap = [&](llvm::orc::MangleAndInterner interner) { + auto symbolMap = llvm::orc::SymbolMap(); + for (auto &[name, address] : runtimeSymbols) + symbolMap[interner(name)] = {llvm::orc::ExecutorAddr::fromPtr(address), + llvm::JITSymbolFlags::Exported}; + return symbolMap; + }; + if (auto err = registerSymbols(runtimeSymbolMap)) { + dlclose(handle); + return err; + } + + runtimeHandles.push_back(handle); return llvm::Error::success(); } diff --git a/codon/compiler/engine.h b/codon/compiler/engine.h index a1bb66fc9..21f9543f8 100644 --- a/codon/compiler/engine.h +++ b/codon/compiler/engine.h @@ -2,6 +2,7 @@ #pragma once +#include #include #include #include @@ -14,12 +15,29 @@ namespace jit { class Engine { private: + constexpr static const char *kLibgcc_sName = "libgcc_s.so.1"; + constexpr static const char *kLibstdcxxName = "libstdc++.so.6"; + constexpr static const char *kRuntimeInitFnName = "__codon_jit_runtime_init"; + + using RuntimeSymbolMap = std::map; + using RuntimeAddSymbolFunc = void (*)(void *, const char *, void *); + using RuntimeInitFunc = void (*)(RuntimeAddSymbolFunc, void *); + std::unique_ptr jit; DebugPlugin *debug; char globalPrefix; + std::vector runtimeHandles; + + /// Register symbols with this Engine. + llvm::Error registerSymbols( + llvm::function_ref symbolMap); + + /// Best-effort dynamic library search generator registration. + void tryAddDynamicLibrarySearchGenerator(const char *path); public: Engine(); + ~Engine(); const llvm::DataLayout &getDataLayout() const { return jit->getDataLayout(); } @@ -32,10 +50,10 @@ class Engine { llvm::Expected lookup(llvm::StringRef name); - /// Load a dynamic library and register it with the JIT for symbol resolution. - /// @param path Path to the dynamic library file (.so/.dll/.dylib) + /// Load the Codon runtime locally and register its JIT symbol map with ORC. + /// @param path Path to the Codon runtime library file (.so/.dll/.dylib) /// @return llvm::Error::success() on success, error code on failure - llvm::Error addDynamicLibrary(const std::string &path); + llvm::Error addRuntimeSymbolMap(const std::string &path); }; } // namespace jit diff --git a/codon/compiler/jit.cpp b/codon/compiler/jit.cpp index 3c426731f..94ba9c1a1 100644 --- a/codon/compiler/jit.cpp +++ b/codon/compiler/jit.cpp @@ -439,15 +439,16 @@ std::string findCodonRuntime() { void *jit_init(char *name) { auto jit = new codon::jit::JIT(std::string(name)); - // Register libcodonrt so the JIT can resolve runtime symbols - // (seq_*, GC_*, ...) without requiring RTLD_GLOBAL on the Python - // extension. Failure here is fatal: without the runtime the JIT cannot - // link any compiled code. + // Register Codon runtime symbols with ORC using the runtime-provided symbol map. + // The runtime is loaded locally so its symbols do not leak into the + // process-global symbol table. Failure here is fatal: without the runtime the JIT + // cannot link any compiled code. const std::string rt = codon::jit::findCodonRuntime(); - if (auto err = jit->getEngine()->addDynamicLibrary(rt)) { + if (auto err = jit->getEngine()->addRuntimeSymbolMap(rt)) { auto info = llvm::toString(std::move(err)); llvm::report_fatal_error( - llvm::StringRef("cannot load codon runtime '" + rt + "': " + info), + llvm::StringRef("cannot register codon runtime symbols from '" + rt + + "': " + info), /*gen_crash_diag=*/false); } if (std::getenv("CODON_JIT_DEBUG")) diff --git a/codon/runtime/lib.cpp b/codon/runtime/lib.cpp index ef09c126d..7f196ef41 100644 --- a/codon/runtime/lib.cpp +++ b/codon/runtime/lib.cpp @@ -375,3 +375,133 @@ SEQ_FUNC void seq_rlock_release(void *lock) { auto *m = (std::recursive_timed_mutex *)lock; m->unlock(); } + +#define CODON_JIT_SYMBOL(name) addSymbol(ctx, #name, reinterpret_cast(&name)) + +SEQ_FUNC void __codon_jit_runtime_init(CodonJITAddSymbolFunc addSymbol, void *ctx) { + if (!addSymbol) + return; + + CODON_JIT_SYMBOL(seq_alloc_exc); + CODON_JIT_SYMBOL(seq_terminate); + CODON_JIT_SYMBOL(seq_throw); + CODON_JIT_SYMBOL(seq_personality); + CODON_JIT_SYMBOL(seq_exc_offset); + CODON_JIT_SYMBOL(seq_init); + CODON_JIT_SYMBOL(seq_pid); + CODON_JIT_SYMBOL(seq_time); + CODON_JIT_SYMBOL(seq_time_monotonic); + CODON_JIT_SYMBOL(seq_time_highres); + CODON_JIT_SYMBOL(seq_localtime); + CODON_JIT_SYMBOL(seq_gmtime); + CODON_JIT_SYMBOL(seq_mktime); + CODON_JIT_SYMBOL(seq_sleep); + CODON_JIT_SYMBOL(seq_env); + CODON_JIT_SYMBOL(seq_alloc); + CODON_JIT_SYMBOL(seq_alloc_atomic); + CODON_JIT_SYMBOL(seq_alloc_uncollectable); + CODON_JIT_SYMBOL(seq_alloc_atomic_uncollectable); + CODON_JIT_SYMBOL(seq_realloc); + CODON_JIT_SYMBOL(seq_free); + CODON_JIT_SYMBOL(seq_register_finalizer); + CODON_JIT_SYMBOL(seq_gc_add_roots); + CODON_JIT_SYMBOL(seq_gc_remove_roots); + CODON_JIT_SYMBOL(seq_gc_clear_roots); + CODON_JIT_SYMBOL(seq_gc_exclude_static_roots); + CODON_JIT_SYMBOL(seq_str_int); + CODON_JIT_SYMBOL(seq_str_uint); + CODON_JIT_SYMBOL(seq_str_float); + CODON_JIT_SYMBOL(seq_str_ptr); + CODON_JIT_SYMBOL(seq_str_str); + CODON_JIT_SYMBOL(seq_float_from_str); + CODON_JIT_SYMBOL(seq_check_errno); + CODON_JIT_SYMBOL(seq_print); + CODON_JIT_SYMBOL(seq_print_full); + CODON_JIT_SYMBOL(seq_stdin); + CODON_JIT_SYMBOL(seq_stdout); + CODON_JIT_SYMBOL(seq_stderr); + CODON_JIT_SYMBOL(seq_lock_new); + CODON_JIT_SYMBOL(seq_lock_acquire); + CODON_JIT_SYMBOL(seq_lock_release); + CODON_JIT_SYMBOL(seq_rlock_new); + CODON_JIT_SYMBOL(seq_rlock_acquire); + CODON_JIT_SYMBOL(seq_rlock_release); + + CODON_JIT_SYMBOL(cnp_acos_float32); + CODON_JIT_SYMBOL(cnp_acos_float64); + CODON_JIT_SYMBOL(cnp_acosh_float32); + CODON_JIT_SYMBOL(cnp_acosh_float64); + CODON_JIT_SYMBOL(cnp_asin_float32); + CODON_JIT_SYMBOL(cnp_asin_float64); + CODON_JIT_SYMBOL(cnp_asinh_float32); + CODON_JIT_SYMBOL(cnp_asinh_float64); + CODON_JIT_SYMBOL(cnp_atan_float32); + CODON_JIT_SYMBOL(cnp_atan_float64); + CODON_JIT_SYMBOL(cnp_atanh_float32); + CODON_JIT_SYMBOL(cnp_atanh_float64); + CODON_JIT_SYMBOL(cnp_atan2_float32); + CODON_JIT_SYMBOL(cnp_atan2_float64); + CODON_JIT_SYMBOL(cnp_cos_float32); + CODON_JIT_SYMBOL(cnp_cos_float64); + CODON_JIT_SYMBOL(cnp_exp_float32); + CODON_JIT_SYMBOL(cnp_exp_float64); + CODON_JIT_SYMBOL(cnp_exp2_float32); + CODON_JIT_SYMBOL(cnp_exp2_float64); + CODON_JIT_SYMBOL(cnp_expm1_float32); + CODON_JIT_SYMBOL(cnp_expm1_float64); + CODON_JIT_SYMBOL(cnp_log_float32); + CODON_JIT_SYMBOL(cnp_log_float64); + CODON_JIT_SYMBOL(cnp_log10_float32); + CODON_JIT_SYMBOL(cnp_log10_float64); + CODON_JIT_SYMBOL(cnp_log1p_float32); + CODON_JIT_SYMBOL(cnp_log1p_float64); + CODON_JIT_SYMBOL(cnp_log2_float32); + CODON_JIT_SYMBOL(cnp_log2_float64); + CODON_JIT_SYMBOL(cnp_sin_float32); + CODON_JIT_SYMBOL(cnp_sin_float64); + CODON_JIT_SYMBOL(cnp_sinh_float32); + CODON_JIT_SYMBOL(cnp_sinh_float64); + CODON_JIT_SYMBOL(cnp_tanh_float32); + CODON_JIT_SYMBOL(cnp_tanh_float64); + CODON_JIT_SYMBOL(cnp_hypot_float32); + CODON_JIT_SYMBOL(cnp_hypot_float64); + + CODON_JIT_SYMBOL(cnp_sort_int16); + CODON_JIT_SYMBOL(cnp_sort_uint16); + CODON_JIT_SYMBOL(cnp_sort_int32); + CODON_JIT_SYMBOL(cnp_sort_uint32); + CODON_JIT_SYMBOL(cnp_sort_int64); + CODON_JIT_SYMBOL(cnp_sort_uint64); + CODON_JIT_SYMBOL(cnp_sort_uint128); + CODON_JIT_SYMBOL(cnp_sort_float32); + CODON_JIT_SYMBOL(cnp_sort_float64); + + CODON_JIT_SYMBOL(cnp_cexpf); + CODON_JIT_SYMBOL(cnp_clogf); + CODON_JIT_SYMBOL(cnp_csqrtf); + CODON_JIT_SYMBOL(cnp_ccoshf); + CODON_JIT_SYMBOL(cnp_csinhf); + CODON_JIT_SYMBOL(cnp_ctanhf); + CODON_JIT_SYMBOL(cnp_cacoshf); + CODON_JIT_SYMBOL(cnp_casinhf); + CODON_JIT_SYMBOL(cnp_catanhf); + CODON_JIT_SYMBOL(cnp_ccosf); + CODON_JIT_SYMBOL(cnp_csinf); + CODON_JIT_SYMBOL(cnp_ctanf); + CODON_JIT_SYMBOL(cnp_cacosf); + CODON_JIT_SYMBOL(cnp_casinf); + CODON_JIT_SYMBOL(cnp_catanf); + + CODON_JIT_SYMBOL(seq_re_match); + CODON_JIT_SYMBOL(seq_re_match_one); + CODON_JIT_SYMBOL(seq_re_escape); + CODON_JIT_SYMBOL(seq_re_compile); + CODON_JIT_SYMBOL(seq_re_purge); + CODON_JIT_SYMBOL(seq_re_pattern_groups); + CODON_JIT_SYMBOL(seq_re_group_name_to_index); + CODON_JIT_SYMBOL(seq_re_group_index_to_name); + CODON_JIT_SYMBOL(seq_re_check_rewrite_string); + CODON_JIT_SYMBOL(seq_re_pattern_error); +} + +#undef CODON_JIT_SYMBOL diff --git a/codon/runtime/lib.h b/codon/runtime/lib.h index 6aebe29d0..96bb9ffed 100644 --- a/codon/runtime/lib.h +++ b/codon/runtime/lib.h @@ -23,6 +23,18 @@ typedef int64_t seq_int_t; +using CodonJITAddSymbolFunc = void (*)(void *, const char *, void *); + +namespace re2 { +class RE2; +} + +namespace hwy { +struct uint128_t; +} + +using Regex = re2::RE2; + struct seq_str_t { seq_int_t len; char *str; @@ -40,6 +52,11 @@ struct seq_time_t { int8_t isdst; }; +struct Span { + seq_int_t start; + seq_int_t end; +}; + SEQ_FUNC int seq_flags; SEQ_FUNC void seq_init(int flags); @@ -69,6 +86,7 @@ SEQ_FUNC void seq_gc_clear_roots(); SEQ_FUNC void seq_gc_exclude_static_roots(void *start, void *end); SEQ_FUNC void *seq_alloc_exc(void *obj); +SEQ_FUNC void seq_terminate(void *exc); SEQ_FUNC void seq_throw(void *exc); SEQ_FUNC _Unwind_Reason_Code seq_personality(int version, _Unwind_Action actions, uint64_t exceptionClass, @@ -81,6 +99,8 @@ SEQ_FUNC seq_str_t seq_str_uint(seq_int_t n, seq_str_t format, bool *error); SEQ_FUNC seq_str_t seq_str_float(double f, seq_str_t format, bool *error); SEQ_FUNC seq_str_t seq_str_ptr(void *p, seq_str_t format, bool *error); SEQ_FUNC seq_str_t seq_str_str(seq_str_t s, seq_str_t format, bool *error); +SEQ_FUNC double seq_float_from_str(seq_str_t s, const char **e); +SEQ_FUNC seq_str_t seq_check_errno(); SEQ_FUNC void *seq_stdin(); SEQ_FUNC void *seq_stdout(); @@ -96,6 +116,125 @@ SEQ_FUNC void *seq_rlock_new(); SEQ_FUNC bool seq_rlock_acquire(void *lock, bool block, double timeout); SEQ_FUNC void seq_rlock_release(void *lock); +SEQ_FUNC void cnp_acos_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_acos_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_acosh_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_acosh_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_asin_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_asin_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_asinh_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_asinh_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_atan_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_atan_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_atanh_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_atanh_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_atan2_float32(const float *in1, size_t is1, const float *in2, + size_t is2, float *out, size_t os, size_t n); +SEQ_FUNC void cnp_atan2_float64(const double *in1, size_t is1, const double *in2, + size_t is2, double *out, size_t os, size_t n); +SEQ_FUNC void cnp_cos_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_cos_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_exp_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_exp_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_exp2_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_exp2_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_expm1_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_expm1_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_log_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_log_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_log10_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_log10_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_log1p_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_log1p_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_log2_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_log2_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_sin_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_sin_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_sinh_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_sinh_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_tanh_float32(const float *in, size_t is, float *out, size_t os, + size_t n); +SEQ_FUNC void cnp_tanh_float64(const double *in, size_t is, double *out, size_t os, + size_t n); +SEQ_FUNC void cnp_hypot_float32(const float *in1, size_t is1, const float *in2, + size_t is2, float *out, size_t os, size_t n); +SEQ_FUNC void cnp_hypot_float64(const double *in1, size_t is1, const double *in2, + size_t is2, double *out, size_t os, size_t n); + +SEQ_FUNC void cnp_sort_int16(int16_t *data, int64_t n); +SEQ_FUNC void cnp_sort_uint16(uint16_t *data, int64_t n); +SEQ_FUNC void cnp_sort_int32(int32_t *data, int64_t n); +SEQ_FUNC void cnp_sort_uint32(uint32_t *data, int64_t n); +SEQ_FUNC void cnp_sort_int64(int64_t *data, int64_t n); +SEQ_FUNC void cnp_sort_uint64(uint64_t *data, int64_t n); +SEQ_FUNC void cnp_sort_uint128(hwy::uint128_t *data, int64_t n); +SEQ_FUNC void cnp_sort_float32(float *data, int64_t n); +SEQ_FUNC void cnp_sort_float64(double *data, int64_t n); + +SEQ_FUNC void cnp_cexpf(float r, float i, float *z); +SEQ_FUNC void cnp_clogf(float r, float i, float *z); +SEQ_FUNC void cnp_csqrtf(float r, float i, float *z); +SEQ_FUNC void cnp_ccoshf(float r, float i, float *z); +SEQ_FUNC void cnp_csinhf(float r, float i, float *z); +SEQ_FUNC void cnp_ctanhf(float r, float i, float *z); +SEQ_FUNC void cnp_cacoshf(float r, float i, float *z); +SEQ_FUNC void cnp_casinhf(float r, float i, float *z); +SEQ_FUNC void cnp_catanhf(float r, float i, float *z); +SEQ_FUNC void cnp_ccosf(float r, float i, float *z); +SEQ_FUNC void cnp_csinf(float r, float i, float *z); +SEQ_FUNC void cnp_ctanf(float r, float i, float *z); +SEQ_FUNC void cnp_cacosf(float r, float i, float *z); +SEQ_FUNC void cnp_casinf(float r, float i, float *z); +SEQ_FUNC void cnp_catanf(float r, float i, float *z); + +SEQ_FUNC Span *seq_re_match(Regex *re, seq_int_t anchor, seq_str_t s, seq_int_t pos, + seq_int_t endpos); +SEQ_FUNC Span seq_re_match_one(Regex *re, seq_int_t anchor, seq_str_t s, seq_int_t pos, + seq_int_t endpos); +SEQ_FUNC seq_str_t seq_re_escape(seq_str_t p); +SEQ_FUNC Regex *seq_re_compile(seq_str_t p, seq_int_t flags); +SEQ_FUNC void seq_re_purge(); +SEQ_FUNC seq_int_t seq_re_pattern_groups(Regex *pattern); +SEQ_FUNC seq_int_t seq_re_group_name_to_index(Regex *pattern, seq_str_t name); +SEQ_FUNC seq_str_t seq_re_group_index_to_name(Regex *pattern, seq_int_t index); +SEQ_FUNC bool seq_re_check_rewrite_string(Regex *pattern, seq_str_t rewrite, + seq_str_t *error); +SEQ_FUNC seq_str_t seq_re_pattern_error(Regex *pattern); + +SEQ_FUNC void __codon_jit_runtime_init(CodonJITAddSymbolFunc addSymbol, void *ctx); + namespace codon { namespace runtime { class JITError : public std::runtime_error { diff --git a/codon/runtime/re.cpp b/codon/runtime/re.cpp index 74437698e..47a3a5c7d 100644 --- a/codon/runtime/re.cpp +++ b/codon/runtime/re.cpp @@ -9,7 +9,6 @@ #include #include -using Regex = re2::RE2; using re2::StringPiece; /* @@ -64,11 +63,6 @@ static inline Regex::Options flags2opt(seq_int_t flags) { * Internal helpers & utilities */ -struct Span { - seq_int_t start; - seq_int_t end; -}; - template struct GCMapAllocator : public std::allocator { GCMapAllocator() = default; GCMapAllocator(GCMapAllocator const &) = default;