Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * llvmjit_expr.c
4 : : * JIT compile expressions.
5 : : *
6 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : : * Portions Copyright (c) 1994, Regents of the University of California
8 : : *
9 : : *
10 : : * IDENTIFICATION
11 : : * src/backend/jit/llvm/llvmjit_expr.c
12 : : *
13 : : *-------------------------------------------------------------------------
14 : : */
15 : :
16 : : #include "postgres.h"
17 : :
18 : : #include <llvm-c/Core.h>
19 : : #include <llvm-c/Target.h>
20 : :
21 : : #include "access/htup_details.h"
22 : : #include "access/nbtree.h"
23 : : #include "catalog/objectaccess.h"
24 : : #include "catalog/pg_type.h"
25 : : #include "executor/execExpr.h"
26 : : #include "executor/execdebug.h"
27 : : #include "executor/nodeAgg.h"
28 : : #include "executor/nodeSubplan.h"
29 : : #include "funcapi.h"
30 : : #include "jit/llvmjit.h"
31 : : #include "jit/llvmjit_emit.h"
32 : : #include "miscadmin.h"
33 : : #include "nodes/makefuncs.h"
34 : : #include "nodes/nodeFuncs.h"
35 : : #include "parser/parse_coerce.h"
36 : : #include "parser/parsetree.h"
37 : : #include "pgstat.h"
38 : : #include "utils/acl.h"
39 : : #include "utils/builtins.h"
40 : : #include "utils/date.h"
41 : : #include "utils/fmgrtab.h"
42 : : #include "utils/lsyscache.h"
43 : : #include "utils/memutils.h"
44 : : #include "utils/timestamp.h"
45 : : #include "utils/typcache.h"
46 : : #include "utils/xml.h"
47 : :
48 : : typedef struct CompiledExprState
49 : : {
50 : : LLVMJitContext *context;
51 : : const char *funcname;
52 : : } CompiledExprState;
53 : :
54 : :
55 : : static Datum ExecRunCompiledExpr(ExprState *state, ExprContext *econtext, bool *isNull);
56 : :
57 : : static LLVMValueRef BuildV1Call(LLVMJitContext *context, LLVMBuilderRef b,
58 : : LLVMModuleRef mod, FunctionCallInfo fcinfo,
59 : : LLVMValueRef *v_fcinfo_isnull);
60 : : static LLVMValueRef build_EvalXFuncInt(LLVMBuilderRef b, LLVMModuleRef mod,
61 : : const char *funcname,
62 : : LLVMValueRef v_state,
63 : : ExprEvalStep *op,
64 : : int natts, LLVMValueRef *v_args);
65 : : #if LLVM_VERSION_MAJOR < 22
66 : : static LLVMValueRef create_LifetimeEnd(LLVMModuleRef mod);
67 : : #endif
68 : :
69 : : /* macro making it easier to call ExecEval* functions */
70 : : #define build_EvalXFunc(b, mod, funcname, v_state, op, ...) \
71 : : build_EvalXFuncInt(b, mod, funcname, v_state, op, \
72 : : lengthof(((LLVMValueRef[]){__VA_ARGS__})), \
73 : : ((LLVMValueRef[]){__VA_ARGS__}))
74 : :
75 : :
76 : : /*
77 : : * JIT compile expression.
78 : : */
79 : : bool
80 : 0 : llvm_compile_expr(ExprState *state)
81 : : {
82 : 0 : PlanState *parent = state->parent;
83 : : char *funcname;
84 : :
85 : 0 : LLVMJitContext *context = NULL;
86 : :
87 : : LLVMBuilderRef b;
88 : : LLVMModuleRef mod;
89 : : LLVMContextRef lc;
90 : : LLVMValueRef eval_fn;
91 : : LLVMBasicBlockRef entry;
92 : : LLVMBasicBlockRef *opblocks;
93 : :
94 : : /* state itself */
95 : : LLVMValueRef v_state;
96 : : LLVMValueRef v_econtext;
97 : : LLVMValueRef v_parent;
98 : :
99 : : /* returnvalue */
100 : : LLVMValueRef v_isnullp;
101 : :
102 : : /* tmp vars in state */
103 : : LLVMValueRef v_tmpvaluep;
104 : : LLVMValueRef v_tmpisnullp;
105 : :
106 : : /* slots */
107 : : LLVMValueRef v_innerslot;
108 : : LLVMValueRef v_outerslot;
109 : : LLVMValueRef v_scanslot;
110 : : LLVMValueRef v_oldslot;
111 : : LLVMValueRef v_newslot;
112 : : LLVMValueRef v_resultslot;
113 : :
114 : : /* nulls/values of slots */
115 : : LLVMValueRef v_innervalues;
116 : : LLVMValueRef v_innernulls;
117 : : LLVMValueRef v_outervalues;
118 : : LLVMValueRef v_outernulls;
119 : : LLVMValueRef v_scanvalues;
120 : : LLVMValueRef v_scannulls;
121 : : LLVMValueRef v_oldvalues;
122 : : LLVMValueRef v_oldnulls;
123 : : LLVMValueRef v_newvalues;
124 : : LLVMValueRef v_newnulls;
125 : : LLVMValueRef v_resultvalues;
126 : : LLVMValueRef v_resultnulls;
127 : :
128 : : /* stuff in econtext */
129 : : LLVMValueRef v_aggvalues;
130 : : LLVMValueRef v_aggnulls;
131 : :
132 : : instr_time starttime;
133 : : instr_time deform_starttime;
134 : : instr_time endtime;
135 : : instr_time deform_endtime;
136 : :
137 : 0 : llvm_enter_fatal_on_oom();
138 : :
139 : : /*
140 : : * Right now we don't support compiling expressions without a parent, as
141 : : * we need access to the EState.
142 : : */
143 : : Assert(parent);
144 : :
145 : : /* get or create JIT context */
146 [ # # ]: 0 : if (parent->state->es_jit)
147 : 0 : context = (LLVMJitContext *) parent->state->es_jit;
148 : : else
149 : : {
150 : 0 : context = llvm_create_context(parent->state->es_jit_flags);
151 : 0 : parent->state->es_jit = &context->base;
152 : : }
153 : :
154 : 0 : INSTR_TIME_SET_CURRENT(starttime);
155 : :
156 : 0 : mod = llvm_mutable_module(context);
157 : 0 : lc = LLVMGetModuleContext(mod);
158 : :
159 : 0 : b = LLVMCreateBuilderInContext(lc);
160 : :
161 : 0 : funcname = llvm_expand_funcname(context, "evalexpr");
162 : :
163 : : /* create function */
164 : 0 : eval_fn = LLVMAddFunction(mod, funcname,
165 : : llvm_pg_var_func_type("ExecInterpExprStillValid"));
166 : 0 : LLVMSetLinkage(eval_fn, LLVMExternalLinkage);
167 : 0 : LLVMSetVisibility(eval_fn, LLVMDefaultVisibility);
168 : 0 : llvm_copy_attributes(AttributeTemplate, eval_fn);
169 : :
170 : 0 : entry = LLVMAppendBasicBlockInContext(lc, eval_fn, "entry");
171 : :
172 : : /* build state */
173 : 0 : v_state = LLVMGetParam(eval_fn, 0);
174 : 0 : v_econtext = LLVMGetParam(eval_fn, 1);
175 : 0 : v_isnullp = LLVMGetParam(eval_fn, 2);
176 : :
177 : 0 : LLVMPositionBuilderAtEnd(b, entry);
178 : :
179 : 0 : v_tmpvaluep = l_struct_gep(b,
180 : : StructExprState,
181 : : v_state,
182 : : FIELDNO_EXPRSTATE_RESVALUE,
183 : : "v.state.resvalue");
184 : 0 : v_tmpisnullp = l_struct_gep(b,
185 : : StructExprState,
186 : : v_state,
187 : : FIELDNO_EXPRSTATE_RESNULL,
188 : : "v.state.resnull");
189 : 0 : v_parent = l_load_struct_gep(b,
190 : : StructExprState,
191 : : v_state,
192 : : FIELDNO_EXPRSTATE_PARENT,
193 : : "v.state.parent");
194 : :
195 : : /* build global slots */
196 : 0 : v_scanslot = l_load_struct_gep(b,
197 : : StructExprContext,
198 : : v_econtext,
199 : : FIELDNO_EXPRCONTEXT_SCANTUPLE,
200 : : "v_scanslot");
201 : 0 : v_innerslot = l_load_struct_gep(b,
202 : : StructExprContext,
203 : : v_econtext,
204 : : FIELDNO_EXPRCONTEXT_INNERTUPLE,
205 : : "v_innerslot");
206 : 0 : v_outerslot = l_load_struct_gep(b,
207 : : StructExprContext,
208 : : v_econtext,
209 : : FIELDNO_EXPRCONTEXT_OUTERTUPLE,
210 : : "v_outerslot");
211 : 0 : v_oldslot = l_load_struct_gep(b,
212 : : StructExprContext,
213 : : v_econtext,
214 : : FIELDNO_EXPRCONTEXT_OLDTUPLE,
215 : : "v_oldslot");
216 : 0 : v_newslot = l_load_struct_gep(b,
217 : : StructExprContext,
218 : : v_econtext,
219 : : FIELDNO_EXPRCONTEXT_NEWTUPLE,
220 : : "v_newslot");
221 : 0 : v_resultslot = l_load_struct_gep(b,
222 : : StructExprState,
223 : : v_state,
224 : : FIELDNO_EXPRSTATE_RESULTSLOT,
225 : : "v_resultslot");
226 : :
227 : : /* build global values/isnull pointers */
228 : 0 : v_scanvalues = l_load_struct_gep(b,
229 : : StructTupleTableSlot,
230 : : v_scanslot,
231 : : FIELDNO_TUPLETABLESLOT_VALUES,
232 : : "v_scanvalues");
233 : 0 : v_scannulls = l_load_struct_gep(b,
234 : : StructTupleTableSlot,
235 : : v_scanslot,
236 : : FIELDNO_TUPLETABLESLOT_ISNULL,
237 : : "v_scannulls");
238 : 0 : v_innervalues = l_load_struct_gep(b,
239 : : StructTupleTableSlot,
240 : : v_innerslot,
241 : : FIELDNO_TUPLETABLESLOT_VALUES,
242 : : "v_innervalues");
243 : 0 : v_innernulls = l_load_struct_gep(b,
244 : : StructTupleTableSlot,
245 : : v_innerslot,
246 : : FIELDNO_TUPLETABLESLOT_ISNULL,
247 : : "v_innernulls");
248 : 0 : v_outervalues = l_load_struct_gep(b,
249 : : StructTupleTableSlot,
250 : : v_outerslot,
251 : : FIELDNO_TUPLETABLESLOT_VALUES,
252 : : "v_outervalues");
253 : 0 : v_outernulls = l_load_struct_gep(b,
254 : : StructTupleTableSlot,
255 : : v_outerslot,
256 : : FIELDNO_TUPLETABLESLOT_ISNULL,
257 : : "v_outernulls");
258 : 0 : v_oldvalues = l_load_struct_gep(b,
259 : : StructTupleTableSlot,
260 : : v_oldslot,
261 : : FIELDNO_TUPLETABLESLOT_VALUES,
262 : : "v_oldvalues");
263 : 0 : v_oldnulls = l_load_struct_gep(b,
264 : : StructTupleTableSlot,
265 : : v_oldslot,
266 : : FIELDNO_TUPLETABLESLOT_ISNULL,
267 : : "v_oldnulls");
268 : 0 : v_newvalues = l_load_struct_gep(b,
269 : : StructTupleTableSlot,
270 : : v_newslot,
271 : : FIELDNO_TUPLETABLESLOT_VALUES,
272 : : "v_newvalues");
273 : 0 : v_newnulls = l_load_struct_gep(b,
274 : : StructTupleTableSlot,
275 : : v_newslot,
276 : : FIELDNO_TUPLETABLESLOT_ISNULL,
277 : : "v_newnulls");
278 : 0 : v_resultvalues = l_load_struct_gep(b,
279 : : StructTupleTableSlot,
280 : : v_resultslot,
281 : : FIELDNO_TUPLETABLESLOT_VALUES,
282 : : "v_resultvalues");
283 : 0 : v_resultnulls = l_load_struct_gep(b,
284 : : StructTupleTableSlot,
285 : : v_resultslot,
286 : : FIELDNO_TUPLETABLESLOT_ISNULL,
287 : : "v_resultnulls");
288 : :
289 : : /* aggvalues/aggnulls */
290 : 0 : v_aggvalues = l_load_struct_gep(b,
291 : : StructExprContext,
292 : : v_econtext,
293 : : FIELDNO_EXPRCONTEXT_AGGVALUES,
294 : : "v.econtext.aggvalues");
295 : 0 : v_aggnulls = l_load_struct_gep(b,
296 : : StructExprContext,
297 : : v_econtext,
298 : : FIELDNO_EXPRCONTEXT_AGGNULLS,
299 : : "v.econtext.aggnulls");
300 : :
301 : : /* allocate blocks for each op upfront, so we can do jumps easily */
302 : 0 : opblocks = palloc_array(LLVMBasicBlockRef, state->steps_len);
303 [ # # ]: 0 : for (int opno = 0; opno < state->steps_len; opno++)
304 : 0 : opblocks[opno] = l_bb_append_v(eval_fn, "b.op.%d.start", opno);
305 : :
306 : : /* jump from entry to first block */
307 : 0 : LLVMBuildBr(b, opblocks[0]);
308 : :
309 [ # # ]: 0 : for (int opno = 0; opno < state->steps_len; opno++)
310 : : {
311 : : ExprEvalStep *op;
312 : : ExprEvalOp opcode;
313 : : LLVMValueRef v_resvaluep;
314 : : LLVMValueRef v_resnullp;
315 : :
316 : 0 : LLVMPositionBuilderAtEnd(b, opblocks[opno]);
317 : :
318 : 0 : op = &state->steps[opno];
319 : 0 : opcode = ExecEvalStepOp(state, op);
320 : :
321 : 0 : v_resvaluep = l_ptr_const(op->resvalue, l_ptr(TypeDatum));
322 : 0 : v_resnullp = l_ptr_const(op->resnull, l_ptr(TypeStorageBool));
323 : :
324 [ # # # # : 0 : switch (opcode)
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
325 : : {
326 : 0 : case EEOP_DONE_RETURN:
327 : : {
328 : : LLVMValueRef v_tmpisnull;
329 : : LLVMValueRef v_tmpvalue;
330 : :
331 : 0 : v_tmpvalue = l_load(b, TypeDatum, v_tmpvaluep, "");
332 : 0 : v_tmpisnull = l_load(b, TypeStorageBool, v_tmpisnullp, "");
333 : :
334 : 0 : LLVMBuildStore(b, v_tmpisnull, v_isnullp);
335 : :
336 : 0 : LLVMBuildRet(b, v_tmpvalue);
337 : 0 : break;
338 : : }
339 : :
340 : 0 : case EEOP_DONE_NO_RETURN:
341 : 0 : LLVMBuildRet(b, l_datum_const(0));
342 : 0 : break;
343 : :
344 : 0 : case EEOP_INNER_FETCHSOME:
345 : : case EEOP_OUTER_FETCHSOME:
346 : : case EEOP_SCAN_FETCHSOME:
347 : : case EEOP_OLD_FETCHSOME:
348 : : case EEOP_NEW_FETCHSOME:
349 : : {
350 : 0 : TupleDesc desc = NULL;
351 : : LLVMValueRef v_slot;
352 : : LLVMBasicBlockRef b_fetch;
353 : : LLVMValueRef v_nvalid;
354 : 0 : LLVMValueRef l_jit_deform = NULL;
355 : 0 : const TupleTableSlotOps *tts_ops = NULL;
356 : :
357 : 0 : b_fetch = l_bb_before_v(opblocks[opno + 1],
358 : : "op.%d.fetch", opno);
359 : :
360 [ # # ]: 0 : if (op->d.fetch.known_desc)
361 : 0 : desc = op->d.fetch.known_desc;
362 : :
363 [ # # ]: 0 : if (op->d.fetch.fixed)
364 : 0 : tts_ops = op->d.fetch.kind;
365 : :
366 : : /* step should not have been generated */
367 : : Assert(tts_ops != &TTSOpsVirtual);
368 : :
369 [ # # ]: 0 : if (opcode == EEOP_INNER_FETCHSOME)
370 : 0 : v_slot = v_innerslot;
371 [ # # ]: 0 : else if (opcode == EEOP_OUTER_FETCHSOME)
372 : 0 : v_slot = v_outerslot;
373 [ # # ]: 0 : else if (opcode == EEOP_SCAN_FETCHSOME)
374 : 0 : v_slot = v_scanslot;
375 [ # # ]: 0 : else if (opcode == EEOP_OLD_FETCHSOME)
376 : 0 : v_slot = v_oldslot;
377 : : else
378 : 0 : v_slot = v_newslot;
379 : :
380 : : /*
381 : : * Check if all required attributes are available, or
382 : : * whether deforming is required.
383 : : */
384 : : v_nvalid =
385 : 0 : l_load_struct_gep(b,
386 : : StructTupleTableSlot,
387 : : v_slot,
388 : : FIELDNO_TUPLETABLESLOT_NVALID,
389 : : "");
390 : 0 : LLVMBuildCondBr(b,
391 : : LLVMBuildICmp(b, LLVMIntUGE, v_nvalid,
392 : 0 : l_int16_const(lc, op->d.fetch.last_var),
393 : : ""),
394 : 0 : opblocks[opno + 1], b_fetch);
395 : :
396 : 0 : LLVMPositionBuilderAtEnd(b, b_fetch);
397 : :
398 : : /*
399 : : * If the tupledesc of the to-be-deformed tuple is known,
400 : : * and JITing of deforming is enabled, build deform
401 : : * function specific to tupledesc and the exact number of
402 : : * to-be-extracted attributes.
403 : : */
404 [ # # # # : 0 : if (tts_ops && desc && (context->base.flags & PGJIT_DEFORM))
# # ]
405 : : {
406 : 0 : INSTR_TIME_SET_CURRENT(deform_starttime);
407 : : l_jit_deform =
408 : 0 : slot_compile_deform(context, desc,
409 : : tts_ops,
410 : : op->d.fetch.last_var);
411 : 0 : INSTR_TIME_SET_CURRENT(deform_endtime);
412 : 0 : INSTR_TIME_ACCUM_DIFF(context->base.instr.deform_counter,
413 : : deform_endtime, deform_starttime);
414 : : }
415 : :
416 [ # # ]: 0 : if (l_jit_deform)
417 : : {
418 : : LLVMValueRef params[1];
419 : :
420 : 0 : params[0] = v_slot;
421 : :
422 : 0 : l_call(b,
423 : : LLVMGetFunctionType(l_jit_deform),
424 : : l_jit_deform,
425 : : params, lengthof(params), "");
426 : : }
427 : : else
428 : : {
429 : : LLVMValueRef params[2];
430 : :
431 : 0 : params[0] = v_slot;
432 : 0 : params[1] = l_int32_const(lc, op->d.fetch.last_var);
433 : :
434 : 0 : l_call(b,
435 : : llvm_pg_var_func_type("slot_getsomeattrs_int"),
436 : : llvm_pg_func(mod, "slot_getsomeattrs_int"),
437 : : params, lengthof(params), "");
438 : : }
439 : :
440 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
441 : 0 : break;
442 : : }
443 : :
444 : 0 : case EEOP_INNER_VAR:
445 : : case EEOP_OUTER_VAR:
446 : : case EEOP_SCAN_VAR:
447 : : case EEOP_OLD_VAR:
448 : : case EEOP_NEW_VAR:
449 : : {
450 : : LLVMValueRef value,
451 : : isnull;
452 : : LLVMValueRef v_attnum;
453 : : LLVMValueRef v_values;
454 : : LLVMValueRef v_nulls;
455 : :
456 [ # # ]: 0 : if (opcode == EEOP_INNER_VAR)
457 : : {
458 : 0 : v_values = v_innervalues;
459 : 0 : v_nulls = v_innernulls;
460 : : }
461 [ # # ]: 0 : else if (opcode == EEOP_OUTER_VAR)
462 : : {
463 : 0 : v_values = v_outervalues;
464 : 0 : v_nulls = v_outernulls;
465 : : }
466 [ # # ]: 0 : else if (opcode == EEOP_SCAN_VAR)
467 : : {
468 : 0 : v_values = v_scanvalues;
469 : 0 : v_nulls = v_scannulls;
470 : : }
471 [ # # ]: 0 : else if (opcode == EEOP_OLD_VAR)
472 : : {
473 : 0 : v_values = v_oldvalues;
474 : 0 : v_nulls = v_oldnulls;
475 : : }
476 : : else
477 : : {
478 : 0 : v_values = v_newvalues;
479 : 0 : v_nulls = v_newnulls;
480 : : }
481 : :
482 : 0 : v_attnum = l_int32_const(lc, op->d.var.attnum);
483 : 0 : value = l_load_gep1(b, TypeDatum, v_values, v_attnum, "");
484 : 0 : isnull = l_load_gep1(b, TypeStorageBool, v_nulls, v_attnum, "");
485 : 0 : LLVMBuildStore(b, value, v_resvaluep);
486 : 0 : LLVMBuildStore(b, isnull, v_resnullp);
487 : :
488 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
489 : 0 : break;
490 : : }
491 : :
492 : 0 : case EEOP_INNER_SYSVAR:
493 : : case EEOP_OUTER_SYSVAR:
494 : : case EEOP_SCAN_SYSVAR:
495 : : case EEOP_OLD_SYSVAR:
496 : : case EEOP_NEW_SYSVAR:
497 : : {
498 : : LLVMValueRef v_slot;
499 : :
500 [ # # ]: 0 : if (opcode == EEOP_INNER_SYSVAR)
501 : 0 : v_slot = v_innerslot;
502 [ # # ]: 0 : else if (opcode == EEOP_OUTER_SYSVAR)
503 : 0 : v_slot = v_outerslot;
504 [ # # ]: 0 : else if (opcode == EEOP_SCAN_SYSVAR)
505 : 0 : v_slot = v_scanslot;
506 [ # # ]: 0 : else if (opcode == EEOP_OLD_SYSVAR)
507 : 0 : v_slot = v_oldslot;
508 : : else
509 : 0 : v_slot = v_newslot;
510 : :
511 : 0 : build_EvalXFunc(b, mod, "ExecEvalSysVar",
512 : : v_state, op, v_econtext, v_slot);
513 : :
514 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
515 : 0 : break;
516 : : }
517 : :
518 : 0 : case EEOP_WHOLEROW:
519 : 0 : build_EvalXFunc(b, mod, "ExecEvalWholeRowVar",
520 : : v_state, op, v_econtext);
521 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
522 : 0 : break;
523 : :
524 : 0 : case EEOP_ASSIGN_INNER_VAR:
525 : : case EEOP_ASSIGN_OUTER_VAR:
526 : : case EEOP_ASSIGN_SCAN_VAR:
527 : : case EEOP_ASSIGN_OLD_VAR:
528 : : case EEOP_ASSIGN_NEW_VAR:
529 : : {
530 : : LLVMValueRef v_value;
531 : : LLVMValueRef v_isnull;
532 : : LLVMValueRef v_rvaluep;
533 : : LLVMValueRef v_risnullp;
534 : : LLVMValueRef v_attnum;
535 : : LLVMValueRef v_resultnum;
536 : : LLVMValueRef v_values;
537 : : LLVMValueRef v_nulls;
538 : :
539 [ # # ]: 0 : if (opcode == EEOP_ASSIGN_INNER_VAR)
540 : : {
541 : 0 : v_values = v_innervalues;
542 : 0 : v_nulls = v_innernulls;
543 : : }
544 [ # # ]: 0 : else if (opcode == EEOP_ASSIGN_OUTER_VAR)
545 : : {
546 : 0 : v_values = v_outervalues;
547 : 0 : v_nulls = v_outernulls;
548 : : }
549 [ # # ]: 0 : else if (opcode == EEOP_ASSIGN_SCAN_VAR)
550 : : {
551 : 0 : v_values = v_scanvalues;
552 : 0 : v_nulls = v_scannulls;
553 : : }
554 [ # # ]: 0 : else if (opcode == EEOP_ASSIGN_OLD_VAR)
555 : : {
556 : 0 : v_values = v_oldvalues;
557 : 0 : v_nulls = v_oldnulls;
558 : : }
559 : : else
560 : : {
561 : 0 : v_values = v_newvalues;
562 : 0 : v_nulls = v_newnulls;
563 : : }
564 : :
565 : : /* load data */
566 : 0 : v_attnum = l_int32_const(lc, op->d.assign_var.attnum);
567 : 0 : v_value = l_load_gep1(b, TypeDatum, v_values, v_attnum, "");
568 : 0 : v_isnull = l_load_gep1(b, TypeStorageBool, v_nulls, v_attnum, "");
569 : :
570 : : /* compute addresses of targets */
571 : 0 : v_resultnum = l_int32_const(lc, op->d.assign_var.resultnum);
572 : 0 : v_rvaluep = l_gep(b,
573 : : TypeDatum,
574 : : v_resultvalues,
575 : : &v_resultnum, 1, "");
576 : 0 : v_risnullp = l_gep(b,
577 : : TypeStorageBool,
578 : : v_resultnulls,
579 : : &v_resultnum, 1, "");
580 : :
581 : : /* and store */
582 : 0 : LLVMBuildStore(b, v_value, v_rvaluep);
583 : 0 : LLVMBuildStore(b, v_isnull, v_risnullp);
584 : :
585 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
586 : 0 : break;
587 : : }
588 : :
589 : 0 : case EEOP_ASSIGN_TMP:
590 : : case EEOP_ASSIGN_TMP_MAKE_RO:
591 : : {
592 : : LLVMValueRef v_value,
593 : : v_isnull;
594 : : LLVMValueRef v_rvaluep,
595 : : v_risnullp;
596 : : LLVMValueRef v_resultnum;
597 : 0 : size_t resultnum = op->d.assign_tmp.resultnum;
598 : :
599 : : /* load data */
600 : 0 : v_value = l_load(b, TypeDatum, v_tmpvaluep, "");
601 : 0 : v_isnull = l_load(b, TypeStorageBool, v_tmpisnullp, "");
602 : :
603 : : /* compute addresses of targets */
604 : 0 : v_resultnum = l_int32_const(lc, resultnum);
605 : : v_rvaluep =
606 : 0 : l_gep(b, TypeDatum, v_resultvalues, &v_resultnum, 1, "");
607 : : v_risnullp =
608 : 0 : l_gep(b, TypeStorageBool, v_resultnulls, &v_resultnum, 1, "");
609 : :
610 : : /* store nullness */
611 : 0 : LLVMBuildStore(b, v_isnull, v_risnullp);
612 : :
613 : : /* make value readonly if necessary */
614 [ # # ]: 0 : if (opcode == EEOP_ASSIGN_TMP_MAKE_RO)
615 : : {
616 : : LLVMBasicBlockRef b_notnull;
617 : : LLVMValueRef v_params[1];
618 : :
619 : 0 : b_notnull = l_bb_before_v(opblocks[opno + 1],
620 : : "op.%d.assign_tmp.notnull", opno);
621 : :
622 : : /* check if value is NULL */
623 : 0 : LLVMBuildCondBr(b,
624 : : LLVMBuildICmp(b, LLVMIntEQ, v_isnull,
625 : : l_sbool_const(0), ""),
626 : 0 : b_notnull, opblocks[opno + 1]);
627 : :
628 : : /* if value is not null, convert to RO datum */
629 : 0 : LLVMPositionBuilderAtEnd(b, b_notnull);
630 : 0 : v_params[0] = v_value;
631 : : v_value =
632 : 0 : l_call(b,
633 : : llvm_pg_var_func_type("MakeExpandedObjectReadOnlyInternal"),
634 : : llvm_pg_func(mod, "MakeExpandedObjectReadOnlyInternal"),
635 : : v_params, lengthof(v_params), "");
636 : :
637 : : /*
638 : : * Falling out of the if () with builder in b_notnull,
639 : : * which is fine - the null is already stored above.
640 : : */
641 : : }
642 : :
643 : : /* and finally store result */
644 : 0 : LLVMBuildStore(b, v_value, v_rvaluep);
645 : :
646 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
647 : 0 : break;
648 : : }
649 : :
650 : 0 : case EEOP_CONST:
651 : : {
652 : : LLVMValueRef v_constvalue,
653 : : v_constnull;
654 : :
655 : 0 : v_constvalue = l_datum_const(op->d.constval.value);
656 : 0 : v_constnull = l_sbool_const(op->d.constval.isnull);
657 : :
658 : 0 : LLVMBuildStore(b, v_constvalue, v_resvaluep);
659 : 0 : LLVMBuildStore(b, v_constnull, v_resnullp);
660 : :
661 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
662 : 0 : break;
663 : : }
664 : :
665 : 0 : case EEOP_FUNCEXPR:
666 : : case EEOP_FUNCEXPR_STRICT:
667 : : case EEOP_FUNCEXPR_STRICT_1:
668 : : case EEOP_FUNCEXPR_STRICT_2:
669 : : {
670 : 0 : FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
671 : : LLVMValueRef v_fcinfo_isnull;
672 : : LLVMValueRef v_retval;
673 : :
674 [ # # # # ]: 0 : if (opcode == EEOP_FUNCEXPR_STRICT ||
675 [ # # ]: 0 : opcode == EEOP_FUNCEXPR_STRICT_1 ||
676 : : opcode == EEOP_FUNCEXPR_STRICT_2)
677 : : {
678 : : LLVMBasicBlockRef b_nonull;
679 : : LLVMBasicBlockRef *b_checkargnulls;
680 : : LLVMValueRef v_fcinfo;
681 : :
682 : : /*
683 : : * Block for the actual function call, if args are
684 : : * non-NULL.
685 : : */
686 : 0 : b_nonull = l_bb_before_v(opblocks[opno + 1],
687 : : "b.%d.no-null-args", opno);
688 : :
689 : : /* should make sure they're optimized beforehand */
690 [ # # ]: 0 : if (op->d.func.nargs == 0)
691 [ # # ]: 0 : elog(ERROR, "argumentless strict functions are pointless");
692 : :
693 : : v_fcinfo =
694 : 0 : l_ptr_const(fcinfo, l_ptr(StructFunctionCallInfoData));
695 : :
696 : : /*
697 : : * set resnull to true, if the function is actually
698 : : * called, it'll be reset
699 : : */
700 : 0 : LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
701 : :
702 : : /* create blocks for checking args, one for each */
703 : : b_checkargnulls = (LLVMBasicBlockRef *)
704 : 0 : palloc(sizeof(LLVMBasicBlockRef) * op->d.func.nargs);
705 [ # # ]: 0 : for (int argno = 0; argno < op->d.func.nargs; argno++)
706 : 0 : b_checkargnulls[argno] =
707 : 0 : l_bb_before_v(b_nonull, "b.%d.isnull.%d", opno,
708 : : argno);
709 : :
710 : : /* jump to check of first argument */
711 : 0 : LLVMBuildBr(b, b_checkargnulls[0]);
712 : :
713 : : /* check each arg for NULLness */
714 [ # # ]: 0 : for (int argno = 0; argno < op->d.func.nargs; argno++)
715 : : {
716 : : LLVMValueRef v_argisnull;
717 : : LLVMBasicBlockRef b_argnotnull;
718 : :
719 : 0 : LLVMPositionBuilderAtEnd(b, b_checkargnulls[argno]);
720 : :
721 : : /*
722 : : * Compute block to jump to if argument is not
723 : : * null.
724 : : */
725 [ # # ]: 0 : if (argno + 1 == op->d.func.nargs)
726 : 0 : b_argnotnull = b_nonull;
727 : : else
728 : 0 : b_argnotnull = b_checkargnulls[argno + 1];
729 : :
730 : : /* and finally load & check NULLness of arg */
731 : 0 : v_argisnull = l_funcnull(b, v_fcinfo, argno);
732 : 0 : LLVMBuildCondBr(b,
733 : : LLVMBuildICmp(b, LLVMIntEQ,
734 : : v_argisnull,
735 : : l_sbool_const(1),
736 : : ""),
737 : 0 : opblocks[opno + 1],
738 : : b_argnotnull);
739 : : }
740 : :
741 : 0 : LLVMPositionBuilderAtEnd(b, b_nonull);
742 : : }
743 : :
744 : 0 : v_retval = BuildV1Call(context, b, mod, fcinfo,
745 : : &v_fcinfo_isnull);
746 : 0 : LLVMBuildStore(b, v_retval, v_resvaluep);
747 : 0 : LLVMBuildStore(b, v_fcinfo_isnull, v_resnullp);
748 : :
749 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
750 : 0 : break;
751 : : }
752 : :
753 : 0 : case EEOP_FUNCEXPR_FUSAGE:
754 : 0 : build_EvalXFunc(b, mod, "ExecEvalFuncExprFusage",
755 : : v_state, op, v_econtext);
756 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
757 : 0 : break;
758 : :
759 : :
760 : 0 : case EEOP_FUNCEXPR_STRICT_FUSAGE:
761 : 0 : build_EvalXFunc(b, mod, "ExecEvalFuncExprStrictFusage",
762 : : v_state, op, v_econtext);
763 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
764 : 0 : break;
765 : :
766 : : /*
767 : : * Treat them the same for now, optimizer can remove
768 : : * redundancy. Could be worthwhile to optimize during emission
769 : : * though.
770 : : */
771 : 0 : case EEOP_BOOL_AND_STEP_FIRST:
772 : : case EEOP_BOOL_AND_STEP:
773 : : case EEOP_BOOL_AND_STEP_LAST:
774 : : {
775 : : LLVMValueRef v_boolvalue;
776 : : LLVMValueRef v_boolnull;
777 : : LLVMValueRef v_boolanynullp,
778 : : v_boolanynull;
779 : : LLVMBasicBlockRef b_boolisnull;
780 : : LLVMBasicBlockRef b_boolcheckfalse;
781 : : LLVMBasicBlockRef b_boolisfalse;
782 : : LLVMBasicBlockRef b_boolcont;
783 : : LLVMBasicBlockRef b_boolisanynull;
784 : :
785 : 0 : b_boolisnull = l_bb_before_v(opblocks[opno + 1],
786 : : "b.%d.boolisnull", opno);
787 : 0 : b_boolcheckfalse = l_bb_before_v(opblocks[opno + 1],
788 : : "b.%d.boolcheckfalse", opno);
789 : 0 : b_boolisfalse = l_bb_before_v(opblocks[opno + 1],
790 : : "b.%d.boolisfalse", opno);
791 : 0 : b_boolisanynull = l_bb_before_v(opblocks[opno + 1],
792 : : "b.%d.boolisanynull", opno);
793 : 0 : b_boolcont = l_bb_before_v(opblocks[opno + 1],
794 : : "b.%d.boolcont", opno);
795 : :
796 : 0 : v_boolanynullp = l_ptr_const(op->d.boolexpr.anynull,
797 : : l_ptr(TypeStorageBool));
798 : :
799 [ # # ]: 0 : if (opcode == EEOP_BOOL_AND_STEP_FIRST)
800 : 0 : LLVMBuildStore(b, l_sbool_const(0), v_boolanynullp);
801 : :
802 : 0 : v_boolnull = l_load(b, TypeStorageBool, v_resnullp, "");
803 : 0 : v_boolvalue = l_load(b, TypeDatum, v_resvaluep, "");
804 : :
805 : : /* check if current input is NULL */
806 : 0 : LLVMBuildCondBr(b,
807 : : LLVMBuildICmp(b, LLVMIntEQ, v_boolnull,
808 : : l_sbool_const(1), ""),
809 : : b_boolisnull,
810 : : b_boolcheckfalse);
811 : :
812 : : /* build block that sets anynull */
813 : 0 : LLVMPositionBuilderAtEnd(b, b_boolisnull);
814 : : /* set boolanynull to true */
815 : 0 : LLVMBuildStore(b, l_sbool_const(1), v_boolanynullp);
816 : : /* and jump to next block */
817 : 0 : LLVMBuildBr(b, b_boolcont);
818 : :
819 : : /* build block checking for false */
820 : 0 : LLVMPositionBuilderAtEnd(b, b_boolcheckfalse);
821 : 0 : LLVMBuildCondBr(b,
822 : : LLVMBuildICmp(b, LLVMIntEQ, v_boolvalue,
823 : : l_datum_const(0), ""),
824 : : b_boolisfalse,
825 : : b_boolcont);
826 : :
827 : : /*
828 : : * Build block handling FALSE. Value is false, so short
829 : : * circuit.
830 : : */
831 : 0 : LLVMPositionBuilderAtEnd(b, b_boolisfalse);
832 : : /* result is already set to FALSE, need not change it */
833 : : /* and jump to the end of the AND expression */
834 : 0 : LLVMBuildBr(b, opblocks[op->d.boolexpr.jumpdone]);
835 : :
836 : : /* Build block that continues if bool is TRUE. */
837 : 0 : LLVMPositionBuilderAtEnd(b, b_boolcont);
838 : :
839 : 0 : v_boolanynull = l_load(b, TypeStorageBool, v_boolanynullp, "");
840 : :
841 : : /* set value to NULL if any previous values were NULL */
842 : 0 : LLVMBuildCondBr(b,
843 : : LLVMBuildICmp(b, LLVMIntEQ, v_boolanynull,
844 : : l_sbool_const(0), ""),
845 : 0 : opblocks[opno + 1], b_boolisanynull);
846 : :
847 : 0 : LLVMPositionBuilderAtEnd(b, b_boolisanynull);
848 : : /* set resnull to true */
849 : 0 : LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
850 : : /* reset resvalue */
851 : 0 : LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
852 : :
853 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
854 : 0 : break;
855 : : }
856 : :
857 : : /*
858 : : * Treat them the same for now, optimizer can remove
859 : : * redundancy. Could be worthwhile to optimize during emission
860 : : * though.
861 : : */
862 : 0 : case EEOP_BOOL_OR_STEP_FIRST:
863 : : case EEOP_BOOL_OR_STEP:
864 : : case EEOP_BOOL_OR_STEP_LAST:
865 : : {
866 : : LLVMValueRef v_boolvalue;
867 : : LLVMValueRef v_boolnull;
868 : : LLVMValueRef v_boolanynullp,
869 : : v_boolanynull;
870 : :
871 : : LLVMBasicBlockRef b_boolisnull;
872 : : LLVMBasicBlockRef b_boolchecktrue;
873 : : LLVMBasicBlockRef b_boolistrue;
874 : : LLVMBasicBlockRef b_boolcont;
875 : : LLVMBasicBlockRef b_boolisanynull;
876 : :
877 : 0 : b_boolisnull = l_bb_before_v(opblocks[opno + 1],
878 : : "b.%d.boolisnull", opno);
879 : 0 : b_boolchecktrue = l_bb_before_v(opblocks[opno + 1],
880 : : "b.%d.boolchecktrue", opno);
881 : 0 : b_boolistrue = l_bb_before_v(opblocks[opno + 1],
882 : : "b.%d.boolistrue", opno);
883 : 0 : b_boolisanynull = l_bb_before_v(opblocks[opno + 1],
884 : : "b.%d.boolisanynull", opno);
885 : 0 : b_boolcont = l_bb_before_v(opblocks[opno + 1],
886 : : "b.%d.boolcont", opno);
887 : :
888 : 0 : v_boolanynullp = l_ptr_const(op->d.boolexpr.anynull,
889 : : l_ptr(TypeStorageBool));
890 : :
891 [ # # ]: 0 : if (opcode == EEOP_BOOL_OR_STEP_FIRST)
892 : 0 : LLVMBuildStore(b, l_sbool_const(0), v_boolanynullp);
893 : 0 : v_boolnull = l_load(b, TypeStorageBool, v_resnullp, "");
894 : 0 : v_boolvalue = l_load(b, TypeDatum, v_resvaluep, "");
895 : :
896 : 0 : LLVMBuildCondBr(b,
897 : : LLVMBuildICmp(b, LLVMIntEQ, v_boolnull,
898 : : l_sbool_const(1), ""),
899 : : b_boolisnull,
900 : : b_boolchecktrue);
901 : :
902 : : /* build block that sets anynull */
903 : 0 : LLVMPositionBuilderAtEnd(b, b_boolisnull);
904 : : /* set boolanynull to true */
905 : 0 : LLVMBuildStore(b, l_sbool_const(1), v_boolanynullp);
906 : : /* and jump to next block */
907 : 0 : LLVMBuildBr(b, b_boolcont);
908 : :
909 : : /* build block checking for true */
910 : 0 : LLVMPositionBuilderAtEnd(b, b_boolchecktrue);
911 : 0 : LLVMBuildCondBr(b,
912 : : LLVMBuildICmp(b, LLVMIntEQ, v_boolvalue,
913 : : l_datum_const(1), ""),
914 : : b_boolistrue,
915 : : b_boolcont);
916 : :
917 : : /*
918 : : * Build block handling True. Value is true, so short
919 : : * circuit.
920 : : */
921 : 0 : LLVMPositionBuilderAtEnd(b, b_boolistrue);
922 : : /* result is already set to TRUE, need not change it */
923 : : /* and jump to the end of the OR expression */
924 : 0 : LLVMBuildBr(b, opblocks[op->d.boolexpr.jumpdone]);
925 : :
926 : : /* build block that continues if bool is FALSE */
927 : 0 : LLVMPositionBuilderAtEnd(b, b_boolcont);
928 : :
929 : 0 : v_boolanynull = l_load(b, TypeStorageBool, v_boolanynullp, "");
930 : :
931 : : /* set value to NULL if any previous values were NULL */
932 : 0 : LLVMBuildCondBr(b,
933 : : LLVMBuildICmp(b, LLVMIntEQ, v_boolanynull,
934 : : l_sbool_const(0), ""),
935 : 0 : opblocks[opno + 1], b_boolisanynull);
936 : :
937 : 0 : LLVMPositionBuilderAtEnd(b, b_boolisanynull);
938 : : /* set resnull to true */
939 : 0 : LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
940 : : /* reset resvalue */
941 : 0 : LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
942 : :
943 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
944 : 0 : break;
945 : : }
946 : :
947 : 0 : case EEOP_BOOL_NOT_STEP:
948 : : {
949 : : LLVMValueRef v_boolvalue;
950 : : LLVMValueRef v_negbool;
951 : :
952 : : /* compute !boolvalue */
953 : 0 : v_boolvalue = l_load(b, TypeDatum, v_resvaluep, "");
954 : 0 : v_negbool = LLVMBuildZExt(b,
955 : : LLVMBuildICmp(b, LLVMIntEQ,
956 : : v_boolvalue,
957 : : l_datum_const(0),
958 : : ""),
959 : : TypeDatum, "");
960 : :
961 : : /*
962 : : * Store it back in resvalue. We can ignore resnull here;
963 : : * if it was true, it stays true, and the value we store
964 : : * in resvalue doesn't matter.
965 : : */
966 : 0 : LLVMBuildStore(b, v_negbool, v_resvaluep);
967 : :
968 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
969 : 0 : break;
970 : : }
971 : :
972 : 0 : case EEOP_QUAL:
973 : : {
974 : : LLVMValueRef v_resnull;
975 : : LLVMValueRef v_resvalue;
976 : : LLVMValueRef v_nullorfalse;
977 : : LLVMBasicBlockRef b_qualfail;
978 : :
979 : 0 : b_qualfail = l_bb_before_v(opblocks[opno + 1],
980 : : "op.%d.qualfail", opno);
981 : :
982 : 0 : v_resvalue = l_load(b, TypeDatum, v_resvaluep, "");
983 : 0 : v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
984 : :
985 : : v_nullorfalse =
986 : 0 : LLVMBuildOr(b,
987 : : LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
988 : : l_sbool_const(1), ""),
989 : : LLVMBuildICmp(b, LLVMIntEQ, v_resvalue,
990 : : l_datum_const(0), ""),
991 : : "");
992 : :
993 : 0 : LLVMBuildCondBr(b,
994 : : v_nullorfalse,
995 : : b_qualfail,
996 : 0 : opblocks[opno + 1]);
997 : :
998 : : /* build block handling NULL or false */
999 : 0 : LLVMPositionBuilderAtEnd(b, b_qualfail);
1000 : : /* set resnull to false */
1001 : 0 : LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
1002 : : /* set resvalue to false */
1003 : 0 : LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
1004 : : /* and jump out */
1005 : 0 : LLVMBuildBr(b, opblocks[op->d.qualexpr.jumpdone]);
1006 : 0 : break;
1007 : : }
1008 : :
1009 : 0 : case EEOP_JUMP:
1010 : : {
1011 : 0 : LLVMBuildBr(b, opblocks[op->d.jump.jumpdone]);
1012 : 0 : break;
1013 : : }
1014 : :
1015 : 0 : case EEOP_JUMP_IF_NULL:
1016 : : {
1017 : : LLVMValueRef v_resnull;
1018 : :
1019 : : /* Transfer control if current result is null */
1020 : :
1021 : 0 : v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
1022 : :
1023 : 0 : LLVMBuildCondBr(b,
1024 : : LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
1025 : : l_sbool_const(1), ""),
1026 : 0 : opblocks[op->d.jump.jumpdone],
1027 : 0 : opblocks[opno + 1]);
1028 : 0 : break;
1029 : : }
1030 : :
1031 : 0 : case EEOP_JUMP_IF_NOT_NULL:
1032 : : {
1033 : : LLVMValueRef v_resnull;
1034 : :
1035 : : /* Transfer control if current result is non-null */
1036 : :
1037 : 0 : v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
1038 : :
1039 : 0 : LLVMBuildCondBr(b,
1040 : : LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
1041 : : l_sbool_const(0), ""),
1042 : 0 : opblocks[op->d.jump.jumpdone],
1043 : 0 : opblocks[opno + 1]);
1044 : 0 : break;
1045 : : }
1046 : :
1047 : :
1048 : 0 : case EEOP_JUMP_IF_NOT_TRUE:
1049 : : {
1050 : : LLVMValueRef v_resnull;
1051 : : LLVMValueRef v_resvalue;
1052 : : LLVMValueRef v_nullorfalse;
1053 : :
1054 : : /* Transfer control if current result is null or false */
1055 : :
1056 : 0 : v_resvalue = l_load(b, TypeDatum, v_resvaluep, "");
1057 : 0 : v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
1058 : :
1059 : : v_nullorfalse =
1060 : 0 : LLVMBuildOr(b,
1061 : : LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
1062 : : l_sbool_const(1), ""),
1063 : : LLVMBuildICmp(b, LLVMIntEQ, v_resvalue,
1064 : : l_datum_const(0), ""),
1065 : : "");
1066 : :
1067 : 0 : LLVMBuildCondBr(b,
1068 : : v_nullorfalse,
1069 : 0 : opblocks[op->d.jump.jumpdone],
1070 : 0 : opblocks[opno + 1]);
1071 : 0 : break;
1072 : : }
1073 : :
1074 : 0 : case EEOP_NULLTEST_ISNULL:
1075 : : {
1076 : 0 : LLVMValueRef v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
1077 : : LLVMValueRef v_resvalue;
1078 : :
1079 : : v_resvalue =
1080 : 0 : LLVMBuildSelect(b,
1081 : : LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
1082 : : l_sbool_const(1), ""),
1083 : : l_datum_const(1),
1084 : : l_datum_const(0),
1085 : : "");
1086 : 0 : LLVMBuildStore(b, v_resvalue, v_resvaluep);
1087 : 0 : LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
1088 : :
1089 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1090 : 0 : break;
1091 : : }
1092 : :
1093 : 0 : case EEOP_NULLTEST_ISNOTNULL:
1094 : : {
1095 : 0 : LLVMValueRef v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
1096 : : LLVMValueRef v_resvalue;
1097 : :
1098 : : v_resvalue =
1099 : 0 : LLVMBuildSelect(b,
1100 : : LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
1101 : : l_sbool_const(1), ""),
1102 : : l_datum_const(0),
1103 : : l_datum_const(1),
1104 : : "");
1105 : 0 : LLVMBuildStore(b, v_resvalue, v_resvaluep);
1106 : 0 : LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
1107 : :
1108 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1109 : 0 : break;
1110 : : }
1111 : :
1112 : 0 : case EEOP_NULLTEST_ROWISNULL:
1113 : 0 : build_EvalXFunc(b, mod, "ExecEvalRowNull",
1114 : : v_state, op, v_econtext);
1115 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1116 : 0 : break;
1117 : :
1118 : 0 : case EEOP_NULLTEST_ROWISNOTNULL:
1119 : 0 : build_EvalXFunc(b, mod, "ExecEvalRowNotNull",
1120 : : v_state, op, v_econtext);
1121 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1122 : 0 : break;
1123 : :
1124 : 0 : case EEOP_BOOLTEST_IS_TRUE:
1125 : : case EEOP_BOOLTEST_IS_NOT_FALSE:
1126 : : case EEOP_BOOLTEST_IS_FALSE:
1127 : : case EEOP_BOOLTEST_IS_NOT_TRUE:
1128 : : {
1129 : : LLVMBasicBlockRef b_isnull,
1130 : : b_notnull;
1131 : 0 : LLVMValueRef v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
1132 : :
1133 : 0 : b_isnull = l_bb_before_v(opblocks[opno + 1],
1134 : : "op.%d.isnull", opno);
1135 : 0 : b_notnull = l_bb_before_v(opblocks[opno + 1],
1136 : : "op.%d.isnotnull", opno);
1137 : :
1138 : : /* check if value is NULL */
1139 : 0 : LLVMBuildCondBr(b,
1140 : : LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
1141 : : l_sbool_const(1), ""),
1142 : : b_isnull, b_notnull);
1143 : :
1144 : : /* if value is NULL, return false */
1145 : 0 : LLVMPositionBuilderAtEnd(b, b_isnull);
1146 : :
1147 : : /* result is not null */
1148 : 0 : LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
1149 : :
1150 [ # # # # ]: 0 : if (opcode == EEOP_BOOLTEST_IS_TRUE ||
1151 : : opcode == EEOP_BOOLTEST_IS_FALSE)
1152 : : {
1153 : 0 : LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
1154 : : }
1155 : : else
1156 : : {
1157 : 0 : LLVMBuildStore(b, l_datum_const(1), v_resvaluep);
1158 : : }
1159 : :
1160 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1161 : :
1162 : 0 : LLVMPositionBuilderAtEnd(b, b_notnull);
1163 : :
1164 [ # # # # ]: 0 : if (opcode == EEOP_BOOLTEST_IS_TRUE ||
1165 : : opcode == EEOP_BOOLTEST_IS_NOT_FALSE)
1166 : : {
1167 : : /*
1168 : : * if value is not null NULL, return value (already
1169 : : * set)
1170 : : */
1171 : : }
1172 : : else
1173 : : {
1174 : : LLVMValueRef v_value =
1175 : 0 : l_load(b, TypeDatum, v_resvaluep, "");
1176 : :
1177 : 0 : v_value = LLVMBuildZExt(b,
1178 : : LLVMBuildICmp(b, LLVMIntEQ,
1179 : : v_value,
1180 : : l_datum_const(0),
1181 : : ""),
1182 : : TypeDatum, "");
1183 : 0 : LLVMBuildStore(b, v_value, v_resvaluep);
1184 : : }
1185 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1186 : 0 : break;
1187 : : }
1188 : :
1189 : 0 : case EEOP_PARAM_EXEC:
1190 : 0 : build_EvalXFunc(b, mod, "ExecEvalParamExec",
1191 : : v_state, op, v_econtext);
1192 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1193 : 0 : break;
1194 : :
1195 : 0 : case EEOP_PARAM_EXTERN:
1196 : 0 : build_EvalXFunc(b, mod, "ExecEvalParamExtern",
1197 : : v_state, op, v_econtext);
1198 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1199 : 0 : break;
1200 : :
1201 : 0 : case EEOP_PARAM_CALLBACK:
1202 : : {
1203 : : LLVMValueRef v_func;
1204 : : LLVMValueRef v_params[3];
1205 : :
1206 : 0 : v_func = l_ptr_const(op->d.cparam.paramfunc,
1207 : : llvm_pg_var_type("TypeExecEvalSubroutine"));
1208 : :
1209 : 0 : v_params[0] = v_state;
1210 : 0 : v_params[1] = l_ptr_const(op, l_ptr(StructExprEvalStep));
1211 : 0 : v_params[2] = v_econtext;
1212 : 0 : l_call(b,
1213 : : LLVMGetFunctionType(ExecEvalSubroutineTemplate),
1214 : : v_func,
1215 : : v_params, lengthof(v_params), "");
1216 : :
1217 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1218 : 0 : break;
1219 : : }
1220 : :
1221 : 0 : case EEOP_PARAM_SET:
1222 : 0 : build_EvalXFunc(b, mod, "ExecEvalParamSet",
1223 : : v_state, op, v_econtext);
1224 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1225 : 0 : break;
1226 : :
1227 : 0 : case EEOP_SBSREF_SUBSCRIPTS:
1228 : : {
1229 : 0 : int jumpdone = op->d.sbsref_subscript.jumpdone;
1230 : : LLVMValueRef v_func;
1231 : : LLVMValueRef v_params[3];
1232 : : LLVMValueRef v_ret;
1233 : :
1234 : 0 : v_func = l_ptr_const(op->d.sbsref_subscript.subscriptfunc,
1235 : : llvm_pg_var_type("TypeExecEvalBoolSubroutine"));
1236 : :
1237 : 0 : v_params[0] = v_state;
1238 : 0 : v_params[1] = l_ptr_const(op, l_ptr(StructExprEvalStep));
1239 : 0 : v_params[2] = v_econtext;
1240 : 0 : v_ret = l_call(b,
1241 : : LLVMGetFunctionType(ExecEvalBoolSubroutineTemplate),
1242 : : v_func,
1243 : : v_params, lengthof(v_params), "");
1244 : 0 : v_ret = LLVMBuildZExt(b, v_ret, TypeStorageBool, "");
1245 : :
1246 : 0 : LLVMBuildCondBr(b,
1247 : : LLVMBuildICmp(b, LLVMIntEQ, v_ret,
1248 : : l_sbool_const(1), ""),
1249 : 0 : opblocks[opno + 1],
1250 : 0 : opblocks[jumpdone]);
1251 : 0 : break;
1252 : : }
1253 : :
1254 : 0 : case EEOP_SBSREF_OLD:
1255 : : case EEOP_SBSREF_ASSIGN:
1256 : : case EEOP_SBSREF_FETCH:
1257 : : {
1258 : : LLVMValueRef v_func;
1259 : : LLVMValueRef v_params[3];
1260 : :
1261 : 0 : v_func = l_ptr_const(op->d.sbsref.subscriptfunc,
1262 : : llvm_pg_var_type("TypeExecEvalSubroutine"));
1263 : :
1264 : 0 : v_params[0] = v_state;
1265 : 0 : v_params[1] = l_ptr_const(op, l_ptr(StructExprEvalStep));
1266 : 0 : v_params[2] = v_econtext;
1267 : 0 : l_call(b,
1268 : : LLVMGetFunctionType(ExecEvalSubroutineTemplate),
1269 : : v_func,
1270 : : v_params, lengthof(v_params), "");
1271 : :
1272 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1273 : 0 : break;
1274 : : }
1275 : :
1276 : 0 : case EEOP_CASE_TESTVAL:
1277 : : {
1278 : : LLVMValueRef v_casevaluep,
1279 : : v_casevalue;
1280 : : LLVMValueRef v_casenullp,
1281 : : v_casenull;
1282 : :
1283 : 0 : v_casevaluep = l_ptr_const(op->d.casetest.value,
1284 : : l_ptr(TypeDatum));
1285 : 0 : v_casenullp = l_ptr_const(op->d.casetest.isnull,
1286 : : l_ptr(TypeStorageBool));
1287 : :
1288 : 0 : v_casevalue = l_load(b, TypeDatum, v_casevaluep, "");
1289 : 0 : v_casenull = l_load(b, TypeStorageBool, v_casenullp, "");
1290 : 0 : LLVMBuildStore(b, v_casevalue, v_resvaluep);
1291 : 0 : LLVMBuildStore(b, v_casenull, v_resnullp);
1292 : :
1293 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1294 : 0 : break;
1295 : : }
1296 : :
1297 : 0 : case EEOP_CASE_TESTVAL_EXT:
1298 : : {
1299 : : LLVMValueRef v_casevalue;
1300 : : LLVMValueRef v_casenull;
1301 : :
1302 : : v_casevalue =
1303 : 0 : l_load_struct_gep(b,
1304 : : StructExprContext,
1305 : : v_econtext,
1306 : : FIELDNO_EXPRCONTEXT_CASEDATUM, "");
1307 : : v_casenull =
1308 : 0 : l_load_struct_gep(b,
1309 : : StructExprContext,
1310 : : v_econtext,
1311 : : FIELDNO_EXPRCONTEXT_CASENULL, "");
1312 : 0 : LLVMBuildStore(b, v_casevalue, v_resvaluep);
1313 : 0 : LLVMBuildStore(b, v_casenull, v_resnullp);
1314 : :
1315 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1316 : 0 : break;
1317 : : }
1318 : :
1319 : 0 : case EEOP_MAKE_READONLY:
1320 : : {
1321 : : LLVMBasicBlockRef b_notnull;
1322 : : LLVMValueRef v_params[1];
1323 : : LLVMValueRef v_ret;
1324 : : LLVMValueRef v_nullp;
1325 : : LLVMValueRef v_valuep;
1326 : : LLVMValueRef v_null;
1327 : : LLVMValueRef v_value;
1328 : :
1329 : 0 : b_notnull = l_bb_before_v(opblocks[opno + 1],
1330 : : "op.%d.readonly.notnull", opno);
1331 : :
1332 : 0 : v_nullp = l_ptr_const(op->d.make_readonly.isnull,
1333 : : l_ptr(TypeStorageBool));
1334 : :
1335 : 0 : v_null = l_load(b, TypeStorageBool, v_nullp, "");
1336 : :
1337 : : /* store null isnull value in result */
1338 : 0 : LLVMBuildStore(b, v_null, v_resnullp);
1339 : :
1340 : : /* check if value is NULL */
1341 : 0 : LLVMBuildCondBr(b,
1342 : : LLVMBuildICmp(b, LLVMIntEQ, v_null,
1343 : : l_sbool_const(1), ""),
1344 : 0 : opblocks[opno + 1], b_notnull);
1345 : :
1346 : : /* if value is not null, convert to RO datum */
1347 : 0 : LLVMPositionBuilderAtEnd(b, b_notnull);
1348 : :
1349 : 0 : v_valuep = l_ptr_const(op->d.make_readonly.value,
1350 : : l_ptr(TypeDatum));
1351 : :
1352 : 0 : v_value = l_load(b, TypeDatum, v_valuep, "");
1353 : :
1354 : 0 : v_params[0] = v_value;
1355 : : v_ret =
1356 : 0 : l_call(b,
1357 : : llvm_pg_var_func_type("MakeExpandedObjectReadOnlyInternal"),
1358 : : llvm_pg_func(mod, "MakeExpandedObjectReadOnlyInternal"),
1359 : : v_params, lengthof(v_params), "");
1360 : 0 : LLVMBuildStore(b, v_ret, v_resvaluep);
1361 : :
1362 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1363 : 0 : break;
1364 : : }
1365 : :
1366 : 0 : case EEOP_IOCOERCE:
1367 : : {
1368 : : FunctionCallInfo fcinfo_out,
1369 : : fcinfo_in;
1370 : : LLVMValueRef v_fn_out,
1371 : : v_fn_in;
1372 : : LLVMValueRef v_fcinfo_out,
1373 : : v_fcinfo_in;
1374 : : LLVMValueRef v_fcinfo_in_isnullp;
1375 : : LLVMValueRef v_retval;
1376 : : LLVMValueRef v_resvalue;
1377 : : LLVMValueRef v_resnull;
1378 : :
1379 : : LLVMValueRef v_output_skip;
1380 : : LLVMValueRef v_output;
1381 : :
1382 : : LLVMBasicBlockRef b_skipoutput;
1383 : : LLVMBasicBlockRef b_calloutput;
1384 : : LLVMBasicBlockRef b_input;
1385 : : LLVMBasicBlockRef b_inputcall;
1386 : :
1387 : 0 : fcinfo_out = op->d.iocoerce.fcinfo_data_out;
1388 : 0 : fcinfo_in = op->d.iocoerce.fcinfo_data_in;
1389 : :
1390 : 0 : b_skipoutput = l_bb_before_v(opblocks[opno + 1],
1391 : : "op.%d.skipoutputnull", opno);
1392 : 0 : b_calloutput = l_bb_before_v(opblocks[opno + 1],
1393 : : "op.%d.calloutput", opno);
1394 : 0 : b_input = l_bb_before_v(opblocks[opno + 1],
1395 : : "op.%d.input", opno);
1396 : 0 : b_inputcall = l_bb_before_v(opblocks[opno + 1],
1397 : : "op.%d.inputcall", opno);
1398 : :
1399 : 0 : v_fn_out = llvm_function_reference(context, b, mod, fcinfo_out);
1400 : 0 : v_fn_in = llvm_function_reference(context, b, mod, fcinfo_in);
1401 : 0 : v_fcinfo_out = l_ptr_const(fcinfo_out, l_ptr(StructFunctionCallInfoData));
1402 : 0 : v_fcinfo_in = l_ptr_const(fcinfo_in, l_ptr(StructFunctionCallInfoData));
1403 : :
1404 : : v_fcinfo_in_isnullp =
1405 : 0 : l_struct_gep(b,
1406 : : StructFunctionCallInfoData,
1407 : : v_fcinfo_in,
1408 : : FIELDNO_FUNCTIONCALLINFODATA_ISNULL,
1409 : : "v_fcinfo_in_isnull");
1410 : :
1411 : : /* output functions are not called on nulls */
1412 : 0 : v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
1413 : 0 : LLVMBuildCondBr(b,
1414 : : LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
1415 : : l_sbool_const(1), ""),
1416 : : b_skipoutput,
1417 : : b_calloutput);
1418 : :
1419 : 0 : LLVMPositionBuilderAtEnd(b, b_skipoutput);
1420 : 0 : v_output_skip = l_datum_const(0);
1421 : 0 : LLVMBuildBr(b, b_input);
1422 : :
1423 : 0 : LLVMPositionBuilderAtEnd(b, b_calloutput);
1424 : 0 : v_resvalue = l_load(b, TypeDatum, v_resvaluep, "");
1425 : :
1426 : : /* set arg[0] */
1427 : 0 : LLVMBuildStore(b,
1428 : : v_resvalue,
1429 : : l_funcvaluep(b, v_fcinfo_out, 0));
1430 : 0 : LLVMBuildStore(b,
1431 : : l_sbool_const(0),
1432 : : l_funcnullp(b, v_fcinfo_out, 0));
1433 : : /* and call output function (can never return NULL) */
1434 : 0 : v_output = l_call(b,
1435 : : LLVMGetFunctionType(v_fn_out),
1436 : : v_fn_out, &v_fcinfo_out,
1437 : : 1, "funccall_coerce_out");
1438 : 0 : LLVMBuildBr(b, b_input);
1439 : :
1440 : : /* build block handling input function call */
1441 : 0 : LLVMPositionBuilderAtEnd(b, b_input);
1442 : :
1443 : : /* phi between resnull and output function call branches */
1444 : : {
1445 : : LLVMValueRef incoming_values[2];
1446 : : LLVMBasicBlockRef incoming_blocks[2];
1447 : :
1448 : 0 : incoming_values[0] = v_output_skip;
1449 : 0 : incoming_blocks[0] = b_skipoutput;
1450 : :
1451 : 0 : incoming_values[1] = v_output;
1452 : 0 : incoming_blocks[1] = b_calloutput;
1453 : :
1454 : 0 : v_output = LLVMBuildPhi(b, TypeDatum, "output");
1455 : 0 : LLVMAddIncoming(v_output,
1456 : : incoming_values, incoming_blocks,
1457 : : lengthof(incoming_blocks));
1458 : : }
1459 : :
1460 : : /*
1461 : : * If input function is strict, skip if input string is
1462 : : * NULL.
1463 : : */
1464 [ # # ]: 0 : if (op->d.iocoerce.finfo_in->fn_strict)
1465 : : {
1466 : 0 : LLVMBuildCondBr(b,
1467 : : LLVMBuildICmp(b, LLVMIntEQ, v_output,
1468 : : l_datum_const(0), ""),
1469 : 0 : opblocks[opno + 1],
1470 : : b_inputcall);
1471 : : }
1472 : : else
1473 : : {
1474 : 0 : LLVMBuildBr(b, b_inputcall);
1475 : : }
1476 : :
1477 : 0 : LLVMPositionBuilderAtEnd(b, b_inputcall);
1478 : : /* set arguments */
1479 : : /* arg0: output */
1480 : 0 : LLVMBuildStore(b, v_output,
1481 : : l_funcvaluep(b, v_fcinfo_in, 0));
1482 : 0 : LLVMBuildStore(b, v_resnull,
1483 : : l_funcnullp(b, v_fcinfo_in, 0));
1484 : :
1485 : : /* arg1: ioparam: preset in execExpr.c */
1486 : : /* arg2: typmod: preset in execExpr.c */
1487 : :
1488 : : /* reset fcinfo_in->isnull */
1489 : 0 : LLVMBuildStore(b, l_sbool_const(0), v_fcinfo_in_isnullp);
1490 : : /* and call function */
1491 : 0 : v_retval = l_call(b,
1492 : : LLVMGetFunctionType(v_fn_in),
1493 : : v_fn_in, &v_fcinfo_in, 1,
1494 : : "funccall_iocoerce_in");
1495 : :
1496 : 0 : LLVMBuildStore(b, v_retval, v_resvaluep);
1497 : :
1498 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1499 : 0 : break;
1500 : : }
1501 : :
1502 : 0 : case EEOP_IOCOERCE_SAFE:
1503 : 0 : build_EvalXFunc(b, mod, "ExecEvalCoerceViaIOSafe",
1504 : : v_state, op);
1505 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1506 : 0 : break;
1507 : :
1508 : 0 : case EEOP_DISTINCT:
1509 : : case EEOP_NOT_DISTINCT:
1510 : : {
1511 : 0 : FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
1512 : :
1513 : : LLVMValueRef v_fcinfo;
1514 : : LLVMValueRef v_fcinfo_isnull;
1515 : :
1516 : : LLVMValueRef v_argnull0,
1517 : : v_argisnull0;
1518 : : LLVMValueRef v_argnull1,
1519 : : v_argisnull1;
1520 : :
1521 : : LLVMValueRef v_anyargisnull;
1522 : : LLVMValueRef v_bothargisnull;
1523 : :
1524 : : LLVMValueRef v_result;
1525 : :
1526 : : LLVMBasicBlockRef b_noargnull;
1527 : : LLVMBasicBlockRef b_checkbothargnull;
1528 : : LLVMBasicBlockRef b_bothargnull;
1529 : : LLVMBasicBlockRef b_anyargnull;
1530 : :
1531 : 0 : b_noargnull = l_bb_before_v(opblocks[opno + 1], "op.%d.noargnull", opno);
1532 : 0 : b_checkbothargnull = l_bb_before_v(opblocks[opno + 1], "op.%d.checkbothargnull", opno);
1533 : 0 : b_bothargnull = l_bb_before_v(opblocks[opno + 1], "op.%d.bothargnull", opno);
1534 : 0 : b_anyargnull = l_bb_before_v(opblocks[opno + 1], "op.%d.anyargnull", opno);
1535 : :
1536 : 0 : v_fcinfo = l_ptr_const(fcinfo, l_ptr(StructFunctionCallInfoData));
1537 : :
1538 : : /* load args[0|1].isnull for both arguments */
1539 : 0 : v_argnull0 = l_funcnull(b, v_fcinfo, 0);
1540 : 0 : v_argisnull0 = LLVMBuildICmp(b, LLVMIntEQ, v_argnull0,
1541 : : l_sbool_const(1), "");
1542 : 0 : v_argnull1 = l_funcnull(b, v_fcinfo, 1);
1543 : 0 : v_argisnull1 = LLVMBuildICmp(b, LLVMIntEQ, v_argnull1,
1544 : : l_sbool_const(1), "");
1545 : :
1546 : 0 : v_anyargisnull = LLVMBuildOr(b, v_argisnull0, v_argisnull1, "");
1547 : 0 : v_bothargisnull = LLVMBuildAnd(b, v_argisnull0, v_argisnull1, "");
1548 : :
1549 : : /*
1550 : : * Check function arguments for NULLness: If either is
1551 : : * NULL, we check if both args are NULL. Otherwise call
1552 : : * comparator.
1553 : : */
1554 : 0 : LLVMBuildCondBr(b, v_anyargisnull, b_checkbothargnull,
1555 : : b_noargnull);
1556 : :
1557 : : /*
1558 : : * build block checking if any arg is null
1559 : : */
1560 : 0 : LLVMPositionBuilderAtEnd(b, b_checkbothargnull);
1561 : 0 : LLVMBuildCondBr(b, v_bothargisnull, b_bothargnull,
1562 : : b_anyargnull);
1563 : :
1564 : :
1565 : : /* Both NULL? Then is not distinct... */
1566 : 0 : LLVMPositionBuilderAtEnd(b, b_bothargnull);
1567 : 0 : LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
1568 [ # # ]: 0 : if (opcode == EEOP_NOT_DISTINCT)
1569 : 0 : LLVMBuildStore(b, l_datum_const(1), v_resvaluep);
1570 : : else
1571 : 0 : LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
1572 : :
1573 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1574 : :
1575 : : /* Only one is NULL? Then is distinct... */
1576 : 0 : LLVMPositionBuilderAtEnd(b, b_anyargnull);
1577 : 0 : LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
1578 [ # # ]: 0 : if (opcode == EEOP_NOT_DISTINCT)
1579 : 0 : LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
1580 : : else
1581 : 0 : LLVMBuildStore(b, l_datum_const(1), v_resvaluep);
1582 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1583 : :
1584 : : /* neither argument is null: compare */
1585 : 0 : LLVMPositionBuilderAtEnd(b, b_noargnull);
1586 : :
1587 : 0 : v_result = BuildV1Call(context, b, mod, fcinfo,
1588 : : &v_fcinfo_isnull);
1589 : :
1590 [ # # ]: 0 : if (opcode == EEOP_DISTINCT)
1591 : : {
1592 : : /* Must invert result of "=" */
1593 : : v_result =
1594 : 0 : LLVMBuildZExt(b,
1595 : : LLVMBuildICmp(b, LLVMIntEQ,
1596 : : v_result,
1597 : : l_datum_const(0), ""),
1598 : : TypeDatum, "");
1599 : : }
1600 : :
1601 : 0 : LLVMBuildStore(b, v_fcinfo_isnull, v_resnullp);
1602 : 0 : LLVMBuildStore(b, v_result, v_resvaluep);
1603 : :
1604 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1605 : 0 : break;
1606 : : }
1607 : :
1608 : 0 : case EEOP_NULLIF:
1609 : : {
1610 : 0 : FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
1611 : :
1612 : : LLVMValueRef v_fcinfo;
1613 : : LLVMValueRef v_fcinfo_isnull;
1614 : : LLVMValueRef v_argnull0;
1615 : : LLVMValueRef v_argnull1;
1616 : : LLVMValueRef v_anyargisnull;
1617 : : LLVMValueRef v_arg0;
1618 : : LLVMBasicBlockRef b_hasnull;
1619 : : LLVMBasicBlockRef b_nonull;
1620 : : LLVMBasicBlockRef b_argsequal;
1621 : : LLVMValueRef v_retval;
1622 : : LLVMValueRef v_argsequal;
1623 : :
1624 : 0 : b_hasnull = l_bb_before_v(opblocks[opno + 1],
1625 : : "b.%d.null-args", opno);
1626 : 0 : b_nonull = l_bb_before_v(opblocks[opno + 1],
1627 : : "b.%d.no-null-args", opno);
1628 : 0 : b_argsequal = l_bb_before_v(opblocks[opno + 1],
1629 : : "b.%d.argsequal", opno);
1630 : :
1631 : 0 : v_fcinfo = l_ptr_const(fcinfo, l_ptr(StructFunctionCallInfoData));
1632 : :
1633 : : /* save original arg[0] */
1634 : 0 : v_arg0 = l_funcvalue(b, v_fcinfo, 0);
1635 : :
1636 : : /* if either argument is NULL they can't be equal */
1637 : 0 : v_argnull0 = l_funcnull(b, v_fcinfo, 0);
1638 : 0 : v_argnull1 = l_funcnull(b, v_fcinfo, 1);
1639 : :
1640 : : v_anyargisnull =
1641 : 0 : LLVMBuildOr(b,
1642 : : LLVMBuildICmp(b, LLVMIntEQ, v_argnull0,
1643 : : l_sbool_const(1), ""),
1644 : : LLVMBuildICmp(b, LLVMIntEQ, v_argnull1,
1645 : : l_sbool_const(1), ""),
1646 : : "");
1647 : :
1648 : 0 : LLVMBuildCondBr(b, v_anyargisnull, b_hasnull, b_nonull);
1649 : :
1650 : : /* one (or both) of the arguments are null, return arg[0] */
1651 : 0 : LLVMPositionBuilderAtEnd(b, b_hasnull);
1652 : 0 : LLVMBuildStore(b, v_argnull0, v_resnullp);
1653 : 0 : LLVMBuildStore(b, v_arg0, v_resvaluep);
1654 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1655 : :
1656 : : /* build block to invoke function and check result */
1657 : 0 : LLVMPositionBuilderAtEnd(b, b_nonull);
1658 : :
1659 : : /*
1660 : : * If first argument is of varlena type, it might be an
1661 : : * expanded datum. We need to ensure that the value
1662 : : * passed to the comparison function is a read-only
1663 : : * pointer. However, if we end by returning the first
1664 : : * argument, that will be the original read-write pointer
1665 : : * if it was read-write.
1666 : : */
1667 [ # # ]: 0 : if (op->d.func.make_ro)
1668 : : {
1669 : : LLVMValueRef v_params[1];
1670 : : LLVMValueRef v_arg0_ro;
1671 : :
1672 : 0 : v_params[0] = v_arg0;
1673 : : v_arg0_ro =
1674 : 0 : l_call(b,
1675 : : llvm_pg_var_func_type("MakeExpandedObjectReadOnlyInternal"),
1676 : : llvm_pg_func(mod, "MakeExpandedObjectReadOnlyInternal"),
1677 : : v_params, lengthof(v_params), "");
1678 : 0 : LLVMBuildStore(b, v_arg0_ro,
1679 : : l_funcvaluep(b, v_fcinfo, 0));
1680 : : }
1681 : :
1682 : 0 : v_retval = BuildV1Call(context, b, mod, fcinfo, &v_fcinfo_isnull);
1683 : :
1684 : : /*
1685 : : * If result not null and arguments are equal return null,
1686 : : * else return arg[0] (same result as if there'd been
1687 : : * NULLs, hence reuse b_hasnull).
1688 : : */
1689 : 0 : v_argsequal = LLVMBuildAnd(b,
1690 : : LLVMBuildICmp(b, LLVMIntEQ,
1691 : : v_fcinfo_isnull,
1692 : : l_sbool_const(0),
1693 : : ""),
1694 : : LLVMBuildICmp(b, LLVMIntEQ,
1695 : : v_retval,
1696 : : l_datum_const(1),
1697 : : ""),
1698 : : "");
1699 : 0 : LLVMBuildCondBr(b, v_argsequal, b_argsequal, b_hasnull);
1700 : :
1701 : : /* build block setting result to NULL, if args are equal */
1702 : 0 : LLVMPositionBuilderAtEnd(b, b_argsequal);
1703 : 0 : LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
1704 : 0 : LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
1705 : :
1706 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1707 : 0 : break;
1708 : : }
1709 : :
1710 : 0 : case EEOP_SQLVALUEFUNCTION:
1711 : 0 : build_EvalXFunc(b, mod, "ExecEvalSQLValueFunction",
1712 : : v_state, op);
1713 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1714 : 0 : break;
1715 : :
1716 : 0 : case EEOP_CURRENTOFEXPR:
1717 : 0 : build_EvalXFunc(b, mod, "ExecEvalCurrentOfExpr",
1718 : : v_state, op);
1719 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1720 : 0 : break;
1721 : :
1722 : 0 : case EEOP_NEXTVALUEEXPR:
1723 : 0 : build_EvalXFunc(b, mod, "ExecEvalNextValueExpr",
1724 : : v_state, op);
1725 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1726 : 0 : break;
1727 : :
1728 : 0 : case EEOP_RETURNINGEXPR:
1729 : : {
1730 : : LLVMBasicBlockRef b_isnull;
1731 : : LLVMValueRef v_flagsp;
1732 : : LLVMValueRef v_flags;
1733 : : LLVMValueRef v_nullflag;
1734 : :
1735 : 0 : b_isnull = l_bb_before_v(opblocks[opno + 1],
1736 : : "op.%d.row.isnull", opno);
1737 : :
1738 : : /*
1739 : : * The next op actually evaluates the expression. If the
1740 : : * OLD/NEW row doesn't exist, skip that and return NULL.
1741 : : */
1742 : 0 : v_flagsp = l_struct_gep(b,
1743 : : StructExprState,
1744 : : v_state,
1745 : : FIELDNO_EXPRSTATE_FLAGS,
1746 : : "v.state.flags");
1747 : 0 : v_flags = l_load(b, TypeStorageBool, v_flagsp, "");
1748 : :
1749 : 0 : v_nullflag = l_int8_const(lc, op->d.returningexpr.nullflag);
1750 : :
1751 : 0 : LLVMBuildCondBr(b,
1752 : : LLVMBuildICmp(b, LLVMIntEQ,
1753 : : LLVMBuildAnd(b, v_flags,
1754 : : v_nullflag, ""),
1755 : : l_sbool_const(0), ""),
1756 : 0 : opblocks[opno + 1], b_isnull);
1757 : :
1758 : 0 : LLVMPositionBuilderAtEnd(b, b_isnull);
1759 : :
1760 : 0 : LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
1761 : 0 : LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
1762 : :
1763 : 0 : LLVMBuildBr(b, opblocks[op->d.returningexpr.jumpdone]);
1764 : 0 : break;
1765 : : }
1766 : :
1767 : 0 : case EEOP_ARRAYEXPR:
1768 : 0 : build_EvalXFunc(b, mod, "ExecEvalArrayExpr",
1769 : : v_state, op);
1770 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1771 : 0 : break;
1772 : :
1773 : 0 : case EEOP_ARRAYCOERCE:
1774 : 0 : build_EvalXFunc(b, mod, "ExecEvalArrayCoerce",
1775 : : v_state, op, v_econtext);
1776 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1777 : 0 : break;
1778 : :
1779 : 0 : case EEOP_ROW:
1780 : 0 : build_EvalXFunc(b, mod, "ExecEvalRow",
1781 : : v_state, op);
1782 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1783 : 0 : break;
1784 : :
1785 : 0 : case EEOP_ROWCOMPARE_STEP:
1786 : : {
1787 : 0 : FunctionCallInfo fcinfo = op->d.rowcompare_step.fcinfo_data;
1788 : : LLVMValueRef v_fcinfo_isnull;
1789 : : LLVMBasicBlockRef b_null;
1790 : : LLVMBasicBlockRef b_compare;
1791 : : LLVMBasicBlockRef b_compare_result;
1792 : :
1793 : : LLVMValueRef v_retval;
1794 : :
1795 : 0 : b_null = l_bb_before_v(opblocks[opno + 1],
1796 : : "op.%d.row-null", opno);
1797 : 0 : b_compare = l_bb_before_v(opblocks[opno + 1],
1798 : : "op.%d.row-compare", opno);
1799 : : b_compare_result =
1800 : 0 : l_bb_before_v(opblocks[opno + 1],
1801 : : "op.%d.row-compare-result",
1802 : : opno);
1803 : :
1804 : : /*
1805 : : * If function is strict, and either arg is null, we're
1806 : : * done.
1807 : : */
1808 [ # # ]: 0 : if (op->d.rowcompare_step.finfo->fn_strict)
1809 : : {
1810 : : LLVMValueRef v_fcinfo;
1811 : : LLVMValueRef v_argnull0;
1812 : : LLVMValueRef v_argnull1;
1813 : : LLVMValueRef v_anyargisnull;
1814 : :
1815 : 0 : v_fcinfo = l_ptr_const(fcinfo,
1816 : : l_ptr(StructFunctionCallInfoData));
1817 : :
1818 : 0 : v_argnull0 = l_funcnull(b, v_fcinfo, 0);
1819 : 0 : v_argnull1 = l_funcnull(b, v_fcinfo, 1);
1820 : :
1821 : : v_anyargisnull =
1822 : 0 : LLVMBuildOr(b,
1823 : : LLVMBuildICmp(b,
1824 : : LLVMIntEQ,
1825 : : v_argnull0,
1826 : : l_sbool_const(1),
1827 : : ""),
1828 : : LLVMBuildICmp(b, LLVMIntEQ,
1829 : : v_argnull1,
1830 : : l_sbool_const(1), ""),
1831 : : "");
1832 : :
1833 : 0 : LLVMBuildCondBr(b, v_anyargisnull, b_null, b_compare);
1834 : : }
1835 : : else
1836 : : {
1837 : 0 : LLVMBuildBr(b, b_compare);
1838 : : }
1839 : :
1840 : : /* build block invoking comparison function */
1841 : 0 : LLVMPositionBuilderAtEnd(b, b_compare);
1842 : :
1843 : : /* call function */
1844 : 0 : v_retval = BuildV1Call(context, b, mod, fcinfo,
1845 : : &v_fcinfo_isnull);
1846 : 0 : LLVMBuildStore(b, v_retval, v_resvaluep);
1847 : :
1848 : : /* if result of function is NULL, force NULL result */
1849 : 0 : LLVMBuildCondBr(b,
1850 : : LLVMBuildICmp(b,
1851 : : LLVMIntEQ,
1852 : : v_fcinfo_isnull,
1853 : : l_sbool_const(0),
1854 : : ""),
1855 : : b_compare_result,
1856 : : b_null);
1857 : :
1858 : : /* build block analyzing the !NULL comparator result */
1859 : 0 : LLVMPositionBuilderAtEnd(b, b_compare_result);
1860 : :
1861 : : /* if results equal, compare next, otherwise done */
1862 : 0 : LLVMBuildCondBr(b,
1863 : : LLVMBuildICmp(b,
1864 : : LLVMIntEQ,
1865 : : v_retval,
1866 : : l_datum_const(0), ""),
1867 : 0 : opblocks[opno + 1],
1868 : 0 : opblocks[op->d.rowcompare_step.jumpdone]);
1869 : :
1870 : : /*
1871 : : * Build block handling NULL input or NULL comparator
1872 : : * result.
1873 : : */
1874 : 0 : LLVMPositionBuilderAtEnd(b, b_null);
1875 : 0 : LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
1876 : 0 : LLVMBuildBr(b, opblocks[op->d.rowcompare_step.jumpnull]);
1877 : :
1878 : 0 : break;
1879 : : }
1880 : :
1881 : 0 : case EEOP_ROWCOMPARE_FINAL:
1882 : : {
1883 : 0 : CompareType cmptype = op->d.rowcompare_final.cmptype;
1884 : :
1885 : : LLVMValueRef v_cmpresult;
1886 : : LLVMValueRef v_result;
1887 : : LLVMIntPredicate predicate;
1888 : :
1889 : : /*
1890 : : * Btree comparators return 32 bit results, need to be
1891 : : * careful about sign (used as a 64 bit value it's
1892 : : * otherwise wrong).
1893 : : */
1894 : : v_cmpresult =
1895 : 0 : LLVMBuildTrunc(b,
1896 : : l_load(b, TypeDatum, v_resvaluep, ""),
1897 : : LLVMInt32TypeInContext(lc), "");
1898 : :
1899 [ # # # # : 0 : switch (cmptype)
# ]
1900 : : {
1901 : 0 : case COMPARE_LT:
1902 : 0 : predicate = LLVMIntSLT;
1903 : 0 : break;
1904 : 0 : case COMPARE_LE:
1905 : 0 : predicate = LLVMIntSLE;
1906 : 0 : break;
1907 : 0 : case COMPARE_GT:
1908 : 0 : predicate = LLVMIntSGT;
1909 : 0 : break;
1910 : 0 : case COMPARE_GE:
1911 : 0 : predicate = LLVMIntSGE;
1912 : 0 : break;
1913 : 0 : default:
1914 : : /* EQ and NE cases aren't allowed here */
1915 : : Assert(false);
1916 : 0 : predicate = 0; /* prevent compiler warning */
1917 : 0 : break;
1918 : : }
1919 : :
1920 : 0 : v_result = LLVMBuildICmp(b,
1921 : : predicate,
1922 : : v_cmpresult,
1923 : : l_int32_const(lc, 0),
1924 : : "");
1925 : 0 : v_result = LLVMBuildZExt(b, v_result, TypeDatum, "");
1926 : :
1927 : 0 : LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
1928 : 0 : LLVMBuildStore(b, v_result, v_resvaluep);
1929 : :
1930 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1931 : 0 : break;
1932 : : }
1933 : :
1934 : 0 : case EEOP_MINMAX:
1935 : 0 : build_EvalXFunc(b, mod, "ExecEvalMinMax",
1936 : : v_state, op);
1937 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1938 : 0 : break;
1939 : :
1940 : 0 : case EEOP_FIELDSELECT:
1941 : 0 : build_EvalXFunc(b, mod, "ExecEvalFieldSelect",
1942 : : v_state, op, v_econtext);
1943 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1944 : 0 : break;
1945 : :
1946 : 0 : case EEOP_FIELDSTORE_DEFORM:
1947 : 0 : build_EvalXFunc(b, mod, "ExecEvalFieldStoreDeForm",
1948 : : v_state, op, v_econtext);
1949 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1950 : 0 : break;
1951 : :
1952 : 0 : case EEOP_FIELDSTORE_FORM:
1953 : 0 : build_EvalXFunc(b, mod, "ExecEvalFieldStoreForm",
1954 : : v_state, op, v_econtext);
1955 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1956 : 0 : break;
1957 : :
1958 : 0 : case EEOP_DOMAIN_TESTVAL:
1959 : : {
1960 : : LLVMValueRef v_casevaluep,
1961 : : v_casevalue;
1962 : : LLVMValueRef v_casenullp,
1963 : : v_casenull;
1964 : :
1965 : 0 : v_casevaluep = l_ptr_const(op->d.casetest.value,
1966 : : l_ptr(TypeDatum));
1967 : 0 : v_casenullp = l_ptr_const(op->d.casetest.isnull,
1968 : : l_ptr(TypeStorageBool));
1969 : :
1970 : 0 : v_casevalue = l_load(b, TypeDatum, v_casevaluep, "");
1971 : 0 : v_casenull = l_load(b, TypeStorageBool, v_casenullp, "");
1972 : 0 : LLVMBuildStore(b, v_casevalue, v_resvaluep);
1973 : 0 : LLVMBuildStore(b, v_casenull, v_resnullp);
1974 : :
1975 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
1976 : 0 : break;
1977 : : }
1978 : :
1979 : 0 : case EEOP_DOMAIN_TESTVAL_EXT:
1980 : : {
1981 : : LLVMValueRef v_casevalue;
1982 : : LLVMValueRef v_casenull;
1983 : :
1984 : : v_casevalue =
1985 : 0 : l_load_struct_gep(b,
1986 : : StructExprContext,
1987 : : v_econtext,
1988 : : FIELDNO_EXPRCONTEXT_DOMAINDATUM,
1989 : : "");
1990 : : v_casenull =
1991 : 0 : l_load_struct_gep(b,
1992 : : StructExprContext,
1993 : : v_econtext,
1994 : : FIELDNO_EXPRCONTEXT_DOMAINNULL,
1995 : : "");
1996 : 0 : LLVMBuildStore(b, v_casevalue, v_resvaluep);
1997 : 0 : LLVMBuildStore(b, v_casenull, v_resnullp);
1998 : :
1999 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2000 : 0 : break;
2001 : : }
2002 : :
2003 : 0 : case EEOP_DOMAIN_NOTNULL:
2004 : 0 : build_EvalXFunc(b, mod, "ExecEvalConstraintNotNull",
2005 : : v_state, op);
2006 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2007 : 0 : break;
2008 : :
2009 : 0 : case EEOP_DOMAIN_CHECK:
2010 : 0 : build_EvalXFunc(b, mod, "ExecEvalConstraintCheck",
2011 : : v_state, op);
2012 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2013 : 0 : break;
2014 : :
2015 : 0 : case EEOP_HASHDATUM_SET_INITVAL:
2016 : : {
2017 : : LLVMValueRef v_initvalue;
2018 : :
2019 : 0 : v_initvalue = l_datum_const(op->d.hashdatum_initvalue.init_value);
2020 : :
2021 : 0 : LLVMBuildStore(b, v_initvalue, v_resvaluep);
2022 : 0 : LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
2023 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2024 : 0 : break;
2025 : : }
2026 : :
2027 : 0 : case EEOP_HASHDATUM_FIRST:
2028 : : case EEOP_HASHDATUM_FIRST_STRICT:
2029 : : case EEOP_HASHDATUM_NEXT32:
2030 : : case EEOP_HASHDATUM_NEXT32_STRICT:
2031 : : {
2032 : 0 : FunctionCallInfo fcinfo = op->d.hashdatum.fcinfo_data;
2033 : : LLVMValueRef v_fcinfo;
2034 : : LLVMValueRef v_fcinfo_isnull;
2035 : : LLVMValueRef v_retval;
2036 : : LLVMBasicBlockRef b_checkargnull;
2037 : : LLVMBasicBlockRef b_ifnotnull;
2038 : : LLVMBasicBlockRef b_ifnullblock;
2039 : : LLVMValueRef v_argisnull;
2040 : 0 : LLVMValueRef v_prevhash = NULL;
2041 : :
2042 : : /*
2043 : : * When performing the next hash and not in strict mode we
2044 : : * perform a rotation of the previously stored hash value
2045 : : * before doing the NULL check. We want to do this even
2046 : : * when we receive a NULL Datum to hash. In strict mode,
2047 : : * we do this after the NULL check so as not to waste the
2048 : : * effort of rotating the bits when we're going to throw
2049 : : * away the hash value and return NULL.
2050 : : */
2051 [ # # ]: 0 : if (opcode == EEOP_HASHDATUM_NEXT32)
2052 : : {
2053 : : LLVMValueRef v_tmp1;
2054 : : LLVMValueRef v_tmp2;
2055 : : LLVMValueRef tmp;
2056 : :
2057 : 0 : tmp = l_ptr_const(&op->d.hashdatum.iresult->value,
2058 : : l_ptr(TypeDatum));
2059 : :
2060 : : /*
2061 : : * Fetch the previously hashed value from where the
2062 : : * previous hash operation stored it.
2063 : : */
2064 : 0 : v_prevhash = l_load(b, TypeDatum, tmp, "prevhash");
2065 : :
2066 : : /*
2067 : : * Rotate bits left by 1 bit. Be careful not to
2068 : : * overflow uint32 when working with Datum.
2069 : : */
2070 : 0 : v_tmp1 = LLVMBuildShl(b, v_prevhash, l_datum_const(1),
2071 : : "");
2072 : 0 : v_tmp1 = LLVMBuildAnd(b, v_tmp1,
2073 : : l_datum_const(0xffffffff), "");
2074 : 0 : v_tmp2 = LLVMBuildLShr(b, v_prevhash,
2075 : : l_datum_const(31), "");
2076 : 0 : v_prevhash = LLVMBuildOr(b, v_tmp1, v_tmp2,
2077 : : "rotatedhash");
2078 : : }
2079 : :
2080 : : /*
2081 : : * Block for the actual function call, if args are
2082 : : * non-NULL.
2083 : : */
2084 : 0 : b_ifnotnull = l_bb_before_v(opblocks[opno + 1],
2085 : : "b.%d.ifnotnull",
2086 : : opno);
2087 : :
2088 : : /* we expect the hash function to have 1 argument */
2089 [ # # ]: 0 : if (fcinfo->nargs != 1)
2090 [ # # ]: 0 : elog(ERROR, "incorrect number of function arguments");
2091 : :
2092 : 0 : v_fcinfo = l_ptr_const(fcinfo,
2093 : : l_ptr(StructFunctionCallInfoData));
2094 : :
2095 : 0 : b_checkargnull = l_bb_before_v(b_ifnotnull,
2096 : : "b.%d.isnull.0", opno);
2097 : :
2098 : 0 : LLVMBuildBr(b, b_checkargnull);
2099 : :
2100 : : /*
2101 : : * Determine what to do if we find the argument to be
2102 : : * NULL.
2103 : : */
2104 [ # # # # ]: 0 : if (opcode == EEOP_HASHDATUM_FIRST_STRICT ||
2105 : : opcode == EEOP_HASHDATUM_NEXT32_STRICT)
2106 : : {
2107 : 0 : b_ifnullblock = l_bb_before_v(b_ifnotnull,
2108 : : "b.%d.strictnull",
2109 : : opno);
2110 : :
2111 : 0 : LLVMPositionBuilderAtEnd(b, b_ifnullblock);
2112 : :
2113 : : /*
2114 : : * In strict node, NULL inputs result in NULL. Save
2115 : : * the NULL result and goto jumpdone.
2116 : : */
2117 : 0 : LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
2118 : 0 : LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
2119 : 0 : LLVMBuildBr(b, opblocks[op->d.hashdatum.jumpdone]);
2120 : : }
2121 : : else
2122 : : {
2123 : 0 : b_ifnullblock = l_bb_before_v(b_ifnotnull,
2124 : : "b.%d.null",
2125 : : opno);
2126 : :
2127 : 0 : LLVMPositionBuilderAtEnd(b, b_ifnullblock);
2128 : :
2129 : :
2130 : 0 : LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
2131 : :
2132 [ # # ]: 0 : if (opcode == EEOP_HASHDATUM_NEXT32)
2133 : : {
2134 : : Assert(v_prevhash != NULL);
2135 : :
2136 : : /*
2137 : : * Save the rotated hash value and skip to the
2138 : : * next op.
2139 : : */
2140 : 0 : LLVMBuildStore(b, v_prevhash, v_resvaluep);
2141 : : }
2142 : : else
2143 : : {
2144 : : Assert(opcode == EEOP_HASHDATUM_FIRST);
2145 : :
2146 : : /*
2147 : : * Store a zero Datum when the Datum to hash is
2148 : : * NULL
2149 : : */
2150 : 0 : LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
2151 : : }
2152 : :
2153 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2154 : : }
2155 : :
2156 : 0 : LLVMPositionBuilderAtEnd(b, b_checkargnull);
2157 : :
2158 : : /* emit code to check if the input parameter is NULL */
2159 : 0 : v_argisnull = l_funcnull(b, v_fcinfo, 0);
2160 : 0 : LLVMBuildCondBr(b,
2161 : : LLVMBuildICmp(b,
2162 : : LLVMIntEQ,
2163 : : v_argisnull,
2164 : : l_sbool_const(1),
2165 : : ""),
2166 : : b_ifnullblock,
2167 : : b_ifnotnull);
2168 : :
2169 : 0 : LLVMPositionBuilderAtEnd(b, b_ifnotnull);
2170 : :
2171 : : /*
2172 : : * Rotate the previously stored hash value when performing
2173 : : * NEXT32 in strict mode. In non-strict mode we already
2174 : : * did this before checking for NULLs.
2175 : : */
2176 [ # # ]: 0 : if (opcode == EEOP_HASHDATUM_NEXT32_STRICT)
2177 : : {
2178 : : LLVMValueRef v_tmp1;
2179 : : LLVMValueRef v_tmp2;
2180 : : LLVMValueRef tmp;
2181 : :
2182 : 0 : tmp = l_ptr_const(&op->d.hashdatum.iresult->value,
2183 : : l_ptr(TypeDatum));
2184 : :
2185 : : /*
2186 : : * Fetch the previously hashed value from where the
2187 : : * previous hash operation stored it.
2188 : : */
2189 : 0 : v_prevhash = l_load(b, TypeDatum, tmp, "prevhash");
2190 : :
2191 : : /*
2192 : : * Rotate bits left by 1 bit. Be careful not to
2193 : : * overflow uint32 when working with Datum.
2194 : : */
2195 : 0 : v_tmp1 = LLVMBuildShl(b, v_prevhash, l_datum_const(1),
2196 : : "");
2197 : 0 : v_tmp1 = LLVMBuildAnd(b, v_tmp1,
2198 : : l_datum_const(0xffffffff), "");
2199 : 0 : v_tmp2 = LLVMBuildLShr(b, v_prevhash,
2200 : : l_datum_const(31), "");
2201 : 0 : v_prevhash = LLVMBuildOr(b, v_tmp1, v_tmp2,
2202 : : "rotatedhash");
2203 : : }
2204 : :
2205 : : /* call the hash function */
2206 : 0 : v_retval = BuildV1Call(context, b, mod, fcinfo,
2207 : : &v_fcinfo_isnull);
2208 : :
2209 : : /*
2210 : : * For NEXT32 ops, XOR (^) the returned hash value with
2211 : : * the existing hash value.
2212 : : */
2213 [ # # # # ]: 0 : if (opcode == EEOP_HASHDATUM_NEXT32 ||
2214 : : opcode == EEOP_HASHDATUM_NEXT32_STRICT)
2215 : 0 : v_retval = LLVMBuildXor(b, v_prevhash, v_retval,
2216 : : "xorhash");
2217 : :
2218 : 0 : LLVMBuildStore(b, v_retval, v_resvaluep);
2219 : 0 : LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
2220 : :
2221 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2222 : 0 : break;
2223 : : }
2224 : :
2225 : 0 : case EEOP_CONVERT_ROWTYPE:
2226 : 0 : build_EvalXFunc(b, mod, "ExecEvalConvertRowtype",
2227 : : v_state, op, v_econtext);
2228 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2229 : 0 : break;
2230 : :
2231 : 0 : case EEOP_SCALARARRAYOP:
2232 : 0 : build_EvalXFunc(b, mod, "ExecEvalScalarArrayOp",
2233 : : v_state, op);
2234 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2235 : 0 : break;
2236 : :
2237 : 0 : case EEOP_HASHED_SCALARARRAYOP:
2238 : 0 : build_EvalXFunc(b, mod, "ExecEvalHashedScalarArrayOp",
2239 : : v_state, op, v_econtext);
2240 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2241 : 0 : break;
2242 : :
2243 : 0 : case EEOP_XMLEXPR:
2244 : 0 : build_EvalXFunc(b, mod, "ExecEvalXmlExpr",
2245 : : v_state, op);
2246 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2247 : 0 : break;
2248 : :
2249 : 0 : case EEOP_JSON_CONSTRUCTOR:
2250 : 0 : build_EvalXFunc(b, mod, "ExecEvalJsonConstructor",
2251 : : v_state, op, v_econtext);
2252 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2253 : 0 : break;
2254 : :
2255 : 0 : case EEOP_IS_JSON:
2256 : 0 : build_EvalXFunc(b, mod, "ExecEvalJsonIsPredicate",
2257 : : v_state, op);
2258 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2259 : 0 : break;
2260 : :
2261 : 0 : case EEOP_JSONEXPR_PATH:
2262 : : {
2263 : 0 : JsonExprState *jsestate = op->d.jsonexpr.jsestate;
2264 : : LLVMValueRef v_ret;
2265 : :
2266 : : /*
2267 : : * Call ExecEvalJsonExprPath(). It returns the address of
2268 : : * the step to perform next.
2269 : : */
2270 : 0 : v_ret = build_EvalXFunc(b, mod, "ExecEvalJsonExprPath",
2271 : : v_state, op, v_econtext);
2272 : :
2273 : : /*
2274 : : * Build a switch to map the return value (v_ret above),
2275 : : * which is a runtime value of the step address to perform
2276 : : * next, to either jump_empty, jump_error,
2277 : : * jump_eval_coercion, or jump_end.
2278 : : */
2279 [ # # ]: 0 : if (jsestate->jump_empty >= 0 ||
2280 [ # # ]: 0 : jsestate->jump_error >= 0 ||
2281 [ # # ]: 0 : jsestate->jump_eval_coercion >= 0)
2282 : : {
2283 : : LLVMValueRef v_jump_empty;
2284 : : LLVMValueRef v_jump_error;
2285 : : LLVMValueRef v_jump_coercion;
2286 : : LLVMValueRef v_switch;
2287 : : LLVMBasicBlockRef b_done,
2288 : : b_empty,
2289 : : b_error,
2290 : : b_coercion;
2291 : :
2292 : : b_empty =
2293 : 0 : l_bb_before_v(opblocks[opno + 1],
2294 : : "op.%d.jsonexpr_empty", opno);
2295 : : b_error =
2296 : 0 : l_bb_before_v(opblocks[opno + 1],
2297 : : "op.%d.jsonexpr_error", opno);
2298 : : b_coercion =
2299 : 0 : l_bb_before_v(opblocks[opno + 1],
2300 : : "op.%d.jsonexpr_coercion", opno);
2301 : : b_done =
2302 : 0 : l_bb_before_v(opblocks[opno + 1],
2303 : : "op.%d.jsonexpr_done", opno);
2304 : :
2305 : 0 : v_switch = LLVMBuildSwitch(b,
2306 : : v_ret,
2307 : : b_done,
2308 : : 3);
2309 : : /* Returned jsestate->jump_empty? */
2310 [ # # ]: 0 : if (jsestate->jump_empty >= 0)
2311 : : {
2312 : 0 : v_jump_empty = l_int32_const(lc, jsestate->jump_empty);
2313 : 0 : LLVMAddCase(v_switch, v_jump_empty, b_empty);
2314 : : }
2315 : : /* ON EMPTY code */
2316 : 0 : LLVMPositionBuilderAtEnd(b, b_empty);
2317 [ # # ]: 0 : if (jsestate->jump_empty >= 0)
2318 : 0 : LLVMBuildBr(b, opblocks[jsestate->jump_empty]);
2319 : : else
2320 : 0 : LLVMBuildUnreachable(b);
2321 : :
2322 : : /* Returned jsestate->jump_error? */
2323 [ # # ]: 0 : if (jsestate->jump_error >= 0)
2324 : : {
2325 : 0 : v_jump_error = l_int32_const(lc, jsestate->jump_error);
2326 : 0 : LLVMAddCase(v_switch, v_jump_error, b_error);
2327 : : }
2328 : : /* ON ERROR code */
2329 : 0 : LLVMPositionBuilderAtEnd(b, b_error);
2330 [ # # ]: 0 : if (jsestate->jump_error >= 0)
2331 : 0 : LLVMBuildBr(b, opblocks[jsestate->jump_error]);
2332 : : else
2333 : 0 : LLVMBuildUnreachable(b);
2334 : :
2335 : : /* Returned jsestate->jump_eval_coercion? */
2336 [ # # ]: 0 : if (jsestate->jump_eval_coercion >= 0)
2337 : : {
2338 : 0 : v_jump_coercion = l_int32_const(lc, jsestate->jump_eval_coercion);
2339 : 0 : LLVMAddCase(v_switch, v_jump_coercion, b_coercion);
2340 : : }
2341 : : /* jump_eval_coercion code */
2342 : 0 : LLVMPositionBuilderAtEnd(b, b_coercion);
2343 [ # # ]: 0 : if (jsestate->jump_eval_coercion >= 0)
2344 : 0 : LLVMBuildBr(b, opblocks[jsestate->jump_eval_coercion]);
2345 : : else
2346 : 0 : LLVMBuildUnreachable(b);
2347 : :
2348 : 0 : LLVMPositionBuilderAtEnd(b, b_done);
2349 : : }
2350 : :
2351 : 0 : LLVMBuildBr(b, opblocks[jsestate->jump_end]);
2352 : 0 : break;
2353 : : }
2354 : :
2355 : 0 : case EEOP_JSONEXPR_COERCION:
2356 : 0 : build_EvalXFunc(b, mod, "ExecEvalJsonCoercion",
2357 : : v_state, op, v_econtext);
2358 : :
2359 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2360 : 0 : break;
2361 : :
2362 : 0 : case EEOP_JSONEXPR_COERCION_FINISH:
2363 : 0 : build_EvalXFunc(b, mod, "ExecEvalJsonCoercionFinish",
2364 : : v_state, op);
2365 : :
2366 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2367 : 0 : break;
2368 : :
2369 : 0 : case EEOP_AGGREF:
2370 : : {
2371 : : LLVMValueRef v_aggno;
2372 : : LLVMValueRef value,
2373 : : isnull;
2374 : :
2375 : 0 : v_aggno = l_int32_const(lc, op->d.aggref.aggno);
2376 : :
2377 : : /* load agg value / null */
2378 : 0 : value = l_load_gep1(b, TypeDatum, v_aggvalues, v_aggno, "aggvalue");
2379 : 0 : isnull = l_load_gep1(b, TypeStorageBool, v_aggnulls, v_aggno, "aggnull");
2380 : :
2381 : : /* and store result */
2382 : 0 : LLVMBuildStore(b, value, v_resvaluep);
2383 : 0 : LLVMBuildStore(b, isnull, v_resnullp);
2384 : :
2385 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2386 : 0 : break;
2387 : : }
2388 : :
2389 : 0 : case EEOP_GROUPING_FUNC:
2390 : 0 : build_EvalXFunc(b, mod, "ExecEvalGroupingFunc",
2391 : : v_state, op);
2392 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2393 : 0 : break;
2394 : :
2395 : 0 : case EEOP_WINDOW_FUNC:
2396 : : {
2397 : 0 : WindowFuncExprState *wfunc = op->d.window_func.wfstate;
2398 : : LLVMValueRef v_wfuncnop;
2399 : : LLVMValueRef v_wfuncno;
2400 : : LLVMValueRef value,
2401 : : isnull;
2402 : :
2403 : : /*
2404 : : * At this point aggref->wfuncno is not yet set (it's set
2405 : : * up in ExecInitWindowAgg() after initializing the
2406 : : * expression). So load it from memory each time round.
2407 : : */
2408 : 0 : v_wfuncnop = l_ptr_const(&wfunc->wfuncno,
2409 : : l_ptr(LLVMInt32TypeInContext(lc)));
2410 : 0 : v_wfuncno = l_load(b, LLVMInt32TypeInContext(lc), v_wfuncnop, "v_wfuncno");
2411 : :
2412 : : /* load window func value / null */
2413 : 0 : value = l_load_gep1(b, TypeDatum, v_aggvalues, v_wfuncno,
2414 : : "windowvalue");
2415 : 0 : isnull = l_load_gep1(b, TypeStorageBool, v_aggnulls, v_wfuncno,
2416 : : "windownull");
2417 : :
2418 : 0 : LLVMBuildStore(b, value, v_resvaluep);
2419 : 0 : LLVMBuildStore(b, isnull, v_resnullp);
2420 : :
2421 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2422 : 0 : break;
2423 : : }
2424 : :
2425 : 0 : case EEOP_MERGE_SUPPORT_FUNC:
2426 : 0 : build_EvalXFunc(b, mod, "ExecEvalMergeSupportFunc",
2427 : : v_state, op, v_econtext);
2428 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2429 : 0 : break;
2430 : :
2431 : 0 : case EEOP_SUBPLAN:
2432 : 0 : build_EvalXFunc(b, mod, "ExecEvalSubPlan",
2433 : : v_state, op, v_econtext);
2434 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2435 : 0 : break;
2436 : :
2437 : 0 : case EEOP_AGG_STRICT_DESERIALIZE:
2438 : : case EEOP_AGG_DESERIALIZE:
2439 : : {
2440 : : AggState *aggstate;
2441 : 0 : FunctionCallInfo fcinfo = op->d.agg_deserialize.fcinfo_data;
2442 : :
2443 : : LLVMValueRef v_retval;
2444 : : LLVMValueRef v_fcinfo_isnull;
2445 : : LLVMValueRef v_tmpcontext;
2446 : : LLVMValueRef v_oldcontext;
2447 : :
2448 [ # # ]: 0 : if (opcode == EEOP_AGG_STRICT_DESERIALIZE)
2449 : : {
2450 : : LLVMValueRef v_fcinfo;
2451 : : LLVMValueRef v_argnull0;
2452 : : LLVMBasicBlockRef b_deserialize;
2453 : :
2454 : 0 : b_deserialize = l_bb_before_v(opblocks[opno + 1],
2455 : : "op.%d.deserialize", opno);
2456 : :
2457 : 0 : v_fcinfo = l_ptr_const(fcinfo,
2458 : : l_ptr(StructFunctionCallInfoData));
2459 : 0 : v_argnull0 = l_funcnull(b, v_fcinfo, 0);
2460 : :
2461 : 0 : LLVMBuildCondBr(b,
2462 : : LLVMBuildICmp(b,
2463 : : LLVMIntEQ,
2464 : : v_argnull0,
2465 : : l_sbool_const(1),
2466 : : ""),
2467 : 0 : opblocks[op->d.agg_deserialize.jumpnull],
2468 : : b_deserialize);
2469 : 0 : LLVMPositionBuilderAtEnd(b, b_deserialize);
2470 : : }
2471 : :
2472 : 0 : aggstate = castNode(AggState, state->parent);
2473 : 0 : fcinfo = op->d.agg_deserialize.fcinfo_data;
2474 : :
2475 : : v_tmpcontext =
2476 : 0 : l_ptr_const(aggstate->tmpcontext->ecxt_per_tuple_memory,
2477 : : l_ptr(StructMemoryContextData));
2478 : 0 : v_oldcontext = l_mcxt_switch(mod, b, v_tmpcontext);
2479 : 0 : v_retval = BuildV1Call(context, b, mod, fcinfo,
2480 : : &v_fcinfo_isnull);
2481 : 0 : l_mcxt_switch(mod, b, v_oldcontext);
2482 : :
2483 : 0 : LLVMBuildStore(b, v_retval, v_resvaluep);
2484 : 0 : LLVMBuildStore(b, v_fcinfo_isnull, v_resnullp);
2485 : :
2486 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2487 : 0 : break;
2488 : : }
2489 : :
2490 : 0 : case EEOP_AGG_STRICT_INPUT_CHECK_ARGS:
2491 : : case EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1:
2492 : : case EEOP_AGG_STRICT_INPUT_CHECK_NULLS:
2493 : : {
2494 : 0 : int nargs = op->d.agg_strict_input_check.nargs;
2495 : 0 : NullableDatum *args = op->d.agg_strict_input_check.args;
2496 : 0 : bool *nulls = op->d.agg_strict_input_check.nulls;
2497 : : int jumpnull;
2498 : :
2499 : : LLVMValueRef v_argsp;
2500 : : LLVMValueRef v_nullsp;
2501 : : LLVMBasicBlockRef *b_checknulls;
2502 : :
2503 : : Assert(nargs > 0);
2504 : :
2505 : 0 : jumpnull = op->d.agg_strict_input_check.jumpnull;
2506 : 0 : v_argsp = l_ptr_const(args, l_ptr(StructNullableDatum));
2507 : 0 : v_nullsp = l_ptr_const(nulls, l_ptr(TypeStorageBool));
2508 : :
2509 : : /* create blocks for checking args */
2510 : 0 : b_checknulls = palloc_array(LLVMBasicBlockRef, nargs);
2511 [ # # ]: 0 : for (int argno = 0; argno < nargs; argno++)
2512 : : {
2513 : 0 : b_checknulls[argno] =
2514 : 0 : l_bb_before_v(opblocks[opno + 1],
2515 : : "op.%d.check-null.%d",
2516 : : opno, argno);
2517 : : }
2518 : :
2519 : 0 : LLVMBuildBr(b, b_checknulls[0]);
2520 : :
2521 : : /* strict function, check for NULL args */
2522 [ # # ]: 0 : for (int argno = 0; argno < nargs; argno++)
2523 : : {
2524 : 0 : LLVMValueRef v_argno = l_int32_const(lc, argno);
2525 : : LLVMValueRef v_argisnull;
2526 : : LLVMBasicBlockRef b_argnotnull;
2527 : :
2528 : 0 : LLVMPositionBuilderAtEnd(b, b_checknulls[argno]);
2529 : :
2530 [ # # ]: 0 : if (argno + 1 == nargs)
2531 : 0 : b_argnotnull = opblocks[opno + 1];
2532 : : else
2533 : 0 : b_argnotnull = b_checknulls[argno + 1];
2534 : :
2535 [ # # ]: 0 : if (opcode == EEOP_AGG_STRICT_INPUT_CHECK_NULLS)
2536 : 0 : v_argisnull = l_load_gep1(b, TypeStorageBool, v_nullsp, v_argno, "");
2537 : : else
2538 : : {
2539 : : LLVMValueRef v_argn;
2540 : :
2541 : 0 : v_argn = l_gep(b, StructNullableDatum, v_argsp, &v_argno, 1, "");
2542 : : v_argisnull =
2543 : 0 : l_load_struct_gep(b, StructNullableDatum, v_argn,
2544 : : FIELDNO_NULLABLE_DATUM_ISNULL,
2545 : : "");
2546 : : }
2547 : :
2548 : 0 : LLVMBuildCondBr(b,
2549 : : LLVMBuildICmp(b,
2550 : : LLVMIntEQ,
2551 : : v_argisnull,
2552 : : l_sbool_const(1), ""),
2553 : 0 : opblocks[jumpnull],
2554 : : b_argnotnull);
2555 : : }
2556 : :
2557 : 0 : break;
2558 : : }
2559 : :
2560 : 0 : case EEOP_AGG_PLAIN_PERGROUP_NULLCHECK:
2561 : : {
2562 : : int jumpnull;
2563 : : LLVMValueRef v_aggstatep;
2564 : : LLVMValueRef v_allpergroupsp;
2565 : : LLVMValueRef v_pergroup_allaggs;
2566 : : LLVMValueRef v_setoff;
2567 : :
2568 : 0 : jumpnull = op->d.agg_plain_pergroup_nullcheck.jumpnull;
2569 : :
2570 : : /*
2571 : : * pergroup_allaggs = aggstate->all_pergroups
2572 : : * [op->d.agg_plain_pergroup_nullcheck.setoff];
2573 : : */
2574 : 0 : v_aggstatep = LLVMBuildBitCast(b, v_parent,
2575 : : l_ptr(StructAggState), "");
2576 : :
2577 : 0 : v_allpergroupsp = l_load_struct_gep(b,
2578 : : StructAggState,
2579 : : v_aggstatep,
2580 : : FIELDNO_AGGSTATE_ALL_PERGROUPS,
2581 : : "aggstate.all_pergroups");
2582 : :
2583 : 0 : v_setoff = l_int32_const(lc, op->d.agg_plain_pergroup_nullcheck.setoff);
2584 : :
2585 : 0 : v_pergroup_allaggs = l_load_gep1(b, l_ptr(StructAggStatePerGroupData),
2586 : : v_allpergroupsp, v_setoff, "");
2587 : :
2588 : 0 : LLVMBuildCondBr(b,
2589 : : LLVMBuildICmp(b, LLVMIntEQ,
2590 : : LLVMBuildPtrToInt(b, v_pergroup_allaggs, TypeDatum, ""),
2591 : : l_datum_const(0), ""),
2592 : 0 : opblocks[jumpnull],
2593 : 0 : opblocks[opno + 1]);
2594 : 0 : break;
2595 : : }
2596 : :
2597 : 0 : case EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL:
2598 : : case EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL:
2599 : : case EEOP_AGG_PLAIN_TRANS_BYVAL:
2600 : : case EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF:
2601 : : case EEOP_AGG_PLAIN_TRANS_STRICT_BYREF:
2602 : : case EEOP_AGG_PLAIN_TRANS_BYREF:
2603 : : {
2604 : : AggState *aggstate;
2605 : : AggStatePerTrans pertrans;
2606 : : FunctionCallInfo fcinfo;
2607 : :
2608 : : LLVMValueRef v_aggstatep;
2609 : : LLVMValueRef v_fcinfo;
2610 : : LLVMValueRef v_fcinfo_isnull;
2611 : :
2612 : : LLVMValueRef v_transvaluep;
2613 : : LLVMValueRef v_transnullp;
2614 : :
2615 : : LLVMValueRef v_setoff;
2616 : : LLVMValueRef v_transno;
2617 : :
2618 : : LLVMValueRef v_aggcontext;
2619 : :
2620 : : LLVMValueRef v_allpergroupsp;
2621 : : LLVMValueRef v_current_setp;
2622 : : LLVMValueRef v_current_pertransp;
2623 : : LLVMValueRef v_curaggcontext;
2624 : :
2625 : : LLVMValueRef v_pertransp;
2626 : :
2627 : : LLVMValueRef v_pergroupp;
2628 : :
2629 : : LLVMValueRef v_retval;
2630 : :
2631 : : LLVMValueRef v_tmpcontext;
2632 : : LLVMValueRef v_oldcontext;
2633 : :
2634 : 0 : aggstate = castNode(AggState, state->parent);
2635 : 0 : pertrans = op->d.agg_trans.pertrans;
2636 : :
2637 : 0 : fcinfo = pertrans->transfn_fcinfo;
2638 : :
2639 : : v_aggstatep =
2640 : 0 : LLVMBuildBitCast(b, v_parent, l_ptr(StructAggState), "");
2641 : 0 : v_pertransp = l_ptr_const(pertrans,
2642 : : l_ptr(StructAggStatePerTransData));
2643 : :
2644 : : /*
2645 : : * pergroup = &aggstate->all_pergroups
2646 : : * [op->d.agg_trans.setoff] [op->d.agg_trans.transno];
2647 : : */
2648 : : v_allpergroupsp =
2649 : 0 : l_load_struct_gep(b,
2650 : : StructAggState,
2651 : : v_aggstatep,
2652 : : FIELDNO_AGGSTATE_ALL_PERGROUPS,
2653 : : "aggstate.all_pergroups");
2654 : 0 : v_setoff = l_int32_const(lc, op->d.agg_trans.setoff);
2655 : 0 : v_transno = l_int32_const(lc, op->d.agg_trans.transno);
2656 : : v_pergroupp =
2657 : 0 : l_gep(b,
2658 : : StructAggStatePerGroupData,
2659 : : l_load_gep1(b, l_ptr(StructAggStatePerGroupData),
2660 : : v_allpergroupsp, v_setoff, ""),
2661 : : &v_transno, 1, "");
2662 : :
2663 : :
2664 [ # # # # ]: 0 : if (opcode == EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL ||
2665 : : opcode == EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF)
2666 : : {
2667 : : LLVMValueRef v_notransvalue;
2668 : : LLVMBasicBlockRef b_init;
2669 : : LLVMBasicBlockRef b_no_init;
2670 : :
2671 : : v_notransvalue =
2672 : 0 : l_load_struct_gep(b,
2673 : : StructAggStatePerGroupData,
2674 : : v_pergroupp,
2675 : : FIELDNO_AGGSTATEPERGROUPDATA_NOTRANSVALUE,
2676 : : "notransvalue");
2677 : :
2678 : 0 : b_init = l_bb_before_v(opblocks[opno + 1],
2679 : : "op.%d.inittrans", opno);
2680 : 0 : b_no_init = l_bb_before_v(opblocks[opno + 1],
2681 : : "op.%d.no_inittrans", opno);
2682 : :
2683 : 0 : LLVMBuildCondBr(b,
2684 : : LLVMBuildICmp(b, LLVMIntEQ, v_notransvalue,
2685 : : l_sbool_const(1), ""),
2686 : : b_init,
2687 : : b_no_init);
2688 : :
2689 : : /* block to init the transition value if necessary */
2690 : : {
2691 : : LLVMValueRef params[4];
2692 : :
2693 : 0 : LLVMPositionBuilderAtEnd(b, b_init);
2694 : :
2695 : 0 : v_aggcontext = l_ptr_const(op->d.agg_trans.aggcontext,
2696 : : l_ptr(StructExprContext));
2697 : :
2698 : 0 : params[0] = v_aggstatep;
2699 : 0 : params[1] = v_pertransp;
2700 : 0 : params[2] = v_pergroupp;
2701 : 0 : params[3] = v_aggcontext;
2702 : :
2703 : 0 : l_call(b,
2704 : : llvm_pg_var_func_type("ExecAggInitGroup"),
2705 : : llvm_pg_func(mod, "ExecAggInitGroup"),
2706 : : params, lengthof(params),
2707 : : "");
2708 : :
2709 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2710 : : }
2711 : :
2712 : 0 : LLVMPositionBuilderAtEnd(b, b_no_init);
2713 : : }
2714 : :
2715 [ # # # # ]: 0 : if (opcode == EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL ||
2716 [ # # ]: 0 : opcode == EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF ||
2717 [ # # ]: 0 : opcode == EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL ||
2718 : : opcode == EEOP_AGG_PLAIN_TRANS_STRICT_BYREF)
2719 : : {
2720 : : LLVMValueRef v_transnull;
2721 : : LLVMBasicBlockRef b_strictpass;
2722 : :
2723 : 0 : b_strictpass = l_bb_before_v(opblocks[opno + 1],
2724 : : "op.%d.strictpass", opno);
2725 : : v_transnull =
2726 : 0 : l_load_struct_gep(b,
2727 : : StructAggStatePerGroupData,
2728 : : v_pergroupp,
2729 : : FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUEISNULL,
2730 : : "transnull");
2731 : :
2732 : 0 : LLVMBuildCondBr(b,
2733 : : LLVMBuildICmp(b, LLVMIntEQ, v_transnull,
2734 : : l_sbool_const(1), ""),
2735 : 0 : opblocks[opno + 1],
2736 : : b_strictpass);
2737 : :
2738 : 0 : LLVMPositionBuilderAtEnd(b, b_strictpass);
2739 : : }
2740 : :
2741 : :
2742 : 0 : v_fcinfo = l_ptr_const(fcinfo,
2743 : : l_ptr(StructFunctionCallInfoData));
2744 : 0 : v_aggcontext = l_ptr_const(op->d.agg_trans.aggcontext,
2745 : : l_ptr(StructExprContext));
2746 : :
2747 : : v_current_setp =
2748 : 0 : l_struct_gep(b,
2749 : : StructAggState,
2750 : : v_aggstatep,
2751 : : FIELDNO_AGGSTATE_CURRENT_SET,
2752 : : "aggstate.current_set");
2753 : : v_curaggcontext =
2754 : 0 : l_struct_gep(b,
2755 : : StructAggState,
2756 : : v_aggstatep,
2757 : : FIELDNO_AGGSTATE_CURAGGCONTEXT,
2758 : : "aggstate.curaggcontext");
2759 : : v_current_pertransp =
2760 : 0 : l_struct_gep(b,
2761 : : StructAggState,
2762 : : v_aggstatep,
2763 : : FIELDNO_AGGSTATE_CURPERTRANS,
2764 : : "aggstate.curpertrans");
2765 : :
2766 : : /* set aggstate globals */
2767 : 0 : LLVMBuildStore(b, v_aggcontext, v_curaggcontext);
2768 : 0 : LLVMBuildStore(b, l_int32_const(lc, op->d.agg_trans.setno),
2769 : : v_current_setp);
2770 : 0 : LLVMBuildStore(b, v_pertransp, v_current_pertransp);
2771 : :
2772 : : /* invoke transition function in per-tuple context */
2773 : : v_tmpcontext =
2774 : 0 : l_ptr_const(aggstate->tmpcontext->ecxt_per_tuple_memory,
2775 : : l_ptr(StructMemoryContextData));
2776 : 0 : v_oldcontext = l_mcxt_switch(mod, b, v_tmpcontext);
2777 : :
2778 : : /* store transvalue in fcinfo->args[0] */
2779 : : v_transvaluep =
2780 : 0 : l_struct_gep(b,
2781 : : StructAggStatePerGroupData,
2782 : : v_pergroupp,
2783 : : FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUE,
2784 : : "transvalue");
2785 : : v_transnullp =
2786 : 0 : l_struct_gep(b,
2787 : : StructAggStatePerGroupData,
2788 : : v_pergroupp,
2789 : : FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUEISNULL,
2790 : : "transnullp");
2791 : 0 : LLVMBuildStore(b,
2792 : : l_load(b,
2793 : : TypeDatum,
2794 : : v_transvaluep,
2795 : : "transvalue"),
2796 : : l_funcvaluep(b, v_fcinfo, 0));
2797 : 0 : LLVMBuildStore(b,
2798 : : l_load(b, TypeStorageBool, v_transnullp, "transnull"),
2799 : : l_funcnullp(b, v_fcinfo, 0));
2800 : :
2801 : : /* and invoke transition function */
2802 : 0 : v_retval = BuildV1Call(context, b, mod, fcinfo,
2803 : : &v_fcinfo_isnull);
2804 : :
2805 : : /*
2806 : : * For pass-by-ref datatype, must copy the new value into
2807 : : * aggcontext and free the prior transValue. But if
2808 : : * transfn returned a pointer to its first input, we don't
2809 : : * need to do anything. Also, if transfn returned a
2810 : : * pointer to a R/W expanded object that is already a
2811 : : * child of the aggcontext, assume we can adopt that value
2812 : : * without copying it.
2813 : : */
2814 [ # # # # ]: 0 : if (opcode == EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF ||
2815 [ # # ]: 0 : opcode == EEOP_AGG_PLAIN_TRANS_STRICT_BYREF ||
2816 : : opcode == EEOP_AGG_PLAIN_TRANS_BYREF)
2817 : : {
2818 : : LLVMBasicBlockRef b_call;
2819 : : LLVMBasicBlockRef b_nocall;
2820 : : LLVMValueRef v_fn;
2821 : : LLVMValueRef v_transvalue;
2822 : : LLVMValueRef v_transnull;
2823 : : LLVMValueRef v_newval;
2824 : : LLVMValueRef params[6];
2825 : :
2826 : 0 : b_call = l_bb_before_v(opblocks[opno + 1],
2827 : : "op.%d.transcall", opno);
2828 : 0 : b_nocall = l_bb_before_v(opblocks[opno + 1],
2829 : : "op.%d.transnocall", opno);
2830 : :
2831 : 0 : v_transvalue = l_load(b, TypeDatum, v_transvaluep, "");
2832 : 0 : v_transnull = l_load(b, TypeStorageBool, v_transnullp, "");
2833 : :
2834 : : /*
2835 : : * DatumGetPointer(newVal) !=
2836 : : * DatumGetPointer(pergroup->transValue))
2837 : : */
2838 : 0 : LLVMBuildCondBr(b,
2839 : : LLVMBuildICmp(b, LLVMIntEQ,
2840 : : v_transvalue,
2841 : : v_retval, ""),
2842 : : b_nocall, b_call);
2843 : :
2844 : : /* returned datum not passed datum, reparent */
2845 : 0 : LLVMPositionBuilderAtEnd(b, b_call);
2846 : :
2847 : 0 : params[0] = v_aggstatep;
2848 : 0 : params[1] = v_pertransp;
2849 : 0 : params[2] = v_retval;
2850 : 0 : params[3] = LLVMBuildTrunc(b, v_fcinfo_isnull,
2851 : : TypeParamBool, "");
2852 : 0 : params[4] = v_transvalue;
2853 : 0 : params[5] = LLVMBuildTrunc(b, v_transnull,
2854 : : TypeParamBool, "");
2855 : :
2856 : 0 : v_fn = llvm_pg_func(mod, "ExecAggCopyTransValue");
2857 : : v_newval =
2858 : 0 : l_call(b,
2859 : : LLVMGetFunctionType(v_fn),
2860 : : v_fn,
2861 : : params, lengthof(params),
2862 : : "");
2863 : :
2864 : : /* store trans value */
2865 : 0 : LLVMBuildStore(b, v_newval, v_transvaluep);
2866 : 0 : LLVMBuildStore(b, v_fcinfo_isnull, v_transnullp);
2867 : :
2868 : 0 : l_mcxt_switch(mod, b, v_oldcontext);
2869 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2870 : :
2871 : : /* returned datum passed datum, no need to reparent */
2872 : 0 : LLVMPositionBuilderAtEnd(b, b_nocall);
2873 : : }
2874 : :
2875 : : /* store trans value */
2876 : 0 : LLVMBuildStore(b, v_retval, v_transvaluep);
2877 : 0 : LLVMBuildStore(b, v_fcinfo_isnull, v_transnullp);
2878 : :
2879 : 0 : l_mcxt_switch(mod, b, v_oldcontext);
2880 : :
2881 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2882 : 0 : break;
2883 : : }
2884 : :
2885 : 0 : case EEOP_AGG_PRESORTED_DISTINCT_SINGLE:
2886 : : {
2887 : 0 : AggState *aggstate = castNode(AggState, state->parent);
2888 : 0 : AggStatePerTrans pertrans = op->d.agg_presorted_distinctcheck.pertrans;
2889 : 0 : int jumpdistinct = op->d.agg_presorted_distinctcheck.jumpdistinct;
2890 : :
2891 : 0 : LLVMValueRef v_fn = llvm_pg_func(mod, "ExecEvalPreOrderedDistinctSingle");
2892 : : LLVMValueRef v_args[2];
2893 : : LLVMValueRef v_ret;
2894 : :
2895 : 0 : v_args[0] = l_ptr_const(aggstate, l_ptr(StructAggState));
2896 : 0 : v_args[1] = l_ptr_const(pertrans, l_ptr(StructAggStatePerTransData));
2897 : :
2898 : 0 : v_ret = l_call(b, LLVMGetFunctionType(v_fn), v_fn, v_args, 2, "");
2899 : 0 : v_ret = LLVMBuildZExt(b, v_ret, TypeStorageBool, "");
2900 : :
2901 : 0 : LLVMBuildCondBr(b,
2902 : : LLVMBuildICmp(b, LLVMIntEQ, v_ret,
2903 : : l_sbool_const(1), ""),
2904 : 0 : opblocks[opno + 1],
2905 : 0 : opblocks[jumpdistinct]);
2906 : 0 : break;
2907 : : }
2908 : :
2909 : 0 : case EEOP_AGG_PRESORTED_DISTINCT_MULTI:
2910 : : {
2911 : 0 : AggState *aggstate = castNode(AggState, state->parent);
2912 : 0 : AggStatePerTrans pertrans = op->d.agg_presorted_distinctcheck.pertrans;
2913 : 0 : int jumpdistinct = op->d.agg_presorted_distinctcheck.jumpdistinct;
2914 : :
2915 : 0 : LLVMValueRef v_fn = llvm_pg_func(mod, "ExecEvalPreOrderedDistinctMulti");
2916 : : LLVMValueRef v_args[2];
2917 : : LLVMValueRef v_ret;
2918 : :
2919 : 0 : v_args[0] = l_ptr_const(aggstate, l_ptr(StructAggState));
2920 : 0 : v_args[1] = l_ptr_const(pertrans, l_ptr(StructAggStatePerTransData));
2921 : :
2922 : 0 : v_ret = l_call(b, LLVMGetFunctionType(v_fn), v_fn, v_args, 2, "");
2923 : 0 : v_ret = LLVMBuildZExt(b, v_ret, TypeStorageBool, "");
2924 : :
2925 : 0 : LLVMBuildCondBr(b,
2926 : : LLVMBuildICmp(b, LLVMIntEQ, v_ret,
2927 : : l_sbool_const(1), ""),
2928 : 0 : opblocks[opno + 1],
2929 : 0 : opblocks[jumpdistinct]);
2930 : 0 : break;
2931 : : }
2932 : :
2933 : 0 : case EEOP_AGG_ORDERED_TRANS_DATUM:
2934 : 0 : build_EvalXFunc(b, mod, "ExecEvalAggOrderedTransDatum",
2935 : : v_state, op, v_econtext);
2936 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2937 : 0 : break;
2938 : :
2939 : 0 : case EEOP_AGG_ORDERED_TRANS_TUPLE:
2940 : 0 : build_EvalXFunc(b, mod, "ExecEvalAggOrderedTransTuple",
2941 : : v_state, op, v_econtext);
2942 : 0 : LLVMBuildBr(b, opblocks[opno + 1]);
2943 : 0 : break;
2944 : :
2945 : 0 : case EEOP_LAST:
2946 : : Assert(false);
2947 : 0 : break;
2948 : : }
2949 : : }
2950 : :
2951 : 0 : LLVMDisposeBuilder(b);
2952 : :
2953 : : /*
2954 : : * Don't immediately emit function, instead do so the first time the
2955 : : * expression is actually evaluated. That allows to emit a lot of
2956 : : * functions together, avoiding a lot of repeated llvm and memory
2957 : : * remapping overhead.
2958 : : */
2959 : : {
2960 : :
2961 : 0 : CompiledExprState *cstate = palloc0_object(CompiledExprState);
2962 : :
2963 : 0 : cstate->context = context;
2964 : 0 : cstate->funcname = funcname;
2965 : :
2966 : 0 : state->evalfunc = ExecRunCompiledExpr;
2967 : 0 : state->evalfunc_private = cstate;
2968 : : }
2969 : :
2970 : 0 : llvm_leave_fatal_on_oom();
2971 : :
2972 : 0 : INSTR_TIME_SET_CURRENT(endtime);
2973 : 0 : INSTR_TIME_ACCUM_DIFF(context->base.instr.generation_counter,
2974 : : endtime, starttime);
2975 : :
2976 : 0 : return true;
2977 : : }
2978 : :
2979 : : /*
2980 : : * Run compiled expression.
2981 : : *
2982 : : * This will only be called the first time a JITed expression is called. We
2983 : : * first make sure the expression is still up-to-date, and then get a pointer to
2984 : : * the emitted function. The latter can be the first thing that triggers
2985 : : * optimizing and emitting all the generated functions.
2986 : : */
2987 : : static Datum
2988 : 0 : ExecRunCompiledExpr(ExprState *state, ExprContext *econtext, bool *isNull)
2989 : : {
2990 : 0 : CompiledExprState *cstate = state->evalfunc_private;
2991 : : ExprStateEvalFunc func;
2992 : :
2993 : 0 : CheckExprStillValid(state, econtext);
2994 : :
2995 : 0 : llvm_enter_fatal_on_oom();
2996 : 0 : func = (ExprStateEvalFunc) llvm_get_function(cstate->context,
2997 : : cstate->funcname);
2998 : 0 : llvm_leave_fatal_on_oom();
2999 : : Assert(func);
3000 : :
3001 : : /* remove indirection via this function for future calls */
3002 : 0 : state->evalfunc = func;
3003 : :
3004 : 0 : return func(state, econtext, isNull);
3005 : : }
3006 : :
3007 : : static LLVMValueRef
3008 : 0 : BuildV1Call(LLVMJitContext *context, LLVMBuilderRef b,
3009 : : LLVMModuleRef mod, FunctionCallInfo fcinfo,
3010 : : LLVMValueRef *v_fcinfo_isnull)
3011 : : {
3012 : : LLVMValueRef v_fn;
3013 : : LLVMValueRef v_fcinfo_isnullp;
3014 : : LLVMValueRef v_retval;
3015 : : LLVMValueRef v_fcinfo;
3016 : :
3017 : 0 : v_fn = llvm_function_reference(context, b, mod, fcinfo);
3018 : :
3019 : 0 : v_fcinfo = l_ptr_const(fcinfo, l_ptr(StructFunctionCallInfoData));
3020 : 0 : v_fcinfo_isnullp = l_struct_gep(b,
3021 : : StructFunctionCallInfoData,
3022 : : v_fcinfo,
3023 : : FIELDNO_FUNCTIONCALLINFODATA_ISNULL,
3024 : : "v_fcinfo_isnull");
3025 : 0 : LLVMBuildStore(b, l_sbool_const(0), v_fcinfo_isnullp);
3026 : :
3027 : 0 : v_retval = l_call(b, LLVMGetFunctionType(AttributeTemplate), v_fn, &v_fcinfo, 1, "funccall");
3028 : :
3029 [ # # ]: 0 : if (v_fcinfo_isnull)
3030 : 0 : *v_fcinfo_isnull = l_load(b, TypeStorageBool, v_fcinfo_isnullp, "");
3031 : :
3032 : : #if LLVM_VERSION_MAJOR < 22
3033 : :
3034 : : /*
3035 : : * Add lifetime-end annotation, signaling that writes to memory don't have
3036 : : * to be retained (important for inlining potential).
3037 : : */
3038 : : {
3039 : 0 : LLVMContextRef lc = LLVMGetModuleContext(mod);
3040 : 0 : LLVMValueRef v_lifetime = create_LifetimeEnd(mod);
3041 : : LLVMValueRef params[2];
3042 : :
3043 : 0 : params[0] = l_int64_const(lc, sizeof(NullableDatum) * fcinfo->nargs);
3044 : 0 : params[1] = l_ptr_const(fcinfo->args, l_ptr(LLVMInt8TypeInContext(lc)));
3045 : 0 : l_call(b, LLVMGetFunctionType(v_lifetime), v_lifetime, params, lengthof(params), "");
3046 : :
3047 : 0 : params[0] = l_int64_const(lc, sizeof(fcinfo->isnull));
3048 : 0 : params[1] = l_ptr_const(&fcinfo->isnull, l_ptr(LLVMInt8TypeInContext(lc)));
3049 : 0 : l_call(b, LLVMGetFunctionType(v_lifetime), v_lifetime, params, lengthof(params), "");
3050 : : }
3051 : : #endif
3052 : :
3053 : 0 : return v_retval;
3054 : : }
3055 : :
3056 : : /*
3057 : : * Implement an expression step by calling the function funcname.
3058 : : */
3059 : : static LLVMValueRef
3060 : 0 : build_EvalXFuncInt(LLVMBuilderRef b, LLVMModuleRef mod, const char *funcname,
3061 : : LLVMValueRef v_state, ExprEvalStep *op,
3062 : : int nargs, LLVMValueRef *v_args)
3063 : : {
3064 : 0 : LLVMValueRef v_fn = llvm_pg_func(mod, funcname);
3065 : : LLVMValueRef *params;
3066 : 0 : int argno = 0;
3067 : : LLVMValueRef v_ret;
3068 : :
3069 : : /* cheap pre-check as llvm just asserts out */
3070 [ # # ]: 0 : if (LLVMCountParams(v_fn) != (nargs + 2))
3071 [ # # ]: 0 : elog(ERROR, "parameter mismatch: %s expects %d passed %d",
3072 : : funcname, LLVMCountParams(v_fn), nargs + 2);
3073 : :
3074 : 0 : params = palloc_array(LLVMValueRef, (2 + nargs));
3075 : :
3076 : 0 : params[argno++] = v_state;
3077 : 0 : params[argno++] = l_ptr_const(op, l_ptr(StructExprEvalStep));
3078 : :
3079 [ # # ]: 0 : for (int i = 0; i < nargs; i++)
3080 : 0 : params[argno++] = v_args[i];
3081 : :
3082 : 0 : v_ret = l_call(b, LLVMGetFunctionType(v_fn), v_fn, params, argno, "");
3083 : :
3084 : 0 : pfree(params);
3085 : :
3086 : 0 : return v_ret;
3087 : : }
3088 : :
3089 : : #if LLVM_VERSION_MAJOR < 22
3090 : : static LLVMValueRef
3091 : 0 : create_LifetimeEnd(LLVMModuleRef mod)
3092 : : {
3093 : : LLVMTypeRef sig;
3094 : : LLVMValueRef fn;
3095 : : LLVMTypeRef param_types[2];
3096 : : LLVMContextRef lc;
3097 : :
3098 : : /* variadic pointer argument */
3099 : 0 : const char *nm = "llvm.lifetime.end.p0";
3100 : :
3101 : 0 : fn = LLVMGetNamedFunction(mod, nm);
3102 [ # # ]: 0 : if (fn)
3103 : 0 : return fn;
3104 : :
3105 : 0 : lc = LLVMGetModuleContext(mod);
3106 : 0 : param_types[0] = LLVMInt64TypeInContext(lc);
3107 : 0 : param_types[1] = l_ptr(LLVMInt8TypeInContext(lc));
3108 : :
3109 : 0 : sig = LLVMFunctionType(LLVMVoidTypeInContext(lc), param_types,
3110 : : lengthof(param_types), false);
3111 : 0 : fn = LLVMAddFunction(mod, nm, sig);
3112 : :
3113 : 0 : LLVMSetFunctionCallConv(fn, LLVMCCallConv);
3114 : :
3115 : : Assert(LLVMGetIntrinsicID(fn));
3116 : :
3117 : 0 : return fn;
3118 : : }
3119 : : #endif
|
