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