WIP: expression evaluation improvements

From 7094935d2dd7334922a782d8ffa8c08b9bcbb7fc Mon Sep 17 00:00:00 2001
From: soumyadeep2007 <sochakraborty@pivotal.io>
Date: Sun, 6 Oct 2019 17:47:08 -0700
Subject: [PATCH v2] Optimize generated functions earlier to lower memory usage

We can optimize functions as soon as they are generated as opposed to
optimizing during module optimization, in order to lower memory usage.
This commit introduces `llvm_optimize_function()`, which will execute
function level passes in accordance with the optimization settings
inside `LLVMJitContext`.
---
 src/backend/jit/llvm/llvmjit.c        | 82 ++++++++++++++++-----------
 src/backend/jit/llvm/llvmjit_deform.c |  3 +
 src/backend/jit/llvm/llvmjit_expr.c   |  3 +
 src/include/jit/llvmjit.h             |  2 +
 4 files changed, 57 insertions(+), 33 deletions(-)

diff --git a/src/backend/jit/llvm/llvmjit.c b/src/backend/jit/llvm/llvmjit.c
index 65f8273d30..cdac7b1c5d 100644
--- a/src/backend/jit/llvm/llvmjit.c
+++ b/src/backend/jit/llvm/llvmjit.c
@@ -122,7 +122,7 @@ 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_optimize_module(LLVMJitContext *context);
 
 static void llvm_create_types(void);
 static uint64_t llvm_resolve_symbol(const char *name, void *ctx);
@@ -435,14 +435,52 @@ llvm_function_reference(LLVMJitContext *context,
 static LLVMPassManagerBuilderRef llvm_pmb;
 
 /*
- * Optimize code in module using the flags set in context.
+ * Optimize code at the function-level for func using the flags set in context.
+ */
+void
+llvm_optimize_function(LLVMJitContext *context, LLVMValueRef func)
+{
+	LLVMPassManagerRef llvm_fpm;
+	int compile_optlevel = context->base.flags & PGJIT_OPT3;
+	instr_time starttime;
+	instr_time endtime;
+
+	INSTR_TIME_SET_CURRENT(starttime);
+
+	if (llvm_pmb == NULL)
+	{
+		llvm_pmb = LLVMPassManagerBuilderCreate();
+		LLVMPassManagerBuilderUseLibraryInfo(llvm_pmb, llvm_targetlibraryinfo);
+	}
+
+	LLVMPassManagerBuilderSetOptLevel(llvm_pmb, compile_optlevel);
+	llvm_fpm = LLVMCreateFunctionPassManagerForModule(context->module);
+	LLVMAddAnalysisPasses(llvm_opt3_targetmachine, llvm_fpm);
+	if (compile_optlevel == 0)
+	{
+		/* we rely on mem2reg heavily, so emit even in the O0 case */
+		LLVMAddPromoteMemoryToRegisterPass(llvm_fpm);
+	}
+	LLVMPassManagerBuilderPopulateFunctionPassManager(llvm_pmb, llvm_fpm);
+
+	LLVMRunFunctionPassManager(llvm_fpm, func);
+
+	LLVMFinalizeFunctionPassManager(llvm_fpm);
+	LLVMDisposePassManager(llvm_fpm);
+
+	INSTR_TIME_SET_CURRENT(endtime);
+	INSTR_TIME_ACCUM_DIFF(context->base.instr.optimization_counter,
+						  endtime, starttime);
+}
+
+/*
+ * Optimize code at the module-level for the current module using the flags set
+ * in context.
  */
 static void
-llvm_optimize_module(LLVMJitContext *context, LLVMModuleRef module)
+llvm_optimize_module(LLVMJitContext *context)
 {
 	LLVMPassManagerRef llvm_mpm;
-	LLVMPassManagerRef llvm_fpm;
-	LLVMValueRef func;
 	int			compile_optlevel;
 
 	if (context->base.flags & PGJIT_OPT3)
@@ -450,11 +488,11 @@ llvm_optimize_module(LLVMJitContext *context, LLVMModuleRef module)
 	else
 		compile_optlevel = 0;
 
-	if (llvm_pmb == NULL)
-	{
-		llvm_pmb = LLVMPassManagerBuilderCreate();
-		LLVMPassManagerBuilderUseLibraryInfo(llvm_pmb, llvm_targetlibraryinfo);
-	}
+	/*
+	 * llvm_pmb must have been initialized by now while
+	 * optimizing generated functions.
+	 */
+	Assert(llvm_pmb != NULL);
 
 	/*
 	 * Have to create a inliner every pass, as it gets "consumed" by
@@ -462,33 +500,11 @@ llvm_optimize_module(LLVMJitContext *context, LLVMModuleRef module)
 	 */
 	LLVMPassManagerBuilderSetOptLevel(llvm_pmb, compile_optlevel);
 
-	llvm_fpm = LLVMCreateFunctionPassManagerForModule(module);
-	LLVMAddAnalysisPasses(llvm_opt3_targetmachine, llvm_fpm);
-
 	if (context->base.flags & PGJIT_OPT3)
 	{
 		/* TODO: Unscientifically determined threshold */
 		LLVMPassManagerBuilderUseInlinerWithThreshold(llvm_pmb, 1024);
 	}
-	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
@@ -579,7 +595,7 @@ llvm_compile_module(LLVMJitContext *context)
 
 	/* optimize according to the chosen optimization settings */
 	INSTR_TIME_SET_CURRENT(starttime);
-	llvm_optimize_module(context, context->module);
+	llvm_optimize_module(context);
 	INSTR_TIME_SET_CURRENT(endtime);
 	INSTR_TIME_ACCUM_DIFF(context->base.instr.optimization_counter,
 						  endtime, starttime);
diff --git a/src/backend/jit/llvm/llvmjit_deform.c b/src/backend/jit/llvm/llvmjit_deform.c
index 533a4aa117..6ff0821072 100644
--- a/src/backend/jit/llvm/llvmjit_deform.c
+++ b/src/backend/jit/llvm/llvmjit_deform.c
@@ -759,5 +759,8 @@ slot_compile_deform(LLVMJitContext *context, TupleDesc desc,
 
 	LLVMDisposeBuilder(b);
 
+	/* optimize according to the chosen optimization settings */
+	llvm_optimize_function(context, v_deform_fn);
+
 	return v_deform_fn;
 }
diff --git a/src/backend/jit/llvm/llvmjit_expr.c b/src/backend/jit/llvm/llvmjit_expr.c
index d527dd02b0..bbe0fd0cb3 100644
--- a/src/backend/jit/llvm/llvmjit_expr.c
+++ b/src/backend/jit/llvm/llvmjit_expr.c
@@ -2576,6 +2576,9 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 	LLVMDisposeDIBuilder(ecs.b_d);
 	LLVMDisposeBuilder(b);
 
+	/* optimize according to the chosen optimization settings */
+	llvm_optimize_function(ecs.context, ecs.fn);
+
 	/*
 	 * Don't immediately emit function, instead do so the first time the
 	 * expression is actually evaluated. That allows to emit a lot of
diff --git a/src/include/jit/llvmjit.h b/src/include/jit/llvmjit.h
index b7b6ed9b34..751bb69e25 100644
--- a/src/include/jit/llvmjit.h
+++ b/src/include/jit/llvmjit.h
@@ -115,6 +115,8 @@ extern LLVMValueRef llvm_function_reference(LLVMJitContext *context,
 						LLVMBuilderRef builder,
 						LLVMModuleRef mod,
 						FunctionCallInfo fcinfo);
+extern void llvm_optimize_function(LLVMJitContext *context,
+						LLVMValueRef func);
 
 extern void llvm_inline(LLVMModuleRef mod);
 
-- 
2.23.0

From 07c9833945e3f762f5d5cffc7272b6477bd14291 Mon Sep 17 00:00:00 2001
From: soumyadeep2007 <sochakraborty@pivotal.io>
Date: Sun, 27 Oct 2019 23:35:45 -0700
Subject: [PATCH v1] Rely on llvmjit_types for building EvalFunc calls

Rely on llvmjit_types's referenced_functions for building calls to EvalFuncs.
This ensures signature checks for the calls constructed.

Discussion:
https://postgr.es/m/20191024224303.jvdx3hq3ak2vbit3%40alap3.anarazel.de:wq
---
 src/backend/jit/llvm/llvmjit.c       | 60 +++++++++++++++++++
 src/backend/jit/llvm/llvmjit_expr.c  | 88 +++++++++++-----------------
 src/backend/jit/llvm/llvmjit_types.c | 31 +++++++++-
 src/include/jit/llvmjit.h            | 30 +++++++++-
 4 files changed, 153 insertions(+), 56 deletions(-)

diff --git a/src/backend/jit/llvm/llvmjit.c b/src/backend/jit/llvm/llvmjit.c
index cdac7b1c5d..7a66d48645 100644
--- a/src/backend/jit/llvm/llvmjit.c
+++ b/src/backend/jit/llvm/llvmjit.c
@@ -98,6 +98,37 @@ LLVMValueRef FuncExecAggInitGroup;
 LLVMValueRef FuncExecEvalArrayCoerceRelabel;
 LLVMValueRef FuncExecEvalArrayCoerceUnpack;
 LLVMValueRef FuncExecEvalArrayCoercePack;
+LLVMValueRef FuncExecAggInitGroup;
+LLVMValueRef FuncExecAggTransReparent;
+LLVMValueRef FuncExecEvalAggOrderedTransDatum;
+LLVMValueRef FuncExecEvalAggOrderedTransTuple;
+LLVMValueRef FuncExecEvalAlternativeSubPlan;
+LLVMValueRef FuncExecEvalArrayExpr;
+LLVMValueRef FuncExecEvalConstraintCheck;
+LLVMValueRef FuncExecEvalConstraintNotNull;
+LLVMValueRef FuncExecEvalConvertRowtype;
+LLVMValueRef FuncExecEvalCurrentOfExpr;
+LLVMValueRef FuncExecEvalFieldSelect;
+LLVMValueRef FuncExecEvalFieldStoreDeForm;
+LLVMValueRef FuncExecEvalFieldStoreForm;
+LLVMValueRef FuncExecEvalFuncExprFusage;
+LLVMValueRef FuncExecEvalFuncExprStrictFusage;
+LLVMValueRef FuncExecEvalGroupingFunc;
+LLVMValueRef FuncExecEvalMinMax;
+LLVMValueRef FuncExecEvalNextValueExpr;
+LLVMValueRef FuncExecEvalParamExec;
+LLVMValueRef FuncExecEvalParamExtern;
+LLVMValueRef FuncExecEvalRow;
+LLVMValueRef FuncExecEvalRowNotNull;
+LLVMValueRef FuncExecEvalRowNull;
+LLVMValueRef FuncExecEvalScalarArrayOp;
+LLVMValueRef FuncExecEvalSQLValueFunction;
+LLVMValueRef FuncExecEvalSubPlan;
+LLVMValueRef FuncExecEvalSubscriptingRefAssign;
+LLVMValueRef FuncExecEvalSubscriptingRefFetch;
+LLVMValueRef FuncExecEvalSubscriptingRefOld;
+LLVMValueRef FuncExecEvalWholeRowVar;
+LLVMValueRef FuncExecEvalXmlExpr;
 
 
 static bool llvm_session_initialized = false;
@@ -928,6 +959,35 @@ llvm_create_types(void)
 	FuncExecEvalArrayCoerceRelabel = LLVMGetNamedFunction(mod, "ExecEvalArrayCoerceRelabel");
 	FuncExecEvalArrayCoerceUnpack = LLVMGetNamedFunction(mod, "ExecEvalArrayCoerceUnpack");
 	FuncExecEvalArrayCoercePack = LLVMGetNamedFunction(mod, "ExecEvalArrayCoercePack");
+	FuncExecEvalFuncExprFusage = LLVMGetNamedFunction(mod, "ExecEvalFuncExprFusage");
+	FuncExecEvalFuncExprStrictFusage = LLVMGetNamedFunction(mod, "ExecEvalFuncExprStrictFusage");
+	FuncExecEvalRowNull = LLVMGetNamedFunction(mod, "ExecEvalRowNull");
+	FuncExecEvalRowNotNull = LLVMGetNamedFunction(mod, "ExecEvalRowNotNull");
+	FuncExecEvalParamExec = LLVMGetNamedFunction(mod, "ExecEvalParamExec");
+	FuncExecEvalParamExtern = LLVMGetNamedFunction(mod, "ExecEvalParamExtern");
+	FuncExecEvalSubscriptingRefOld = LLVMGetNamedFunction(mod, "ExecEvalSubscriptingRefOld");
+	FuncExecEvalSubscriptingRefAssign = LLVMGetNamedFunction(mod, "ExecEvalSubscriptingRefAssign");
+	FuncExecEvalSubscriptingRefFetch = LLVMGetNamedFunction(mod, "ExecEvalSubscriptingRefFetch");
+	FuncExecEvalSQLValueFunction = LLVMGetNamedFunction(mod, "ExecEvalSQLValueFunction");
+	FuncExecEvalCurrentOfExpr = LLVMGetNamedFunction(mod, "ExecEvalCurrentOfExpr");
+	FuncExecEvalNextValueExpr = LLVMGetNamedFunction(mod, "ExecEvalNextValueExpr");
+	FuncExecEvalArrayExpr = LLVMGetNamedFunction(mod, "ExecEvalArrayExpr");
+	FuncExecEvalRow = LLVMGetNamedFunction(mod, "ExecEvalRow");
+	FuncExecEvalMinMax = LLVMGetNamedFunction(mod, "ExecEvalMinMax");
+	FuncExecEvalFieldSelect = LLVMGetNamedFunction(mod, "ExecEvalFieldSelect");
+	FuncExecEvalFieldStoreDeForm = LLVMGetNamedFunction(mod, "ExecEvalFieldStoreDeForm");
+	FuncExecEvalFieldStoreForm = LLVMGetNamedFunction(mod, "ExecEvalFieldStoreForm");
+	FuncExecEvalConstraintNotNull = LLVMGetNamedFunction(mod, "ExecEvalConstraintNotNull");
+	FuncExecEvalConstraintCheck = LLVMGetNamedFunction(mod, "ExecEvalConstraintCheck");
+	FuncExecEvalConvertRowtype = LLVMGetNamedFunction(mod, "ExecEvalConvertRowtype");
+	FuncExecEvalScalarArrayOp = LLVMGetNamedFunction(mod, "ExecEvalScalarArrayOp");
+	FuncExecEvalXmlExpr = LLVMGetNamedFunction(mod, "ExecEvalXmlExpr");
+	FuncExecEvalGroupingFunc = LLVMGetNamedFunction(mod, "ExecEvalGroupingFunc");
+	FuncExecEvalSubPlan = LLVMGetNamedFunction(mod, "ExecEvalSubPlan");
+	FuncExecEvalAlternativeSubPlan = LLVMGetNamedFunction(mod, "ExecEvalAlternativeSubPlan");
+	FuncExecEvalAggOrderedTransDatum = LLVMGetNamedFunction(mod, "ExecEvalAggOrderedTransDatum");
+	FuncExecEvalAggOrderedTransTuple = LLVMGetNamedFunction(mod, "ExecEvalAggOrderedTransTuple");
+	FuncExecEvalWholeRowVar = LLVMGetNamedFunction(mod, "ExecEvalWholeRowVar");
 
 	/*
 	 * Leave the module alive, otherwise references to function would be
diff --git a/src/backend/jit/llvm/llvmjit_expr.c b/src/backend/jit/llvm/llvmjit_expr.c
index bbe0fd0cb3..9284e32bde 100644
--- a/src/backend/jit/llvm/llvmjit_expr.c
+++ b/src/backend/jit/llvm/llvmjit_expr.c
@@ -131,12 +131,12 @@ static LLVMValueRef BuildV1CallFC(ExprCompileState *ecs,
 								  LLVMValueRef v_fcinfo,
 								  LLVMValueRef *v_fcinfo_isnull);
 
-#define build_EvalXFunc(ecs, funcname, opno, ...) \
-	build_EvalXFuncInt(ecs, funcname, opno, \
+#define build_EvalXFunc(ecs, v_fn, opno, ...) \
+	build_EvalXFuncInt(ecs, v_fn, opno, \
 					   lengthof(((LLVMValueRef[]){__VA_ARGS__})), \
 					   ((LLVMValueRef[]){__VA_ARGS__}))
 
-static void build_EvalXFuncInt(ExprCompileState *ecs, const char *funcname,
+static void build_EvalXFuncInt(ExprCompileState *ecs, LLVMValueRef v_fn,
 							   int opno, int natts, LLVMValueRef v_args[]);
 
 /*
@@ -561,7 +561,7 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_WHOLEROW:
-				build_EvalXFunc(&ecs, "ExecEvalWholeRowVar", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalWholeRowVar, opno,
 								ecs.v_econtext,	v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -798,7 +798,7 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_FUNCEXPR_FUSAGE:
-				build_EvalXFunc(&ecs, "ExecEvalFuncExprFusage", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalFuncExprFusage, opno,
 								v_resultp,
 								expr_fcinfo_ref(&ecs, op->d.func.fcinfo_data, NULL));
 				LLVMBuildBr(b, opblocks[opno + 1]);
@@ -806,7 +806,7 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 
 
 			case EEOP_FUNCEXPR_STRICT_FUSAGE:
-				build_EvalXFunc(&ecs, "ExecEvalFuncExprStrictFusage", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalFuncExprStrictFusage, opno,
 								v_resultp,
 								expr_fcinfo_ref(&ecs, op->d.func.fcinfo_data, NULL));
 				LLVMBuildBr(b, opblocks[opno + 1]);
@@ -1190,13 +1190,13 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_NULLTEST_ROWISNULL:
-				build_EvalXFunc(&ecs, "ExecEvalRowNull", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalRowNull, opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_NULLTEST_ROWISNOTNULL:
-				build_EvalXFunc(&ecs, "ExecEvalRowNotNull", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalRowNotNull, opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -1269,13 +1269,13 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_PARAM_EXEC:
-				build_EvalXFunc(&ecs, "ExecEvalParamExec", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalParamExec, opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_PARAM_EXTERN:
-				build_EvalXFunc(&ecs, "ExecEvalParamExtern", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalParamExtern, opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -1322,21 +1322,21 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_SBSREF_OLD:
-				build_EvalXFunc(&ecs, "ExecEvalSubscriptingRefOld", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalSubscriptingRefOld, opno,
 								v_resultp,
 								expr_nullable_datum_ref(&ecs, op->d.sbsref.prev));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_SBSREF_ASSIGN:
-				build_EvalXFunc(&ecs, "ExecEvalSubscriptingRefAssign", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalSubscriptingRefAssign, opno,
 								v_resultp,
 								expr_nullable_datum_ref(&ecs, op->d.sbsref.replace));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_SBSREF_FETCH:
-				build_EvalXFunc(&ecs, "ExecEvalSubscriptingRefFetch", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalSubscriptingRefFetch, opno,
 								v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -1755,24 +1755,24 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_SQLVALUEFUNCTION:
-				build_EvalXFunc(&ecs, "ExecEvalSQLValueFunction", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalSQLValueFunction, opno,
 								v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_CURRENTOFEXPR:
-				build_EvalXFunc(&ecs, "ExecEvalCurrentOfExpr", opno);
+				build_EvalXFunc(&ecs, FuncExecEvalCurrentOfExpr, opno);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_NEXTVALUEEXPR:
-				build_EvalXFunc(&ecs, "ExecEvalNextValueExpr", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalNextValueExpr, opno,
 								v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_ARRAYEXPR:
-				build_EvalXFunc(&ecs, "ExecEvalArrayExpr", opno, v_resultp,
+				build_EvalXFunc(&ecs, FuncExecEvalArrayExpr, opno, v_resultp,
 								expr_nullable_datum_array_ref(&ecs, op->d.arrayexpr.elements));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -1842,7 +1842,7 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_ROW:
-				build_EvalXFunc(&ecs, "ExecEvalRow", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalRow, opno,
 								v_resultp,
 								expr_nullable_datum_array_ref(&ecs, op->d.row.elements));
 				LLVMBuildBr(b, opblocks[opno + 1]);
@@ -2003,7 +2003,7 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_MINMAX:
-				build_EvalXFunc(&ecs, "ExecEvalMinMax", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalMinMax, opno,
 								v_resultp,
 								expr_nullable_datum_array_ref(&ecs, op->d.minmax.arguments),
 								expr_fcinfo_ref(&ecs, op->d.minmax.fcinfo_data, NULL));
@@ -2011,20 +2011,20 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				break;
 
 			case EEOP_FIELDSELECT:
-				build_EvalXFunc(&ecs, "ExecEvalFieldSelect", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalFieldSelect, opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_FIELDSTORE_DEFORM:
-				build_EvalXFunc(&ecs, "ExecEvalFieldStoreDeForm", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalFieldStoreDeForm, opno,
 								ecs.v_econtext, v_resultp,
 								expr_nullable_datum_array_ref(&ecs, op->d.fieldstore.columns));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_FIELDSTORE_FORM:
-				build_EvalXFunc(&ecs, "ExecEvalFieldStoreForm", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalFieldStoreForm, opno,
 								v_resultp,
 								expr_nullable_datum_array_ref(&ecs, op->d.fieldstore.columns));
 				LLVMBuildBr(b, opblocks[opno + 1]);
@@ -2101,32 +2101,32 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_DOMAIN_NOTNULL:
-				build_EvalXFunc(&ecs, "ExecEvalConstraintNotNull", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalConstraintNotNull, opno,
 								v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_DOMAIN_CHECK:
-				build_EvalXFunc(&ecs, "ExecEvalConstraintCheck", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalConstraintCheck, opno,
 								expr_nullable_datum_ref(&ecs, op->d.domaincheck.check));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_CONVERT_ROWTYPE:
-				build_EvalXFunc(&ecs, "ExecEvalConvertRowtype", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalConvertRowtype, opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_SCALARARRAYOP:
-				build_EvalXFunc(&ecs, "ExecEvalScalarArrayOp", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalScalarArrayOp, opno,
 								v_resultp,
 								expr_fcinfo_ref(&ecs, op->d.scalararrayop.fcinfo_data, NULL));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_XMLEXPR:
-				build_EvalXFunc(&ecs, "ExecEvalXmlExpr", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalXmlExpr, opno,
 								v_resultp,
 								expr_nullable_datum_array_ref(&ecs, op->d.xmlexpr.args),
 								expr_nullable_datum_array_ref(&ecs, op->d.xmlexpr.named_args));
@@ -2162,7 +2162,7 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_GROUPING_FUNC:
-				build_EvalXFunc(&ecs, "ExecEvalGroupingFunc", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalGroupingFunc, opno,
 								v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -2196,13 +2196,13 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_SUBPLAN:
-				build_EvalXFunc(&ecs, "ExecEvalSubPlan", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalSubPlan, opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_ALTERNATIVE_SUBPLAN:
-				build_EvalXFunc(&ecs, "ExecEvalAlternativeSubPlan", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalAlternativeSubPlan, opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -2551,13 +2551,13 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_AGG_ORDERED_TRANS_DATUM:
-				build_EvalXFunc(&ecs, "ExecEvalAggOrderedTransDatum", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalAggOrderedTransDatum, opno,
 								expr_nullable_datum_array_ref(&ecs, op->d.agg_trans_ordered.columns));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_AGG_ORDERED_TRANS_TUPLE:
-				build_EvalXFunc(&ecs, "ExecEvalAggOrderedTransTuple", opno,
+				build_EvalXFunc(&ecs, FuncExecEvalAggOrderedTransTuple, opno,
 								expr_nullable_datum_array_ref(&ecs, op->d.agg_trans_ordered.columns));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -3115,37 +3115,17 @@ BuildV1CallFC(ExprCompileState *ecs,
  * Implement an expression step by calling the function funcname.
  */
 static void
-build_EvalXFuncInt(ExprCompileState *ecs, const char *funcname, int opno,
+build_EvalXFuncInt(ExprCompileState *ecs, LLVMValueRef v_fn, int opno,
 				   int nargs, LLVMValueRef v_args[])
 {
 	LLVMValueRef v_opno = l_int32_const(opno);
 	LLVMValueRef v_opp;
-	LLVMTypeRef sig;
-	LLVMValueRef v_fn;
 	LLVMValueRef *params;
-	LLVMTypeRef *param_types;
 
 	params = palloc(sizeof(LLVMValueRef) * (2 + nargs));
-	param_types = palloc(sizeof(LLVMValueRef) * (2 + nargs));
 
 	v_opp = LLVMBuildGEP(ecs->b, ecs->v_steps,
 						 (LLVMValueRef[]){l_int32_const(0), v_opno}, 2, "");
-	v_fn = LLVMGetNamedFunction(ecs->mod, funcname);
-	if (!v_fn)
-	{
-		int argno = 0;
-
-		param_types[argno++] = l_ptr(StructExprState);
-		param_types[argno++] = l_ptr(StructExprEvalStep);
-
-		for (int i = 0; i < nargs; i++)
-			param_types[argno++] = LLVMTypeOf(v_args[i]);
-
-		sig = LLVMFunctionType(LLVMVoidType(),
-							   param_types, argno,
-							   false);
-		v_fn = LLVMAddFunction(ecs->mod, funcname, sig);
-	}
 
 	{
 		int argno = 0;
@@ -3156,6 +3136,6 @@ build_EvalXFuncInt(ExprCompileState *ecs, const char *funcname, int opno,
 		for (int i = 0; i < nargs; i++)
 			params[argno++] = v_args[i];
 
-		LLVMBuildCall(ecs->b, v_fn, params, argno, "");
+		LLVMBuildCall(ecs->b, llvm_get_decl(ecs->mod, v_fn), params, argno, "");
 	}
 }
diff --git a/src/backend/jit/llvm/llvmjit_types.c b/src/backend/jit/llvm/llvmjit_types.c
index 082b312060..d414e60b99 100644
--- a/src/backend/jit/llvm/llvmjit_types.c
+++ b/src/backend/jit/llvm/llvmjit_types.c
@@ -114,5 +114,34 @@ void	   *referenced_functions[] =
 	ExecAggInitGroup,
 	ExecEvalArrayCoerceRelabel,
 	ExecEvalArrayCoerceUnpack,
-	ExecEvalArrayCoercePack
+	ExecEvalArrayCoercePack,
+	ExecEvalFuncExprFusage,
+	ExecEvalFuncExprStrictFusage,
+	ExecEvalRowNull,
+	ExecEvalRowNotNull,
+	ExecEvalParamExec,
+	ExecEvalParamExtern,
+	ExecEvalSubscriptingRefOld,
+	ExecEvalSubscriptingRefAssign,
+	ExecEvalSubscriptingRefFetch,
+	ExecEvalSQLValueFunction,
+	ExecEvalCurrentOfExpr,
+	ExecEvalNextValueExpr,
+	ExecEvalArrayExpr,
+	ExecEvalRow,
+	ExecEvalMinMax,
+	ExecEvalFieldSelect,
+	ExecEvalFieldStoreDeForm,
+	ExecEvalFieldStoreForm,
+	ExecEvalConstraintNotNull,
+	ExecEvalConstraintCheck,
+	ExecEvalConvertRowtype,
+	ExecEvalScalarArrayOp,
+	ExecEvalXmlExpr,
+	ExecEvalGroupingFunc,
+	ExecEvalSubPlan,
+	ExecEvalAlternativeSubPlan,
+	ExecEvalAggOrderedTransDatum,
+	ExecEvalAggOrderedTransTuple,
+	ExecEvalWholeRowVar
 };
diff --git a/src/include/jit/llvmjit.h b/src/include/jit/llvmjit.h
index 751bb69e25..4fd0dc7072 100644
--- a/src/include/jit/llvmjit.h
+++ b/src/include/jit/llvmjit.h
@@ -97,7 +97,35 @@ extern LLVMValueRef FuncExecAggInitGroup;
 extern LLVMValueRef FuncExecEvalArrayCoerceRelabel;
 extern LLVMValueRef FuncExecEvalArrayCoerceUnpack;
 extern LLVMValueRef FuncExecEvalArrayCoercePack;
-
+extern LLVMValueRef FuncExecEvalFuncExprFusage;
+extern LLVMValueRef FuncExecEvalFuncExprStrictFusage;
+extern LLVMValueRef FuncExecEvalRowNull;
+extern LLVMValueRef FuncExecEvalRowNotNull;
+extern LLVMValueRef FuncExecEvalParamExec;
+extern LLVMValueRef FuncExecEvalParamExtern;
+extern LLVMValueRef FuncExecEvalSubscriptingRefOld;
+extern LLVMValueRef FuncExecEvalSubscriptingRefAssign;
+extern LLVMValueRef FuncExecEvalSubscriptingRefFetch;
+extern LLVMValueRef FuncExecEvalSQLValueFunction;
+extern LLVMValueRef FuncExecEvalCurrentOfExpr;
+extern LLVMValueRef FuncExecEvalNextValueExpr;
+extern LLVMValueRef FuncExecEvalArrayExpr;
+extern LLVMValueRef FuncExecEvalRow;
+extern LLVMValueRef FuncExecEvalMinMax;
+extern LLVMValueRef FuncExecEvalFieldSelect;
+extern LLVMValueRef FuncExecEvalFieldStoreDeForm;
+extern LLVMValueRef FuncExecEvalFieldStoreForm;
+extern LLVMValueRef FuncExecEvalConstraintNotNull;
+extern LLVMValueRef FuncExecEvalConstraintCheck;
+extern LLVMValueRef FuncExecEvalConvertRowtype;
+extern LLVMValueRef FuncExecEvalScalarArrayOp;
+extern LLVMValueRef FuncExecEvalXmlExpr;
+extern LLVMValueRef FuncExecEvalGroupingFunc;
+extern LLVMValueRef FuncExecEvalSubPlan;
+extern LLVMValueRef FuncExecEvalAlternativeSubPlan;
+extern LLVMValueRef FuncExecEvalAggOrderedTransDatum;
+extern LLVMValueRef FuncExecEvalAggOrderedTransTuple;
+extern LLVMValueRef FuncExecEvalWholeRowVar;
 
 extern void llvm_enter_fatal_on_oom(void);
 extern void llvm_leave_fatal_on_oom(void);
-- 
2.23.0

From 07c7ff996706c6f71e00d76894845c1f87956472 Mon Sep 17 00:00:00 2001
From: soumyadeep2007 <sochakraborty@pivotal.io>
Date: Sun, 27 Oct 2019 17:42:53 -0700
Subject: [PATCH v1] Resolve PL handler names for JITed code instead of using
 const pointers

Using const pointers to PL handler functions prevents optimization
opportunities in JITed code. Now fmgr_symbol() resolves PL function
references to the corresponding language's handler.
llvm_function_reference() now no longer needs to create the global to
such a function.

Discussion: https://postgr.es/m/20191024224303.jvdx3hq3ak2vbit3%40alap3.anarazel.de:wq
---
 src/backend/jit/llvm/llvmjit.c | 29 +++--------------------------
 src/backend/utils/fmgr/fmgr.c  | 30 +++++++++++++++++++++++-------
 2 files changed, 26 insertions(+), 33 deletions(-)

diff --git a/src/backend/jit/llvm/llvmjit.c b/src/backend/jit/llvm/llvmjit.c
index 82c4afb701..69a4167ac9 100644
--- a/src/backend/jit/llvm/llvmjit.c
+++ b/src/backend/jit/llvm/llvmjit.c
@@ -369,38 +369,15 @@ llvm_function_reference(LLVMJitContext *context,
 
 	fmgr_symbol(fcinfo->flinfo->fn_oid, &modname, &basename);
 
-	if (modname != NULL && basename != NULL)
+	if (modname != NULL)
 	{
 		/* external function in loadable library */
 		funcname = psprintf("pgextern.%s.%s", modname, basename);
 	}
-	else if (basename != NULL)
-	{
-		/* internal function */
-		funcname = psprintf("%s", 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 LLVMBuildLoad(builder, 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);
-
-		return LLVMBuildLoad(builder, v_fn, "");
+		/* internal function or a PL handler */
+		funcname = psprintf("%s", basename);
 	}
 
 	/* check if function already has been added */
diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c
index 099ebd779b..71398bb3c1 100644
--- a/src/backend/utils/fmgr/fmgr.c
+++ b/src/backend/utils/fmgr/fmgr.c
@@ -265,11 +265,9 @@ fmgr_info_cxt_security(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt,
 /*
  * Return module and C function name providing implementation of functionId.
  *
- * If *mod == NULL and *fn == NULL, no C symbol is known to implement
- * function.
- *
  * If *mod == NULL and *fn != NULL, the function is implemented by a symbol in
- * the main binary.
+ * the main binary. If the function being looked up is not a C language
+ * function, it's language handler name is returned.
  *
  * If *mod != NULL and *fn !=NULL the function is implemented in an extension
  * shared object.
@@ -285,6 +283,11 @@ fmgr_symbol(Oid functionId, char **mod, char **fn)
 	bool		isnull;
 	Datum		prosrcattr;
 	Datum		probinattr;
+	Oid			language;
+	HeapTuple	languageTuple;
+	Form_pg_language languageStruct;
+	HeapTuple	plHandlerProcedureTuple;
+	Form_pg_proc plHandlerProcedureStruct;
 
 	/* Otherwise we need the pg_proc entry */
 	procedureTuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(functionId));
@@ -304,8 +307,9 @@ fmgr_symbol(Oid functionId, char **mod, char **fn)
 		return;
 	}
 
+	language = procedureStruct->prolang;
 	/* see fmgr_info_cxt_security for the individual cases */
-	switch (procedureStruct->prolang)
+	switch (language)
 	{
 		case INTERNALlanguageId:
 			prosrcattr = SysCacheGetAttr(PROCOID, procedureTuple,
@@ -342,9 +346,21 @@ fmgr_symbol(Oid functionId, char **mod, char **fn)
 			break;
 
 		default:
+			languageTuple = SearchSysCache1(LANGOID,
+											 ObjectIdGetDatum(language));
+			if (!HeapTupleIsValid(languageTuple))
+				elog(ERROR, "cache lookup failed for language %u", language);
+			languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
+			plHandlerProcedureTuple = SearchSysCache1(PROCOID,
+													  ObjectIdGetDatum(
+														  languageStruct->lanplcallfoid));
+			if (!HeapTupleIsValid(plHandlerProcedureTuple))
+				elog(ERROR, "cache lookup failed for function %u", functionId);
+			plHandlerProcedureStruct = (Form_pg_proc) GETSTRUCT(plHandlerProcedureTuple);
 			*mod = NULL;
-			*fn = NULL;			/* unknown, pass pointer */
-			break;
+			*fn = pstrdup(NameStr(plHandlerProcedureStruct->proname));
+			ReleaseSysCache(languageTuple);
+			ReleaseSysCache(plHandlerProcedureTuple);
 	}
 
 	ReleaseSysCache(procedureTuple);
-- 
2.23.0

From 31e27a06c265abcaf8bc991b691194fc6b7f90a0 Mon Sep 17 00:00:00 2001
From: soumyadeep2007 <sochakraborty@pivotal.io>
Date: Mon, 28 Oct 2019 22:25:20 -0700
Subject: [PATCH v2] Rely on llvmjit_types for building EvalFunc calls

Rely on llvmjit_types's referenced_functions for building calls to EvalFuncs.
This ensures signature checks for the calls constructed.
---
 src/backend/jit/llvm/llvmjit.c       |  84 +++++++--------
 src/backend/jit/llvm/llvmjit_expr.c  | 146 +++++++++++++++++----------
 src/backend/jit/llvm/llvmjit_types.c |  31 +++++-
 src/include/jit/llvmjit.h            |   3 +-
 4 files changed, 166 insertions(+), 98 deletions(-)

diff --git a/src/backend/jit/llvm/llvmjit.c b/src/backend/jit/llvm/llvmjit.c
index cdac7b1c5d..be86ef2054 100644
--- a/src/backend/jit/llvm/llvmjit.c
+++ b/src/backend/jit/llvm/llvmjit.c
@@ -49,6 +49,7 @@ typedef struct LLVMJitHandle
 	LLVMOrcModuleHandle orc_handle;
 } LLVMJitHandle;
 
+LLVMModuleRef LLVMJITPGTypesModule = NULL;
 
 /* types & functions commonly needed for JITing */
 LLVMTypeRef TypeSizeT;
@@ -866,7 +867,6 @@ llvm_create_types(void)
 	char		path[MAXPGPATH];
 	LLVMMemoryBufferRef buf;
 	char	   *msg;
-	LLVMModuleRef mod = NULL;
 
 	snprintf(path, MAXPGPATH, "%s/%s", pkglib_path, "llvmjit_types.bc");
 
@@ -878,7 +878,7 @@ llvm_create_types(void)
 	}
 
 	/* eagerly load contents, going to need it all */
-	if (LLVMParseBitcode2(buf, &mod))
+	if (LLVMParseBitcode2(buf, &LLVMJITPGTypesModule))
 	{
 		elog(ERROR, "LLVMParseBitcode2 of %s failed", path);
 	}
@@ -888,46 +888,46 @@ llvm_create_types(void)
 	 * 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");
-	TypeExecEvalParamCallback = load_type(mod, "TypeExecEvalParamCallback");
-	StructNode = load_type(mod, "StructNode");
-	StructNullableDatum = load_type(mod, "StructNullableDatum");
-	StructExprContext = load_type(mod, "StructExprContext");
-	StructExprEvalStep = load_type(mod, "StructExprEvalStep");
-	StructExprEvalStepParamCallback = load_type(mod, "StructExprEvalStepParamCallback");
-	StructExprState = load_type(mod, "StructExprState");
-	StructFmgrInfo = load_type(mod, "StructFmgrInfo");
-	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");
-	StructAggStatePerCallContext = load_type(mod, "StructAggStatePerCallContext");
-	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");
-	FuncExecEvalArrayCoerceRelabel = LLVMGetNamedFunction(mod, "ExecEvalArrayCoerceRelabel");
-	FuncExecEvalArrayCoerceUnpack = LLVMGetNamedFunction(mod, "ExecEvalArrayCoerceUnpack");
-	FuncExecEvalArrayCoercePack = LLVMGetNamedFunction(mod, "ExecEvalArrayCoercePack");
+	llvm_triple = pstrdup(LLVMGetTarget(LLVMJITPGTypesModule));
+	llvm_layout = pstrdup(LLVMGetDataLayoutStr(LLVMJITPGTypesModule));
+
+	TypeSizeT = load_type(LLVMJITPGTypesModule, "TypeSizeT");
+	TypeParamBool = load_return_type(LLVMJITPGTypesModule, "FunctionReturningBool");
+	TypeStorageBool = load_type(LLVMJITPGTypesModule, "TypeStorageBool");
+	TypePGFunction = load_type(LLVMJITPGTypesModule, "TypePGFunction");
+	TypeExecEvalParamCallback = load_type(LLVMJITPGTypesModule, "TypeExecEvalParamCallback");
+	StructNode = load_type(LLVMJITPGTypesModule, "StructNode");
+	StructNullableDatum = load_type(LLVMJITPGTypesModule, "StructNullableDatum");
+	StructExprContext = load_type(LLVMJITPGTypesModule, "StructExprContext");
+	StructExprEvalStep = load_type(LLVMJITPGTypesModule, "StructExprEvalStep");
+	StructExprEvalStepParamCallback = load_type(LLVMJITPGTypesModule, "StructExprEvalStepParamCallback");
+	StructExprState = load_type(LLVMJITPGTypesModule, "StructExprState");
+	StructFmgrInfo = load_type(LLVMJITPGTypesModule, "StructFmgrInfo");
+	StructFunctionCallInfoData = load_type(LLVMJITPGTypesModule, "StructFunctionCallInfoData");
+	StructMemoryContextData = load_type(LLVMJITPGTypesModule, "StructMemoryContextData");
+	StructTupleTableSlot = load_type(LLVMJITPGTypesModule, "StructTupleTableSlot");
+	StructHeapTupleTableSlot = load_type(LLVMJITPGTypesModule, "StructHeapTupleTableSlot");
+	StructMinimalTupleTableSlot = load_type(LLVMJITPGTypesModule, "StructMinimalTupleTableSlot");
+	StructHeapTupleData = load_type(LLVMJITPGTypesModule, "StructHeapTupleData");
+	StructTupleDescData = load_type(LLVMJITPGTypesModule, "StructTupleDescData");
+	StructAggState = load_type(LLVMJITPGTypesModule, "StructAggState");
+	StructAggStatePerCallContext = load_type(LLVMJITPGTypesModule, "StructAggStatePerCallContext");
+	StructAggStatePerGroupData = load_type(LLVMJITPGTypesModule, "StructAggStatePerGroupData");
+	StructAggStatePerTransData = load_type(LLVMJITPGTypesModule, "StructAggStatePerTransData");
+
+	AttributeTemplate = LLVMGetNamedFunction(LLVMJITPGTypesModule, "AttributeTemplate");
+	FuncStrlen = LLVMGetNamedFunction(LLVMJITPGTypesModule, "strlen");
+	FuncVarsizeAny = LLVMGetNamedFunction(LLVMJITPGTypesModule, "varsize_any");
+	FuncSlotGetsomeattrsInt = LLVMGetNamedFunction(LLVMJITPGTypesModule, "slot_getsomeattrs_int");
+	FuncSlotGetmissingattrs = LLVMGetNamedFunction(LLVMJITPGTypesModule, "slot_getmissingattrs");
+	FuncMakeExpandedObjectReadOnlyInternal = LLVMGetNamedFunction(LLVMJITPGTypesModule, "MakeExpandedObjectReadOnlyInternal");
+	FuncExecEvalSubscriptingRef = LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalSubscriptingRef");
+	FuncExecEvalSysVar = LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalSysVar");
+	FuncExecAggTransReparent = LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecAggTransReparent");
+	FuncExecAggInitGroup = LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecAggInitGroup");
+	FuncExecEvalArrayCoerceRelabel = LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalArrayCoerceRelabel");
+	FuncExecEvalArrayCoerceUnpack = LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalArrayCoerceUnpack");
+	FuncExecEvalArrayCoercePack = LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalArrayCoercePack");
 
 	/*
 	 * Leave the module alive, otherwise references to function would be
diff --git a/src/backend/jit/llvm/llvmjit_expr.c b/src/backend/jit/llvm/llvmjit_expr.c
index bbe0fd0cb3..d7e528f032 100644
--- a/src/backend/jit/llvm/llvmjit_expr.c
+++ b/src/backend/jit/llvm/llvmjit_expr.c
@@ -131,12 +131,12 @@ static LLVMValueRef BuildV1CallFC(ExprCompileState *ecs,
 								  LLVMValueRef v_fcinfo,
 								  LLVMValueRef *v_fcinfo_isnull);
 
-#define build_EvalXFunc(ecs, funcname, opno, ...) \
-	build_EvalXFuncInt(ecs, funcname, opno, \
+#define build_EvalXFunc(ecs, v_fn, opno, ...) \
+	build_EvalXFuncInt(ecs, v_fn, opno, \
 					   lengthof(((LLVMValueRef[]){__VA_ARGS__})), \
 					   ((LLVMValueRef[]){__VA_ARGS__}))
 
-static void build_EvalXFuncInt(ExprCompileState *ecs, const char *funcname,
+static void build_EvalXFuncInt(ExprCompileState *ecs, LLVMValueRef v_fn,
 							   int opno, int natts, LLVMValueRef v_args[]);
 
 /*
@@ -561,7 +561,9 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_WHOLEROW:
-				build_EvalXFunc(&ecs, "ExecEvalWholeRowVar", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalWholeRowVar"),
+								opno,
 								ecs.v_econtext,	v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -798,7 +800,9 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_FUNCEXPR_FUSAGE:
-				build_EvalXFunc(&ecs, "ExecEvalFuncExprFusage", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "EvalFuncExprFusage"),
+								opno,
 								v_resultp,
 								expr_fcinfo_ref(&ecs, op->d.func.fcinfo_data, NULL));
 				LLVMBuildBr(b, opblocks[opno + 1]);
@@ -806,7 +810,9 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 
 
 			case EEOP_FUNCEXPR_STRICT_FUSAGE:
-				build_EvalXFunc(&ecs, "ExecEvalFuncExprStrictFusage", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalFuncExprStrictFusage"),
+								opno,
 								v_resultp,
 								expr_fcinfo_ref(&ecs, op->d.func.fcinfo_data, NULL));
 				LLVMBuildBr(b, opblocks[opno + 1]);
@@ -1190,13 +1196,17 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_NULLTEST_ROWISNULL:
-				build_EvalXFunc(&ecs, "ExecEvalRowNull", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalRowNull"),
+								opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_NULLTEST_ROWISNOTNULL:
-				build_EvalXFunc(&ecs, "ExecEvalRowNotNull", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalRowNotNull"),
+								opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -1269,13 +1279,17 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_PARAM_EXEC:
-				build_EvalXFunc(&ecs, "ExecEvalParamExec", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalParamExec"),
+								opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_PARAM_EXTERN:
-				build_EvalXFunc(&ecs, "ExecEvalParamExtern", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalParamExtern"),
+								opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -1322,21 +1336,27 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_SBSREF_OLD:
-				build_EvalXFunc(&ecs, "ExecEvalSubscriptingRefOld", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalSubscriptingRefOld"),
+								opno,
 								v_resultp,
 								expr_nullable_datum_ref(&ecs, op->d.sbsref.prev));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_SBSREF_ASSIGN:
-				build_EvalXFunc(&ecs, "ExecEvalSubscriptingRefAssign", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalSubscriptingRefAssign"),
+									opno,
 								v_resultp,
 								expr_nullable_datum_ref(&ecs, op->d.sbsref.replace));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_SBSREF_FETCH:
-				build_EvalXFunc(&ecs, "ExecEvalSubscriptingRefFetch", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalSubscriptingRefFetch"),
+								opno,
 								v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -1755,24 +1775,32 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_SQLVALUEFUNCTION:
-				build_EvalXFunc(&ecs, "ExecEvalSQLValueFunction", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalSQLValueFunction"),
+								opno,
 								v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_CURRENTOFEXPR:
-				build_EvalXFunc(&ecs, "ExecEvalCurrentOfExpr", opno);
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalCurrentOfExpr"),
+								opno);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_NEXTVALUEEXPR:
-				build_EvalXFunc(&ecs, "ExecEvalNextValueExpr", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalNextValueExpr"),
+								opno,
 								v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_ARRAYEXPR:
-				build_EvalXFunc(&ecs, "ExecEvalArrayExpr", opno, v_resultp,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalArrayExpr"),
+								opno, v_resultp,
 								expr_nullable_datum_array_ref(&ecs, op->d.arrayexpr.elements));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -1842,7 +1870,9 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_ROW:
-				build_EvalXFunc(&ecs, "ExecEvalRow", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalRow"),
+								opno,
 								v_resultp,
 								expr_nullable_datum_array_ref(&ecs, op->d.row.elements));
 				LLVMBuildBr(b, opblocks[opno + 1]);
@@ -2003,7 +2033,9 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_MINMAX:
-				build_EvalXFunc(&ecs, "ExecEvalMinMax", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalMinMax"),
+								opno,
 								v_resultp,
 								expr_nullable_datum_array_ref(&ecs, op->d.minmax.arguments),
 								expr_fcinfo_ref(&ecs, op->d.minmax.fcinfo_data, NULL));
@@ -2011,20 +2043,26 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				break;
 
 			case EEOP_FIELDSELECT:
-				build_EvalXFunc(&ecs, "ExecEvalFieldSelect", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalFieldSelect"),
+								opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_FIELDSTORE_DEFORM:
-				build_EvalXFunc(&ecs, "ExecEvalFieldStoreDeForm", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalFieldStoreDeForm"),
+								opno,
 								ecs.v_econtext, v_resultp,
 								expr_nullable_datum_array_ref(&ecs, op->d.fieldstore.columns));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_FIELDSTORE_FORM:
-				build_EvalXFunc(&ecs, "ExecEvalFieldStoreForm", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalFieldStoreForm"),
+								opno,
 								v_resultp,
 								expr_nullable_datum_array_ref(&ecs, op->d.fieldstore.columns));
 				LLVMBuildBr(b, opblocks[opno + 1]);
@@ -2101,32 +2139,42 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_DOMAIN_NOTNULL:
-				build_EvalXFunc(&ecs, "ExecEvalConstraintNotNull", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalConstraintNotNull"),
+								opno,
 								v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_DOMAIN_CHECK:
-				build_EvalXFunc(&ecs, "ExecEvalConstraintCheck", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalConstraintCheck"),
+								opno,
 								expr_nullable_datum_ref(&ecs, op->d.domaincheck.check));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_CONVERT_ROWTYPE:
-				build_EvalXFunc(&ecs, "ExecEvalConvertRowtype", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalConvertRowtype"),
+								opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_SCALARARRAYOP:
-				build_EvalXFunc(&ecs, "ExecEvalScalarArrayOp", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalScalarArrayOp"),
+								opno,
 								v_resultp,
 								expr_fcinfo_ref(&ecs, op->d.scalararrayop.fcinfo_data, NULL));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_XMLEXPR:
-				build_EvalXFunc(&ecs, "ExecEvalXmlExpr", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalXmlExpr"),
+								opno,
 								v_resultp,
 								expr_nullable_datum_array_ref(&ecs, op->d.xmlexpr.args),
 								expr_nullable_datum_array_ref(&ecs, op->d.xmlexpr.named_args));
@@ -2162,7 +2210,9 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_GROUPING_FUNC:
-				build_EvalXFunc(&ecs, "ExecEvalGroupingFunc", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalGroupingFunc"),
+								opno,
 								v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -2196,13 +2246,17 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_SUBPLAN:
-				build_EvalXFunc(&ecs, "ExecEvalSubPlan", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalSubPlan"),
+								opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_ALTERNATIVE_SUBPLAN:
-				build_EvalXFunc(&ecs, "ExecEvalAlternativeSubPlan", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalAlternativeSubPlan"),
+								opno,
 								ecs.v_econtext, v_resultp);
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -2551,13 +2605,17 @@ llvm_compile_expr(ExprState *state, ExprStateBuilder *esb)
 				}
 
 			case EEOP_AGG_ORDERED_TRANS_DATUM:
-				build_EvalXFunc(&ecs, "ExecEvalAggOrderedTransDatum", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalAggOrderedTransDatum"),
+								opno,
 								expr_nullable_datum_array_ref(&ecs, op->d.agg_trans_ordered.columns));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
 
 			case EEOP_AGG_ORDERED_TRANS_TUPLE:
-				build_EvalXFunc(&ecs, "ExecEvalAggOrderedTransTuple", opno,
+				build_EvalXFunc(&ecs,
+								LLVMGetNamedFunction(LLVMJITPGTypesModule, "ExecEvalAggOrderedTransTuple"),
+								opno,
 								expr_nullable_datum_array_ref(&ecs, op->d.agg_trans_ordered.columns));
 				LLVMBuildBr(b, opblocks[opno + 1]);
 				break;
@@ -3115,37 +3173,17 @@ BuildV1CallFC(ExprCompileState *ecs,
  * Implement an expression step by calling the function funcname.
  */
 static void
-build_EvalXFuncInt(ExprCompileState *ecs, const char *funcname, int opno,
+build_EvalXFuncInt(ExprCompileState *ecs, LLVMValueRef v_fn, int opno,
 				   int nargs, LLVMValueRef v_args[])
 {
 	LLVMValueRef v_opno = l_int32_const(opno);
 	LLVMValueRef v_opp;
-	LLVMTypeRef sig;
-	LLVMValueRef v_fn;
 	LLVMValueRef *params;
-	LLVMTypeRef *param_types;
 
 	params = palloc(sizeof(LLVMValueRef) * (2 + nargs));
-	param_types = palloc(sizeof(LLVMValueRef) * (2 + nargs));
 
 	v_opp = LLVMBuildGEP(ecs->b, ecs->v_steps,
 						 (LLVMValueRef[]){l_int32_const(0), v_opno}, 2, "");
-	v_fn = LLVMGetNamedFunction(ecs->mod, funcname);
-	if (!v_fn)
-	{
-		int argno = 0;
-
-		param_types[argno++] = l_ptr(StructExprState);
-		param_types[argno++] = l_ptr(StructExprEvalStep);
-
-		for (int i = 0; i < nargs; i++)
-			param_types[argno++] = LLVMTypeOf(v_args[i]);
-
-		sig = LLVMFunctionType(LLVMVoidType(),
-							   param_types, argno,
-							   false);
-		v_fn = LLVMAddFunction(ecs->mod, funcname, sig);
-	}
 
 	{
 		int argno = 0;
@@ -3156,6 +3194,6 @@ build_EvalXFuncInt(ExprCompileState *ecs, const char *funcname, int opno,
 		for (int i = 0; i < nargs; i++)
 			params[argno++] = v_args[i];
 
-		LLVMBuildCall(ecs->b, v_fn, params, argno, "");
+		LLVMBuildCall(ecs->b, llvm_get_decl(ecs->mod, v_fn), params, argno, "");
 	}
 }
diff --git a/src/backend/jit/llvm/llvmjit_types.c b/src/backend/jit/llvm/llvmjit_types.c
index 082b312060..d414e60b99 100644
--- a/src/backend/jit/llvm/llvmjit_types.c
+++ b/src/backend/jit/llvm/llvmjit_types.c
@@ -114,5 +114,34 @@ void	   *referenced_functions[] =
 	ExecAggInitGroup,
 	ExecEvalArrayCoerceRelabel,
 	ExecEvalArrayCoerceUnpack,
-	ExecEvalArrayCoercePack
+	ExecEvalArrayCoercePack,
+	ExecEvalFuncExprFusage,
+	ExecEvalFuncExprStrictFusage,
+	ExecEvalRowNull,
+	ExecEvalRowNotNull,
+	ExecEvalParamExec,
+	ExecEvalParamExtern,
+	ExecEvalSubscriptingRefOld,
+	ExecEvalSubscriptingRefAssign,
+	ExecEvalSubscriptingRefFetch,
+	ExecEvalSQLValueFunction,
+	ExecEvalCurrentOfExpr,
+	ExecEvalNextValueExpr,
+	ExecEvalArrayExpr,
+	ExecEvalRow,
+	ExecEvalMinMax,
+	ExecEvalFieldSelect,
+	ExecEvalFieldStoreDeForm,
+	ExecEvalFieldStoreForm,
+	ExecEvalConstraintNotNull,
+	ExecEvalConstraintCheck,
+	ExecEvalConvertRowtype,
+	ExecEvalScalarArrayOp,
+	ExecEvalXmlExpr,
+	ExecEvalGroupingFunc,
+	ExecEvalSubPlan,
+	ExecEvalAlternativeSubPlan,
+	ExecEvalAggOrderedTransDatum,
+	ExecEvalAggOrderedTransTuple,
+	ExecEvalWholeRowVar
 };
diff --git a/src/include/jit/llvmjit.h b/src/include/jit/llvmjit.h
index 751bb69e25..2fb25eb899 100644
--- a/src/include/jit/llvmjit.h
+++ b/src/include/jit/llvmjit.h
@@ -57,6 +57,8 @@ typedef struct LLVMJitContext
 	List	   *handles;
 } LLVMJitContext;
 
+extern LLVMModuleRef LLVMJITPGTypesModule;
+
 
 /* type and struct definitions */
 extern LLVMTypeRef TypeParamBool;
@@ -98,7 +100,6 @@ extern LLVMValueRef FuncExecEvalArrayCoerceRelabel;
 extern LLVMValueRef FuncExecEvalArrayCoerceUnpack;
 extern LLVMValueRef FuncExecEvalArrayCoercePack;
 
-
 extern void llvm_enter_fatal_on_oom(void);
 extern void llvm_leave_fatal_on_oom(void);
 extern void llvm_reset_after_error(void);
-- 
2.23.0

From 1f7b9b9a448521deb0d28b07ed77bb9ea7b842cd Mon Sep 17 00:00:00 2001
From: soumyadeep2007 <sochakraborty@pivotal.io>
Date: Sun, 27 Oct 2019 17:42:53 -0700
Subject: [PATCH v2] Resolve PL handler names for JITed code instead of using
 const pointers

Using const pointers to PL handler functions prevents optimization
opportunities in JITed code. Now fmgr_symbol() resolves PL function
references to the corresponding language's handler.
llvm_function_reference() now no longer needs to create the global to
such a function.

Discussion: https://postgr.es/m/20191024224303.jvdx3hq3ak2vbit3%40alap3.anarazel.de:wq
---
 src/backend/jit/llvm/llvmjit.c | 31 +++++--------------------------
 src/backend/utils/fmgr/fmgr.c  | 30 +++++++++++++++++++++++-------
 2 files changed, 28 insertions(+), 33 deletions(-)

diff --git a/src/backend/jit/llvm/llvmjit.c b/src/backend/jit/llvm/llvmjit.c
index 82c4afb701..9da71a2da7 100644
--- a/src/backend/jit/llvm/llvmjit.c
+++ b/src/backend/jit/llvm/llvmjit.c
@@ -369,38 +369,17 @@ llvm_function_reference(LLVMJitContext *context,
 
 	fmgr_symbol(fcinfo->flinfo->fn_oid, &modname, &basename);
 
-	if (modname != NULL && basename != NULL)
+	Assert(basename != NULL);
+
+	if (modname != NULL)
 	{
 		/* external function in loadable library */
 		funcname = psprintf("pgextern.%s.%s", modname, basename);
 	}
-	else if (basename != NULL)
-	{
-		/* internal function */
-		funcname = psprintf("%s", 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 LLVMBuildLoad(builder, 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);
-
-		return LLVMBuildLoad(builder, v_fn, "");
+		/* internal function or a PL handler */
+		funcname = psprintf("%s", basename);
 	}
 
 	/* check if function already has been added */
diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c
index 099ebd779b..71398bb3c1 100644
--- a/src/backend/utils/fmgr/fmgr.c
+++ b/src/backend/utils/fmgr/fmgr.c
@@ -265,11 +265,9 @@ fmgr_info_cxt_security(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt,
 /*
  * Return module and C function name providing implementation of functionId.
  *
- * If *mod == NULL and *fn == NULL, no C symbol is known to implement
- * function.
- *
  * If *mod == NULL and *fn != NULL, the function is implemented by a symbol in
- * the main binary.
+ * the main binary. If the function being looked up is not a C language
+ * function, it's language handler name is returned.
  *
  * If *mod != NULL and *fn !=NULL the function is implemented in an extension
  * shared object.
@@ -285,6 +283,11 @@ fmgr_symbol(Oid functionId, char **mod, char **fn)
 	bool		isnull;
 	Datum		prosrcattr;
 	Datum		probinattr;
+	Oid			language;
+	HeapTuple	languageTuple;
+	Form_pg_language languageStruct;
+	HeapTuple	plHandlerProcedureTuple;
+	Form_pg_proc plHandlerProcedureStruct;
 
 	/* Otherwise we need the pg_proc entry */
 	procedureTuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(functionId));
@@ -304,8 +307,9 @@ fmgr_symbol(Oid functionId, char **mod, char **fn)
 		return;
 	}
 
+	language = procedureStruct->prolang;
 	/* see fmgr_info_cxt_security for the individual cases */
-	switch (procedureStruct->prolang)
+	switch (language)
 	{
 		case INTERNALlanguageId:
 			prosrcattr = SysCacheGetAttr(PROCOID, procedureTuple,
@@ -342,9 +346,21 @@ fmgr_symbol(Oid functionId, char **mod, char **fn)
 			break;
 
 		default:
+			languageTuple = SearchSysCache1(LANGOID,
+											 ObjectIdGetDatum(language));
+			if (!HeapTupleIsValid(languageTuple))
+				elog(ERROR, "cache lookup failed for language %u", language);
+			languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
+			plHandlerProcedureTuple = SearchSysCache1(PROCOID,
+													  ObjectIdGetDatum(
+														  languageStruct->lanplcallfoid));
+			if (!HeapTupleIsValid(plHandlerProcedureTuple))
+				elog(ERROR, "cache lookup failed for function %u", functionId);
+			plHandlerProcedureStruct = (Form_pg_proc) GETSTRUCT(plHandlerProcedureTuple);
 			*mod = NULL;
-			*fn = NULL;			/* unknown, pass pointer */
-			break;
+			*fn = pstrdup(NameStr(plHandlerProcedureStruct->proname));
+			ReleaseSysCache(languageTuple);
+			ReleaseSysCache(plHandlerProcedureTuple);
 	}
 
 	ReleaseSysCache(procedureTuple);
-- 
2.23.0

diff -U3 /Users/pivotal/workspace/postgres/src/test/regress/expected/point.out /Users/pivotal/workspace/postgres/src/test/regress/results/point.out
--- /Users/pivotal/workspace/postgres/src/test/regress/expected/point.out	2019-09-30 20:23:03.000000000 -0700
+++ /Users/pivotal/workspace/postgres/src/test/regress/results/point.out	2019-10-28 23:14:59.000000000 -0700
@@ -158,91 +158,9 @@
 SELECT '' AS thirtysix, p1.f1 AS point1, p2.f1 AS point2, p1.f1 <-> p2.f1 AS dist
    FROM POINT_TBL p1, POINT_TBL p2
    ORDER BY dist, p1.f1[0], p2.f1[0];
- thirtysix |      point1       |      point2       |         dist         
------------+-------------------+-------------------+----------------------
-           | (-10,0)           | (-10,0)           |                    0
-           | (-5,-12)          | (-5,-12)          |                    0
-           | (-3,4)            | (-3,4)            |                    0
-           | (0,0)             | (0,0)             |                    0
-           | (1e-300,-1e-300)  | (1e-300,-1e-300)  |                    0
-           | (5.1,34.5)        | (5.1,34.5)        |                    0
-           | (10,10)           | (10,10)           |                    0
-           | (0,0)             | (1e-300,-1e-300)  | 1.4142135623731e-300
-           | (1e-300,-1e-300)  | (0,0)             | 1.4142135623731e-300
-           | (-3,4)            | (0,0)             |                    5
-           | (-3,4)            | (1e-300,-1e-300)  |                    5
-           | (0,0)             | (-3,4)            |                    5
-           | (1e-300,-1e-300)  | (-3,4)            |                    5
-           | (-10,0)           | (-3,4)            |     8.06225774829855
-           | (-3,4)            | (-10,0)           |     8.06225774829855
-           | (-10,0)           | (0,0)             |                   10
-           | (-10,0)           | (1e-300,-1e-300)  |                   10
-           | (0,0)             | (-10,0)           |                   10
-           | (1e-300,-1e-300)  | (-10,0)           |                   10
-           | (-10,0)           | (-5,-12)          |                   13
-           | (-5,-12)          | (-10,0)           |                   13
-           | (-5,-12)          | (0,0)             |                   13
-           | (-5,-12)          | (1e-300,-1e-300)  |                   13
-           | (0,0)             | (-5,-12)          |                   13
-           | (1e-300,-1e-300)  | (-5,-12)          |                   13
-           | (0,0)             | (10,10)           |      14.142135623731
-           | (1e-300,-1e-300)  | (10,10)           |      14.142135623731
-           | (10,10)           | (0,0)             |      14.142135623731
-           | (10,10)           | (1e-300,-1e-300)  |      14.142135623731
-           | (-3,4)            | (10,10)           |     14.3178210632764
-           | (10,10)           | (-3,4)            |     14.3178210632764
-           | (-5,-12)          | (-3,4)            |     16.1245154965971
-           | (-3,4)            | (-5,-12)          |     16.1245154965971
-           | (-10,0)           | (10,10)           |     22.3606797749979
-           | (10,10)           | (-10,0)           |     22.3606797749979
-           | (5.1,34.5)        | (10,10)           |     24.9851956166046
-           | (10,10)           | (5.1,34.5)        |     24.9851956166046
-           | (-5,-12)          | (10,10)           |     26.6270539113887
-           | (10,10)           | (-5,-12)          |     26.6270539113887
-           | (-3,4)            | (5.1,34.5)        |     31.5572495632937
-           | (5.1,34.5)        | (-3,4)            |     31.5572495632937
-           | (0,0)             | (5.1,34.5)        |     34.8749193547455
-           | (1e-300,-1e-300)  | (5.1,34.5)        |     34.8749193547455
-           | (5.1,34.5)        | (0,0)             |     34.8749193547455
-           | (5.1,34.5)        | (1e-300,-1e-300)  |     34.8749193547455
-           | (-10,0)           | (5.1,34.5)        |     37.6597928831267
-           | (5.1,34.5)        | (-10,0)           |     37.6597928831267
-           | (-5,-12)          | (5.1,34.5)        |     47.5842410888311
-           | (5.1,34.5)        | (-5,-12)          |     47.5842410888311
-           | (-10,0)           | (1e+300,Infinity) |             Infinity
-           | (-5,-12)          | (1e+300,Infinity) |             Infinity
-           | (-3,4)            | (1e+300,Infinity) |             Infinity
-           | (0,0)             | (1e+300,Infinity) |             Infinity
-           | (1e-300,-1e-300)  | (1e+300,Infinity) |             Infinity
-           | (5.1,34.5)        | (1e+300,Infinity) |             Infinity
-           | (10,10)           | (1e+300,Infinity) |             Infinity
-           | (1e+300,Infinity) | (-10,0)           |             Infinity
-           | (1e+300,Infinity) | (-5,-12)          |             Infinity
-           | (1e+300,Infinity) | (-3,4)            |             Infinity
-           | (1e+300,Infinity) | (0,0)             |             Infinity
-           | (1e+300,Infinity) | (1e-300,-1e-300)  |             Infinity
-           | (1e+300,Infinity) | (5.1,34.5)        |             Infinity
-           | (1e+300,Infinity) | (10,10)           |             Infinity
-           | (-10,0)           | (NaN,NaN)         |                  NaN
-           | (-5,-12)          | (NaN,NaN)         |                  NaN
-           | (-3,4)            | (NaN,NaN)         |                  NaN
-           | (0,0)             | (NaN,NaN)         |                  NaN
-           | (1e-300,-1e-300)  | (NaN,NaN)         |                  NaN
-           | (5.1,34.5)        | (NaN,NaN)         |                  NaN
-           | (10,10)           | (NaN,NaN)         |                  NaN
-           | (1e+300,Infinity) | (1e+300,Infinity) |                  NaN
-           | (1e+300,Infinity) | (NaN,NaN)         |                  NaN
-           | (NaN,NaN)         | (-10,0)           |                  NaN
-           | (NaN,NaN)         | (-5,-12)          |                  NaN
-           | (NaN,NaN)         | (-3,4)            |                  NaN
-           | (NaN,NaN)         | (0,0)             |                  NaN
-           | (NaN,NaN)         | (1e-300,-1e-300)  |                  NaN
-           | (NaN,NaN)         | (5.1,34.5)        |                  NaN
-           | (NaN,NaN)         | (10,10)           |                  NaN
-           | (NaN,NaN)         | (1e+300,Infinity) |                  NaN
-           | (NaN,NaN)         | (NaN,NaN)         |                  NaN
-(81 rows)
-
+WARNING:  failed to resolve name float_underflow_error
+WARNING:  failed to resolve name float_overflow_error
+ERROR:  failed to look up symbol "evalexpr_21_0"
 SELECT '' AS thirty, p1.f1 AS point1, p2.f1 AS point2
    FROM POINT_TBL p1, POINT_TBL p2
    WHERE (p1.f1 <-> p2.f1) > 3;

From a90c150c7c3e9dc42902e6e42ec91f6fe2657d44 Mon Sep 17 00:00:00 2001
From: soumyadeep2007 <sochakraborty@pivotal.io>
Date: Wed, 19 Feb 2020 16:12:39 -0800
Subject: [PATCH v3] Resolve PL handler names for JITed code instead of using
 const pointers

This patch is similar in spirit to 8c2769405f and would similarly
increase the scope for inlining and optimization.

Earlier for references to PL functions, a const pointer to the PL's
handler function was emitted. Specifically, fmgr_symbol() would return
modname=NULL, basename=NULL for such a PL function reference. Then in
llvm_function_reference() a const pointer to fcinfo->finfo->fn_addr
(which would always be the PL handler's address for a PL function
reference) would be emitted.

Now, instead, look up the qualified PL handler's library and C function
name in fmgr_symbol(), so that llvm_resolve_symbol() can resolve the PL
handler's address.
---
 src/backend/jit/llvm/llvmjit.c | 29 +++-------------------
 src/backend/utils/fmgr/fmgr.c  | 45 ++++++++++++++++++++++++++++------
 2 files changed, 42 insertions(+), 32 deletions(-)

diff --git a/src/backend/jit/llvm/llvmjit.c b/src/backend/jit/llvm/llvmjit.c
index af8b34aaaf..8c547c9090 100644
--- a/src/backend/jit/llvm/llvmjit.c
+++ b/src/backend/jit/llvm/llvmjit.c
@@ -363,39 +363,18 @@ llvm_function_reference(LLVMJitContext *context,
 
 	fmgr_symbol(fcinfo->flinfo->fn_oid, &modname, &basename);
 
-	if (modname != NULL && basename != NULL)
+	Assert(basename != NULL);
+
+	if (modname != NULL)
 	{
 		/* external function in loadable library */
 		funcname = psprintf("pgextern.%s.%s", modname, basename);
 	}
-	else if (basename != NULL)
+	else
 	{
 		/* internal function */
 		funcname = psprintf("%s", 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 LLVMBuildLoad(builder, 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);
-
-		return LLVMBuildLoad(builder, v_fn, "");
-	}
 
 	/* check if function already has been added */
 	v_fn = LLVMGetNamedFunction(mod, funcname);
diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c
index 2b4226d3a8..fd967346d0 100644
--- a/src/backend/utils/fmgr/fmgr.c
+++ b/src/backend/utils/fmgr/fmgr.c
@@ -265,15 +265,15 @@ fmgr_info_cxt_security(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt,
 /*
  * Return module and C function name providing implementation of functionId.
  *
- * If *mod == NULL and *fn == NULL, no C symbol is known to implement
- * function.
- *
  * If *mod == NULL and *fn != NULL, the function is implemented by a symbol in
  * the main binary.
  *
  * If *mod != NULL and *fn !=NULL the function is implemented in an extension
  * shared object.
  *
+ * If functionId references a PL function, mod and fn will point to the PL
+ * handler's shared object and function name.
+ *
  * The returned module and function names are pstrdup'ed into the current
  * memory context.
  */
@@ -285,6 +285,11 @@ fmgr_symbol(Oid functionId, char **mod, char **fn)
 	bool		isnull;
 	Datum		prosrcattr;
 	Datum		probinattr;
+	Datum		pronameattr;
+	Oid			language;
+	HeapTuple	languageTuple;
+	Form_pg_language languageStruct;
+	HeapTuple	plhandlerTuple;
 
 	/* Otherwise we need the pg_proc entry */
 	procedureTuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(functionId));
@@ -304,8 +309,9 @@ fmgr_symbol(Oid functionId, char **mod, char **fn)
 		return;
 	}
 
+	language = procedureStruct->prolang;
 	/* see fmgr_info_cxt_security for the individual cases */
-	switch (procedureStruct->prolang)
+	switch (language)
 	{
 		case INTERNALlanguageId:
 			prosrcattr = SysCacheGetAttr(PROCOID, procedureTuple,
@@ -342,9 +348,34 @@ fmgr_symbol(Oid functionId, char **mod, char **fn)
 			break;
 
 		default:
-			*mod = NULL;
-			*fn = NULL;			/* unknown, pass pointer */
-			break;
+			/*
+			 * We referenced a PL function. Return PL handler's module and C
+			 * function name.
+			 */
+			languageTuple = SearchSysCache1(LANGOID,
+											ObjectIdGetDatum(language));
+			if (!HeapTupleIsValid(languageTuple))
+				elog(ERROR, "cache lookup failed for language %u", language);
+			languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
+			plhandlerTuple = SearchSysCache1(PROCOID,
+											 ObjectIdGetDatum(languageStruct->lanplcallfoid));
+			if (!HeapTupleIsValid(plhandlerTuple))
+				elog(ERROR, "cache lookup failed for function %u", languageStruct->lanplcallfoid);
+
+			probinattr = SysCacheGetAttr(PROCOID, plhandlerTuple,
+										 Anum_pg_proc_probin, &isnull);
+			if (isnull)
+				*mod = NULL;
+			else
+				*mod = TextDatumGetCString(probinattr);
+
+			pronameattr = SysCacheGetAttr(PROCOID, plhandlerTuple,
+										  Anum_pg_proc_proname, &isnull);
+			Assert(!isnull);
+			*fn = pstrdup(NameStr(*(DatumGetName(pronameattr))));
+
+			ReleaseSysCache(languageTuple);
+			ReleaseSysCache(plhandlerTuple);
 	}
 
 	ReleaseSysCache(procedureTuple);
-- 
2.24.1

From dcee28d76d28a396cc6e925af61690afecd9c516 Mon Sep 17 00:00:00 2001
From: soumyadeep2007 <sochakraborty@pivotal.io>
Date: Tue, 3 Mar 2020 09:25:52 -0800
Subject: [PATCH v1 1/1] jit: Eliminate const pointer to fmgrinfo

---
 src/backend/executor/execExpr.c     | 96 ++++++++++++++++++++++-------
 src/backend/jit/llvm/llvmjit_expr.c | 84 +++++++++++++++++++++----
 src/include/executor/execExpr.h     |  7 +++
 src/include/jit/llvmjit.h           |  6 +-
 4 files changed, 156 insertions(+), 37 deletions(-)

diff --git a/src/backend/executor/execExpr.c b/src/backend/executor/execExpr.c
index 4e10f9aea8..a1ac44133c 100644
--- a/src/backend/executor/execExpr.c
+++ b/src/backend/executor/execExpr.c
@@ -149,8 +149,23 @@ ExprBuilderAllocNullableDatumArrayInit(ExprStateBuilder *esb, int nelems, Nullab
 	return (RelNullableDatumArray){alloc->ptr};
 }
 
+static RelFunctionMgrInfo
+ExprBuilderAllocFunctionMgrInfo(ExprStateBuilder *esb, FmgrInfo **ptr)
+{
+	Size sz = sizeof(FmgrInfo);
+	ExprStateAllocation *alloc;
+
+	alloc = ExprBuilderAllocInternal(esb, ERP_FUNCTIONMGRINFO, sz);
+
+	alloc->zeroed = true;
+	alloc->initial_content = palloc0(sz);
+	*ptr = alloc->initial_content;
+
+	return (RelFunctionMgrInfo){alloc->ptr};
+}
+
 static RelFunctionCallInfo
-ExprBuilderAllocFunctionCallInfo(ExprStateBuilder *esb, int nargs, FunctionCallInfo *ptr)
+ExprBuilderAllocFunctionCallInfo(ExprStateBuilder *esb, int nargs, RelFunctionMgrInfo finfoRel, FunctionCallInfo *ptr)
 {
 	ExprStateAllocation *alloc;
 	Size sz = SizeForFunctionCallInfo(nargs);
@@ -161,7 +176,7 @@ ExprBuilderAllocFunctionCallInfo(ExprStateBuilder *esb, int nargs, FunctionCallI
 	alloc->initial_content = palloc0(sz);
 	*ptr = alloc->initial_content;
 
-	return (RelFunctionCallInfo){alloc->ptr};
+	return (RelFunctionCallInfo){alloc->ptr, finfoRel.ptr};
 }
 
 static RelNullableDatum
@@ -1148,6 +1163,7 @@ ExecInitExprRec(ExprStateBuilder *esb, Expr *node, RelNullableDatum result)
 				ScalarArrayOpExpr *opexpr = (ScalarArrayOpExpr *) node;
 				Expr	   *scalararg;
 				Expr	   *arrayarg;
+				RelFunctionMgrInfo finfo_rel;
 				FmgrInfo   *finfo;
 				RelFunctionCallInfo fcinfo_rel;
 				FunctionCallInfo fcinfo;
@@ -1167,8 +1183,11 @@ ExecInitExprRec(ExprStateBuilder *esb, Expr *node, RelNullableDatum result)
 				InvokeFunctionExecuteHook(opexpr->opfuncid);
 
 				/* Set up the primary fmgr lookup information */
-				finfo = palloc0(sizeof(FmgrInfo));
-				fcinfo_rel = ExprBuilderAllocFunctionCallInfo(esb, 2, &fcinfo);
+				finfo_rel = ExprBuilderAllocFunctionMgrInfo(esb, &finfo);
+				fcinfo_rel = ExprBuilderAllocFunctionCallInfo(esb,
+															  2,
+															  finfo_rel,
+															  &fcinfo);
 
 				fmgr_info(opexpr->opfuncid, finfo);
 				fmgr_info_set_expr((Node *) node, finfo);
@@ -1441,8 +1460,10 @@ ExecInitExprRec(ExprStateBuilder *esb, Expr *node, RelNullableDatum result)
 				Oid			typioparam;
 				FunctionCallInfo fcinfo_in;
 				FunctionCallInfo fcinfo_out;
-				FmgrInfo   *finfo_in = palloc0(sizeof(FmgrInfo));
-				FmgrInfo   *finfo_out = palloc0(sizeof(FmgrInfo));
+				RelFunctionMgrInfo finfo_in_rel;
+				FmgrInfo   *finfo_in;
+				RelFunctionMgrInfo finfo_out_rel;
+				FmgrInfo   *finfo_out;
 
 				/* evaluate argument into step's result area */
 				ExecInitExprRec(esb, iocoerce->arg, result);
@@ -1456,10 +1477,13 @@ ExecInitExprRec(ExprStateBuilder *esb, Expr *node, RelNullableDatum result)
 				 * function are assumed to be executable by everyone.
 				 */
 				scratch.opcode = EEOP_IOCOERCE;
-
 				/* lookup the source type's output function */
+				finfo_out_rel = ExprBuilderAllocFunctionMgrInfo(esb, &finfo_out);
 				scratch.d.iocoerce.fcinfo_data_out =
-					ExprBuilderAllocFunctionCallInfo(esb, 1, &fcinfo_out);
+					ExprBuilderAllocFunctionCallInfo(esb,
+													 1,
+													 finfo_out_rel,
+													 &fcinfo_out);
 
 				getTypeOutputInfo(exprType((Node *) iocoerce->arg),
 								  &iofunc, &typisvarlena);
@@ -1470,8 +1494,12 @@ ExecInitExprRec(ExprStateBuilder *esb, Expr *node, RelNullableDatum result)
 				scratch.d.iocoerce.fn_addr_out = finfo_out->fn_addr;
 
 				/* lookup the result type's input function */
+				finfo_in_rel = ExprBuilderAllocFunctionMgrInfo(esb, &finfo_in);
 				scratch.d.iocoerce.fcinfo_data_in =
-					ExprBuilderAllocFunctionCallInfo(esb, 3, &fcinfo_in);
+					ExprBuilderAllocFunctionCallInfo(esb,
+													 3,
+													 finfo_in_rel,
+													 &fcinfo_in);
 
 				getTypeInputInfo(iocoerce->resulttype,
 								 &iofunc, &typioparam);
@@ -1888,6 +1916,7 @@ ExecInitExprRec(ExprStateBuilder *esb, Expr *node, RelNullableDatum result)
 					Oid			lefttype;
 					Oid			righttype;
 					Oid			proc;
+					RelFunctionMgrInfo finfo_rel;
 					FmgrInfo   *finfo;
 					RelFunctionCallInfo fcinfo_rel;
 					FunctionCallInfo fcinfo;
@@ -1905,9 +1934,12 @@ ExecInitExprRec(ExprStateBuilder *esb, Expr *node, RelNullableDatum result)
 							 BTORDER_PROC, lefttype, righttype, opfamily);
 
 					/* Set up the primary fmgr lookup information */
-					finfo = palloc0(sizeof(FmgrInfo));
+					finfo_rel = ExprBuilderAllocFunctionMgrInfo(esb, &finfo);
 					fcinfo_rel =
-						ExprBuilderAllocFunctionCallInfo(esb, 3, &fcinfo);
+						ExprBuilderAllocFunctionCallInfo(esb,
+														 3,
+														 finfo_rel,
+														 &fcinfo);
 
 					fmgr_info(proc, finfo);
 					fmgr_info_set_expr((Node *) node, finfo);
@@ -2026,6 +2058,7 @@ ExecInitExprRec(ExprStateBuilder *esb, Expr *node, RelNullableDatum result)
 				MinMaxExpr *minmaxexpr = (MinMaxExpr *) node;
 				int			nelems = list_length(minmaxexpr->args);
 				TypeCacheEntry *typentry;
+				RelFunctionMgrInfo finfo_rel;
 				FmgrInfo   *finfo;
 				RelFunctionCallInfo fcinfo_rel;
 				FunctionCallInfo fcinfo;
@@ -2049,9 +2082,12 @@ ExecInitExprRec(ExprStateBuilder *esb, Expr *node, RelNullableDatum result)
 				 */
 
 				/* Perform function lookup */
-				finfo = palloc0(sizeof(FmgrInfo));
+				finfo_rel = ExprBuilderAllocFunctionMgrInfo(esb, &finfo);
 				fcinfo_rel =
-					ExprBuilderAllocFunctionCallInfo(esb, 2, &fcinfo);
+					ExprBuilderAllocFunctionCallInfo(esb,
+													 2,
+													 finfo_rel,
+													 &fcinfo);
 				fmgr_info(typentry->cmp_proc, finfo);
 				fmgr_info_set_expr((Node *) node, finfo);
 				InitFunctionCallInfoData(*fcinfo, finfo, 2,
@@ -2327,6 +2363,7 @@ ExecInitFunc(ExprEvalStep *scratch, Expr *node, List *args, Oid funcid,
 {
 	int			nargs = list_length(args);
 	AclResult	aclresult;
+	RelFunctionMgrInfo flinfo_rel;
 	FmgrInfo   *flinfo;
 	RelFunctionCallInfo fcinfo_rel;
 	FunctionCallInfo fcinfo;
@@ -2354,8 +2391,11 @@ ExecInitFunc(ExprEvalStep *scratch, Expr *node, List *args, Oid funcid,
 							   FUNC_MAX_ARGS)));
 
 	/* Allocate function lookup data and parameter workspace for this call */
-	flinfo = palloc0(sizeof(FmgrInfo));
-	fcinfo_rel = ExprBuilderAllocFunctionCallInfo(esb, nargs, &fcinfo);
+	flinfo_rel = ExprBuilderAllocFunctionMgrInfo(esb, &flinfo);
+	fcinfo_rel = ExprBuilderAllocFunctionCallInfo(esb,
+												  nargs,
+												  flinfo_rel,
+												  &fcinfo);
 	scratch->d.func.fcinfo_data = fcinfo_rel;
 
 	/* Set up the primary fmgr lookup information */
@@ -3145,6 +3185,8 @@ ExecBuildAggTrans(AggState *aggstate, AggStatePerPhase phase,
 	for (int transno = 0; transno < aggstate->numtrans; transno++)
 	{
 		AggStatePerTrans pertrans = &aggstate->pertrans[transno];
+		RelFunctionMgrInfo trans_finfo_rel;
+		FmgrInfo *trans_finfo;
 		RelFunctionCallInfo trans_fcinfo_rel;
 		FunctionCallInfo trans_fcinfo;
 		List	   *adjust_bailout = NIL;
@@ -3154,13 +3196,17 @@ ExecBuildAggTrans(AggState *aggstate, AggStatePerPhase phase,
 		ListCell   *bail;
 		size_t		numTransArgs;
 
+		trans_finfo_rel = ExprBuilderAllocFunctionMgrInfo(&esb, &trans_finfo);
+		*trans_finfo = pertrans->transfn;
 		/* account for the current transition state */
 		numTransArgs = pertrans->numTransInputs + 1;
 		trans_fcinfo_rel =
-			ExprBuilderAllocFunctionCallInfo(&esb, numTransArgs,
+			ExprBuilderAllocFunctionCallInfo(&esb,
+											 numTransArgs,
+											 trans_finfo_rel,
 											 &trans_fcinfo);
 		InitFunctionCallInfoData(*trans_fcinfo,
-								 &pertrans->transfn,
+								 trans_finfo,
 								 numTransArgs,
 								 pertrans->aggCollation,
 								 NULL, /* will get set when calling */
@@ -3218,6 +3264,8 @@ ExecBuildAggTrans(AggState *aggstate, AggStatePerPhase phase,
 			}
 			else
 			{
+				RelFunctionMgrInfo ds_finfo_rel;
+				FmgrInfo *ds_finfo;
 				FunctionCallInfo ds_fcinfo;
 				RelFunctionCallInfo ds_fcinfo_rel;
 				AggStatePerCallContext *percall;
@@ -3226,12 +3274,17 @@ ExecBuildAggTrans(AggState *aggstate, AggStatePerPhase phase,
 				percall->aggstate = aggstate;
 				percall->pertrans = pertrans;
 
+				ds_finfo_rel = ExprBuilderAllocFunctionMgrInfo(&esb, &ds_finfo);
+				*ds_finfo = pertrans->deserialfn;
+
 				ds_fcinfo_rel =
-					ExprBuilderAllocFunctionCallInfo(&esb, numTransArgs,
+					ExprBuilderAllocFunctionCallInfo(&esb,
+													 numTransArgs,
+													 ds_finfo_rel,
 													 &ds_fcinfo);
 
 				InitFunctionCallInfoData(*ds_fcinfo,
-										 &pertrans->deserialfn,
+										 ds_finfo,
 										 2,
 										 InvalidOid,
 										 (void *) percall, NULL);
@@ -3603,6 +3656,7 @@ ExecBuildGroupingEqual(TupleDesc ldesc, TupleDesc rdesc,
 		Form_pg_attribute ratt = TupleDescAttr(rdesc, attno - 1);
 		Oid			foid = eqfunctions[natt];
 		Oid			collid = collations[natt];
+		RelFunctionMgrInfo finfo_rel;
 		FmgrInfo   *finfo;
 		RelFunctionCallInfo fcinfo_rel;
 		FunctionCallInfo fcinfo;
@@ -3616,8 +3670,8 @@ ExecBuildGroupingEqual(TupleDesc ldesc, TupleDesc rdesc,
 		InvokeFunctionExecuteHook(foid);
 
 		/* Set up the primary fmgr lookup information */
-		finfo = palloc0(sizeof(FmgrInfo));
-		fcinfo_rel = ExprBuilderAllocFunctionCallInfo(&esb, 2, &fcinfo);
+		finfo_rel = ExprBuilderAllocFunctionMgrInfo(&esb, &finfo);
+		fcinfo_rel = ExprBuilderAllocFunctionCallInfo(&esb,2, finfo_rel, &fcinfo);
 		fmgr_info(foid, finfo);
 		fmgr_info_set_expr(NULL, finfo);
 		InitFunctionCallInfoData(*fcinfo, finfo, 2,
diff --git a/src/backend/jit/llvm/llvmjit_expr.c b/src/backend/jit/llvm/llvmjit_expr.c
index 43501a5bb6..f9af5482f8 100644
--- a/src/backend/jit/llvm/llvmjit_expr.c
+++ b/src/backend/jit/llvm/llvmjit_expr.c
@@ -110,6 +110,7 @@ typedef struct ExprCompileState
 static Datum ExecRunCompiledExpr(ExprState *state, ExprContext *econtext, bool *isNull);
 
 static void expr_emit_allocations(ExprCompileState *ecs);
+static void expr_init_fmgri(ExprCompileState *ecs, FmgrInfo *fmgrinfo, LLVMValueRef v_fmgrinfo);
 static void expr_init_fci(ExprCompileState *ecs, FunctionCallInfo fcinfo, LLVMValueRef v_fcinfo);
 static void expr_init_nullable_datums(ExprCompileState *ecs, int nelems, NullableDatum *datums, LLVMValueRef v_datums);
 
@@ -2672,6 +2673,13 @@ expr_emit_allocations(ExprCompileState *ecs)
 											  v_allocation);
 				break;
 
+			case ERP_FUNCTIONMGRINFO:
+				Assert(allocation->initial_content != NULL);
+				allocname = psprintf("alloc.%u.fmgr_info", i + 1);
+				v_allocation = LLVMBuildAlloca(ecs->b, StructFmgrInfo, allocname);
+				expr_init_fmgri(ecs, (FmgrInfo *) allocation->initial_content, v_allocation);
+				break;
+
 			case ERP_FUNCTIONCALLINFO:
 				Assert(allocation->initial_content != NULL);
 
@@ -2704,22 +2712,49 @@ expr_emit_allocations(ExprCompileState *ecs)
 	}
 }
 
+static void
+expr_init_fmgri(ExprCompileState *ecs, FmgrInfo *fmgrinfo, LLVMValueRef v_fmgrinfo)
+{
+	/*
+	 * There is no need to set fn_addr as the function will be resolved via
+	 * llvm_function_reference() followed by llvm_resolve_symbl().
+	 */
+
+	LLVMBuildStore(ecs->b,
+				   l_int32_const(fmgrinfo->fn_oid),
+				   LLVMBuildStructGEP(ecs->b, v_fmgrinfo, 1, ""));
+	LLVMBuildStore(ecs->b,
+				   l_int16_const(fmgrinfo->fn_nargs),
+				   LLVMBuildStructGEP(ecs->b, v_fmgrinfo, 2, ""));
+	LLVMBuildStore(ecs->b,
+				   l_sbool_const(fmgrinfo->fn_strict),
+				   LLVMBuildStructGEP(ecs->b, v_fmgrinfo, 3, ""));
+	LLVMBuildStore(ecs->b,
+				   l_sbool_const(fmgrinfo->fn_retset),
+				   LLVMBuildStructGEP(ecs->b, v_fmgrinfo, 4, ""));
+	LLVMBuildStore(ecs->b,
+				   l_int8_const(fmgrinfo->fn_stats),
+				   LLVMBuildStructGEP(ecs->b, v_fmgrinfo, 5, ""));
+	LLVMBuildStore(ecs->b,
+				   l_ptr_const(fmgrinfo->fn_extra, LLVMStructGetTypeAtIndex(StructFmgrInfo, 6)),
+				   LLVMBuildStructGEP(ecs->b, v_fmgrinfo, 6, "")); /* TODO */
+	LLVMBuildStore(ecs->b,
+				   l_ptr_const(fmgrinfo->fn_mcxt, l_ptr(StructMemoryContextData)),
+				   LLVMBuildStructGEP(ecs->b, v_fmgrinfo, 7, ""));
+	LLVMBuildStore(ecs->b,
+				   l_ptr_const(fmgrinfo->fn_expr, l_ptr(StructNode)),
+				   LLVMBuildStructGEP(ecs->b, v_fmgrinfo, 8, "")); /* TODO */
+}
+
 static void
 expr_init_fci(ExprCompileState *ecs, FunctionCallInfo fcinfo, LLVMValueRef v_fcinfo)
 {
 	LLVMValueRef v_args;
 
 	/*
-	 * FIXME: should be allocated as part of the ExprState, allowing this to
-	 * be referenced efficiently / without pointer constants.
+	 * We can't set fcinfo->flinfo here. It will be set inside expr_fcinfo_ref()
+	 * where we have access to the flinfo relptr.
 	 */
-	if (fcinfo->flinfo)
-		LLVMBuildStore(ecs->b,
-					   l_ptr_const(fcinfo->flinfo, l_ptr(StructFmgrInfo)),
-					   LLVMBuildStructGEP(ecs->b,
-										  v_fcinfo,
-										  FIELDNO_FUNCTIONCALLINFODATA_FLINFO,
-										  ""));
 
 	/*
 	 * FIXME: should be allocated as part of the ExprState, allowing this to
@@ -2910,13 +2945,36 @@ expr_allocation_ref(ExprCompileState *ecs, ExprRelPtr rel)
 static LLVMValueRef
 expr_fcinfo_ref(ExprCompileState *ecs, RelFunctionCallInfo relfc, FunctionCallInfo *fcinfo)
 {
-	ExprStateAllocation *alloc = list_nth(ecs->esb->allocations, relfc.ptr.allocno - 1);
+	FmgrInfo            *fmgrInfo;
+	LLVMValueRef        v_fmgrInfo;
+	LLVMValueRef        v_fcinfo;
+	ExprStateAllocation *fcinfo_alloc;
+	ExprStateAllocation *fmgr_alloc;
+
+	fcinfo_alloc = list_nth(ecs->esb->allocations, relfc.ptr.allocno - 1);
+	Assert(fcinfo_alloc->initial_content != NULL);
+
+	fmgr_alloc = list_nth(ecs->esb->allocations, relfc.fmgrInfoPtr.allocno - 1);
+	Assert(fmgr_alloc->initial_content != NULL);
 
-	Assert(alloc->initial_content != NULL);
 	if (fcinfo)
-		*fcinfo = (FunctionCallInfo) alloc->initial_content;
+	{
+		*fcinfo = (FunctionCallInfo) fcinfo_alloc->initial_content;
+		fmgrInfo = (FmgrInfo *) fmgr_alloc->initial_content;
+		(*fcinfo)->flinfo = fmgrInfo;
+	}
+	v_fmgrInfo = expr_allocation_ref(ecs, relfc.fmgrInfoPtr);
+
+	v_fcinfo = expr_allocation_ref(ecs, relfc.ptr);
+
+	LLVMBuildStore(ecs->b,
+				   v_fmgrInfo,
+				   LLVMBuildStructGEP(ecs->b,
+										  v_fcinfo,
+										  FIELDNO_FUNCTIONCALLINFODATA_FLINFO,
+										  ""));
 
-   return expr_allocation_ref(ecs, relfc.ptr);
+	return v_fcinfo;
 }
 
 static LLVMValueRef
diff --git a/src/include/executor/execExpr.h b/src/include/executor/execExpr.h
index b523e839bb..a3f9e8676f 100644
--- a/src/include/executor/execExpr.h
+++ b/src/include/executor/execExpr.h
@@ -265,9 +265,15 @@ typedef struct RelNullableDatumArray
 	ExprRelPtr ptr;
 } RelNullableDatumArray;
 
+typedef struct RelFunctionMgrInfo
+{
+	ExprRelPtr ptr;
+} RelFunctionMgrInfo;
+
 typedef struct RelFunctionCallInfo
 {
 	ExprRelPtr ptr;
+	ExprRelPtr fmgrInfoPtr;
 } RelFunctionCallInfo;
 
 typedef struct ExprEvalStep
@@ -682,6 +688,7 @@ typedef enum ExprRelPtrKind
 	ERP_BOOL,
 	ERP_NULLABLE_DATUM,
 	ERP_NULLABLE_DATUM_ARRAY,
+	ERP_FUNCTIONMGRINFO,
 	ERP_FUNCTIONCALLINFO
 } ExprRelPtrKind;
 
diff --git a/src/include/jit/llvmjit.h b/src/include/jit/llvmjit.h
index 6250148159..ae874fca03 100644
--- a/src/include/jit/llvmjit.h
+++ b/src/include/jit/llvmjit.h
@@ -112,9 +112,9 @@ extern void llvm_split_symbol_name(const char *name, char **modname, char **func
 extern LLVMValueRef llvm_get_decl(LLVMModuleRef mod, LLVMValueRef f);
 extern void llvm_copy_attributes(LLVMValueRef from, LLVMValueRef to);
 extern LLVMValueRef llvm_function_reference(LLVMJitContext *context,
-						LLVMBuilderRef builder,
-						LLVMModuleRef mod,
-						FunctionCallInfo fcinfo);
+											LLVMBuilderRef builder,
+											LLVMModuleRef mod,
+											FunctionCallInfo fcinfo);
 
 extern void llvm_inline(LLVMModuleRef mod);
 
-- 
2.24.1