19 #include <llvm/IR/InstIterator.h>
20 #include <llvm/IR/Verifier.h>
21 #include <llvm/Support/raw_os_ostream.h>
22 #include <llvm/Transforms/Utils/BasicBlockUtils.h>
24 #include <boost/algorithm/string.hpp>
33 const auto pi8_type = llvm::PointerType::get(
get_int_type(8, ctx), 0);
34 const auto ppi8_type = llvm::PointerType::get(pi8_type, 0);
35 const auto pi64_type = llvm::PointerType::get(
get_int_type(64, ctx), 0);
36 const auto ppi64_type = llvm::PointerType::get(pi64_type, 0);
39 const auto func_type = llvm::FunctionType::get(
41 {pi8_type, ppi8_type, pi64_type, ppi8_type, ppi64_type, ppi8_type, pi64_type},
44 auto func = llvm::Function::Create(func_type,
45 llvm::Function::ExternalLinkage,
46 "call_table_function",
48 auto arg_it = func->arg_begin();
49 const auto mgr_arg = &*arg_it;
50 mgr_arg->setName(
"mgr_ptr");
51 const auto input_cols_arg = &*(++arg_it);
52 input_cols_arg->setName(
"input_col_buffers");
53 const auto input_row_counts = &*(++arg_it);
54 input_row_counts->setName(
"input_row_counts");
55 const auto input_str_dict_proxies = &*(++arg_it);
56 input_str_dict_proxies->setName(
"input_str_dict_proxies");
57 const auto output_buffers = &*(++arg_it);
58 output_buffers->setName(
"output_buffers");
59 const auto output_str_dict_proxies = &*(++arg_it);
60 output_str_dict_proxies->setName(
"output_str_dict_proxies");
61 const auto output_row_count = &*(++arg_it);
62 output_row_count->setName(
"output_row_count");
67 llvm::LLVMContext& ctx) {
68 if (elem_ti.
is_fp()) {
85 LOG(
FATAL) <<
"get_llvm_type_from_sql_column_type: not implemented for "
92 llvm::Value* value_ptr,
93 llvm::IRBuilder<>& ir_builder) {
94 if (value_ptr !=
nullptr) {
95 if (value_ptr->getType() == member_llvm_type->getPointerElementType()) {
96 ir_builder.CreateStore(value_ptr, member_ptr);
98 auto tmp = ir_builder.CreateBitCast(value_ptr, member_llvm_type);
99 ir_builder.CreateStore(tmp, member_ptr);
102 ir_builder.CreateStore(llvm::Constant::getNullValue(member_llvm_type), member_ptr);
108 int64_t default_value,
109 llvm::LLVMContext& ctx,
110 llvm::IRBuilder<>& ir_builder) {
111 llvm::Value* val =
nullptr;
112 if (value !=
nullptr) {
113 auto value_type = value->getType();
114 if (value_type->isPointerTy()) {
115 CHECK(value_type->getPointerElementType()->isIntegerTy(64));
116 val = ir_builder.CreateLoad(value->getType()->getPointerElementType(), value);
118 CHECK(value_type->isIntegerTy(64));
121 ir_builder.CreateStore(val, member_ptr);
124 llvm::ConstantInt::get(llvm::Type::getInt64Ty(ctx), default_value,
true);
125 ir_builder.CreateStore(const_default, member_ptr);
129 std::tuple<llvm::Value*, llvm::Value*>
alloc_column(std::string col_name,
132 llvm::Value* data_ptr,
133 llvm::Value* data_size,
134 llvm::Value* data_str_dict_proxy_ptr,
135 llvm::LLVMContext& ctx,
136 llvm::IRBuilder<>& ir_builder) {
150 const bool is_text_encoding_dict_type =
153 llvm::StructType* col_struct_type;
156 if (is_text_encoding_dict_type) {
157 col_struct_type = llvm::StructType::get(
161 llvm::Type::getInt64Ty(ctx),
162 llvm::Type::getInt8PtrTy(ctx)
166 llvm::StructType::get(ctx,
169 llvm::Type::getInt64Ty(ctx)
173 auto col = ir_builder.CreateAlloca(col_struct_type);
174 col->setName(col_name);
175 auto col_ptr_ptr = ir_builder.CreateStructGEP(col_struct_type, col, 0);
176 auto col_sz_ptr = ir_builder.CreateStructGEP(col_struct_type, col, 1);
177 auto col_str_dict_ptr = is_text_encoding_dict_type
178 ? ir_builder.CreateStructGEP(col_struct_type, col, 2)
180 col_ptr_ptr->setName(col_name +
".ptr");
181 col_sz_ptr->setName(col_name +
".sz");
182 if (is_text_encoding_dict_type) {
183 col_str_dict_ptr->setName(col_name +
".string_dict_proxy");
188 if (is_text_encoding_dict_type) {
190 llvm::Type::getInt8PtrTy(ctx),
191 data_str_dict_proxy_ptr,
194 auto col_ptr = ir_builder.CreatePointerCast(
195 col_ptr_ptr, llvm::PointerType::get(llvm::Type::getInt8Ty(ctx), 0));
196 col_ptr->setName(col_name +
"_ptr");
197 return {col, col_ptr};
202 llvm::Value* data_ptrs,
204 llvm::Value* data_size,
205 llvm::Value* data_str_dict_proxy_ptrs,
206 llvm::LLVMContext& ctx,
207 llvm::IRBuilder<>& ir_builder) {
214 llvm::Type* data_ptrs_llvm_type = llvm::Type::getInt8PtrTy(ctx);
215 const bool is_text_encoding_dict_type =
219 llvm::StructType* col_list_struct_type =
220 is_text_encoding_dict_type
221 ? llvm::StructType::get(
225 llvm::Type::getInt64Ty(ctx),
226 llvm::Type::getInt64Ty(ctx),
229 : llvm::StructType::get(ctx,
232 llvm::Type::getInt64Ty(ctx),
233 llvm::Type::getInt64Ty(ctx)
236 auto col_list = ir_builder.CreateAlloca(col_list_struct_type);
237 col_list->setName(col_list_name);
238 auto col_list_ptr_ptr = ir_builder.CreateStructGEP(col_list_struct_type, col_list, 0);
239 auto col_list_length_ptr =
240 ir_builder.CreateStructGEP(col_list_struct_type, col_list, 1);
241 auto col_list_size_ptr = ir_builder.CreateStructGEP(col_list_struct_type, col_list, 2);
242 auto col_str_dict_ptr_ptr =
243 is_text_encoding_dict_type
244 ? ir_builder.CreateStructGEP(col_list_struct_type, col_list, 3)
247 col_list_ptr_ptr->setName(col_list_name +
".ptrs");
248 col_list_length_ptr->setName(col_list_name +
".length");
249 col_list_size_ptr->setName(col_list_name +
".size");
250 if (is_text_encoding_dict_type) {
251 col_str_dict_ptr_ptr->setName(col_list_name +
".string_dict_proxies");
257 auto const_length = llvm::ConstantInt::get(llvm::Type::getInt64Ty(ctx), length,
true);
258 ir_builder.CreateStore(const_length, col_list_length_ptr);
262 if (is_text_encoding_dict_type) {
264 data_str_dict_proxy_ptrs->getType(),
265 data_str_dict_proxy_ptrs,
269 auto col_list_ptr = ir_builder.CreatePointerCast(
270 col_list_ptr_ptr, llvm::PointerType::get(llvm::Type::getInt8Ty(ctx), 0));
271 col_list_ptr->setName(col_list_name +
"_ptrs");
306 throw std::runtime_error(
"Unsupported cast from " + orig_ti.
get_type_name() +
" to " +
312 llvm::Function* func,
316 llvm::IRBuilder<>& ir_builder,
317 llvm::LLVMContext& ctx,
347 llvm::BasicBlock* for_pre =
348 llvm::BasicBlock::Create(ctx,
"for_pre_cast." + index, func);
349 llvm::BasicBlock* for_cond =
350 llvm::BasicBlock::Create(ctx,
"for_cond_cast." + index, func);
351 llvm::BasicBlock* for_body =
352 llvm::BasicBlock::Create(ctx,
"for_body_cast." + index, func);
353 llvm::BasicBlock* for_end =
354 llvm::BasicBlock::Create(ctx,
"for_end_cast." + index, func);
355 ir_builder.CreateBr(for_pre);
358 ir_builder.SetInsertPoint(for_pre);
360 llvm::StructType* col_struct_type =
361 llvm::StructType::get(ctx, {data_type, ir_builder.getInt64Ty()});
362 llvm::Value* struct_cast = ir_builder.CreateBitCast(
363 col_base_ptr, col_struct_type->getPointerTo(),
"col_struct." + index);
364 llvm::Value* gep_ptr = ir_builder.CreateStructGEP(
365 col_struct_type, struct_cast, 0,
"col_ptr_addr." + index);
366 llvm::Value* col_ptr = ir_builder.CreateLoad(data_type, gep_ptr,
"col_ptr." + index);
367 llvm::Value* gep_sz =
368 ir_builder.CreateStructGEP(col_struct_type, struct_cast, 1,
"col_sz_addr." + index);
369 llvm::Value* col_sz =
370 ir_builder.CreateLoad(ir_builder.getInt64Ty(), gep_sz,
"col_sz." + index);
371 ir_builder.CreateBr(for_cond);
374 ir_builder.SetInsertPoint(for_cond);
375 llvm::PHINode* for_ind_var =
376 ir_builder.CreatePHI(ir_builder.getInt64Ty(), 2,
"for_ind_var." + index);
377 for_ind_var->addIncoming(ir_builder.getInt64(0), for_pre);
378 llvm::Value* for_pred =
379 ir_builder.CreateICmpSLT(for_ind_var, col_sz,
"for_pred." + index);
380 ir_builder.CreateCondBr(for_pred, for_body, for_end);
383 ir_builder.SetInsertPoint(for_body);
385 llvm::Value* val_gep = ir_builder.CreateInBoundsGEP(
386 ir_builder.getInt64Ty(), col_ptr, for_ind_var,
"val_gep." + index);
387 llvm::Value* val_load =
388 ir_builder.CreateLoad(ir_builder.getInt64Ty(), val_gep,
"val_load." + index);
389 llvm::Value* cast_result =
cast_value(val_load, orig_ti, dest_ti,
false, codeGenerator);
390 cast_result->setName(
"cast_result." + index);
391 ir_builder.CreateStore(cast_result, val_gep);
392 llvm::Value* for_inc =
393 ir_builder.CreateAdd(for_ind_var, ir_builder.getInt64(1),
"for_inc." + index);
394 ir_builder.CreateBr(for_cond);
397 llvm::Instruction* inc_as_inst = llvm::cast<llvm::Instruction>(for_inc);
398 for_ind_var->addIncoming(for_inc, inc_as_inst->getParent());
399 ir_builder.SetInsertPoint(for_end);
402 std::string
exprsKey(
const std::vector<Analyzer::Expr*>& exprs) {
404 for (
const auto& expr : exprs) {
405 const auto& ti = expr->get_type_info();
406 result += ti.to_string() +
", ";
415 bool emit_only_preflight_fn) {
434 auto cgen_state =
executor_->getCgenStatePtr();
436 CHECK(cgen_state->module_ ==
nullptr);
437 cgen_state->set_module_shallow_copy(
executor_->get_rt_module());
444 CHECK(!emit_only_preflight_fn);
456 auto mod =
executor_->get_rt_udf_module(is_gpu).get();
457 if (mod !=
nullptr) {
458 auto* flag = mod->getModuleFlag(
"pass_column_arguments_by_value");
459 if (
auto* cnt = llvm::mdconst::extract_or_null<llvm::ConstantInt>(flag)) {
460 return cnt->getZExtValue();
470 const std::vector<llvm::Value*>& func_args,
471 llvm::BasicBlock* bb_exit,
472 llvm::Value* output_row_count_ptr,
473 bool emit_only_preflight_fn) {
474 auto cgen_state =
executor_->getCgenStatePtr();
476 llvm::LLVMContext& ctx = cgen_state->context_;
477 llvm::IRBuilder<>* ir_builder = &cgen_state->ir_builder_;
479 std::string func_name =
482 llvm::Value* table_func_return =
483 cgen_state->emitExternalCall(func_name,
get_int_type(32, ctx), func_args);
485 table_func_return->setName(emit_only_preflight_fn ?
"preflight_check_func_ret"
491 llvm::BasicBlock* bb_exit_0 =
494 llvm::Constant* const_zero =
495 llvm::ConstantInt::get(table_func_return->getType(), 0,
true);
496 llvm::Value* is_ok = ir_builder->CreateICmpSGE(table_func_return, const_zero);
497 ir_builder->CreateCondBr(is_ok, bb_exit_0, bb_exit);
499 ir_builder->SetInsertPoint(bb_exit_0);
501 ir_builder->CreateIntCast(table_func_return,
get_int_type(64, ctx),
true);
502 ir_builder->CreateStore(r, output_row_count_ptr);
503 ir_builder->CreateRet(const_zero);
505 ir_builder->SetInsertPoint(bb_exit);
506 ir_builder->CreateRet(table_func_return);
511 bool emit_only_preflight_fn) {
516 const auto mgr_ptr = &*arg_it;
517 const auto input_cols_arg = &*(++arg_it);
518 const auto input_row_counts_arg = &*(++arg_it);
519 const auto input_str_dict_proxies_arg = &*(++arg_it);
520 const auto output_buffers_arg = &*(++arg_it);
521 const auto output_str_dict_proxies_arg = &*(++arg_it);
522 const auto output_row_count_ptr = &*(++arg_it);
523 auto cgen_state =
executor_->getCgenStatePtr();
525 auto& ctx = cgen_state->context_;
527 llvm::BasicBlock* bb_entry =
529 cgen_state->ir_builder_.SetInsertPoint(bb_entry);
531 llvm::BasicBlock* bb_exit = llvm::BasicBlock::Create(ctx,
".exit",
entry_point_func_);
533 llvm::BasicBlock* func_body_bb = llvm::BasicBlock::Create(
534 ctx,
".func_body0", cgen_state->ir_builder_.GetInsertBlock()->getParent());
536 cgen_state->ir_builder_.SetInsertPoint(bb_entry);
537 cgen_state->ir_builder_.CreateBr(func_body_bb);
539 cgen_state->ir_builder_.SetInsertPoint(func_body_bb);
541 exe_unit.
input_exprs.size(), input_cols_arg, cgen_state->ir_builder_, ctx);
544 exe_unit.
input_exprs.size(), input_row_counts_arg, cgen_state->ir_builder_, ctx);
546 auto input_str_dict_proxy_heads = std::vector<llvm::Value*>();
549 input_str_dict_proxies_arg,
550 cgen_state->ir_builder_,
556 std::vector<llvm::Value*> func_args;
557 std::vector<std::pair<llvm::Value*, const SQLTypeInfo>> columns_to_cast;
558 size_t func_arg_index = 0;
560 func_args.push_back(mgr_ptr);
565 for (
size_t i = 0; i < exe_unit.
input_exprs.size(); i++) {
567 const auto& ti = expr->get_type_info();
568 if (col_index == -1) {
572 auto r = cgen_state->ir_builder_.CreateBitCast(
574 llvm::LoadInst* scalar_fp = cgen_state->ir_builder_.CreateLoad(
575 r->getType()->getPointerElementType(),
578 func_args.push_back(scalar_fp);
580 }
else if (ti.is_integer() || ti.is_boolean() || ti.is_timestamp() ||
581 ti.is_timeinterval()) {
582 auto r = cgen_state->ir_builder_.CreateBitCast(
584 llvm::LoadInst* scalar_int = cgen_state->ir_builder_.CreateLoad(
585 r->getType()->getPointerElementType(),
588 func_args.push_back(scalar_int);
590 }
else if (ti.is_bytes()) {
592 cgen_state->ir_builder_.CreateBitCast(col_heads[i],
get_int_ptr_type(64, ctx));
593 auto varchar_ptr = cgen_state->ir_builder_.CreateGEP(
594 col_heads[i]->getType()->getScalarType()->getPointerElementType(),
596 cgen_state->llInt(8));
597 auto [varchar_struct, varchar_struct_ptr] =
alloc_column(
598 std::string(
"input_varchar_literal.") +
std::to_string(func_arg_index),
605 cgen_state->ir_builder_);
607 (pass_column_by_value
608 ? cgen_state->ir_builder_.CreateLoad(
609 varchar_struct->getType()->getPointerElementType(), varchar_struct)
610 : varchar_struct_ptr));
612 }
else if (ti.is_column()) {
621 : input_str_dict_proxy_heads[i],
623 cgen_state->ir_builder_);
624 func_args.push_back((pass_column_by_value
625 ? cgen_state->ir_builder_.CreateLoad(
626 col->getType()->getPointerElementType(), col)
631 columns_to_cast.push_back(std::make_pair(col_ptr, ti));
634 }
else if (ti.is_column_list()) {
635 if (col_index == -1) {
642 (emit_only_preflight_fn) ?
nullptr : input_str_dict_proxy_heads[i],
644 cgen_state->ir_builder_);
645 func_args.push_back(col_list);
648 if (col_index + 1 == ti.get_dimension()) {
652 throw std::runtime_error(
653 "Only integer and floating point columns or scalars are supported as inputs to "
659 auto output_str_dict_proxy_heads =
662 output_str_dict_proxies_arg,
663 cgen_state->ir_builder_,
665 : std::vector<llvm::Value*>();
667 std::vector<llvm::Value*> output_col_args;
668 for (
size_t i = 0; i < exe_unit.
target_exprs.size(); i++) {
669 auto* gep = cgen_state->ir_builder_.CreateGEP(
670 output_buffers_arg->getType()->getScalarType()->getPointerElementType(),
672 cgen_state->llInt(i));
674 cgen_state->ir_builder_.CreateLoad(gep->getType()->getPointerElementType(), gep);
676 const auto& ti = expr->get_type_info();
677 CHECK(!ti.is_column());
678 CHECK(!ti.is_column_list());
688 output_row_count_ptr,
692 cgen_state->ir_builder_);
694 cgen_state->emitExternalCall(
695 "TableFunctionManager_register_output_column",
696 llvm::Type::getVoidTy(ctx),
697 {mgr_ptr, llvm::ConstantInt::get(
get_int_type(32, ctx), i,
true), col_ptr});
699 output_col_args.push_back((pass_column_by_value ? col : col_ptr));
707 cgen_state->emitExternalCall(
708 "TableFunctionManager_set_output_row_size",
709 llvm::Type::getVoidTy(ctx),
711 cgen_state->ir_builder_.CreateLoad(
712 output_row_count_ptr->getType()->getPointerElementType(),
713 output_row_count_ptr)});
716 if (!emit_only_preflight_fn) {
717 for (
auto& col : output_col_args) {
718 func_args.push_back((pass_column_by_value
719 ? cgen_state->ir_builder_.CreateLoad(
720 col->getType()->getPointerElementType(), col)
730 exe_unit, func_args, bb_exit, output_row_count_ptr, emit_only_preflight_fn);
741 const std::vector<std::pair<llvm::Value*, const SQLTypeInfo>>& columns_to_cast,
742 llvm::Value* mgr_ptr) {
743 auto* cgen_state =
executor_->getCgenStatePtr();
744 llvm::LLVMContext& ctx = cgen_state->context_;
745 llvm::IRBuilder<>* ir_builder = &cgen_state->ir_builder_;
747 llvm::Function* old_func = cgen_state->current_func_;
748 cgen_state->current_func_ =
751 for (
unsigned i = 0; i < columns_to_cast.size(); ++i) {
752 auto [col_ptr, ti] = columns_to_cast[i];
754 if (ti.is_column() && ti.get_subtype() ==
kTIMESTAMP && ti.get_precision() != 9) {
757 ti.get_subtype(), ti.get_precision(), ti.get_dimension(), ti.get_notnull());
780 std::vector<llvm::ReturnInst*> rets_to_replace;
782 for (llvm::Instruction& I : BB) {
783 if (!llvm::isa<llvm::ReturnInst>(&I)) {
786 llvm::ReturnInst* RI = llvm::cast<llvm::ReturnInst>(&I);
787 llvm::Value* retValue = RI->getReturnValue();
788 if (!retValue || !llvm::isa<llvm::ConstantInt>(retValue)) {
791 llvm::ConstantInt* retConst = llvm::cast<llvm::ConstantInt>(retValue);
792 if (retConst->getValue() == 7) {
794 rets_to_replace.push_back(RI);
799 auto prev_insert_point = ir_builder->saveIP();
800 for (llvm::ReturnInst* RI : rets_to_replace) {
801 ir_builder->SetInsertPoint(RI);
802 llvm::Value* err_msg = ir_builder->CreateGlobalStringPtr(
803 "Underflow or overflow during casting of input types!",
"cast_err_str");
804 llvm::Value* error_call;
806 error_call = cgen_state->emitExternalCall(
"TableFunctionManager_error_message",
807 ir_builder->getInt32Ty(),
810 error_call = cgen_state->emitExternalCall(
811 "table_function_error", ir_builder->getInt32Ty(), {err_msg});
813 llvm::ReplaceInstWithInst(RI, llvm::ReturnInst::Create(ctx, error_call));
815 ir_builder->restoreIP(prev_insert_point);
817 cgen_state->current_func_ = old_func;
823 std::vector<llvm::Type*> arg_types;
827 [&arg_types](
const auto& arg) { arg_types.push_back(arg.getType()); });
830 auto cgen_state =
executor_->getCgenStatePtr();
832 auto& ctx = cgen_state->context_;
834 std::vector<llvm::Type*> wrapper_arg_types(arg_types.size() + 1);
835 wrapper_arg_types[0] = llvm::PointerType::get(
get_int_type(32, ctx), 0);
836 wrapper_arg_types[1] = arg_types[0];
838 for (
size_t i = 1; i < arg_types.size(); ++i) {
839 wrapper_arg_types[i + 1] = arg_types[i];
843 llvm::FunctionType::get(llvm::Type::getVoidTy(ctx), wrapper_arg_types,
false);
845 llvm::Function::ExternalLinkage,
847 cgen_state->module_);
849 auto wrapper_bb_entry = llvm::BasicBlock::Create(ctx,
".entry",
kernel_func_, 0);
850 llvm::IRBuilder<> b(ctx);
851 b.SetInsertPoint(wrapper_bb_entry);
852 std::vector<llvm::Value*> loaded_args = {
kernel_func_->arg_begin() + 1};
853 for (
size_t i = 2; i < wrapper_arg_types.size(); ++i) {
862 bool emit_only_preflight_fn) {
868 auto cgen_state =
executor_->getCgenStatePtr();
870 if (
executor_->has_rt_udf_module(is_gpu)) {
872 *(cgen_state->module_),
874 llvm::Linker::Flags::OverrideFromSrc);
877 LOG(
IR) << (emit_only_preflight_fn ?
"Pre Flight Function Entry Point IR\n"
878 :
"Table Function Entry Point IR\n")
880 std::shared_ptr<CompilationContext> code;
899 auto cpu_code = std::make_shared<CpuCompilationContext>(std::move(ee));
903 LOG(
IR) <<
"End of IR";
llvm::Type * get_fp_ptr_type(const int width, llvm::LLVMContext &context)
llvm::Function * kernel_func_
HOST DEVICE SQLTypes get_subtype() const
std::string exprsKey(const std::vector< Analyzer::Expr * > &exprs)
HOST DEVICE int get_size() const
bool is_timestamp() const
void generateEntryPoint(const TableFunctionExecutionUnit &exe_unit, bool emit_only_preflight_fn)
void initialize_ptr_member(llvm::Value *member_ptr, llvm::Type *member_llvm_type, llvm::Value *value_ptr, llvm::IRBuilder<> &ir_builder)
bool passColumnsByValue(const TableFunctionExecutionUnit &exe_unit)
std::vector< Analyzer::Expr * > input_exprs
const table_functions::TableFunction table_func
std::tuple< llvm::Value *, llvm::Value * > alloc_column(std::string col_name, const size_t index, const SQLTypeInfo &data_target_info, llvm::Value *data_ptr, llvm::Value *data_size, llvm::Value *data_str_dict_proxy_ptr, llvm::LLVMContext &ctx, llvm::IRBuilder<> &ir_builder)
bool mayRequireCastingInputTypes() const
llvm::Function * generate_entry_point(const CgenState *cgen_state)
std::shared_ptr< CompilationContext > finalize(bool emit_only_preflight_fn)
std::vector< std::string > CodeCacheKey
void generateCastsForInputTypes(const TableFunctionExecutionUnit &exe_unit, const std::vector< std::pair< llvm::Value *, const SQLTypeInfo >> &columns_to_cast, llvm::Value *mgr_ptr)
static ExecutionEngineWrapper generateNativeCPUCode(llvm::Function *func, const std::unordered_set< llvm::Function * > &live_funcs, const CompilationOptions &co)
llvm::Type * get_int_type(const int width, llvm::LLVMContext &context)
llvm::Value * alloc_column_list(std::string col_list_name, const SQLTypeInfo &data_target_info, llvm::Value *data_ptrs, int length, llvm::Value *data_size, llvm::Value *data_str_dict_proxy_ptrs, llvm::LLVMContext &ctx, llvm::IRBuilder<> &ir_builder)
bool hasOutputSizeKnownPreLaunch() const
void verify_function_ir(const llvm::Function *func)
size_t get_bit_width(const SQLTypeInfo &ti)
llvm::LLVMContext & context_
const CompilationOptions & co_
std::string getPreFlightFnName() const
std::string toString(const ExecutorDeviceType &device_type)
static void link_udf_module(const std::unique_ptr< llvm::Module > &udf_module, llvm::Module &module, CgenState *cgen_state, llvm::Linker::Flags flags=llvm::Linker::Flags::None)
void generateTableFunctionCall(const TableFunctionExecutionUnit &exe_unit, const std::vector< llvm::Value * > &func_args, llvm::BasicBlock *bb_exit, llvm::Value *output_row_count_ptr, bool emit_only_preflight_fn)
std::string getName(const bool drop_suffix=false, const bool lower=false) const
int get_precision() const
ExecutorDeviceType device_type
HOST DEVICE EncodingType get_compression() const
std::string serialize_llvm_object(const T *llvm_obj)
static std::shared_ptr< GpuCompilationContext > generateNativeGPUCode(Executor *executor, llvm::Function *func, llvm::Function *wrapper_func, const std::unordered_set< llvm::Function * > &live_funcs, const bool is_gpu_smem_used, const CompilationOptions &co, const GPUTarget &gpu_target)
bool hasPreFlightOutputSizer() const
llvm::Function * entry_point_func_
std::vector< llvm::Value * > generate_column_heads_load(const int num_columns, llvm::Value *byte_stream_arg, llvm::IRBuilder<> &ir_builder, llvm::LLVMContext &ctx)
std::string get_type_name() const
void cast_column(llvm::Value *col_base_ptr, llvm::Function *func, SQLTypeInfo &orig_ti, SQLTypeInfo &dest_ti, std::string index, llvm::IRBuilder<> &ir_builder, llvm::LLVMContext &ctx, CodeGenerator &codeGenerator)
llvm::Value * codegenCastBetweenTimestamps(llvm::Value *ts_lv, const SQLTypeInfo &operand_dimen, const SQLTypeInfo &target_dimen, const bool nullable)
llvm::Type * get_llvm_type_from_sql_column_type(const SQLTypeInfo elem_ti, llvm::LLVMContext &ctx)
#define DEBUG_TIMER(name)
static bool columnTypeRequiresCasting(const SQLTypeInfo &ti)
void initialize_int64_member(llvm::Value *member_ptr, llvm::Value *value, int64_t default_value, llvm::LLVMContext &ctx, llvm::IRBuilder<> &ir_builder)
static std::shared_ptr< QueryEngine > getInstance()
std::shared_ptr< CompilationContext > compile(const TableFunctionExecutionUnit &exe_unit, bool emit_only_preflight_fn)
std::vector< Analyzer::Expr * > target_exprs
HOST DEVICE bool get_notnull() const
llvm::Type * get_int_ptr_type(const int width, llvm::LLVMContext &context)
llvm::Value * cast_value(llvm::Value *value, SQLTypeInfo &orig_ti, SQLTypeInfo &dest_ti, bool nullable, CodeGenerator &codeGenerator)