Function compileSortDescription

src/Interpreters/JIT/compileFunction.cpp:594–763

}

static void compileSortDescription(llvm::Module & module,
    SortDescription & description,
    const DataTypes & sort_description_types,
    const std::string & sort_description_dump)
{
    llvm::IRBuilder<> b(module.getContext());

    auto * size_type = b.getIntNTy(sizeof(size_t) * 8);

    auto * column_data_type = buildColumnDataStruct(b);

    std::vector<llvm::Type *> function_argument_types = {size_type, size_type, column_data_type->getPointerTo(), column_data_type->getPointerTo()};
    auto * comparator_func_declaration = llvm::FunctionType::get(b.getInt8Ty(), function_argument_types, false);
    auto * comparator_func = llvm::Function::Create(comparator_func_declaration, llvm::Function::ExternalLinkage, sort_description_dump, module);
    /// The result is read back through an `int8_t (*)(...)` function pointer, so the i8 return
    /// must obey the C `int8_t` calling convention. This matters only on Darwin/Apple arm64:
    /// Apple's arm64 ABI makes the *callee* sign-extend sub-word return values and the caller
    /// relies on it (it emits no `sxtb` after the call). Without `signext` the JIT callee leaves
    /// the upper bits unset, so e.g. a -1 result is read as 255 and NULL ordering breaks.
    /// Linux arm64 (AAPCS64) is unaffected because there the *caller* sign-extends the return
    /// itself (`sxtb w0, w0`); x86-64 is likewise a no-op.
    comparator_func->addRetAttr(llvm::Attribute::SExt);

    auto * arguments = comparator_func->args().begin();
    llvm::Value * lhs_index_arg = arguments++;
    llvm::Value * rhs_index_arg = arguments++;
    llvm::Value * columns_lhs_arg = arguments++;
    llvm::Value * columns_rhs_arg = arguments++;

    size_t columns_size = description.size();

    std::vector<std::pair<llvm::BasicBlock *, llvm::Value *>> comparator_steps_and_results;
    for (size_t i = 0; i < columns_size; ++i)
    {
        auto * step = llvm::BasicBlock::Create(b.getContext(), "step_" + std::to_string(i), comparator_func);
        comparator_steps_and_results.emplace_back(step, nullptr);
    }

    auto * lhs_equals_rhs_result = llvm::ConstantInt::getSigned(b.getInt8Ty(), 0);

    auto * comparator_join = llvm::BasicBlock::Create(b.getContext(), "comparator_join", comparator_func);

    for (size_t i = 0; i < columns_size; ++i)
    {
        b.SetInsertPoint(comparator_steps_and_results[i].first);

        const auto & sort_description = description[i];
        const auto & column_type = sort_description_types[i];
        auto nested_column_type = removeNullable(column_type);

        auto dummy_column = column_type->createColumn();

        auto try_load_nullable_value = [&](llvm::Value * value, llvm::Value * nullable_uninitialized, llvm::Value * column_null_data, llvm::Value * index_arg) -> llvm::Value *
        {
            if (column_null_data)
            {
                auto * is_null_value_pointer = b.CreateInBoundsGEP(b.getInt8Ty(), column_null_data, index_arg);
                auto * is_null = b.CreateICmpNE(b.CreateLoad(b.getInt8Ty(), is_null_value_pointer), b.getInt8(0));