PostgreSQL Source Code git master
Loading...
Searching...
No Matches
llvmjit_expr.c
Go to the documentation of this file.
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
53
54
55static Datum ExecRunCompiledExpr(ExprState *state, ExprContext *econtext, bool *isNull);
56
57static LLVMValueRef BuildV1Call(LLVMJitContext *context, LLVMBuilderRef b,
58 LLVMModuleRef mod, FunctionCallInfo fcinfo,
59 LLVMValueRef *v_fcinfo_isnull);
60static 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
66static 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 */
79bool
80llvm_compile_expr(ExprState *state)
81{
82 PlanState *parent = state->parent;
83 char *funcname;
84
85 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 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 if (parent->state->es_jit)
147 context = (LLVMJitContext *) parent->state->es_jit;
148 else
149 {
150 context = llvm_create_context(parent->state->es_jit_flags);
151 parent->state->es_jit = &context->base;
152 }
153
154 INSTR_TIME_SET_CURRENT(starttime);
155
156 mod = llvm_mutable_module(context);
157 lc = LLVMGetModuleContext(mod);
158
159 b = LLVMCreateBuilderInContext(lc);
160
161 funcname = llvm_expand_funcname(context, "evalexpr");
162
163 /* create function */
164 eval_fn = LLVMAddFunction(mod, funcname,
165 llvm_pg_var_func_type("ExecInterpExprStillValid"));
166 LLVMSetLinkage(eval_fn, LLVMExternalLinkage);
167 LLVMSetVisibility(eval_fn, LLVMDefaultVisibility);
168 llvm_copy_attributes(AttributeTemplate, eval_fn);
169
170 entry = LLVMAppendBasicBlockInContext(lc, eval_fn, "entry");
171
172 /* build state */
173 v_state = LLVMGetParam(eval_fn, 0);
174 v_econtext = LLVMGetParam(eval_fn, 1);
175 v_isnullp = LLVMGetParam(eval_fn, 2);
176
177 LLVMPositionBuilderAtEnd(b, entry);
178
179 v_tmpvaluep = l_struct_gep(b,
180 StructExprState,
181 v_state,
182 FIELDNO_EXPRSTATE_RESVALUE,
183 "v.state.resvalue");
184 v_tmpisnullp = l_struct_gep(b,
185 StructExprState,
186 v_state,
187 FIELDNO_EXPRSTATE_RESNULL,
188 "v.state.resnull");
189 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 v_scanslot = l_load_struct_gep(b,
197 StructExprContext,
198 v_econtext,
199 FIELDNO_EXPRCONTEXT_SCANTUPLE,
200 "v_scanslot");
201 v_innerslot = l_load_struct_gep(b,
202 StructExprContext,
203 v_econtext,
204 FIELDNO_EXPRCONTEXT_INNERTUPLE,
205 "v_innerslot");
206 v_outerslot = l_load_struct_gep(b,
207 StructExprContext,
208 v_econtext,
209 FIELDNO_EXPRCONTEXT_OUTERTUPLE,
210 "v_outerslot");
211 v_oldslot = l_load_struct_gep(b,
212 StructExprContext,
213 v_econtext,
214 FIELDNO_EXPRCONTEXT_OLDTUPLE,
215 "v_oldslot");
216 v_newslot = l_load_struct_gep(b,
217 StructExprContext,
218 v_econtext,
219 FIELDNO_EXPRCONTEXT_NEWTUPLE,
220 "v_newslot");
221 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 v_scanvalues = l_load_struct_gep(b,
229 StructTupleTableSlot,
230 v_scanslot,
231 FIELDNO_TUPLETABLESLOT_VALUES,
232 "v_scanvalues");
233 v_scannulls = l_load_struct_gep(b,
234 StructTupleTableSlot,
235 v_scanslot,
236 FIELDNO_TUPLETABLESLOT_ISNULL,
237 "v_scannulls");
238 v_innervalues = l_load_struct_gep(b,
239 StructTupleTableSlot,
240 v_innerslot,
241 FIELDNO_TUPLETABLESLOT_VALUES,
242 "v_innervalues");
243 v_innernulls = l_load_struct_gep(b,
244 StructTupleTableSlot,
245 v_innerslot,
246 FIELDNO_TUPLETABLESLOT_ISNULL,
247 "v_innernulls");
248 v_outervalues = l_load_struct_gep(b,
249 StructTupleTableSlot,
250 v_outerslot,
251 FIELDNO_TUPLETABLESLOT_VALUES,
252 "v_outervalues");
253 v_outernulls = l_load_struct_gep(b,
254 StructTupleTableSlot,
255 v_outerslot,
256 FIELDNO_TUPLETABLESLOT_ISNULL,
257 "v_outernulls");
258 v_oldvalues = l_load_struct_gep(b,
259 StructTupleTableSlot,
260 v_oldslot,
261 FIELDNO_TUPLETABLESLOT_VALUES,
262 "v_oldvalues");
263 v_oldnulls = l_load_struct_gep(b,
264 StructTupleTableSlot,
265 v_oldslot,
266 FIELDNO_TUPLETABLESLOT_ISNULL,
267 "v_oldnulls");
268 v_newvalues = l_load_struct_gep(b,
269 StructTupleTableSlot,
270 v_newslot,
271 FIELDNO_TUPLETABLESLOT_VALUES,
272 "v_newvalues");
273 v_newnulls = l_load_struct_gep(b,
274 StructTupleTableSlot,
275 v_newslot,
276 FIELDNO_TUPLETABLESLOT_ISNULL,
277 "v_newnulls");
278 v_resultvalues = l_load_struct_gep(b,
279 StructTupleTableSlot,
280 v_resultslot,
281 FIELDNO_TUPLETABLESLOT_VALUES,
282 "v_resultvalues");
283 v_resultnulls = l_load_struct_gep(b,
284 StructTupleTableSlot,
285 v_resultslot,
286 FIELDNO_TUPLETABLESLOT_ISNULL,
287 "v_resultnulls");
288
289 /* aggvalues/aggnulls */
290 v_aggvalues = l_load_struct_gep(b,
291 StructExprContext,
292 v_econtext,
293 FIELDNO_EXPRCONTEXT_AGGVALUES,
294 "v.econtext.aggvalues");
295 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 opblocks = palloc_array(LLVMBasicBlockRef, state->steps_len);
303 for (int opno = 0; opno < state->steps_len; opno++)
304 opblocks[opno] = l_bb_append_v(eval_fn, "b.op.%d.start", opno);
305
306 /* jump from entry to first block */
307 LLVMBuildBr(b, opblocks[0]);
308
309 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 LLVMPositionBuilderAtEnd(b, opblocks[opno]);
317
318 op = &state->steps[opno];
319 opcode = ExecEvalStepOp(state, op);
320
321 v_resvaluep = l_ptr_const(op->resvalue, l_ptr(TypeDatum));
322 v_resnullp = l_ptr_const(op->resnull, l_ptr(TypeStorageBool));
323
324 switch (opcode)
325 {
326 case EEOP_DONE_RETURN:
327 {
328 LLVMValueRef v_tmpisnull;
329 LLVMValueRef v_tmpvalue;
330
331 v_tmpvalue = l_load(b, TypeDatum, v_tmpvaluep, "");
332 v_tmpisnull = l_load(b, TypeStorageBool, v_tmpisnullp, "");
333
334 LLVMBuildStore(b, v_tmpisnull, v_isnullp);
335
336 LLVMBuildRet(b, v_tmpvalue);
337 break;
338 }
339
340 case EEOP_DONE_NO_RETURN:
341 LLVMBuildRet(b, l_datum_const(0));
342 break;
343
344 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 TupleDesc desc = NULL;
351 LLVMValueRef v_slot;
352 LLVMBasicBlockRef b_fetch;
353 LLVMValueRef v_nvalid;
354 LLVMValueRef l_jit_deform = NULL;
355 const TupleTableSlotOps *tts_ops = NULL;
356
357 b_fetch = l_bb_before_v(opblocks[opno + 1],
358 "op.%d.fetch", opno);
359
360 if (op->d.fetch.known_desc)
361 desc = op->d.fetch.known_desc;
362
363 if (op->d.fetch.fixed)
364 tts_ops = op->d.fetch.kind;
365
366 /* step should not have been generated */
367 Assert(tts_ops != &TTSOpsVirtual);
368
369 if (opcode == EEOP_INNER_FETCHSOME)
370 v_slot = v_innerslot;
371 else if (opcode == EEOP_OUTER_FETCHSOME)
372 v_slot = v_outerslot;
373 else if (opcode == EEOP_SCAN_FETCHSOME)
374 v_slot = v_scanslot;
375 else if (opcode == EEOP_OLD_FETCHSOME)
376 v_slot = v_oldslot;
377 else
378 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 l_load_struct_gep(b,
386 StructTupleTableSlot,
387 v_slot,
388 FIELDNO_TUPLETABLESLOT_NVALID,
389 "");
390 LLVMBuildCondBr(b,
391 LLVMBuildICmp(b, LLVMIntUGE, v_nvalid,
392 l_int16_const(lc, op->d.fetch.last_var),
393 ""),
394 opblocks[opno + 1], b_fetch);
395
396 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 if (tts_ops && desc && (context->base.flags & PGJIT_DEFORM))
405 {
406 INSTR_TIME_SET_CURRENT(deform_starttime);
407 l_jit_deform =
408 slot_compile_deform(context, desc,
409 tts_ops,
410 op->d.fetch.last_var);
411 INSTR_TIME_SET_CURRENT(deform_endtime);
412 INSTR_TIME_ACCUM_DIFF(context->base.instr.deform_counter,
413 deform_endtime, deform_starttime);
414 }
415
416 if (l_jit_deform)
417 {
418 LLVMValueRef params[1];
419
420 params[0] = v_slot;
421
422 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 params[0] = v_slot;
432 params[1] = l_int32_const(lc, op->d.fetch.last_var);
433
434 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 LLVMBuildBr(b, opblocks[opno + 1]);
441 break;
442 }
443
444 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 if (opcode == EEOP_INNER_VAR)
457 {
458 v_values = v_innervalues;
459 v_nulls = v_innernulls;
460 }
461 else if (opcode == EEOP_OUTER_VAR)
462 {
463 v_values = v_outervalues;
464 v_nulls = v_outernulls;
465 }
466 else if (opcode == EEOP_SCAN_VAR)
467 {
468 v_values = v_scanvalues;
469 v_nulls = v_scannulls;
470 }
471 else if (opcode == EEOP_OLD_VAR)
472 {
473 v_values = v_oldvalues;
474 v_nulls = v_oldnulls;
475 }
476 else
477 {
478 v_values = v_newvalues;
479 v_nulls = v_newnulls;
480 }
481
482 v_attnum = l_int32_const(lc, op->d.var.attnum);
483 value = l_load_gep1(b, TypeDatum, v_values, v_attnum, "");
484 isnull = l_load_gep1(b, TypeStorageBool, v_nulls, v_attnum, "");
485 LLVMBuildStore(b, value, v_resvaluep);
486 LLVMBuildStore(b, isnull, v_resnullp);
487
488 LLVMBuildBr(b, opblocks[opno + 1]);
489 break;
490 }
491
492 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 if (opcode == EEOP_INNER_SYSVAR)
501 v_slot = v_innerslot;
502 else if (opcode == EEOP_OUTER_SYSVAR)
503 v_slot = v_outerslot;
504 else if (opcode == EEOP_SCAN_SYSVAR)
505 v_slot = v_scanslot;
506 else if (opcode == EEOP_OLD_SYSVAR)
507 v_slot = v_oldslot;
508 else
509 v_slot = v_newslot;
510
511 build_EvalXFunc(b, mod, "ExecEvalSysVar",
512 v_state, op, v_econtext, v_slot);
513
514 LLVMBuildBr(b, opblocks[opno + 1]);
515 break;
516 }
517
518 case EEOP_WHOLEROW:
519 build_EvalXFunc(b, mod, "ExecEvalWholeRowVar",
520 v_state, op, v_econtext);
521 LLVMBuildBr(b, opblocks[opno + 1]);
522 break;
523
524 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 if (opcode == EEOP_ASSIGN_INNER_VAR)
540 {
541 v_values = v_innervalues;
542 v_nulls = v_innernulls;
543 }
544 else if (opcode == EEOP_ASSIGN_OUTER_VAR)
545 {
546 v_values = v_outervalues;
547 v_nulls = v_outernulls;
548 }
549 else if (opcode == EEOP_ASSIGN_SCAN_VAR)
550 {
551 v_values = v_scanvalues;
552 v_nulls = v_scannulls;
553 }
554 else if (opcode == EEOP_ASSIGN_OLD_VAR)
555 {
556 v_values = v_oldvalues;
557 v_nulls = v_oldnulls;
558 }
559 else
560 {
561 v_values = v_newvalues;
562 v_nulls = v_newnulls;
563 }
564
565 /* load data */
566 v_attnum = l_int32_const(lc, op->d.assign_var.attnum);
567 v_value = l_load_gep1(b, TypeDatum, v_values, v_attnum, "");
568 v_isnull = l_load_gep1(b, TypeStorageBool, v_nulls, v_attnum, "");
569
570 /* compute addresses of targets */
571 v_resultnum = l_int32_const(lc, op->d.assign_var.resultnum);
572 v_rvaluep = l_gep(b,
573 TypeDatum,
574 v_resultvalues,
575 &v_resultnum, 1, "");
576 v_risnullp = l_gep(b,
577 TypeStorageBool,
578 v_resultnulls,
579 &v_resultnum, 1, "");
580
581 /* and store */
582 LLVMBuildStore(b, v_value, v_rvaluep);
583 LLVMBuildStore(b, v_isnull, v_risnullp);
584
585 LLVMBuildBr(b, opblocks[opno + 1]);
586 break;
587 }
588
589 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 size_t resultnum = op->d.assign_tmp.resultnum;
598
599 /* load data */
600 v_value = l_load(b, TypeDatum, v_tmpvaluep, "");
601 v_isnull = l_load(b, TypeStorageBool, v_tmpisnullp, "");
602
603 /* compute addresses of targets */
604 v_resultnum = l_int32_const(lc, resultnum);
605 v_rvaluep =
606 l_gep(b, TypeDatum, v_resultvalues, &v_resultnum, 1, "");
607 v_risnullp =
608 l_gep(b, TypeStorageBool, v_resultnulls, &v_resultnum, 1, "");
609
610 /* store nullness */
611 LLVMBuildStore(b, v_isnull, v_risnullp);
612
613 /* make value readonly if necessary */
614 if (opcode == EEOP_ASSIGN_TMP_MAKE_RO)
615 {
616 LLVMBasicBlockRef b_notnull;
617 LLVMValueRef v_params[1];
618
619 b_notnull = l_bb_before_v(opblocks[opno + 1],
620 "op.%d.assign_tmp.notnull", opno);
621
622 /* check if value is NULL */
623 LLVMBuildCondBr(b,
624 LLVMBuildICmp(b, LLVMIntEQ, v_isnull,
625 l_sbool_const(0), ""),
626 b_notnull, opblocks[opno + 1]);
627
628 /* if value is not null, convert to RO datum */
629 LLVMPositionBuilderAtEnd(b, b_notnull);
630 v_params[0] = v_value;
631 v_value =
632 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 LLVMBuildStore(b, v_value, v_rvaluep);
645
646 LLVMBuildBr(b, opblocks[opno + 1]);
647 break;
648 }
649
650 case EEOP_CONST:
651 {
652 LLVMValueRef v_constvalue,
653 v_constnull;
654
655 v_constvalue = l_datum_const(op->d.constval.value);
656 v_constnull = l_sbool_const(op->d.constval.isnull);
657
658 LLVMBuildStore(b, v_constvalue, v_resvaluep);
659 LLVMBuildStore(b, v_constnull, v_resnullp);
660
661 LLVMBuildBr(b, opblocks[opno + 1]);
662 break;
663 }
664
665 case EEOP_FUNCEXPR:
666 case EEOP_FUNCEXPR_STRICT:
667 case EEOP_FUNCEXPR_STRICT_1:
668 case EEOP_FUNCEXPR_STRICT_2:
669 {
670 FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
671 LLVMValueRef v_fcinfo_isnull;
672 LLVMValueRef v_retval;
673
674 if (opcode == EEOP_FUNCEXPR_STRICT ||
675 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 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 if (op->d.func.nargs == 0)
691 elog(ERROR, "argumentless strict functions are pointless");
692
693 v_fcinfo =
694 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 LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
701
702 /* create blocks for checking args, one for each */
703 b_checkargnulls = (LLVMBasicBlockRef *)
704 palloc(sizeof(LLVMBasicBlockRef) * op->d.func.nargs);
705 for (int argno = 0; argno < op->d.func.nargs; argno++)
706 b_checkargnulls[argno] =
707 l_bb_before_v(b_nonull, "b.%d.isnull.%d", opno,
708 argno);
709
710 /* jump to check of first argument */
711 LLVMBuildBr(b, b_checkargnulls[0]);
712
713 /* check each arg for NULLness */
714 for (int argno = 0; argno < op->d.func.nargs; argno++)
715 {
716 LLVMValueRef v_argisnull;
717 LLVMBasicBlockRef b_argnotnull;
718
719 LLVMPositionBuilderAtEnd(b, b_checkargnulls[argno]);
720
721 /*
722 * Compute block to jump to if argument is not
723 * null.
724 */
725 if (argno + 1 == op->d.func.nargs)
726 b_argnotnull = b_nonull;
727 else
728 b_argnotnull = b_checkargnulls[argno + 1];
729
730 /* and finally load & check NULLness of arg */
731 v_argisnull = l_funcnull(b, v_fcinfo, argno);
732 LLVMBuildCondBr(b,
733 LLVMBuildICmp(b, LLVMIntEQ,
734 v_argisnull,
735 l_sbool_const(1),
736 ""),
737 opblocks[opno + 1],
738 b_argnotnull);
739 }
740
741 LLVMPositionBuilderAtEnd(b, b_nonull);
742 }
743
744 v_retval = BuildV1Call(context, b, mod, fcinfo,
745 &v_fcinfo_isnull);
746 LLVMBuildStore(b, v_retval, v_resvaluep);
747 LLVMBuildStore(b, v_fcinfo_isnull, v_resnullp);
748
749 LLVMBuildBr(b, opblocks[opno + 1]);
750 break;
751 }
752
753 case EEOP_FUNCEXPR_FUSAGE:
754 build_EvalXFunc(b, mod, "ExecEvalFuncExprFusage",
755 v_state, op, v_econtext);
756 LLVMBuildBr(b, opblocks[opno + 1]);
757 break;
758
759
760 case EEOP_FUNCEXPR_STRICT_FUSAGE:
761 build_EvalXFunc(b, mod, "ExecEvalFuncExprStrictFusage",
762 v_state, op, v_econtext);
763 LLVMBuildBr(b, opblocks[opno + 1]);
764 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 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 b_boolisnull = l_bb_before_v(opblocks[opno + 1],
786 "b.%d.boolisnull", opno);
787 b_boolcheckfalse = l_bb_before_v(opblocks[opno + 1],
788 "b.%d.boolcheckfalse", opno);
789 b_boolisfalse = l_bb_before_v(opblocks[opno + 1],
790 "b.%d.boolisfalse", opno);
791 b_boolisanynull = l_bb_before_v(opblocks[opno + 1],
792 "b.%d.boolisanynull", opno);
793 b_boolcont = l_bb_before_v(opblocks[opno + 1],
794 "b.%d.boolcont", opno);
795
796 v_boolanynullp = l_ptr_const(op->d.boolexpr.anynull,
797 l_ptr(TypeStorageBool));
798
799 if (opcode == EEOP_BOOL_AND_STEP_FIRST)
800 LLVMBuildStore(b, l_sbool_const(0), v_boolanynullp);
801
802 v_boolnull = l_load(b, TypeStorageBool, v_resnullp, "");
803 v_boolvalue = l_load(b, TypeDatum, v_resvaluep, "");
804
805 /* check if current input is NULL */
806 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 LLVMPositionBuilderAtEnd(b, b_boolisnull);
814 /* set boolanynull to true */
815 LLVMBuildStore(b, l_sbool_const(1), v_boolanynullp);
816 /* and jump to next block */
817 LLVMBuildBr(b, b_boolcont);
818
819 /* build block checking for false */
820 LLVMPositionBuilderAtEnd(b, b_boolcheckfalse);
821 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 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 LLVMBuildBr(b, opblocks[op->d.boolexpr.jumpdone]);
835
836 /* Build block that continues if bool is TRUE. */
837 LLVMPositionBuilderAtEnd(b, b_boolcont);
838
839 v_boolanynull = l_load(b, TypeStorageBool, v_boolanynullp, "");
840
841 /* set value to NULL if any previous values were NULL */
842 LLVMBuildCondBr(b,
843 LLVMBuildICmp(b, LLVMIntEQ, v_boolanynull,
844 l_sbool_const(0), ""),
845 opblocks[opno + 1], b_boolisanynull);
846
847 LLVMPositionBuilderAtEnd(b, b_boolisanynull);
848 /* set resnull to true */
849 LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
850 /* reset resvalue */
851 LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
852
853 LLVMBuildBr(b, opblocks[opno + 1]);
854 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 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 b_boolisnull = l_bb_before_v(opblocks[opno + 1],
878 "b.%d.boolisnull", opno);
879 b_boolchecktrue = l_bb_before_v(opblocks[opno + 1],
880 "b.%d.boolchecktrue", opno);
881 b_boolistrue = l_bb_before_v(opblocks[opno + 1],
882 "b.%d.boolistrue", opno);
883 b_boolisanynull = l_bb_before_v(opblocks[opno + 1],
884 "b.%d.boolisanynull", opno);
885 b_boolcont = l_bb_before_v(opblocks[opno + 1],
886 "b.%d.boolcont", opno);
887
888 v_boolanynullp = l_ptr_const(op->d.boolexpr.anynull,
889 l_ptr(TypeStorageBool));
890
891 if (opcode == EEOP_BOOL_OR_STEP_FIRST)
892 LLVMBuildStore(b, l_sbool_const(0), v_boolanynullp);
893 v_boolnull = l_load(b, TypeStorageBool, v_resnullp, "");
894 v_boolvalue = l_load(b, TypeDatum, v_resvaluep, "");
895
896 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 LLVMPositionBuilderAtEnd(b, b_boolisnull);
904 /* set boolanynull to true */
905 LLVMBuildStore(b, l_sbool_const(1), v_boolanynullp);
906 /* and jump to next block */
907 LLVMBuildBr(b, b_boolcont);
908
909 /* build block checking for true */
910 LLVMPositionBuilderAtEnd(b, b_boolchecktrue);
911 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 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 LLVMBuildBr(b, opblocks[op->d.boolexpr.jumpdone]);
925
926 /* build block that continues if bool is FALSE */
927 LLVMPositionBuilderAtEnd(b, b_boolcont);
928
929 v_boolanynull = l_load(b, TypeStorageBool, v_boolanynullp, "");
930
931 /* set value to NULL if any previous values were NULL */
932 LLVMBuildCondBr(b,
933 LLVMBuildICmp(b, LLVMIntEQ, v_boolanynull,
934 l_sbool_const(0), ""),
935 opblocks[opno + 1], b_boolisanynull);
936
937 LLVMPositionBuilderAtEnd(b, b_boolisanynull);
938 /* set resnull to true */
939 LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
940 /* reset resvalue */
941 LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
942
943 LLVMBuildBr(b, opblocks[opno + 1]);
944 break;
945 }
946
947 case EEOP_BOOL_NOT_STEP:
948 {
949 LLVMValueRef v_boolvalue;
950 LLVMValueRef v_negbool;
951
952 /* compute !boolvalue */
953 v_boolvalue = l_load(b, TypeDatum, v_resvaluep, "");
954 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 LLVMBuildStore(b, v_negbool, v_resvaluep);
967
968 LLVMBuildBr(b, opblocks[opno + 1]);
969 break;
970 }
971
972 case EEOP_QUAL:
973 {
974 LLVMValueRef v_resnull;
975 LLVMValueRef v_resvalue;
976 LLVMValueRef v_nullorfalse;
977 LLVMBasicBlockRef b_qualfail;
978
979 b_qualfail = l_bb_before_v(opblocks[opno + 1],
980 "op.%d.qualfail", opno);
981
982 v_resvalue = l_load(b, TypeDatum, v_resvaluep, "");
983 v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
984
985 v_nullorfalse =
986 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 LLVMBuildCondBr(b,
994 v_nullorfalse,
995 b_qualfail,
996 opblocks[opno + 1]);
997
998 /* build block handling NULL or false */
999 LLVMPositionBuilderAtEnd(b, b_qualfail);
1000 /* set resnull to false */
1001 LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
1002 /* set resvalue to false */
1003 LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
1004 /* and jump out */
1005 LLVMBuildBr(b, opblocks[op->d.qualexpr.jumpdone]);
1006 break;
1007 }
1008
1009 case EEOP_JUMP:
1010 {
1011 LLVMBuildBr(b, opblocks[op->d.jump.jumpdone]);
1012 break;
1013 }
1014
1015 case EEOP_JUMP_IF_NULL:
1016 {
1017 LLVMValueRef v_resnull;
1018
1019 /* Transfer control if current result is null */
1020
1021 v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
1022
1023 LLVMBuildCondBr(b,
1024 LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
1025 l_sbool_const(1), ""),
1026 opblocks[op->d.jump.jumpdone],
1027 opblocks[opno + 1]);
1028 break;
1029 }
1030
1031 case EEOP_JUMP_IF_NOT_NULL:
1032 {
1033 LLVMValueRef v_resnull;
1034
1035 /* Transfer control if current result is non-null */
1036
1037 v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
1038
1039 LLVMBuildCondBr(b,
1040 LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
1041 l_sbool_const(0), ""),
1042 opblocks[op->d.jump.jumpdone],
1043 opblocks[opno + 1]);
1044 break;
1045 }
1046
1047
1048 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 v_resvalue = l_load(b, TypeDatum, v_resvaluep, "");
1057 v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
1058
1059 v_nullorfalse =
1060 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 LLVMBuildCondBr(b,
1068 v_nullorfalse,
1069 opblocks[op->d.jump.jumpdone],
1070 opblocks[opno + 1]);
1071 break;
1072 }
1073
1074 case EEOP_NULLTEST_ISNULL:
1075 {
1076 LLVMValueRef v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
1077 LLVMValueRef v_resvalue;
1078
1079 v_resvalue =
1080 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 LLVMBuildStore(b, v_resvalue, v_resvaluep);
1087 LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
1088
1089 LLVMBuildBr(b, opblocks[opno + 1]);
1090 break;
1091 }
1092
1093 case EEOP_NULLTEST_ISNOTNULL:
1094 {
1095 LLVMValueRef v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
1096 LLVMValueRef v_resvalue;
1097
1098 v_resvalue =
1099 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 LLVMBuildStore(b, v_resvalue, v_resvaluep);
1106 LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
1107
1108 LLVMBuildBr(b, opblocks[opno + 1]);
1109 break;
1110 }
1111
1112 case EEOP_NULLTEST_ROWISNULL:
1113 build_EvalXFunc(b, mod, "ExecEvalRowNull",
1114 v_state, op, v_econtext);
1115 LLVMBuildBr(b, opblocks[opno + 1]);
1116 break;
1117
1118 case EEOP_NULLTEST_ROWISNOTNULL:
1119 build_EvalXFunc(b, mod, "ExecEvalRowNotNull",
1120 v_state, op, v_econtext);
1121 LLVMBuildBr(b, opblocks[opno + 1]);
1122 break;
1123
1124 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 LLVMValueRef v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
1132
1133 b_isnull = l_bb_before_v(opblocks[opno + 1],
1134 "op.%d.isnull", opno);
1135 b_notnull = l_bb_before_v(opblocks[opno + 1],
1136 "op.%d.isnotnull", opno);
1137
1138 /* check if value is NULL */
1139 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 LLVMPositionBuilderAtEnd(b, b_isnull);
1146
1147 /* result is not null */
1148 LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
1149
1150 if (opcode == EEOP_BOOLTEST_IS_TRUE ||
1151 opcode == EEOP_BOOLTEST_IS_FALSE)
1152 {
1153 LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
1154 }
1155 else
1156 {
1157 LLVMBuildStore(b, l_datum_const(1), v_resvaluep);
1158 }
1159
1160 LLVMBuildBr(b, opblocks[opno + 1]);
1161
1162 LLVMPositionBuilderAtEnd(b, b_notnull);
1163
1164 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 l_load(b, TypeDatum, v_resvaluep, "");
1176
1177 v_value = LLVMBuildZExt(b,
1178 LLVMBuildICmp(b, LLVMIntEQ,
1179 v_value,
1180 l_datum_const(0),
1181 ""),
1182 TypeDatum, "");
1183 LLVMBuildStore(b, v_value, v_resvaluep);
1184 }
1185 LLVMBuildBr(b, opblocks[opno + 1]);
1186 break;
1187 }
1188
1189 case EEOP_PARAM_EXEC:
1190 build_EvalXFunc(b, mod, "ExecEvalParamExec",
1191 v_state, op, v_econtext);
1192 LLVMBuildBr(b, opblocks[opno + 1]);
1193 break;
1194
1195 case EEOP_PARAM_EXTERN:
1196 build_EvalXFunc(b, mod, "ExecEvalParamExtern",
1197 v_state, op, v_econtext);
1198 LLVMBuildBr(b, opblocks[opno + 1]);
1199 break;
1200
1201 case EEOP_PARAM_CALLBACK:
1202 {
1203 LLVMValueRef v_func;
1204 LLVMValueRef v_params[3];
1205
1206 v_func = l_ptr_const(op->d.cparam.paramfunc,
1207 llvm_pg_var_type("TypeExecEvalSubroutine"));
1208
1209 v_params[0] = v_state;
1210 v_params[1] = l_ptr_const(op, l_ptr(StructExprEvalStep));
1211 v_params[2] = v_econtext;
1212 l_call(b,
1213 LLVMGetFunctionType(ExecEvalSubroutineTemplate),
1214 v_func,
1215 v_params, lengthof(v_params), "");
1216
1217 LLVMBuildBr(b, opblocks[opno + 1]);
1218 break;
1219 }
1220
1221 case EEOP_PARAM_SET:
1222 build_EvalXFunc(b, mod, "ExecEvalParamSet",
1223 v_state, op, v_econtext);
1224 LLVMBuildBr(b, opblocks[opno + 1]);
1225 break;
1226
1227 case EEOP_SBSREF_SUBSCRIPTS:
1228 {
1229 int jumpdone = op->d.sbsref_subscript.jumpdone;
1230 LLVMValueRef v_func;
1231 LLVMValueRef v_params[3];
1232 LLVMValueRef v_ret;
1233
1234 v_func = l_ptr_const(op->d.sbsref_subscript.subscriptfunc,
1235 llvm_pg_var_type("TypeExecEvalBoolSubroutine"));
1236
1237 v_params[0] = v_state;
1238 v_params[1] = l_ptr_const(op, l_ptr(StructExprEvalStep));
1239 v_params[2] = v_econtext;
1240 v_ret = l_call(b,
1241 LLVMGetFunctionType(ExecEvalBoolSubroutineTemplate),
1242 v_func,
1243 v_params, lengthof(v_params), "");
1244 v_ret = LLVMBuildZExt(b, v_ret, TypeStorageBool, "");
1245
1246 LLVMBuildCondBr(b,
1247 LLVMBuildICmp(b, LLVMIntEQ, v_ret,
1248 l_sbool_const(1), ""),
1249 opblocks[opno + 1],
1250 opblocks[jumpdone]);
1251 break;
1252 }
1253
1254 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 v_func = l_ptr_const(op->d.sbsref.subscriptfunc,
1262 llvm_pg_var_type("TypeExecEvalSubroutine"));
1263
1264 v_params[0] = v_state;
1265 v_params[1] = l_ptr_const(op, l_ptr(StructExprEvalStep));
1266 v_params[2] = v_econtext;
1267 l_call(b,
1268 LLVMGetFunctionType(ExecEvalSubroutineTemplate),
1269 v_func,
1270 v_params, lengthof(v_params), "");
1271
1272 LLVMBuildBr(b, opblocks[opno + 1]);
1273 break;
1274 }
1275
1276 case EEOP_CASE_TESTVAL:
1277 {
1278 LLVMValueRef v_casevaluep,
1279 v_casevalue;
1280 LLVMValueRef v_casenullp,
1281 v_casenull;
1282
1283 v_casevaluep = l_ptr_const(op->d.casetest.value,
1284 l_ptr(TypeDatum));
1285 v_casenullp = l_ptr_const(op->d.casetest.isnull,
1286 l_ptr(TypeStorageBool));
1287
1288 v_casevalue = l_load(b, TypeDatum, v_casevaluep, "");
1289 v_casenull = l_load(b, TypeStorageBool, v_casenullp, "");
1290 LLVMBuildStore(b, v_casevalue, v_resvaluep);
1291 LLVMBuildStore(b, v_casenull, v_resnullp);
1292
1293 LLVMBuildBr(b, opblocks[opno + 1]);
1294 break;
1295 }
1296
1297 case EEOP_CASE_TESTVAL_EXT:
1298 {
1299 LLVMValueRef v_casevalue;
1300 LLVMValueRef v_casenull;
1301
1302 v_casevalue =
1303 l_load_struct_gep(b,
1304 StructExprContext,
1305 v_econtext,
1306 FIELDNO_EXPRCONTEXT_CASEDATUM, "");
1307 v_casenull =
1308 l_load_struct_gep(b,
1309 StructExprContext,
1310 v_econtext,
1311 FIELDNO_EXPRCONTEXT_CASENULL, "");
1312 LLVMBuildStore(b, v_casevalue, v_resvaluep);
1313 LLVMBuildStore(b, v_casenull, v_resnullp);
1314
1315 LLVMBuildBr(b, opblocks[opno + 1]);
1316 break;
1317 }
1318
1319 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 b_notnull = l_bb_before_v(opblocks[opno + 1],
1330 "op.%d.readonly.notnull", opno);
1331
1332 v_nullp = l_ptr_const(op->d.make_readonly.isnull,
1333 l_ptr(TypeStorageBool));
1334
1335 v_null = l_load(b, TypeStorageBool, v_nullp, "");
1336
1337 /* store null isnull value in result */
1338 LLVMBuildStore(b, v_null, v_resnullp);
1339
1340 /* check if value is NULL */
1341 LLVMBuildCondBr(b,
1342 LLVMBuildICmp(b, LLVMIntEQ, v_null,
1343 l_sbool_const(1), ""),
1344 opblocks[opno + 1], b_notnull);
1345
1346 /* if value is not null, convert to RO datum */
1347 LLVMPositionBuilderAtEnd(b, b_notnull);
1348
1349 v_valuep = l_ptr_const(op->d.make_readonly.value,
1350 l_ptr(TypeDatum));
1351
1352 v_value = l_load(b, TypeDatum, v_valuep, "");
1353
1354 v_params[0] = v_value;
1355 v_ret =
1356 l_call(b,
1357 llvm_pg_var_func_type("MakeExpandedObjectReadOnlyInternal"),
1358 llvm_pg_func(mod, "MakeExpandedObjectReadOnlyInternal"),
1359 v_params, lengthof(v_params), "");
1360 LLVMBuildStore(b, v_ret, v_resvaluep);
1361
1362 LLVMBuildBr(b, opblocks[opno + 1]);
1363 break;
1364 }
1365
1366 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 fcinfo_out = op->d.iocoerce.fcinfo_data_out;
1388 fcinfo_in = op->d.iocoerce.fcinfo_data_in;
1389
1390 b_skipoutput = l_bb_before_v(opblocks[opno + 1],
1391 "op.%d.skipoutputnull", opno);
1392 b_calloutput = l_bb_before_v(opblocks[opno + 1],
1393 "op.%d.calloutput", opno);
1394 b_input = l_bb_before_v(opblocks[opno + 1],
1395 "op.%d.input", opno);
1396 b_inputcall = l_bb_before_v(opblocks[opno + 1],
1397 "op.%d.inputcall", opno);
1398
1399 v_fn_out = llvm_function_reference(context, b, mod, fcinfo_out);
1400 v_fn_in = llvm_function_reference(context, b, mod, fcinfo_in);
1401 v_fcinfo_out = l_ptr_const(fcinfo_out, l_ptr(StructFunctionCallInfoData));
1402 v_fcinfo_in = l_ptr_const(fcinfo_in, l_ptr(StructFunctionCallInfoData));
1403
1404 v_fcinfo_in_isnullp =
1405 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 v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
1413 LLVMBuildCondBr(b,
1414 LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
1415 l_sbool_const(1), ""),
1416 b_skipoutput,
1417 b_calloutput);
1418
1419 LLVMPositionBuilderAtEnd(b, b_skipoutput);
1420 v_output_skip = l_datum_const(0);
1421 LLVMBuildBr(b, b_input);
1422
1423 LLVMPositionBuilderAtEnd(b, b_calloutput);
1424 v_resvalue = l_load(b, TypeDatum, v_resvaluep, "");
1425
1426 /* set arg[0] */
1427 LLVMBuildStore(b,
1428 v_resvalue,
1429 l_funcvaluep(b, v_fcinfo_out, 0));
1430 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 v_output = l_call(b,
1435 LLVMGetFunctionType(v_fn_out),
1436 v_fn_out, &v_fcinfo_out,
1437 1, "funccall_coerce_out");
1438 LLVMBuildBr(b, b_input);
1439
1440 /* build block handling input function call */
1441 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 incoming_values[0] = v_output_skip;
1449 incoming_blocks[0] = b_skipoutput;
1450
1451 incoming_values[1] = v_output;
1452 incoming_blocks[1] = b_calloutput;
1453
1454 v_output = LLVMBuildPhi(b, TypeDatum, "output");
1455 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 if (op->d.iocoerce.finfo_in->fn_strict)
1465 {
1466 LLVMBuildCondBr(b,
1467 LLVMBuildICmp(b, LLVMIntEQ, v_output,
1468 l_datum_const(0), ""),
1469 opblocks[opno + 1],
1470 b_inputcall);
1471 }
1472 else
1473 {
1474 LLVMBuildBr(b, b_inputcall);
1475 }
1476
1477 LLVMPositionBuilderAtEnd(b, b_inputcall);
1478 /* set arguments */
1479 /* arg0: output */
1480 LLVMBuildStore(b, v_output,
1481 l_funcvaluep(b, v_fcinfo_in, 0));
1482 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 LLVMBuildStore(b, l_sbool_const(0), v_fcinfo_in_isnullp);
1490 /* and call function */
1491 v_retval = l_call(b,
1492 LLVMGetFunctionType(v_fn_in),
1493 v_fn_in, &v_fcinfo_in, 1,
1494 "funccall_iocoerce_in");
1495
1496 LLVMBuildStore(b, v_retval, v_resvaluep);
1497
1498 LLVMBuildBr(b, opblocks[opno + 1]);
1499 break;
1500 }
1501
1502 case EEOP_IOCOERCE_SAFE:
1503 build_EvalXFunc(b, mod, "ExecEvalCoerceViaIOSafe",
1504 v_state, op);
1505 LLVMBuildBr(b, opblocks[opno + 1]);
1506 break;
1507
1508 case EEOP_DISTINCT:
1509 case EEOP_NOT_DISTINCT:
1510 {
1511 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 b_noargnull = l_bb_before_v(opblocks[opno + 1], "op.%d.noargnull", opno);
1532 b_checkbothargnull = l_bb_before_v(opblocks[opno + 1], "op.%d.checkbothargnull", opno);
1533 b_bothargnull = l_bb_before_v(opblocks[opno + 1], "op.%d.bothargnull", opno);
1534 b_anyargnull = l_bb_before_v(opblocks[opno + 1], "op.%d.anyargnull", opno);
1535
1536 v_fcinfo = l_ptr_const(fcinfo, l_ptr(StructFunctionCallInfoData));
1537
1538 /* load args[0|1].isnull for both arguments */
1539 v_argnull0 = l_funcnull(b, v_fcinfo, 0);
1540 v_argisnull0 = LLVMBuildICmp(b, LLVMIntEQ, v_argnull0,
1541 l_sbool_const(1), "");
1542 v_argnull1 = l_funcnull(b, v_fcinfo, 1);
1543 v_argisnull1 = LLVMBuildICmp(b, LLVMIntEQ, v_argnull1,
1544 l_sbool_const(1), "");
1545
1546 v_anyargisnull = LLVMBuildOr(b, v_argisnull0, v_argisnull1, "");
1547 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 LLVMBuildCondBr(b, v_anyargisnull, b_checkbothargnull,
1555 b_noargnull);
1556
1557 /*
1558 * build block checking if any arg is null
1559 */
1560 LLVMPositionBuilderAtEnd(b, b_checkbothargnull);
1561 LLVMBuildCondBr(b, v_bothargisnull, b_bothargnull,
1562 b_anyargnull);
1563
1564
1565 /* Both NULL? Then is not distinct... */
1566 LLVMPositionBuilderAtEnd(b, b_bothargnull);
1567 LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
1568 if (opcode == EEOP_NOT_DISTINCT)
1569 LLVMBuildStore(b, l_datum_const(1), v_resvaluep);
1570 else
1571 LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
1572
1573 LLVMBuildBr(b, opblocks[opno + 1]);
1574
1575 /* Only one is NULL? Then is distinct... */
1576 LLVMPositionBuilderAtEnd(b, b_anyargnull);
1577 LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
1578 if (opcode == EEOP_NOT_DISTINCT)
1579 LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
1580 else
1581 LLVMBuildStore(b, l_datum_const(1), v_resvaluep);
1582 LLVMBuildBr(b, opblocks[opno + 1]);
1583
1584 /* neither argument is null: compare */
1585 LLVMPositionBuilderAtEnd(b, b_noargnull);
1586
1587 v_result = BuildV1Call(context, b, mod, fcinfo,
1588 &v_fcinfo_isnull);
1589
1590 if (opcode == EEOP_DISTINCT)
1591 {
1592 /* Must invert result of "=" */
1593 v_result =
1594 LLVMBuildZExt(b,
1595 LLVMBuildICmp(b, LLVMIntEQ,
1596 v_result,
1597 l_datum_const(0), ""),
1598 TypeDatum, "");
1599 }
1600
1601 LLVMBuildStore(b, v_fcinfo_isnull, v_resnullp);
1602 LLVMBuildStore(b, v_result, v_resvaluep);
1603
1604 LLVMBuildBr(b, opblocks[opno + 1]);
1605 break;
1606 }
1607
1608 case EEOP_NULLIF:
1609 {
1610 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 b_hasnull = l_bb_before_v(opblocks[opno + 1],
1625 "b.%d.null-args", opno);
1626 b_nonull = l_bb_before_v(opblocks[opno + 1],
1627 "b.%d.no-null-args", opno);
1628 b_argsequal = l_bb_before_v(opblocks[opno + 1],
1629 "b.%d.argsequal", opno);
1630
1631 v_fcinfo = l_ptr_const(fcinfo, l_ptr(StructFunctionCallInfoData));
1632
1633 /* save original arg[0] */
1634 v_arg0 = l_funcvalue(b, v_fcinfo, 0);
1635
1636 /* if either argument is NULL they can't be equal */
1637 v_argnull0 = l_funcnull(b, v_fcinfo, 0);
1638 v_argnull1 = l_funcnull(b, v_fcinfo, 1);
1639
1640 v_anyargisnull =
1641 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 LLVMBuildCondBr(b, v_anyargisnull, b_hasnull, b_nonull);
1649
1650 /* one (or both) of the arguments are null, return arg[0] */
1651 LLVMPositionBuilderAtEnd(b, b_hasnull);
1652 LLVMBuildStore(b, v_argnull0, v_resnullp);
1653 LLVMBuildStore(b, v_arg0, v_resvaluep);
1654 LLVMBuildBr(b, opblocks[opno + 1]);
1655
1656 /* build block to invoke function and check result */
1657 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 if (op->d.func.make_ro)
1668 {
1669 LLVMValueRef v_params[1];
1670 LLVMValueRef v_arg0_ro;
1671
1672 v_params[0] = v_arg0;
1673 v_arg0_ro =
1674 l_call(b,
1675 llvm_pg_var_func_type("MakeExpandedObjectReadOnlyInternal"),
1676 llvm_pg_func(mod, "MakeExpandedObjectReadOnlyInternal"),
1677 v_params, lengthof(v_params), "");
1678 LLVMBuildStore(b, v_arg0_ro,
1679 l_funcvaluep(b, v_fcinfo, 0));
1680 }
1681
1682 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 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 LLVMBuildCondBr(b, v_argsequal, b_argsequal, b_hasnull);
1700
1701 /* build block setting result to NULL, if args are equal */
1702 LLVMPositionBuilderAtEnd(b, b_argsequal);
1703 LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
1704 LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
1705
1706 LLVMBuildBr(b, opblocks[opno + 1]);
1707 break;
1708 }
1709
1710 case EEOP_SQLVALUEFUNCTION:
1711 build_EvalXFunc(b, mod, "ExecEvalSQLValueFunction",
1712 v_state, op);
1713 LLVMBuildBr(b, opblocks[opno + 1]);
1714 break;
1715
1716 case EEOP_CURRENTOFEXPR:
1717 build_EvalXFunc(b, mod, "ExecEvalCurrentOfExpr",
1718 v_state, op);
1719 LLVMBuildBr(b, opblocks[opno + 1]);
1720 break;
1721
1722 case EEOP_NEXTVALUEEXPR:
1723 build_EvalXFunc(b, mod, "ExecEvalNextValueExpr",
1724 v_state, op);
1725 LLVMBuildBr(b, opblocks[opno + 1]);
1726 break;
1727
1728 case EEOP_RETURNINGEXPR:
1729 {
1730 LLVMBasicBlockRef b_isnull;
1731 LLVMValueRef v_flagsp;
1732 LLVMValueRef v_flags;
1733 LLVMValueRef v_nullflag;
1734
1735 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 v_flagsp = l_struct_gep(b,
1743 StructExprState,
1744 v_state,
1745 FIELDNO_EXPRSTATE_FLAGS,
1746 "v.state.flags");
1747 v_flags = l_load(b, TypeStorageBool, v_flagsp, "");
1748
1749 v_nullflag = l_int8_const(lc, op->d.returningexpr.nullflag);
1750
1751 LLVMBuildCondBr(b,
1752 LLVMBuildICmp(b, LLVMIntEQ,
1753 LLVMBuildAnd(b, v_flags,
1754 v_nullflag, ""),
1755 l_sbool_const(0), ""),
1756 opblocks[opno + 1], b_isnull);
1757
1758 LLVMPositionBuilderAtEnd(b, b_isnull);
1759
1760 LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
1761 LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
1762
1763 LLVMBuildBr(b, opblocks[op->d.returningexpr.jumpdone]);
1764 break;
1765 }
1766
1767 case EEOP_ARRAYEXPR:
1768 build_EvalXFunc(b, mod, "ExecEvalArrayExpr",
1769 v_state, op);
1770 LLVMBuildBr(b, opblocks[opno + 1]);
1771 break;
1772
1773 case EEOP_ARRAYCOERCE:
1774 build_EvalXFunc(b, mod, "ExecEvalArrayCoerce",
1775 v_state, op, v_econtext);
1776 LLVMBuildBr(b, opblocks[opno + 1]);
1777 break;
1778
1779 case EEOP_ROW:
1780 build_EvalXFunc(b, mod, "ExecEvalRow",
1781 v_state, op);
1782 LLVMBuildBr(b, opblocks[opno + 1]);
1783 break;
1784
1785 case EEOP_ROWCOMPARE_STEP:
1786 {
1787 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 b_null = l_bb_before_v(opblocks[opno + 1],
1796 "op.%d.row-null", opno);
1797 b_compare = l_bb_before_v(opblocks[opno + 1],
1798 "op.%d.row-compare", opno);
1799 b_compare_result =
1800 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 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 v_fcinfo = l_ptr_const(fcinfo,
1816 l_ptr(StructFunctionCallInfoData));
1817
1818 v_argnull0 = l_funcnull(b, v_fcinfo, 0);
1819 v_argnull1 = l_funcnull(b, v_fcinfo, 1);
1820
1821 v_anyargisnull =
1822 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 LLVMBuildCondBr(b, v_anyargisnull, b_null, b_compare);
1834 }
1835 else
1836 {
1837 LLVMBuildBr(b, b_compare);
1838 }
1839
1840 /* build block invoking comparison function */
1841 LLVMPositionBuilderAtEnd(b, b_compare);
1842
1843 /* call function */
1844 v_retval = BuildV1Call(context, b, mod, fcinfo,
1845 &v_fcinfo_isnull);
1846 LLVMBuildStore(b, v_retval, v_resvaluep);
1847
1848 /* if result of function is NULL, force NULL result */
1849 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 LLVMPositionBuilderAtEnd(b, b_compare_result);
1860
1861 /* if results equal, compare next, otherwise done */
1862 LLVMBuildCondBr(b,
1863 LLVMBuildICmp(b,
1864 LLVMIntEQ,
1865 v_retval,
1866 l_datum_const(0), ""),
1867 opblocks[opno + 1],
1868 opblocks[op->d.rowcompare_step.jumpdone]);
1869
1870 /*
1871 * Build block handling NULL input or NULL comparator
1872 * result.
1873 */
1874 LLVMPositionBuilderAtEnd(b, b_null);
1875 LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
1876 LLVMBuildBr(b, opblocks[op->d.rowcompare_step.jumpnull]);
1877
1878 break;
1879 }
1880
1881 case EEOP_ROWCOMPARE_FINAL:
1882 {
1883 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 LLVMBuildTrunc(b,
1896 l_load(b, TypeDatum, v_resvaluep, ""),
1897 LLVMInt32TypeInContext(lc), "");
1898
1899 switch (cmptype)
1900 {
1901 case COMPARE_LT:
1902 predicate = LLVMIntSLT;
1903 break;
1904 case COMPARE_LE:
1905 predicate = LLVMIntSLE;
1906 break;
1907 case COMPARE_GT:
1908 predicate = LLVMIntSGT;
1909 break;
1910 case COMPARE_GE:
1911 predicate = LLVMIntSGE;
1912 break;
1913 default:
1914 /* EQ and NE cases aren't allowed here */
1915 Assert(false);
1916 predicate = 0; /* prevent compiler warning */
1917 break;
1918 }
1919
1920 v_result = LLVMBuildICmp(b,
1921 predicate,
1922 v_cmpresult,
1923 l_int32_const(lc, 0),
1924 "");
1925 v_result = LLVMBuildZExt(b, v_result, TypeDatum, "");
1926
1927 LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
1928 LLVMBuildStore(b, v_result, v_resvaluep);
1929
1930 LLVMBuildBr(b, opblocks[opno + 1]);
1931 break;
1932 }
1933
1934 case EEOP_MINMAX:
1935 build_EvalXFunc(b, mod, "ExecEvalMinMax",
1936 v_state, op);
1937 LLVMBuildBr(b, opblocks[opno + 1]);
1938 break;
1939
1940 case EEOP_FIELDSELECT:
1941 build_EvalXFunc(b, mod, "ExecEvalFieldSelect",
1942 v_state, op, v_econtext);
1943 LLVMBuildBr(b, opblocks[opno + 1]);
1944 break;
1945
1946 case EEOP_FIELDSTORE_DEFORM:
1947 build_EvalXFunc(b, mod, "ExecEvalFieldStoreDeForm",
1948 v_state, op, v_econtext);
1949 LLVMBuildBr(b, opblocks[opno + 1]);
1950 break;
1951
1952 case EEOP_FIELDSTORE_FORM:
1953 build_EvalXFunc(b, mod, "ExecEvalFieldStoreForm",
1954 v_state, op, v_econtext);
1955 LLVMBuildBr(b, opblocks[opno + 1]);
1956 break;
1957
1958 case EEOP_DOMAIN_TESTVAL:
1959 {
1960 LLVMValueRef v_casevaluep,
1961 v_casevalue;
1962 LLVMValueRef v_casenullp,
1963 v_casenull;
1964
1965 v_casevaluep = l_ptr_const(op->d.casetest.value,
1966 l_ptr(TypeDatum));
1967 v_casenullp = l_ptr_const(op->d.casetest.isnull,
1968 l_ptr(TypeStorageBool));
1969
1970 v_casevalue = l_load(b, TypeDatum, v_casevaluep, "");
1971 v_casenull = l_load(b, TypeStorageBool, v_casenullp, "");
1972 LLVMBuildStore(b, v_casevalue, v_resvaluep);
1973 LLVMBuildStore(b, v_casenull, v_resnullp);
1974
1975 LLVMBuildBr(b, opblocks[opno + 1]);
1976 break;
1977 }
1978
1979 case EEOP_DOMAIN_TESTVAL_EXT:
1980 {
1981 LLVMValueRef v_casevalue;
1982 LLVMValueRef v_casenull;
1983
1984 v_casevalue =
1985 l_load_struct_gep(b,
1986 StructExprContext,
1987 v_econtext,
1988 FIELDNO_EXPRCONTEXT_DOMAINDATUM,
1989 "");
1990 v_casenull =
1991 l_load_struct_gep(b,
1992 StructExprContext,
1993 v_econtext,
1994 FIELDNO_EXPRCONTEXT_DOMAINNULL,
1995 "");
1996 LLVMBuildStore(b, v_casevalue, v_resvaluep);
1997 LLVMBuildStore(b, v_casenull, v_resnullp);
1998
1999 LLVMBuildBr(b, opblocks[opno + 1]);
2000 break;
2001 }
2002
2003 case EEOP_DOMAIN_NOTNULL:
2004 build_EvalXFunc(b, mod, "ExecEvalConstraintNotNull",
2005 v_state, op);
2006 LLVMBuildBr(b, opblocks[opno + 1]);
2007 break;
2008
2009 case EEOP_DOMAIN_CHECK:
2010 build_EvalXFunc(b, mod, "ExecEvalConstraintCheck",
2011 v_state, op);
2012 LLVMBuildBr(b, opblocks[opno + 1]);
2013 break;
2014
2015 case EEOP_HASHDATUM_SET_INITVAL:
2016 {
2017 LLVMValueRef v_initvalue;
2018
2019 v_initvalue = l_datum_const(op->d.hashdatum_initvalue.init_value);
2020
2021 LLVMBuildStore(b, v_initvalue, v_resvaluep);
2022 LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
2023 LLVMBuildBr(b, opblocks[opno + 1]);
2024 break;
2025 }
2026
2027 case EEOP_HASHDATUM_FIRST:
2028 case EEOP_HASHDATUM_FIRST_STRICT:
2029 case EEOP_HASHDATUM_NEXT32:
2030 case EEOP_HASHDATUM_NEXT32_STRICT:
2031 {
2032 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 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 if (opcode == EEOP_HASHDATUM_NEXT32)
2052 {
2053 LLVMValueRef v_tmp1;
2054 LLVMValueRef v_tmp2;
2055 LLVMValueRef tmp;
2056
2057 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 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 v_tmp1 = LLVMBuildShl(b, v_prevhash, l_datum_const(1),
2071 "");
2072 v_tmp1 = LLVMBuildAnd(b, v_tmp1,
2073 l_datum_const(0xffffffff), "");
2074 v_tmp2 = LLVMBuildLShr(b, v_prevhash,
2075 l_datum_const(31), "");
2076 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 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 if (fcinfo->nargs != 1)
2090 elog(ERROR, "incorrect number of function arguments");
2091
2092 v_fcinfo = l_ptr_const(fcinfo,
2093 l_ptr(StructFunctionCallInfoData));
2094
2095 b_checkargnull = l_bb_before_v(b_ifnotnull,
2096 "b.%d.isnull.0", opno);
2097
2098 LLVMBuildBr(b, b_checkargnull);
2099
2100 /*
2101 * Determine what to do if we find the argument to be
2102 * NULL.
2103 */
2104 if (opcode == EEOP_HASHDATUM_FIRST_STRICT ||
2105 opcode == EEOP_HASHDATUM_NEXT32_STRICT)
2106 {
2107 b_ifnullblock = l_bb_before_v(b_ifnotnull,
2108 "b.%d.strictnull",
2109 opno);
2110
2111 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 LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
2118 LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
2119 LLVMBuildBr(b, opblocks[op->d.hashdatum.jumpdone]);
2120 }
2121 else
2122 {
2123 b_ifnullblock = l_bb_before_v(b_ifnotnull,
2124 "b.%d.null",
2125 opno);
2126
2127 LLVMPositionBuilderAtEnd(b, b_ifnullblock);
2128
2129
2130 LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
2131
2132 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 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 LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
2151 }
2152
2153 LLVMBuildBr(b, opblocks[opno + 1]);
2154 }
2155
2156 LLVMPositionBuilderAtEnd(b, b_checkargnull);
2157
2158 /* emit code to check if the input parameter is NULL */
2159 v_argisnull = l_funcnull(b, v_fcinfo, 0);
2160 LLVMBuildCondBr(b,
2161 LLVMBuildICmp(b,
2162 LLVMIntEQ,
2163 v_argisnull,
2164 l_sbool_const(1),
2165 ""),
2166 b_ifnullblock,
2167 b_ifnotnull);
2168
2169 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 if (opcode == EEOP_HASHDATUM_NEXT32_STRICT)
2177 {
2178 LLVMValueRef v_tmp1;
2179 LLVMValueRef v_tmp2;
2180 LLVMValueRef tmp;
2181
2182 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 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 v_tmp1 = LLVMBuildShl(b, v_prevhash, l_datum_const(1),
2196 "");
2197 v_tmp1 = LLVMBuildAnd(b, v_tmp1,
2198 l_datum_const(0xffffffff), "");
2199 v_tmp2 = LLVMBuildLShr(b, v_prevhash,
2200 l_datum_const(31), "");
2201 v_prevhash = LLVMBuildOr(b, v_tmp1, v_tmp2,
2202 "rotatedhash");
2203 }
2204
2205 /* call the hash function */
2206 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 if (opcode == EEOP_HASHDATUM_NEXT32 ||
2214 opcode == EEOP_HASHDATUM_NEXT32_STRICT)
2215 v_retval = LLVMBuildXor(b, v_prevhash, v_retval,
2216 "xorhash");
2217
2218 LLVMBuildStore(b, v_retval, v_resvaluep);
2219 LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
2220
2221 LLVMBuildBr(b, opblocks[opno + 1]);
2222 break;
2223 }
2224
2225 case EEOP_CONVERT_ROWTYPE:
2226 build_EvalXFunc(b, mod, "ExecEvalConvertRowtype",
2227 v_state, op, v_econtext);
2228 LLVMBuildBr(b, opblocks[opno + 1]);
2229 break;
2230
2231 case EEOP_SCALARARRAYOP:
2232 build_EvalXFunc(b, mod, "ExecEvalScalarArrayOp",
2233 v_state, op);
2234 LLVMBuildBr(b, opblocks[opno + 1]);
2235 break;
2236
2237 case EEOP_HASHED_SCALARARRAYOP:
2238 build_EvalXFunc(b, mod, "ExecEvalHashedScalarArrayOp",
2239 v_state, op, v_econtext);
2240 LLVMBuildBr(b, opblocks[opno + 1]);
2241 break;
2242
2243 case EEOP_XMLEXPR:
2244 build_EvalXFunc(b, mod, "ExecEvalXmlExpr",
2245 v_state, op);
2246 LLVMBuildBr(b, opblocks[opno + 1]);
2247 break;
2248
2249 case EEOP_JSON_CONSTRUCTOR:
2250 build_EvalXFunc(b, mod, "ExecEvalJsonConstructor",
2251 v_state, op, v_econtext);
2252 LLVMBuildBr(b, opblocks[opno + 1]);
2253 break;
2254
2255 case EEOP_IS_JSON:
2256 build_EvalXFunc(b, mod, "ExecEvalJsonIsPredicate",
2257 v_state, op);
2258 LLVMBuildBr(b, opblocks[opno + 1]);
2259 break;
2260
2261 case EEOP_JSONEXPR_PATH:
2262 {
2263 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 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 if (jsestate->jump_empty >= 0 ||
2280 jsestate->jump_error >= 0 ||
2281 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 l_bb_before_v(opblocks[opno + 1],
2294 "op.%d.jsonexpr_empty", opno);
2295 b_error =
2296 l_bb_before_v(opblocks[opno + 1],
2297 "op.%d.jsonexpr_error", opno);
2298 b_coercion =
2299 l_bb_before_v(opblocks[opno + 1],
2300 "op.%d.jsonexpr_coercion", opno);
2301 b_done =
2302 l_bb_before_v(opblocks[opno + 1],
2303 "op.%d.jsonexpr_done", opno);
2304
2305 v_switch = LLVMBuildSwitch(b,
2306 v_ret,
2307 b_done,
2308 3);
2309 /* Returned jsestate->jump_empty? */
2310 if (jsestate->jump_empty >= 0)
2311 {
2312 v_jump_empty = l_int32_const(lc, jsestate->jump_empty);
2313 LLVMAddCase(v_switch, v_jump_empty, b_empty);
2314 }
2315 /* ON EMPTY code */
2316 LLVMPositionBuilderAtEnd(b, b_empty);
2317 if (jsestate->jump_empty >= 0)
2318 LLVMBuildBr(b, opblocks[jsestate->jump_empty]);
2319 else
2320 LLVMBuildUnreachable(b);
2321
2322 /* Returned jsestate->jump_error? */
2323 if (jsestate->jump_error >= 0)
2324 {
2325 v_jump_error = l_int32_const(lc, jsestate->jump_error);
2326 LLVMAddCase(v_switch, v_jump_error, b_error);
2327 }
2328 /* ON ERROR code */
2329 LLVMPositionBuilderAtEnd(b, b_error);
2330 if (jsestate->jump_error >= 0)
2331 LLVMBuildBr(b, opblocks[jsestate->jump_error]);
2332 else
2333 LLVMBuildUnreachable(b);
2334
2335 /* Returned jsestate->jump_eval_coercion? */
2336 if (jsestate->jump_eval_coercion >= 0)
2337 {
2338 v_jump_coercion = l_int32_const(lc, jsestate->jump_eval_coercion);
2339 LLVMAddCase(v_switch, v_jump_coercion, b_coercion);
2340 }
2341 /* jump_eval_coercion code */
2342 LLVMPositionBuilderAtEnd(b, b_coercion);
2343 if (jsestate->jump_eval_coercion >= 0)
2344 LLVMBuildBr(b, opblocks[jsestate->jump_eval_coercion]);
2345 else
2346 LLVMBuildUnreachable(b);
2347
2348 LLVMPositionBuilderAtEnd(b, b_done);
2349 }
2350
2351 LLVMBuildBr(b, opblocks[jsestate->jump_end]);
2352 break;
2353 }
2354
2355 case EEOP_JSONEXPR_COERCION:
2356 build_EvalXFunc(b, mod, "ExecEvalJsonCoercion",
2357 v_state, op, v_econtext);
2358
2359 LLVMBuildBr(b, opblocks[opno + 1]);
2360 break;
2361
2362 case EEOP_JSONEXPR_COERCION_FINISH:
2363 build_EvalXFunc(b, mod, "ExecEvalJsonCoercionFinish",
2364 v_state, op);
2365
2366 LLVMBuildBr(b, opblocks[opno + 1]);
2367 break;
2368
2369 case EEOP_AGGREF:
2370 {
2371 LLVMValueRef v_aggno;
2372 LLVMValueRef value,
2373 isnull;
2374
2375 v_aggno = l_int32_const(lc, op->d.aggref.aggno);
2376
2377 /* load agg value / null */
2378 value = l_load_gep1(b, TypeDatum, v_aggvalues, v_aggno, "aggvalue");
2379 isnull = l_load_gep1(b, TypeStorageBool, v_aggnulls, v_aggno, "aggnull");
2380
2381 /* and store result */
2382 LLVMBuildStore(b, value, v_resvaluep);
2383 LLVMBuildStore(b, isnull, v_resnullp);
2384
2385 LLVMBuildBr(b, opblocks[opno + 1]);
2386 break;
2387 }
2388
2389 case EEOP_GROUPING_FUNC:
2390 build_EvalXFunc(b, mod, "ExecEvalGroupingFunc",
2391 v_state, op);
2392 LLVMBuildBr(b, opblocks[opno + 1]);
2393 break;
2394
2395 case EEOP_WINDOW_FUNC:
2396 {
2397 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 v_wfuncnop = l_ptr_const(&wfunc->wfuncno,
2409 l_ptr(LLVMInt32TypeInContext(lc)));
2410 v_wfuncno = l_load(b, LLVMInt32TypeInContext(lc), v_wfuncnop, "v_wfuncno");
2411
2412 /* load window func value / null */
2413 value = l_load_gep1(b, TypeDatum, v_aggvalues, v_wfuncno,
2414 "windowvalue");
2415 isnull = l_load_gep1(b, TypeStorageBool, v_aggnulls, v_wfuncno,
2416 "windownull");
2417
2418 LLVMBuildStore(b, value, v_resvaluep);
2419 LLVMBuildStore(b, isnull, v_resnullp);
2420
2421 LLVMBuildBr(b, opblocks[opno + 1]);
2422 break;
2423 }
2424
2425 case EEOP_MERGE_SUPPORT_FUNC:
2426 build_EvalXFunc(b, mod, "ExecEvalMergeSupportFunc",
2427 v_state, op, v_econtext);
2428 LLVMBuildBr(b, opblocks[opno + 1]);
2429 break;
2430
2431 case EEOP_SUBPLAN:
2432 build_EvalXFunc(b, mod, "ExecEvalSubPlan",
2433 v_state, op, v_econtext);
2434 LLVMBuildBr(b, opblocks[opno + 1]);
2435 break;
2436
2437 case EEOP_AGG_STRICT_DESERIALIZE:
2438 case EEOP_AGG_DESERIALIZE:
2439 {
2440 AggState *aggstate;
2441 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 if (opcode == EEOP_AGG_STRICT_DESERIALIZE)
2449 {
2450 LLVMValueRef v_fcinfo;
2451 LLVMValueRef v_argnull0;
2452 LLVMBasicBlockRef b_deserialize;
2453
2454 b_deserialize = l_bb_before_v(opblocks[opno + 1],
2455 "op.%d.deserialize", opno);
2456
2457 v_fcinfo = l_ptr_const(fcinfo,
2458 l_ptr(StructFunctionCallInfoData));
2459 v_argnull0 = l_funcnull(b, v_fcinfo, 0);
2460
2461 LLVMBuildCondBr(b,
2462 LLVMBuildICmp(b,
2463 LLVMIntEQ,
2464 v_argnull0,
2465 l_sbool_const(1),
2466 ""),
2467 opblocks[op->d.agg_deserialize.jumpnull],
2468 b_deserialize);
2469 LLVMPositionBuilderAtEnd(b, b_deserialize);
2470 }
2471
2472 aggstate = castNode(AggState, state->parent);
2473 fcinfo = op->d.agg_deserialize.fcinfo_data;
2474
2475 v_tmpcontext =
2476 l_ptr_const(aggstate->tmpcontext->ecxt_per_tuple_memory,
2477 l_ptr(StructMemoryContextData));
2478 v_oldcontext = l_mcxt_switch(mod, b, v_tmpcontext);
2479 v_retval = BuildV1Call(context, b, mod, fcinfo,
2480 &v_fcinfo_isnull);
2481 l_mcxt_switch(mod, b, v_oldcontext);
2482
2483 LLVMBuildStore(b, v_retval, v_resvaluep);
2484 LLVMBuildStore(b, v_fcinfo_isnull, v_resnullp);
2485
2486 LLVMBuildBr(b, opblocks[opno + 1]);
2487 break;
2488 }
2489
2490 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 int nargs = op->d.agg_strict_input_check.nargs;
2495 NullableDatum *args = op->d.agg_strict_input_check.args;
2496 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 jumpnull = op->d.agg_strict_input_check.jumpnull;
2506 v_argsp = l_ptr_const(args, l_ptr(StructNullableDatum));
2507 v_nullsp = l_ptr_const(nulls, l_ptr(TypeStorageBool));
2508
2509 /* create blocks for checking args */
2510 b_checknulls = palloc_array(LLVMBasicBlockRef, nargs);
2511 for (int argno = 0; argno < nargs; argno++)
2512 {
2513 b_checknulls[argno] =
2514 l_bb_before_v(opblocks[opno + 1],
2515 "op.%d.check-null.%d",
2516 opno, argno);
2517 }
2518
2519 LLVMBuildBr(b, b_checknulls[0]);
2520
2521 /* strict function, check for NULL args */
2522 for (int argno = 0; argno < nargs; argno++)
2523 {
2524 LLVMValueRef v_argno = l_int32_const(lc, argno);
2525 LLVMValueRef v_argisnull;
2526 LLVMBasicBlockRef b_argnotnull;
2527
2528 LLVMPositionBuilderAtEnd(b, b_checknulls[argno]);
2529
2530 if (argno + 1 == nargs)
2531 b_argnotnull = opblocks[opno + 1];
2532 else
2533 b_argnotnull = b_checknulls[argno + 1];
2534
2535 if (opcode == EEOP_AGG_STRICT_INPUT_CHECK_NULLS)
2536 v_argisnull = l_load_gep1(b, TypeStorageBool, v_nullsp, v_argno, "");
2537 else
2538 {
2539 LLVMValueRef v_argn;
2540
2541 v_argn = l_gep(b, StructNullableDatum, v_argsp, &v_argno, 1, "");
2542 v_argisnull =
2543 l_load_struct_gep(b, StructNullableDatum, v_argn,
2544 FIELDNO_NULLABLE_DATUM_ISNULL,
2545 "");
2546 }
2547
2548 LLVMBuildCondBr(b,
2549 LLVMBuildICmp(b,
2550 LLVMIntEQ,
2551 v_argisnull,
2552 l_sbool_const(1), ""),
2553 opblocks[jumpnull],
2554 b_argnotnull);
2555 }
2556
2557 break;
2558 }
2559
2560 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 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 v_aggstatep = LLVMBuildBitCast(b, v_parent,
2575 l_ptr(StructAggState), "");
2576
2577 v_allpergroupsp = l_load_struct_gep(b,
2578 StructAggState,
2579 v_aggstatep,
2580 FIELDNO_AGGSTATE_ALL_PERGROUPS,
2581 "aggstate.all_pergroups");
2582
2583 v_setoff = l_int32_const(lc, op->d.agg_plain_pergroup_nullcheck.setoff);
2584
2585 v_pergroup_allaggs = l_load_gep1(b, l_ptr(StructAggStatePerGroupData),
2586 v_allpergroupsp, v_setoff, "");
2587
2588 LLVMBuildCondBr(b,
2589 LLVMBuildICmp(b, LLVMIntEQ,
2590 LLVMBuildPtrToInt(b, v_pergroup_allaggs, TypeDatum, ""),
2591 l_datum_const(0), ""),
2592 opblocks[jumpnull],
2593 opblocks[opno + 1]);
2594 break;
2595 }
2596
2597 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 aggstate = castNode(AggState, state->parent);
2635 pertrans = op->d.agg_trans.pertrans;
2636
2637 fcinfo = pertrans->transfn_fcinfo;
2638
2639 v_aggstatep =
2640 LLVMBuildBitCast(b, v_parent, l_ptr(StructAggState), "");
2641 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 l_load_struct_gep(b,
2650 StructAggState,
2651 v_aggstatep,
2652 FIELDNO_AGGSTATE_ALL_PERGROUPS,
2653 "aggstate.all_pergroups");
2654 v_setoff = l_int32_const(lc, op->d.agg_trans.setoff);
2655 v_transno = l_int32_const(lc, op->d.agg_trans.transno);
2656 v_pergroupp =
2657 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 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 l_load_struct_gep(b,
2673 StructAggStatePerGroupData,
2674 v_pergroupp,
2675 FIELDNO_AGGSTATEPERGROUPDATA_NOTRANSVALUE,
2676 "notransvalue");
2677
2678 b_init = l_bb_before_v(opblocks[opno + 1],
2679 "op.%d.inittrans", opno);
2680 b_no_init = l_bb_before_v(opblocks[opno + 1],
2681 "op.%d.no_inittrans", opno);
2682
2683 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 LLVMPositionBuilderAtEnd(b, b_init);
2694
2695 v_aggcontext = l_ptr_const(op->d.agg_trans.aggcontext,
2696 l_ptr(StructExprContext));
2697
2698 params[0] = v_aggstatep;
2699 params[1] = v_pertransp;
2700 params[2] = v_pergroupp;
2701 params[3] = v_aggcontext;
2702
2703 l_call(b,
2704 llvm_pg_var_func_type("ExecAggInitGroup"),
2705 llvm_pg_func(mod, "ExecAggInitGroup"),
2706 params, lengthof(params),
2707 "");
2708
2709 LLVMBuildBr(b, opblocks[opno + 1]);
2710 }
2711
2712 LLVMPositionBuilderAtEnd(b, b_no_init);
2713 }
2714
2715 if (opcode == EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL ||
2716 opcode == EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF ||
2717 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 b_strictpass = l_bb_before_v(opblocks[opno + 1],
2724 "op.%d.strictpass", opno);
2725 v_transnull =
2726 l_load_struct_gep(b,
2727 StructAggStatePerGroupData,
2728 v_pergroupp,
2729 FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUEISNULL,
2730 "transnull");
2731
2732 LLVMBuildCondBr(b,
2733 LLVMBuildICmp(b, LLVMIntEQ, v_transnull,
2734 l_sbool_const(1), ""),
2735 opblocks[opno + 1],
2736 b_strictpass);
2737
2738 LLVMPositionBuilderAtEnd(b, b_strictpass);
2739 }
2740
2741
2742 v_fcinfo = l_ptr_const(fcinfo,
2743 l_ptr(StructFunctionCallInfoData));
2744 v_aggcontext = l_ptr_const(op->d.agg_trans.aggcontext,
2745 l_ptr(StructExprContext));
2746
2747 v_current_setp =
2748 l_struct_gep(b,
2749 StructAggState,
2750 v_aggstatep,
2751 FIELDNO_AGGSTATE_CURRENT_SET,
2752 "aggstate.current_set");
2753 v_curaggcontext =
2754 l_struct_gep(b,
2755 StructAggState,
2756 v_aggstatep,
2757 FIELDNO_AGGSTATE_CURAGGCONTEXT,
2758 "aggstate.curaggcontext");
2759 v_current_pertransp =
2760 l_struct_gep(b,
2761 StructAggState,
2762 v_aggstatep,
2763 FIELDNO_AGGSTATE_CURPERTRANS,
2764 "aggstate.curpertrans");
2765
2766 /* set aggstate globals */
2767 LLVMBuildStore(b, v_aggcontext, v_curaggcontext);
2768 LLVMBuildStore(b, l_int32_const(lc, op->d.agg_trans.setno),
2769 v_current_setp);
2770 LLVMBuildStore(b, v_pertransp, v_current_pertransp);
2771
2772 /* invoke transition function in per-tuple context */
2773 v_tmpcontext =
2774 l_ptr_const(aggstate->tmpcontext->ecxt_per_tuple_memory,
2775 l_ptr(StructMemoryContextData));
2776 v_oldcontext = l_mcxt_switch(mod, b, v_tmpcontext);
2777
2778 /* store transvalue in fcinfo->args[0] */
2779 v_transvaluep =
2780 l_struct_gep(b,
2781 StructAggStatePerGroupData,
2782 v_pergroupp,
2783 FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUE,
2784 "transvalue");
2785 v_transnullp =
2786 l_struct_gep(b,
2787 StructAggStatePerGroupData,
2788 v_pergroupp,
2789 FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUEISNULL,
2790 "transnullp");
2791 LLVMBuildStore(b,
2792 l_load(b,
2793 TypeDatum,
2794 v_transvaluep,
2795 "transvalue"),
2796 l_funcvaluep(b, v_fcinfo, 0));
2797 LLVMBuildStore(b,
2798 l_load(b, TypeStorageBool, v_transnullp, "transnull"),
2799 l_funcnullp(b, v_fcinfo, 0));
2800
2801 /* and invoke transition function */
2802 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 if (opcode == EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF ||
2815 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 b_call = l_bb_before_v(opblocks[opno + 1],
2827 "op.%d.transcall", opno);
2828 b_nocall = l_bb_before_v(opblocks[opno + 1],
2829 "op.%d.transnocall", opno);
2830
2831 v_transvalue = l_load(b, TypeDatum, v_transvaluep, "");
2832 v_transnull = l_load(b, TypeStorageBool, v_transnullp, "");
2833
2834 /*
2835 * DatumGetPointer(newVal) !=
2836 * DatumGetPointer(pergroup->transValue))
2837 */
2838 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 LLVMPositionBuilderAtEnd(b, b_call);
2846
2847 params[0] = v_aggstatep;
2848 params[1] = v_pertransp;
2849 params[2] = v_retval;
2850 params[3] = LLVMBuildTrunc(b, v_fcinfo_isnull,
2851 TypeParamBool, "");
2852 params[4] = v_transvalue;
2853 params[5] = LLVMBuildTrunc(b, v_transnull,
2854 TypeParamBool, "");
2855
2856 v_fn = llvm_pg_func(mod, "ExecAggCopyTransValue");
2857 v_newval =
2858 l_call(b,
2859 LLVMGetFunctionType(v_fn),
2860 v_fn,
2861 params, lengthof(params),
2862 "");
2863
2864 /* store trans value */
2865 LLVMBuildStore(b, v_newval, v_transvaluep);
2866 LLVMBuildStore(b, v_fcinfo_isnull, v_transnullp);
2867
2868 l_mcxt_switch(mod, b, v_oldcontext);
2869 LLVMBuildBr(b, opblocks[opno + 1]);
2870
2871 /* returned datum passed datum, no need to reparent */
2872 LLVMPositionBuilderAtEnd(b, b_nocall);
2873 }
2874
2875 /* store trans value */
2876 LLVMBuildStore(b, v_retval, v_transvaluep);
2877 LLVMBuildStore(b, v_fcinfo_isnull, v_transnullp);
2878
2879 l_mcxt_switch(mod, b, v_oldcontext);
2880
2881 LLVMBuildBr(b, opblocks[opno + 1]);
2882 break;
2883 }
2884
2885 case EEOP_AGG_PRESORTED_DISTINCT_SINGLE:
2886 {
2887 AggState *aggstate = castNode(AggState, state->parent);
2888 AggStatePerTrans pertrans = op->d.agg_presorted_distinctcheck.pertrans;
2889 int jumpdistinct = op->d.agg_presorted_distinctcheck.jumpdistinct;
2890
2891 LLVMValueRef v_fn = llvm_pg_func(mod, "ExecEvalPreOrderedDistinctSingle");
2892 LLVMValueRef v_args[2];
2893 LLVMValueRef v_ret;
2894
2895 v_args[0] = l_ptr_const(aggstate, l_ptr(StructAggState));
2896 v_args[1] = l_ptr_const(pertrans, l_ptr(StructAggStatePerTransData));
2897
2898 v_ret = l_call(b, LLVMGetFunctionType(v_fn), v_fn, v_args, 2, "");
2899 v_ret = LLVMBuildZExt(b, v_ret, TypeStorageBool, "");
2900
2901 LLVMBuildCondBr(b,
2902 LLVMBuildICmp(b, LLVMIntEQ, v_ret,
2903 l_sbool_const(1), ""),
2904 opblocks[opno + 1],
2905 opblocks[jumpdistinct]);
2906 break;
2907 }
2908
2909 case EEOP_AGG_PRESORTED_DISTINCT_MULTI:
2910 {
2911 AggState *aggstate = castNode(AggState, state->parent);
2912 AggStatePerTrans pertrans = op->d.agg_presorted_distinctcheck.pertrans;
2913 int jumpdistinct = op->d.agg_presorted_distinctcheck.jumpdistinct;
2914
2915 LLVMValueRef v_fn = llvm_pg_func(mod, "ExecEvalPreOrderedDistinctMulti");
2916 LLVMValueRef v_args[2];
2917 LLVMValueRef v_ret;
2918
2919 v_args[0] = l_ptr_const(aggstate, l_ptr(StructAggState));
2920 v_args[1] = l_ptr_const(pertrans, l_ptr(StructAggStatePerTransData));
2921
2922 v_ret = l_call(b, LLVMGetFunctionType(v_fn), v_fn, v_args, 2, "");
2923 v_ret = LLVMBuildZExt(b, v_ret, TypeStorageBool, "");
2924
2925 LLVMBuildCondBr(b,
2926 LLVMBuildICmp(b, LLVMIntEQ, v_ret,
2927 l_sbool_const(1), ""),
2928 opblocks[opno + 1],
2929 opblocks[jumpdistinct]);
2930 break;
2931 }
2932
2933 case EEOP_AGG_ORDERED_TRANS_DATUM:
2934 build_EvalXFunc(b, mod, "ExecEvalAggOrderedTransDatum",
2935 v_state, op, v_econtext);
2936 LLVMBuildBr(b, opblocks[opno + 1]);
2937 break;
2938
2939 case EEOP_AGG_ORDERED_TRANS_TUPLE:
2940 build_EvalXFunc(b, mod, "ExecEvalAggOrderedTransTuple",
2941 v_state, op, v_econtext);
2942 LLVMBuildBr(b, opblocks[opno + 1]);
2943 break;
2944
2945 case EEOP_LAST:
2946 Assert(false);
2947 break;
2948 }
2949 }
2950
2951 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 CompiledExprState *cstate = palloc0_object(CompiledExprState);
2962
2963 cstate->context = context;
2964 cstate->funcname = funcname;
2965
2966 state->evalfunc = ExecRunCompiledExpr;
2967 state->evalfunc_private = cstate;
2968 }
2969
2970 llvm_leave_fatal_on_oom();
2971
2972 INSTR_TIME_SET_CURRENT(endtime);
2973 INSTR_TIME_ACCUM_DIFF(context->base.instr.generation_counter,
2974 endtime, starttime);
2975
2976 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 */
2987static Datum
2988ExecRunCompiledExpr(ExprState *state, ExprContext *econtext, bool *isNull)
2989{
2990 CompiledExprState *cstate = state->evalfunc_private;
2991 ExprStateEvalFunc func;
2992
2993 CheckExprStillValid(state, econtext);
2994
2995 llvm_enter_fatal_on_oom();
2996 func = (ExprStateEvalFunc) llvm_get_function(cstate->context,
2997 cstate->funcname);
2998 llvm_leave_fatal_on_oom();
2999 Assert(func);
3000
3001 /* remove indirection via this function for future calls */
3002 state->evalfunc = func;
3003
3004 return func(state, econtext, isNull);
3005}
3006
3007static LLVMValueRef
3008BuildV1Call(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 v_fn = llvm_function_reference(context, b, mod, fcinfo);
3018
3019 v_fcinfo = l_ptr_const(fcinfo, l_ptr(StructFunctionCallInfoData));
3020 v_fcinfo_isnullp = l_struct_gep(b,
3021 StructFunctionCallInfoData,
3022 v_fcinfo,
3023 FIELDNO_FUNCTIONCALLINFODATA_ISNULL,
3024 "v_fcinfo_isnull");
3025 LLVMBuildStore(b, l_sbool_const(0), v_fcinfo_isnullp);
3026
3027 v_retval = l_call(b, LLVMGetFunctionType(AttributeTemplate), v_fn, &v_fcinfo, 1, "funccall");
3028
3029 if (v_fcinfo_isnull)
3030 *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 LLVMContextRef lc = LLVMGetModuleContext(mod);
3040 LLVMValueRef v_lifetime = create_LifetimeEnd(mod);
3041 LLVMValueRef params[2];
3042
3043 params[0] = l_int64_const(lc, sizeof(NullableDatum) * fcinfo->nargs);
3044 params[1] = l_ptr_const(fcinfo->args, l_ptr(LLVMInt8TypeInContext(lc)));
3045 l_call(b, LLVMGetFunctionType(v_lifetime), v_lifetime, params, lengthof(params), "");
3046
3047 params[0] = l_int64_const(lc, sizeof(fcinfo->isnull));
3048 params[1] = l_ptr_const(&fcinfo->isnull, l_ptr(LLVMInt8TypeInContext(lc)));
3049 l_call(b, LLVMGetFunctionType(v_lifetime), v_lifetime, params, lengthof(params), "");
3050 }
3051#endif
3052
3053 return v_retval;
3054}
3055
3056/*
3057 * Implement an expression step by calling the function funcname.
3058 */
3059static LLVMValueRef
3060build_EvalXFuncInt(LLVMBuilderRef b, LLVMModuleRef mod, const char *funcname,
3061 LLVMValueRef v_state, ExprEvalStep *op,
3062 int nargs, LLVMValueRef *v_args)
3063{
3064 LLVMValueRef v_fn = llvm_pg_func(mod, funcname);
3065 LLVMValueRef *params;
3066 int argno = 0;
3067 LLVMValueRef v_ret;
3068
3069 /* cheap pre-check as llvm just asserts out */
3070 if (LLVMCountParams(v_fn) != (nargs + 2))
3071 elog(ERROR, "parameter mismatch: %s expects %d passed %d",
3072 funcname, LLVMCountParams(v_fn), nargs + 2);
3073
3074 params = palloc_array(LLVMValueRef, (2 + nargs));
3075
3076 params[argno++] = v_state;
3077 params[argno++] = l_ptr_const(op, l_ptr(StructExprEvalStep));
3078
3079 for (int i = 0; i < nargs; i++)
3080 params[argno++] = v_args[i];
3081
3082 v_ret = l_call(b, LLVMGetFunctionType(v_fn), v_fn, params, argno, "");
3083
3084 pfree(params);
3085
3086 return v_ret;
3087}
3088
3089#if LLVM_VERSION_MAJOR < 22
3090static LLVMValueRef
3091create_LifetimeEnd(LLVMModuleRef mod)
3092{
3093 LLVMTypeRef sig;
3094 LLVMValueRef fn;
3095 LLVMTypeRef param_types[2];
3096 LLVMContextRef lc;
3097
3098 /* variadic pointer argument */
3099 const char *nm = "llvm.lifetime.end.p0";
3100
3101 fn = LLVMGetNamedFunction(mod, nm);
3102 if (fn)
3103 return fn;
3104
3105 lc = LLVMGetModuleContext(mod);
3106 param_types[0] = LLVMInt64TypeInContext(lc);
3107 param_types[1] = l_ptr(LLVMInt8TypeInContext(lc));
3108
3109 sig = LLVMFunctionType(LLVMVoidTypeInContext(lc), param_types,
3110 lengthof(param_types), false);
3111 fn = LLVMAddFunction(mod, nm, sig);
3112
3113 LLVMSetFunctionCallConv(fn, LLVMCCallConv);
3114
3115 Assert(LLVMGetIntrinsicID(fn));
3116
3117 return fn;
3118}
3119#endif
Assert
#define Assert(condition)
Definition c.h:943
lengthof
#define lengthof(array)
Definition c.h:873
CompareType
CompareType
Definition cmptype.h:32
COMPARE_LE
@ COMPARE_LE
Definition cmptype.h:35
COMPARE_GT
@ COMPARE_GT
Definition cmptype.h:38
COMPARE_GE
@ COMPARE_GE
Definition cmptype.h:37
COMPARE_LT
@ COMPARE_LT
Definition cmptype.h:34
ERROR
#define ERROR
Definition elog.h:40
elog
#define elog(elevel,...)
Definition elog.h:228
CheckExprStillValid
void CheckExprStillValid(ExprState *state, ExprContext *econtext)
Definition execExprInterp.c:2309
ExecEvalStepOp
ExprEvalOp ExecEvalStepOp(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:2962
ExprEvalOp
ExprEvalOp
Definition execExpr.h:67
EEOP_OLD_VAR
@ EEOP_OLD_VAR
Definition execExpr.h:85
EEOP_ASSIGN_TMP
@ EEOP_ASSIGN_TMP
Definition execExpr.h:110
EEOP_SUBPLAN
@ EEOP_SUBPLAN
Definition execExpr.h:275
EEOP_CONVERT_ROWTYPE
@ EEOP_CONVERT_ROWTYPE
Definition execExpr.h:262
EEOP_FUNCEXPR_STRICT_FUSAGE
@ EEOP_FUNCEXPR_STRICT_FUSAGE
Definition execExpr.h:127
EEOP_ARRAYEXPR
@ EEOP_ARRAYEXPR
Definition execExpr.h:196
EEOP_JSONEXPR_PATH
@ EEOP_JSONEXPR_PATH
Definition execExpr.h:268
EEOP_NOT_DISTINCT
@ EEOP_NOT_DISTINCT
Definition execExpr.h:190
EEOP_DOMAIN_TESTVAL
@ EEOP_DOMAIN_TESTVAL
Definition execExpr.h:245
EEOP_PARAM_EXTERN
@ EEOP_PARAM_EXTERN
Definition execExpr.h:174
EEOP_HASHDATUM_NEXT32_STRICT
@ EEOP_HASHDATUM_NEXT32_STRICT
Definition execExpr.h:259
EEOP_IOCOERCE_SAFE
@ EEOP_IOCOERCE_SAFE
Definition execExpr.h:188
EEOP_BOOL_AND_STEP
@ EEOP_BOOL_AND_STEP
Definition execExpr.h:136
EEOP_DONE_RETURN
@ EEOP_DONE_RETURN
Definition execExpr.h:69
EEOP_WHOLEROW
@ EEOP_WHOLEROW
Definition execExpr.h:96
EEOP_JSONEXPR_COERCION_FINISH
@ EEOP_JSONEXPR_COERCION_FINISH
Definition execExpr.h:270
EEOP_HASHDATUM_FIRST_STRICT
@ EEOP_HASHDATUM_FIRST_STRICT
Definition execExpr.h:257
EEOP_AGGREF
@ EEOP_AGGREF
Definition execExpr.h:271
EEOP_FUNCEXPR_STRICT_1
@ EEOP_FUNCEXPR_STRICT_1
Definition execExpr.h:124
EEOP_INNER_VAR
@ EEOP_INNER_VAR
Definition execExpr.h:82
EEOP_AGG_PLAIN_PERGROUP_NULLCHECK
@ EEOP_AGG_PLAIN_PERGROUP_NULLCHECK
Definition execExpr.h:283
EEOP_HASHDATUM_NEXT32
@ EEOP_HASHDATUM_NEXT32
Definition execExpr.h:258
EEOP_ROWCOMPARE_FINAL
@ EEOP_ROWCOMPARE_FINAL
Definition execExpr.h:207
EEOP_AGG_STRICT_DESERIALIZE
@ EEOP_AGG_STRICT_DESERIALIZE
Definition execExpr.h:278
EEOP_IOCOERCE
@ EEOP_IOCOERCE
Definition execExpr.h:187
EEOP_RETURNINGEXPR
@ EEOP_RETURNINGEXPR
Definition execExpr.h:195
EEOP_GROUPING_FUNC
@ EEOP_GROUPING_FUNC
Definition execExpr.h:272
EEOP_DOMAIN_CHECK
@ EEOP_DOMAIN_CHECK
Definition execExpr.h:252
EEOP_BOOLTEST_IS_NOT_FALSE
@ EEOP_BOOLTEST_IS_NOT_FALSE
Definition execExpr.h:170
EEOP_PARAM_SET
@ EEOP_PARAM_SET
Definition execExpr.h:177
EEOP_NEXTVALUEEXPR
@ EEOP_NEXTVALUEEXPR
Definition execExpr.h:194
EEOP_NEW_SYSVAR
@ EEOP_NEW_SYSVAR
Definition execExpr.h:93
EEOP_AGG_PLAIN_TRANS_BYREF
@ EEOP_AGG_PLAIN_TRANS_BYREF
Definition execExpr.h:289
EEOP_QUAL
@ EEOP_QUAL
Definition execExpr.h:148
EEOP_AGG_PRESORTED_DISTINCT_MULTI
@ EEOP_AGG_PRESORTED_DISTINCT_MULTI
Definition execExpr.h:291
EEOP_AGG_PLAIN_TRANS_BYVAL
@ EEOP_AGG_PLAIN_TRANS_BYVAL
Definition execExpr.h:286
EEOP_SCAN_VAR
@ EEOP_SCAN_VAR
Definition execExpr.h:84
EEOP_CASE_TESTVAL_EXT
@ EEOP_CASE_TESTVAL_EXT
Definition execExpr.h:181
EEOP_BOOL_NOT_STEP
@ EEOP_BOOL_NOT_STEP
Definition execExpr.h:145
EEOP_ASSIGN_SCAN_VAR
@ EEOP_ASSIGN_SCAN_VAR
Definition execExpr.h:105
EEOP_NEW_VAR
@ EEOP_NEW_VAR
Definition execExpr.h:86
EEOP_SCAN_SYSVAR
@ EEOP_SCAN_SYSVAR
Definition execExpr.h:91
EEOP_SCALARARRAYOP
@ EEOP_SCALARARRAYOP
Definition execExpr.h:263
EEOP_DOMAIN_NOTNULL
@ EEOP_DOMAIN_NOTNULL
Definition execExpr.h:249
EEOP_WINDOW_FUNC
@ EEOP_WINDOW_FUNC
Definition execExpr.h:273
EEOP_INNER_FETCHSOME
@ EEOP_INNER_FETCHSOME
Definition execExpr.h:75
EEOP_NULLTEST_ROWISNOTNULL
@ EEOP_NULLTEST_ROWISNOTNULL
Definition execExpr.h:164
EEOP_ASSIGN_OUTER_VAR
@ EEOP_ASSIGN_OUTER_VAR
Definition execExpr.h:104
EEOP_ROW
@ EEOP_ROW
Definition execExpr.h:198
EEOP_MAKE_READONLY
@ EEOP_MAKE_READONLY
Definition execExpr.h:184
EEOP_FIELDSTORE_FORM
@ EEOP_FIELDSTORE_FORM
Definition execExpr.h:226
EEOP_ASSIGN_OLD_VAR
@ EEOP_ASSIGN_OLD_VAR
Definition execExpr.h:106
EEOP_SBSREF_SUBSCRIPTS
@ EEOP_SBSREF_SUBSCRIPTS
Definition execExpr.h:229
EEOP_FUNCEXPR_STRICT_2
@ EEOP_FUNCEXPR_STRICT_2
Definition execExpr.h:125
EEOP_SBSREF_FETCH
@ EEOP_SBSREF_FETCH
Definition execExpr.h:242
EEOP_FUNCEXPR_STRICT
@ EEOP_FUNCEXPR_STRICT
Definition execExpr.h:123
EEOP_NULLIF
@ EEOP_NULLIF
Definition execExpr.h:191
EEOP_CURRENTOFEXPR
@ EEOP_CURRENTOFEXPR
Definition execExpr.h:193
EEOP_INNER_SYSVAR
@ EEOP_INNER_SYSVAR
Definition execExpr.h:89
EEOP_ASSIGN_TMP_MAKE_RO
@ EEOP_ASSIGN_TMP_MAKE_RO
Definition execExpr.h:112
EEOP_CONST
@ EEOP_CONST
Definition execExpr.h:115
EEOP_BOOL_OR_STEP_LAST
@ EEOP_BOOL_OR_STEP_LAST
Definition execExpr.h:142
EEOP_JSONEXPR_COERCION
@ EEOP_JSONEXPR_COERCION
Definition execExpr.h:269
EEOP_BOOL_OR_STEP_FIRST
@ EEOP_BOOL_OR_STEP_FIRST
Definition execExpr.h:140
EEOP_XMLEXPR
@ EEOP_XMLEXPR
Definition execExpr.h:265
EEOP_AGG_STRICT_INPUT_CHECK_NULLS
@ EEOP_AGG_STRICT_INPUT_CHECK_NULLS
Definition execExpr.h:282
EEOP_SBSREF_ASSIGN
@ EEOP_SBSREF_ASSIGN
Definition execExpr.h:239
EEOP_OUTER_SYSVAR
@ EEOP_OUTER_SYSVAR
Definition execExpr.h:90
EEOP_ASSIGN_INNER_VAR
@ EEOP_ASSIGN_INNER_VAR
Definition execExpr.h:103
EEOP_BOOL_OR_STEP
@ EEOP_BOOL_OR_STEP
Definition execExpr.h:141
EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1
@ EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1
Definition execExpr.h:281
EEOP_OUTER_FETCHSOME
@ EEOP_OUTER_FETCHSOME
Definition execExpr.h:76
EEOP_AGG_STRICT_INPUT_CHECK_ARGS
@ EEOP_AGG_STRICT_INPUT_CHECK_ARGS
Definition execExpr.h:280
EEOP_NULLTEST_ROWISNULL
@ EEOP_NULLTEST_ROWISNULL
Definition execExpr.h:163
EEOP_BOOLTEST_IS_TRUE
@ EEOP_BOOLTEST_IS_TRUE
Definition execExpr.h:167
EEOP_FUNCEXPR
@ EEOP_FUNCEXPR
Definition execExpr.h:122
EEOP_NULLTEST_ISNOTNULL
@ EEOP_NULLTEST_ISNOTNULL
Definition execExpr.h:160
EEOP_ROWCOMPARE_STEP
@ EEOP_ROWCOMPARE_STEP
Definition execExpr.h:204
EEOP_MERGE_SUPPORT_FUNC
@ EEOP_MERGE_SUPPORT_FUNC
Definition execExpr.h:274
EEOP_AGG_DESERIALIZE
@ EEOP_AGG_DESERIALIZE
Definition execExpr.h:279
EEOP_LAST
@ EEOP_LAST
Definition execExpr.h:296
EEOP_HASHDATUM_FIRST
@ EEOP_HASHDATUM_FIRST
Definition execExpr.h:256
EEOP_DISTINCT
@ EEOP_DISTINCT
Definition execExpr.h:189
EEOP_JUMP_IF_NOT_TRUE
@ EEOP_JUMP_IF_NOT_TRUE
Definition execExpr.h:156
EEOP_FUNCEXPR_FUSAGE
@ EEOP_FUNCEXPR_FUSAGE
Definition execExpr.h:126
EEOP_AGG_PRESORTED_DISTINCT_SINGLE
@ EEOP_AGG_PRESORTED_DISTINCT_SINGLE
Definition execExpr.h:290
EEOP_BOOL_AND_STEP_FIRST
@ EEOP_BOOL_AND_STEP_FIRST
Definition execExpr.h:135
EEOP_JUMP
@ EEOP_JUMP
Definition execExpr.h:151
EEOP_DONE_NO_RETURN
@ EEOP_DONE_NO_RETURN
Definition execExpr.h:72
EEOP_PARAM_CALLBACK
@ EEOP_PARAM_CALLBACK
Definition execExpr.h:175
EEOP_DOMAIN_TESTVAL_EXT
@ EEOP_DOMAIN_TESTVAL_EXT
Definition execExpr.h:246
EEOP_OLD_SYSVAR
@ EEOP_OLD_SYSVAR
Definition execExpr.h:92
EEOP_BOOL_AND_STEP_LAST
@ EEOP_BOOL_AND_STEP_LAST
Definition execExpr.h:137
EEOP_NEW_FETCHSOME
@ EEOP_NEW_FETCHSOME
Definition execExpr.h:79
EEOP_AGG_ORDERED_TRANS_DATUM
@ EEOP_AGG_ORDERED_TRANS_DATUM
Definition execExpr.h:292
EEOP_OLD_FETCHSOME
@ EEOP_OLD_FETCHSOME
Definition execExpr.h:78
EEOP_ASSIGN_NEW_VAR
@ EEOP_ASSIGN_NEW_VAR
Definition execExpr.h:107
EEOP_SBSREF_OLD
@ EEOP_SBSREF_OLD
Definition execExpr.h:236
EEOP_SQLVALUEFUNCTION
@ EEOP_SQLVALUEFUNCTION
Definition execExpr.h:192
EEOP_HASHDATUM_SET_INITVAL
@ EEOP_HASHDATUM_SET_INITVAL
Definition execExpr.h:255
EEOP_JUMP_IF_NOT_NULL
@ EEOP_JUMP_IF_NOT_NULL
Definition execExpr.h:155
EEOP_AGG_PLAIN_TRANS_STRICT_BYREF
@ EEOP_AGG_PLAIN_TRANS_STRICT_BYREF
Definition execExpr.h:288
EEOP_FIELDSTORE_DEFORM
@ EEOP_FIELDSTORE_DEFORM
Definition execExpr.h:219
EEOP_BOOLTEST_IS_FALSE
@ EEOP_BOOLTEST_IS_FALSE
Definition execExpr.h:169
EEOP_BOOLTEST_IS_NOT_TRUE
@ EEOP_BOOLTEST_IS_NOT_TRUE
Definition execExpr.h:168
EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL
@ EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL
Definition execExpr.h:284
EEOP_PARAM_EXEC
@ EEOP_PARAM_EXEC
Definition execExpr.h:173
EEOP_JSON_CONSTRUCTOR
@ EEOP_JSON_CONSTRUCTOR
Definition execExpr.h:266
EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL
@ EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL
Definition execExpr.h:285
EEOP_NULLTEST_ISNULL
@ EEOP_NULLTEST_ISNULL
Definition execExpr.h:159
EEOP_MINMAX
@ EEOP_MINMAX
Definition execExpr.h:210
EEOP_JUMP_IF_NULL
@ EEOP_JUMP_IF_NULL
Definition execExpr.h:154
EEOP_ARRAYCOERCE
@ EEOP_ARRAYCOERCE
Definition execExpr.h:197
EEOP_FIELDSELECT
@ EEOP_FIELDSELECT
Definition execExpr.h:213
EEOP_CASE_TESTVAL
@ EEOP_CASE_TESTVAL
Definition execExpr.h:180
EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF
@ EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF
Definition execExpr.h:287
EEOP_HASHED_SCALARARRAYOP
@ EEOP_HASHED_SCALARARRAYOP
Definition execExpr.h:264
EEOP_OUTER_VAR
@ EEOP_OUTER_VAR
Definition execExpr.h:83
EEOP_AGG_ORDERED_TRANS_TUPLE
@ EEOP_AGG_ORDERED_TRANS_TUPLE
Definition execExpr.h:293
EEOP_SCAN_FETCHSOME
@ EEOP_SCAN_FETCHSOME
Definition execExpr.h:77
EEOP_IS_JSON
@ EEOP_IS_JSON
Definition execExpr.h:267
TTSOpsVirtual
const TupleTableSlotOps TTSOpsVirtual
Definition execTuples.c:84
ExprStateEvalFunc
Datum(* ExprStateEvalFunc)(ExprState *expression, ExprContext *econtext, bool *isNull)
Definition execnodes.h:82
FIELDNO_EXPRSTATE_RESULTSLOT
#define FIELDNO_EXPRSTATE_RESULTSLOT
Definition execnodes.h:117
FIELDNO_EXPRCONTEXT_CASENULL
#define FIELDNO_EXPRCONTEXT_CASENULL
Definition execnodes.h:313
FIELDNO_EXPRCONTEXT_INNERTUPLE
#define FIELDNO_EXPRCONTEXT_INNERTUPLE
Definition execnodes.h:288
FIELDNO_EXPRSTATE_FLAGS
#define FIELDNO_EXPRSTATE_FLAGS
Definition execnodes.h:102
FIELDNO_EXPRCONTEXT_DOMAINNULL
#define FIELDNO_EXPRCONTEXT_DOMAINNULL
Definition execnodes.h:319
FIELDNO_EXPRCONTEXT_DOMAINDATUM
#define FIELDNO_EXPRCONTEXT_DOMAINDATUM
Definition execnodes.h:317
FIELDNO_EXPRCONTEXT_CASEDATUM
#define FIELDNO_EXPRCONTEXT_CASEDATUM
Definition execnodes.h:311
FIELDNO_EXPRCONTEXT_OLDTUPLE
#define FIELDNO_EXPRCONTEXT_OLDTUPLE
Definition execnodes.h:323
FIELDNO_AGGSTATE_CURPERTRANS
#define FIELDNO_AGGSTATE_CURPERTRANS
Definition execnodes.h:2449
FIELDNO_EXPRSTATE_RESNULL
#define FIELDNO_EXPRSTATE_RESNULL
Definition execnodes.h:109
FIELDNO_EXPRCONTEXT_NEWTUPLE
#define FIELDNO_EXPRCONTEXT_NEWTUPLE
Definition execnodes.h:325
FIELDNO_EXPRCONTEXT_AGGNULLS
#define FIELDNO_EXPRCONTEXT_AGGNULLS
Definition execnodes.h:307
FIELDNO_EXPRSTATE_RESVALUE
#define FIELDNO_EXPRSTATE_RESVALUE
Definition execnodes.h:111
FIELDNO_AGGSTATE_CURRENT_SET
#define FIELDNO_AGGSTATE_CURRENT_SET
Definition execnodes.h:2454
FIELDNO_EXPRCONTEXT_AGGVALUES
#define FIELDNO_EXPRCONTEXT_AGGVALUES
Definition execnodes.h:305
FIELDNO_EXPRCONTEXT_OUTERTUPLE
#define FIELDNO_EXPRCONTEXT_OUTERTUPLE
Definition execnodes.h:290
FIELDNO_AGGSTATE_ALL_PERGROUPS
#define FIELDNO_AGGSTATE_ALL_PERGROUPS
Definition execnodes.h:2501
FIELDNO_EXPRSTATE_PARENT
#define FIELDNO_EXPRSTATE_PARENT
Definition execnodes.h:145
FIELDNO_EXPRCONTEXT_SCANTUPLE
#define FIELDNO_EXPRCONTEXT_SCANTUPLE
Definition execnodes.h:286
FIELDNO_AGGSTATE_CURAGGCONTEXT
#define FIELDNO_AGGSTATE_CURAGGCONTEXT
Definition execnodes.h:2446
palloc_array
#define palloc_array(type, count)
Definition fe_memutils.h:76
palloc0_object
#define palloc0_object(type)
Definition fe_memutils.h:75
FIELDNO_FUNCTIONCALLINFODATA_ISNULL
#define FIELDNO_FUNCTIONCALLINFODATA_ISNULL
Definition fmgr.h:91
htup_details.h
funcname
#define funcname
Definition indent_codes.h:69
value
static struct @177 value
INSTR_TIME_SET_CURRENT
#define INSTR_TIME_SET_CURRENT(t)
Definition instr_time.h:426
INSTR_TIME_ACCUM_DIFF
#define INSTR_TIME_ACCUM_DIFF(x, y, z)
Definition instr_time.h:439
b
int b
Definition isn.c:74
i
int i
Definition isn.c:77
PGJIT_DEFORM
#define PGJIT_DEFORM
Definition jit.h:24
StructFunctionCallInfoData
LLVMTypeRef StructFunctionCallInfoData
Definition llvmjit.c:70
llvm_create_context
LLVMJitContext * llvm_create_context(int jitFlags)
Definition llvmjit.c:224
StructExprState
LLVMTypeRef StructExprState
Definition llvmjit.c:73
StructExprEvalStep
LLVMTypeRef StructExprEvalStep
Definition llvmjit.c:72
llvm_pg_func
LLVMValueRef llvm_pg_func(LLVMModuleRef mod, const char *funcname)
Definition llvmjit.c:465
TypeParamBool
LLVMTypeRef TypeParamBool
Definition llvmjit.c:58
StructMemoryContextData
LLVMTypeRef StructMemoryContextData
Definition llvmjit.c:69
StructAggStatePerGroupData
LLVMTypeRef StructAggStatePerGroupData
Definition llvmjit.c:75
llvm_pg_var_type
LLVMTypeRef llvm_pg_var_type(const char *varname)
Definition llvmjit.c:423
llvm_function_reference
LLVMValueRef llvm_function_reference(LLVMJitContext *context, LLVMBuilderRef builder, LLVMModuleRef mod, FunctionCallInfo fcinfo)
Definition llvmjit.c:541
llvm_expand_funcname
char * llvm_expand_funcname(struct LLVMJitContext *context, const char *basename)
Definition llvmjit.c:342
llvm_pg_var_func_type
LLVMTypeRef llvm_pg_var_func_type(const char *varname)
Definition llvmjit.c:443
StructTupleTableSlot
LLVMTypeRef StructTupleTableSlot
Definition llvmjit.c:65
TypeStorageBool
LLVMTypeRef TypeStorageBool
Definition llvmjit.c:59
TypeDatum
LLVMTypeRef TypeDatum
Definition llvmjit.c:57
llvm_mutable_module
LLVMModuleRef llvm_mutable_module(LLVMJitContext *context)
Definition llvmjit.c:317
StructAggState
LLVMTypeRef StructAggState
Definition llvmjit.c:74
AttributeTemplate
LLVMValueRef AttributeTemplate
Definition llvmjit.c:79
StructExprContext
LLVMTypeRef StructExprContext
Definition llvmjit.c:71
llvm_get_function
void * llvm_get_function(LLVMJitContext *context, const char *funcname)
Definition llvmjit.c:363
StructNullableDatum
LLVMTypeRef StructNullableDatum
Definition llvmjit.c:61
ExecEvalSubroutineTemplate
LLVMValueRef ExecEvalSubroutineTemplate
Definition llvmjit.c:80
ExecEvalBoolSubroutineTemplate
LLVMValueRef ExecEvalBoolSubroutineTemplate
Definition llvmjit.c:81
StructAggStatePerTransData
LLVMTypeRef StructAggStatePerTransData
Definition llvmjit.c:76
llvm_copy_attributes
void llvm_copy_attributes(LLVMValueRef v_from, LLVMValueRef v_to)
Definition llvmjit.c:517
slot_compile_deform
LLVMValueRef slot_compile_deform(LLVMJitContext *context, TupleDesc desc, const TupleTableSlotOps *ops, int natts)
Definition llvmjit_deform.c:34
llvmjit_emit.h
llvm_enter_fatal_on_oom
void llvm_enter_fatal_on_oom(void)
Definition llvmjit_error.cpp:55
llvm_leave_fatal_on_oom
void llvm_leave_fatal_on_oom(void)
Definition llvmjit_error.cpp:70
ExecRunCompiledExpr
static Datum ExecRunCompiledExpr(ExprState *state, ExprContext *econtext, bool *isNull)
Definition llvmjit_expr.c:2988
build_EvalXFunc
#define build_EvalXFunc(b, mod, funcname, v_state, op,...)
Definition llvmjit_expr.c:70
llvm_compile_expr
bool llvm_compile_expr(ExprState *state)
Definition llvmjit_expr.c:80
build_EvalXFuncInt
static LLVMValueRef build_EvalXFuncInt(LLVMBuilderRef b, LLVMModuleRef mod, const char *funcname, LLVMValueRef v_state, ExprEvalStep *op, int natts, LLVMValueRef *v_args)
Definition llvmjit_expr.c:3060
create_LifetimeEnd
static LLVMValueRef create_LifetimeEnd(LLVMModuleRef mod)
Definition llvmjit_expr.c:3091
BuildV1Call
static LLVMValueRef BuildV1Call(LLVMJitContext *context, LLVMBuilderRef b, LLVMModuleRef mod, FunctionCallInfo fcinfo, LLVMValueRef *v_fcinfo_isnull)
Definition llvmjit_expr.c:3008
LLVMGetFunctionType
LLVMTypeRef LLVMGetFunctionType(LLVMValueRef r)
Definition llvmjit_wrap.cpp:44
pfree
void pfree(void *pointer)
Definition mcxt.c:1616
palloc
void * palloc(Size size)
Definition mcxt.c:1387
FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUE
#define FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUE
Definition nodeAgg.h:252
FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUEISNULL
#define FIELDNO_AGGSTATEPERGROUPDATA_TRANSVALUEISNULL
Definition nodeAgg.h:254
FIELDNO_AGGSTATEPERGROUPDATA_NOTRANSVALUE
#define FIELDNO_AGGSTATEPERGROUPDATA_NOTRANSVALUE
Definition nodeAgg.h:257
castNode
#define castNode(_type_, nodeptr)
Definition nodes.h:182
parse_coerce.h
sig
static int sig
Definition pg_ctl.c:81
pg_type.h
FIELDNO_NULLABLE_DATUM_ISNULL
#define FIELDNO_NULLABLE_DATUM_ISNULL
Definition postgres.h:88
Datum
uint64_t Datum
Definition postgres.h:70
fb
static int fb(int x)
Definition preproc-init.c:92
AggStatePerTransData::transfn_fcinfo
FunctionCallInfo transfn_fcinfo
Definition nodeAgg.h:170
CompiledExprState::funcname
const char * funcname
Definition llvmjit_expr.c:51
CompiledExprState::context
LLVMJitContext * context
Definition llvmjit_expr.c:50
EState::es_jit
struct JitContext * es_jit
Definition execnodes.h:800
EState::es_jit_flags
int es_jit_flags
Definition execnodes.h:799
ExprEvalStep::nullflag
uint8 nullflag
Definition execExpr.h:373
ExprEvalStep::anynull
bool * anynull
Definition execExpr.h:399
ExprEvalStep::fetch
struct ExprEvalStep::@63::@64 fetch
ExprEvalStep::func
struct ExprEvalStep::@63::@71 func
ExprEvalStep::wfstate
WindowFuncExprState * wfstate
Definition execExpr.h:684
ExprEvalStep::subscriptfunc
ExecEvalBoolSubroutine subscriptfunc
Definition execExpr.h:568
ExprEvalStep::returningexpr
struct ExprEvalStep::@63::@69 returningexpr
ExprEvalStep::boolexpr
struct ExprEvalStep::@63::@72 boolexpr
ExprEvalStep::iocoerce
struct ExprEvalStep::@63::@80 iocoerce
ExprEvalStep::assign_var
struct ExprEvalStep::@63::@67 assign_var
ExprEvalStep::pertrans
AggStatePerTrans pertrans
Definition execExpr.h:731
ExprEvalStep::jsestate
struct JsonExprState * jsestate
Definition execExpr.h:756
ExprEvalStep::paramfunc
ExecEvalSubroutine paramfunc
Definition execExpr.h:432
ExprEvalStep::fcinfo_data_in
FunctionCallInfo fcinfo_data_in
Definition execExpr.h:461
ExprEvalStep::sbsref_subscript
struct ExprEvalStep::@63::@91 sbsref_subscript
ExprEvalStep::known_desc
TupleDesc known_desc
Definition execExpr.h:329
ExprEvalStep::args
NullableDatum * args
Definition execExpr.h:715
ExprEvalStep::nulls
bool * nulls
Definition execExpr.h:531
ExprEvalStep::resvalue
Datum * resvalue
Definition execExpr.h:310
ExprEvalStep::iresult
NullableDatum * iresult
Definition execExpr.h:610
ExprEvalStep::var
struct ExprEvalStep::@63::@65 var
ExprEvalStep::assign_tmp
struct ExprEvalStep::@63::@68 assign_tmp
ExprEvalStep::kind
const TupleTableSlotOps * kind
Definition execExpr.h:331
ExprEvalStep::agg_presorted_distinctcheck
struct ExprEvalStep::@63::@108 agg_presorted_distinctcheck
ExprEvalStep::fcinfo_data
FunctionCallInfo fcinfo_data
Definition execExpr.h:389
ExprEvalStep::casetest
struct ExprEvalStep::@63::@78 casetest
ExprEvalStep::jumpdistinct
int jumpdistinct
Definition execExpr.h:733
ExprEvalStep::finfo_in
FmgrInfo * finfo_in
Definition execExpr.h:460
ExprEvalStep::constval
struct ExprEvalStep::@63::@70 constval
ExprEvalStep::hashdatum
struct ExprEvalStep::@63::@95 hashdatum
ExprEvalStep::agg_deserialize
struct ExprEvalStep::@63::@105 agg_deserialize
ExprEvalStep::agg_strict_input_check
struct ExprEvalStep::@63::@106 agg_strict_input_check
ExprEvalStep::qualexpr
struct ExprEvalStep::@63::@73 qualexpr
ExprEvalStep::window_func
struct ExprEvalStep::@63::@103 window_func
ExprEvalStep::make_readonly
struct ExprEvalStep::@63::@79 make_readonly
ExprEvalStep::d
union ExprEvalStep::@63 d
ExprEvalStep::value
Datum value
Definition execExpr.h:381
ExprEvalStep::sbsref
struct ExprEvalStep::@63::@92 sbsref
ExprEvalStep::cmptype
CompareType cmptype
Definition execExpr.h:523
ExprEvalStep::rowcompare_step
struct ExprEvalStep::@63::@86 rowcompare_step
ExprEvalStep::resnull
bool * resnull
Definition execExpr.h:311
ExprEvalStep::hashdatum_initvalue
struct ExprEvalStep::@63::@94 hashdatum_initvalue
ExprEvalStep::jump
struct ExprEvalStep::@63::@74 jump
ExprEvalStep::cparam
struct ExprEvalStep::@63::@77 cparam
ExprEvalStep::fcinfo_data_out
FunctionCallInfo fcinfo_data_out
Definition execExpr.h:458
ExprEvalStep::aggref
struct ExprEvalStep::@63::@101 aggref
ExprEvalStep::init_value
Datum init_value
Definition execExpr.h:598
ExprEvalStep::agg_trans
struct ExprEvalStep::@63::@109 agg_trans
ExprEvalStep::jsonexpr
struct ExprEvalStep::@63::@111 jsonexpr
ExprEvalStep::finfo
FmgrInfo * finfo
Definition execExpr.h:388
ExprEvalStep::aggcontext
ExprContext * aggcontext
Definition execExpr.h:732
ExprEvalStep::rowcompare_final
struct ExprEvalStep::@63::@87 rowcompare_final
ExprEvalStep::agg_plain_pergroup_nullcheck
struct ExprEvalStep::@63::@107 agg_plain_pergroup_nullcheck
FmgrInfo::fn_strict
bool fn_strict
Definition fmgr.h:61
FunctionCallInfoBaseData::args
NullableDatum args[FLEXIBLE_ARRAY_MEMBER]
Definition fmgr.h:95
JsonExprState::jump_eval_coercion
int jump_eval_coercion
Definition execnodes.h:1143
NullableDatum::value
Datum value
Definition postgres.h:87
PlanState::state
EState * state
Definition execnodes.h:1203
instr_time
Definition instr_time.h:77
fn
static void * fn(void *arg)
Definition thread-alloc.c:119
FIELDNO_TUPLETABLESLOT_ISNULL
#define FIELDNO_TUPLETABLESLOT_ISNULL
Definition tuptable.h:132
FIELDNO_TUPLETABLESLOT_VALUES
#define FIELDNO_TUPLETABLESLOT_VALUES
Definition tuptable.h:130
FIELDNO_TUPLETABLESLOT_NVALID
#define FIELDNO_TUPLETABLESLOT_NVALID
Definition tuptable.h:125