LLVMTypeRef StructAggState;
LLVMTypeRef StructAggStatePerGroupData;
LLVMTypeRef StructAggStatePerTransData;
+LLVMTypeRef StructPlanState;
LLVMValueRef AttributeTemplate;
-LLVMValueRef FuncStrlen;
-LLVMValueRef FuncVarsizeAny;
-LLVMValueRef FuncSlotGetsomeattrsInt;
-LLVMValueRef FuncSlotGetmissingattrs;
-LLVMValueRef FuncMakeExpandedObjectReadOnlyInternal;
-LLVMValueRef FuncExecEvalSubscriptingRef;
-LLVMValueRef FuncExecEvalSysVar;
-LLVMValueRef FuncExecAggTransReparent;
-LLVMValueRef FuncExecAggInitGroup;
+LLVMValueRef ExecEvalSubroutineTemplate;
+LLVMModuleRef llvm_types_module = NULL;
static bool llvm_session_initialized = false;
static size_t llvm_generation = 0;
}
/*
- * Return declaration for passed function, adding it to the module if
- * necessary.
+ * Return type of a variable in llvmjit_types.c. This is useful to keep types
+ * in sync between plain C and JIT related code.
+ */
+LLVMTypeRef
+llvm_pg_var_type(const char *varname)
+{
+ 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;
+}
+
+/*
+ * Return function type of a variable in llvmjit_types.c. This is useful to
+ * keep function types in sync between C and JITed code.
+ */
+LLVMTypeRef
+llvm_pg_var_func_type(const char *varname)
+{
+ 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;
+}
+
+/*
+ * Return declaration for a function referenced in llvmjit_types.c, adding it
+ * to the module if necessary.
*
- * This is used to make functions imported by llvm_create_types() known to the
- * module that's currently being worked on.
+ * This is used to make functions discovered via llvm_create_types() known to
+ * the module that's currently being worked on.
*/
LLVMValueRef
-llvm_get_decl(LLVMModuleRef mod, LLVMValueRef v_src)
+llvm_pg_func(LLVMModuleRef mod, const char *funcname)
{
+ LLVMValueRef v_srcfn;
LLVMValueRef v_fn;
/* don't repeatedly add function */
- v_fn = LLVMGetNamedFunction(mod, LLVMGetValueName(v_src));
+ 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,
- LLVMGetValueName(v_src),
- LLVMGetElementType(LLVMTypeOf(v_src)));
- llvm_copy_attributes(v_src, v_fn);
+ funcname,
+ LLVMGetFunctionType(v_srcfn));
+ llvm_copy_attributes(v_srcfn, v_fn);
return v_fn;
}
fcinfo->flinfo->fn_oid);
v_fn = LLVMGetNamedGlobal(mod, funcname);
if (v_fn != 0)
- return LLVMBuildLoad(builder, v_fn, "");
+ return l_load(builder, TypePGFunction, v_fn, "");
v_fn_addr = l_ptr_const(fcinfo->flinfo->fn_addr, TypePGFunction);
LLVMSetLinkage(v_fn, LLVMPrivateLinkage);
LLVMSetUnnamedAddr(v_fn, true);
- return LLVMBuildLoad(builder, v_fn, "");
+ return l_load(builder, TypePGFunction, v_fn, "");
}
/* check if function already has been added */
if (v_fn != 0)
return v_fn;
- v_fn = LLVMAddFunction(mod, funcname, LLVMGetElementType(TypePGFunction));
+ v_fn = LLVMAddFunction(mod, funcname, LLVMGetFunctionType(AttributeTemplate));
return v_fn;
}
LLVMInitializeNativeAsmParser();
/*
- * When targeting an LLVM version with opaque pointers enabled by
- * default, turn them off for the context we build our code in. We don't
- * need to do so for other contexts (e.g. llvm_ts_context). Once the IR is
- * generated, it carries the necessary information.
+ * 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_ts_context). Once the IR is generated, it carries the necessary
+ * information.
+ *
+ * For 16 and above, opaque pointers must be used, and we have special
+ * code for that.
*/
-#if LLVM_VERSION_MAJOR > 14
+#if LLVM_VERSION_MAJOR == 15
LLVMContextSetOpaquePointers(LLVMGetGlobalContext(), false);
#endif
#endif /* LLVM_VERSION_MAJOR > 11 */
}
-/* helper for llvm_create_types, returning a global var's type */
-static LLVMTypeRef
-load_type(LLVMModuleRef mod, const char *name)
-{
- LLVMValueRef value;
- LLVMTypeRef typ;
-
- /* this'll return a *pointer* to the global */
- value = LLVMGetNamedGlobal(mod, name);
- if (!value)
- elog(ERROR, "type %s is unknown", name);
-
- /* therefore look at the contained type and return that */
- typ = LLVMTypeOf(value);
- Assert(typ != NULL);
- typ = LLVMGetElementType(typ);
- Assert(typ != NULL);
- return typ;
-}
-
/* helper for llvm_create_types, returning a function's return type */
static LLVMTypeRef
load_return_type(LLVMModuleRef mod, const char *name)
if (!value)
elog(ERROR, "function %s is unknown", name);
- /* get type of function pointer */
- typ = LLVMTypeOf(value);
- Assert(typ != NULL);
- /* dereference pointer */
- typ = LLVMGetElementType(typ);
- Assert(typ != NULL);
- /* and look at return type */
- typ = LLVMGetReturnType(typ);
- Assert(typ != NULL);
+ typ = LLVMGetFunctionReturnType(value); /* in llvmjit_wrap.cpp */
return typ;
}
char path[MAXPGPATH];
LLVMMemoryBufferRef buf;
char *msg;
- LLVMModuleRef mod = NULL;
snprintf(path, MAXPGPATH, "%s/%s", pkglib_path, "llvmjit_types.bc");
}
/* eagerly load contents, going to need it all */
- if (LLVMParseBitcode2(buf, &mod))
+ if (LLVMParseBitcode2(buf, &llvm_types_module))
{
elog(ERROR, "LLVMParseBitcode2 of %s failed", path);
}
* Load triple & layout from clang emitted file so we're guaranteed to be
* compatible.
*/
- llvm_triple = pstrdup(LLVMGetTarget(mod));
- llvm_layout = pstrdup(LLVMGetDataLayoutStr(mod));
-
- TypeSizeT = load_type(mod, "TypeSizeT");
- TypeParamBool = load_return_type(mod, "FunctionReturningBool");
- TypeStorageBool = load_type(mod, "TypeStorageBool");
- TypePGFunction = load_type(mod, "TypePGFunction");
- StructNullableDatum = load_type(mod, "StructNullableDatum");
- StructExprContext = load_type(mod, "StructExprContext");
- StructExprEvalStep = load_type(mod, "StructExprEvalStep");
- StructExprState = load_type(mod, "StructExprState");
- StructFunctionCallInfoData = load_type(mod, "StructFunctionCallInfoData");
- StructMemoryContextData = load_type(mod, "StructMemoryContextData");
- StructTupleTableSlot = load_type(mod, "StructTupleTableSlot");
- StructHeapTupleTableSlot = load_type(mod, "StructHeapTupleTableSlot");
- StructMinimalTupleTableSlot = load_type(mod, "StructMinimalTupleTableSlot");
- StructHeapTupleData = load_type(mod, "StructHeapTupleData");
- StructTupleDescData = load_type(mod, "StructTupleDescData");
- StructAggState = load_type(mod, "StructAggState");
- StructAggStatePerGroupData = load_type(mod, "StructAggStatePerGroupData");
- StructAggStatePerTransData = load_type(mod, "StructAggStatePerTransData");
-
- AttributeTemplate = LLVMGetNamedFunction(mod, "AttributeTemplate");
- FuncStrlen = LLVMGetNamedFunction(mod, "strlen");
- FuncVarsizeAny = LLVMGetNamedFunction(mod, "varsize_any");
- FuncSlotGetsomeattrsInt = LLVMGetNamedFunction(mod, "slot_getsomeattrs_int");
- FuncSlotGetmissingattrs = LLVMGetNamedFunction(mod, "slot_getmissingattrs");
- FuncMakeExpandedObjectReadOnlyInternal = LLVMGetNamedFunction(mod, "MakeExpandedObjectReadOnlyInternal");
- FuncExecEvalSubscriptingRef = LLVMGetNamedFunction(mod, "ExecEvalSubscriptingRef");
- FuncExecEvalSysVar = LLVMGetNamedFunction(mod, "ExecEvalSysVar");
- FuncExecAggTransReparent = LLVMGetNamedFunction(mod, "ExecAggTransReparent");
- FuncExecAggInitGroup = LLVMGetNamedFunction(mod, "ExecAggInitGroup");
-
- /*
- * Leave the module alive, otherwise references to function would be
- * dangling.
- */
-
- return;
+ 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");
+ 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");
}
/*
v_slot = LLVMGetParam(v_deform_fn, 0);
v_tts_values =
- l_load_struct_gep(b, v_slot, FIELDNO_TUPLETABLESLOT_VALUES,
+ l_load_struct_gep(b, StructTupleTableSlot, v_slot, FIELDNO_TUPLETABLESLOT_VALUES,
"tts_values");
v_tts_nulls =
- l_load_struct_gep(b, v_slot, FIELDNO_TUPLETABLESLOT_ISNULL,
+ l_load_struct_gep(b, StructTupleTableSlot, v_slot, FIELDNO_TUPLETABLESLOT_ISNULL,
"tts_ISNULL");
- v_flagsp = LLVMBuildStructGEP(b, v_slot, FIELDNO_TUPLETABLESLOT_FLAGS, "");
- v_nvalidp = LLVMBuildStructGEP(b, v_slot, FIELDNO_TUPLETABLESLOT_NVALID, "");
+ v_flagsp = l_struct_gep(b, StructTupleTableSlot, v_slot, FIELDNO_TUPLETABLESLOT_FLAGS, "");
+ v_nvalidp = l_struct_gep(b, StructTupleTableSlot, v_slot, FIELDNO_TUPLETABLESLOT_NVALID, "");
if (ops == &TTSOpsHeapTuple || ops == &TTSOpsBufferHeapTuple)
{
v_slot,
l_ptr(StructHeapTupleTableSlot),
"heapslot");
- v_slotoffp = LLVMBuildStructGEP(b, v_heapslot, FIELDNO_HEAPTUPLETABLESLOT_OFF, "");
+ v_slotoffp = l_struct_gep(b, StructHeapTupleTableSlot, v_heapslot, FIELDNO_HEAPTUPLETABLESLOT_OFF, "");
v_tupleheaderp =
- l_load_struct_gep(b, v_heapslot, FIELDNO_HEAPTUPLETABLESLOT_TUPLE,
+ l_load_struct_gep(b, StructHeapTupleTableSlot, v_heapslot, FIELDNO_HEAPTUPLETABLESLOT_TUPLE,
"tupleheader");
}
v_slot,
l_ptr(StructMinimalTupleTableSlot),
"minimalslot");
- v_slotoffp = LLVMBuildStructGEP(b, v_minimalslot, FIELDNO_MINIMALTUPLETABLESLOT_OFF, "");
+ v_slotoffp = l_struct_gep(b,
+ StructMinimalTupleTableSlot,
+ v_minimalslot,
+ FIELDNO_MINIMALTUPLETABLESLOT_OFF, "");
v_tupleheaderp =
- l_load_struct_gep(b, v_minimalslot, FIELDNO_MINIMALTUPLETABLESLOT_TUPLE,
+ l_load_struct_gep(b,
+ StructMinimalTupleTableSlot,
+ v_minimalslot,
+ FIELDNO_MINIMALTUPLETABLESLOT_TUPLE,
"tupleheader");
}
else
}
v_tuplep =
- l_load_struct_gep(b, v_tupleheaderp, FIELDNO_HEAPTUPLEDATA_DATA,
+ l_load_struct_gep(b,
+ StructHeapTupleData,
+ v_tupleheaderp,
+ FIELDNO_HEAPTUPLEDATA_DATA,
"tuple");
v_bits =
LLVMBuildBitCast(b,
- LLVMBuildStructGEP(b, v_tuplep,
- FIELDNO_HEAPTUPLEHEADERDATA_BITS,
- ""),
+ l_struct_gep(b,
+ StructHeapTupleHeaderData,
+ v_tuplep,
+ FIELDNO_HEAPTUPLEHEADERDATA_BITS,
+ ""),
l_ptr(LLVMInt8Type()),
"t_bits");
v_infomask1 =
- l_load_struct_gep(b, v_tuplep,
+ l_load_struct_gep(b,
+ StructHeapTupleHeaderData,
+ v_tuplep,
FIELDNO_HEAPTUPLEHEADERDATA_INFOMASK,
"infomask1");
v_infomask2 =
l_load_struct_gep(b,
+ StructHeapTupleHeaderData,
v_tuplep, FIELDNO_HEAPTUPLEHEADERDATA_INFOMASK2,
"infomask2");
*/
v_hoff =
LLVMBuildZExt(b,
- l_load_struct_gep(b, v_tuplep,
+ l_load_struct_gep(b,
+ StructHeapTupleHeaderData,
+ v_tuplep,
FIELDNO_HEAPTUPLEHEADERDATA_HOFF,
""),
LLVMInt32Type(), "t_hoff");
- v_tupdata_base =
- LLVMBuildGEP(b,
- LLVMBuildBitCast(b,
- v_tuplep,
- l_ptr(LLVMInt8Type()),
- ""),
- &v_hoff, 1,
- "v_tupdata_base");
+ v_tupdata_base = l_gep(b,
+ LLVMInt8Type(),
+ LLVMBuildBitCast(b,
+ v_tuplep,
+ l_ptr(LLVMInt8Type()),
+ ""),
+ &v_hoff, 1,
+ "v_tupdata_base");
/*
* Load tuple start offset from slot. Will be reset below in case there's
{
LLVMValueRef v_off_start;
- v_off_start = LLVMBuildLoad(b, v_slotoffp, "v_slot_off");
+ v_off_start = l_load(b, LLVMInt32Type(), v_slotoffp, "v_slot_off");
v_off_start = LLVMBuildZExt(b, v_off_start, TypeSizeT, "");
LLVMBuildStore(b, v_off_start, v_offp);
}
else
{
LLVMValueRef v_params[3];
+ LLVMValueRef f;
/* branch if not all columns available */
LLVMBuildCondBr(b,
v_params[0] = v_slot;
v_params[1] = LLVMBuildZExt(b, v_maxatt, LLVMInt32Type(), "");
v_params[2] = l_int32_const(natts);
- LLVMBuildCall(b, llvm_get_decl(mod, FuncSlotGetmissingattrs),
- v_params, lengthof(v_params), "");
+ f = llvm_pg_func(mod, "slot_getmissingattrs");
+ l_call(b,
+ LLVMGetFunctionType(f), f,
+ v_params, lengthof(v_params), "");
LLVMBuildBr(b, b_find_start);
}
LLVMPositionBuilderAtEnd(b, b_find_start);
- v_nvalid = LLVMBuildLoad(b, v_nvalidp, "");
+ v_nvalid = l_load(b, LLVMInt16Type(), v_nvalidp, "");
/*
* Build switch to go from nvalid to the right startblock. Callers
v_nullbyteno = l_int32_const(attnum >> 3);
v_nullbytemask = l_int8_const(1 << ((attnum) & 0x07));
- v_nullbyte = l_load_gep1(b, v_bits, v_nullbyteno, "attnullbyte");
+ v_nullbyte = l_load_gep1(b, LLVMInt8Type(), v_bits, v_nullbyteno, "attnullbyte");
v_nullbit = LLVMBuildICmp(b,
LLVMIntEQ,
/* store null-byte */
LLVMBuildStore(b,
l_int8_const(1),
- LLVMBuildGEP(b, v_tts_nulls, &l_attno, 1, ""));
+ l_gep(b, LLVMInt8Type(), v_tts_nulls, &l_attno, 1, ""));
/* store zero datum */
LLVMBuildStore(b,
l_sizet_const(0),
- LLVMBuildGEP(b, v_tts_values, &l_attno, 1, ""));
+ l_gep(b, TypeSizeT, v_tts_values, &l_attno, 1, ""));
LLVMBuildBr(b, b_next);
attguaranteedalign = false;
/* don't know if short varlena or not */
attguaranteedalign = false;
- v_off = LLVMBuildLoad(b, v_offp, "");
+ v_off = l_load(b, TypeSizeT, v_offp, "");
v_possible_padbyte =
- l_load_gep1(b, v_tupdata_base, v_off, "padbyte");
+ l_load_gep1(b, LLVMInt8Type(), v_tupdata_base, v_off, "padbyte");
v_ispad =
LLVMBuildICmp(b, LLVMIntEQ,
v_possible_padbyte, l_int8_const(0),
/* translation of alignment code (cf TYPEALIGN()) */
{
LLVMValueRef v_off_aligned;
- LLVMValueRef v_off = LLVMBuildLoad(b, v_offp, "");
+ LLVMValueRef v_off = l_load(b, TypeSizeT, v_offp, "");
/* ((ALIGNVAL) - 1) */
LLVMValueRef v_alignval = l_sizet_const(alignto - 1);
/* compute address to load data from */
{
- LLVMValueRef v_off = LLVMBuildLoad(b, v_offp, "");
+ LLVMValueRef v_off = l_load(b, TypeSizeT, v_offp, "");
v_attdatap =
- LLVMBuildGEP(b, v_tupdata_base, &v_off, 1, "");
+ l_gep(b, LLVMInt8Type(), v_tupdata_base, &v_off, 1, "");
}
/* compute address to store value at */
- v_resultp = LLVMBuildGEP(b, v_tts_values, &l_attno, 1, "");
+ v_resultp = l_gep(b, TypeSizeT, v_tts_values, &l_attno, 1, "");
/* store null-byte (false) */
LLVMBuildStore(b, l_int8_const(0),
- LLVMBuildGEP(b, v_tts_nulls, &l_attno, 1, ""));
+ l_gep(b, TypeStorageBool, v_tts_nulls, &l_attno, 1, ""));
/*
* Store datum. For byval: datums copy the value, extend to Datum's
if (att->attbyval)
{
LLVMValueRef v_tmp_loaddata;
- LLVMTypeRef vartypep =
- LLVMPointerType(LLVMIntType(att->attlen * 8), 0);
+ LLVMTypeRef vartype = LLVMIntType(att->attlen * 8);
+ LLVMTypeRef vartypep = LLVMPointerType(vartype, 0);
v_tmp_loaddata =
LLVMBuildPointerCast(b, v_attdatap, vartypep, "");
- v_tmp_loaddata = LLVMBuildLoad(b, v_tmp_loaddata, "attr_byval");
+ v_tmp_loaddata = l_load(b, vartype, v_tmp_loaddata, "attr_byval");
v_tmp_loaddata = LLVMBuildZExt(b, v_tmp_loaddata, TypeSizeT, "");
LLVMBuildStore(b, v_tmp_loaddata, v_resultp);
}
else if (att->attlen == -1)
{
- v_incby = LLVMBuildCall(b,
- llvm_get_decl(mod, FuncVarsizeAny),
- &v_attdatap, 1,
- "varsize_any");
+ v_incby = l_call(b,
+ llvm_pg_var_func_type("varsize_any"),
+ llvm_pg_func(mod, "varsize_any"),
+ &v_attdatap, 1,
+ "varsize_any");
l_callsite_ro(v_incby);
l_callsite_alwaysinline(v_incby);
}
else if (att->attlen == -2)
{
- v_incby = LLVMBuildCall(b,
- llvm_get_decl(mod, FuncStrlen),
- &v_attdatap, 1, "strlen");
+ v_incby = l_call(b,
+ llvm_pg_var_func_type("strlen"),
+ llvm_pg_func(mod, "strlen"),
+ &v_attdatap, 1, "strlen");
l_callsite_ro(v_incby);
}
else
{
- LLVMValueRef v_off = LLVMBuildLoad(b, v_offp, "");
+ LLVMValueRef v_off = l_load(b, TypeSizeT, v_offp, "");
v_off = LLVMBuildAdd(b, v_off, v_incby, "increment_offset");
LLVMBuildStore(b, v_off, v_offp);
LLVMPositionBuilderAtEnd(b, b_out);
{
- LLVMValueRef v_off = LLVMBuildLoad(b, v_offp, "");
+ 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, v_off, v_slotoffp);
- v_flags = LLVMBuildLoad(b, v_flagsp, "tts_flags");
+ v_flags = l_load(b, LLVMInt16Type(), v_flagsp, "tts_flags");
v_flags = LLVMBuildOr(b, v_flags, l_int16_const(TTS_FLAG_SLOW), "");
LLVMBuildStore(b, v_flags, v_flagsp);
LLVMBuildRetVoid(b);
LLVMBuilderRef b;
LLVMModuleRef mod;
- LLVMTypeRef eval_sig;
LLVMValueRef eval_fn;
LLVMBasicBlockRef entry;
LLVMBasicBlockRef *opblocks;
funcname = llvm_expand_funcname(context, "evalexpr");
- /* Create the signature and function */
- {
- LLVMTypeRef param_types[3];
-
- param_types[0] = l_ptr(StructExprState); /* state */
- param_types[1] = l_ptr(StructExprContext); /* econtext */
- param_types[2] = l_ptr(TypeStorageBool); /* isnull */
-
- eval_sig = LLVMFunctionType(TypeSizeT,
- param_types, lengthof(param_types),
- false);
- }
- eval_fn = LLVMAddFunction(mod, funcname, eval_sig);
+ /* create function */
+ eval_fn = LLVMAddFunction(mod, funcname,
+ llvm_pg_var_func_type("ExecInterpExprStillValid"));
LLVMSetLinkage(eval_fn, LLVMExternalLinkage);
LLVMSetVisibility(eval_fn, LLVMDefaultVisibility);
llvm_copy_attributes(AttributeTemplate, eval_fn);
LLVMPositionBuilderAtEnd(b, entry);
- v_tmpvaluep = LLVMBuildStructGEP(b, v_state,
- FIELDNO_EXPRSTATE_RESVALUE,
- "v.state.resvalue");
- v_tmpisnullp = LLVMBuildStructGEP(b, v_state,
- FIELDNO_EXPRSTATE_RESNULL,
- "v.state.resnull");
+ v_tmpvaluep = l_struct_gep(b,
+ StructExprState,
+ v_state,
+ FIELDNO_EXPRSTATE_RESVALUE,
+ "v.state.resvalue");
+ v_tmpisnullp = l_struct_gep(b,
+ StructExprState,
+ v_state,
+ FIELDNO_EXPRSTATE_RESNULL,
+ "v.state.resnull");
/* build global slots */
- v_scanslot = l_load_struct_gep(b, v_econtext,
+ v_scanslot = l_load_struct_gep(b,
+ StructExprContext,
+ v_econtext,
FIELDNO_EXPRCONTEXT_SCANTUPLE,
"v_scanslot");
- v_innerslot = l_load_struct_gep(b, v_econtext,
+ v_innerslot = l_load_struct_gep(b,
+ StructExprContext,
+ v_econtext,
FIELDNO_EXPRCONTEXT_INNERTUPLE,
"v_innerslot");
- v_outerslot = l_load_struct_gep(b, v_econtext,
+ v_outerslot = l_load_struct_gep(b,
+ StructExprContext,
+ v_econtext,
FIELDNO_EXPRCONTEXT_OUTERTUPLE,
"v_outerslot");
- v_resultslot = l_load_struct_gep(b, v_state,
+ v_resultslot = l_load_struct_gep(b,
+ StructExprState,
+ v_state,
FIELDNO_EXPRSTATE_RESULTSLOT,
"v_resultslot");
/* build global values/isnull pointers */
- v_scanvalues = l_load_struct_gep(b, v_scanslot,
+ v_scanvalues = l_load_struct_gep(b,
+ StructTupleTableSlot,
+ v_scanslot,
FIELDNO_TUPLETABLESLOT_VALUES,
"v_scanvalues");
- v_scannulls = l_load_struct_gep(b, v_scanslot,
+ v_scannulls = l_load_struct_gep(b,
+ StructTupleTableSlot,
+ v_scanslot,
FIELDNO_TUPLETABLESLOT_ISNULL,
"v_scannulls");
- v_innervalues = l_load_struct_gep(b, v_innerslot,
+ v_innervalues = l_load_struct_gep(b,
+ StructTupleTableSlot,
+ v_innerslot,
FIELDNO_TUPLETABLESLOT_VALUES,
"v_innervalues");
- v_innernulls = l_load_struct_gep(b, v_innerslot,
+ v_innernulls = l_load_struct_gep(b,
+ StructTupleTableSlot,
+ v_innerslot,
FIELDNO_TUPLETABLESLOT_ISNULL,
"v_innernulls");
- v_outervalues = l_load_struct_gep(b, v_outerslot,
+ v_outervalues = l_load_struct_gep(b,
+ StructTupleTableSlot,
+ v_outerslot,
FIELDNO_TUPLETABLESLOT_VALUES,
"v_outervalues");
- v_outernulls = l_load_struct_gep(b, v_outerslot,
+ v_outernulls = l_load_struct_gep(b,
+ StructTupleTableSlot,
+ v_outerslot,
FIELDNO_TUPLETABLESLOT_ISNULL,
"v_outernulls");
- v_resultvalues = l_load_struct_gep(b, v_resultslot,
+ v_resultvalues = l_load_struct_gep(b,
+ StructTupleTableSlot,
+ v_resultslot,
FIELDNO_TUPLETABLESLOT_VALUES,
"v_resultvalues");
- v_resultnulls = l_load_struct_gep(b, v_resultslot,
+ v_resultnulls = l_load_struct_gep(b,
+ StructTupleTableSlot,
+ v_resultslot,
FIELDNO_TUPLETABLESLOT_ISNULL,
"v_resultnulls");
/* aggvalues/aggnulls */
- v_aggvalues = l_load_struct_gep(b, v_econtext,
+ v_aggvalues = l_load_struct_gep(b,
+ StructExprContext,
+ v_econtext,
FIELDNO_EXPRCONTEXT_AGGVALUES,
"v.econtext.aggvalues");
- v_aggnulls = l_load_struct_gep(b, v_econtext,
+ v_aggnulls = l_load_struct_gep(b,
+ StructExprContext,
+ v_econtext,
FIELDNO_EXPRCONTEXT_AGGNULLS,
"v.econtext.aggnulls");
LLVMValueRef v_tmpisnull,
v_tmpvalue;
- v_tmpvalue = LLVMBuildLoad(b, v_tmpvaluep, "");
- v_tmpisnull = LLVMBuildLoad(b, v_tmpisnullp, "");
+ v_tmpvalue = l_load(b, TypeSizeT, v_tmpvaluep, "");
+ v_tmpisnull = l_load(b, TypeStorageBool, v_tmpisnullp, "");
LLVMBuildStore(b, v_tmpisnull, v_isnullp);
* be a virtual slot.
*/
v_nvalid =
- l_load_struct_gep(b, v_slot,
+ l_load_struct_gep(b,
+ StructTupleTableSlot,
+ v_slot,
FIELDNO_TUPLETABLESLOT_NVALID,
"");
LLVMBuildCondBr(b,
params[0] = v_slot;
- LLVMBuildCall(b, l_jit_deform,
- params, lengthof(params), "");
+ l_call(b,
+ LLVMGetFunctionType(l_jit_deform),
+ l_jit_deform,
+ params, lengthof(params), "");
}
else
{
params[0] = v_slot;
params[1] = l_int32_const(op->d.fetch.last_var);
- LLVMBuildCall(b,
- llvm_get_decl(mod, FuncSlotGetsomeattrsInt),
- params, lengthof(params), "");
+ l_call(b,
+ llvm_pg_var_func_type("slot_getsomeattrs_int"),
+ llvm_pg_func(mod, "slot_getsomeattrs_int"),
+ params, lengthof(params), "");
}
LLVMBuildBr(b, opblocks[i + 1]);
}
v_attnum = l_int32_const(op->d.var.attnum);
- value = l_load_gep1(b, v_values, v_attnum, "");
- isnull = l_load_gep1(b, v_nulls, v_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);
LLVMBuildStore(b, isnull, v_resnullp);
v_params[2] = v_econtext;
v_params[3] = v_slot;
- LLVMBuildCall(b,
- llvm_get_decl(mod, FuncExecEvalSysVar),
- v_params, lengthof(v_params), "");
+ l_call(b,
+ llvm_pg_var_func_type("ExecEvalSysVar"),
+ llvm_pg_func(mod, "ExecEvalSysVar"),
+ v_params, lengthof(v_params), "");
LLVMBuildBr(b, opblocks[i + 1]);
break;
/* load data */
v_attnum = l_int32_const(op->d.assign_var.attnum);
- v_value = l_load_gep1(b, v_values, v_attnum, "");
- v_isnull = l_load_gep1(b, v_nulls, v_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_rvaluep = LLVMBuildGEP(b, v_resultvalues,
- &v_resultnum, 1, "");
- v_risnullp = LLVMBuildGEP(b, v_resultnulls,
- &v_resultnum, 1, "");
+ v_rvaluep = l_gep(b,
+ TypeSizeT,
+ v_resultvalues,
+ &v_resultnum, 1, "");
+ v_risnullp = l_gep(b,
+ TypeStorageBool,
+ v_resultnulls,
+ &v_resultnum, 1, "");
/* and store */
LLVMBuildStore(b, v_value, v_rvaluep);
size_t resultnum = op->d.assign_tmp.resultnum;
/* load data */
- v_value = LLVMBuildLoad(b, v_tmpvaluep, "");
- v_isnull = LLVMBuildLoad(b, v_tmpisnullp, "");
+ v_value = l_load(b, TypeSizeT, v_tmpvaluep, "");
+ v_isnull = l_load(b, TypeStorageBool, v_tmpisnullp, "");
/* compute addresses of targets */
v_resultnum = l_int32_const(resultnum);
v_rvaluep =
- LLVMBuildGEP(b, v_resultvalues, &v_resultnum, 1, "");
+ l_gep(b, TypeSizeT, v_resultvalues, &v_resultnum, 1, "");
v_risnullp =
- LLVMBuildGEP(b, v_resultnulls, &v_resultnum, 1, "");
+ l_gep(b, TypeStorageBool, v_resultnulls, &v_resultnum, 1, "");
/* and store */
LLVMBuildStore(b, v_value, v_rvaluep);
"op.%d.assign_tmp.notnull", i);
/* load data */
- v_value = LLVMBuildLoad(b, v_tmpvaluep, "");
- v_isnull = LLVMBuildLoad(b, v_tmpisnullp, "");
+ v_value = l_load(b, TypeSizeT, v_tmpvaluep, "");
+ v_isnull = l_load(b, TypeStorageBool, v_tmpisnullp, "");
/* compute addresses of targets */
v_resultnum = l_int32_const(resultnum);
- v_rvaluep = LLVMBuildGEP(b, v_resultvalues,
- &v_resultnum, 1, "");
- v_risnullp = LLVMBuildGEP(b, v_resultnulls,
- &v_resultnum, 1, "");
+ v_rvaluep =
+ l_gep(b, TypeSizeT, v_resultvalues, &v_resultnum, 1, "");
+ v_risnullp =
+ l_gep(b, TypeStorageBool, v_resultnulls, &v_resultnum, 1, "");
/* store nullness */
LLVMBuildStore(b, v_isnull, v_risnullp);
LLVMPositionBuilderAtEnd(b, b_notnull);
v_params[0] = v_value;
v_ret =
- LLVMBuildCall(b,
- llvm_get_decl(mod, FuncMakeExpandedObjectReadOnlyInternal),
- v_params, lengthof(v_params), "");
+ l_call(b,
+ llvm_pg_var_func_type("MakeExpandedObjectReadOnlyInternal"),
+ llvm_pg_func(mod, "MakeExpandedObjectReadOnlyInternal"),
+ v_params, lengthof(v_params), "");
/* store value */
LLVMBuildStore(b, v_ret, v_rvaluep);
v_boolanynullp = l_ptr_const(op->d.boolexpr.anynull,
l_ptr(TypeStorageBool));
- v_boolnull = LLVMBuildLoad(b, v_resnullp, "");
- v_boolvalue = LLVMBuildLoad(b, v_resvaluep, "");
+ v_boolnull = l_load(b, TypeStorageBool, v_resnullp, "");
+ v_boolvalue = l_load(b, TypeSizeT, v_resvaluep, "");
/* set resnull to boolnull */
LLVMBuildStore(b, v_boolnull, v_resnullp);
/* Build block that continues if bool is TRUE. */
LLVMPositionBuilderAtEnd(b, b_boolcont);
- v_boolanynull = LLVMBuildLoad(b, v_boolanynullp, "");
+ v_boolanynull = l_load(b, TypeStorageBool, v_boolanynullp, "");
/* set value to NULL if any previous values were NULL */
LLVMBuildCondBr(b,
v_boolanynullp = l_ptr_const(op->d.boolexpr.anynull,
l_ptr(TypeStorageBool));
- v_boolnull = LLVMBuildLoad(b, v_resnullp, "");
- v_boolvalue = LLVMBuildLoad(b, v_resvaluep, "");
+ v_boolnull = l_load(b, TypeStorageBool, v_resnullp, "");
+ v_boolvalue = l_load(b, TypeSizeT, v_resvaluep, "");
/* set resnull to boolnull */
LLVMBuildStore(b, v_boolnull, v_resnullp);
/* build block that continues if bool is FALSE */
LLVMPositionBuilderAtEnd(b, b_boolcont);
- v_boolanynull = LLVMBuildLoad(b, v_boolanynullp, "");
+ v_boolanynull = l_load(b, TypeStorageBool, v_boolanynullp, "");
/* set value to NULL if any previous values were NULL */
LLVMBuildCondBr(b,
LLVMValueRef v_boolnull;
LLVMValueRef v_negbool;
- v_boolnull = LLVMBuildLoad(b, v_resnullp, "");
- v_boolvalue = LLVMBuildLoad(b, v_resvaluep, "");
+ v_boolnull = l_load(b, TypeStorageBool, v_resnullp, "");
+ v_boolvalue = l_load(b, TypeSizeT, v_resvaluep, "");
v_negbool = LLVMBuildZExt(b,
LLVMBuildICmp(b, LLVMIntEQ,
b_qualfail = l_bb_before_v(opblocks[i + 1],
"op.%d.qualfail", i);
- v_resvalue = LLVMBuildLoad(b, v_resvaluep, "");
- v_resnull = LLVMBuildLoad(b, v_resnullp, "");
+ v_resvalue = l_load(b, TypeSizeT, v_resvaluep, "");
+ v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
v_nullorfalse =
LLVMBuildOr(b,
/* Transfer control if current result is null */
- v_resnull = LLVMBuildLoad(b, v_resnullp, "");
+ v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
LLVMBuildCondBr(b,
LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
/* Transfer control if current result is non-null */
- v_resnull = LLVMBuildLoad(b, v_resnullp, "");
+ v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
LLVMBuildCondBr(b,
LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
/* Transfer control if current result is null or false */
- v_resvalue = LLVMBuildLoad(b, v_resvaluep, "");
- v_resnull = LLVMBuildLoad(b, v_resnullp, "");
+ v_resvalue = l_load(b, TypeSizeT, v_resvaluep, "");
+ v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
v_nullorfalse =
LLVMBuildOr(b,
case EEOP_NULLTEST_ISNULL:
{
- LLVMValueRef v_resnull = LLVMBuildLoad(b, v_resnullp, "");
+ LLVMValueRef v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
LLVMValueRef v_resvalue;
v_resvalue =
case EEOP_NULLTEST_ISNOTNULL:
{
- LLVMValueRef v_resnull = LLVMBuildLoad(b, v_resnullp, "");
+ LLVMValueRef v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
LLVMValueRef v_resvalue;
v_resvalue =
{
LLVMBasicBlockRef b_isnull,
b_notnull;
- LLVMValueRef v_resnull = LLVMBuildLoad(b, v_resnullp, "");
+ LLVMValueRef v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
b_isnull = l_bb_before_v(opblocks[i + 1],
"op.%d.isnull", i);
else
{
LLVMValueRef v_value =
- LLVMBuildLoad(b, v_resvaluep, "");
+ l_load(b, TypeSizeT, v_resvaluep, "");
v_value = LLVMBuildZExt(b,
LLVMBuildICmp(b, LLVMIntEQ,
case EEOP_PARAM_CALLBACK:
{
- LLVMTypeRef param_types[3];
LLVMValueRef v_params[3];
- LLVMTypeRef v_functype;
LLVMValueRef v_func;
- param_types[0] = l_ptr(StructExprState);
- param_types[1] = l_ptr(TypeSizeT);
- param_types[2] = l_ptr(StructExprContext);
-
- v_functype = LLVMFunctionType(LLVMVoidType(),
- param_types,
- lengthof(param_types),
- false);
v_func = l_ptr_const(op->d.cparam.paramfunc,
- l_ptr(v_functype));
+ llvm_pg_var_type("TypeExecEvalSubroutine"));
v_params[0] = v_state;
v_params[1] = l_ptr_const(op, l_ptr(TypeSizeT));
v_params[2] = v_econtext;
- LLVMBuildCall(b,
- v_func,
- v_params, lengthof(v_params), "");
+ l_call(b,
+ LLVMGetFunctionType(ExecEvalSubroutineTemplate),
+ v_func,
+ v_params, lengthof(v_params), "");
LLVMBuildBr(b, opblocks[i + 1]);
break;
/* if casetest != NULL */
LLVMPositionBuilderAtEnd(b, b_avail);
- v_casevalue = LLVMBuildLoad(b, v_casevaluep, "");
- v_casenull = LLVMBuildLoad(b, v_casenullp, "");
+ v_casevalue = l_load(b, TypeSizeT, v_casevaluep, "");
+ v_casenull = l_load(b, TypeStorageBool, v_casenullp, "");
LLVMBuildStore(b, v_casevalue, v_resvaluep);
LLVMBuildStore(b, v_casenull, v_resnullp);
LLVMBuildBr(b, opblocks[i + 1]);
/* if casetest == NULL */
LLVMPositionBuilderAtEnd(b, b_notavail);
v_casevalue =
- l_load_struct_gep(b, v_econtext,
+ l_load_struct_gep(b,
+ StructExprContext,
+ v_econtext,
FIELDNO_EXPRCONTEXT_CASEDATUM, "");
v_casenull =
- l_load_struct_gep(b, v_econtext,
+ l_load_struct_gep(b,
+ StructExprContext,
+ v_econtext,
FIELDNO_EXPRCONTEXT_CASENULL, "");
LLVMBuildStore(b, v_casevalue, v_resvaluep);
LLVMBuildStore(b, v_casenull, v_resnullp);
v_nullp = l_ptr_const(op->d.make_readonly.isnull,
l_ptr(TypeStorageBool));
- v_null = LLVMBuildLoad(b, v_nullp, "");
+ v_null = l_load(b, TypeStorageBool, v_nullp, "");
/* store null isnull value in result */
LLVMBuildStore(b, v_null, v_resnullp);
v_valuep = l_ptr_const(op->d.make_readonly.value,
l_ptr(TypeSizeT));
- v_value = LLVMBuildLoad(b, v_valuep, "");
+ v_value = l_load(b, TypeSizeT, v_valuep, "");
v_params[0] = v_value;
v_ret =
- LLVMBuildCall(b,
- llvm_get_decl(mod, FuncMakeExpandedObjectReadOnlyInternal),
- v_params, lengthof(v_params), "");
+ l_call(b,
+ llvm_pg_var_func_type("MakeExpandedObjectReadOnlyInternal"),
+ llvm_pg_func(mod, "MakeExpandedObjectReadOnlyInternal"),
+ v_params, lengthof(v_params), "");
LLVMBuildStore(b, v_ret, v_resvaluep);
LLVMBuildBr(b, opblocks[i + 1]);
{
FunctionCallInfo fcinfo_out,
fcinfo_in;
+ LLVMValueRef v_fn_out,
+ v_fn_in;
LLVMValueRef v_fcinfo_out,
v_fcinfo_in;
- LLVMValueRef v_fn_addr_out,
- v_fn_addr_in;
LLVMValueRef v_fcinfo_in_isnullp;
LLVMValueRef v_retval;
LLVMValueRef v_resvalue;
b_inputcall = l_bb_before_v(opblocks[i + 1],
"op.%d.inputcall", i);
+ v_fn_out = llvm_function_reference(context, b, mod, fcinfo_out);
+ v_fn_in = llvm_function_reference(context, b, mod, fcinfo_in);
v_fcinfo_out = l_ptr_const(fcinfo_out, l_ptr(StructFunctionCallInfoData));
v_fcinfo_in = l_ptr_const(fcinfo_in, l_ptr(StructFunctionCallInfoData));
- v_fn_addr_out = l_ptr_const(fcinfo_out->flinfo->fn_addr, TypePGFunction);
- v_fn_addr_in = l_ptr_const(fcinfo_in->flinfo->fn_addr, TypePGFunction);
v_fcinfo_in_isnullp =
- LLVMBuildStructGEP(b, v_fcinfo_in,
- FIELDNO_FUNCTIONCALLINFODATA_ISNULL,
- "v_fcinfo_in_isnull");
+ l_struct_gep(b,
+ StructFunctionCallInfoData,
+ v_fcinfo_in,
+ FIELDNO_FUNCTIONCALLINFODATA_ISNULL,
+ "v_fcinfo_in_isnull");
/* output functions are not called on nulls */
- v_resnull = LLVMBuildLoad(b, v_resnullp, "");
+ v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
LLVMBuildCondBr(b,
LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
l_sbool_const(1), ""),
LLVMBuildBr(b, b_input);
LLVMPositionBuilderAtEnd(b, b_calloutput);
- v_resvalue = LLVMBuildLoad(b, v_resvaluep, "");
+ v_resvalue = l_load(b, TypeSizeT, v_resvaluep, "");
/* set arg[0] */
LLVMBuildStore(b,
l_sbool_const(0),
l_funcnullp(b, v_fcinfo_out, 0));
/* and call output function (can never return NULL) */
- v_output = LLVMBuildCall(b, v_fn_addr_out, &v_fcinfo_out,
- 1, "funccall_coerce_out");
+ v_output = l_call(b,
+ LLVMGetFunctionType(v_fn_out),
+ v_fn_out, &v_fcinfo_out,
+ 1, "funccall_coerce_out");
LLVMBuildBr(b, b_input);
/* build block handling input function call */
/* reset fcinfo_in->isnull */
LLVMBuildStore(b, l_sbool_const(0), v_fcinfo_in_isnullp);
/* and call function */
- v_retval = LLVMBuildCall(b, v_fn_addr_in, &v_fcinfo_in, 1,
- "funccall_iocoerce_in");
+ v_retval = l_call(b,
+ LLVMGetFunctionType(v_fn_in),
+ v_fn_in, &v_fcinfo_in, 1,
+ "funccall_iocoerce_in");
LLVMBuildStore(b, v_retval, v_resvaluep);
*/
v_cmpresult =
LLVMBuildTrunc(b,
- LLVMBuildLoad(b, v_resvaluep, ""),
+ l_load(b, TypeSizeT, v_resvaluep, ""),
LLVMInt32Type(), "");
switch (rctype)
case EEOP_SBSREF_SUBSCRIPT:
{
- LLVMValueRef v_fn;
int jumpdone = op->d.sbsref_subscript.jumpdone;
LLVMValueRef v_params[2];
LLVMValueRef v_ret;
- v_fn = llvm_get_decl(mod, FuncExecEvalSubscriptingRef);
-
v_params[0] = v_state;
v_params[1] = l_ptr_const(op, l_ptr(StructExprEvalStep));
- v_ret = LLVMBuildCall(b, v_fn,
- v_params, lengthof(v_params), "");
+ v_ret = l_call(b,
+ llvm_pg_var_func_type("ExecEvalSubscriptingRef"),
+ llvm_pg_func(mod, "ExecEvalSubscriptingRef"),
+ v_params, lengthof(v_params), "");
v_ret = LLVMBuildZExt(b, v_ret, TypeStorageBool, "");
LLVMBuildCondBr(b,
/* if casetest != NULL */
LLVMPositionBuilderAtEnd(b, b_avail);
- v_casevalue = LLVMBuildLoad(b, v_casevaluep, "");
- v_casenull = LLVMBuildLoad(b, v_casenullp, "");
+ v_casevalue = l_load(b, TypeSizeT, v_casevaluep, "");
+ v_casenull = l_load(b, TypeStorageBool, v_casenullp, "");
LLVMBuildStore(b, v_casevalue, v_resvaluep);
LLVMBuildStore(b, v_casenull, v_resnullp);
LLVMBuildBr(b, opblocks[i + 1]);
/* if casetest == NULL */
LLVMPositionBuilderAtEnd(b, b_notavail);
v_casevalue =
- l_load_struct_gep(b, v_econtext,
+ l_load_struct_gep(b,
+ StructExprContext,
+ v_econtext,
FIELDNO_EXPRCONTEXT_DOMAINDATUM,
"");
v_casenull =
- l_load_struct_gep(b, v_econtext,
+ l_load_struct_gep(b,
+ StructExprContext,
+ v_econtext,
FIELDNO_EXPRCONTEXT_DOMAINNULL,
"");
LLVMBuildStore(b, v_casevalue, v_resvaluep);
*/
v_aggnop = l_ptr_const(&aggref->aggno,
l_ptr(LLVMInt32Type()));
- v_aggno = LLVMBuildLoad(b, v_aggnop, "v_aggno");
+ v_aggno = l_load(b, LLVMInt32Type(), v_aggnop, "v_aggno");
/* load agg value / null */
- value = l_load_gep1(b, v_aggvalues, v_aggno, "aggvalue");
- isnull = l_load_gep1(b, v_aggnulls, v_aggno, "aggnull");
+ value = l_load_gep1(b, TypeSizeT, v_aggvalues, v_aggno, "aggvalue");
+ isnull = l_load_gep1(b, TypeStorageBool, v_aggnulls, v_aggno, "aggnull");
/* and store result */
LLVMBuildStore(b, value, v_resvaluep);
*/
v_wfuncnop = l_ptr_const(&wfunc->wfuncno,
l_ptr(LLVMInt32Type()));
- v_wfuncno = LLVMBuildLoad(b, v_wfuncnop, "v_wfuncno");
+ v_wfuncno = l_load(b, LLVMInt32Type(), v_wfuncnop, "v_wfuncno");
/* load window func value / null */
- value = l_load_gep1(b, v_aggvalues, v_wfuncno,
+ value = l_load_gep1(b, TypeSizeT, v_aggvalues, v_wfuncno,
"windowvalue");
- isnull = l_load_gep1(b, v_aggnulls, v_wfuncno,
+ isnull = l_load_gep1(b, TypeStorageBool, v_aggnulls, v_wfuncno,
"windownull");
LLVMBuildStore(b, value, v_resvaluep);
b_argnotnull = b_checknulls[argno + 1];
if (opcode == EEOP_AGG_STRICT_INPUT_CHECK_NULLS)
- v_argisnull = l_load_gep1(b, v_nullsp, v_argno, "");
+ v_argisnull = l_load_gep1(b, TypeStorageBool, v_nullsp, v_argno, "");
else
{
LLVMValueRef v_argn;
- v_argn = LLVMBuildGEP(b, v_argsp, &v_argno, 1, "");
+ v_argn = l_gep(b, StructNullableDatum, v_argsp, &v_argno, 1, "");
v_argisnull =
- l_load_struct_gep(b, v_argn,
+ l_load_struct_gep(b, StructNullableDatum, v_argn,
FIELDNO_NULLABLE_DATUM_ISNULL,
"");
}
* [op->d.agg_init_trans_check.transno];
*/
v_allpergroupsp =
- l_load_struct_gep(b, v_aggstatep,
+ l_load_struct_gep(b,
+ StructAggState,
+ 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_pergroupp =
- LLVMBuildGEP(b,
- l_load_gep1(b, v_allpergroupsp, v_setoff, ""),
- &v_transno, 1, "");
+ l_gep(b,
+ StructAggStatePerGroupData,
+ l_load_gep1(b, l_ptr(StructAggStatePerGroupData),
+ v_allpergroupsp, v_setoff, ""),
+ &v_transno, 1, "");
v_notransvalue =
- l_load_struct_gep(b, v_pergroupp,
+ l_load_struct_gep(b,
+ StructAggStatePerGroupData,
+ v_pergroupp,
FIELDNO_AGGSTATEPERGROUPDATA_NOTRANSVALUE,
"notransvalue");
l_ptr(StructExprContext));
v_current_set =
- LLVMBuildStructGEP(b,
- v_aggstatep,
- FIELDNO_AGGSTATE_CURRENT_SET,
- "aggstate.current_set");
+ l_struct_gep(b,
+ StructAggState,
+ v_aggstatep,
+ FIELDNO_AGGSTATE_CURRENT_SET,
+ "aggstate.current_set");
v_curaggcontext =
- LLVMBuildStructGEP(b,
- v_aggstatep,
- FIELDNO_AGGSTATE_CURAGGCONTEXT,
- "aggstate.curaggcontext");
+ l_struct_gep(b,
+ StructAggState,
+ v_aggstatep,
+ FIELDNO_AGGSTATE_CURAGGCONTEXT,
+ "aggstate.curaggcontext");
LLVMBuildStore(b, l_int32_const(op->d.agg_init_trans.setno),
v_current_set);
params[1] = v_pertransp;
params[2] = v_pergroupp;
- LLVMBuildCall(b,
- llvm_get_decl(mod, FuncExecAggInitGroup),
- params, lengthof(params),
- "");
+ l_call(b,
+ llvm_pg_var_func_type("ExecAggInitGroup"),
+ llvm_pg_func(mod, "ExecAggInitGroup"),
+ params, lengthof(params),
+ "");
}
LLVMBuildBr(b, opblocks[op->d.agg_init_trans.jumpnull]);
* [op->d.agg_init_trans_check.transno];
*/
v_allpergroupsp =
- l_load_struct_gep(b, v_aggstatep,
+ l_load_struct_gep(b,
+ StructAggState,
+ v_aggstatep,
FIELDNO_AGGSTATE_ALL_PERGROUPS,
"aggstate.all_pergroups");
v_setoff =
v_transno =
l_int32_const(op->d.agg_strict_trans_check.transno);
v_pergroupp =
- LLVMBuildGEP(b,
- l_load_gep1(b, v_allpergroupsp, v_setoff, ""),
- &v_transno, 1, "");
+ l_gep(b,
+ StructAggStatePerGroupData,
+ l_load_gep1(b, l_ptr(StructAggStatePerGroupData),
+ v_allpergroupsp, v_setoff, ""),
+ &v_transno, 1, "");
v_transnull =
- l_load_struct_gep(b, v_pergroupp,
+ l_load_struct_gep(b,
+ StructAggStatePerGroupData,
+ v_pergroupp,
FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUEISNULL,
"transnull");
* [op->d.agg_init_trans_check.transno];
*/
v_allpergroupsp =
- l_load_struct_gep(b, v_aggstatep,
+ l_load_struct_gep(b,
+ StructAggState,
+ 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_pergroupp =
- LLVMBuildGEP(b,
- l_load_gep1(b, v_allpergroupsp, v_setoff, ""),
- &v_transno, 1, "");
+ l_gep(b,
+ StructAggStatePerGroupData,
+ l_load_gep1(b, l_ptr(StructAggStatePerGroupData),
+ v_allpergroupsp, v_setoff, ""),
+ &v_transno, 1, "");
v_fcinfo = l_ptr_const(fcinfo,
l_ptr(StructFunctionCallInfoData));
l_ptr(StructExprContext));
v_current_setp =
- LLVMBuildStructGEP(b,
- v_aggstatep,
- FIELDNO_AGGSTATE_CURRENT_SET,
- "aggstate.current_set");
+ l_struct_gep(b,
+ StructAggState,
+ v_aggstatep,
+ FIELDNO_AGGSTATE_CURRENT_SET,
+ "aggstate.current_set");
v_curaggcontext =
- LLVMBuildStructGEP(b,
- v_aggstatep,
- FIELDNO_AGGSTATE_CURAGGCONTEXT,
- "aggstate.curaggcontext");
+ l_struct_gep(b,
+ StructAggState,
+ v_aggstatep,
+ FIELDNO_AGGSTATE_CURAGGCONTEXT,
+ "aggstate.curaggcontext");
v_current_pertransp =
- LLVMBuildStructGEP(b,
- v_aggstatep,
- FIELDNO_AGGSTATE_CURPERTRANS,
- "aggstate.curpertrans");
+ l_struct_gep(b,
+ StructAggState,
+ v_aggstatep,
+ FIELDNO_AGGSTATE_CURPERTRANS,
+ "aggstate.curpertrans");
/* set aggstate globals */
LLVMBuildStore(b, v_aggcontext, v_curaggcontext);
/* store transvalue in fcinfo->args[0] */
v_transvaluep =
- LLVMBuildStructGEP(b, v_pergroupp,
- FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUE,
- "transvalue");
+ l_struct_gep(b,
+ StructAggStatePerGroupData,
+ v_pergroupp,
+ FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUE,
+ "transvalue");
v_transnullp =
- LLVMBuildStructGEP(b, v_pergroupp,
- FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUEISNULL,
- "transnullp");
+ l_struct_gep(b,
+ StructAggStatePerGroupData,
+ v_pergroupp,
+ FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUEISNULL,
+ "transnullp");
LLVMBuildStore(b,
- LLVMBuildLoad(b, v_transvaluep,
- "transvalue"),
+ l_load(b,
+ TypeSizeT,
+ v_transvaluep,
+ "transvalue"),
l_funcvaluep(b, v_fcinfo, 0));
LLVMBuildStore(b,
- LLVMBuildLoad(b, v_transnullp, "transnull"),
+ l_load(b, TypeStorageBool, v_transnullp, "transnull"),
l_funcnullp(b, v_fcinfo, 0));
/* and invoke transition function */
b_nocall = l_bb_before_v(opblocks[i + 1],
"op.%d.transnocall", i);
- v_transvalue = LLVMBuildLoad(b, v_transvaluep, "");
- v_transnull = LLVMBuildLoad(b, v_transnullp, "");
+ v_transvalue = l_load(b, TypeSizeT, v_transvaluep, "");
+ v_transnull = l_load(b, TypeStorageBool, v_transnullp, "");
/*
* DatumGetPointer(newVal) !=
params[5] = LLVMBuildTrunc(b, v_transnull,
TypeParamBool, "");
- v_fn = llvm_get_decl(mod, FuncExecAggTransReparent);
+ v_fn = llvm_pg_func(mod, "ExecAggTransReparent");
v_newval =
- LLVMBuildCall(b, v_fn,
- params, lengthof(params),
- "");
+ l_call(b,
+ LLVMGetFunctionType(v_fn),
+ v_fn,
+ params, lengthof(params),
+ "");
/* store trans value */
LLVMBuildStore(b, v_newval, v_transvaluep);
v_fn = llvm_function_reference(context, b, mod, fcinfo);
v_fcinfo = l_ptr_const(fcinfo, l_ptr(StructFunctionCallInfoData));
- v_fcinfo_isnullp = LLVMBuildStructGEP(b, v_fcinfo,
- FIELDNO_FUNCTIONCALLINFODATA_ISNULL,
- "v_fcinfo_isnull");
+ v_fcinfo_isnullp = l_struct_gep(b,
+ StructFunctionCallInfoData,
+ v_fcinfo,
+ FIELDNO_FUNCTIONCALLINFODATA_ISNULL,
+ "v_fcinfo_isnull");
LLVMBuildStore(b, l_sbool_const(0), v_fcinfo_isnullp);
- v_retval = LLVMBuildCall(b, v_fn, &v_fcinfo, 1, "funccall");
+ v_retval = l_call(b, LLVMGetFunctionType(AttributeTemplate), v_fn, &v_fcinfo, 1, "funccall");
if (v_fcinfo_isnull)
- *v_fcinfo_isnull = LLVMBuildLoad(b, v_fcinfo_isnullp, "");
+ *v_fcinfo_isnull = l_load(b, TypeStorageBool, v_fcinfo_isnullp, "");
/*
* Add lifetime-end annotation, signalling that writes to memory don't
params[0] = l_int64_const(sizeof(NullableDatum) * fcinfo->nargs);
params[1] = l_ptr_const(fcinfo->args, l_ptr(LLVMInt8Type()));
- LLVMBuildCall(b, v_lifetime, params, lengthof(params), "");
+ 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()));
- LLVMBuildCall(b, v_lifetime, params, lengthof(params), "");
+ l_call(b, LLVMGetFunctionType(v_lifetime), v_lifetime, params, lengthof(params), "");
}
return v_retval;
params[1] = l_ptr_const(op, l_ptr(StructExprEvalStep));
params[2] = v_econtext;
- LLVMBuildCall(b,
- v_fn,
- params, lengthof(params), "");
+ l_call(b, LLVMGetFunctionType(v_fn), v_fn, params, lengthof(params), "");
}
static LLVMValueRef
projects / postgresql.git / commitdiff