Method BuildFunctionCall

cpp/src/gandiva/llvm_generator.cc:1255–1308

}

LValuePtr LLVMGenerator::Visitor::BuildFunctionCall(const NativeFunction* func,
                                                    DataTypePtr arrow_return_type,
                                                    std::vector<llvm::Value*>* params) {
  auto types = generator_->types();
  auto arrow_return_type_id = arrow_return_type->id();
  auto llvm_return_type = types->IRType(arrow_return_type_id);
  DecimalIR decimalIR(generator_->engine_.get());

  if (arrow_return_type_id == arrow::Type::DECIMAL) {
    // For decimal fns, the output precision/scale are passed along as parameters.
    //
    // convert from this :
    //     out = add_decimal(v1, p1, s1, v2, p2, s2)
    // to:
    //     out = add_decimal(v1, p1, s1, v2, p2, s2, out_p, out_s)

    // Append the out_precision and out_scale
    auto ret_lvalue = generator_->BuildDecimalLValue(nullptr, arrow_return_type);
    params->push_back(ret_lvalue->precision());
    params->push_back(ret_lvalue->scale());

    // Make the function call
    auto out = decimalIR.CallDecimalFunction(func->pc_name(), llvm_return_type, *params);
    ret_lvalue->set_data(out);
    return ret_lvalue;
  } else {
    bool isDecimalFunction = false;
    for (auto& arg : *params) {
      if (arg->getType() == types->i128_type()) {
        isDecimalFunction = true;
      }
    }
    // add extra arg for return length for variable len return types (allocated on stack).
    llvm::AllocaInst* result_len_ptr = nullptr;
    if (arrow::is_binary_like(arrow_return_type_id)) {
      result_len_ptr = new llvm::AllocaInst(generator_->types()->i32_type(), 0,
                                            "result_len", entry_block_);
      params->push_back(result_len_ptr);
      has_arena_allocs_ = true;
    }

    // Make the function call
    llvm::IRBuilder<>* builder = ir_builder();
    auto value =
        isDecimalFunction
            ? decimalIR.CallDecimalFunction(func->pc_name(), llvm_return_type, *params)
            : generator_->AddFunctionCall(func->pc_name(), llvm_return_type, *params);
    auto value_len =
        (result_len_ptr == nullptr)
            ? nullptr
            : builder->CreateLoad(result_len_ptr->getAllocatedType(), result_len_ptr);
    return std::make_shared<LValue>(value, value_len);
  }
}

std::vector<llvm::Value*> LLVMGenerator::Visitor::BuildParams(
    int holder_idx, const ValueValidityPairVector& args, bool with_validity,