v1-0001-Rely-on-llvmjit_types-for-building-EvalFunc-calls.patch

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