Function compileFunction

src/Interpreters/JIT/compileFunction.cpp:108–208

}

static void compileFunction(llvm::Module & module, const IFunctionBase & function)
{
    const auto & function_argument_types = function.getArgumentTypes();

    llvm::IRBuilder<> b(module.getContext());
    auto * size_type = b.getIntNTy(sizeof(size_t) * 8);
    auto * data_type = buildColumnDataStruct(b);
    auto * func_type = llvm::FunctionType::get(b.getVoidTy(), { size_type, data_type->getPointerTo() }, /*isVarArg=*/false);

    /// Create function in module

    auto * func = llvm::Function::Create(func_type, llvm::Function::ExternalLinkage, function.getName(), module);
    auto * args = func->args().begin();
    llvm::Value * rows_count_arg = args++;
    llvm::Value * columns_arg = args++;

    /// Initialize ColumnDataPlaceholder llvm representation of ColumnData

    auto * entry = llvm::BasicBlock::Create(b.getContext(), "entry", func);
    b.SetInsertPoint(entry);

    std::vector<ColumnDataPlaceholder> columns(function_argument_types.size() + 1);
    for (size_t i = 0; i <= function_argument_types.size(); ++i)
    {
        const auto & function_argument_type = i == function_argument_types.size() ? function.getResultType() : function_argument_types[i];
        auto * data = b.CreateLoad(data_type, b.CreateConstInBoundsGEP1_64(data_type, columns_arg, i));
        columns[i].data_ptr = b.CreateExtractValue(data, {0});
        columns[i].data_element_type = toNativeType(b, removeNullable(function_argument_type));
        columns[i].null_data_ptr = function_argument_type->isNullable() ? b.CreateExtractValue(data, {1}) : nullptr;
    }

    /// Initialize loop

    auto * end = llvm::BasicBlock::Create(b.getContext(), "end", func);
    auto * loop = llvm::BasicBlock::Create(b.getContext(), "loop", func);
    b.CreateCondBr(b.CreateICmpEQ(rows_count_arg, llvm::ConstantInt::get(size_type, 0)), end, loop);

    b.SetInsertPoint(loop);

    /// Loop

    auto * counter_phi = b.CreatePHI(rows_count_arg->getType(), 2);
    counter_phi->addIncoming(llvm::ConstantInt::get(size_type, 0), entry);

    /// Initialize column row values

    ValuesWithType arguments;
    arguments.reserve(function_argument_types.size());

    for (size_t i = 0; i < function_argument_types.size(); ++i)
    {
        auto & column = columns[i];
        const auto & type = function_argument_types[i];

        auto * column_data_ptr = column.data_ptr;
        auto * column_element_value = b.CreateLoad(column.data_element_type, b.CreateInBoundsGEP(column.data_element_type, column_data_ptr, counter_phi));

        if (!type->isNullable())