Adapt expression JIT to stdbool.h introduction.

The LLVM JIT provider uses clang to synchronize types between normal C
code and runtime generated code. Clang represents stdbool.h style
booleans in return values & parameters differently from booleans
stored in variables.

Thus the expression compilation code from 2a0faed9d needs to be
adapted to 9a95a77d9. Instead of hardcoding i8 as the type for
booleans (which already was wrong on some edge case platforms!), use
postgres' notion of a boolean as used for storage and for parameters.

Per buildfarm animal xenodermus.

Author: Andres Freund

diff --git a/src/backend/jit/llvm/llvmjit.c b/src/backend/jit/llvm/llvmjit.c
index 21d36605a4884faf4b433bed72de26f459b5c56e..cd3c40c5f1bda3a7407614ee8cba28673ee41c0f 100644 (file)
--- a/src/backend/jit/llvm/llvmjit.c
+++ b/src/backend/jit/llvm/llvmjit.c
@@ -46,6 +46,8 @@ typedef struct LLVMJitHandle
 
 /* types & functions commonly needed for JITing */
 LLVMTypeRef TypeSizeT;
+LLVMTypeRef TypeParamBool;
+LLVMTypeRef TypeStorageBool;
 LLVMTypeRef TypePGFunction;
 LLVMTypeRef StructHeapTupleFieldsField3;
 LLVMTypeRef StructHeapTupleFields;
@@ -682,7 +684,7 @@ llvm_shutdown(int code, Datum arg)
    }
 }
 
-/* helper for llvm_create_types */
+/* helper for llvm_create_types, returning a global var's type */
 static LLVMTypeRef
 load_type(LLVMModuleRef mod, const char *name)
 {
@@ -702,6 +704,31 @@ load_type(LLVMModuleRef mod, const char *name)
    return typ;
 }
 
+/* helper for llvm_create_types, returning a function's return type */
+static LLVMTypeRef
+load_return_type(LLVMModuleRef mod, const char *name)
+{
+   LLVMValueRef value;
+   LLVMTypeRef typ;
+
+   /* this'll return a *pointer* to the function */
+   value = LLVMGetNamedFunction(mod, name);
+   if (!value)
+       elog(ERROR, "function %s is unknown", name);
+
+   /* get type of function pointer */
+   typ = LLVMTypeOf(value);
+   Assert(typ != NULL);
+   /* dereference pointer */
+   typ = LLVMGetElementType(typ);
+   Assert(typ != NULL);
+   /* and look at return type */
+   typ = LLVMGetReturnType(typ);
+   Assert(typ != NULL);
+
+   return typ;
+}
+
 /*
  * Load required information, types, function signatures from llvmjit_types.c
  * and make them available in global variables.
@@ -740,6 +767,8 @@ llvm_create_types(void)
    llvm_layout = pstrdup(LLVMGetDataLayoutStr(mod));
 
    TypeSizeT = load_type(mod, "TypeSizeT");
+   TypeParamBool = load_return_type(mod, "FunctionReturningBool");
+   TypeStorageBool = load_type(mod, "TypeStorageBool");
    TypePGFunction = load_type(mod, "TypePGFunction");
    StructExprContext = load_type(mod, "StructExprContext");
    StructExprEvalStep = load_type(mod, "StructExprEvalStep");

diff --git a/src/backend/jit/llvm/llvmjit_expr.c b/src/backend/jit/llvm/llvmjit_expr.c
index 80638d6d818bfd63015bd236beeb9b30a0521504..667fb01d3be717639fcadeeb80116e6e951128f0 100644 (file)
--- a/src/backend/jit/llvm/llvmjit_expr.c
+++ b/src/backend/jit/llvm/llvmjit_expr.c
@@ -152,7 +152,7 @@ llvm_compile_expr(ExprState *state)
 
        param_types[0] = l_ptr(StructExprState);    /* state */
        param_types[1] = l_ptr(StructExprContext);  /* econtext */
-       param_types[2] = l_ptr(LLVMInt8Type()); /* isnull */
+       param_types[2] = l_ptr(TypeParamBool);      /* isnull */
 
        eval_sig = LLVMFunctionType(TypeSizeT,
                                    param_types, lengthof(param_types),
@@ -248,7 +248,7 @@ llvm_compile_expr(ExprState *state)
        opcode = ExecEvalStepOp(state, op);
 
        v_resvaluep = l_ptr_const(op->resvalue, l_ptr(TypeSizeT));
-       v_resnullp = l_ptr_const(op->resnull, l_ptr(LLVMInt8Type()));
+       v_resnullp = l_ptr_const(op->resnull, l_ptr(TypeStorageBool));
 
        switch (opcode)
        {
@@ -259,6 +259,8 @@ llvm_compile_expr(ExprState *state)
 
                    v_tmpvalue = LLVMBuildLoad(b, v_tmpvaluep, "");
                    v_tmpisnull = LLVMBuildLoad(b, v_tmpisnullp, "");
+                   v_tmpisnull =
+                       LLVMBuildTrunc(b, v_tmpisnull, TypeParamBool, "");
 
                    LLVMBuildStore(b, v_tmpisnull, v_isnullp);
 
@@ -521,7 +523,7 @@ llvm_compile_expr(ExprState *state)
                    /* check if value is NULL */
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_isnull,
-                                                 l_int8_const(0), ""),
+                                                 l_sbool_const(0), ""),
                                    b_notnull, opblocks[i + 1]);
 
                    /* if value is not null, convert to RO datum */
@@ -545,7 +547,7 @@ llvm_compile_expr(ExprState *state)
                                v_constnull;
 
                    v_constvalue = l_sizet_const(op->d.constval.value);
-                   v_constnull = l_int8_const(op->d.constval.isnull);
+                   v_constnull = l_sbool_const(op->d.constval.isnull);
 
                    LLVMBuildStore(b, v_constvalue, v_resvaluep);
                    LLVMBuildStore(b, v_constnull, v_resnullp);
@@ -587,7 +589,7 @@ llvm_compile_expr(ExprState *state)
                     * set resnull to true, if the function is actually
                     * called, it'll be reset
                     */
-                   LLVMBuildStore(b, l_int8_const(1), v_resnullp);
+                   LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
 
                    /* create blocks for checking args, one for each */
                    b_checkargnulls =
@@ -619,7 +621,7 @@ llvm_compile_expr(ExprState *state)
                        LLVMBuildCondBr(b,
                                        LLVMBuildICmp(b, LLVMIntEQ,
                                                      v_argisnull,
-                                                     l_int8_const(1),
+                                                     l_sbool_const(1),
                                                      ""),
                                        opblocks[i + 1],
                                        b_argnotnull);
@@ -661,8 +663,8 @@ llvm_compile_expr(ExprState *state)
                    LLVMValueRef v_boolanynullp;
 
                    v_boolanynullp = l_ptr_const(op->d.boolexpr.anynull,
-                                                l_ptr(LLVMInt8Type()));
-                   LLVMBuildStore(b, l_int8_const(0), v_boolanynullp);
+                                                l_ptr(TypeStorageBool));
+                   LLVMBuildStore(b, l_sbool_const(0), v_boolanynullp);
 
                    /* intentionally fall through */
                }
@@ -697,7 +699,7 @@ llvm_compile_expr(ExprState *state)
                                               "b.%d.boolcont", i);
 
                    v_boolanynullp = l_ptr_const(op->d.boolexpr.anynull,
-                                                l_ptr(LLVMInt8Type()));
+                                                l_ptr(TypeStorageBool));
 
                    v_boolnull = LLVMBuildLoad(b, v_resnullp, "");
                    v_boolvalue = LLVMBuildLoad(b, v_resvaluep, "");
@@ -710,14 +712,14 @@ llvm_compile_expr(ExprState *state)
                    /* check if current input is NULL */
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_boolnull,
-                                                 l_int8_const(1), ""),
+                                                 l_sbool_const(1), ""),
                                    b_boolisnull,
                                    b_boolcheckfalse);
 
                    /* build block that sets anynull */
                    LLVMPositionBuilderAtEnd(b, b_boolisnull);
                    /* set boolanynull to true */
-                   LLVMBuildStore(b, l_int8_const(1), v_boolanynullp);
+                   LLVMBuildStore(b, l_sbool_const(1), v_boolanynullp);
                    /* and jump to next block */
                    LLVMBuildBr(b, b_boolcont);
 
@@ -746,12 +748,12 @@ llvm_compile_expr(ExprState *state)
                    /* set value to NULL if any previous values were NULL */
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_boolanynull,
-                                                 l_int8_const(0), ""),
+                                                 l_sbool_const(0), ""),
                                    opblocks[i + 1], b_boolisanynull);
 
                    LLVMPositionBuilderAtEnd(b, b_boolisanynull);
                    /* set resnull to true */
-                   LLVMBuildStore(b, l_int8_const(1), v_resnullp);
+                   LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
                    /* reset resvalue */
                    LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
 
@@ -763,8 +765,8 @@ llvm_compile_expr(ExprState *state)
                    LLVMValueRef v_boolanynullp;
 
                    v_boolanynullp = l_ptr_const(op->d.boolexpr.anynull,
-                                                l_ptr(LLVMInt8Type()));
-                   LLVMBuildStore(b, l_int8_const(0), v_boolanynullp);
+                                                l_ptr(TypeStorageBool));
+                   LLVMBuildStore(b, l_sbool_const(0), v_boolanynullp);
 
                    /* intentionally fall through */
                }
@@ -800,7 +802,7 @@ llvm_compile_expr(ExprState *state)
                                               "b.%d.boolcont", i);
 
                    v_boolanynullp = l_ptr_const(op->d.boolexpr.anynull,
-                                                l_ptr(LLVMInt8Type()));
+                                                l_ptr(TypeStorageBool));
 
                    v_boolnull = LLVMBuildLoad(b, v_resnullp, "");
                    v_boolvalue = LLVMBuildLoad(b, v_resvaluep, "");
@@ -812,14 +814,14 @@ llvm_compile_expr(ExprState *state)
 
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_boolnull,
-                                                 l_int8_const(1), ""),
+                                                 l_sbool_const(1), ""),
                                    b_boolisnull,
                                    b_boolchecktrue);
 
                    /* build block that sets anynull */
                    LLVMPositionBuilderAtEnd(b, b_boolisnull);
                    /* set boolanynull to true */
-                   LLVMBuildStore(b, l_int8_const(1), v_boolanynullp);
+                   LLVMBuildStore(b, l_sbool_const(1), v_boolanynullp);
                    /* and jump to next block */
                    LLVMBuildBr(b, b_boolcont);
 
@@ -848,12 +850,12 @@ llvm_compile_expr(ExprState *state)
                    /* set value to NULL if any previous values were NULL */
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_boolanynull,
-                                                 l_int8_const(0), ""),
+                                                 l_sbool_const(0), ""),
                                    opblocks[i + 1], b_boolisanynull);
 
                    LLVMPositionBuilderAtEnd(b, b_boolisanynull);
                    /* set resnull to true */
-                   LLVMBuildStore(b, l_int8_const(1), v_resnullp);
+                   LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
                    /* reset resvalue */
                    LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
 
@@ -901,7 +903,7 @@ llvm_compile_expr(ExprState *state)
                    v_nullorfalse =
                        LLVMBuildOr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
-                                                 l_int8_const(1), ""),
+                                                 l_sbool_const(1), ""),
                                    LLVMBuildICmp(b, LLVMIntEQ, v_resvalue,
                                                  l_sizet_const(0), ""),
                                    "");
@@ -914,7 +916,7 @@ llvm_compile_expr(ExprState *state)
                    /* build block handling NULL or false */
                    LLVMPositionBuilderAtEnd(b, b_qualfail);
                    /* set resnull to false */
-                   LLVMBuildStore(b, l_int8_const(0), v_resnullp);
+                   LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
                    /* set resvalue to false */
                    LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
                    /* and jump out */
@@ -938,7 +940,7 @@ llvm_compile_expr(ExprState *state)
 
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
-                                                 l_int8_const(1), ""),
+                                                 l_sbool_const(1), ""),
                                    opblocks[op->d.jump.jumpdone],
                                    opblocks[i + 1]);
                    break;
@@ -954,7 +956,7 @@ llvm_compile_expr(ExprState *state)
 
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
-                                                 l_int8_const(0), ""),
+                                                 l_sbool_const(0), ""),
                                    opblocks[op->d.jump.jumpdone],
                                    opblocks[i + 1]);
                    break;
@@ -975,7 +977,7 @@ llvm_compile_expr(ExprState *state)
                    v_nullorfalse =
                        LLVMBuildOr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
-                                                 l_int8_const(1), ""),
+                                                 l_sbool_const(1), ""),
                                    LLVMBuildICmp(b, LLVMIntEQ, v_resvalue,
                                                  l_sizet_const(0), ""),
                                    "");
@@ -995,12 +997,12 @@ llvm_compile_expr(ExprState *state)
                    v_resvalue =
                        LLVMBuildSelect(b,
                                        LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
-                                                     l_int8_const(1), ""),
+                                                     l_sbool_const(1), ""),
                                        l_sizet_const(1),
                                        l_sizet_const(0),
                                        "");
                    LLVMBuildStore(b, v_resvalue, v_resvaluep);
-                   LLVMBuildStore(b, l_int8_const(0), v_resnullp);
+                   LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
 
                    LLVMBuildBr(b, opblocks[i + 1]);
                    break;
@@ -1014,12 +1016,12 @@ llvm_compile_expr(ExprState *state)
                    v_resvalue =
                        LLVMBuildSelect(b,
                                        LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
-                                                     l_int8_const(1), ""),
+                                                     l_sbool_const(1), ""),
                                        l_sizet_const(0),
                                        l_sizet_const(1),
                                        "");
                    LLVMBuildStore(b, v_resvalue, v_resvaluep);
-                   LLVMBuildStore(b, l_int8_const(0), v_resnullp);
+                   LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
 
                    LLVMBuildBr(b, opblocks[i + 1]);
                    break;
@@ -1054,14 +1056,14 @@ llvm_compile_expr(ExprState *state)
                    /* check if value is NULL */
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
-                                                 l_int8_const(1), ""),
+                                                 l_sbool_const(1), ""),
                                    b_isnull, b_notnull);
 
                    /* if value is NULL, return false */
                    LLVMPositionBuilderAtEnd(b, b_isnull);
 
                    /* result is not null */
-                   LLVMBuildStore(b, l_int8_const(0), v_resnullp);
+                   LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
 
                    if (opcode == EEOP_BOOLTEST_IS_TRUE ||
                        opcode == EEOP_BOOLTEST_IS_FALSE)
@@ -1179,7 +1181,7 @@ llvm_compile_expr(ExprState *state)
                    v_casevaluep = l_ptr_const(op->d.casetest.value,
                                               l_ptr(TypeSizeT));
                    v_casenullp = l_ptr_const(op->d.casetest.isnull,
-                                             l_ptr(LLVMInt8Type()));
+                                             l_ptr(TypeStorageBool));
 
                    v_casevaluenull =
                        LLVMBuildICmp(b, LLVMIntEQ,
@@ -1225,7 +1227,7 @@ llvm_compile_expr(ExprState *state)
                                              "op.%d.readonly.notnull", i);
 
                    v_nullp = l_ptr_const(op->d.make_readonly.isnull,
-                                         l_ptr(LLVMInt8Type()));
+                                         l_ptr(TypeStorageBool));
 
                    v_null = LLVMBuildLoad(b, v_nullp, "");
 
@@ -1235,7 +1237,7 @@ llvm_compile_expr(ExprState *state)
                    /* check if value is NULL */
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_null,
-                                                 l_int8_const(1), ""),
+                                                 l_sbool_const(1), ""),
                                    opblocks[i + 1], b_notnull);
 
                    /* if value is not null, convert to RO datum */
@@ -1324,7 +1326,7 @@ llvm_compile_expr(ExprState *state)
                    v_resnull = LLVMBuildLoad(b, v_resnullp, "");
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_resnull,
-                                                 l_int8_const(1), ""),
+                                                 l_sbool_const(1), ""),
                                    b_skipoutput,
                                    b_calloutput);
 
@@ -1340,7 +1342,7 @@ llvm_compile_expr(ExprState *state)
                                   v_resvalue,
                                   LLVMBuildStructGEP(b, v_out_argp, 0, ""));
                    LLVMBuildStore(b,
-                                  l_int8_const(0),
+                                  l_sbool_const(0),
                                   LLVMBuildStructGEP(b, v_out_argnullp,
                                                      0, ""));
                    /* and call output function (can never return NULL) */
@@ -1397,7 +1399,7 @@ llvm_compile_expr(ExprState *state)
                    /* arg2: typmod: preset in execExpr.c  */
 
                    /* reset fcinfo_in->isnull */
-                   LLVMBuildStore(b, l_int8_const(0), v_fcinfo_in_isnullp);
+                   LLVMBuildStore(b, l_sbool_const(0), v_fcinfo_in_isnullp);
                    /* and call function */
                    v_retval = LLVMBuildCall(b, v_fn_addr_in, &v_fcinfo_in, 1,
                                             "funccall_iocoerce_in");
@@ -1448,11 +1450,11 @@ llvm_compile_expr(ExprState *state)
                    /* load argnull[0|1] for both arguments */
                    v_argnull0 = l_load_struct_gep(b, v_argnullp, 0, "");
                    v_argisnull0 = LLVMBuildICmp(b, LLVMIntEQ, v_argnull0,
-                                                l_int8_const(1), "");
+                                                l_sbool_const(1), "");
 
                    v_argnull1 = l_load_struct_gep(b, v_argnullp, 1, "");
                    v_argisnull1 = LLVMBuildICmp(b, LLVMIntEQ, v_argnull1,
-                                                l_int8_const(1), "");
+                                                l_sbool_const(1), "");
 
                    v_anyargisnull = LLVMBuildOr(b, v_argisnull0, v_argisnull1, "");
                    v_bothargisnull = LLVMBuildAnd(b, v_argisnull0, v_argisnull1, "");
@@ -1475,7 +1477,7 @@ llvm_compile_expr(ExprState *state)
 
                    /* Both NULL? Then is not distinct... */
                    LLVMPositionBuilderAtEnd(b, b_bothargnull);
-                   LLVMBuildStore(b, l_int8_const(0), v_resnullp);
+                   LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
                    if (opcode == EEOP_NOT_DISTINCT)
                        LLVMBuildStore(b, l_sizet_const(1), v_resvaluep);
                    else
@@ -1485,7 +1487,7 @@ llvm_compile_expr(ExprState *state)
 
                    /* Only one is NULL? Then is distinct... */
                    LLVMPositionBuilderAtEnd(b, b_anyargnull);
-                   LLVMBuildStore(b, l_int8_const(0), v_resnullp);
+                   LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
                    if (opcode == EEOP_NOT_DISTINCT)
                        LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
                    else
@@ -1562,9 +1564,9 @@ llvm_compile_expr(ExprState *state)
                    v_anyargisnull =
                        LLVMBuildOr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_argnull0,
-                                                 l_int8_const(1), ""),
+                                                 l_sbool_const(1), ""),
                                    LLVMBuildICmp(b, LLVMIntEQ, v_argnull1,
-                                                 l_int8_const(1), ""),
+                                                 l_sbool_const(1), ""),
                                    "");
 
                    LLVMBuildCondBr(b, v_anyargisnull, b_hasnull, b_nonull);
@@ -1589,7 +1591,7 @@ llvm_compile_expr(ExprState *state)
                    v_argsequal = LLVMBuildAnd(b,
                                               LLVMBuildICmp(b, LLVMIntEQ,
                                                             v_fcinfo_isnull,
-                                                            l_int8_const(0),
+                                                            l_sbool_const(0),
                                                             ""),
                                               LLVMBuildICmp(b, LLVMIntEQ,
                                                             v_retval,
@@ -1600,7 +1602,7 @@ llvm_compile_expr(ExprState *state)
 
                    /* build block setting result to NULL, if args are equal */
                    LLVMPositionBuilderAtEnd(b, b_argsequal);
-                   LLVMBuildStore(b, l_int8_const(1), v_resnullp);
+                   LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
                    LLVMBuildStore(b, l_sizet_const(0), v_resvaluep);
                    LLVMBuildStore(b, v_retval, v_resvaluep);
 
@@ -1691,11 +1693,11 @@ llvm_compile_expr(ExprState *state)
                                        LLVMBuildICmp(b,
                                                      LLVMIntEQ,
                                                      v_argnull0,
-                                                     l_int8_const(1),
+                                                     l_sbool_const(1),
                                                      ""),
                                        LLVMBuildICmp(b, LLVMIntEQ,
                                                      v_argnull1,
-                                                     l_int8_const(1), ""),
+                                                     l_sbool_const(1), ""),
                                        "");
 
                        LLVMBuildCondBr(b, v_anyargisnull, b_null, b_compare);
@@ -1718,7 +1720,7 @@ llvm_compile_expr(ExprState *state)
                                    LLVMBuildICmp(b,
                                                  LLVMIntEQ,
                                                  v_fcinfo_isnull,
-                                                 l_int8_const(0),
+                                                 l_sbool_const(0),
                                                  ""),
                                    b_compare_result,
                                    b_null);
@@ -1740,7 +1742,7 @@ llvm_compile_expr(ExprState *state)
                     * result.
                     */
                    LLVMPositionBuilderAtEnd(b, b_null);
-                   LLVMBuildStore(b, l_int8_const(1), v_resnullp);
+                   LLVMBuildStore(b, l_sbool_const(1), v_resnullp);
                    LLVMBuildBr(b, opblocks[op->d.rowcompare_step.jumpnull]);
 
                    break;
@@ -1792,7 +1794,7 @@ llvm_compile_expr(ExprState *state)
                                             "");
                    v_result = LLVMBuildZExt(b, v_result, TypeSizeT, "");
 
-                   LLVMBuildStore(b, l_int8_const(0), v_resnullp);
+                   LLVMBuildStore(b, l_sbool_const(0), v_resnullp);
                    LLVMBuildStore(b, v_result, v_resvaluep);
 
                    LLVMBuildBr(b, opblocks[i + 1]);
@@ -1836,10 +1838,11 @@ llvm_compile_expr(ExprState *state)
                    v_params[1] = l_ptr_const(op, l_ptr(StructExprEvalStep));
                    v_ret = LLVMBuildCall(b, v_fn,
                                          v_params, lengthof(v_params), "");
+                   v_ret = LLVMBuildZExt(b, v_ret, TypeStorageBool, "");
 
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_ret,
-                                                 l_int8_const(1), ""),
+                                                 l_sbool_const(1), ""),
                                    opblocks[i + 1],
                                    opblocks[jumpdone]);
                    break;
@@ -1863,7 +1866,7 @@ llvm_compile_expr(ExprState *state)
                    v_casevaluep = l_ptr_const(op->d.casetest.value,
                                               l_ptr(TypeSizeT));
                    v_casenullp = l_ptr_const(op->d.casetest.isnull,
-                                             l_ptr(LLVMInt8Type()));
+                                             l_ptr(TypeStorageBool));
 
                    v_casevaluenull =
                        LLVMBuildICmp(b, LLVMIntEQ,
@@ -2032,7 +2035,7 @@ llvm_compile_expr(ExprState *state)
                                    LLVMBuildICmp(b,
                                                  LLVMIntEQ,
                                                  v_argnull0,
-                                                 l_int8_const(1),
+                                                 l_sbool_const(1),
                                                  ""),
                                    opblocks[op->d.agg_deserialize.jumpnull],
                                    b_deserialize);
@@ -2080,7 +2083,7 @@ llvm_compile_expr(ExprState *state)
                    LLVMBasicBlockRef *b_checknulls;
 
                    jumpnull = op->d.agg_strict_input_check.jumpnull;
-                   v_nullp = l_ptr_const(nulls, l_ptr(LLVMInt8Type()));
+                   v_nullp = l_ptr_const(nulls, l_ptr(TypeStorageBool));
 
                    /* create blocks for checking args */
                    b_checknulls = palloc(sizeof(LLVMBasicBlockRef *) * nargs);
@@ -2114,7 +2117,7 @@ llvm_compile_expr(ExprState *state)
                                        LLVMBuildICmp(b,
                                                      LLVMIntEQ,
                                                      v_argisnull,
-                                                     l_int8_const(1), ""),
+                                                     l_sbool_const(1), ""),
                                        opblocks[jumpnull],
                                        b_argnotnull);
                    }
@@ -2175,7 +2178,7 @@ llvm_compile_expr(ExprState *state)
 
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_notransvalue,
-                                                 l_int8_const(1), ""),
+                                                 l_sbool_const(1), ""),
                                    b_init,
                                    opblocks[i + 1]);
 
@@ -2240,7 +2243,7 @@ llvm_compile_expr(ExprState *state)
 
                    LLVMBuildCondBr(b,
                                    LLVMBuildICmp(b, LLVMIntEQ, v_transnull,
-                                                 l_int8_const(1), ""),
+                                                 l_sbool_const(1), ""),
                                    opblocks[jumpnull],
                                    opblocks[i + 1]);
 
@@ -2417,9 +2420,11 @@ llvm_compile_expr(ExprState *state)
                        params[0] = v_aggstatep;
                        params[1] = v_pertransp;
                        params[2] = v_retval;
-                       params[3] = v_fcinfo_isnull;
+                       params[3] = LLVMBuildTrunc(b, v_fcinfo_isnull,
+                                                  TypeParamBool, "");
                        params[4] = v_transvalue;
-                       params[5] = v_transnull;
+                       params[5] = LLVMBuildTrunc(b, v_transnull,
+                                                  TypeParamBool, "");
 
                        v_fn = llvm_get_decl(mod, FuncExecAggTransReparent);
                        v_newval =
@@ -2536,8 +2541,7 @@ BuildV1Call(LLVMJitContext *context, LLVMBuilderRef b,
    v_fcinfo_isnullp = LLVMBuildStructGEP(b, v_fcinfo,
                                          FIELDNO_FUNCTIONCALLINFODATA_ISNULL,
                                          "v_fcinfo_isnull");
-   LLVMBuildStore(b, l_int8_const(0),
-                  v_fcinfo_isnullp);
+   LLVMBuildStore(b, l_sbool_const(0), v_fcinfo_isnullp);
 
    v_retval = LLVMBuildCall(b, v_fn, &v_fcinfo, 1, "funccall");
 

diff --git a/src/backend/jit/llvm/llvmjit_types.c b/src/backend/jit/llvm/llvmjit_types.c
index e40dff3886323b23216bbe4f8fcc6f7b633cca19..84bc140737396d11a6950dd0747b7e43b3059493 100644 (file)
--- a/src/backend/jit/llvm/llvmjit_types.c
+++ b/src/backend/jit/llvm/llvmjit_types.c
@@ -45,8 +45,9 @@
  * clang/LLVM will omit them.  As this file will never be linked into
  * anything, that's harmless.
  */
-size_t     TypeSizeT;
 PGFunction TypePGFunction;
+size_t     TypeSizeT;
+bool       TypeStorageBool;
 
 AggState   StructAggState;
 AggStatePerGroupData StructAggStatePerGroupData;
@@ -73,6 +74,19 @@ AttributeTemplate(PG_FUNCTION_ARGS)
    PG_RETURN_NULL();
 }
 
+/*
+ * Clang represents stdbool.h style booleans that are returned by functions
+ * differently (as i1) than stored ones (as i8). Therefore we do not just need
+ * TypeBool (above), but also a way to determine the width of a returned
+ * integer. This allows us to keep compatible with non-stdbool using
+ * architectures.
+ */
+extern bool FunctionReturningBool(void);
+bool
+FunctionReturningBool(void)
+{
+   return false;
+}
 
 /*
  * To force signatures of functions used during JITing to be present,

diff --git a/src/include/jit/llvmjit.h b/src/include/jit/llvmjit.h
index 0c97d231f1d5b2aeef018935e5a60695816d5e1c..cc908477e8e379f0c612eb1fa26f923ffaa280ea 100644 (file)
--- a/src/include/jit/llvmjit.h
+++ b/src/include/jit/llvmjit.h
@@ -56,8 +56,11 @@ typedef struct LLVMJitContext
 
 
 /* type and struct definitions */
-extern LLVMTypeRef TypeSizeT;
+extern LLVMTypeRef TypeParamBool;
 extern LLVMTypeRef TypePGFunction;
+extern LLVMTypeRef TypeSizeT;
+extern LLVMTypeRef TypeStorageBool;
+
 extern LLVMTypeRef StructtupleDesc;
 extern LLVMTypeRef StructHeapTupleData;
 extern LLVMTypeRef StructTupleTableSlot;

diff --git a/src/include/jit/llvmjit_emit.h b/src/include/jit/llvmjit_emit.h
index 374c8335ba16501e383389a62e9a226d7d007f10..0d1b246f42ace87b40592c1e7afc16da5e7a8fd7 100644 (file)
--- a/src/include/jit/llvmjit_emit.h
+++ b/src/include/jit/llvmjit_emit.h
@@ -78,6 +78,24 @@ l_sizet_const(size_t i)
    return LLVMConstInt(TypeSizeT, i, false);
 }
 
+/*
+ * Emit constant boolean, as used for storage (e.g. global vars, structs).
+ */
+static inline LLVMValueRef
+l_sbool_const(bool i)
+{
+   return LLVMConstInt(TypeStorageBool, (int) i, false);
+}
+
+/*
+ * Emit constant boolean, as used for parameters (e.g. function parameters).
+ */
+static inline LLVMValueRef
+l_pbool_const(bool i)
+{
+   return LLVMConstInt(TypeParamBool, (int) i, false);
+}
+
 /*
  * Load a pointer member idx from a struct.
  */