jit: Fix type used for Datum values in LLVM IR.

Commit 2a600a93 made Datum 8 bytes wide everywhere.  It was no longer
appropriate to use TypeSizeT on 32 bit systems, and JIT compilation
would fail with various type check errors.  Introduce a separate
LLVMTypeRef with the name TypeDatum.  TypeSizeT is still used in some
places for actual size_t values.

Reported-by: Dmitry Mityugov <d.mityugov@postgrespro.ru>
Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us>
Tested-by: Dmitry Mityugov <d.mityugov@postgrespro.ru>
Discussion: https://postgr.es/m/0a9f0be59171c2e8f1b3bc10f4fcf267%40postgrespro.ru

diff --git a/src/backend/jit/llvm/llvmjit.c b/src/backend/jit/llvm/llvmjit.c
index 46511624f0166dcdd698b1e125de865e309af48e..e978b996baede96af367bd67958cd9a8f659d346 100644 (file)
--- a/src/backend/jit/llvm/llvmjit.c
+++ b/src/backend/jit/llvm/llvmjit.c
@@ -54,6 +54,7 @@ typedef struct LLVMJitHandle
 
 /* types & functions commonly needed for JITing */
 LLVMTypeRef TypeSizeT;
+LLVMTypeRef TypeDatum;
 LLVMTypeRef TypeParamBool;
 LLVMTypeRef TypeStorageBool;
 LLVMTypeRef TypePGFunction;
@@ -1011,6 +1012,7 @@ llvm_create_types(void)
    LLVMDisposeMemoryBuffer(buf);
 
    TypeSizeT = llvm_pg_var_type("TypeSizeT");
+   TypeDatum = llvm_pg_var_type("TypeDatum");
    TypeParamBool = load_return_type(llvm_types_module, "FunctionReturningBool");
    TypeStorageBool = llvm_pg_var_type("TypeStorageBool");
    TypePGFunction = llvm_pg_var_type("TypePGFunction");

diff --git a/src/backend/jit/llvm/llvmjit_deform.c b/src/backend/jit/llvm/llvmjit_deform.c
index c562edd094bb27436016a0cb9fb040a54c2b0055..9791073faf9d3387908f0b50a3c7f22189525ac5 100644 (file)
--- a/src/backend/jit/llvm/llvmjit_deform.c
+++ b/src/backend/jit/llvm/llvmjit_deform.c
@@ -479,8 +479,8 @@ slot_compile_deform(LLVMJitContext *context, TupleDesc desc,
                           l_gep(b, LLVMInt8TypeInContext(lc), v_tts_nulls, &l_attno, 1, ""));
            /* store zero datum */
            LLVMBuildStore(b,
-                          l_sizet_const(0),
-                          l_gep(b, TypeSizeT, v_tts_values, &l_attno, 1, ""));
+                          l_datum_const(0),
+                          l_gep(b, TypeDatum, v_tts_values, &l_attno, 1, ""));
 
            LLVMBuildBr(b, b_next);
            attguaranteedalign = false;
@@ -644,7 +644,7 @@ slot_compile_deform(LLVMJitContext *context, TupleDesc desc,
        }
 
        /* compute address to store value at */
-       v_resultp = l_gep(b, TypeSizeT, v_tts_values, &l_attno, 1, "");
+       v_resultp = l_gep(b, TypeDatum, v_tts_values, &l_attno, 1, "");
 
        /* store null-byte (false) */
        LLVMBuildStore(b, l_int8_const(lc, 0),
@@ -663,7 +663,7 @@ slot_compile_deform(LLVMJitContext *context, TupleDesc desc,
            v_tmp_loaddata =
                LLVMBuildPointerCast(b, v_attdatap, vartypep, "");
            v_tmp_loaddata = l_load(b, vartype, v_tmp_loaddata, "attr_byval");
-           v_tmp_loaddata = LLVMBuildZExt(b, v_tmp_loaddata, TypeSizeT, "");
+           v_tmp_loaddata = LLVMBuildZExt(b, v_tmp_loaddata, TypeDatum, "");
 
            LLVMBuildStore(b, v_tmp_loaddata, v_resultp);
        }
@@ -675,7 +675,7 @@ slot_compile_deform(LLVMJitContext *context, TupleDesc desc,
            v_tmp_loaddata =
                LLVMBuildPtrToInt(b,
                                  v_attdatap,
-                                 TypeSizeT,
+                                 TypeDatum,
                                  "attr_ptr");
            LLVMBuildStore(b, v_tmp_loaddata, v_resultp);
        }

diff --git a/src/backend/jit/llvm/llvmjit_expr.c b/src/backend/jit/llvm/llvmjit_expr.c
index 890bcb0b0a79dfd5f347e6f683300f4ba9afb217..712b35df7e581335cd3837a5da300042fef8d321 100644 (file)
--- a/src/backend/jit/llvm/llvmjit_expr.c
+++ b/src/backend/jit/llvm/llvmjit_expr.c
@@ -316,7 +316,7 @@ llvm_compile_expr(ExprState *state)
        op = &state->steps[opno];
        opcode = ExecEvalStepOp(state, op);
 
-       v_resvaluep = l_ptr_const(op->resvalue, l_ptr(TypeSizeT));
+       v_resvaluep = l_ptr_const(op->resvalue, l_ptr(TypeDatum));
        v_resnullp = l_ptr_const(op->resnull, l_ptr(TypeStorageBool));
 
        switch (opcode)
@@ -326,7 +326,7 @@ llvm_compile_expr(ExprState *state)
                    LLVMValueRef v_tmpisnull;
                    LLVMValueRef v_tmpvalue;
 
-                   v_tmpvalue = l_load(b, TypeSizeT, v_tmpvaluep, "");
+                   v_tmpvalue = l_load(b, TypeDatum, v_tmpvaluep, "");
                    v_tmpisnull = l_load(b, TypeStorageBool, v_tmpisnullp, "");
 
                    LLVMBuildStore(b, v_tmpisnull, v_isnullp);
@@ -336,7 +336,7 @@ llvm_compile_expr(ExprState *state)
                }
 
            case EEOP_DONE_NO_RETURN:
-               LLVMBuildRet(b, l_sizet_const(0));
+               LLVMBuildRet(b, l_datum_const(0));
                break;
 
            case EEOP_INNER_FETCHSOME:
@@ -478,7 +478,7 @@ llvm_compile_expr(ExprState *state)
                    }
 
                    v_attnum = l_int32_const(lc, op->d.var.attnum);
-                   value = l_load_gep1(b, TypeSizeT, v_values, v_attnum, "");
+                   value = l_load_gep1(b, TypeDatum, v_values, v_attnum, "");
                    isnull = l_load_gep1(b, TypeStorageBool, v_nulls, v_attnum, "");
                    LLVMBuildStore(b, value, v_resvaluep);
                    LLVMBuildStore(b, isnull, v_resnullp);
@@ -562,13 +562,13 @@ llvm_compile_expr(ExprState *state)
 
                    /* load data */
                    v_attnum = l_int32_const(lc, op->d.assign_var.attnum);
-                   v_value = l_load_gep1(b, TypeSizeT, v_values, v_attnum, "");
+                   v_value = l_load_gep1(b, TypeDatum, v_values, v_attnum, "");
                    v_isnull = l_load_gep1(b, TypeStorageBool, v_nulls, v_attnum, "");
 
                    /* compute addresses of targets */
                    v_resultnum = l_int32_const(lc, op->d.assign_var.resultnum);
                    v_rvaluep = l_gep(b,
-                                     TypeSizeT,
+                                     TypeDatum,
                                      v_resultvalues,
                                      &v_resultnum, 1, "");
                    v_risnullp = l_gep(b,
@@ -595,13 +595,13 @@ llvm_compile_expr(ExprState *state)
                    size_t      resultnum = op->d.assign_tmp.resultnum;
 
                    /* load data */
-                   v_value = l_load(b, TypeSizeT, v_tmpvaluep, "");
+                   v_value = l_load(b, TypeDatum, v_tmpvaluep, "");
                    v_isnull = l_load(b, TypeStorageBool, v_tmpisnullp, "");
 
                    /* compute addresses of targets */
                    v_resultnum = l_int32_const(lc, resultnum);
                    v_rvaluep =
-                       l_gep(b, TypeSizeT, v_resultvalues, &v_resultnum, 1, "");
+                       l_gep(b, TypeDatum, v_resultvalues, &v_resultnum, 1, "");
                    v_risnullp =
                        l_gep(b, TypeStorageBool, v_resultnulls, &v_resultnum, 1, "");
 
@@ -650,7 +650,7 @@ llvm_compile_expr(ExprState *state)
                    LLVMValueRef v_constvalue,
                                v_constnull;
 
-                   v_constvalue = l_sizet_const(op->d.constval.value);
+                   v_constvalue = l_datum_const(op->d.constval.value);
                    v_constnull = l_sbool_const(op->d.constval.isnull);
 
                    LLVMBuildStore(b, v_constvalue, v_resvaluep);
@@ -798,7 +798,7 @@ llvm_compile_expr(ExprState *state)
                        LLVMBuildStore(b, l_sbool_const(0), v_boolanynullp);
 
                    v_boolnull = l_load(b, TypeStorageBool, v_resnullp, "");
-                   v_boolvalue = l_load(b, TypeSizeT, v_resvaluep, "");
+                   v_boolvalue = l_load(b, TypeDatum, v_resvaluep, "");
 
                    /* check if current input is NULL */
                    LLVMBuildCondBr(b,
@@ -818,7 +818,7 @@ llvm_compile_expr(ExprState *state)
                    LLVMPositionBuilderAtEnd(b, b_boolcheckfalse);
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_boolvalue,
-                                                 l_sizet_const(0), ""),
+                                                 l_datum_const(0), ""),
                                    b_boolisfalse,
                                    b_boolcont);
 
@@ -846,7 +846,7 @@ llvm_compile_expr(ExprState *state)
                    /* set resnull to true */
                    LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
                    /* reset resvalue */
-                   LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
+                   LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
 
                    LLVMBuildBr(b, opblocks[opno + 1]);
                    break;
@@ -889,7 +889,7 @@ llvm_compile_expr(ExprState *state)
                    if (opcode == EEOP_BOOL_OR_STEP_FIRST)
                        LLVMBuildStore(b, l_sbool_const(0), v_boolanynullp);
                    v_boolnull = l_load(b, TypeStorageBool, v_resnullp, "");
-                   v_boolvalue = l_load(b, TypeSizeT, v_resvaluep, "");
+                   v_boolvalue = l_load(b, TypeDatum, v_resvaluep, "");
 
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_boolnull,
@@ -908,7 +908,7 @@ llvm_compile_expr(ExprState *state)
                    LLVMPositionBuilderAtEnd(b, b_boolchecktrue);
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_boolvalue,
-                                                 l_sizet_const(1), ""),
+                                                 l_datum_const(1), ""),
                                    b_boolistrue,
                                    b_boolcont);
 
@@ -936,7 +936,7 @@ llvm_compile_expr(ExprState *state)
                    /* set resnull to true */
                    LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
                    /* reset resvalue */
-                   LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
+                   LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
 
                    LLVMBuildBr(b, opblocks[opno + 1]);
                    break;
@@ -948,13 +948,13 @@ llvm_compile_expr(ExprState *state)
                    LLVMValueRef v_negbool;
 
                    /* compute !boolvalue */
-                   v_boolvalue = l_load(b, TypeSizeT, v_resvaluep, "");
+                   v_boolvalue = l_load(b, TypeDatum, v_resvaluep, "");
                    v_negbool = LLVMBuildZExt(b,
                                              LLVMBuildICmp(b, LLVMIntEQ,
                                                            v_boolvalue,
-                                                           l_sizet_const(0),
+                                                           l_datum_const(0),
                                                            ""),
-                                             TypeSizeT, "");
+                                             TypeDatum, "");
 
                    /*
                     * Store it back in resvalue.  We can ignore resnull here;
@@ -977,7 +977,7 @@ llvm_compile_expr(ExprState *state)
                    b_qualfail = l_bb_before_v(opblocks[opno + 1],
                                               "op.%d.qualfail", opno);
 
-                   v_resvalue = l_load(b, TypeSizeT, v_resvaluep, "");
+                   v_resvalue = l_load(b, TypeDatum, v_resvaluep, "");
                    v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
 
                    v_nullorfalse =
@@ -985,7 +985,7 @@ llvm_compile_expr(ExprState *state)
                                    LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
                                                  l_sbool_const(1), ""),
                                    LLVMBuildICmp(b, LLVMIntEQ, v_resvalue,
-                                                 l_sizet_const(0), ""),
+                                                 l_datum_const(0), ""),
                                    "");
 
                    LLVMBuildCondBr(b,
@@ -998,7 +998,7 @@ llvm_compile_expr(ExprState *state)
                    /* set resnull to false */
                    LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
                    /* set resvalue to false */
-                   LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
+                   LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
                    /* and jump out */
                    LLVMBuildBr(b, opblocks[op->d.qualexpr.jumpdone]);
                    break;
@@ -1051,7 +1051,7 @@ llvm_compile_expr(ExprState *state)
 
                    /* Transfer control if current result is null or false */
 
-                   v_resvalue = l_load(b, TypeSizeT, v_resvaluep, "");
+                   v_resvalue = l_load(b, TypeDatum, v_resvaluep, "");
                    v_resnull = l_load(b, TypeStorageBool, v_resnullp, "");
 
                    v_nullorfalse =
@@ -1059,7 +1059,7 @@ llvm_compile_expr(ExprState *state)
                                    LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
                                                  l_sbool_const(1), ""),
                                    LLVMBuildICmp(b, LLVMIntEQ, v_resvalue,
-                                                 l_sizet_const(0), ""),
+                                                 l_datum_const(0), ""),
                                    "");
 
                    LLVMBuildCondBr(b,
@@ -1078,8 +1078,8 @@ llvm_compile_expr(ExprState *state)
                        LLVMBuildSelect(b,
                                        LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
                                                      l_sbool_const(1), ""),
-                                       l_sizet_const(1),
-                                       l_sizet_const(0),
+                                       l_datum_const(1),
+                                       l_datum_const(0),
                                        "");
                    LLVMBuildStore(b, v_resvalue, v_resvaluep);
                    LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
@@ -1097,8 +1097,8 @@ llvm_compile_expr(ExprState *state)
                        LLVMBuildSelect(b,
                                        LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
                                                      l_sbool_const(1), ""),
-                                       l_sizet_const(0),
-                                       l_sizet_const(1),
+                                       l_datum_const(0),
+                                       l_datum_const(1),
                                        "");
                    LLVMBuildStore(b, v_resvalue, v_resvaluep);
                    LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
@@ -1148,11 +1148,11 @@ llvm_compile_expr(ExprState *state)
                    if (opcode == EEOP_BOOLTEST_IS_TRUE ||
                        opcode == EEOP_BOOLTEST_IS_FALSE)
                    {
-                       LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
+                       LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
                    }
                    else
                    {
-                       LLVMBuildStore(b, l_sizet_const(1), v_resvaluep);
+                       LLVMBuildStore(b, l_datum_const(1), v_resvaluep);
                    }
 
                    LLVMBuildBr(b, opblocks[opno + 1]);
@@ -1170,14 +1170,14 @@ llvm_compile_expr(ExprState *state)
                    else
                    {
                        LLVMValueRef v_value =
-                           l_load(b, TypeSizeT, v_resvaluep, "");
+                           l_load(b, TypeDatum, v_resvaluep, "");
 
                        v_value = LLVMBuildZExt(b,
                                                LLVMBuildICmp(b, LLVMIntEQ,
                                                              v_value,
-                                                             l_sizet_const(0),
+                                                             l_datum_const(0),
                                                              ""),
-                                               TypeSizeT, "");
+                                               TypeDatum, "");
                        LLVMBuildStore(b, v_value, v_resvaluep);
                    }
                    LLVMBuildBr(b, opblocks[opno + 1]);
@@ -1279,11 +1279,11 @@ llvm_compile_expr(ExprState *state)
                                v_casenull;
 
                    v_casevaluep = l_ptr_const(op->d.casetest.value,
-                                              l_ptr(TypeSizeT));
+                                              l_ptr(TypeDatum));
                    v_casenullp = l_ptr_const(op->d.casetest.isnull,
                                              l_ptr(TypeStorageBool));
 
-                   v_casevalue = l_load(b, TypeSizeT, v_casevaluep, "");
+                   v_casevalue = l_load(b, TypeDatum, v_casevaluep, "");
                    v_casenull = l_load(b, TypeStorageBool, v_casenullp, "");
                    LLVMBuildStore(b, v_casevalue, v_resvaluep);
                    LLVMBuildStore(b, v_casenull, v_resnullp);
@@ -1345,9 +1345,9 @@ llvm_compile_expr(ExprState *state)
                    LLVMPositionBuilderAtEnd(b, b_notnull);
 
                    v_valuep = l_ptr_const(op->d.make_readonly.value,
-                                          l_ptr(TypeSizeT));
+                                          l_ptr(TypeDatum));
 
-                   v_value = l_load(b, TypeSizeT, v_valuep, "");
+                   v_value = l_load(b, TypeDatum, v_valuep, "");
 
                    v_params[0] = v_value;
                    v_ret =
@@ -1415,11 +1415,11 @@ llvm_compile_expr(ExprState *state)
                                    b_calloutput);
 
                    LLVMPositionBuilderAtEnd(b, b_skipoutput);
-                   v_output_skip = l_sizet_const(0);
+                   v_output_skip = l_datum_const(0);
                    LLVMBuildBr(b, b_input);
 
                    LLVMPositionBuilderAtEnd(b, b_calloutput);
-                   v_resvalue = l_load(b, TypeSizeT, v_resvaluep, "");
+                   v_resvalue = l_load(b, TypeDatum, v_resvaluep, "");
 
                    /* set arg[0] */
                    LLVMBuildStore(b,
@@ -1449,7 +1449,7 @@ llvm_compile_expr(ExprState *state)
                        incoming_values[1] = v_output;
                        incoming_blocks[1] = b_calloutput;
 
-                       v_output = LLVMBuildPhi(b, TypeSizeT, "output");
+                       v_output = LLVMBuildPhi(b, TypeDatum, "output");
                        LLVMAddIncoming(v_output,
                                        incoming_values, incoming_blocks,
                                        lengthof(incoming_blocks));
@@ -1463,7 +1463,7 @@ llvm_compile_expr(ExprState *state)
                    {
                        LLVMBuildCondBr(b,
                                        LLVMBuildICmp(b, LLVMIntEQ, v_output,
-                                                     l_sizet_const(0), ""),
+                                                     l_datum_const(0), ""),
                                        opblocks[opno + 1],
                                        b_inputcall);
                    }
@@ -1564,9 +1564,9 @@ llvm_compile_expr(ExprState *state)
                    LLVMPositionBuilderAtEnd(b, b_bothargnull);
                    LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
                    if (opcode == EEOP_NOT_DISTINCT)
-                       LLVMBuildStore(b, l_sizet_const(1), v_resvaluep);
+                       LLVMBuildStore(b, l_datum_const(1), v_resvaluep);
                    else
-                       LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
+                       LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
 
                    LLVMBuildBr(b, opblocks[opno + 1]);
 
@@ -1574,9 +1574,9 @@ llvm_compile_expr(ExprState *state)
                    LLVMPositionBuilderAtEnd(b, b_anyargnull);
                    LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
                    if (opcode == EEOP_NOT_DISTINCT)
-                       LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
+                       LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
                    else
-                       LLVMBuildStore(b, l_sizet_const(1), v_resvaluep);
+                       LLVMBuildStore(b, l_datum_const(1), v_resvaluep);
                    LLVMBuildBr(b, opblocks[opno + 1]);
 
                    /* neither argument is null: compare */
@@ -1592,8 +1592,8 @@ llvm_compile_expr(ExprState *state)
                            LLVMBuildZExt(b,
                                          LLVMBuildICmp(b, LLVMIntEQ,
                                                        v_result,
-                                                       l_sizet_const(0), ""),
-                                         TypeSizeT, "");
+                                                       l_datum_const(0), ""),
+                                         TypeDatum, "");
                    }
 
                    LLVMBuildStore(b, v_fcinfo_isnull, v_resnullp);
@@ -1691,7 +1691,7 @@ llvm_compile_expr(ExprState *state)
                                                             ""),
                                               LLVMBuildICmp(b, LLVMIntEQ,
                                                             v_retval,
-                                                            l_sizet_const(1),
+                                                            l_datum_const(1),
                                                             ""),
                                               "");
                    LLVMBuildCondBr(b, v_argsequal, b_argsequal, b_hasnull);
@@ -1699,7 +1699,7 @@ llvm_compile_expr(ExprState *state)
                    /* build block setting result to NULL, if args are equal */
                    LLVMPositionBuilderAtEnd(b, b_argsequal);
                    LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
-                   LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
+                   LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
 
                    LLVMBuildBr(b, opblocks[opno + 1]);
                    break;
@@ -1755,7 +1755,7 @@ llvm_compile_expr(ExprState *state)
 
                    LLVMPositionBuilderAtEnd(b, b_isnull);
 
-                   LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
+                   LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
                    LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
 
                    LLVMBuildBr(b, opblocks[op->d.returningexpr.jumpdone]);
@@ -1861,7 +1861,7 @@ llvm_compile_expr(ExprState *state)
                                    LLVMBuildICmp(b,
                                                  LLVMIntEQ,
                                                  v_retval,
-                                                 l_sizet_const(0), ""),
+                                                 l_datum_const(0), ""),
                                    opblocks[opno + 1],
                                    opblocks[op->d.rowcompare_step.jumpdone]);
 
@@ -1891,7 +1891,7 @@ llvm_compile_expr(ExprState *state)
                     */
                    v_cmpresult =
                        LLVMBuildTrunc(b,
-                                      l_load(b, TypeSizeT, v_resvaluep, ""),
+                                      l_load(b, TypeDatum, v_resvaluep, ""),
                                       LLVMInt32TypeInContext(lc), "");
 
                    switch (cmptype)
@@ -1920,7 +1920,7 @@ llvm_compile_expr(ExprState *state)
                                             v_cmpresult,
                                             l_int32_const(lc, 0),
                                             "");
-                   v_result = LLVMBuildZExt(b, v_result, TypeSizeT, "");
+                   v_result = LLVMBuildZExt(b, v_result, TypeDatum, "");
 
                    LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
                    LLVMBuildStore(b, v_result, v_resvaluep);
@@ -1961,11 +1961,11 @@ llvm_compile_expr(ExprState *state)
                                v_casenull;
 
                    v_casevaluep = l_ptr_const(op->d.casetest.value,
-                                              l_ptr(TypeSizeT));
+                                              l_ptr(TypeDatum));
                    v_casenullp = l_ptr_const(op->d.casetest.isnull,
                                              l_ptr(TypeStorageBool));
 
-                   v_casevalue = l_load(b, TypeSizeT, v_casevaluep, "");
+                   v_casevalue = l_load(b, TypeDatum, v_casevaluep, "");
                    v_casenull = l_load(b, TypeStorageBool, v_casenullp, "");
                    LLVMBuildStore(b, v_casevalue, v_resvaluep);
                    LLVMBuildStore(b, v_casenull, v_resnullp);
@@ -2014,7 +2014,7 @@ llvm_compile_expr(ExprState *state)
                {
                    LLVMValueRef v_initvalue;
 
-                   v_initvalue = l_sizet_const(op->d.hashdatum_initvalue.init_value);
+                   v_initvalue = l_datum_const(op->d.hashdatum_initvalue.init_value);
 
                    LLVMBuildStore(b, v_initvalue, v_resvaluep);
                    LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
@@ -2053,24 +2053,24 @@ llvm_compile_expr(ExprState *state)
                        LLVMValueRef tmp;
 
                        tmp = l_ptr_const(&op->d.hashdatum.iresult->value,
-                                         l_ptr(TypeSizeT));
+                                         l_ptr(TypeDatum));
 
                        /*
                         * Fetch the previously hashed value from where the
                         * previous hash operation stored it.
                         */
-                       v_prevhash = l_load(b, TypeSizeT, tmp, "prevhash");
+                       v_prevhash = l_load(b, TypeDatum, tmp, "prevhash");
 
                        /*
                         * Rotate bits left by 1 bit.  Be careful not to
-                        * overflow uint32 when working with size_t.
+                        * overflow uint32 when working with Datum.
                         */
-                       v_tmp1 = LLVMBuildShl(b, v_prevhash, l_sizet_const(1),
+                       v_tmp1 = LLVMBuildShl(b, v_prevhash, l_datum_const(1),
                                              "");
                        v_tmp1 = LLVMBuildAnd(b, v_tmp1,
-                                             l_sizet_const(0xffffffff), "");
+                                             l_datum_const(0xffffffff), "");
                        v_tmp2 = LLVMBuildLShr(b, v_prevhash,
-                                              l_sizet_const(31), "");
+                                              l_datum_const(31), "");
                        v_prevhash = LLVMBuildOr(b, v_tmp1, v_tmp2,
                                                 "rotatedhash");
                    }
@@ -2113,7 +2113,7 @@ llvm_compile_expr(ExprState *state)
                         * the NULL result and goto jumpdone.
                         */
                        LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
-                       LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
+                       LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
                        LLVMBuildBr(b, opblocks[op->d.hashdatum.jumpdone]);
                    }
                    else
@@ -2145,7 +2145,7 @@ llvm_compile_expr(ExprState *state)
                             * Store a zero Datum when the Datum to hash is
                             * NULL
                             */
-                           LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
+                           LLVMBuildStore(b, l_datum_const(0), v_resvaluep);
                        }
 
                        LLVMBuildBr(b, opblocks[opno + 1]);
@@ -2178,24 +2178,24 @@ llvm_compile_expr(ExprState *state)
                        LLVMValueRef tmp;
 
                        tmp = l_ptr_const(&op->d.hashdatum.iresult->value,
-                                         l_ptr(TypeSizeT));
+                                         l_ptr(TypeDatum));
 
                        /*
                         * Fetch the previously hashed value from where the
                         * previous hash operation stored it.
                         */
-                       v_prevhash = l_load(b, TypeSizeT, tmp, "prevhash");
+                       v_prevhash = l_load(b, TypeDatum, tmp, "prevhash");
 
                        /*
                         * Rotate bits left by 1 bit.  Be careful not to
-                        * overflow uint32 when working with size_t.
+                        * overflow uint32 when working with Datum.
                         */
-                       v_tmp1 = LLVMBuildShl(b, v_prevhash, l_sizet_const(1),
+                       v_tmp1 = LLVMBuildShl(b, v_prevhash, l_datum_const(1),
                                              "");
                        v_tmp1 = LLVMBuildAnd(b, v_tmp1,
-                                             l_sizet_const(0xffffffff), "");
+                                             l_datum_const(0xffffffff), "");
                        v_tmp2 = LLVMBuildLShr(b, v_prevhash,
-                                              l_sizet_const(31), "");
+                                              l_datum_const(31), "");
                        v_prevhash = LLVMBuildOr(b, v_tmp1, v_tmp2,
                                                 "rotatedhash");
                    }
@@ -2373,7 +2373,7 @@ llvm_compile_expr(ExprState *state)
                    v_aggno = l_int32_const(lc, op->d.aggref.aggno);
 
                    /* load agg value / null */
-                   value = l_load_gep1(b, TypeSizeT, v_aggvalues, v_aggno, "aggvalue");
+                   value = l_load_gep1(b, TypeDatum, v_aggvalues, v_aggno, "aggvalue");
                    isnull = l_load_gep1(b, TypeStorageBool, v_aggnulls, v_aggno, "aggnull");
 
                    /* and store result */
@@ -2408,7 +2408,7 @@ llvm_compile_expr(ExprState *state)
                    v_wfuncno = l_load(b, LLVMInt32TypeInContext(lc), v_wfuncnop, "v_wfuncno");
 
                    /* load window func value / null */
-                   value = l_load_gep1(b, TypeSizeT, v_aggvalues, v_wfuncno,
+                   value = l_load_gep1(b, TypeDatum, v_aggvalues, v_wfuncno,
                                        "windowvalue");
                    isnull = l_load_gep1(b, TypeStorageBool, v_aggnulls, v_wfuncno,
                                         "windownull");
@@ -2585,8 +2585,8 @@ llvm_compile_expr(ExprState *state)
 
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ,
-                                                 LLVMBuildPtrToInt(b, v_pergroup_allaggs, TypeSizeT, ""),
-                                                 l_sizet_const(0), ""),
+                                                 LLVMBuildPtrToInt(b, v_pergroup_allaggs, TypeDatum, ""),
+                                                 l_datum_const(0), ""),
                                    opblocks[jumpnull],
                                    opblocks[opno + 1]);
                    break;
@@ -2788,7 +2788,7 @@ llvm_compile_expr(ExprState *state)
                                     "transnullp");
                    LLVMBuildStore(b,
                                   l_load(b,
-                                         TypeSizeT,
+                                         TypeDatum,
                                          v_transvaluep,
                                          "transvalue"),
                                   l_funcvaluep(b, v_fcinfo, 0));
@@ -2826,7 +2826,7 @@ llvm_compile_expr(ExprState *state)
                        b_nocall = l_bb_before_v(opblocks[opno + 1],
                                                 "op.%d.transnocall", opno);
 
-                       v_transvalue = l_load(b, TypeSizeT, v_transvaluep, "");
+                       v_transvalue = l_load(b, TypeDatum, v_transvaluep, "");
                        v_transnull = l_load(b, TypeStorageBool, v_transnullp, "");
 
                        /*

diff --git a/src/backend/jit/llvm/llvmjit_types.c b/src/backend/jit/llvm/llvmjit_types.c
index dbe0282e98f4bd7bcf8648d0e262042834ed6fd2..167cd554b9c07e6ca2614d44d1cb9fae3156a2cb 100644 (file)
--- a/src/backend/jit/llvm/llvmjit_types.c
+++ b/src/backend/jit/llvm/llvmjit_types.c
@@ -47,6 +47,7 @@
  */
 PGFunction TypePGFunction;
 size_t     TypeSizeT;
+Datum      TypeDatum;
 bool       TypeStorageBool;
 
 ExecEvalSubroutine TypeExecEvalSubroutine;

diff --git a/src/include/jit/llvmjit.h b/src/include/jit/llvmjit.h
index 5038cf33e3fe9d9507387f85c6d8e3bc38ff8763..b3c75022f55cefa089cf8028bd78087a1efd1209 100644 (file)
--- a/src/include/jit/llvmjit.h
+++ b/src/include/jit/llvmjit.h
@@ -74,6 +74,7 @@ typedef struct LLVMJitContext
 extern PGDLLIMPORT LLVMTypeRef TypeParamBool;
 extern PGDLLIMPORT LLVMTypeRef TypePGFunction;
 extern PGDLLIMPORT LLVMTypeRef TypeSizeT;
+extern PGDLLIMPORT LLVMTypeRef TypeDatum;
 extern PGDLLIMPORT LLVMTypeRef TypeStorageBool;
 
 extern PGDLLIMPORT LLVMTypeRef StructNullableDatum;

diff --git a/src/include/jit/llvmjit_emit.h b/src/include/jit/llvmjit_emit.h
index df5a9fc85007a06648c286edfada8d6bb0f549b1..0e57a332b6ef30b94a7cfd9e1706d82e113f60b1 100644 (file)
--- a/src/include/jit/llvmjit_emit.h
+++ b/src/include/jit/llvmjit_emit.h
@@ -86,6 +86,15 @@ l_sizet_const(size_t i)
    return LLVMConstInt(TypeSizeT, i, false);
 }
 
+/*
+ * Emit constant integer.
+ */
+static inline LLVMValueRef
+l_datum_const(Datum i)
+{
+   return LLVMConstInt(TypeDatum, i, false);
+}
+
 /*
  * Emit constant boolean, as used for storage (e.g. global vars, structs).
  */
@@ -313,7 +322,7 @@ l_funcnull(LLVMBuilderRef b, LLVMValueRef v_fcinfo, size_t argno)
 static inline LLVMValueRef
 l_funcvalue(LLVMBuilderRef b, LLVMValueRef v_fcinfo, size_t argno)
 {
-   return l_load(b, TypeSizeT, l_funcvaluep(b, v_fcinfo, argno), "");
+   return l_load(b, TypeDatum, l_funcvaluep(b, v_fcinfo, argno), "");
 }
 
 #endif                         /* USE_LLVM */