#endif
+#define LLVMJIT_LLVM_CONTEXT_REUSE_MAX 100
+
/* Handle of a module emitted via ORC JIT */
typedef struct LLVMJitHandle
{
static bool llvm_session_initialized = false;
static size_t llvm_generation = 0;
+
+/* number of LLVMJitContexts that currently are in use */
+static size_t llvm_jit_context_in_use_count = 0;
+
+/* how many times has the current LLVMContextRef been used */
+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 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);
#if LLVM_VERSION_MAJOR > 11
cb->compile_expr = llvm_compile_expr;
}
+
+/*
+ * Every now and then create a new LLVMContextRef. Unfortunately, during every
+ * round of inlining, types may "leak" (they can still be found/used via the
+ * context, but new types will be created the next time in inlining is
+ * performed). To prevent that from slowly accumulating problematic amounts of
+ * memory, recreate the LLVMContextRef we use. We don't want to do so too
+ * often, as that implies some overhead (particularly re-loading the module
+ * summaries / modules is fairly expensive). A future TODO would be to make
+ * this more finegrained and only drop/recreate the LLVMContextRef when we know
+ * there has been inlining. If we can get the size of the context from LLVM
+ * then that might be a better way to determine when to drop/recreate rather
+ * then the usagecount heuristic currently employed.
+ */
+static void
+llvm_recreate_llvm_context(void)
+{
+ 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();
+}
+
+
/*
* Create a context for JITing work.
*
llvm_session_initialize();
+ llvm_recreate_llvm_context();
+
ResourceOwnerEnlargeJIT(CurrentResourceOwner);
context = MemoryContextAllocZero(TopMemoryContext,
context->base.resowner = CurrentResourceOwner;
ResourceOwnerRememberJIT(CurrentResourceOwner, PointerGetDatum(context));
+ llvm_jit_context_in_use_count++;
+
return context;
}
static void
llvm_release_context(JitContext *context)
{
- LLVMJitContext *llvm_context = (LLVMJitContext *) context;
+ LLVMJitContext *llvm_jit_context = (LLVMJitContext *) context;
+
+ /*
+ * 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
llvm_enter_fatal_on_oom();
- if (llvm_context->module)
+ if (llvm_jit_context->module)
{
- LLVMDisposeModule(llvm_context->module);
- llvm_context->module = NULL;
+ LLVMDisposeModule(llvm_jit_context->module);
+ llvm_jit_context->module = NULL;
}
- while (llvm_context->handles != NIL)
+ while (llvm_jit_context->handles != NIL)
{
LLVMJitHandle *jit_handle;
- jit_handle = (LLVMJitHandle *) linitial(llvm_context->handles);
- llvm_context->handles = list_delete_first(llvm_context->handles);
+ jit_handle = (LLVMJitHandle *) linitial(llvm_jit_context->handles);
+ llvm_jit_context->handles = list_delete_first(llvm_jit_context->handles);
#if LLVM_VERSION_MAJOR > 11
{
pfree(jit_handle);
}
+ list_free(llvm_jit_context->handles);
+ llvm_jit_context->handles = NIL;
llvm_leave_fatal_on_oom();
}
{
context->compiled = false;
context->module_generation = llvm_generation++;
- context->module = LLVMModuleCreateWithName("pg");
+ context->module = LLVMModuleCreateWithNameInContext("pg", llvm_context);
LLVMSetTarget(context->module, llvm_triple);
LLVMSetDataLayout(context->module, llvm_layout);
}
LLVMInitializeNativeAsmPrinter();
LLVMInitializeNativeAsmParser();
+ if (llvm_context == NULL)
+ {
+ llvm_context = LLVMContextCreate();
+
+ llvm_jit_context_in_use_count = 0;
+ llvm_llvm_context_reuse_count = 0;
+ }
+
/*
* When targeting LLVM 15, turn off opaque pointers for the context we
* build our code in. We don't need to do so for other contexts (e.g.
*/
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);
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_VERSION_MAJOR > 11
{
if (llvm_opt3_orc)
return typ;
}
+/*
+ * Load triple & layout from clang emitted file so we're guaranteed to be
+ * compatible.
+ */
+static void
+llvm_set_target(void)
+{
+ 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));
+}
+
/*
* Load required information, types, function signatures from llvmjit_types.c
* and make them available in global variables.
}
/* eagerly load contents, going to need it all */
- if (LLVMParseBitcode2(buf, &llvm_types_module))
+ if (LLVMParseBitcodeInContext2(llvm_context, buf, &llvm_types_module))
{
- elog(ERROR, "LLVMParseBitcode2 of %s failed", path);
+ elog(ERROR, "LLVMParseBitcodeInContext2 of %s failed", path);
}
LLVMDisposeMemoryBuffer(buf);
- /*
- * Load triple & layout from clang emitted file so we're guaranteed to be
- * compatible.
- */
- llvm_triple = pstrdup(LLVMGetTarget(llvm_types_module));
- llvm_layout = pstrdup(LLVMGetDataLayoutStr(llvm_types_module));
-
TypeSizeT = llvm_pg_var_type("TypeSizeT");
TypeParamBool = load_return_type(llvm_types_module, "FunctionReturningBool");
TypeStorageBool = llvm_pg_var_type("TypeStorageBool");
char *funcname;
LLVMModuleRef mod;
+ LLVMContextRef lc;
LLVMBuilderRef b;
LLVMTypeRef deform_sig;
return NULL;
mod = llvm_mutable_module(context);
+ lc = LLVMGetModuleContext(mod);
funcname = llvm_expand_funcname(context, "deform");
param_types[0] = l_ptr(StructTupleTableSlot);
- deform_sig = LLVMFunctionType(LLVMVoidType(), param_types,
- lengthof(param_types), 0);
+ deform_sig = LLVMFunctionType(LLVMVoidTypeInContext(lc),
+ param_types, lengthof(param_types), 0);
}
v_deform_fn = LLVMAddFunction(mod, funcname, deform_sig);
LLVMSetLinkage(v_deform_fn, LLVMInternalLinkage);
llvm_copy_attributes(AttributeTemplate, v_deform_fn);
b_entry =
- LLVMAppendBasicBlock(v_deform_fn, "entry");
+ LLVMAppendBasicBlockInContext(lc, v_deform_fn, "entry");
b_adjust_unavail_cols =
- LLVMAppendBasicBlock(v_deform_fn, "adjust_unavail_cols");
+ LLVMAppendBasicBlockInContext(lc, v_deform_fn, "adjust_unavail_cols");
b_find_start =
- LLVMAppendBasicBlock(v_deform_fn, "find_startblock");
+ LLVMAppendBasicBlockInContext(lc, v_deform_fn, "find_startblock");
b_out =
- LLVMAppendBasicBlock(v_deform_fn, "outblock");
+ LLVMAppendBasicBlockInContext(lc, v_deform_fn, "outblock");
b_dead =
- LLVMAppendBasicBlock(v_deform_fn, "deadblock");
+ LLVMAppendBasicBlockInContext(lc, v_deform_fn, "deadblock");
- b = LLVMCreateBuilder();
+ b = LLVMCreateBuilderInContext(lc);
attcheckattnoblocks = palloc(sizeof(LLVMBasicBlockRef) * natts);
attstartblocks = palloc(sizeof(LLVMBasicBlockRef) * natts);
v_tuplep,
FIELDNO_HEAPTUPLEHEADERDATA_BITS,
""),
- l_ptr(LLVMInt8Type()),
+ l_ptr(LLVMInt8TypeInContext(lc)),
"t_bits");
v_infomask1 =
l_load_struct_gep(b,
v_hasnulls =
LLVMBuildICmp(b, LLVMIntNE,
LLVMBuildAnd(b,
- l_int16_const(HEAP_HASNULL),
+ l_int16_const(lc, HEAP_HASNULL),
v_infomask1, ""),
- l_int16_const(0),
+ l_int16_const(lc, 0),
"hasnulls");
/* t_infomask2 & HEAP_NATTS_MASK */
v_maxatt = LLVMBuildAnd(b,
- l_int16_const(HEAP_NATTS_MASK),
+ l_int16_const(lc, HEAP_NATTS_MASK),
v_infomask2,
"maxatt");
v_tuplep,
FIELDNO_HEAPTUPLEHEADERDATA_HOFF,
""),
- LLVMInt32Type(), "t_hoff");
+ LLVMInt32TypeInContext(lc), "t_hoff");
v_tupdata_base = l_gep(b,
- LLVMInt8Type(),
+ LLVMInt8TypeInContext(lc),
LLVMBuildBitCast(b,
v_tuplep,
- l_ptr(LLVMInt8Type()),
+ l_ptr(LLVMInt8TypeInContext(lc)),
""),
&v_hoff, 1,
"v_tupdata_base");
{
LLVMValueRef v_off_start;
- v_off_start = l_load(b, LLVMInt32Type(), v_slotoffp, "v_slot_off");
+ v_off_start = l_load(b, LLVMInt32TypeInContext(lc), v_slotoffp, "v_slot_off");
v_off_start = LLVMBuildZExt(b, v_off_start, TypeSizeT, "");
LLVMBuildStore(b, v_off_start, v_offp);
}
LLVMBuildCondBr(b,
LLVMBuildICmp(b, LLVMIntULT,
v_maxatt,
- l_int16_const(natts),
+ l_int16_const(lc, natts),
""),
b_adjust_unavail_cols,
b_find_start);
LLVMPositionBuilderAtEnd(b, b_adjust_unavail_cols);
v_params[0] = v_slot;
- v_params[1] = LLVMBuildZExt(b, v_maxatt, LLVMInt32Type(), "");
- v_params[2] = l_int32_const(natts);
+ v_params[1] = LLVMBuildZExt(b, v_maxatt, LLVMInt32TypeInContext(lc), "");
+ v_params[2] = l_int32_const(lc, natts);
f = llvm_pg_func(mod, "slot_getmissingattrs");
l_call(b,
LLVMGetFunctionType(f), f,
LLVMPositionBuilderAtEnd(b, b_find_start);
- v_nvalid = l_load(b, LLVMInt16Type(), v_nvalidp, "");
+ v_nvalid = l_load(b, LLVMInt16TypeInContext(lc), v_nvalidp, "");
/*
* Build switch to go from nvalid to the right startblock. Callers
for (attnum = 0; attnum < natts; attnum++)
{
- LLVMValueRef v_attno = l_int16_const(attnum);
+ LLVMValueRef v_attno = l_int16_const(lc, attnum);
LLVMAddCase(v_switch, v_attno, attcheckattnoblocks[attnum]);
}
Form_pg_attribute att = TupleDescAttr(desc, attnum);
LLVMValueRef v_incby;
int alignto;
- LLVMValueRef l_attno = l_int16_const(attnum);
+ LLVMValueRef l_attno = l_int16_const(lc, attnum);
LLVMValueRef v_attdatap;
LLVMValueRef v_resultp;
else
b_next = attcheckattnoblocks[attnum + 1];
- v_nullbyteno = l_int32_const(attnum >> 3);
- v_nullbytemask = l_int8_const(1 << ((attnum) & 0x07));
- v_nullbyte = l_load_gep1(b, LLVMInt8Type(), v_bits, v_nullbyteno, "attnullbyte");
+ v_nullbyteno = l_int32_const(lc, attnum >> 3);
+ v_nullbytemask = l_int8_const(lc, 1 << ((attnum) & 0x07));
+ v_nullbyte = l_load_gep1(b, LLVMInt8TypeInContext(lc), v_bits, v_nullbyteno, "attnullbyte");
v_nullbit = LLVMBuildICmp(b,
LLVMIntEQ,
LLVMBuildAnd(b, v_nullbyte, v_nullbytemask, ""),
- l_int8_const(0),
+ l_int8_const(lc, 0),
"attisnull");
v_attisnull = LLVMBuildAnd(b, v_hasnulls, v_nullbit, "");
/* store null-byte */
LLVMBuildStore(b,
- l_int8_const(1),
- l_gep(b, LLVMInt8Type(), v_tts_nulls, &l_attno, 1, ""));
+ l_int8_const(lc, 1),
+ l_gep(b, LLVMInt8TypeInContext(lc), v_tts_nulls, &l_attno, 1, ""));
/* store zero datum */
LLVMBuildStore(b,
l_sizet_const(0),
v_off = l_load(b, TypeSizeT, v_offp, "");
v_possible_padbyte =
- l_load_gep1(b, LLVMInt8Type(), v_tupdata_base, v_off, "padbyte");
+ l_load_gep1(b, LLVMInt8TypeInContext(lc), v_tupdata_base,
+ v_off, "padbyte");
v_ispad =
LLVMBuildICmp(b, LLVMIntEQ,
- v_possible_padbyte, l_int8_const(0),
+ v_possible_padbyte, l_int8_const(lc, 0),
"ispadbyte");
LLVMBuildCondBr(b, v_ispad,
attalignblocks[attnum],
LLVMValueRef v_off = l_load(b, TypeSizeT, v_offp, "");
v_attdatap =
- l_gep(b, LLVMInt8Type(), v_tupdata_base, &v_off, 1, "");
+ l_gep(b, LLVMInt8TypeInContext(lc), v_tupdata_base, &v_off, 1, "");
}
/* compute address to store value at */
v_resultp = l_gep(b, TypeSizeT, v_tts_values, &l_attno, 1, "");
/* store null-byte (false) */
- LLVMBuildStore(b, l_int8_const(0),
+ LLVMBuildStore(b, l_int8_const(lc, 0),
l_gep(b, TypeStorageBool, v_tts_nulls, &l_attno, 1, ""));
/*
if (att->attbyval)
{
LLVMValueRef v_tmp_loaddata;
- LLVMTypeRef vartype = LLVMIntType(att->attlen * 8);
+ LLVMTypeRef vartype = LLVMIntTypeInContext(lc, att->attlen * 8);
LLVMTypeRef vartypep = LLVMPointerType(vartype, 0);
v_tmp_loaddata =
LLVMValueRef v_off = l_load(b, TypeSizeT, v_offp, "");
LLVMValueRef v_flags;
- LLVMBuildStore(b, l_int16_const(natts), v_nvalidp);
- v_off = LLVMBuildTrunc(b, v_off, LLVMInt32Type(), "");
+ LLVMBuildStore(b, l_int16_const(lc, natts), v_nvalidp);
+ v_off = LLVMBuildTrunc(b, v_off, LLVMInt32TypeInContext(lc), "");
LLVMBuildStore(b, v_off, v_slotoffp);
- v_flags = l_load(b, LLVMInt16Type(), v_flagsp, "tts_flags");
- v_flags = LLVMBuildOr(b, v_flags, l_int16_const(TTS_FLAG_SLOW), "");
+ v_flags = l_load(b, LLVMInt16TypeInContext(lc), v_flagsp, "tts_flags");
+ v_flags = LLVMBuildOr(b, v_flags, l_int16_const(lc, TTS_FLAG_SLOW), "");
LLVMBuildStore(b, v_flags, v_flagsp);
LLVMBuildRetVoid(b);
}
LLVMBuilderRef b;
LLVMModuleRef mod;
+ LLVMContextRef lc;
LLVMValueRef eval_fn;
LLVMBasicBlockRef entry;
LLVMBasicBlockRef *opblocks;
INSTR_TIME_SET_CURRENT(starttime);
mod = llvm_mutable_module(context);
+ lc = LLVMGetModuleContext(mod);
- b = LLVMCreateBuilder();
+ b = LLVMCreateBuilderInContext(lc);
funcname = llvm_expand_funcname(context, "evalexpr");
LLVMSetVisibility(eval_fn, LLVMDefaultVisibility);
llvm_copy_attributes(AttributeTemplate, eval_fn);
- entry = LLVMAppendBasicBlock(eval_fn, "entry");
+ entry = LLVMAppendBasicBlockInContext(lc, eval_fn, "entry");
/* build state */
v_state = LLVMGetParam(eval_fn, 0);
"");
LLVMBuildCondBr(b,
LLVMBuildICmp(b, LLVMIntUGE, v_nvalid,
- l_int16_const(op->d.fetch.last_var),
+ l_int16_const(lc, op->d.fetch.last_var),
""),
opblocks[i + 1], b_fetch);
LLVMValueRef params[2];
params[0] = v_slot;
- params[1] = l_int32_const(op->d.fetch.last_var);
+ params[1] = l_int32_const(lc, op->d.fetch.last_var);
l_call(b,
llvm_pg_var_func_type("slot_getsomeattrs_int"),
v_nulls = v_scannulls;
}
- v_attnum = l_int32_const(op->d.var.attnum);
+ v_attnum = l_int32_const(lc, op->d.var.attnum);
value = l_load_gep1(b, TypeSizeT, v_values, v_attnum, "");
isnull = l_load_gep1(b, TypeStorageBool, v_nulls, v_attnum, "");
LLVMBuildStore(b, value, v_resvaluep);
}
/* load data */
- v_attnum = l_int32_const(op->d.assign_var.attnum);
+ v_attnum = l_int32_const(lc, op->d.assign_var.attnum);
v_value = l_load_gep1(b, TypeSizeT, v_values, v_attnum, "");
v_isnull = l_load_gep1(b, TypeStorageBool, v_nulls, v_attnum, "");
/* compute addresses of targets */
- v_resultnum = l_int32_const(op->d.assign_var.resultnum);
+ v_resultnum = l_int32_const(lc, op->d.assign_var.resultnum);
v_rvaluep = l_gep(b,
TypeSizeT,
v_resultvalues,
v_isnull = l_load(b, TypeStorageBool, v_tmpisnullp, "");
/* compute addresses of targets */
- v_resultnum = l_int32_const(resultnum);
+ v_resultnum = l_int32_const(lc, resultnum);
v_rvaluep =
l_gep(b, TypeSizeT, v_resultvalues, &v_resultnum, 1, "");
v_risnullp =
v_isnull = l_load(b, TypeStorageBool, v_tmpisnullp, "");
/* compute addresses of targets */
- v_resultnum = l_int32_const(resultnum);
+ v_resultnum = l_int32_const(lc, resultnum);
v_rvaluep =
l_gep(b, TypeSizeT, v_resultvalues, &v_resultnum, 1, "");
v_risnullp =
v_cmpresult =
LLVMBuildTrunc(b,
l_load(b, TypeSizeT, v_resvaluep, ""),
- LLVMInt32Type(), "");
+ LLVMInt32TypeInContext(lc), "");
switch (rctype)
{
v_result = LLVMBuildICmp(b,
predicate,
v_cmpresult,
- l_int32_const(0),
+ l_int32_const(lc, 0),
"");
v_result = LLVMBuildZExt(b, v_result, TypeSizeT, "");
* load it from memory each time round.
*/
v_aggnop = l_ptr_const(&aggref->aggno,
- l_ptr(LLVMInt32Type()));
- v_aggno = l_load(b, LLVMInt32Type(), v_aggnop, "v_aggno");
+ l_ptr(LLVMInt32TypeInContext(lc)));
+ v_aggno = l_load(b, LLVMInt32TypeInContext(lc), v_aggnop, "v_aggno");
/* load agg value / null */
value = l_load_gep1(b, TypeSizeT, v_aggvalues, v_aggno, "aggvalue");
* expression). So load it from memory each time round.
*/
v_wfuncnop = l_ptr_const(&wfunc->wfuncno,
- l_ptr(LLVMInt32Type()));
- v_wfuncno = l_load(b, LLVMInt32Type(), v_wfuncnop, "v_wfuncno");
+ l_ptr(LLVMInt32TypeInContext(lc)));
+ v_wfuncno = l_load(b, LLVMInt32TypeInContext(lc), v_wfuncnop, "v_wfuncno");
/* load window func value / null */
value = l_load_gep1(b, TypeSizeT, v_aggvalues, v_wfuncno,
/* strict function, check for NULL args */
for (argno = 0; argno < nargs; argno++)
{
- LLVMValueRef v_argno = l_int32_const(argno);
+ LLVMValueRef v_argno = l_int32_const(lc, argno);
LLVMValueRef v_argisnull;
LLVMBasicBlockRef b_argnotnull;
v_aggstatep,
FIELDNO_AGGSTATE_ALL_PERGROUPS,
"aggstate.all_pergroups");
- v_setoff = l_int32_const(op->d.agg_init_trans.setoff);
- v_transno = l_int32_const(op->d.agg_init_trans.transno);
+ v_setoff = l_int32_const(lc, op->d.agg_init_trans.setoff);
+ v_transno = l_int32_const(lc, op->d.agg_init_trans.transno);
v_pergroupp =
l_gep(b,
StructAggStatePerGroupData,
FIELDNO_AGGSTATE_CURAGGCONTEXT,
"aggstate.curaggcontext");
- LLVMBuildStore(b, l_int32_const(op->d.agg_init_trans.setno),
+ LLVMBuildStore(b, l_int32_const(lc, op->d.agg_init_trans.setno),
v_current_set);
LLVMBuildStore(b, v_aggcontext,
v_curaggcontext);
FIELDNO_AGGSTATE_ALL_PERGROUPS,
"aggstate.all_pergroups");
v_setoff =
- l_int32_const(op->d.agg_strict_trans_check.setoff);
+ l_int32_const(lc, op->d.agg_strict_trans_check.setoff);
v_transno =
- l_int32_const(op->d.agg_strict_trans_check.transno);
+ l_int32_const(lc, op->d.agg_strict_trans_check.transno);
v_pergroupp =
l_gep(b,
StructAggStatePerGroupData,
v_aggstatep,
FIELDNO_AGGSTATE_ALL_PERGROUPS,
"aggstate.all_pergroups");
- v_setoff = l_int32_const(op->d.agg_trans.setoff);
- v_transno = l_int32_const(op->d.agg_trans.transno);
+ v_setoff = l_int32_const(lc, op->d.agg_trans.setoff);
+ v_transno = l_int32_const(lc, op->d.agg_trans.transno);
v_pergroupp =
l_gep(b,
StructAggStatePerGroupData,
/* set aggstate globals */
LLVMBuildStore(b, v_aggcontext, v_curaggcontext);
- LLVMBuildStore(b, l_int32_const(op->d.agg_trans.setno),
+ LLVMBuildStore(b, l_int32_const(lc, op->d.agg_trans.setno),
v_current_setp);
LLVMBuildStore(b, v_pertransp, v_current_pertransp);
LLVMModuleRef mod, FunctionCallInfo fcinfo,
LLVMValueRef *v_fcinfo_isnull)
{
+ LLVMContextRef lc;
LLVMValueRef v_fn;
LLVMValueRef v_fcinfo_isnullp;
LLVMValueRef v_retval;
LLVMValueRef v_fcinfo;
+ lc = LLVMGetModuleContext(mod);
+
v_fn = llvm_function_reference(context, b, mod, fcinfo);
v_fcinfo = l_ptr_const(fcinfo, l_ptr(StructFunctionCallInfoData));
LLVMValueRef v_lifetime = create_LifetimeEnd(mod);
LLVMValueRef params[2];
- params[0] = l_int64_const(sizeof(NullableDatum) * fcinfo->nargs);
- params[1] = l_ptr_const(fcinfo->args, l_ptr(LLVMInt8Type()));
+ params[0] = l_int64_const(lc, sizeof(NullableDatum) * fcinfo->nargs);
+ params[1] = l_ptr_const(fcinfo->args, l_ptr(LLVMInt8TypeInContext(lc)));
l_call(b, LLVMGetFunctionType(v_lifetime), v_lifetime, params, lengthof(params), "");
- params[0] = l_int64_const(sizeof(fcinfo->isnull));
- params[1] = l_ptr_const(&fcinfo->isnull, l_ptr(LLVMInt8Type()));
+ params[0] = l_int64_const(lc, sizeof(fcinfo->isnull));
+ params[1] = l_ptr_const(&fcinfo->isnull, l_ptr(LLVMInt8TypeInContext(lc)));
l_call(b, LLVMGetFunctionType(v_lifetime), v_lifetime, params, lengthof(params), "");
}
LLVMTypeRef sig;
LLVMValueRef fn;
LLVMTypeRef param_types[2];
+ LLVMContextRef lc;
/* LLVM 5+ has a variadic pointer argument */
#if LLVM_VERSION_MAJOR < 5
if (fn)
return fn;
- param_types[0] = LLVMInt64Type();
- param_types[1] = l_ptr(LLVMInt8Type());
+ lc = LLVMGetModuleContext(mod);
+ param_types[0] = LLVMInt64TypeInContext(lc);
+ param_types[1] = l_ptr(LLVMInt8TypeInContext(lc));
- sig = LLVMFunctionType(LLVMVoidType(),
- param_types, lengthof(param_types),
- false);
+ sig = LLVMFunctionType(LLVMVoidTypeInContext(lc), param_types,
+ lengthof(param_types), false);
fn = LLVMAddFunction(mod, nm, sig);
LLVMSetFunctionCallConv(fn, LLVMCCallConv);
llvm::ManagedStatic<SummaryCache> summary_cache;
-static std::unique_ptr<ImportMapTy> llvm_build_inline_plan(llvm::Module *mod);
+static std::unique_ptr<ImportMapTy> llvm_build_inline_plan(LLVMContextRef lc, llvm::Module *mod);
static void llvm_execute_inline_plan(llvm::Module *mod,
ImportMapTy *globalsToInline);
-static llvm::Module* load_module_cached(llvm::StringRef modPath);
-static std::unique_ptr<llvm::Module> load_module(llvm::StringRef Identifier);
+static llvm::Module* load_module_cached(LLVMContextRef c, llvm::StringRef modPath);
+static std::unique_ptr<llvm::Module> load_module(LLVMContextRef c, llvm::StringRef Identifier);
static std::unique_ptr<llvm::ModuleSummaryIndex> llvm_load_summary(llvm::StringRef path);
#define ilog(...) (void) 0
#endif
+/*
+ * Reset inlining related state. This needs to be called before the currently
+ * used LLVMContextRef is disposed (and a new one create), otherwise we would
+ * have dangling references to deleted modules.
+ */
+void
+llvm_inline_reset_caches(void)
+{
+ module_cache->clear();
+ summary_cache->clear();
+}
+
/*
* Perform inlining of external function references in M based on a simple
* cost based analysis.
void
llvm_inline(LLVMModuleRef M)
{
+ LLVMContextRef lc = LLVMGetModuleContext(M);
llvm::Module *mod = llvm::unwrap(M);
- std::unique_ptr<ImportMapTy> globalsToInline = llvm_build_inline_plan(mod);
+ std::unique_ptr<ImportMapTy> globalsToInline = llvm_build_inline_plan(lc, mod);
if (!globalsToInline)
return;
llvm_execute_inline_plan(mod, globalsToInline.get());
* mod.
*/
static std::unique_ptr<ImportMapTy>
-llvm_build_inline_plan(llvm::Module *mod)
+llvm_build_inline_plan(LLVMContextRef lc, llvm::Module *mod)
{
std::unique_ptr<ImportMapTy> globalsToInline(new ImportMapTy());
FunctionInlineStates functionStates;
continue;
}
- defMod = load_module_cached(modPath);
+ defMod = load_module_cached(lc, modPath);
if (defMod->materializeMetadata())
elog(FATAL, "failed to materialize metadata");
* the cache state would get corrupted.
*/
static llvm::Module*
-load_module_cached(llvm::StringRef modPath)
+load_module_cached(LLVMContextRef lc, llvm::StringRef modPath)
{
auto it = module_cache->find(modPath);
if (it == module_cache->end())
{
it = module_cache->insert(
- std::make_pair(modPath, load_module(modPath))).first;
+ std::make_pair(modPath, load_module(lc, modPath))).first;
}
return it->second.get();
}
static std::unique_ptr<llvm::Module>
-load_module(llvm::StringRef Identifier)
+load_module(LLVMContextRef lc, llvm::StringRef Identifier)
{
LLVMMemoryBufferRef buf;
LLVMModuleRef mod;
if (LLVMCreateMemoryBufferWithContentsOfFile(path, &buf, &msg))
elog(FATAL, "failed to open bitcode file \"%s\": %s",
path, msg);
- if (LLVMGetBitcodeModuleInContext2(LLVMGetGlobalContext(), buf, &mod))
+ if (LLVMGetBitcodeModuleInContext2(lc, buf, &mod))
elog(FATAL, "failed to parse bitcode in file \"%s\"", path);
/*
/* number of modules created */
size_t module_generation;
+ /*
+ * The LLVM Context used by this JIT context. An LLVM context is reused
+ * across many compilations, but occasionally reset to prevent it using
+ * too much memory due to more and more types accumulating.
+ */
+ LLVMContextRef llvm_context;
+
/* current, "open for write", module */
LLVMModuleRef module;
LLVMModuleRef mod,
FunctionCallInfo fcinfo);
+extern void llvm_inline_reset_caches(void);
extern void llvm_inline(LLVMModuleRef mod);
/*
* Emit constant integer.
*/
static inline LLVMValueRef
-l_int8_const(int8 i)
+l_int8_const(LLVMContextRef lc, int8 i)
{
- return LLVMConstInt(LLVMInt8Type(), i, false);
+ return LLVMConstInt(LLVMInt8TypeInContext(lc), i, false);
}
/*
* Emit constant integer.
*/
static inline LLVMValueRef
-l_int16_const(int16 i)
+l_int16_const(LLVMContextRef lc, int16 i)
{
- return LLVMConstInt(LLVMInt16Type(), i, false);
+ return LLVMConstInt(LLVMInt16TypeInContext(lc), i, false);
}
/*
* Emit constant integer.
*/
static inline LLVMValueRef
-l_int32_const(int32 i)
+l_int32_const(LLVMContextRef lc, int32 i)
{
- return LLVMConstInt(LLVMInt32Type(), i, false);
+ return LLVMConstInt(LLVMInt32TypeInContext(lc), i, false);
}
/*
* Emit constant integer.
*/
static inline LLVMValueRef
-l_int64_const(int64 i)
+l_int64_const(LLVMContextRef lc, int64 i)
{
- return LLVMConstInt(LLVMInt64Type(), i, false);
+ return LLVMConstInt(LLVMInt64TypeInContext(lc), i, false);
}
/*
{
char buf[512];
va_list args;
+ LLVMContextRef lc;
va_start(args, fmt);
vsnprintf(buf, sizeof(buf), fmt, args);
va_end(args);
- return LLVMInsertBasicBlock(r, buf);
+ lc = LLVMGetTypeContext(LLVMTypeOf(LLVMGetBasicBlockParent(r)));
+
+ return LLVMInsertBasicBlockInContext(lc, r, buf);
}
/* separate, because pg_attribute_printf(2, 3) can't appear in definition */
{
char buf[512];
va_list args;
+ LLVMContextRef lc;
va_start(args, fmt);
vsnprintf(buf, sizeof(buf), fmt, args);
va_end(args);
- return LLVMAppendBasicBlock(f, buf);
+ lc = LLVMGetTypeContext(LLVMTypeOf(f));
+
+ return LLVMAppendBasicBlockInContext(lc, f, buf);
}
/*
const char argname[] = "readonly";
LLVMAttributeRef ref;
- ref = LLVMCreateStringAttribute(LLVMGetGlobalContext(),
+ ref = LLVMCreateStringAttribute(LLVMGetTypeContext(LLVMTypeOf(f)),
argname,
sizeof(argname) - 1,
NULL, 0);
id = LLVMGetEnumAttributeKindForName(argname,
sizeof(argname) - 1);
- attr = LLVMCreateEnumAttribute(LLVMGetGlobalContext(), id, 0);
+ attr = LLVMCreateEnumAttribute(LLVMGetTypeContext(LLVMTypeOf(f)), id, 0);
LLVMAddCallSiteAttribute(f, LLVMAttributeFunctionIndex, attr);
}
projects / thirdparty / postgresql.git / commitdiff
