1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
/*-------------------------------------------------------------------------
*
* llvmjit_types.c
* List of types needed by JIT emitting code.
*
* JIT emitting code often needs to access struct elements, create functions
* with the correct signature etc. To allow synchronizing these types with a
* low chance of definitions getting out of sync, this file lists types and
* functions that directly need to be accessed from LLVM.
*
* When LLVM is first used in a backend, a bitcode version of this file will
* be loaded. The needed types and signatures will be stored into Struct*,
* Type*, Func* variables.
*
* NB: This file will not be linked into the server, it's just converted to
* bitcode.
*
*
* Copyright (c) 2016-2025, PostgreSQL Global Development Group
*
* IDENTIFICATION
* src/backend/jit/llvm/llvmjit_types.c
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/htup.h"
#include "access/htup_details.h"
#include "access/tupdesc.h"
#include "catalog/pg_attribute.h"
#include "executor/execExpr.h"
#include "executor/nodeAgg.h"
#include "executor/tuptable.h"
#include "fmgr.h"
#include "nodes/execnodes.h"
#include "nodes/memnodes.h"
#include "utils/expandeddatum.h"
#include "utils/palloc.h"
/*
* List of types needed for JITing. These have to be non-static, otherwise
* clang/LLVM will omit them. As this file will never be linked into
* anything, that's harmless.
*/
PGFunction TypePGFunction;
size_t TypeSizeT;
bool TypeStorageBool;
ExecEvalSubroutine TypeExecEvalSubroutine;
ExecEvalBoolSubroutine TypeExecEvalBoolSubroutine;
NullableDatum StructNullableDatum;
AggState StructAggState;
AggStatePerGroupData StructAggStatePerGroupData;
AggStatePerTransData StructAggStatePerTransData;
ExprContext StructExprContext;
ExprEvalStep StructExprEvalStep;
ExprState StructExprState;
FunctionCallInfoBaseData StructFunctionCallInfoData;
HeapTupleData StructHeapTupleData;
HeapTupleHeaderData StructHeapTupleHeaderData;
MemoryContextData StructMemoryContextData;
TupleTableSlot StructTupleTableSlot;
HeapTupleTableSlot StructHeapTupleTableSlot;
MinimalTupleTableSlot StructMinimalTupleTableSlot;
TupleDescData StructTupleDescData;
PlanState StructPlanState;
MinimalTupleData StructMinimalTupleData;
/*
* To determine which attributes functions need to have (depends e.g. on
* compiler version and settings) to be compatible for inlining, we simply
* copy the attributes of this function.
*/
extern Datum AttributeTemplate(PG_FUNCTION_ARGS);
Datum
AttributeTemplate(PG_FUNCTION_ARGS)
{
AssertVariableIsOfType(&AttributeTemplate, PGFunction);
PG_RETURN_NULL();
}
/*
* And some more "templates" to give us examples of function types
* corresponding to function pointer types.
*/
extern void ExecEvalSubroutineTemplate(ExprState *state,
struct ExprEvalStep *op,
ExprContext *econtext);
void
ExecEvalSubroutineTemplate(ExprState *state,
struct ExprEvalStep *op,
ExprContext *econtext)
{
AssertVariableIsOfType(&ExecEvalSubroutineTemplate,
ExecEvalSubroutine);
}
extern bool ExecEvalBoolSubroutineTemplate(ExprState *state,
struct ExprEvalStep *op,
ExprContext *econtext);
bool
ExecEvalBoolSubroutineTemplate(ExprState *state,
struct ExprEvalStep *op,
ExprContext *econtext)
{
AssertVariableIsOfType(&ExecEvalBoolSubroutineTemplate,
ExecEvalBoolSubroutine);
return false;
}
/*
* Clang represents bool returned by functions differently (as i1) than stored
* ones (as i8). Therefore we do not just need TypeStorageBool (above), but
* also a way to determine the width of a returned integer.
*/
extern bool FunctionReturningBool(void);
bool
FunctionReturningBool(void)
{
return false;
}
/*
* To force signatures of functions used during JITing to be present,
* reference the functions required. This again has to be non-static, to avoid
* being removed as unnecessary.
*/
void *referenced_functions[] =
{
ExecAggInitGroup,
ExecAggCopyTransValue,
ExecEvalPreOrderedDistinctSingle,
ExecEvalPreOrderedDistinctMulti,
ExecEvalAggOrderedTransDatum,
ExecEvalAggOrderedTransTuple,
ExecEvalArrayCoerce,
ExecEvalArrayExpr,
ExecEvalConstraintCheck,
ExecEvalConstraintNotNull,
ExecEvalConvertRowtype,
ExecEvalCurrentOfExpr,
ExecEvalFieldSelect,
ExecEvalFieldStoreDeForm,
ExecEvalFieldStoreForm,
ExecEvalFuncExprFusage,
ExecEvalFuncExprStrictFusage,
ExecEvalGroupingFunc,
ExecEvalMergeSupportFunc,
ExecEvalMinMax,
ExecEvalNextValueExpr,
ExecEvalParamExec,
ExecEvalParamExtern,
ExecEvalParamSet,
ExecEvalRow,
ExecEvalRowNotNull,
ExecEvalRowNull,
ExecEvalCoerceViaIOSafe,
ExecEvalSQLValueFunction,
ExecEvalScalarArrayOp,
ExecEvalHashedScalarArrayOp,
ExecEvalSubPlan,
ExecEvalSysVar,
ExecEvalWholeRowVar,
ExecEvalXmlExpr,
ExecEvalJsonConstructor,
ExecEvalJsonIsPredicate,
ExecEvalJsonCoercion,
ExecEvalJsonCoercionFinish,
ExecEvalJsonExprPath,
MakeExpandedObjectReadOnlyInternal,
slot_getmissingattrs,
slot_getsomeattrs_int,
strlen,
varsize_any,
ExecInterpExprStillValid,
};
|
