llvmjit.c File Reference

#include "postgres.h"
#include <llvm-c/Analysis.h>
#include <llvm-c/BitReader.h>
#include <llvm-c/BitWriter.h>
#include <llvm-c/Core.h>
#include <llvm-c/ExecutionEngine.h>
#include <llvm-c/Orc.h>
#include <llvm-c/OrcEE.h>
#include <llvm-c/LLJIT.h>
#include <llvm-c/Support.h>
#include <llvm-c/Target.h>
#include <llvm-c/Transforms/IPO.h>
#include <llvm-c/Transforms/PassManagerBuilder.h>
#include <llvm-c/Transforms/Scalar.h>
#include <llvm-c/Transforms/Utils.h>
#include "jit/llvmjit.h"
#include "jit/llvmjit_emit.h"
#include "miscadmin.h"
#include "portability/instr_time.h"
#include "storage/ipc.h"
#include "utils/memutils.h"
#include "utils/resowner.h"

Include dependency graph for llvmjit.c:

Go to the source code of this file.

Data Structures
struct	LLVMJitHandle

Macros
#define	LLVMJIT_LLVM_CONTEXT_REUSE_MAX   100

Typedefs
typedef struct LLVMJitHandle	LLVMJitHandle

Functions
static void	llvm_release_context (JitContext *context)
static void	llvm_session_initialize (void)
static void	llvm_shutdown (int code, Datum arg)
static void	llvm_compile_module (LLVMJitContext *context)
static void	llvm_optimize_module (LLVMJitContext *context, LLVMModuleRef module)
static void	llvm_create_types (void)
static void	llvm_set_target (void)
static void	llvm_recreate_llvm_context (void)
static uint64_t	llvm_resolve_symbol (const char *name, void *ctx)
static LLVMOrcLLJITRef	llvm_create_jit_instance (LLVMTargetMachineRef tm)
static char *	llvm_error_message (LLVMErrorRef error)
static void	ResOwnerReleaseJitContext (Datum res)
static void	ResourceOwnerRememberJIT (ResourceOwner owner, LLVMJitContext *handle)
static void	ResourceOwnerForgetJIT (ResourceOwner owner, LLVMJitContext *handle)
void	_PG_jit_provider_init (JitProviderCallbacks *cb)
LLVMJitContext *	llvm_create_context (int jitFlags)
LLVMModuleRef	llvm_mutable_module (LLVMJitContext *context)
char *	llvm_expand_funcname (struct LLVMJitContext *context, const char *basename)
void *	llvm_get_function (LLVMJitContext *context, const char *funcname)
LLVMTypeRef	llvm_pg_var_type (const char *varname)
LLVMTypeRef	llvm_pg_var_func_type (const char *varname)
LLVMValueRef	llvm_pg_func (LLVMModuleRef mod, const char *funcname)
static void	llvm_copy_attributes_at_index (LLVMValueRef v_from, LLVMValueRef v_to, uint32 index)
void	llvm_copy_attributes (LLVMValueRef v_from, LLVMValueRef v_to)
LLVMValueRef	llvm_function_reference (LLVMJitContext *context, LLVMBuilderRef builder, LLVMModuleRef mod, FunctionCallInfo fcinfo)
static LLVMTypeRef	load_return_type (LLVMModuleRef mod, const char *name)
void	llvm_split_symbol_name (const char *name, char **modname, char **funcname)
static LLVMErrorRef	llvm_resolve_symbols (LLVMOrcDefinitionGeneratorRef GeneratorObj, void *Ctx, LLVMOrcLookupStateRef *LookupState, LLVMOrcLookupKind Kind, LLVMOrcJITDylibRef JD, LLVMOrcJITDylibLookupFlags JDLookupFlags, LLVMOrcCLookupSet LookupSet, size_t LookupSetSize)
static void	llvm_log_jit_error (void *ctx, LLVMErrorRef error)
static LLVMOrcObjectLayerRef	llvm_create_object_layer (void *Ctx, LLVMOrcExecutionSessionRef ES, const char *Triple)

Variables
LLVMTypeRef	TypeSizeT
LLVMTypeRef	TypeParamBool
LLVMTypeRef	TypeStorageBool
LLVMTypeRef	TypePGFunction
LLVMTypeRef	StructNullableDatum
LLVMTypeRef	StructHeapTupleData
LLVMTypeRef	StructMinimalTupleData
LLVMTypeRef	StructTupleDescData
LLVMTypeRef	StructTupleTableSlot
LLVMTypeRef	StructHeapTupleHeaderData
LLVMTypeRef	StructHeapTupleTableSlot
LLVMTypeRef	StructMinimalTupleTableSlot
LLVMTypeRef	StructMemoryContextData
LLVMTypeRef	StructFunctionCallInfoData
LLVMTypeRef	StructExprContext
LLVMTypeRef	StructExprEvalStep
LLVMTypeRef	StructExprState
LLVMTypeRef	StructAggState
LLVMTypeRef	StructAggStatePerGroupData
LLVMTypeRef	StructAggStatePerTransData
LLVMTypeRef	StructPlanState
LLVMValueRef	AttributeTemplate
LLVMValueRef	ExecEvalSubroutineTemplate
LLVMValueRef	ExecEvalBoolSubroutineTemplate
static LLVMModuleRef	llvm_types_module = NULL
static bool	llvm_session_initialized = false
static size_t	llvm_generation = 0
static size_t	llvm_jit_context_in_use_count = 0
static size_t	llvm_llvm_context_reuse_count = 0
static const char *	llvm_triple = NULL
static const char *	llvm_layout = NULL
static LLVMContextRef	llvm_context
static LLVMTargetRef	llvm_targetref
static LLVMOrcThreadSafeContextRef	llvm_ts_context
static LLVMOrcLLJITRef	llvm_opt0_orc
static LLVMOrcLLJITRef	llvm_opt3_orc
static const ResourceOwnerDesc	jit_resowner_desc
	PG_MODULE_MAGIC

Macro Definition Documentation

LLVMJIT_LLVM_CONTEXT_REUSE_MAX

#define LLVMJIT_LLVM_CONTEXT_REUSE_MAX   100

Definition at line 44 of file llvmjit.c.

Typedef Documentation

LLVMJitHandle

typedef struct LLVMJitHandle LLVMJitHandle

Function Documentation

_PG_jit_provider_init()

void _PG_jit_provider_init

(

JitProviderCallbacks *

cb

)

Definition at line 147 of file llvmjit.c.

{
    cb->reset_after_error = llvm_reset_after_error;
    cb->release_context = llvm_release_context;
    cb->compile_expr = llvm_compile_expr;
}

References JitProviderCallbacks::compile_expr, llvm_compile_expr(), llvm_release_context(), llvm_reset_after_error(), JitProviderCallbacks::release_context, and JitProviderCallbacks::reset_after_error.

llvm_compile_module()

static void llvm_compile_module ( LLVMJitContext *  context )

static

Definition at line 701 of file llvmjit.c.

{
    LLVMJitHandle *handle;
    MemoryContext oldcontext;
    instr_time  starttime;
    instr_time  endtime;
    LLVMOrcLLJITRef compile_orc;
 
    if (context->base.flags & PGJIT_OPT3)
        compile_orc = llvm_opt3_orc;
    else
        compile_orc = llvm_opt0_orc;
 
    /* perform inlining */
    if (context->base.flags & PGJIT_INLINE)
    {
        INSTR_TIME_SET_CURRENT(starttime);
        llvm_inline(context->module);
        INSTR_TIME_SET_CURRENT(endtime);
        INSTR_TIME_ACCUM_DIFF(context->base.instr.inlining_counter,
                              endtime, starttime);
    }
 
    if (jit_dump_bitcode)
    {
        char       *filename;
 
        filename = psprintf("%d.%zu.bc",
                            MyProcPid,
                            context->module_generation);
        LLVMWriteBitcodeToFile(context->module, filename);
        pfree(filename);
    }
 
 
    /* optimize according to the chosen optimization settings */
    INSTR_TIME_SET_CURRENT(starttime);
    llvm_optimize_module(context, context->module);
    INSTR_TIME_SET_CURRENT(endtime);
    INSTR_TIME_ACCUM_DIFF(context->base.instr.optimization_counter,
                          endtime, starttime);
 
    if (jit_dump_bitcode)
    {
        char       *filename;
 
        filename = psprintf("%d.%zu.optimized.bc",
                            MyProcPid,
                            context->module_generation);
        LLVMWriteBitcodeToFile(context->module, filename);
        pfree(filename);
    }
 
    handle = (LLVMJitHandle *)
        MemoryContextAlloc(TopMemoryContext, sizeof(LLVMJitHandle));
 
    /*
     * Emit the code. Note that this can, depending on the optimization
     * settings, take noticeable resources as code emission executes low-level
     * instruction combining/selection passes etc. Without optimization a
     * faster instruction selection mechanism is used.
     */
    INSTR_TIME_SET_CURRENT(starttime);
    {
        LLVMOrcThreadSafeModuleRef ts_module;
        LLVMErrorRef error;
        LLVMOrcJITDylibRef jd = LLVMOrcLLJITGetMainJITDylib(compile_orc);
 
        ts_module = LLVMOrcCreateNewThreadSafeModule(context->module, llvm_ts_context);
 
        handle->lljit = compile_orc;
        handle->resource_tracker = LLVMOrcJITDylibCreateResourceTracker(jd);
 
        /*
         * NB: This doesn't actually emit code. That happens lazily the first
         * time a symbol defined in the module is requested. Due to that
         * llvm_get_function() also accounts for emission time.
         */
 
        context->module = NULL; /* will be owned by LLJIT */
        error = LLVMOrcLLJITAddLLVMIRModuleWithRT(compile_orc,
                                                  handle->resource_tracker,
                                                  ts_module);
 
        if (error)
            elog(ERROR, "failed to JIT module: %s",
                 llvm_error_message(error));
 
        /* LLVMOrcLLJITAddLLVMIRModuleWithRT takes ownership of the module */
    }
 
    INSTR_TIME_SET_CURRENT(endtime);
    INSTR_TIME_ACCUM_DIFF(context->base.instr.emission_counter,
                          endtime, starttime);
 
    context->module = NULL;
    context->compiled = true;
 
    /* remember emitted code for cleanup and lookups */
    oldcontext = MemoryContextSwitchTo(TopMemoryContext);
    context->handles = lappend(context->handles, handle);
    MemoryContextSwitchTo(oldcontext);
 
    ereport(DEBUG1,
            (errmsg_internal("time to inline: %.3fs, opt: %.3fs, emit: %.3fs",
                             INSTR_TIME_GET_DOUBLE(context->base.instr.inlining_counter),
                             INSTR_TIME_GET_DOUBLE(context->base.instr.optimization_counter),
                             INSTR_TIME_GET_DOUBLE(context->base.instr.emission_counter)),
             errhidestmt(true),
             errhidecontext(true)));
}

References context, DEBUG1, elog, ereport, errhidecontext(), errhidestmt(), errmsg_internal(), ERROR, error(), filename, INSTR_TIME_ACCUM_DIFF, INSTR_TIME_GET_DOUBLE, INSTR_TIME_SET_CURRENT, jit_dump_bitcode, lappend(), LLVMJitHandle::lljit, llvm_error_message(), llvm_inline(), llvm_opt0_orc, llvm_opt3_orc, llvm_optimize_module(), llvm_ts_context, MemoryContextAlloc(), MemoryContextSwitchTo(), MyProcPid, pfree(), PGJIT_INLINE, PGJIT_OPT3, psprintf(), LLVMJitHandle::resource_tracker, and TopMemoryContext.

Referenced by llvm_get_function().

llvm_copy_attributes()

void llvm_copy_attributes	(	LLVMValueRef	v_from,
		LLVMValueRef	v_to
	)

Definition at line 512 of file llvmjit.c.

{
    uint32      param_count;
 
    /* copy function attributes */
    llvm_copy_attributes_at_index(v_from, v_to, LLVMAttributeFunctionIndex);
 
    if (LLVMGetTypeKind(LLVMGetFunctionReturnType(v_to)) != LLVMVoidTypeKind)
    {
        /* and the return value attributes */
        llvm_copy_attributes_at_index(v_from, v_to, LLVMAttributeReturnIndex);
    }
 
    /* and each function parameter's attribute */
    param_count = LLVMCountParams(v_from);
 
    for (int paramidx = 1; paramidx <= param_count; paramidx++)
        llvm_copy_attributes_at_index(v_from, v_to, paramidx);
}

References llvm_copy_attributes_at_index(), and LLVMGetFunctionReturnType().

Referenced by llvm_pg_func(), and slot_compile_deform().

llvm_copy_attributes_at_index()

static void llvm_copy_attributes_at_index ( LLVMValueRef  v_from, LLVMValueRef  v_to, uint32  index  )

static

Definition at line 488 of file llvmjit.c.

{
    int         num_attributes;
    LLVMAttributeRef *attrs;
 
    num_attributes = LLVMGetAttributeCountAtIndex(v_from, index);
 
    if (num_attributes == 0)
        return;
 
    attrs = palloc(sizeof(LLVMAttributeRef) * num_attributes);
    LLVMGetAttributesAtIndex(v_from, index, attrs);
 
    for (int attno = 0; attno < num_attributes; attno++)
        LLVMAddAttributeAtIndex(v_to, index, attrs[attno]);
 
    pfree(attrs);
}

References palloc(), and pfree().

Referenced by llvm_copy_attributes().

llvm_create_context()

LLVMJitContext* llvm_create_context

(

int

jitFlags

)

Definition at line 219 of file llvmjit.c.

{
    LLVMJitContext *context;
 
    llvm_assert_in_fatal_section();
 
    llvm_session_initialize();
 
    llvm_recreate_llvm_context();
 
    ResourceOwnerEnlarge(CurrentResourceOwner);
 
    context = MemoryContextAllocZero(TopMemoryContext,
                                     sizeof(LLVMJitContext));
    context->base.flags = jitFlags;
 
    /* ensure cleanup */
    context->resowner = CurrentResourceOwner;
    ResourceOwnerRememberJIT(CurrentResourceOwner, context);
 
    llvm_jit_context_in_use_count++;
 
    return context;
}

References context, CurrentResourceOwner, llvm_assert_in_fatal_section(), llvm_jit_context_in_use_count, llvm_recreate_llvm_context(), llvm_session_initialize(), MemoryContextAllocZero(), ResourceOwnerEnlarge(), ResourceOwnerRememberJIT(), and TopMemoryContext.

Referenced by llvm_compile_expr().

llvm_create_jit_instance()

static LLVMOrcLLJITRef llvm_create_jit_instance ( LLVMTargetMachineRef  tm )

static

Definition at line 1198 of file llvmjit.c.

{
    LLVMOrcLLJITRef lljit;
    LLVMOrcJITTargetMachineBuilderRef tm_builder;
    LLVMOrcLLJITBuilderRef lljit_builder;
    LLVMErrorRef error;
    LLVMOrcDefinitionGeneratorRef main_gen;
    LLVMOrcDefinitionGeneratorRef ref_gen;
 
    lljit_builder = LLVMOrcCreateLLJITBuilder();
    tm_builder = LLVMOrcJITTargetMachineBuilderCreateFromTargetMachine(tm);
    LLVMOrcLLJITBuilderSetJITTargetMachineBuilder(lljit_builder, tm_builder);
 
    LLVMOrcLLJITBuilderSetObjectLinkingLayerCreator(lljit_builder,
                                                    llvm_create_object_layer,
                                                    NULL);
 
    error = LLVMOrcCreateLLJIT(&lljit, lljit_builder);
    if (error)
        elog(ERROR, "failed to create lljit instance: %s",
             llvm_error_message(error));
 
    LLVMOrcExecutionSessionSetErrorReporter(LLVMOrcLLJITGetExecutionSession(lljit),
                                            llvm_log_jit_error, NULL);
 
    /*
     * Symbol resolution support for symbols in the postgres binary /
     * libraries already loaded.
     */
    error = LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess(&main_gen,
                                                                 LLVMOrcLLJITGetGlobalPrefix(lljit),
                                                                 0, NULL);
    if (error)
        elog(ERROR, "failed to create generator: %s",
             llvm_error_message(error));
    LLVMOrcJITDylibAddGenerator(LLVMOrcLLJITGetMainJITDylib(lljit), main_gen);
 
    /*
     * Symbol resolution support for "special" functions, e.g. a call into an
     * SQL callable function.
     */
#if LLVM_VERSION_MAJOR > 14
    ref_gen = LLVMOrcCreateCustomCAPIDefinitionGenerator(llvm_resolve_symbols, NULL, NULL);
#else
    ref_gen = LLVMOrcCreateCustomCAPIDefinitionGenerator(llvm_resolve_symbols, NULL);
#endif
    LLVMOrcJITDylibAddGenerator(LLVMOrcLLJITGetMainJITDylib(lljit), ref_gen);
 
    return lljit;
}

References elog, ERROR, error(), llvm_create_object_layer(), llvm_error_message(), llvm_log_jit_error(), llvm_resolve_symbols(), and tm.

Referenced by llvm_session_initialize().

llvm_create_object_layer()

static LLVMOrcObjectLayerRef llvm_create_object_layer ( void *  Ctx, LLVMOrcExecutionSessionRef  ES, const char *  Triple  )

static

Definition at line 1167 of file llvmjit.c.

{
    LLVMOrcObjectLayerRef objlayer =
        LLVMOrcCreateRTDyldObjectLinkingLayerWithSectionMemoryManager(ES);
 
#if defined(HAVE_DECL_LLVMCREATEGDBREGISTRATIONLISTENER) && HAVE_DECL_LLVMCREATEGDBREGISTRATIONLISTENER
    if (jit_debugging_support)
    {
        LLVMJITEventListenerRef l = LLVMCreateGDBRegistrationListener();
 
        LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(objlayer, l);
    }
#endif
 
#if defined(HAVE_DECL_LLVMCREATEPERFJITEVENTLISTENER) && HAVE_DECL_LLVMCREATEPERFJITEVENTLISTENER
    if (jit_profiling_support)
    {
        LLVMJITEventListenerRef l = LLVMCreatePerfJITEventListener();
 
        LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(objlayer, l);
    }
#endif
 
    return objlayer;
}

References jit_debugging_support, and jit_profiling_support.

Referenced by llvm_create_jit_instance().

llvm_create_types()

static void llvm_create_types ( void  )

static

Definition at line 987 of file llvmjit.c.

{
    char        path[MAXPGPATH];
    LLVMMemoryBufferRef buf;
    char       *msg;
 
    snprintf(path, MAXPGPATH, "%s/%s", pkglib_path, "llvmjit_types.bc");
 
    /* open file */
    if (LLVMCreateMemoryBufferWithContentsOfFile(path, &buf, &msg))
    {
        elog(ERROR, "LLVMCreateMemoryBufferWithContentsOfFile(%s) failed: %s",
             path, msg);
    }
 
    /* eagerly load contents, going to need it all */
    if (LLVMParseBitcodeInContext2(llvm_context, buf, &llvm_types_module))
    {
        elog(ERROR, "LLVMParseBitcodeInContext2 of %s failed", path);
    }
    LLVMDisposeMemoryBuffer(buf);
 
    TypeSizeT = llvm_pg_var_type("TypeSizeT");
    TypeParamBool = load_return_type(llvm_types_module, "FunctionReturningBool");
    TypeStorageBool = llvm_pg_var_type("TypeStorageBool");
    TypePGFunction = llvm_pg_var_type("TypePGFunction");
    StructNullableDatum = llvm_pg_var_type("StructNullableDatum");
    StructExprContext = llvm_pg_var_type("StructExprContext");
    StructExprEvalStep = llvm_pg_var_type("StructExprEvalStep");
    StructExprState = llvm_pg_var_type("StructExprState");
    StructFunctionCallInfoData = llvm_pg_var_type("StructFunctionCallInfoData");
    StructMemoryContextData = llvm_pg_var_type("StructMemoryContextData");
    StructTupleTableSlot = llvm_pg_var_type("StructTupleTableSlot");
    StructHeapTupleTableSlot = llvm_pg_var_type("StructHeapTupleTableSlot");
    StructMinimalTupleTableSlot = llvm_pg_var_type("StructMinimalTupleTableSlot");
    StructHeapTupleData = llvm_pg_var_type("StructHeapTupleData");
    StructHeapTupleHeaderData = llvm_pg_var_type("StructHeapTupleHeaderData");
    StructTupleDescData = llvm_pg_var_type("StructTupleDescData");
    StructAggState = llvm_pg_var_type("StructAggState");
    StructAggStatePerGroupData = llvm_pg_var_type("StructAggStatePerGroupData");
    StructAggStatePerTransData = llvm_pg_var_type("StructAggStatePerTransData");
    StructPlanState = llvm_pg_var_type("StructPlanState");
    StructMinimalTupleData = llvm_pg_var_type("StructMinimalTupleData");
 
    AttributeTemplate = LLVMGetNamedFunction(llvm_types_module, "AttributeTemplate");
    ExecEvalSubroutineTemplate = LLVMGetNamedFunction(llvm_types_module, "ExecEvalSubroutineTemplate");
    ExecEvalBoolSubroutineTemplate = LLVMGetNamedFunction(llvm_types_module, "ExecEvalBoolSubroutineTemplate");
}

References AttributeTemplate, buf, elog, ERROR, ExecEvalBoolSubroutineTemplate, ExecEvalSubroutineTemplate, llvm_context, llvm_pg_var_type(), llvm_types_module, load_return_type(), MAXPGPATH, pkglib_path, snprintf, StructAggState, StructAggStatePerGroupData, StructAggStatePerTransData, StructExprContext, StructExprEvalStep, StructExprState, StructFunctionCallInfoData, StructHeapTupleData, StructHeapTupleHeaderData, StructHeapTupleTableSlot, StructMemoryContextData, StructMinimalTupleData, StructMinimalTupleTableSlot, StructNullableDatum, StructPlanState, StructTupleDescData, StructTupleTableSlot, TypeParamBool, TypePGFunction, TypeSizeT, and TypeStorageBool.

Referenced by llvm_recreate_llvm_context(), and llvm_session_initialize().

llvm_error_message()

static char * llvm_error_message ( LLVMErrorRef  error )

static

Definition at line 1250 of file llvmjit.c.

{
    char       *orig = LLVMGetErrorMessage(error);
    char       *msg = pstrdup(orig);
 
    LLVMDisposeErrorMessage(orig);
 
    return msg;
}

References error(), and pstrdup().

Referenced by llvm_compile_module(), llvm_create_jit_instance(), llvm_get_function(), llvm_log_jit_error(), and llvm_optimize_module().

llvm_expand_funcname()

char* llvm_expand_funcname	(	struct LLVMJitContext *	context,
		const char *	basename
	)

Definition at line 337 of file llvmjit.c.

{
    Assert(context->module != NULL);
 
    context->base.instr.created_functions++;
 
    /*
     * Previously we used dots to separate, but turns out some tools, e.g.
     * GDB, don't like that and truncate name.
     */
    return psprintf("%s_%zu_%d",
                    basename,
                    context->module_generation,
                    context->counter++);
}

References Assert, context, and psprintf().

Referenced by slot_compile_deform().

llvm_function_reference()

LLVMValueRef llvm_function_reference	(	LLVMJitContext *	context,
		LLVMBuilderRef	builder,
		LLVMModuleRef	mod,
		FunctionCallInfo	fcinfo
	)

Definition at line 536 of file llvmjit.c.

{
    char       *modname;
    char       *basename;
    char       *funcname;
 
    LLVMValueRef v_fn;
 
    fmgr_symbol(fcinfo->flinfo->fn_oid, &modname, &basename);
 
    if (modname != NULL && basename != NULL)
    {
        /* external function in loadable library */
        funcname = psprintf("pgextern.%s.%s", modname, basename);
    }
    else if (basename != NULL)
    {
        /* internal function */
        funcname = pstrdup(basename);
    }
    else
    {
        /*
         * Function we don't know to handle, return pointer. We do so by
         * creating a global constant containing a pointer to the function.
         * Makes IR more readable.
         */
        LLVMValueRef v_fn_addr;
 
        funcname = psprintf("pgoidextern.%u",
                            fcinfo->flinfo->fn_oid);
        v_fn = LLVMGetNamedGlobal(mod, funcname);
        if (v_fn != 0)
            return l_load(builder, TypePGFunction, v_fn, "");
 
        v_fn_addr = l_ptr_const(fcinfo->flinfo->fn_addr, TypePGFunction);
 
        v_fn = LLVMAddGlobal(mod, TypePGFunction, funcname);
        LLVMSetInitializer(v_fn, v_fn_addr);
        LLVMSetGlobalConstant(v_fn, true);
        LLVMSetLinkage(v_fn, LLVMPrivateLinkage);
        LLVMSetUnnamedAddr(v_fn, true);
 
        return l_load(builder, TypePGFunction, v_fn, "");
    }
 
    /* check if function already has been added */
    v_fn = LLVMGetNamedFunction(mod, funcname);
    if (v_fn != 0)
        return v_fn;
 
    v_fn = LLVMAddFunction(mod, funcname, LLVMGetFunctionType(AttributeTemplate));
 
    return v_fn;
}

References AttributeTemplate, FunctionCallInfoBaseData::flinfo, fmgr_symbol(), FmgrInfo::fn_addr, FmgrInfo::fn_oid, funcname, LLVMGetFunctionType(), psprintf(), pstrdup(), and TypePGFunction.

Referenced by BuildV1Call().

llvm_get_function()

void* llvm_get_function	(	LLVMJitContext *	context,
		const char *	funcname
	)

Definition at line 358 of file llvmjit.c.

{
    ListCell   *lc;
 
    llvm_assert_in_fatal_section();
 
    /*
     * If there is a pending / not emitted module, compile and emit now.
     * Otherwise we might not find the [correct] function.
     */
    if (!context->compiled)
    {
        llvm_compile_module(context);
    }
 
    /*
     * ORC's symbol table is of *unmangled* symbols. Therefore we don't need
     * to mangle here.
     */
 
    foreach(lc, context->handles)
    {
        LLVMJitHandle *handle = (LLVMJitHandle *) lfirst(lc);
        instr_time  starttime;
        instr_time  endtime;
        LLVMErrorRef error;
        LLVMOrcJITTargetAddress addr;
 
        INSTR_TIME_SET_CURRENT(starttime);
 
        addr = 0;
        error = LLVMOrcLLJITLookup(handle->lljit, &addr, funcname);
        if (error)
            elog(ERROR, "failed to look up symbol \"%s\": %s",
                 funcname, llvm_error_message(error));
 
        /*
         * LLJIT only actually emits code the first time a symbol is
         * referenced. Thus add lookup time to emission time. That's counting
         * a bit more than with older LLVM versions, but unlikely to ever
         * matter.
         */
        INSTR_TIME_SET_CURRENT(endtime);
        INSTR_TIME_ACCUM_DIFF(context->base.instr.emission_counter,
                              endtime, starttime);
 
        if (addr)
            return (void *) (uintptr_t) addr;
    }
 
    elog(ERROR, "failed to JIT: %s", funcname);
 
    return NULL;
}

References context, elog, ERROR, error(), funcname, INSTR_TIME_ACCUM_DIFF, INSTR_TIME_SET_CURRENT, lfirst, LLVMJitHandle::lljit, llvm_assert_in_fatal_section(), llvm_compile_module(), and llvm_error_message().

Referenced by ExecRunCompiledExpr().

llvm_log_jit_error()

static void llvm_log_jit_error ( void *  ctx, LLVMErrorRef  error  )

static

Definition at line 1157 of file llvmjit.c.

{
    elog(WARNING, "error during JITing: %s",
         llvm_error_message(error));
}

References elog, error(), llvm_error_message(), and WARNING.

Referenced by llvm_create_jit_instance().

llvm_mutable_module()

LLVMModuleRef llvm_mutable_module

(

LLVMJitContext *

context

)

Definition at line 312 of file llvmjit.c.

{
    llvm_assert_in_fatal_section();
 
    /*
     * If there's no in-progress module, create a new one.
     */
    if (!context->module)
    {
        context->compiled = false;
        context->module_generation = llvm_generation++;
        context->module = LLVMModuleCreateWithNameInContext("pg", llvm_context);
        LLVMSetTarget(context->module, llvm_triple);
        LLVMSetDataLayout(context->module, llvm_layout);
    }
 
    return context->module;
}

References context, llvm_assert_in_fatal_section(), llvm_context, llvm_generation, llvm_layout, and llvm_triple.

Referenced by slot_compile_deform().

llvm_optimize_module()

static void llvm_optimize_module ( LLVMJitContext *  context, LLVMModuleRef  module  )

static

Definition at line 599 of file llvmjit.c.

{
#if LLVM_VERSION_MAJOR < 17
    LLVMPassManagerBuilderRef llvm_pmb;
    LLVMPassManagerRef llvm_mpm;
    LLVMPassManagerRef llvm_fpm;
    LLVMValueRef func;
    int         compile_optlevel;
 
    if (context->base.flags & PGJIT_OPT3)
        compile_optlevel = 3;
    else
        compile_optlevel = 0;
 
    /*
     * Have to create a new pass manager builder every pass through, as the
     * inliner has some per-builder state. Otherwise one ends up only inlining
     * a function the first time though.
     */
    llvm_pmb = LLVMPassManagerBuilderCreate();
    LLVMPassManagerBuilderSetOptLevel(llvm_pmb, compile_optlevel);
    llvm_fpm = LLVMCreateFunctionPassManagerForModule(module);
 
    if (context->base.flags & PGJIT_OPT3)
    {
        /* TODO: Unscientifically determined threshold */
        LLVMPassManagerBuilderUseInlinerWithThreshold(llvm_pmb, 512);
    }
    else
    {
        /* we rely on mem2reg heavily, so emit even in the O0 case */
        LLVMAddPromoteMemoryToRegisterPass(llvm_fpm);
    }
 
    LLVMPassManagerBuilderPopulateFunctionPassManager(llvm_pmb, llvm_fpm);
 
    /*
     * Do function level optimization. This could be moved to the point where
     * functions are emitted, to reduce memory usage a bit.
     */
    LLVMInitializeFunctionPassManager(llvm_fpm);
    for (func = LLVMGetFirstFunction(context->module);
         func != NULL;
         func = LLVMGetNextFunction(func))
        LLVMRunFunctionPassManager(llvm_fpm, func);
    LLVMFinalizeFunctionPassManager(llvm_fpm);
    LLVMDisposePassManager(llvm_fpm);
 
    /*
     * Perform module level optimization. We do so even in the non-optimized
     * case, so always-inline functions etc get inlined. It's cheap enough.
     */
    llvm_mpm = LLVMCreatePassManager();
    LLVMPassManagerBuilderPopulateModulePassManager(llvm_pmb,
                                                    llvm_mpm);
    /* always use always-inliner pass */
    if (!(context->base.flags & PGJIT_OPT3))
        LLVMAddAlwaysInlinerPass(llvm_mpm);
    /* if doing inlining, but no expensive optimization, add inlining pass */
    if (context->base.flags & PGJIT_INLINE
        && !(context->base.flags & PGJIT_OPT3))
        LLVMAddFunctionInliningPass(llvm_mpm);
    LLVMRunPassManager(llvm_mpm, context->module);
    LLVMDisposePassManager(llvm_mpm);
 
    LLVMPassManagerBuilderDispose(llvm_pmb);
#else
    LLVMPassBuilderOptionsRef options;
    LLVMErrorRef err;
    const char *passes;
 
    if (context->base.flags & PGJIT_OPT3)
        passes = "default<O3>";
    else
        passes = "default<O0>,mem2reg";
 
    options = LLVMCreatePassBuilderOptions();
 
#ifdef LLVM_PASS_DEBUG
    LLVMPassBuilderOptionsSetDebugLogging(options, 1);
#endif
 
    /* In assertion builds, run the LLVM verify pass. */
#ifdef USE_ASSERT_CHECKING
    LLVMPassBuilderOptionsSetVerifyEach(options, true);
#endif
 
    LLVMPassBuilderOptionsSetInlinerThreshold(options, 512);
 
    err = LLVMRunPasses(module, passes, NULL, options);
 
    if (err)
        elog(ERROR, "failed to JIT module: %s", llvm_error_message(err));
 
    LLVMDisposePassBuilderOptions(options);
#endif
}

References context, elog, err(), ERROR, llvm_error_message(), options, PGJIT_INLINE, and PGJIT_OPT3.

Referenced by llvm_compile_module().

llvm_pg_func()

LLVMValueRef llvm_pg_func	(	LLVMModuleRef	mod,
		const char *	funcname
	)

Definition at line 460 of file llvmjit.c.

{
    LLVMValueRef v_srcfn;
    LLVMValueRef v_fn;
 
    /* don't repeatedly add function */
    v_fn = LLVMGetNamedFunction(mod, funcname);
    if (v_fn)
        return v_fn;
 
    v_srcfn = LLVMGetNamedFunction(llvm_types_module, funcname);
 
    if (!v_srcfn)
        elog(ERROR, "function %s not in llvmjit_types.c", funcname);
 
    v_fn = LLVMAddFunction(mod,
                           funcname,
                           LLVMGetFunctionType(v_srcfn));
    llvm_copy_attributes(v_srcfn, v_fn);
 
    return v_fn;
}

References elog, ERROR, funcname, llvm_copy_attributes(), llvm_types_module, and LLVMGetFunctionType().

Referenced by build_EvalXFuncInt(), and slot_compile_deform().

llvm_pg_var_func_type()

LLVMTypeRef llvm_pg_var_func_type

(

const char *

varname

)

Definition at line 438 of file llvmjit.c.

{
    LLVMValueRef v_srcvar;
    LLVMTypeRef typ;
 
    v_srcvar = LLVMGetNamedFunction(llvm_types_module, varname);
    if (!v_srcvar)
        elog(ERROR, "function %s not in llvmjit_types.c", varname);
 
    typ = LLVMGetFunctionType(v_srcvar);
 
    return typ;
}

References elog, ERROR, llvm_types_module, and LLVMGetFunctionType().

Referenced by slot_compile_deform().

llvm_pg_var_type()

LLVMTypeRef llvm_pg_var_type

(

const char *

varname

)

Definition at line 418 of file llvmjit.c.

{
    LLVMValueRef v_srcvar;
    LLVMTypeRef typ;
 
    /* this'll return a *pointer* to the global */
    v_srcvar = LLVMGetNamedGlobal(llvm_types_module, varname);
    if (!v_srcvar)
        elog(ERROR, "variable %s not in llvmjit_types.c", varname);
 
    typ = LLVMGlobalGetValueType(v_srcvar);
 
    return typ;
}

References elog, ERROR, and llvm_types_module.

Referenced by llvm_create_types().

llvm_recreate_llvm_context()

static void llvm_recreate_llvm_context ( void  )

static

Definition at line 169 of file llvmjit.c.

{
    if (!llvm_context)
        elog(ERROR, "Trying to recreate a non-existing context");
 
    /*
     * We can only safely recreate the LLVM context if no other code is being
     * JITed, otherwise we'd release the types in use for that.
     */
    if (llvm_jit_context_in_use_count > 0)
    {
        llvm_llvm_context_reuse_count++;
        return;
    }
 
    if (llvm_llvm_context_reuse_count <= LLVMJIT_LLVM_CONTEXT_REUSE_MAX)
    {
        llvm_llvm_context_reuse_count++;
        return;
    }
 
    /*
     * Need to reset the modules that the inlining code caches before
     * disposing of the context. LLVM modules exist within a specific LLVM
     * context, therefore disposing of the context before resetting the cache
     * would lead to dangling pointers to modules.
     */
    llvm_inline_reset_caches();
 
    LLVMContextDispose(llvm_context);
    llvm_context = LLVMContextCreate();
    llvm_llvm_context_reuse_count = 0;
 
    /*
     * Re-build cached type information, so code generation code can rely on
     * that information to be present (also prevents the variables to be
     * dangling references).
     */
    llvm_create_types();
}

References elog, ERROR, llvm_context, llvm_create_types(), llvm_inline_reset_caches(), llvm_jit_context_in_use_count, llvm_llvm_context_reuse_count, and LLVMJIT_LLVM_CONTEXT_REUSE_MAX.

Referenced by llvm_create_context().

llvm_release_context()

static void llvm_release_context ( JitContext *  context )

static

Definition at line 248 of file llvmjit.c.

{
    LLVMJitContext *llvm_jit_context = (LLVMJitContext *) context;
    ListCell   *lc;
 
    /*
     * Consider as cleaned up even if we skip doing so below, that way we can
     * verify the tracking is correct (see llvm_shutdown()).
     */
    llvm_jit_context_in_use_count--;
 
    /*
     * When this backend is exiting, don't clean up LLVM. As an error might
     * have occurred from within LLVM, we do not want to risk reentering. All
     * resource cleanup is going to happen through process exit.
     */
    if (proc_exit_inprogress)
        return;
 
    llvm_enter_fatal_on_oom();
 
    if (llvm_jit_context->module)
    {
        LLVMDisposeModule(llvm_jit_context->module);
        llvm_jit_context->module = NULL;
    }
 
    foreach(lc, llvm_jit_context->handles)
    {
        LLVMJitHandle *jit_handle = (LLVMJitHandle *) lfirst(lc);
 
        {
            LLVMOrcExecutionSessionRef ee;
            LLVMOrcSymbolStringPoolRef sp;
 
            LLVMOrcResourceTrackerRemove(jit_handle->resource_tracker);
            LLVMOrcReleaseResourceTracker(jit_handle->resource_tracker);
 
            /*
             * Without triggering cleanup of the string pool, we'd leak
             * memory. It'd be sufficient to do this far less often, but in
             * experiments the required time was small enough to just always
             * do it.
             */
            ee = LLVMOrcLLJITGetExecutionSession(jit_handle->lljit);
            sp = LLVMOrcExecutionSessionGetSymbolStringPool(ee);
            LLVMOrcSymbolStringPoolClearDeadEntries(sp);
        }
 
        pfree(jit_handle);
    }
    list_free(llvm_jit_context->handles);
    llvm_jit_context->handles = NIL;
 
    llvm_leave_fatal_on_oom();
 
    if (llvm_jit_context->resowner)
        ResourceOwnerForgetJIT(llvm_jit_context->resowner, llvm_jit_context);
}

References context, lfirst, list_free(), LLVMJitHandle::lljit, llvm_enter_fatal_on_oom(), llvm_jit_context_in_use_count, llvm_leave_fatal_on_oom(), NIL, pfree(), proc_exit_inprogress, LLVMJitHandle::resource_tracker, and ResourceOwnerForgetJIT().

Referenced by _PG_jit_provider_init().

llvm_resolve_symbol()

static uint64_t llvm_resolve_symbol ( const char *  name, void *  ctx  )

static

Definition at line 1075 of file llvmjit.c.

{
    uintptr_t   addr;
    char       *funcname;
    char       *modname;
 
    /*
     * macOS prefixes all object level symbols with an underscore. But neither
     * dlsym() nor PG's inliner expect that. So undo.
     */
#if defined(__darwin__)
    if (symname[0] != '_')
        elog(ERROR, "expected prefixed symbol name, but got \"%s\"", symname);
    symname++;
#endif
 
    llvm_split_symbol_name(symname, &modname, &funcname);
 
    /* functions that aren't resolved to names shouldn't ever get here */
    Assert(funcname);
 
    if (modname)
        addr = (uintptr_t) load_external_function(modname, funcname,
                                                  true, NULL);
    else
        addr = (uintptr_t) LLVMSearchForAddressOfSymbol(symname);
 
    pfree(funcname);
    if (modname)
        pfree(modname);
 
    /* let LLVM will error out - should never happen */
    if (!addr)
        elog(WARNING, "failed to resolve name %s", symname);
 
    return (uint64_t) addr;
}

References Assert, elog, ERROR, funcname, llvm_split_symbol_name(), load_external_function(), pfree(), and WARNING.

Referenced by llvm_resolve_symbols().

llvm_resolve_symbols()

static LLVMErrorRef llvm_resolve_symbols ( LLVMOrcDefinitionGeneratorRef  GeneratorObj, void *  Ctx, LLVMOrcLookupStateRef *  LookupState, LLVMOrcLookupKind  Kind, LLVMOrcJITDylibRef  JD, LLVMOrcJITDylibLookupFlags  JDLookupFlags, LLVMOrcCLookupSet  LookupSet, size_t  LookupSetSize  )

static

Definition at line 1114 of file llvmjit.c.

{
#if LLVM_VERSION_MAJOR > 14
    LLVMOrcCSymbolMapPairs symbols = palloc0(sizeof(LLVMOrcCSymbolMapPair) * LookupSetSize);
#else
    LLVMOrcCSymbolMapPairs symbols = palloc0(sizeof(LLVMJITCSymbolMapPair) * LookupSetSize);
#endif
    LLVMErrorRef error;
    LLVMOrcMaterializationUnitRef mu;
 
    for (int i = 0; i < LookupSetSize; i++)
    {
        const char *name = LLVMOrcSymbolStringPoolEntryStr(LookupSet[i].Name);
 
        LLVMOrcRetainSymbolStringPoolEntry(LookupSet[i].Name);
        symbols[i].Name = LookupSet[i].Name;
        symbols[i].Sym.Address = llvm_resolve_symbol(name, NULL);
        symbols[i].Sym.Flags.GenericFlags = LLVMJITSymbolGenericFlagsExported;
    }
 
    mu = LLVMOrcAbsoluteSymbols(symbols, LookupSetSize);
    error = LLVMOrcJITDylibDefine(JD, mu);
    if (error != LLVMErrorSuccess)
        LLVMOrcDisposeMaterializationUnit(mu);
 
    pfree(symbols);
 
    return error;
}

References error(), i, llvm_resolve_symbol(), name, palloc0(), and pfree().

Referenced by llvm_create_jit_instance().

llvm_session_initialize()

static void llvm_session_initialize ( void  )

static

Definition at line 817 of file llvmjit.c.

{
    MemoryContext oldcontext;
    char       *error = NULL;
    char       *cpu = NULL;
    char       *features = NULL;
    LLVMTargetMachineRef opt0_tm;
    LLVMTargetMachineRef opt3_tm;
 
    if (llvm_session_initialized)
        return;
 
    oldcontext = MemoryContextSwitchTo(TopMemoryContext);
 
    LLVMInitializeNativeTarget();
    LLVMInitializeNativeAsmPrinter();
    LLVMInitializeNativeAsmParser();
 
    if (llvm_context == NULL)
    {
        llvm_context = LLVMContextCreate();
 
        llvm_jit_context_in_use_count = 0;
        llvm_llvm_context_reuse_count = 0;
    }
 
    /*
     * Synchronize types early, as that also includes inferring the target
     * triple.
     */
    llvm_create_types();
 
    /*
     * Extract target information from loaded module.
     */
    llvm_set_target();
 
    if (LLVMGetTargetFromTriple(llvm_triple, &llvm_targetref, &error) != 0)
    {
        elog(FATAL, "failed to query triple %s", error);
    }
 
    /*
     * We want the generated code to use all available features. Therefore
     * grab the host CPU string and detect features of the current CPU. The
     * latter is needed because some CPU architectures default to enabling
     * features not all CPUs have (weird, huh).
     */
    cpu = LLVMGetHostCPUName();
    features = LLVMGetHostCPUFeatures();
    elog(DEBUG2, "LLVMJIT detected CPU \"%s\", with features \"%s\"",
         cpu, features);
 
    opt0_tm =
        LLVMCreateTargetMachine(llvm_targetref, llvm_triple, cpu, features,
                                LLVMCodeGenLevelNone,
                                LLVMRelocDefault,
                                LLVMCodeModelJITDefault);
    opt3_tm =
        LLVMCreateTargetMachine(llvm_targetref, llvm_triple, cpu, features,
                                LLVMCodeGenLevelAggressive,
                                LLVMRelocDefault,
                                LLVMCodeModelJITDefault);
 
    LLVMDisposeMessage(cpu);
    cpu = NULL;
    LLVMDisposeMessage(features);
    features = NULL;
 
    /* force symbols in main binary to be loaded */
    LLVMLoadLibraryPermanently(NULL);
 
    {
        llvm_ts_context = LLVMOrcCreateNewThreadSafeContext();
 
        llvm_opt0_orc = llvm_create_jit_instance(opt0_tm);
        opt0_tm = 0;
 
        llvm_opt3_orc = llvm_create_jit_instance(opt3_tm);
        opt3_tm = 0;
    }
 
    on_proc_exit(llvm_shutdown, 0);
 
    llvm_session_initialized = true;
 
    MemoryContextSwitchTo(oldcontext);
}

References DEBUG2, elog, error(), FATAL, llvm_context, llvm_create_jit_instance(), llvm_create_types(), llvm_jit_context_in_use_count, llvm_llvm_context_reuse_count, llvm_opt0_orc, llvm_opt3_orc, llvm_session_initialized, llvm_set_target(), llvm_shutdown(), llvm_targetref, llvm_triple, llvm_ts_context, MemoryContextSwitchTo(), on_proc_exit(), and TopMemoryContext.

Referenced by llvm_create_context().

llvm_set_target()

static void llvm_set_target ( void  )

static

Definition at line 968 of file llvmjit.c.

{
    if (!llvm_types_module)
        elog(ERROR, "failed to extract target information, llvmjit_types.c not loaded");
 
    if (llvm_triple == NULL)
        llvm_triple = pstrdup(LLVMGetTarget(llvm_types_module));
 
    if (llvm_layout == NULL)
        llvm_layout = pstrdup(LLVMGetDataLayoutStr(llvm_types_module));
}

References elog, ERROR, llvm_layout, llvm_triple, llvm_types_module, and pstrdup().

Referenced by llvm_session_initialize().

llvm_shutdown()

static void llvm_shutdown ( int  code, Datum  arg  )

static

Definition at line 907 of file llvmjit.c.

{
    /*
     * If llvm_shutdown() is reached while in a fatal-on-oom section an error
     * has occurred in the middle of LLVM code. It is not safe to call back
     * into LLVM (which is why a FATAL error was thrown).
     *
     * We do need to shutdown LLVM in other shutdown cases, otherwise e.g.
     * profiling data won't be written out.
     */
    if (llvm_in_fatal_on_oom())
    {
        Assert(proc_exit_inprogress);
        return;
    }
 
    if (llvm_jit_context_in_use_count != 0)
        elog(PANIC, "LLVMJitContext in use count not 0 at exit (is %zu)",
             llvm_jit_context_in_use_count);
 
    {
        if (llvm_opt3_orc)
        {
            LLVMOrcDisposeLLJIT(llvm_opt3_orc);
            llvm_opt3_orc = NULL;
        }
        if (llvm_opt0_orc)
        {
            LLVMOrcDisposeLLJIT(llvm_opt0_orc);
            llvm_opt0_orc = NULL;
        }
        if (llvm_ts_context)
        {
            LLVMOrcDisposeThreadSafeContext(llvm_ts_context);
            llvm_ts_context = NULL;
        }
    }
}

References Assert, elog, llvm_in_fatal_on_oom(), llvm_jit_context_in_use_count, llvm_opt0_orc, llvm_opt3_orc, llvm_ts_context, PANIC, and proc_exit_inprogress.

Referenced by llvm_session_initialize().

llvm_split_symbol_name()

void llvm_split_symbol_name	(	const char *	name,
		char **	modname,
		char **	funcname
	)

Definition at line 1041 of file llvmjit.c.

{
    *modname = NULL;
    *funcname = NULL;
 
    /*
     * Module function names are pgextern.$module.$funcname
     */
    if (strncmp(name, "pgextern.", strlen("pgextern.")) == 0)
    {
        /*
         * Symbol names cannot contain a ., therefore we can split based on
         * first and last occurrence of one.
         */
        *funcname = rindex(name, '.');
        (*funcname)++;          /* jump over . */
 
        *modname = pnstrdup(name + strlen("pgextern."),
                            *funcname - name - strlen("pgextern.") - 1);
        Assert(funcname);
 
        *funcname = pstrdup(*funcname);
    }
    else
    {
        *modname = NULL;
        *funcname = pstrdup(name);
    }
}

References Assert, funcname, name, pnstrdup(), and pstrdup().

Referenced by llvm_build_inline_plan(), llvm_execute_inline_plan(), and llvm_resolve_symbol().

load_return_type()

static LLVMTypeRef load_return_type ( LLVMModuleRef  mod, const char *  name  )

static

Definition at line 948 of file llvmjit.c.

{
    LLVMValueRef value;
    LLVMTypeRef typ;
 
    /* this'll return a *pointer* to the function */
    value = LLVMGetNamedFunction(mod, name);
    if (!value)
        elog(ERROR, "function %s is unknown", name);
 
    typ = LLVMGetFunctionReturnType(value); /* in llvmjit_wrap.cpp */
 
    return typ;
}

References elog, ERROR, LLVMGetFunctionReturnType(), name, and value.

Referenced by llvm_create_types().

ResourceOwnerForgetJIT()

static void ResourceOwnerForgetJIT ( ResourceOwner  owner, LLVMJitContext *  handle  )

inlinestatic

Definition at line 135 of file llvmjit.c.

{
    ResourceOwnerForget(owner, PointerGetDatum(handle), &jit_resowner_desc);
}

References jit_resowner_desc, PointerGetDatum(), and ResourceOwnerForget().

Referenced by llvm_release_context().

ResourceOwnerRememberJIT()

static void ResourceOwnerRememberJIT ( ResourceOwner  owner, LLVMJitContext *  handle  )

inlinestatic

Definition at line 130 of file llvmjit.c.

{
    ResourceOwnerRemember(owner, PointerGetDatum(handle), &jit_resowner_desc);
}

References jit_resowner_desc, PointerGetDatum(), and ResourceOwnerRemember().

Referenced by llvm_create_context().

ResOwnerReleaseJitContext()

static void ResOwnerReleaseJitContext ( Datum  res )

static

Definition at line 1264 of file llvmjit.c.

{
    LLVMJitContext *context = (LLVMJitContext *) DatumGetPointer(res);
 
    context->resowner = NULL;
    jit_release_context(&context->base);
}

References context, DatumGetPointer(), jit_release_context(), and res.

Variable Documentation

AttributeTemplate

Datum AttributeTemplate

Definition at line 77 of file llvmjit.c.

Referenced by BuildV1Call(), llvm_create_types(), llvm_function_reference(), and slot_compile_deform().

ExecEvalBoolSubroutineTemplate

bool ExecEvalBoolSubroutineTemplate

Definition at line 79 of file llvmjit.c.

Referenced by llvm_create_types().

ExecEvalSubroutineTemplate

void ExecEvalSubroutineTemplate

Definition at line 78 of file llvmjit.c.

Referenced by llvm_create_types().

jit_resowner_desc

const ResourceOwnerDesc jit_resowner_desc

static

Initial value:

=
{
    .name = "LLVM JIT context",
    .release_phase = RESOURCE_RELEASE_BEFORE_LOCKS,
    .release_priority = RELEASE_PRIO_JIT_CONTEXTS,
    .ReleaseResource = ResOwnerReleaseJitContext,
    .DebugPrint = NULL          
}

Definition at line 119 of file llvmjit.c.

Referenced by ResourceOwnerForgetJIT(), and ResourceOwnerRememberJIT().

llvm_context

LLVMContextRef llvm_context

static

Definition at line 93 of file llvmjit.c.

Referenced by llvm_create_types(), llvm_mutable_module(), llvm_recreate_llvm_context(), and llvm_session_initialize().

llvm_generation

size_t llvm_generation = 0

static

Definition at line 84 of file llvmjit.c.

Referenced by llvm_mutable_module().

llvm_jit_context_in_use_count

size_t llvm_jit_context_in_use_count = 0

static

Definition at line 87 of file llvmjit.c.

Referenced by llvm_create_context(), llvm_recreate_llvm_context(), llvm_release_context(), llvm_session_initialize(), and llvm_shutdown().

llvm_layout

const char* llvm_layout = NULL

static

Definition at line 92 of file llvmjit.c.

Referenced by llvm_mutable_module(), and llvm_set_target().

llvm_llvm_context_reuse_count

size_t llvm_llvm_context_reuse_count = 0

static

Definition at line 90 of file llvmjit.c.

Referenced by llvm_recreate_llvm_context(), and llvm_session_initialize().

llvm_opt0_orc

LLVMOrcLLJITRef llvm_opt0_orc

static

Definition at line 98 of file llvmjit.c.

Referenced by llvm_compile_module(), llvm_session_initialize(), and llvm_shutdown().

llvm_opt3_orc

LLVMOrcLLJITRef llvm_opt3_orc

static

Definition at line 99 of file llvmjit.c.

Referenced by llvm_compile_module(), llvm_session_initialize(), and llvm_shutdown().

llvm_session_initialized

bool llvm_session_initialized = false

static

Definition at line 83 of file llvmjit.c.

Referenced by llvm_session_initialize().

llvm_targetref

LLVMTargetRef llvm_targetref

static

Definition at line 96 of file llvmjit.c.

Referenced by llvm_session_initialize().

llvm_triple

const char* llvm_triple = NULL

static

Definition at line 91 of file llvmjit.c.

Referenced by llvm_mutable_module(), llvm_session_initialize(), and llvm_set_target().

llvm_ts_context

LLVMOrcThreadSafeContextRef llvm_ts_context

static

Definition at line 97 of file llvmjit.c.

Referenced by llvm_compile_module(), llvm_session_initialize(), and llvm_shutdown().

llvm_types_module

LLVMModuleRef llvm_types_module = NULL

static

Definition at line 81 of file llvmjit.c.

Referenced by llvm_create_types(), llvm_pg_func(), llvm_pg_var_func_type(), llvm_pg_var_type(), and llvm_set_target().

PG_MODULE_MAGIC

PG_MODULE_MAGIC

Definition at line 140 of file llvmjit.c.

StructAggState

LLVMTypeRef StructAggState

Definition at line 72 of file llvmjit.c.

Referenced by llvm_create_types().

StructAggStatePerGroupData

LLVMTypeRef StructAggStatePerGroupData

Definition at line 73 of file llvmjit.c.

Referenced by llvm_create_types().

StructAggStatePerTransData

LLVMTypeRef StructAggStatePerTransData

Definition at line 74 of file llvmjit.c.

Referenced by llvm_create_types().

StructExprContext

LLVMTypeRef StructExprContext

Definition at line 69 of file llvmjit.c.

Referenced by llvm_create_types().

StructExprEvalStep

LLVMTypeRef StructExprEvalStep

Definition at line 70 of file llvmjit.c.

Referenced by build_EvalXFuncInt(), and llvm_create_types().

StructExprState

LLVMTypeRef StructExprState

Definition at line 71 of file llvmjit.c.

Referenced by llvm_create_types().

StructFunctionCallInfoData

LLVMTypeRef StructFunctionCallInfoData

Definition at line 68 of file llvmjit.c.

Referenced by BuildV1Call(), and llvm_create_types().

StructHeapTupleData

LLVMTypeRef StructHeapTupleData

Definition at line 60 of file llvmjit.c.

Referenced by llvm_create_types(), and slot_compile_deform().

StructHeapTupleHeaderData

LLVMTypeRef StructHeapTupleHeaderData

Definition at line 64 of file llvmjit.c.

Referenced by llvm_create_types(), and slot_compile_deform().

StructHeapTupleTableSlot

LLVMTypeRef StructHeapTupleTableSlot

Definition at line 65 of file llvmjit.c.

Referenced by llvm_create_types(), and slot_compile_deform().

StructMemoryContextData

LLVMTypeRef StructMemoryContextData

Definition at line 67 of file llvmjit.c.

Referenced by llvm_create_types().

StructMinimalTupleData

LLVMTypeRef StructMinimalTupleData

Definition at line 61 of file llvmjit.c.

Referenced by llvm_create_types().

StructMinimalTupleTableSlot

LLVMTypeRef StructMinimalTupleTableSlot

Definition at line 66 of file llvmjit.c.

Referenced by llvm_create_types(), and slot_compile_deform().

StructNullableDatum

LLVMTypeRef StructNullableDatum

Definition at line 59 of file llvmjit.c.

Referenced by llvm_create_types().

StructPlanState

LLVMTypeRef StructPlanState

Definition at line 75 of file llvmjit.c.

Referenced by llvm_create_types().

StructTupleDescData

LLVMTypeRef StructTupleDescData

Definition at line 62 of file llvmjit.c.

Referenced by llvm_create_types().

StructTupleTableSlot

LLVMTypeRef StructTupleTableSlot

Definition at line 63 of file llvmjit.c.

Referenced by llvm_create_types(), and slot_compile_deform().

TypeParamBool

LLVMTypeRef TypeParamBool

Definition at line 56 of file llvmjit.c.

Referenced by llvm_create_types().

TypePGFunction

LLVMTypeRef TypePGFunction

Definition at line 58 of file llvmjit.c.

Referenced by llvm_create_types(), and llvm_function_reference().

TypeSizeT

LLVMTypeRef TypeSizeT

Definition at line 55 of file llvmjit.c.

Referenced by llvm_create_types(), and slot_compile_deform().

TypeStorageBool

LLVMTypeRef TypeStorageBool

Definition at line 57 of file llvmjit.c.

Referenced by BuildV1Call(), llvm_create_types(), and slot_compile_deform().