#include <CodeGenerator.h>

Inheritance diagram for CodeGenerator:

Collaboration diagram for CodeGenerator:

Classes
struct	ArgNullcheckBBs

struct	ExecutorRequired

struct	GPUTarget

struct	NullCheckCodegen

Public Member Functions
	CodeGenerator (Executor *executor)

	CodeGenerator (CgenState cgen_state, PlanState plan_state)

std::vector< llvm::Value * >	codegen (const Analyzer::Expr *, const bool fetch_columns, const CompilationOptions &)

llvm::Value *	codegenPerRowStringOper (const Analyzer::StringOper *string_oper, const CompilationOptions &co)

llvm::Value *	codegenPseudoStringOper (const Analyzer::ColumnVar *, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos, const CompilationOptions &)

std::vector< llvm::Value * >	codegenHoistedConstants (const std::vector< const Analyzer::Constant * > &constants, const EncodingType enc_type, const shared::StringDictKey &dict_id)

llvm::Value *	codegenCastBetweenIntTypes (llvm::Value *operand_lv, const SQLTypeInfo &operand_ti, const SQLTypeInfo &ti, bool upscale=true)

void	codegenCastBetweenIntTypesOverflowChecks (llvm::Value *operand_lv, const SQLTypeInfo &operand_ti, const SQLTypeInfo &ti, const int64_t scale)

llvm::Value *	posArg (const Analyzer::Expr *) const

llvm::Value *	toBool (llvm::Value *)

llvm::Value *	castArrayPointer (llvm::Value *ptr, const SQLTypeInfo &elem_ti)

llvm::Value *	codegenCastBetweenTimestamps (llvm::Value *ts_lv, const SQLTypeInfo &operand_dimen, const SQLTypeInfo &target_dimen, const bool nullable)

llvm::Value *	codegenWindowPosition (const WindowFunctionContext window_func_context, llvm::Value pos_arg)

Static Public Member Functions
static llvm::ConstantInt *	codegenIntConst (const Analyzer::Constant constant, CgenState cgen_state)

static std::unordered_set < llvm::Function * >	markDeadRuntimeFuncs (llvm::Module &module, const std::vector< llvm::Function * > &roots, const std::vector< llvm::Function * > &leaves)

static ExecutionEngineWrapper	generateNativeCPUCode (llvm::Function func, const std::unordered_set< llvm::Function > &live_funcs, const CompilationOptions &co)

static std::string	generatePTX (const std::string &cuda_llir, llvm::TargetMachine *nvptx_target_machine, llvm::LLVMContext &context)

static std::unique_ptr < llvm::TargetMachine >	initializeNVPTXBackend (const CudaMgr_Namespace::NvidiaDeviceArch arch)

static bool	alwaysCloneRuntimeFunction (const llvm::Function *func)

static void	linkModuleWithLibdevice (Executor *executor, llvm::Module &module, llvm::PassManagerBuilder &pass_manager_builder, const GPUTarget &gpu_target)

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)

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)

static bool	prioritizeQuals (const RelAlgExecutionUnit &ra_exe_unit, std::vector< Analyzer::Expr * > &primary_quals, std::vector< Analyzer::Expr * > &deferred_quals, const PlanState::HoistedFiltersSet &hoisted_quals)

static ArrayLoadCodegen	codegenGeoArrayLoadAndNullcheck (llvm::Value byte_stream, llvm::Value pos, const SQLTypeInfo &ti, CgenState *cgen_state)

Protected Member Functions
Executor *	executor () const

Protected Attributes
CgenState *	cgen_state_

PlanState *	plan_state_

Private Member Functions
std::vector< llvm::Value * >	codegen (const Analyzer::Constant *, const EncodingType enc_type, const shared::StringDictKey &dict_id, const CompilationOptions &)

virtual std::vector < llvm::Value * >	codegenColumn (const Analyzer::ColumnVar *, const bool fetch_column, const CompilationOptions &)

llvm::Value *	codegenArith (const Analyzer::BinOper *, const CompilationOptions &)

llvm::Value *	codegenUMinus (const Analyzer::UOper *, const CompilationOptions &)

llvm::Value *	codegenCmp (const Analyzer::BinOper *, const CompilationOptions &)

llvm::Value *	codegenCmp (const SQLOps, const SQLQualifier, std::vector< llvm::Value * >, const SQLTypeInfo &, const Analyzer::Expr *, const CompilationOptions &)

llvm::Value *	codegenIsNull (const Analyzer::UOper *, const CompilationOptions &)

llvm::Value *	codegenIsNullNumber (llvm::Value *, const SQLTypeInfo &)

llvm::Value *	codegenLogical (const Analyzer::BinOper *, const CompilationOptions &)

llvm::Value *	codegenLogical (const Analyzer::UOper *, const CompilationOptions &)

llvm::Value *	codegenCast (const Analyzer::UOper *, const CompilationOptions &)

llvm::Value *	codegenCast (llvm::Value *operand_lv, const SQLTypeInfo &operand_ti, const SQLTypeInfo &ti, const bool operand_is_const, const CompilationOptions &co)

llvm::Value *	codegen (const Analyzer::InValues *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::InIntegerSet *expr, const CompilationOptions &co)

std::vector< llvm::Value * >	codegen (const Analyzer::CaseExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::ExtractExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::DateaddExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::DatediffExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::DatetruncExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::CharLengthExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::KeyForStringExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::SampleRatioExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::WidthBucketExpr *, const CompilationOptions &)

llvm::Value *	codegenConstantWidthBucketExpr (const Analyzer::WidthBucketExpr *, const CompilationOptions &)

llvm::Value *	codegenWidthBucketExpr (const Analyzer::WidthBucketExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::MLPredictExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::PCAProjectExpr *, const CompilationOptions &)

llvm::Value *	codegenLinRegPredict (const Analyzer::MLPredictExpr *, const std::shared_ptr< AbstractMLModel > &model, const CompilationOptions &)

llvm::Value *	codegenTreeRegPredict (const Analyzer::MLPredictExpr *, const std::shared_ptr< AbstractTreeModel > &tree_model, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::StringOper *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::LikeExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::RegexpExpr *, const CompilationOptions &)

llvm::Value *	codegenUnnest (const Analyzer::UOper *, const CompilationOptions &)

llvm::Value *	codegenArrayAt (const Analyzer::BinOper *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::CardinalityExpr *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenArrayExpr (const Analyzer::ArrayExpr *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeoColumnVar (const Analyzer::GeoColumnVar *, const bool fetch_columns, const CompilationOptions &co)

std::vector< llvm::Value * >	codegenGeoExpr (const Analyzer::GeoExpr *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeoConstant (const Analyzer::GeoConstant *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeoOperator (const Analyzer::GeoOperator *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeoUOper (const Analyzer::GeoUOper *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeoBinOper (const Analyzer::GeoBinOper *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeosPredicateCall (const std::string &, std::vector< llvm::Value * >, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeosConstructorCall (const std::string &, std::vector< llvm::Value * >, llvm::Value *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeoArgs (const std::vector< std::shared_ptr< Analyzer::Expr >> &, const CompilationOptions &)

llvm::Value *	codegenFunctionOper (const Analyzer::FunctionOper *, const CompilationOptions &)

llvm::Value *	codegenFunctionOperWithCustomTypeHandling (const Analyzer::FunctionOperWithCustomTypeHandling *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::BinOper *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::UOper *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenHoistedConstantsLoads (const SQLTypeInfo &type_info, const EncodingType enc_type, const shared::StringDictKey &dict_id, const int16_t lit_off, const size_t lit_bytes)

std::vector< llvm::Value * >	codegenHoistedConstantsPlaceholders (const SQLTypeInfo &type_info, const EncodingType enc_type, const int16_t lit_off, const std::vector< llvm::Value * > &literal_loads)

std::vector< llvm::Value * >	codegenColVar (const Analyzer::ColumnVar *, const bool fetch_column, const bool update_query_plan, const CompilationOptions &)

llvm::Value *	codegenFixedLengthColVar (const Analyzer::ColumnVar col_var, llvm::Value col_byte_stream, llvm::Value pos_arg, const WindowFunctionContext window_function_context=nullptr)

llvm::Value *	codegenFixedLengthColVarInWindow (const Analyzer::ColumnVar col_var, llvm::Value col_byte_stream, llvm::Value pos_arg, const CompilationOptions &co, const WindowFunctionContext window_function_context=nullptr)

std::vector< llvm::Value * >	codegenVariableLengthStringColVar (llvm::Value col_byte_stream, llvm::Value pos_arg)

llvm::Value *	codegenRowId (const Analyzer::ColumnVar *col_var, const CompilationOptions &co)

llvm::Value *	codgenAdjustFixedEncNull (llvm::Value *, const SQLTypeInfo &)

std::vector< llvm::Value * >	codegenOuterJoinNullPlaceholder (const Analyzer::ColumnVar *col_var, const bool fetch_column, const CompilationOptions &co)

llvm::Value *	codegenIntArith (const Analyzer::BinOper , llvm::Value , llvm::Value *, const CompilationOptions &)

llvm::Value *	codegenFpArith (const Analyzer::BinOper , llvm::Value , llvm::Value *)

llvm::Value *	codegenCastTimestampToTime (llvm::Value *ts_lv, const int dimen, const bool nullable)

llvm::Value *	codegenCastTimestampToDate (llvm::Value *ts_lv, const int dimen, const bool nullable)

llvm::Value *	codegenCastFromString (llvm::Value *operand_lv, const SQLTypeInfo &operand_ti, const SQLTypeInfo &ti, const bool operand_is_const, const CompilationOptions &co)

llvm::Value *	codegenCastNonStringToString (llvm::Value *operand_lv, const SQLTypeInfo &operand_ti, const SQLTypeInfo &ti, const bool operand_is_const, const CompilationOptions &co)

llvm::Value *	codegenCastToFp (llvm::Value *operand_lv, const SQLTypeInfo &operand_ti, const SQLTypeInfo &ti)

llvm::Value *	codegenCastFromFp (llvm::Value *operand_lv, const SQLTypeInfo &operand_ti, const SQLTypeInfo &ti)

llvm::Value *	codegenAdd (const Analyzer::BinOper , llvm::Value , llvm::Value *, const std::string &null_typename, const std::string &null_check_suffix, const SQLTypeInfo &, const CompilationOptions &)

llvm::Value *	codegenSub (const Analyzer::BinOper , llvm::Value , llvm::Value *, const std::string &null_typename, const std::string &null_check_suffix, const SQLTypeInfo &, const CompilationOptions &)

void	codegenSkipOverflowCheckForNull (llvm::Value lhs_lv, llvm::Value rhs_lv, llvm::BasicBlock *no_overflow_bb, const SQLTypeInfo &ti)

llvm::Value *	codegenMul (const Analyzer::BinOper , llvm::Value , llvm::Value *, const std::string &null_typename, const std::string &null_check_suffix, const SQLTypeInfo &, const CompilationOptions &, bool downscale=true)

llvm::Value *	codegenDiv (llvm::Value , llvm::Value , const std::string &null_typename, const std::string &null_check_suffix, const SQLTypeInfo &, bool upscale=true)

llvm::Value *	codegenDeciDiv (const Analyzer::BinOper *, const CompilationOptions &)

llvm::Value *	codegenMod (llvm::Value , llvm::Value , const std::string &null_typename, const std::string &null_check_suffix, const SQLTypeInfo &)

llvm::Value *	codegenCase (const Analyzer::CaseExpr , llvm::Type case_llvm_type, const bool is_real_str, const CompilationOptions &)

llvm::Value *	codegenExtractHighPrecisionTimestamps (llvm::Value *, const SQLTypeInfo &, const ExtractField &)

llvm::Value *	codegenDateTruncHighPrecisionTimestamps (llvm::Value *, const SQLTypeInfo &, const DatetruncField &)

llvm::Value *	codegenCmpDecimalConst (const SQLOps, const SQLQualifier, const Analyzer::Expr , const SQLTypeInfo &, const Analyzer::Expr , const CompilationOptions &)

llvm::Value *	codegenBoundingBoxIntersect (const SQLOps, const SQLQualifier, const std::shared_ptr< Analyzer::Expr >, const std::shared_ptr< Analyzer::Expr >, const CompilationOptions &)

llvm::Value *	codegenStrCmp (const SQLOps, const SQLQualifier, const std::shared_ptr< Analyzer::Expr >, const std::shared_ptr< Analyzer::Expr >, const CompilationOptions &)

llvm::Value *	codegenQualifierCmp (const SQLOps, const SQLQualifier, std::vector< llvm::Value * >, const Analyzer::Expr *, const CompilationOptions &)

llvm::Value *	codegenLogicalShortCircuit (const Analyzer::BinOper *, const CompilationOptions &)

llvm::Value *	codegenDictLike (const std::shared_ptr< Analyzer::Expr > arg, const Analyzer::Constant *pattern, const bool ilike, const bool is_simple, const char escape_char, const CompilationOptions &)

llvm::Value *	codegenDictStrCmp (const std::shared_ptr< Analyzer::Expr >, const std::shared_ptr< Analyzer::Expr >, const SQLOps, const CompilationOptions &co)

llvm::Value *	codegenDictRegexp (const std::shared_ptr< Analyzer::Expr > arg, const Analyzer::Constant *pattern, const char escape_char, const CompilationOptions &)

llvm::Value *	foundOuterJoinMatch (const size_t nesting_level) const

llvm::Value *	resolveGroupedColumnReference (const Analyzer::ColumnVar *)

llvm::Value *	colByteStream (const Analyzer::ColumnVar *col_var, const bool fetch_column, const bool hoist_literals)

std::shared_ptr< const Analyzer::Expr >	hashJoinLhs (const Analyzer::ColumnVar *rhs) const

std::shared_ptr< const Analyzer::ColumnVar >	hashJoinLhsTuple (const Analyzer::ColumnVar rhs, const Analyzer::BinOper tautological_eq) const

bool	needCastForHashJoinLhs (const Analyzer::ColumnVar *rhs) const

std::unique_ptr< InValuesBitmap >	createInValuesBitmap (const Analyzer::InValues *, const CompilationOptions &)

bool	checkExpressionRanges (const Analyzer::UOper *, int64_t, int64_t)

bool	checkExpressionRanges (const Analyzer::BinOper *, int64_t, int64_t)

std::tuple< ArgNullcheckBBs, llvm::Value * >	beginArgsNullcheck (const Analyzer::FunctionOper function_oper, const std::vector< llvm::Value > &orig_arg_lvs)

llvm::Value *	endArgsNullcheck (const ArgNullcheckBBs &, llvm::Value , llvm::Value , const Analyzer::FunctionOper *)

llvm::Value *	codegenFunctionOperNullArg (const Analyzer::FunctionOper , const std::vector< llvm::Value > &)

llvm::Value *	codegenCompression (const SQLTypeInfo &type_info)

std::pair< llvm::Value , llvm::Value >	codegenArrayBuff (llvm::Value chunk, llvm::Value row_pos, SQLTypes array_type, bool cast_and_extend)

void	codegenBufferArgs (const std::string &udf_func_name, size_t param_num, llvm::Value buffer_buf, llvm::Value buffer_size, llvm::Value buffer_is_null, std::vector< llvm::Value > &output_args)

llvm::StructType *	createPointStructType (const std::string &udf_func_name, size_t param_num)

void	codegenGeoPointArgs (const std::string &udf_func_name, size_t param_num, llvm::Value point_buf, llvm::Value point_size, llvm::Value compression, llvm::Value input_srid, llvm::Value output_srid, std::vector< llvm::Value > &output_args)

llvm::StructType *	createMultiPointStructType (const std::string &udf_func_name, size_t param_num)

void	codegenGeoMultiPointArgs (const std::string &udf_func_name, size_t param_num, llvm::Value multi_point_buf, llvm::Value multi_point_size, llvm::Value compression, llvm::Value input_srid, llvm::Value output_srid, std::vector< llvm::Value > &output_args)

llvm::StructType *	createLineStringStructType (const std::string &udf_func_name, size_t param_num)

void	codegenGeoLineStringArgs (const std::string &udf_func_name, size_t param_num, llvm::Value line_string_buf, llvm::Value line_string_size, llvm::Value compression, llvm::Value input_srid, llvm::Value output_srid, std::vector< llvm::Value > &output_args)

llvm::StructType *	createMultiLineStringStructType (const std::string &udf_func_name, size_t param_num)

void	codegenGeoMultiLineStringArgs (const std::string &udf_func_name, size_t param_num, llvm::Value multi_linestring_coords, llvm::Value multi_linestring_size, llvm::Value linestring_sizes, llvm::Value linestring_sizes_size, llvm::Value compression, llvm::Value input_srid, llvm::Value output_srid, std::vector< llvm::Value > &output_args)

llvm::StructType *	createPolygonStructType (const std::string &udf_func_name, size_t param_num)

void	codegenGeoPolygonArgs (const std::string &udf_func_name, size_t param_num, llvm::Value polygon_buf, llvm::Value polygon_size, llvm::Value ring_sizes_buf, llvm::Value num_rings, llvm::Value compression, llvm::Value input_srid, llvm::Value output_srid, std::vector< llvm::Value > &output_args)

llvm::StructType *	createMultiPolygonStructType (const std::string &udf_func_name, size_t param_num)

void	codegenGeoMultiPolygonArgs (const std::string &udf_func_name, size_t param_num, llvm::Value polygon_coords, llvm::Value polygon_coords_size, llvm::Value ring_sizes_buf, llvm::Value ring_sizes, llvm::Value polygon_bounds, llvm::Value polygon_bounds_sizes, llvm::Value compression, llvm::Value input_srid, llvm::Value output_srid, std::vector< llvm::Value > &output_args)

std::vector< llvm::Value * >	codegenFunctionOperCastArgs (const Analyzer::FunctionOper , const ExtensionFunction , const std::vector< llvm::Value * > &, const std::vector< size_t > &, const std::unordered_map< llvm::Value , llvm::Value > &, const CompilationOptions &)

llvm::StructType *	createStringViewStructType ()

llvm::Function *	getArithWithOverflowIntrinsic (const Analyzer::BinOper bin_oper, llvm::Type type)

llvm::Value *	codegenBinOpWithOverflowForCPU (const Analyzer::BinOper bin_oper, llvm::Value lhs_lv, llvm::Value *rhs_lv, const std::string &null_check_suffix, const SQLTypeInfo &ti)

std::pair< std::vector < llvm::Value * > , std::unique_ptr < CodeGenerator::NullCheckCodegen > >	codegenStringFetchAndEncode (const Analyzer::StringOper *expr, const CompilationOptions &co, const size_t arg_idx, const bool codegen_nullcheck)

Private Attributes
Executor *	executor_

Static Private Attributes
static std::mutex	initialize_nvptx_mutex_

static std::mutex	initialize_cpu_backend_mutex_

Friends
class	GroupByAndAggregate

Detailed Description

Definition at line 29 of file CodeGenerator.h.

Constructor & Destructor Documentation

CodeGenerator::CodeGenerator ( Executor * executor )

inline

Definition at line 31 of file CodeGenerator.h.

       : executor_(executor)
       , cgen_state_(executor->cgen_state_.get())
       , plan_state_(executor->plan_state_.get()) {}

CodeGenerator::CodeGenerator	(	CgenState *	cgen_state,
		PlanState *	plan_state
	)

inline

Definition at line 38 of file CodeGenerator.h.

39 : executor_(nullptr), cgen_state_(cgen_state), plan_state_(plan_state) {}

CodeGenerator::cgen_state_

CgenState * cgen_state_

Definition: CodeGenerator.h:666

CodeGenerator::executor_

Executor * executor_

Definition: CodeGenerator.h:656

CodeGenerator::plan_state_

PlanState * plan_state_

Definition: CodeGenerator.h:667

Member Function Documentation

bool CodeGenerator::alwaysCloneRuntimeFunction ( const llvm::Function * func )

static

Definition at line 1574 of file NativeCodegen.cpp.

Referenced by CgenState::set_module_shallow_copy().

                                                                        {
   auto const candidate_func_name = func->getName().str();
   return std::any_of(TARGET_RUNTIME_FUNCTIONS_FOR_MODULE_CLONING.begin(),
                      TARGET_RUNTIME_FUNCTIONS_FOR_MODULE_CLONING.end(),
                      [candidate_func_name](std::string_view func_name) {
                        return candidate_func_name == func_name;
                      });
 }

Here is the caller graph for this function:

std::tuple< CodeGenerator::ArgNullcheckBBs, llvm::Value * > CodeGenerator::beginArgsNullcheck	(	const Analyzer::FunctionOper *	function_oper,
		const std::vector< llvm::Value * > &	orig_arg_lvs
	)

private

Definition at line 428 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, codegenFunctionOperNullArg(), CgenState::context_, CgenState::current_func_, anonymous_namespace{ExtensionsIR.cpp}::ext_func_call_requires_nullcheck(), anonymous_namespace{ExtensionsIR.cpp}::get_buffer_struct_type(), anonymous_namespace{ExtensionsIR.cpp}::get_llvm_type_from_sql_array_type(), Analyzer::Expr::get_type_info(), Analyzer::FunctionOper::getName(), and CgenState::ir_builder_.

Referenced by codegenFunctionOper(), and codegenFunctionOperWithCustomTypeHandling().

                                                                              {
   AUTOMATIC_IR_METADATA(cgen_state_);
   llvm::BasicBlock* args_null_bb{nullptr};
   llvm::BasicBlock* args_notnull_bb{nullptr};
   llvm::BasicBlock* orig_bb = cgen_state_->ir_builder_.GetInsertBlock();
   llvm::Value* null_array_alloca{nullptr};
   // Only generate the check if required (at least one argument must be nullable).
   if (ext_func_call_requires_nullcheck(function_oper)) {
     const auto func_ti = function_oper->get_type_info();
     if (func_ti.is_buffer()) {
       const auto arr_struct_ty = get_buffer_struct_type(
           cgen_state_,
           function_oper->getName(),
           0,
           get_llvm_type_from_sql_array_type(func_ti, cgen_state_->context_));
       null_array_alloca = cgen_state_->ir_builder_.CreateAlloca(arr_struct_ty);
     }
     const auto args_notnull_lv = cgen_state_->ir_builder_.CreateNot(
         codegenFunctionOperNullArg(function_oper, orig_arg_lvs));
     args_notnull_bb = llvm::BasicBlock::Create(
         cgen_state_->context_, "args_notnull", cgen_state_->current_func_);
     args_null_bb = llvm::BasicBlock::Create(
         cgen_state_->context_, "args_null", cgen_state_->current_func_);
     cgen_state_->ir_builder_.CreateCondBr(args_notnull_lv, args_notnull_bb, args_null_bb);
     cgen_state_->ir_builder_.SetInsertPoint(args_notnull_bb);
   }
   return std::make_tuple(
       CodeGenerator::ArgNullcheckBBs{args_null_bb, args_notnull_bb, orig_bb},
       null_array_alloca);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::castArrayPointer	(	llvm::Value *	ptr,
		const SQLTypeInfo &	elem_ti
	)

Definition at line 1748 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CgenState::context_, SQLTypeInfo::get_compression(), SQLTypeInfo::get_size(), SQLTypeInfo::get_type(), CgenState::ir_builder_, SQLTypeInfo::is_boolean(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_string(), kDOUBLE, kENCODING_DICT, and kFLOAT.

Referenced by codegenFunctionOperCastArgs(), RangeJoinHashTable::codegenKey(), and BoundingBoxIntersectJoinHashTable::codegenKey().

                                                                          {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (elem_ti.get_type() == kFLOAT) {
     return cgen_state_->ir_builder_.CreatePointerCast(
         ptr, llvm::Type::getFloatPtrTy(cgen_state_->context_));
   }
   if (elem_ti.get_type() == kDOUBLE) {
     return cgen_state_->ir_builder_.CreatePointerCast(
         ptr, llvm::Type::getDoublePtrTy(cgen_state_->context_));
   }
   CHECK(elem_ti.is_integer() || elem_ti.is_boolean() ||
         (elem_ti.is_string() && elem_ti.get_compression() == kENCODING_DICT));
   switch (elem_ti.get_size()) {
     case 1:
       return cgen_state_->ir_builder_.CreatePointerCast(
           ptr, llvm::Type::getInt8PtrTy(cgen_state_->context_));
     case 2:
       return cgen_state_->ir_builder_.CreatePointerCast(
           ptr, llvm::Type::getInt16PtrTy(cgen_state_->context_));
     case 4:
       return cgen_state_->ir_builder_.CreatePointerCast(
           ptr, llvm::Type::getInt32PtrTy(cgen_state_->context_));
     case 8:
       return cgen_state_->ir_builder_.CreatePointerCast(
           ptr, llvm::Type::getInt64PtrTy(cgen_state_->context_));
     default:
       CHECK(false);
   }
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CodeGenerator::checkExpressionRanges	(	const Analyzer::UOper *	uoper,
		int64_t	min,
		int64_t	max
	)

private

Definition at line 630 of file ArithmeticIR.cpp.

References CHECK, executor(), executor_, Analyzer::Expr::get_type_info(), getExpressionRange(), Integer, SQLTypeInfo::is_decimal(), ExpressionRange::makeInvalidRange(), plan_state_, and PlanState::query_infos_.

Referenced by codegenAdd(), codegenMul(), codegenSub(), and codegenUMinus().

                                                        {
   if (uoper->get_type_info().is_decimal()) {
     return false;
   }
 
   CHECK(plan_state_);
   if (executor_) {
     auto expr_range_info =
         plan_state_->query_infos_.size() > 0
             ? getExpressionRange(uoper, plan_state_->query_infos_, executor())
             : ExpressionRange::makeInvalidRange();
     if (expr_range_info.getType() != ExpressionRangeType::Integer) {
       return false;
     }
     if (expr_range_info.getIntMin() >= min && expr_range_info.getIntMax() <= max) {
       return true;
     }
   }
 
   return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CodeGenerator::checkExpressionRanges	(	const Analyzer::BinOper *	bin_oper,
		int64_t	min,
		int64_t	max
	)

private

Definition at line 189 of file ArithmeticIR.cpp.

References CHECK, executor(), executor_, Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_right_operand(), Analyzer::Expr::get_type_info(), getExpressionRange(), Integer, SQLTypeInfo::is_decimal(), anonymous_namespace{ArithmeticIR.cpp}::is_temporary_column(), ExpressionRange::makeInvalidRange(), plan_state_, and PlanState::query_infos_.

                                                        {
   if (is_temporary_column(bin_oper->get_left_operand()) ||
       is_temporary_column(bin_oper->get_right_operand())) {
     // Computing the range for temporary columns is a lot more expensive than the overflow
     // check.
     return false;
   }
   if (bin_oper->get_type_info().is_decimal()) {
     return false;
   }
 
   CHECK(plan_state_);
   if (executor_) {
     auto expr_range_info =
         plan_state_->query_infos_.size() > 0
             ? getExpressionRange(bin_oper, plan_state_->query_infos_, executor())
             : ExpressionRange::makeInvalidRange();
     if (expr_range_info.getType() != ExpressionRangeType::Integer) {
       return false;
     }
     if (expr_range_info.getIntMin() >= min && expr_range_info.getIntMax() <= max) {
       return true;
     }
   }
 
   return false;
 }

Here is the call graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegen	(	const Analyzer::Expr *	expr,
		const bool	fetch_columns,
		const CompilationOptions &	co
	)

Definition at line 30 of file IRCodegen.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_NE, codegenArrayExpr(), codegenColumn(), codegenFunctionOper(), codegenFunctionOperWithCustomTypeHandling(), codegenGeoBinOper(), codegenGeoColumnVar(), codegenGeoExpr(), codegenGeoUOper(), CgenState::context_, createStringViewStructType(), executor_, get_int_type(), Analyzer::Expr::get_type_info(), CgenState::ir_builder_, kENCODING_DICT, kENCODING_NONE, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kNULLT, kPOINT, kPOLYGON, CgenState::llInt(), posArg(), and width_bucket_expr().

Referenced by Executor::buildHoistLeftHandSideFiltersCb(), Executor::buildIsDeletedCb(), Executor::buildJoinLoops(), TreeModelPredictionMgr::codegen(), codegen(), GroupByAndAggregate::codegenAggArg(), TargetExprCodegen::codegenAggregate(), codegenArith(), codegenArrayAt(), codegenArrayExpr(), codegenCase(), codegenCast(), codegenCmp(), codegenCmpDecimalConst(), HashJoin::codegenColOrStringOper(), codegenColVar(), codegenConstantWidthBucketExpr(), codegenDeciDiv(), codegenDictLike(), codegenDictRegexp(), codegenDictStrCmp(), Executor::codegenFrameBoundExpr(), codegenFunctionOper(), codegenFunctionOperWithCustomTypeHandling(), codegenGeoArgs(), codegenGeoColumnVar(), codegenGeoConstant(), codegenGeoOperator(), codegenIsNull(), RangeJoinHashTable::codegenKey(), BoundingBoxIntersectJoinHashTable::codegenKey(), codegenLogical(), codegenLogicalShortCircuit(), BoundingBoxIntersectJoinHashTable::codegenManyKey(), codegenOuterJoinNullPlaceholder(), GroupByAndAggregate::codegenOutputSlot(), codegenPseudoStringOper(), codegenQualifierCmp(), codegenRowId(), codegenStringFetchAndEncode(), codegenTreeRegPredict(), codegenUMinus(), codegenUnnest(), codegenWidthBucketExpr(), Executor::codegenWindowFunctionAggregateCalls(), ScalarCodeGenerator::compile(), and Executor::groupByColumnCodegen().

                                                                                {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (!expr) {
     return {posArg(expr)};
   }
   auto bin_oper = dynamic_cast<const Analyzer::BinOper*>(expr);
   if (bin_oper) {
     return {codegen(bin_oper, co)};
   }
   auto u_oper = dynamic_cast<const Analyzer::UOper*>(expr);
   if (u_oper) {
     return {codegen(u_oper, co)};
   }
   auto geo_col_var = dynamic_cast<const Analyzer::GeoColumnVar*>(expr);
   if (geo_col_var) {
     // inherits from ColumnVar, so it is important we check this first
     return codegenGeoColumnVar(geo_col_var, fetch_columns, co);
   }
   auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(expr);
   if (col_var) {
     return codegenColumn(col_var, fetch_columns, co);
   }
   auto constant = dynamic_cast<const Analyzer::Constant*>(expr);
   if (constant) {
     const auto& ti = constant->get_type_info();
     if (ti.get_type() == kNULLT) {
       throw std::runtime_error(
           "NULL type literals are not currently supported in this context.");
     }
     if (constant->get_is_null()) {
       const auto i8p_ty =
           llvm::PointerType::get(get_int_type(8, executor_->cgen_state_->context_), 0);
       if (ti.is_string() && ti.get_compression() == kENCODING_NONE) {
         std::vector<llvm::Value*> null_target_lvs;
         llvm::StructType* str_view_ty = createStringViewStructType();
         auto null_str_view_struct_lv = cgen_state_->ir_builder_.CreateAlloca(str_view_ty);
         // we do not need to fill the values of the string_view struct representing null
         // string
         null_target_lvs.push_back(
             cgen_state_->ir_builder_.CreateLoad(str_view_ty, null_str_view_struct_lv));
         null_target_lvs.push_back(llvm::ConstantPointerNull::get(
             llvm::PointerType::get(llvm::IntegerType::get(cgen_state_->context_, 8), 0)));
         null_target_lvs.push_back(cgen_state_->llInt((int32_t)0));
         return null_target_lvs;
       } else if (ti.is_geometry()) {
         std::vector<llvm::Value*> ret_lvs;
         // we classify whether the geo col value is null from the rhs of the left-join
         // qual i.e., table S in the qual: R left join S on R.v = S.v by checking 1)
         // nulled chunk_iter and 2) its col buffer w/ the size 0 for instance, we consider
         // the size of col buffer for point as 16 and for other types we use `array_size`
         // function to determine it, and they all assume valid geos have their buf size >
         // 0 thus, by returning all bufs' ptr as nullptr we can return 0 as the length of
         // the nulled geos' col val, and remaining logic can exploit this to finally
         // return "null" as the col value of the corresponding row in the resultset
         switch (ti.get_type()) {
           // outer join's phi node in the generated code expects the # returned lvs'
           // is the same as `col_ti.get_physical_coord_cols()`
           // now we have necessary logic to deal with these nullptr and can conclude
           // it as nulled geo val, i.e., see ResultSetIteration::991
           case kPOINT:
           case kMULTIPOINT:
           case kLINESTRING:
             return {llvm::ConstantPointerNull::get(i8p_ty)};
           case kMULTILINESTRING:
           case kPOLYGON:
             return {llvm::ConstantPointerNull::get(i8p_ty),
                     llvm::ConstantPointerNull::get(i8p_ty)};
           case kMULTIPOLYGON:
             return {llvm::ConstantPointerNull::get(i8p_ty),
                     llvm::ConstantPointerNull::get(i8p_ty),
                     llvm::ConstantPointerNull::get(i8p_ty)};
           default:
             CHECK(false);
             return {nullptr};
         }
       } else if (ti.is_array()) {
         // similar to above nulled geo case, we can use this `nullptr` to guide
         // `array_buff` and `array_size` functions representing nulled array value
         return {llvm::ConstantPointerNull::get(i8p_ty)};
       }
       return {ti.is_fp()
                   ? static_cast<llvm::Value*>(executor_->cgen_state_->inlineFpNull(ti))
                   : static_cast<llvm::Value*>(executor_->cgen_state_->inlineIntNull(ti))};
     }
     if (ti.get_compression() == kENCODING_DICT) {
       // The dictionary encoding case should be handled by the parent expression
       // (cast, for now), here is too late to know the dictionary id if not already set
       CHECK_NE(ti.getStringDictKey().dict_id, 0);
       return {codegen(constant, ti.get_compression(), ti.getStringDictKey(), co)};
     }
     return {codegen(constant, ti.get_compression(), {}, co)};
   }
   auto case_expr = dynamic_cast<const Analyzer::CaseExpr*>(expr);
   if (case_expr) {
     return {codegen(case_expr, co)};
   }
   auto extract_expr = dynamic_cast<const Analyzer::ExtractExpr*>(expr);
   if (extract_expr) {
     return {codegen(extract_expr, co)};
   }
   auto dateadd_expr = dynamic_cast<const Analyzer::DateaddExpr*>(expr);
   if (dateadd_expr) {
     return {codegen(dateadd_expr, co)};
   }
   auto datediff_expr = dynamic_cast<const Analyzer::DatediffExpr*>(expr);
   if (datediff_expr) {
     return {codegen(datediff_expr, co)};
   }
   auto datetrunc_expr = dynamic_cast<const Analyzer::DatetruncExpr*>(expr);
   if (datetrunc_expr) {
     return {codegen(datetrunc_expr, co)};
   }
   auto charlength_expr = dynamic_cast<const Analyzer::CharLengthExpr*>(expr);
   if (charlength_expr) {
     return {codegen(charlength_expr, co)};
   }
   auto keyforstring_expr = dynamic_cast<const Analyzer::KeyForStringExpr*>(expr);
   if (keyforstring_expr) {
     return {codegen(keyforstring_expr, co)};
   }
   auto sample_ratio_expr = dynamic_cast<const Analyzer::SampleRatioExpr*>(expr);
   if (sample_ratio_expr) {
     return {codegen(sample_ratio_expr, co)};
   }
   auto string_oper_expr = dynamic_cast<const Analyzer::StringOper*>(expr);
   if (string_oper_expr) {
     return {codegen(string_oper_expr, co)};
   }
   auto cardinality_expr = dynamic_cast<const Analyzer::CardinalityExpr*>(expr);
   if (cardinality_expr) {
     return {codegen(cardinality_expr, co)};
   }
   auto like_expr = dynamic_cast<const Analyzer::LikeExpr*>(expr);
   if (like_expr) {
     return {codegen(like_expr, co)};
   }
   auto regexp_expr = dynamic_cast<const Analyzer::RegexpExpr*>(expr);
   if (regexp_expr) {
     return {codegen(regexp_expr, co)};
   }
   auto width_bucket_expr = dynamic_cast<const Analyzer::WidthBucketExpr*>(expr);
   if (width_bucket_expr) {
     return {codegen(width_bucket_expr, co)};
   }
 
   auto ml_predict_expr = dynamic_cast<const Analyzer::MLPredictExpr*>(expr);
   if (ml_predict_expr) {
     return {codegen(ml_predict_expr, co)};
   }
 
   auto pca_project_expr = dynamic_cast<const Analyzer::PCAProjectExpr*>(expr);
   if (pca_project_expr) {
     return {codegen(pca_project_expr, co)};
   }
 
   auto likelihood_expr = dynamic_cast<const Analyzer::LikelihoodExpr*>(expr);
   if (likelihood_expr) {
     return {codegen(likelihood_expr->get_arg(), fetch_columns, co)};
   }
   auto in_expr = dynamic_cast<const Analyzer::InValues*>(expr);
   if (in_expr) {
     return {codegen(in_expr, co)};
   }
   auto in_integer_set_expr = dynamic_cast<const Analyzer::InIntegerSet*>(expr);
   if (in_integer_set_expr) {
     return {codegen(in_integer_set_expr, co)};
   }
   auto function_oper_with_custom_type_handling_expr =
       dynamic_cast<const Analyzer::FunctionOperWithCustomTypeHandling*>(expr);
   if (function_oper_with_custom_type_handling_expr) {
     return {codegenFunctionOperWithCustomTypeHandling(
         function_oper_with_custom_type_handling_expr, co)};
   }
   auto array_oper_expr = dynamic_cast<const Analyzer::ArrayExpr*>(expr);
   if (array_oper_expr) {
     return {codegenArrayExpr(array_oper_expr, co)};
   }
   auto geo_uop = dynamic_cast<const Analyzer::GeoUOper*>(expr);
   if (geo_uop) {
     return {codegenGeoUOper(geo_uop, co)};
   }
   auto geo_binop = dynamic_cast<const Analyzer::GeoBinOper*>(expr);
   if (geo_binop) {
     return {codegenGeoBinOper(geo_binop, co)};
   }
   auto function_oper_expr = dynamic_cast<const Analyzer::FunctionOper*>(expr);
   if (function_oper_expr) {
     return {codegenFunctionOper(function_oper_expr, co)};
   }
   auto geo_expr = dynamic_cast<const Analyzer::GeoExpr*>(expr);
   if (geo_expr) {
     return codegenGeoExpr(geo_expr, co);
   }
   if (dynamic_cast<const Analyzer::OffsetInFragment*>(expr)) {
     return {posArg(nullptr)};
   }
   if (dynamic_cast<const Analyzer::WindowFunction*>(expr)) {
     throw NativeExecutionError("Window expression not supported in this context");
   }
   abort();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegen	(	const Analyzer::Constant *	constant,
		const EncodingType	enc_type,
		const shared::StringDictKey &	dict_id,
		const CompilationOptions &	co
	)

private

Definition at line 20 of file ConstantIR.cpp.

References CgenState::addStringConstant(), AUTOMATIC_IR_METADATA, Datum::boolval, cgen_state_, CHECK, codegenGeoConstant(), codegenHoistedConstants(), codegenIntConst(), CgenState::context_, decimal_to_int_type(), CompilationOptions::device_type, Datum::doubleval, executor(), Datum::floatval, Analyzer::Constant::get_constval(), get_int_type(), Analyzer::Constant::get_is_null(), Analyzer::Expr::get_type_info(), CompilationOptions::hoist_literals, inline_int_null_val(), kBIGINT, kBOOLEAN, kCHAR, kDATE, kDOUBLE, kENCODING_DICT, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, CgenState::llInt(), Datum::stringval, and run_benchmark_import::type.

                                                                                {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (co.hoist_literals) {
     if (const auto geo_constant = dynamic_cast<const Analyzer::GeoConstant*>(constant)) {
       return codegenGeoConstant(geo_constant, co);
     } else {
       std::vector<const Analyzer::Constant*> constants(
           executor()->deviceCount(co.device_type), constant);
       return codegenHoistedConstants(constants, enc_type, dict_id);
     }
   }
   const auto& type_info = constant->get_type_info();
   const auto type =
       type_info.is_decimal() ? decimal_to_int_type(type_info) : type_info.get_type();
   switch (type) {
     case kBOOLEAN:
       return {llvm::ConstantInt::get(get_int_type(8, cgen_state_->context_),
                                      constant->get_constval().boolval)};
     case kTINYINT:
     case kSMALLINT:
     case kINT:
     case kBIGINT:
     case kTIME:
     case kTIMESTAMP:
     case kDATE:
     case kINTERVAL_DAY_TIME:
     case kINTERVAL_YEAR_MONTH:
       return {CodeGenerator::codegenIntConst(constant, cgen_state_)};
     case kFLOAT:
       return {llvm::ConstantFP::get(llvm::Type::getFloatTy(cgen_state_->context_),
                                     constant->get_constval().floatval)};
     case kDOUBLE:
       return {llvm::ConstantFP::get(llvm::Type::getDoubleTy(cgen_state_->context_),
                                     constant->get_constval().doubleval)};
     case kVARCHAR:
     case kCHAR:
     case kTEXT: {
       CHECK(constant->get_constval().stringval || constant->get_is_null());
       if (constant->get_is_null()) {
         if (enc_type == kENCODING_DICT) {
           return {
               cgen_state_->llInt(static_cast<int32_t>(inline_int_null_val(type_info)))};
         }
         return {cgen_state_->llInt(int64_t(0)),
                 llvm::Constant::getNullValue(
                     llvm::PointerType::get(get_int_type(8, cgen_state_->context_), 0)),
                 cgen_state_->llInt(int32_t(0))};
       }
       const auto& str_const = *constant->get_constval().stringval;
       if (enc_type == kENCODING_DICT) {
         return {
             cgen_state_->llInt(executor()
                                    ->getStringDictionaryProxy(
                                        dict_id, executor()->getRowSetMemoryOwner(), true)
                                    ->getIdOfString(str_const))};
       }
       return {cgen_state_->llInt(int64_t(0)),
               cgen_state_->addStringConstant(str_const),
               cgen_state_->llInt(static_cast<int32_t>(str_const.size()))};
     }
     default:
       CHECK(false);
   }
   abort();
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::InValues *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 23 of file InValuesIR.cpp.

References CgenState::addInValuesBitmap(), AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), InValuesBitmap::codegen(), codegenCmp(), CgenState::context_, createInValuesBitmap(), CgenState::emitCall(), executor(), Analyzer::InValues::get_arg(), Analyzer::Expr::get_type_info(), Analyzer::InValues::get_value_list(), CompilationOptions::hoist_literals, CgenState::inlineIntNull(), CgenState::ir_builder_, is_unnest(), kBOOLEAN, kEQ, kONE, CgenState::llInt(), run_benchmark_import::result, and toBool().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto in_arg = expr->get_arg();
   if (is_unnest(in_arg)) {
     throw std::runtime_error("IN not supported for unnested expressions");
   }
   const auto& expr_ti = expr->get_type_info();
   CHECK(expr_ti.is_boolean());
   const auto lhs_lvs = codegen(in_arg, true, co);
   llvm::Value* result{nullptr};
   if (expr_ti.get_notnull()) {
     result = llvm::ConstantInt::get(llvm::IntegerType::getInt1Ty(cgen_state_->context_),
                                     false);
   } else {
     result = cgen_state_->llInt(int8_t(0));
   }
   CHECK(result);
   if (co.hoist_literals) {  // TODO(alex): remove this constraint
     auto in_vals_bitmap = createInValuesBitmap(expr, co);
     if (in_vals_bitmap) {
       if (in_vals_bitmap->isEmpty()) {
         return in_vals_bitmap->hasNull()
                    ? cgen_state_->inlineIntNull(SQLTypeInfo(kBOOLEAN, false))
                    : result;
       }
       CHECK_EQ(size_t(1), lhs_lvs.size());
       return cgen_state_->addInValuesBitmap(in_vals_bitmap)
           ->codegen(lhs_lvs.front(), executor());
     }
   }
   if (expr_ti.get_notnull()) {
     for (auto in_val : expr->get_value_list()) {
       result = cgen_state_->ir_builder_.CreateOr(
           result,
           toBool(
               codegenCmp(kEQ, kONE, lhs_lvs, in_arg->get_type_info(), in_val.get(), co)));
     }
   } else {
     for (auto in_val : expr->get_value_list()) {
       const auto crt =
           codegenCmp(kEQ, kONE, lhs_lvs, in_arg->get_type_info(), in_val.get(), co);
       result = cgen_state_->emitCall("logical_or",
                                      {result, crt, cgen_state_->inlineIntNull(expr_ti)});
     }
   }
   return result;
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::InIntegerSet *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 72 of file InValuesIR.cpp.

References CgenState::addInValuesBitmap(), AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), InValuesBitmap::codegen(), CgenState::context_, Data_Namespace::CPU_LEVEL, CompilationOptions::device_type, executor(), Analyzer::InIntegerSet::get_arg(), Analyzer::Expr::get_type_info(), Analyzer::InIntegerSet::get_value_list(), GPU, Data_Namespace::GPU_LEVEL, CompilationOptions::hoist_literals, inline_int_null_val(), is_unnest(), CgenState::llInt(), and run_benchmark_import::result.

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto in_arg = in_integer_set->get_arg();
   if (is_unnest(in_arg)) {
     throw std::runtime_error("IN not supported for unnested expressions");
   }
   const auto& ti = in_integer_set->get_arg()->get_type_info();
   const auto needle_null_val = inline_int_null_val(ti);
   if (!co.hoist_literals) {
     // We never run without literal hoisting in real world scenarios, this avoids a crash
     // when testing.
     throw std::runtime_error(
         "IN subquery with many right-hand side values not supported when literal "
         "hoisting is disabled");
   }
   auto in_vals_bitmap = std::make_unique<InValuesBitmap>(
       in_integer_set->get_value_list(),
       needle_null_val,
       co.device_type == ExecutorDeviceType::GPU ? Data_Namespace::GPU_LEVEL
                                                 : Data_Namespace::CPU_LEVEL,
       executor()->deviceCount(co.device_type),
       executor()->data_mgr_,
       co);
   const auto& in_integer_set_ti = in_integer_set->get_type_info();
   CHECK(in_integer_set_ti.is_boolean());
   const auto lhs_lvs = codegen(in_arg, true, co);
   llvm::Value* result{nullptr};
   if (in_integer_set_ti.get_notnull()) {
     result = llvm::ConstantInt::get(llvm::IntegerType::getInt1Ty(cgen_state_->context_),
                                     false);
   } else {
     result = cgen_state_->llInt(int8_t(0));
   }
   CHECK(result);
   CHECK_EQ(size_t(1), lhs_lvs.size());
   return cgen_state_->addInValuesBitmap(in_vals_bitmap)
       ->codegen(lhs_lvs.front(), executor());
 }

Here is the call graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegen	(	const Analyzer::CaseExpr *	case_expr,
		const CompilationOptions &	co
	)

private

Definition at line 20 of file CaseIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegenCase(), CgenState::context_, createStringViewStructType(), get_bit_width(), Analyzer::CaseExpr::get_else_expr(), get_int_type(), Analyzer::Expr::get_type_info(), CgenState::ir_builder_, kENCODING_DICT, and kFLOAT.

                                                                                {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto case_ti = case_expr->get_type_info();
   llvm::Type* case_llvm_type = nullptr;
   bool is_real_str = false;
   if (case_ti.is_integer() || case_ti.is_time() || case_ti.is_decimal()) {
     case_llvm_type = get_int_type(get_bit_width(case_ti), cgen_state_->context_);
   } else if (case_ti.is_fp()) {
     case_llvm_type = case_ti.get_type() == kFLOAT
                          ? llvm::Type::getFloatTy(cgen_state_->context_)
                          : llvm::Type::getDoubleTy(cgen_state_->context_);
   } else if (case_ti.is_string()) {
     if (case_ti.get_compression() == kENCODING_DICT) {
       case_llvm_type =
           get_int_type(8 * case_ti.get_logical_size(), cgen_state_->context_);
     } else {
       is_real_str = true;
       case_llvm_type = createStringViewStructType();
     }
   } else if (case_ti.is_boolean()) {
     case_llvm_type = get_int_type(8 * case_ti.get_logical_size(), cgen_state_->context_);
   } else if (case_ti.is_geometry()) {
     throw std::runtime_error(
         "Geospatial column projections are currently not supported in conditional "
         "expressions.");
   } else if (case_ti.is_array()) {
     throw std::runtime_error(
         "Array column projections are currently not supported in conditional "
         "expressions.");
   }
   CHECK(case_llvm_type);
   const auto& else_ti = case_expr->get_else_expr()->get_type_info();
   CHECK_EQ(else_ti.get_type(), case_ti.get_type());
   llvm::Value* case_val = codegenCase(case_expr, case_llvm_type, is_real_str, co);
   std::vector<llvm::Value*> ret_vals{case_val};
   if (is_real_str) {
     ret_vals.push_back(cgen_state_->ir_builder_.CreateExtractValue(case_val, 0));
     ret_vals.push_back(cgen_state_->ir_builder_.CreateExtractValue(case_val, 1));
     ret_vals.back() = cgen_state_->ir_builder_.CreateTrunc(
         ret_vals.back(), llvm::Type::getInt32Ty(cgen_state_->context_));
   }
   return ret_vals;
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::ExtractExpr *	extract_expr,
		const CompilationOptions &	co
	)

private

Definition at line 76 of file DateTimeIR.cpp.

References AUTOMATIC_IR_METADATA, CHECK, DateTimeUtils::get_extract_timestamp_precision_scale(), Analyzer::ExtractExpr::get_field(), Analyzer::ExtractExpr::get_from_expr(), get_int_type(), Analyzer::Expr::get_type_info(), DateTimeUtils::is_subsecond_extract_field(), kDATE, kEPOCH, and kTIMESTAMP.

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto from_expr = codegen(extract_expr->get_from_expr(), true, co).front();
   const int32_t extract_field{extract_expr->get_field()};
   const auto& extract_expr_ti = extract_expr->get_from_expr()->get_type_info();
   if (extract_field == kEPOCH) {
     CHECK(extract_expr_ti.get_type() == kTIMESTAMP ||
           extract_expr_ti.get_type() == kDATE);
     if (from_expr->getType()->isIntegerTy(32)) {
       from_expr =
           cgen_state_->ir_builder_.CreateCast(llvm::Instruction::CastOps::SExt,
                                               from_expr,
                                               get_int_type(64, cgen_state_->context_));
       return from_expr;
     }
   }
   CHECK(from_expr->getType()->isIntegerTy(64));
   if (extract_expr_ti.is_high_precision_timestamp()) {
     from_expr = codegenExtractHighPrecisionTimestamps(
         from_expr, extract_expr_ti, extract_expr->get_field());
   }
   if (!extract_expr_ti.is_high_precision_timestamp() &&
       is_subsecond_extract_field(extract_expr->get_field())) {
     from_expr =
         extract_expr_ti.get_notnull()
             ? cgen_state_->ir_builder_.CreateMul(
                   from_expr,
                   cgen_state_->llInt(
                       get_extract_timestamp_precision_scale(extract_expr->get_field())))
             : cgen_state_->emitCall(
                   "mul_int64_t_nullable_lhs",
                   {from_expr,
                    cgen_state_->llInt(
                        get_extract_timestamp_precision_scale(extract_expr->get_field())),
                    cgen_state_->inlineIntNull(extract_expr_ti)});
   }
   const auto extract_fname = get_extract_function_name(extract_expr->get_field());
   if (!extract_expr_ti.get_notnull()) {
     llvm::BasicBlock* extract_nullcheck_bb{nullptr};
     llvm::PHINode* extract_nullcheck_value{nullptr};
     {
       DiamondCodegen null_check(cgen_state_->ir_builder_.CreateICmp(
                                     llvm::ICmpInst::ICMP_EQ,
                                     from_expr,
                                     cgen_state_->inlineIntNull(extract_expr_ti)),
                                 executor(),
                                 false,
                                 "extract_nullcheck",
                                 nullptr,
                                 false);
       // generate a phi node depending on whether we got a null or not
       extract_nullcheck_bb = llvm::BasicBlock::Create(
           cgen_state_->context_, "extract_nullcheck_bb", cgen_state_->current_func_);
 
       // update the blocks created by diamond codegen to point to the newly created phi
       // block
       cgen_state_->ir_builder_.SetInsertPoint(null_check.cond_true_);
       cgen_state_->ir_builder_.CreateBr(extract_nullcheck_bb);
       cgen_state_->ir_builder_.SetInsertPoint(null_check.cond_false_);
       auto extract_call =
           cgen_state_->emitExternalCall(extract_fname,
                                         get_int_type(64, cgen_state_->context_),
                                         std::vector<llvm::Value*>{from_expr});
       cgen_state_->ir_builder_.CreateBr(extract_nullcheck_bb);
 
       cgen_state_->ir_builder_.SetInsertPoint(extract_nullcheck_bb);
       extract_nullcheck_value = cgen_state_->ir_builder_.CreatePHI(
           get_int_type(64, cgen_state_->context_), 2, "extract_value");
       extract_nullcheck_value->addIncoming(extract_call, null_check.cond_false_);
       extract_nullcheck_value->addIncoming(cgen_state_->inlineIntNull(extract_expr_ti),
                                            null_check.cond_true_);
     }
 
     // diamond codegen will set the insert point in its destructor. override it to
     // continue using the extract nullcheck bb
     CHECK(extract_nullcheck_bb);
     cgen_state_->ir_builder_.SetInsertPoint(extract_nullcheck_bb);
     CHECK(extract_nullcheck_value);
     return extract_nullcheck_value;
   } else {
     return cgen_state_->emitExternalCall(extract_fname,
                                          get_int_type(64, cgen_state_->context_),
                                          std::vector<llvm::Value*>{from_expr});
   }
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::DateaddExpr *	dateadd_expr,
		const CompilationOptions &	co
	)

private

Definition at line 163 of file DateTimeIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegen(), CgenState::context_, CgenState::emitExternalCall(), Analyzer::DateaddExpr::get_datetime_expr(), Analyzer::DateaddExpr::get_field(), get_int_type(), Analyzer::DateaddExpr::get_number_expr(), Analyzer::Expr::get_type_info(), inline_fixed_encoding_null_val(), inline_int_null_val(), DateTimeUtils::is_subsecond_dateadd_field(), kDATE, kTIMESTAMP, CgenState::llInt(), and Analyzer::DateaddExpr::use_fixed_encoding_null_val().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto& dateadd_expr_ti = dateadd_expr->get_type_info();
   CHECK(dateadd_expr_ti.get_type() == kTIMESTAMP || dateadd_expr_ti.get_type() == kDATE);
   auto datetime = codegen(dateadd_expr->get_datetime_expr(), true, co).front();
   CHECK(datetime->getType()->isIntegerTy(64));
   auto number = codegen(dateadd_expr->get_number_expr(), true, co).front();
 
   const auto& datetime_ti = dateadd_expr->get_datetime_expr()->get_type_info();
   std::vector<llvm::Value*> dateadd_args{
       cgen_state_->llInt(static_cast<int32_t>(dateadd_expr->get_field())),
       number,
       datetime};
   std::string dateadd_fname{"DateAdd"};
   if (is_subsecond_dateadd_field(dateadd_expr->get_field()) ||
       dateadd_expr_ti.is_high_precision_timestamp()) {
     dateadd_fname += "HighPrecision";
     dateadd_args.push_back(
         cgen_state_->llInt(static_cast<int32_t>(datetime_ti.get_dimension())));
   }
   if (!datetime_ti.get_notnull()) {
     auto null_val = dateadd_expr->use_fixed_encoding_null_val()
                         ? inline_fixed_encoding_null_val(datetime_ti)
                         : inline_int_null_val(datetime_ti);
     dateadd_args.push_back(cgen_state_->llInt((int64_t)null_val));
     dateadd_fname += "Nullable";
   }
   return cgen_state_->emitExternalCall(dateadd_fname,
                                        get_int_type(64, cgen_state_->context_),
                                        dateadd_args,
                                        {llvm::Attribute::NoUnwind,
                                         llvm::Attribute::ReadNone,
                                         llvm::Attribute::Speculatable});
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::DatediffExpr *	datediff_expr,
		const CompilationOptions &	co
	)

private

Definition at line 199 of file DateTimeIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegen(), CgenState::context_, CgenState::emitExternalCall(), Analyzer::DatediffExpr::get_end_expr(), Analyzer::DatediffExpr::get_field(), get_int_type(), Analyzer::DatediffExpr::get_start_expr(), Analyzer::Expr::get_type_info(), CgenState::inlineIntNull(), and CgenState::llInt().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto start = codegen(datediff_expr->get_start_expr(), true, co).front();
   CHECK(start->getType()->isIntegerTy(64));
   auto end = codegen(datediff_expr->get_end_expr(), true, co).front();
   CHECK(end->getType()->isIntegerTy(32) || end->getType()->isIntegerTy(64));
   const auto& start_ti = datediff_expr->get_start_expr()->get_type_info();
   const auto& end_ti = datediff_expr->get_end_expr()->get_type_info();
   std::vector<llvm::Value*> datediff_args{
       cgen_state_->llInt(static_cast<int32_t>(datediff_expr->get_field())), start, end};
   std::string datediff_fname{"DateDiff"};
   if (start_ti.is_high_precision_timestamp() || end_ti.is_high_precision_timestamp()) {
     datediff_fname += "HighPrecision";
     datediff_args.push_back(
         cgen_state_->llInt(static_cast<int32_t>(start_ti.get_dimension())));
     datediff_args.push_back(
         cgen_state_->llInt(static_cast<int32_t>(end_ti.get_dimension())));
   }
   const auto& ret_ti = datediff_expr->get_type_info();
   if (!start_ti.get_notnull() || !end_ti.get_notnull()) {
     datediff_args.push_back(cgen_state_->inlineIntNull(ret_ti));
     datediff_fname += "Nullable";
   }
   return cgen_state_->emitExternalCall(
       datediff_fname, get_int_type(64, cgen_state_->context_), datediff_args);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::DatetruncExpr *	datetrunc_expr,
		const CompilationOptions &	co
	)

private

Definition at line 227 of file DateTimeIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegen(), codegenDateTruncHighPrecisionTimestamps(), CgenState::context_, datetrunc_fname_lookup, dtMICROSECOND, dtMILLISECOND, dtNANOSECOND, dtSECOND, CgenState::emitExternalCall(), executor(), field(), Analyzer::DatetruncExpr::get_field(), Analyzer::DatetruncExpr::get_from_expr(), get_int_type(), Analyzer::Expr::get_type_info(), and CgenState::ir_builder_.

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto from_expr = codegen(datetrunc_expr->get_from_expr(), true, co).front();
   const auto& datetrunc_expr_ti = datetrunc_expr->get_from_expr()->get_type_info();
   CHECK(from_expr->getType()->isIntegerTy(64));
   DatetruncField const field = datetrunc_expr->get_field();
   if (datetrunc_expr_ti.is_high_precision_timestamp()) {
     return codegenDateTruncHighPrecisionTimestamps(from_expr, datetrunc_expr_ti, field);
   }
   static_assert(dtSECOND + 1 == dtMILLISECOND, "Please keep these consecutive.");
   static_assert(dtMILLISECOND + 1 == dtMICROSECOND, "Please keep these consecutive.");
   static_assert(dtMICROSECOND + 1 == dtNANOSECOND, "Please keep these consecutive.");
   if (dtSECOND <= field && field <= dtNANOSECOND) {
     return cgen_state_->ir_builder_.CreateCast(llvm::Instruction::CastOps::SExt,
                                                from_expr,
                                                get_int_type(64, cgen_state_->context_));
   }
   std::unique_ptr<CodeGenerator::NullCheckCodegen> nullcheck_codegen;
   const bool is_nullable = !datetrunc_expr_ti.get_notnull();
   if (is_nullable) {
     nullcheck_codegen = std::make_unique<NullCheckCodegen>(
         cgen_state_, executor(), from_expr, datetrunc_expr_ti, "date_trunc_nullcheck");
   }
   char const* const fname = datetrunc_fname_lookup.at(field);
   auto ret = cgen_state_->emitExternalCall(
       fname, get_int_type(64, cgen_state_->context_), {from_expr});
   if (is_nullable) {
     ret = nullcheck_codegen->finalize(ll_int(NULL_BIGINT, cgen_state_->context_), ret);
   }
   return ret;
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::CharLengthExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 239 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK_EQ, codegen(), CgenState::context_, CompilationOptions::device_type, CgenState::emitCall(), CgenState::emitExternalCall(), Analyzer::CharLengthExpr::get_arg(), Analyzer::CharLengthExpr::get_calc_encoded_length(), get_int_type(), SQLTypeInfo::get_notnull(), Analyzer::Expr::get_type_info(), GPU, CgenState::inlineIntNull(), and CgenState::ir_builder_.

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto str_lv = codegen(expr->get_arg(), true, co);
   if (str_lv.size() != 3) {
     CHECK_EQ(size_t(1), str_lv.size());
     str_lv.push_back(cgen_state_->ir_builder_.CreateExtractValue(str_lv.front(), 0));
     str_lv.push_back(cgen_state_->ir_builder_.CreateExtractValue(str_lv.front(), 1));
     str_lv.back() = cgen_state_->ir_builder_.CreateTrunc(
         str_lv.back(), llvm::Type::getInt32Ty(cgen_state_->context_));
     if (co.device_type == ExecutorDeviceType::GPU) {
       throw QueryMustRunOnCpu();
     }
   }
   std::vector<llvm::Value*> charlength_args{str_lv[1], str_lv[2]};
   std::string fn_name("char_length");
   if (expr->get_calc_encoded_length()) {
     fn_name += "_encoded";
   }
   const bool is_nullable{!expr->get_arg()->get_type_info().get_notnull()};
   if (is_nullable) {
     fn_name += "_nullable";
     charlength_args.push_back(cgen_state_->inlineIntNull(expr->get_type_info()));
   }
   return expr->get_calc_encoded_length()
              ? cgen_state_->emitExternalCall(
                    fn_name, get_int_type(32, cgen_state_->context_), charlength_args)
              : cgen_state_->emitCall(fn_name, charlength_args);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::KeyForStringExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 269 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK_EQ, codegen(), CgenState::emitCall(), and Analyzer::KeyForStringExpr::get_arg().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto str_lv = codegen(expr->get_arg(), true, co);
   CHECK_EQ(size_t(1), str_lv.size());
   return cgen_state_->emitCall("key_for_string_encoded", str_lv);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::SampleRatioExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 278 of file IRCodegen.cpp.

References run_benchmark_import::args, AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), CgenState::context_, CgenState::emitCall(), executor(), Analyzer::SampleRatioExpr::get_arg(), kDOUBLE, ll_bool(), and posArg().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto input_expr = expr->get_arg();
   CHECK(input_expr);
 
   auto double_lv = codegen(input_expr, true, co);
   CHECK_EQ(size_t(1), double_lv.size());
 
   std::unique_ptr<CodeGenerator::NullCheckCodegen> nullcheck_codegen;
   const bool is_nullable = !input_expr->get_type_info().get_notnull();
   if (is_nullable) {
     nullcheck_codegen = std::make_unique<NullCheckCodegen>(cgen_state_,
                                                            executor(),
                                                            double_lv.front(),
                                                            input_expr->get_type_info(),
                                                            "sample_ratio_nullcheck");
   }
   CHECK_EQ(input_expr->get_type_info().get_type(), kDOUBLE);
   std::vector<llvm::Value*> args{double_lv[0], posArg(nullptr)};
   auto ret = cgen_state_->emitCall("sample_ratio", args);
   if (nullcheck_codegen) {
     ret = nullcheck_codegen->finalize(ll_bool(false, cgen_state_->context_), ret);
   }
   return ret;
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::WidthBucketExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 305 of file IRCodegen.cpp.

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto target_value_expr = expr->get_target_value();
   auto lower_bound_expr = expr->get_lower_bound();
   auto upper_bound_expr = expr->get_upper_bound();
   auto partition_count_expr = expr->get_partition_count();
   CHECK(target_value_expr);
   CHECK(lower_bound_expr);
   CHECK(upper_bound_expr);
   CHECK(partition_count_expr);
 
   auto is_constant_expr = [](const Analyzer::Expr* expr) {
     auto target_expr = expr;
     if (auto cast_expr = dynamic_cast<const Analyzer::UOper*>(expr)) {
       if (cast_expr->get_optype() == SQLOps::kCAST) {
         target_expr = cast_expr->get_operand();
       }
     }
     // there are more complex constant expr like 1+2, 1/2*3, and so on
     // but when considering a typical usage of width_bucket function
     // it is sufficient to consider a singleton constant expr
     auto constant_expr = dynamic_cast<const Analyzer::Constant*>(target_expr);
     if (constant_expr) {
       return true;
     }
     return false;
   };
   if (is_constant_expr(lower_bound_expr) && is_constant_expr(upper_bound_expr) &&
       is_constant_expr(partition_count_expr)) {
     expr->set_constant_expr();
   }
   // compute width_bucket's expresn range and check the possibility of avoiding oob check
   auto col_range =
       getExpressionRange(expr,
                          plan_state_->query_infos_,
                          executor_,
                          boost::make_optional(plan_state_->getSimpleQuals()));
   // check whether target_expr is valid
   if (col_range.getType() == ExpressionRangeType::Integer &&
       !expr->can_skip_out_of_bound_check() && col_range.getIntMin() > 0 &&
       col_range.getIntMax() <= expr->get_partition_count_val()) {
     // check whether target_col is not-nullable or has filter expr on it
     if (!col_range.hasNulls()) {
       // Even if the target_expr has its filter expression, target_col_range may exactly
       // the same with the col_range of the target_expr's operand col,
       // i.e., SELECT WIDTH_BUCKET(v1, 1, 10, 10) FROM T WHERE v1 != 1;
       // In that query, col_range of v1 with/without considering the filter expression
       // v1 != 1 have exactly the same col ranges, so we cannot recognize the existence
       // of the filter expression based on them. Also, is (not) null is located in
       // FilterNode, so we cannot trace it in here.
       // todo (yoonmin): relax this to allow skipping oob check more cases
       expr->skip_out_of_bound_check();
     }
   }
   return expr->is_constant_expr() ? codegenConstantWidthBucketExpr(expr, co)
                                   : codegenWidthBucketExpr(expr, co);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::MLPredictExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 288 of file MLPredictCodegen.cpp.

References CHECK, codegenLinRegPredict(), codegenTreeRegPredict(), DEBUG_TIMER, DECISION_TREE_REG, g_ml_models, GBT_REG, Analyzer::MLPredictExpr::get_model_value(), Analyzer::MLPredictExpr::get_regressor_values(), MLModelMap::getModel(), LINEAR_REG, and RANDOM_FOREST_REG.

                                                                   {
   auto timer = DEBUG_TIMER(__func__);
   const auto& model_expr = expr->get_model_value();
   CHECK(model_expr);
   auto model_constant_expr = dynamic_cast<const Analyzer::Constant*>(model_expr);
   CHECK(model_constant_expr);
   const auto model_datum = model_constant_expr->get_constval();
   const auto model_name_ptr = model_datum.stringval;
   CHECK(model_name_ptr);
   const auto model_name = *model_name_ptr;
   const auto abstract_model = g_ml_models.getModel(model_name);
   const auto model_type = abstract_model->getModelType();
   const auto& regressor_exprs = expr->get_regressor_values();
   if (abstract_model->getNumLogicalFeatures() !=
       static_cast<int64_t>(regressor_exprs.size())) {
     std::ostringstream error_oss;
     error_oss << "ML_PREDICT: Model '" << model_name
               << "' expects different number of predictor variables ("
               << abstract_model->getNumLogicalFeatures() << ") than provided ("
               << regressor_exprs.size() << ").";
     throw std::runtime_error(error_oss.str());
   }
 
   switch (model_type) {
     case MLModelType::LINEAR_REG: {
       return codegenLinRegPredict(expr, abstract_model, co);
     }
     case MLModelType::DECISION_TREE_REG:
     case MLModelType::GBT_REG:
     case MLModelType::RANDOM_FOREST_REG: {
       if (auto tree_model =
               std::dynamic_pointer_cast<AbstractTreeModel>(abstract_model)) {
         return codegenTreeRegPredict(expr, tree_model, co);
       } else {
         throw std::runtime_error(
             "Invalid ML model codegen call. Input model is not of expected type "
             "TreeModel.");
       }
     }
     default: {
       throw std::runtime_error("Unsupported model type.");
     }
   }
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::PCAProjectExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 334 of file MLPredictCodegen.cpp.

References CHECK, codegenArith(), DEBUG_TIMER, Datum::doubleval, executor(), g_ml_models, generated_encoded_and_casted_features(), Analyzer::Constant::get_constval(), Analyzer::PCAProjectExpr::get_feature_values(), Analyzer::PCAProjectExpr::get_model_value(), Analyzer::PCAProjectExpr::get_pc_dimension_value(), MLModelMap::getModel(), Datum::intval, kDIVIDE, kDOUBLE, kMINUS, kMULTIPLY, kONE, kPLUS, PCA, and run_benchmark_import::result.

                                                                   {
   auto timer = DEBUG_TIMER(__func__);
   const auto& model_expr = expr->get_model_value();
   CHECK(model_expr);
   auto model_constant_expr = dynamic_cast<const Analyzer::Constant*>(model_expr);
   CHECK(model_constant_expr);
   const auto model_datum = model_constant_expr->get_constval();
   const auto model_name_ptr = model_datum.stringval;
   CHECK(model_name_ptr);
   const auto model_name = *model_name_ptr;
   const auto abstract_model = g_ml_models.getModel(model_name);
   const auto model_type = abstract_model->getModelType();
   if (model_type != MLModelType::PCA) {
     throw std::runtime_error("PCA_PROJECT: Model '" + model_name +
                              "' is not a PCA model.");
   }
   const auto pca_model = std::dynamic_pointer_cast<PcaModel>(abstract_model);
   const auto& feature_exprs = expr->get_feature_values();
   if (pca_model->getNumLogicalFeatures() != static_cast<int64_t>(feature_exprs.size())) {
     std::ostringstream error_oss;
     error_oss << "PCA_PROJECT: Model '" << model_name
               << "' expects different number of predictor variables ("
               << pca_model->getNumLogicalFeatures() << ") than provided ("
               << feature_exprs.size() << ").";
     throw std::runtime_error(error_oss.str());
   }
 
   const auto& pc_dimension_expr = expr->get_pc_dimension_value();
   auto pc_dimension_const_expr =
       dynamic_cast<const Analyzer::Constant*>(pc_dimension_expr);
   const auto pc_dimension_datum = pc_dimension_const_expr->get_constval();
   const auto pc_dimension = pc_dimension_datum.intval - 1;
   if (pc_dimension < 0 || pc_dimension >= pca_model->getNumFeatures()) {
     std::ostringstream error_oss;
     error_oss << "PCA_PROJECT: Invalid PC dimension (" << pc_dimension + 1
               << ") provided. Valid range is [1, " << pca_model->getNumFeatures() << "].";
     throw std::runtime_error(error_oss.str());
   }
 
   const auto& column_means = pca_model->getColumnMeans();
   const auto& column_std_devs = pca_model->getColumnStdDevs();
   const auto& eigenvectors = pca_model->getEigenvectors();
 
   const auto& cat_feature_keys = pca_model->getCatFeatureKeys();
 
   const auto casted_feature_exprs = generated_encoded_and_casted_features(
       feature_exprs,
       cat_feature_keys,
       pca_model->getModelMetadata().getFeaturePermutations(),
       executor());
 
   auto get_double_constant_expr = [](double const_val) {
     Datum d;
     d.doubleval = const_val;
     return makeExpr<Analyzer::Constant>(SQLTypeInfo(kDOUBLE, false), false, d);
   };
 
   std::shared_ptr<Analyzer::Expr> result;
 
   for (size_t feature_idx = 0; feature_idx < feature_exprs.size(); ++feature_idx) {
     auto mean_expr = get_double_constant_expr(column_means[feature_idx]);
     const auto& casted_feature_expr = casted_feature_exprs[feature_idx];
     // Subtract column mean from feature
     auto mean_diff_expr = makeExpr<Analyzer::BinOper>(
         SQLTypeInfo(kDOUBLE, false), false, kMINUS, kONE, casted_feature_expr, mean_expr);
     auto std_dev_expr = get_double_constant_expr(column_std_devs[feature_idx]);
     auto z_score_expr = makeExpr<Analyzer::BinOper>(
         SQLTypeInfo(kDOUBLE, false), false, kDIVIDE, kONE, mean_diff_expr, std_dev_expr);
     auto pc_term_expr = get_double_constant_expr(eigenvectors[pc_dimension][feature_idx]);
     auto pca_mul_expr = makeExpr<Analyzer::BinOper>(
         SQLTypeInfo(kDOUBLE, false), false, kMULTIPLY, kONE, z_score_expr, pc_term_expr);
     if (feature_idx == 0) {
       // There is no result yet, so set the result to the first term
       result = pca_mul_expr;
     } else {
       // Add the term to the result
       result = makeExpr<Analyzer::BinOper>(
           SQLTypeInfo(kDOUBLE, false), false, kPLUS, kONE, result, pca_mul_expr);
     }
   }
 
   // The following will codegen the expression tree we just created modeling
   // the linear regression formula
   return codegenArith(dynamic_cast<Analyzer::BinOper*>(result.get()), co);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::StringOper *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 533 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK_EQ, CHECK_GE, codegen(), StringDictionaryTranslationMgr::codegen(), codegenPerRowStringOper(), CompilationOptions::device_type, executor(), Analyzer::Expr::get_type_info(), Analyzer::StringOper::getArg(), Analyzer::StringOper::getArity(), CgenState::moveStringDictionaryTranslationMgr(), Analyzer::StringOper::requiresPerRowTranslation(), and translate_dict_strings().

                                                                   {
   CHECK_GE(expr->getArity(), 1UL);
   if (expr->requiresPerRowTranslation()) {
     return codegenPerRowStringOper(expr, co);
   }
 
   AUTOMATIC_IR_METADATA(cgen_state_);
 
   auto string_dictionary_translation_mgr =
       translate_dict_strings(expr, co.device_type, executor());
 
   auto str_id_lv = codegen(expr->getArg(0), true, co);
   CHECK_EQ(size_t(1), str_id_lv.size());
   const auto& expr_ti = expr->get_type_info();
 
   return cgen_state_
       ->moveStringDictionaryTranslationMgr(std::move(string_dictionary_translation_mgr))
       ->codegen(str_id_lv[0], expr_ti, true /* add_nullcheck */, co);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::LikeExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 587 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), codegenDictLike(), CgenState::context_, CompilationOptions::device_type, CgenState::emitCall(), extract_cast_arg(), g_enable_watchdog, Analyzer::LikeExpr::get_arg(), Analyzer::LikeExpr::get_escape_expr(), Analyzer::LikeExpr::get_is_ilike(), Analyzer::LikeExpr::get_is_simple(), Analyzer::LikeExpr::get_like_expr(), SQLTypeInfo::get_notnull(), Analyzer::LikeExpr::get_own_arg(), Analyzer::Expr::get_type_info(), GPU, CgenState::inlineIntNull(), CgenState::ir_builder_, is_unnest(), kENCODING_NONE, and CgenState::llInt().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (is_unnest(extract_cast_arg(expr->get_arg()))) {
     throw std::runtime_error("LIKE not supported for unnested expressions");
   }
   char escape_char{'\\'};
   if (expr->get_escape_expr()) {
     auto escape_char_expr =
         dynamic_cast<const Analyzer::Constant*>(expr->get_escape_expr());
     CHECK(escape_char_expr);
     CHECK(escape_char_expr->get_type_info().is_string());
     CHECK_EQ(size_t(1), escape_char_expr->get_constval().stringval->size());
     escape_char = (*escape_char_expr->get_constval().stringval)[0];
   }
   auto pattern = dynamic_cast<const Analyzer::Constant*>(expr->get_like_expr());
   CHECK(pattern);
   auto fast_dict_like_lv = codegenDictLike(expr->get_own_arg(),
                                            pattern,
                                            expr->get_is_ilike(),
                                            expr->get_is_simple(),
                                            escape_char,
                                            co);
   if (fast_dict_like_lv) {
     return fast_dict_like_lv;
   }
   const auto& ti = expr->get_arg()->get_type_info();
   CHECK(ti.is_string());
   if (g_enable_watchdog && ti.get_compression() != kENCODING_NONE) {
     throw WatchdogException(
         "Cannot do LIKE / ILIKE on this dictionary encoded column, its cardinality is "
         "too high");
   }
   auto str_lv = codegen(expr->get_arg(), true, co);
   if (str_lv.size() != 3) {
     CHECK_EQ(size_t(1), str_lv.size());
     str_lv.push_back(cgen_state_->ir_builder_.CreateExtractValue(str_lv.front(), 0));
     str_lv.push_back(cgen_state_->ir_builder_.CreateExtractValue(str_lv.front(), 1));
     str_lv.back() = cgen_state_->ir_builder_.CreateTrunc(
         str_lv.back(), llvm::Type::getInt32Ty(cgen_state_->context_));
     if (co.device_type == ExecutorDeviceType::GPU) {
       throw QueryMustRunOnCpu();
     }
   }
   auto like_expr_arg_lvs = codegen(expr->get_like_expr(), true, co);
   CHECK_EQ(size_t(3), like_expr_arg_lvs.size());
   const bool is_nullable{!expr->get_arg()->get_type_info().get_notnull()};
   std::vector<llvm::Value*> str_like_args{str_lv[1],
                                           str_lv[2],
                                           like_expr_arg_lvs[1],
                                           like_expr_arg_lvs[2],
                                           cgen_state_->llInt(int8_t(escape_char))};
   std::string fn_name{expr->get_is_ilike() ? "string_ilike" : "string_like"};
   if (expr->get_is_simple()) {
     fn_name += "_simple";
   }
   if (is_nullable) {
     fn_name += "_nullable";
     str_like_args.push_back(cgen_state_->inlineIntNull(expr->get_type_info()));
   }
   return cgen_state_->emitCall(fn_name, str_like_args);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::RegexpExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 845 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), codegenDictRegexp(), CgenState::context_, CompilationOptions::device_type, CgenState::emitExternalCall(), extract_cast_arg(), g_enable_watchdog, Analyzer::RegexpExpr::get_arg(), Analyzer::RegexpExpr::get_escape_expr(), get_int_type(), SQLTypeInfo::get_notnull(), Analyzer::RegexpExpr::get_own_arg(), Analyzer::RegexpExpr::get_pattern_expr(), Analyzer::Expr::get_type_info(), GPU, CgenState::inlineIntNull(), CgenState::ir_builder_, is_unnest(), kENCODING_NONE, and CgenState::llInt().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (is_unnest(extract_cast_arg(expr->get_arg()))) {
     throw std::runtime_error("REGEXP not supported for unnested expressions");
   }
   char escape_char{'\\'};
   if (expr->get_escape_expr()) {
     auto escape_char_expr =
         dynamic_cast<const Analyzer::Constant*>(expr->get_escape_expr());
     CHECK(escape_char_expr);
     CHECK(escape_char_expr->get_type_info().is_string());
     CHECK_EQ(size_t(1), escape_char_expr->get_constval().stringval->size());
     escape_char = (*escape_char_expr->get_constval().stringval)[0];
   }
   auto pattern = dynamic_cast<const Analyzer::Constant*>(expr->get_pattern_expr());
   CHECK(pattern);
   auto fast_dict_pattern_lv =
       codegenDictRegexp(expr->get_own_arg(), pattern, escape_char, co);
   if (fast_dict_pattern_lv) {
     return fast_dict_pattern_lv;
   }
   const auto& ti = expr->get_arg()->get_type_info();
   CHECK(ti.is_string());
   if (g_enable_watchdog && ti.get_compression() != kENCODING_NONE) {
     throw WatchdogException(
         "Cannot do REGEXP_LIKE on this dictionary encoded column, its cardinality is too "
         "high");
   }
   // Now we know we are working on NONE ENCODED column. So switch back to CPU
   if (co.device_type == ExecutorDeviceType::GPU) {
     throw QueryMustRunOnCpu();
   }
   auto str_lv = codegen(expr->get_arg(), true, co);
   if (str_lv.size() != 3) {
     CHECK_EQ(size_t(1), str_lv.size());
     str_lv.push_back(cgen_state_->ir_builder_.CreateExtractValue(str_lv.front(), 0));
     str_lv.push_back(cgen_state_->ir_builder_.CreateExtractValue(str_lv.front(), 1));
     str_lv.back() = cgen_state_->ir_builder_.CreateTrunc(
         str_lv.back(), llvm::Type::getInt32Ty(cgen_state_->context_));
   }
   auto regexp_expr_arg_lvs = codegen(expr->get_pattern_expr(), true, co);
   CHECK_EQ(size_t(3), regexp_expr_arg_lvs.size());
   const bool is_nullable{!expr->get_arg()->get_type_info().get_notnull()};
   std::vector<llvm::Value*> regexp_args{
       str_lv[1], str_lv[2], regexp_expr_arg_lvs[1], regexp_expr_arg_lvs[2]};
   std::string fn_name("regexp_like");
   regexp_args.push_back(cgen_state_->llInt(int8_t(escape_char)));
   if (is_nullable) {
     fn_name += "_nullable";
     regexp_args.push_back(cgen_state_->inlineIntNull(expr->get_type_info()));
     return cgen_state_->emitExternalCall(
         fn_name, get_int_type(8, cgen_state_->context_), regexp_args);
   }
   return cgen_state_->emitExternalCall(
       fn_name, get_int_type(1, cgen_state_->context_), regexp_args);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::CardinalityExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 68 of file ArrayIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegen(), CgenState::context_, CgenState::emitExternalCall(), Analyzer::CardinalityExpr::get_arg(), get_int_type(), Analyzer::Expr::get_type_info(), CgenState::inlineIntNull(), CgenState::llInt(), log2_bytes(), and posArg().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto arr_expr = expr->get_arg();
   const auto& array_ti = arr_expr->get_type_info();
   CHECK(array_ti.is_array());
   const auto& elem_ti = array_ti.get_elem_type();
   auto arr_lv = codegen(arr_expr, true, co);
   std::string fn_name("array_size");
 
   if (auto alloca = llvm::dyn_cast<llvm::AllocaInst>(arr_lv.front())) {
     if (alloca->getAllocatedType()->isStructTy()) {
       throw std::runtime_error("Unsupported type used in 'cardinality'");
     }
   }
 
   std::vector<llvm::Value*> array_size_args{
       arr_lv.front(),
       posArg(arr_expr),
       cgen_state_->llInt(log2_bytes(elem_ti.get_logical_size()))};
   const bool is_nullable{!arr_expr->get_type_info().get_notnull()};
   if (is_nullable) {
     fn_name += "_nullable";
     array_size_args.push_back(cgen_state_->inlineIntNull(expr->get_type_info()));
   }
   return cgen_state_->emitExternalCall(
       fn_name, get_int_type(32, cgen_state_->context_), array_size_args);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::BinOper *	bin_oper,
		const CompilationOptions &	co
	)

private

Definition at line 234 of file IRCodegen.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, codegenArith(), codegenArrayAt(), codegenCmp(), codegenLogical(), Analyzer::BinOper::get_optype(), IS_ARITHMETIC, IS_COMPARISON, IS_LOGIC, and kARRAY_AT.

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto optype = bin_oper->get_optype();
   if (IS_ARITHMETIC(optype)) {
     return codegenArith(bin_oper, co);
   }
   if (IS_COMPARISON(optype)) {
     return codegenCmp(bin_oper, co);
   }
   if (IS_LOGIC(optype)) {
     return codegenLogical(bin_oper, co);
   }
   if (optype == kARRAY_AT) {
     return codegenArrayAt(bin_oper, co);
   }
   abort();
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::UOper *	u_oper,
		const CompilationOptions &	co
	)

private

Definition at line 253 of file IRCodegen.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, codegenCast(), codegenIsNull(), codegenLogical(), codegenUMinus(), codegenUnnest(), Analyzer::UOper::get_optype(), kCAST, kISNULL, kNOT, kUMINUS, kUNNEST, and UNREACHABLE.

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto optype = u_oper->get_optype();
   switch (optype) {
     case kNOT: {
       return codegenLogical(u_oper, co);
     }
     case kCAST: {
       return codegenCast(u_oper, co);
     }
     case kUMINUS: {
       return codegenUMinus(u_oper, co);
     }
     case kISNULL: {
       return codegenIsNull(u_oper, co);
     }
     case kUNNEST:
       return codegenUnnest(u_oper, co);
     default:
       UNREACHABLE();
   }
   return nullptr;
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegenAdd	(	const Analyzer::BinOper *	bin_oper,
		llvm::Value *	lhs_lv,
		llvm::Value *	rhs_lv,
		const std::string &	null_typename,
		const std::string &	null_check_suffix,
		const SQLTypeInfo &	ti,
		const CompilationOptions &	co
	)

private

Definition at line 219 of file ArithmeticIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, checkExpressionRanges(), codegenBinOpWithOverflowForCPU(), codegenSkipOverflowCheckForNull(), CgenState::context_, CPU, CgenState::current_func_, CompilationOptions::device_type, CgenState::emitCall(), SQLTypeInfo::get_size(), inline_int_null_val(), CgenState::inlineIntMaxMin(), CgenState::ir_builder_, SQLTypeInfo::is_decimal(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_timeinterval(), CgenState::llInt(), and CgenState::needs_error_check_.

Referenced by codegenIntArith().

                                                                      {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK_EQ(lhs_lv->getType(), rhs_lv->getType());
   CHECK(ti.is_integer() || ti.is_decimal() || ti.is_timeinterval());
   llvm::Value* chosen_max{nullptr};
   llvm::Value* chosen_min{nullptr};
   std::tie(chosen_max, chosen_min) = cgen_state_->inlineIntMaxMin(ti.get_size(), true);
   auto need_overflow_check =
       !checkExpressionRanges(bin_oper,
                              static_cast<llvm::ConstantInt*>(chosen_min)->getSExtValue(),
                              static_cast<llvm::ConstantInt*>(chosen_max)->getSExtValue());
 
   if (need_overflow_check && co.device_type == ExecutorDeviceType::CPU) {
     return codegenBinOpWithOverflowForCPU(
         bin_oper, lhs_lv, rhs_lv, null_check_suffix, ti);
   }
 
   llvm::BasicBlock* add_ok{nullptr};
   llvm::BasicBlock* add_fail{nullptr};
   if (need_overflow_check) {
     cgen_state_->needs_error_check_ = true;
     add_ok = llvm::BasicBlock::Create(
         cgen_state_->context_, "add_ok", cgen_state_->current_func_);
     if (!null_check_suffix.empty()) {
       codegenSkipOverflowCheckForNull(lhs_lv, rhs_lv, add_ok, ti);
     }
     add_fail = llvm::BasicBlock::Create(
         cgen_state_->context_, "add_fail", cgen_state_->current_func_);
     llvm::Value* detected{nullptr};
     auto const_zero = llvm::ConstantInt::get(lhs_lv->getType(), 0, true);
     auto overflow = cgen_state_->ir_builder_.CreateAnd(
         cgen_state_->ir_builder_.CreateICmpSGT(lhs_lv, const_zero),
         cgen_state_->ir_builder_.CreateICmpSGT(
             rhs_lv, cgen_state_->ir_builder_.CreateSub(chosen_max, lhs_lv)));
     auto underflow = cgen_state_->ir_builder_.CreateAnd(
         cgen_state_->ir_builder_.CreateICmpSLT(lhs_lv, const_zero),
         cgen_state_->ir_builder_.CreateICmpSLT(
             rhs_lv, cgen_state_->ir_builder_.CreateSub(chosen_min, lhs_lv)));
     detected = cgen_state_->ir_builder_.CreateOr(overflow, underflow);
     cgen_state_->ir_builder_.CreateCondBr(detected, add_fail, add_ok);
     cgen_state_->ir_builder_.SetInsertPoint(add_ok);
   }
   auto ret = null_check_suffix.empty()
                  ? cgen_state_->ir_builder_.CreateAdd(lhs_lv, rhs_lv)
                  : cgen_state_->emitCall(
                        "add_" + null_typename + null_check_suffix,
                        {lhs_lv, rhs_lv, cgen_state_->llInt(inline_int_null_val(ti))});
   if (need_overflow_check) {
     cgen_state_->ir_builder_.SetInsertPoint(add_fail);
     cgen_state_->ir_builder_.CreateRet(
         cgen_state_->llInt(int32_t(ErrorCode::OVERFLOW_OR_UNDERFLOW)));
     cgen_state_->ir_builder_.SetInsertPoint(add_ok);
   }
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenArith	(	const Analyzer::BinOper *	bin_oper,
		const CompilationOptions &	co
	)

private

Definition at line 38 of file ArithmeticIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), codegenCastBetweenIntTypes(), codegenDeciDiv(), codegenFpArith(), codegenIntArith(), Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_optype(), Analyzer::BinOper::get_right_operand(), Analyzer::Expr::get_type_info(), IS_ARITHMETIC, and kDIVIDE.

Referenced by codegen(), and codegenLinRegPredict().

                                                                        {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto optype = bin_oper->get_optype();
   CHECK(IS_ARITHMETIC(optype));
   const auto lhs = bin_oper->get_left_operand();
   const auto rhs = bin_oper->get_right_operand();
   const auto& lhs_type = lhs->get_type_info();
   const auto& rhs_type = rhs->get_type_info();
 
   if (lhs_type.is_decimal() && rhs_type.is_decimal() && optype == kDIVIDE) {
     const auto ret = codegenDeciDiv(bin_oper, co);
     if (ret) {
       return ret;
     }
   }
 
   auto lhs_lv = codegen(lhs, true, co).front();
   auto rhs_lv = codegen(rhs, true, co).front();
   // Handle operations when a time interval operand is involved, an operation
   // between an integer and a time interval isn't normalized by the analyzer.
   if (lhs_type.is_timeinterval()) {
     rhs_lv = codegenCastBetweenIntTypes(rhs_lv, rhs_type, lhs_type);
   } else if (rhs_type.is_timeinterval()) {
     lhs_lv = codegenCastBetweenIntTypes(lhs_lv, lhs_type, rhs_type);
   } else {
     CHECK_EQ(lhs_type.get_type(), rhs_type.get_type());
   }
   if (lhs_type.is_integer() || lhs_type.is_decimal() || lhs_type.is_timeinterval()) {
     return codegenIntArith(bin_oper, lhs_lv, rhs_lv, co);
   }
   if (lhs_type.is_fp()) {
     return codegenFpArith(bin_oper, lhs_lv, rhs_lv);
   }
   CHECK(false);
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenArrayAt	(	const Analyzer::BinOper *	array_at,
		const CompilationOptions &	co
	)

private

Definition at line 26 of file ArrayIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), CgenState::context_, CgenState::emitExternalCall(), get_int_type(), Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_right_operand(), Analyzer::Expr::get_type_info(), CgenState::inlineFpNull(), CgenState::inlineIntNull(), CgenState::ir_builder_, kDOUBLE, posArg(), and to_string().

Referenced by codegen().

                                                                          {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto arr_expr = array_at->get_left_operand();
   const auto idx_expr = array_at->get_right_operand();
   const auto& idx_ti = idx_expr->get_type_info();
   CHECK(idx_ti.is_integer());
   auto idx_lvs = codegen(idx_expr, true, co);
   CHECK_EQ(size_t(1), idx_lvs.size());
   auto idx_lv = idx_lvs.front();
   if (idx_ti.get_logical_size() < 8) {
     idx_lv = cgen_state_->ir_builder_.CreateCast(llvm::Instruction::CastOps::SExt,
                                                  idx_lv,
                                                  get_int_type(64, cgen_state_->context_));
   }
   const auto& array_ti = arr_expr->get_type_info();
   CHECK(array_ti.is_array());
   const auto& elem_ti = array_ti.get_elem_type();
   const std::string array_at_fname{
       elem_ti.is_fp()
           ? "array_at_" + std::string(elem_ti.get_type() == kDOUBLE ? "double_checked"
                                                                     : "float_checked")
           : "array_at_int" + std::to_string(elem_ti.get_logical_size() * 8) +
                 "_t_checked"};
   const auto ret_ty =
       elem_ti.is_fp()
           ? (elem_ti.get_type() == kDOUBLE
                  ? llvm::Type::getDoubleTy(cgen_state_->context_)
                  : llvm::Type::getFloatTy(cgen_state_->context_))
           : get_int_type(elem_ti.get_logical_size() * 8, cgen_state_->context_);
   const auto arr_lvs = codegen(arr_expr, true, co);
   CHECK_EQ(size_t(1), arr_lvs.size());
   return cgen_state_->emitExternalCall(
       array_at_fname,
       ret_ty,
       {arr_lvs.front(),
        posArg(arr_expr),
        idx_lv,
        elem_ti.is_fp() ? static_cast<llvm::Value*>(cgen_state_->inlineFpNull(elem_ti))
                        : static_cast<llvm::Value*>(cgen_state_->inlineIntNull(elem_ti))});
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair< llvm::Value , llvm::Value > CodeGenerator::codegenArrayBuff	(	llvm::Value *	chunk,
		llvm::Value *	row_pos,
		SQLTypes	array_type,
		bool	cast_and_extend
	)

private

Definition at line 685 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CgenState::context_, CgenState::emitExternalCall(), SQLTypeInfo::get_elem_type(), kARRAY, and kENCODING_NONE.

Referenced by codegenFunctionOperCastArgs().

                           {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto elem_ti =
       SQLTypeInfo(
           SQLTypes::kARRAY, 0, 0, false, EncodingType::kENCODING_NONE, 0, array_type)
           .get_elem_type();
 
   auto buff = cgen_state_->emitExternalCall(
       "array_buff", llvm::Type::getInt32PtrTy(cgen_state_->context_), {chunk, row_pos});
 
   auto len = cgen_state_->emitExternalCall(
       "array_size",
       get_int_type(32, cgen_state_->context_),
       {chunk, row_pos, cgen_state_->llInt(log2_bytes(elem_ti.get_logical_size()))});
 
   if (cast_and_extend) {
     buff = castArrayPointer(buff, elem_ti);
     len =
         cgen_state_->ir_builder_.CreateZExt(len, get_int_type(64, cgen_state_->context_));
   }
 
   return std::make_pair(buff, len);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenArrayExpr	(	const Analyzer::ArrayExpr *	array_expr,
		const CompilationOptions &	co
	)

private

Definition at line 97 of file ArrayIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegen(), CgenState::context_, CompilationOptions::device_type, CgenState::emitExternalCall(), executor(), get_int_array_type(), get_int_type(), Analyzer::Expr::get_type_info(), Analyzer::ArrayExpr::getElement(), Analyzer::ArrayExpr::getElementCount(), GPU, CgenState::ir_builder_, Analyzer::ArrayExpr::isLocalAlloc(), Analyzer::ArrayExpr::isNull(), kENCODING_GEOINT, CgenState::llFp(), and CgenState::llInt().

Referenced by codegen().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   using ValueVector = std::vector<llvm::Value*>;
   ValueVector argument_list;
   auto& ir_builder(cgen_state_->ir_builder_);
 
   const auto& return_type = array_expr->get_type_info();
   auto coord_compression = (return_type.get_compression() == kENCODING_GEOINT);
   if (coord_compression) {
     CHECK(array_expr->isLocalAlloc() && array_expr->getElementCount() == 2);
   }
   for (size_t i = 0; i < array_expr->getElementCount(); i++) {
     const auto arg = array_expr->getElement(i);
     const auto arg_lvs = codegen(arg, true, co);
     if (arg_lvs.size() == 1) {
       if (coord_compression) {
         // Compress double coords on the fly
         auto mult = cgen_state_->llFp(2147483647.0 / (i == 0 ? 180.0 : 90.0));
         auto c = ir_builder.CreateCast(llvm::Instruction::CastOps::FPToSI,
                                        ir_builder.CreateFMul(arg_lvs.front(), mult),
                                        get_int_type(32, cgen_state_->context_));
         argument_list.push_back(c);
       } else {
         argument_list.push_back(arg_lvs.front());
       }
     } else {
       throw std::runtime_error(
           "Unexpected argument count during array[] code generation.");
     }
   }
 
   auto array_element_size_bytes =
       return_type.get_elem_type().get_array_context_logical_size();
   auto* array_index_type =
       get_int_type(array_element_size_bytes * 8, cgen_state_->context_);
   auto* array_type = get_int_array_type(
       array_element_size_bytes * 8, array_expr->getElementCount(), cgen_state_->context_);
 
   if (array_expr->isNull()) {
     return {llvm::ConstantPointerNull::get(
                 llvm::PointerType::get(get_int_type(64, cgen_state_->context_), 0)),
             cgen_state_->llInt(0)};
   }
 
   if (0 == array_expr->getElementCount()) {
     llvm::Constant* dead_const = cgen_state_->llInt(0xdead);
     llvm::Value* dead_pointer = llvm::ConstantExpr::getIntToPtr(
         dead_const, llvm::PointerType::get(get_int_type(64, cgen_state_->context_), 0));
     return {dead_pointer, cgen_state_->llInt(0)};
   }
 
   llvm::Value* allocated_target_buffer;
   if (array_expr->isLocalAlloc()) {
     allocated_target_buffer = ir_builder.CreateAlloca(array_type);
   } else {
     if (co.device_type == ExecutorDeviceType::GPU) {
       throw QueryMustRunOnCpu();
     }
 
     allocated_target_buffer =
         cgen_state_->emitExternalCall("allocate_varlen_buffer",
                                       llvm::Type::getInt8PtrTy(cgen_state_->context_),
                                       {cgen_state_->llInt(array_expr->getElementCount()),
                                        cgen_state_->llInt(array_element_size_bytes)});
     cgen_state_->emitExternalCall(
         "register_buffer_with_executor_rsm",
         llvm::Type::getVoidTy(cgen_state_->context_),
         {cgen_state_->llInt(reinterpret_cast<int64_t>(executor())),
          allocated_target_buffer});
   }
   llvm::Value* casted_allocated_target_buffer =
       ir_builder.CreatePointerCast(allocated_target_buffer, array_type->getPointerTo());
 
   for (size_t i = 0; i < array_expr->getElementCount(); i++) {
     auto* element = argument_list[i];
     auto* element_ptr = ir_builder.CreateGEP(
         array_type,
         casted_allocated_target_buffer,
         std::vector<llvm::Value*>{cgen_state_->llInt(0), cgen_state_->llInt(i)});
 
     const auto& elem_ti = return_type.get_elem_type();
     if (elem_ti.is_boolean()) {
       const auto byte_casted_bit =
           ir_builder.CreateIntCast(element, array_index_type, true);
       ir_builder.CreateStore(byte_casted_bit, element_ptr);
     } else if (elem_ti.is_fp()) {
       switch (elem_ti.get_size()) {
         case sizeof(double): {
           const auto double_element_ptr = ir_builder.CreatePointerCast(
               element_ptr, llvm::Type::getDoublePtrTy(cgen_state_->context_));
           ir_builder.CreateStore(element, double_element_ptr);
           break;
         }
         case sizeof(float): {
           const auto float_element_ptr = ir_builder.CreatePointerCast(
               element_ptr, llvm::Type::getFloatPtrTy(cgen_state_->context_));
           ir_builder.CreateStore(element, float_element_ptr);
           break;
         }
         default:
           UNREACHABLE();
       }
     } else if (elem_ti.is_integer() || elem_ti.is_decimal() || elem_ti.is_date() ||
                elem_ti.is_timestamp() || elem_ti.is_time() || elem_ti.is_timeinterval() ||
                elem_ti.is_dict_encoded_string()) {
       // TODO(adb): this validation and handling should be done elsewhere
       const auto sign_extended_element = ir_builder.CreateSExt(element, array_index_type);
       ir_builder.CreateStore(sign_extended_element, element_ptr);
     } else {
       throw std::runtime_error("Unsupported type used in ARRAY construction.");
     }
   }
 
   return {ir_builder.CreateGEP(
               array_type, casted_allocated_target_buffer, cgen_state_->llInt(0)),
           cgen_state_->llInt(array_expr->getElementCount())};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenBinOpWithOverflowForCPU	(	const Analyzer::BinOper *	bin_oper,
		llvm::Value *	lhs_lv,
		llvm::Value *	rhs_lv,
		const std::string &	null_check_suffix,
		const SQLTypeInfo &	ti
	)

private

Definition at line 728 of file ArithmeticIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, codegenSkipOverflowCheckForNull(), CgenState::context_, CgenState::current_func_, getArithWithOverflowIntrinsic(), inline_int_null_val(), CgenState::ir_builder_, CgenState::llInt(), and CgenState::needs_error_check_.

Referenced by codegenAdd(), codegenMul(), and codegenSub().

                            {
   AUTOMATIC_IR_METADATA(cgen_state_);
   cgen_state_->needs_error_check_ = true;
 
   llvm::BasicBlock* check_ok = llvm::BasicBlock::Create(
       cgen_state_->context_, "ovf_ok", cgen_state_->current_func_);
   llvm::BasicBlock* check_fail = llvm::BasicBlock::Create(
       cgen_state_->context_, "ovf_detected", cgen_state_->current_func_);
   llvm::BasicBlock* null_check{nullptr};
 
   if (!null_check_suffix.empty()) {
     null_check = cgen_state_->ir_builder_.GetInsertBlock();
     codegenSkipOverflowCheckForNull(lhs_lv, rhs_lv, check_ok, ti);
   }
 
   // Compute result and overflow flag
   auto func = getArithWithOverflowIntrinsic(bin_oper, lhs_lv->getType());
   auto ret_and_overflow = cgen_state_->ir_builder_.CreateCall(
       func, std::vector<llvm::Value*>{lhs_lv, rhs_lv});
   auto ret = cgen_state_->ir_builder_.CreateExtractValue(ret_and_overflow,
                                                          std::vector<unsigned>{0});
   auto overflow = cgen_state_->ir_builder_.CreateExtractValue(ret_and_overflow,
                                                               std::vector<unsigned>{1});
   auto val_bb = cgen_state_->ir_builder_.GetInsertBlock();
 
   // Return error on overflow
   cgen_state_->ir_builder_.CreateCondBr(overflow, check_fail, check_ok);
   cgen_state_->ir_builder_.SetInsertPoint(check_fail);
   cgen_state_->ir_builder_.CreateRet(
       cgen_state_->llInt(int32_t(ErrorCode::OVERFLOW_OR_UNDERFLOW)));
 
   cgen_state_->ir_builder_.SetInsertPoint(check_ok);
 
   // In case of null check we have to use NULL result on check fail
   if (null_check) {
     auto phi = cgen_state_->ir_builder_.CreatePHI(ret->getType(), 2);
     phi->addIncoming(llvm::ConstantInt::get(ret->getType(), inline_int_null_val(ti)),
                      null_check);
     phi->addIncoming(ret, val_bb);
     ret = phi;
   }
 
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenBoundingBoxIntersect	(	const SQLOps	optype,
		const SQLQualifier	qualifier,
		const std::shared_ptr< Analyzer::Expr >	lhs,
		const std::shared_ptr< Analyzer::Expr >	rhs,
		const CompilationOptions &	co
	)

private

Definition at line 285 of file CompareIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegenFunctionOper(), CgenState::context_, g_enable_bbox_intersect_hashjoin, get_int_type(), Catalog_Namespace::get_metadata_for_column(), Datum::intval, IS_GEO_POLY, kBOOLEAN, kDOUBLE, kENCODING_GEOINT, kINT, kPOINT, and VLOG.

Referenced by codegenCmp().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto lhs_ti = lhs->get_type_info();
   if (g_enable_bbox_intersect_hashjoin) {
     // failed to build a suitable hash table. short circuit the bounding box interesect
     // expression by always returning true. this will fall into the ST_Contains check,
     // which will do bounding box intersection before the heavier contains computation.
     VLOG(1) << "Failed to build bounding box intersect hash table, short circuiting "
                "bounding box intersect operator.";
     return llvm::ConstantInt::get(get_int_type(8, cgen_state_->context_), true);
   }
   // TODO(adb): we should never get here, but going to leave this in place for now since
   // it will likely be useful in factoring the bounds check out of ST_Contains
   CHECK(lhs_ti.is_geometry());
 
   if (lhs_ti.is_geometry()) {
     // only point in linestring/poly/mpoly is currently supported
     CHECK(lhs_ti.get_type() == kPOINT);
     const auto lhs_col = dynamic_cast<Analyzer::ColumnVar*>(lhs.get());
     CHECK(lhs_col);
 
     // Get the actual point data column descriptor
     auto lhs_column_key = lhs_col->getColumnKey();
     lhs_column_key.column_id = lhs_column_key.column_id + 1;
     const auto coords_cd = Catalog_Namespace::get_metadata_for_column(lhs_column_key);
     CHECK(coords_cd);
 
     std::vector<std::shared_ptr<Analyzer::Expr>> geoargs;
     geoargs.push_back(makeExpr<Analyzer::ColumnVar>(
         coords_cd->columnType,
         shared::ColumnKey{lhs_col->getTableKey(), coords_cd->columnId},
         lhs_col->get_rte_idx()));
 
     Datum input_compression;
     input_compression.intval =
         (lhs_ti.get_compression() == kENCODING_GEOINT && lhs_ti.get_comp_param() == 32)
             ? 1
             : 0;
     geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression));
     Datum input_srid;
     input_srid.intval = lhs_ti.get_input_srid();
     geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_srid));
     Datum output_srid;
     output_srid.intval = lhs_ti.get_output_srid();
     geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, output_srid));
 
     const auto x_ptr_oper = makeExpr<Analyzer::FunctionOper>(
         SQLTypeInfo(kDOUBLE, true), "ST_X_Point", geoargs);
     const auto y_ptr_oper = makeExpr<Analyzer::FunctionOper>(
         SQLTypeInfo(kDOUBLE, true), "ST_Y_Point", geoargs);
 
     const auto rhs_ti = rhs->get_type_info();
     CHECK(IS_GEO_POLY(rhs_ti.get_type()));
     const auto rhs_col = dynamic_cast<Analyzer::ColumnVar*>(rhs.get());
     CHECK(rhs_col);
 
     auto rhs_column_key = rhs_col->getColumnKey();
     rhs_column_key.column_id =
         rhs_column_key.column_id + rhs_ti.get_physical_coord_cols() + 1;
     const auto poly_bounds_cd =
         Catalog_Namespace::get_metadata_for_column(rhs_column_key);
     CHECK(poly_bounds_cd);
 
     auto bbox_col_var = makeExpr<Analyzer::ColumnVar>(
         poly_bounds_cd->columnType,
         shared::ColumnKey{rhs_col->getTableKey(), poly_bounds_cd->columnId},
         rhs_col->get_rte_idx());
 
     const auto bbox_contains_func_oper =
         makeExpr<Analyzer::FunctionOper>(SQLTypeInfo(kBOOLEAN, false),
                                          "Point_Overlaps_Box",
                                          std::vector<std::shared_ptr<Analyzer::Expr>>{
                                              bbox_col_var, x_ptr_oper, y_ptr_oper});
 
     return codegenFunctionOper(bbox_contains_func_oper.get(), co);
   }
 
   CHECK(false) << "Unsupported type for bounding box intersect operator: "
                << lhs_ti.get_type_name();
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CodeGenerator::codegenBufferArgs	(	const std::string &	udf_func_name,
		size_t	param_num,
		llvm::Value *	buffer_buf,
		llvm::Value *	buffer_size,
		llvm::Value *	buffer_is_null,
		std::vector< llvm::Value * > &	output_args
	)

private

Definition at line 713 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CgenState::context_, anonymous_namespace{ExtensionsIR.cpp}::get_buffer_struct_type(), and CgenState::ir_builder_.

Referenced by codegenFunctionOperCastArgs().

                                                                           {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(buffer_buf);
   CHECK(buffer_size);
 
   auto buffer_abstraction = get_buffer_struct_type(
       cgen_state_, ext_func_name, param_num, buffer_buf->getType());
   auto alloc_mem = cgen_state_->ir_builder_.CreateAlloca(buffer_abstraction);
 
   auto buffer_buf_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(buffer_abstraction, alloc_mem, 0);
   cgen_state_->ir_builder_.CreateStore(buffer_buf, buffer_buf_ptr);
 
   auto buffer_size_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(buffer_abstraction, alloc_mem, 1);
   cgen_state_->ir_builder_.CreateStore(buffer_size, buffer_size_ptr);
 
   auto bool_extended_type = llvm::Type::getInt8Ty(cgen_state_->context_);
   auto buffer_null_extended =
       cgen_state_->ir_builder_.CreateZExt(buffer_null, bool_extended_type);
   auto buffer_is_null_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(buffer_abstraction, alloc_mem, 2);
   cgen_state_->ir_builder_.CreateStore(buffer_null_extended, buffer_is_null_ptr);
   output_args.push_back(alloc_mem);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCase	(	const Analyzer::CaseExpr *	case_expr,
		llvm::Type *	case_llvm_type,
		const bool	is_real_str,
		const CompilationOptions &	co
	)

private

Definition at line 65 of file CaseIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK_EQ, codegen(), CgenState::context_, CgenState::current_func_, CgenState::emitCall(), Analyzer::CaseExpr::get_expr_pair_list(), CgenState::ir_builder_, and toBool().

Referenced by codegen().

                                                                       {
   AUTOMATIC_IR_METADATA(cgen_state_);
   // Here the linear control flow will diverge and expressions cached during the
   // code branch code generation (currently just column decoding) are not going
   // to be available once we're done generating the case. Take a snapshot of
   // the cache with FetchCacheAnchor and restore it once we're done with CASE.
   Executor::FetchCacheAnchor anchor(cgen_state_);
   const auto& expr_pair_list = case_expr->get_expr_pair_list();
   std::vector<llvm::Value*> then_lvs;
   std::vector<llvm::BasicBlock*> then_bbs;
   const auto end_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "end_case", cgen_state_->current_func_);
   for (const auto& expr_pair : expr_pair_list) {
     Executor::FetchCacheAnchor branch_anchor(cgen_state_);
     const auto when_lv = toBool(codegen(expr_pair.first.get(), true, co).front());
     const auto cmp_bb = cgen_state_->ir_builder_.GetInsertBlock();
     const auto then_bb = llvm::BasicBlock::Create(cgen_state_->context_,
                                                   "then_case",
                                                   cgen_state_->current_func_,
                                                   /*insert_before=*/end_bb);
     cgen_state_->ir_builder_.SetInsertPoint(then_bb);
     auto then_bb_lvs = codegen(expr_pair.second.get(), true, co);
     if (is_real_str) {
       if (then_bb_lvs.size() == 3) {
         then_lvs.push_back(
             cgen_state_->emitCall("string_pack", {then_bb_lvs[1], then_bb_lvs[2]}));
       } else {
         then_lvs.push_back(then_bb_lvs.front());
       }
     } else {
       CHECK_EQ(size_t(1), then_bb_lvs.size());
       then_lvs.push_back(then_bb_lvs.front());
     }
     then_bbs.push_back(cgen_state_->ir_builder_.GetInsertBlock());
     cgen_state_->ir_builder_.CreateBr(end_bb);
     const auto when_bb = llvm::BasicBlock::Create(
         cgen_state_->context_, "when_case", cgen_state_->current_func_);
     cgen_state_->ir_builder_.SetInsertPoint(cmp_bb);
     cgen_state_->ir_builder_.CreateCondBr(when_lv, then_bb, when_bb);
     cgen_state_->ir_builder_.SetInsertPoint(when_bb);
   }
   const auto else_expr = case_expr->get_else_expr();
   CHECK(else_expr);
   auto else_lvs = codegen(else_expr, true, co);
   llvm::Value* else_lv{nullptr};
   if (else_lvs.size() == 3) {
     else_lv = cgen_state_->emitCall("string_pack", {else_lvs[1], else_lvs[2]});
   } else {
     else_lv = else_lvs.front();
   }
   CHECK(else_lv);
   auto else_bb = cgen_state_->ir_builder_.GetInsertBlock();
   cgen_state_->ir_builder_.CreateBr(end_bb);
   cgen_state_->ir_builder_.SetInsertPoint(end_bb);
   auto then_phi =
       cgen_state_->ir_builder_.CreatePHI(case_llvm_type, expr_pair_list.size() + 1);
   CHECK_EQ(then_bbs.size(), then_lvs.size());
   for (size_t i = 0; i < then_bbs.size(); ++i) {
     then_phi->addIncoming(then_lvs[i], then_bbs[i]);
   }
   then_phi->addIncoming(else_lv, else_bb);
   return then_phi;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCast	(	const Analyzer::UOper *	uoper,
		const CompilationOptions &	co
	)

private

Definition at line 21 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK_EQ, codegen(), CgenState::context_, CgenState::emitCall(), executor_, get_int_type(), Analyzer::UOper::get_operand(), Analyzer::UOper::get_optype(), Analyzer::Expr::get_type_info(), CgenState::ir_builder_, and kCAST.

Referenced by codegen(), codegenCmpDecimalConst(), codegenFunctionOper(), and codegenFunctionOperWithCustomTypeHandling().

                                                                       {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK_EQ(uoper->get_optype(), kCAST);
   const auto& ti = uoper->get_type_info();
   const auto operand = uoper->get_operand();
   const auto operand_as_const = dynamic_cast<const Analyzer::Constant*>(operand);
   // For dictionary encoded constants, the cast holds the dictionary id
   // information as the compression parameter; handle this case separately.
   llvm::Value* operand_lv{nullptr};
   if (operand_as_const) {
     const auto operand_lvs =
         codegen(operand_as_const, ti.get_compression(), ti.getStringDictKey(), co);
     if (operand_lvs.size() == 3) {
       operand_lv = cgen_state_->emitCall("string_pack", {operand_lvs[1], operand_lvs[2]});
     } else {
       operand_lv = operand_lvs.front();
     }
   } else {
     operand_lv = codegen(operand, true, co).front();
   }
 
   // If the operand is a TextEncodingNone struct ({i8*, i64, i8})
   // unpack it into an int64_t using "string_pack" so that codegenCast
   // can properly cast it to a TextEncodingDict
   if (operand_lv->getType()->isPointerTy() &&
       operand_lv->getType()->getPointerElementType()->isStructTy()) {
     auto _struct = cgen_state_->ir_builder_.CreateLoad(
         operand_lv->getType()->getPointerElementType(), operand_lv);
     auto ptr = cgen_state_->ir_builder_.CreateExtractValue(_struct, {0});
     auto len = cgen_state_->ir_builder_.CreateTrunc(
         cgen_state_->ir_builder_.CreateExtractValue(_struct, {1}),
         get_int_type(32, cgen_state_->context_));
     executor_->cgen_state_->emitExternalCall(
         "register_buffer_with_executor_rsm",
         llvm::Type::getVoidTy(executor_->cgen_state_->context_),
         {executor_->cgen_state_->llInt(reinterpret_cast<int64_t>(executor_)), ptr});
     operand_lv = cgen_state_->emitCall("string_pack", {ptr, len});
   }
   const auto& operand_ti = operand->get_type_info();
   return codegenCast(operand_lv, operand_ti, ti, operand_as_const, co);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCast	(	llvm::Value *	operand_lv,
		const SQLTypeInfo &	operand_ti,
		const SQLTypeInfo &	ti,
		const bool	operand_is_const,
		const CompilationOptions &	co
	)

private

Definition at line 73 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, anonymous_namespace{CastIR.cpp}::byte_array_cast(), CgenState::castToTypeIn(), cgen_state_, CHECK, codegenCastBetweenIntTypes(), codegenCastBetweenTimestamps(), codegenCastFromFp(), codegenCastFromString(), codegenCastNonStringToString(), codegenCastTimestampToDate(), codegenCastTimestampToTime(), codegenCastToFp(), CgenState::context_, SQLTypeInfo::get_dimension(), get_int_array_type(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_size(), SQLTypeInfo::get_type(), CgenState::ir_builder_, SQLTypeInfo::is_boolean(), SQLTypeInfo::is_decimal(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_string(), SQLTypeInfo::is_text_encoding_dict(), SQLTypeInfo::is_time(), SQLTypeInfo::is_timestamp(), kDATE, kTIME, and kTIMESTAMP.

                                                                       {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (byte_array_cast(operand_ti, ti)) {
     auto* byte_array_type = get_int_array_type(8, ti.get_size(), cgen_state_->context_);
     return cgen_state_->ir_builder_.CreatePointerCast(operand_lv,
                                                       byte_array_type->getPointerTo());
   } else if (!operand_ti.is_string() && ti.is_text_encoding_dict()) {
     return codegenCastNonStringToString(operand_lv, operand_ti, ti, operand_is_const, co);
   } else if (operand_ti.is_string()) {
     return codegenCastFromString(operand_lv, operand_ti, ti, operand_is_const, co);
   } else if (operand_lv->getType()->isIntegerTy()) {
     CHECK(operand_ti.is_integer() || operand_ti.is_decimal() || operand_ti.is_time() ||
           operand_ti.is_boolean());
 
     if (operand_ti.is_boolean()) {
       // cast boolean to int8
       CHECK(operand_lv->getType()->isIntegerTy(1) ||
             operand_lv->getType()->isIntegerTy(8));
       if (operand_lv->getType()->isIntegerTy(1)) {
         operand_lv = cgen_state_->castToTypeIn(operand_lv, 8);
       }
       if (ti.is_boolean()) {
         return operand_lv;
       }
     }
     if (operand_ti.is_integer() && operand_lv->getType()->isIntegerTy(8) &&
         ti.is_boolean()) {
       // cast int8 to boolean
       return codegenCastBetweenIntTypes(operand_lv, operand_ti, ti);
     }
     if (operand_ti.get_type() == kTIMESTAMP && ti.get_type() == kDATE) {
       // Maybe we should instead generate DatetruncExpr directly from RelAlgTranslator
       // for this pattern. However, DatetruncExpr is supposed to return a timestamp,
       // whereas this cast returns a date. The underlying type for both is still the same,
       // but it still doesn't look like a good idea to misuse DatetruncExpr.
       // Date will have default precision of day, but TIMESTAMP dimension would
       // matter but while converting date through seconds
       return codegenCastTimestampToDate(
           operand_lv, operand_ti.get_dimension(), !ti.get_notnull());
     }
     if (operand_ti.get_type() == kTIMESTAMP && ti.get_type() == kTIME) {
       return codegenCastTimestampToTime(
           operand_lv, operand_ti.get_dimension(), !ti.get_notnull());
     }
     if ((operand_ti.get_type() == kTIMESTAMP || operand_ti.get_type() == kDATE) &&
         ti.get_type() == kTIMESTAMP) {
       const auto operand_dimen =
           (operand_ti.is_timestamp()) ? operand_ti.get_dimension() : 0;
       if (operand_dimen != ti.get_dimension()) {
         return codegenCastBetweenTimestamps(
             operand_lv, operand_ti, ti, !ti.get_notnull());
       }
     }
     if (ti.is_integer() || ti.is_decimal() || ti.is_time()) {
       return codegenCastBetweenIntTypes(operand_lv, operand_ti, ti);
     } else {
       return codegenCastToFp(operand_lv, operand_ti, ti);
     }
   } else {
     return codegenCastFromFp(operand_lv, operand_ti, ti);
   }
   CHECK(false);
   return nullptr;
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegenCastBetweenIntTypes	(	llvm::Value *	operand_lv,
		const SQLTypeInfo &	operand_ti,
		const SQLTypeInfo &	ti,
		bool	upscale = `true`
	)

Definition at line 427 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegenCastBetweenIntTypesOverflowChecks(), CgenState::context_, CgenState::emitCall(), exp_to_scale(), get_bit_width(), get_int_type(), SQLTypeInfo::get_logical_size(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_scale(), inline_int_null_val(), CgenState::inlineIntNull(), CgenState::ir_builder_, SQLTypeInfo::is_decimal(), SQLTypeInfo::is_integer(), kBIGINT, CgenState::llInt(), and numeric_type_name().

Referenced by codegenArith(), codegenCast(), codegenDeciDiv(), codegenWidthBucketExpr(), and Executor::codegenWindowFunctionAggregateCalls().

                                                                      {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (ti.is_decimal() &&
       (!operand_ti.is_decimal() || operand_ti.get_scale() <= ti.get_scale())) {
     if (upscale) {
       if (operand_ti.get_scale() < ti.get_scale()) {  // scale only if needed
         auto scale = exp_to_scale(ti.get_scale() - operand_ti.get_scale());
         const auto scale_lv =
             llvm::ConstantInt::get(get_int_type(64, cgen_state_->context_), scale);
         operand_lv = cgen_state_->ir_builder_.CreateSExt(
             operand_lv, get_int_type(64, cgen_state_->context_));
 
         codegenCastBetweenIntTypesOverflowChecks(operand_lv, operand_ti, ti, scale);
 
         if (operand_ti.get_notnull()) {
           operand_lv = cgen_state_->ir_builder_.CreateMul(operand_lv, scale_lv);
         } else {
           operand_lv = cgen_state_->emitCall(
               "scale_decimal_up",
               {operand_lv,
                scale_lv,
                cgen_state_->llInt(inline_int_null_val(operand_ti)),
                cgen_state_->inlineIntNull(SQLTypeInfo(kBIGINT, false))});
         }
       }
     }
   } else if (operand_ti.is_decimal()) {
     // rounded scale down
     auto scale = (int64_t)exp_to_scale(operand_ti.get_scale() - ti.get_scale());
     const auto scale_lv =
         llvm::ConstantInt::get(get_int_type(64, cgen_state_->context_), scale);
 
     const auto operand_width =
         static_cast<llvm::IntegerType*>(operand_lv->getType())->getBitWidth();
 
     std::string method_name = "scale_decimal_down_nullable";
     if (operand_ti.get_notnull()) {
       method_name = "scale_decimal_down_not_nullable";
     }
 
     CHECK(operand_width == 64);
     operand_lv = cgen_state_->emitCall(
         method_name,
         {operand_lv, scale_lv, cgen_state_->llInt(inline_int_null_val(operand_ti))});
   }
   if (ti.is_integer() && operand_ti.is_integer() &&
       operand_ti.get_logical_size() > ti.get_logical_size()) {
     codegenCastBetweenIntTypesOverflowChecks(operand_lv, operand_ti, ti, 1);
   }
 
   const auto operand_width =
       static_cast<llvm::IntegerType*>(operand_lv->getType())->getBitWidth();
   const auto target_width = get_bit_width(ti);
   if (target_width == operand_width) {
     return operand_lv;
   }
   if (operand_ti.get_notnull()) {
     return cgen_state_->ir_builder_.CreateCast(
         target_width > operand_width ? llvm::Instruction::CastOps::SExt
                                      : llvm::Instruction::CastOps::Trunc,
         operand_lv,
         get_int_type(target_width, cgen_state_->context_));
   }
   return cgen_state_->emitCall("cast_" + numeric_type_name(operand_ti) + "_to_" +
                                    numeric_type_name(ti) + "_nullable",
                                {operand_lv,
                                 cgen_state_->inlineIntNull(operand_ti),
                                 cgen_state_->inlineIntNull(ti)});
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CodeGenerator::codegenCastBetweenIntTypesOverflowChecks	(	llvm::Value *	operand_lv,
		const SQLTypeInfo &	operand_ti,
		const SQLTypeInfo &	ti,
		const int64_t	scale
	)

Definition at line 500 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CgenState::context_, CgenState::current_func_, CgenState::emitCall(), get_int_type(), SQLTypeInfo::get_logical_size(), SQLTypeInfo::get_notnull(), inline_int_null_val(), CgenState::inlineIntMaxMin(), CgenState::inlineIntNull(), CgenState::ir_builder_, kBOOLEAN, CgenState::llInt(), CgenState::needs_error_check_, numeric_type_name(), toBool(), and type_name().

Referenced by codegenCastBetweenIntTypes(), and codegenCastBetweenTimestamps().

                          {
   AUTOMATIC_IR_METADATA(cgen_state_);
   llvm::Value* chosen_max{nullptr};
   llvm::Value* chosen_min{nullptr};
   std::tie(chosen_max, chosen_min) =
       cgen_state_->inlineIntMaxMin(ti.get_logical_size(), true);
 
   cgen_state_->needs_error_check_ = true;
   auto cast_ok = llvm::BasicBlock::Create(
       cgen_state_->context_, "cast_ok", cgen_state_->current_func_);
   auto cast_fail = llvm::BasicBlock::Create(
       cgen_state_->context_, "cast_fail", cgen_state_->current_func_);
   auto operand_max = static_cast<llvm::ConstantInt*>(chosen_max)->getSExtValue() / scale;
   auto operand_min = static_cast<llvm::ConstantInt*>(chosen_min)->getSExtValue() / scale;
   const auto ti_llvm_type =
       get_int_type(8 * ti.get_logical_size(), cgen_state_->context_);
   llvm::Value* operand_max_lv = llvm::ConstantInt::get(ti_llvm_type, operand_max);
   llvm::Value* operand_min_lv = llvm::ConstantInt::get(ti_llvm_type, operand_min);
   const bool is_narrowing = operand_ti.get_logical_size() > ti.get_logical_size();
   if (is_narrowing) {
     const auto operand_ti_llvm_type =
         get_int_type(8 * operand_ti.get_logical_size(), cgen_state_->context_);
     operand_max_lv =
         cgen_state_->ir_builder_.CreateSExt(operand_max_lv, operand_ti_llvm_type);
     operand_min_lv =
         cgen_state_->ir_builder_.CreateSExt(operand_min_lv, operand_ti_llvm_type);
   }
   llvm::Value* over{nullptr};
   llvm::Value* under{nullptr};
   if (operand_ti.get_notnull()) {
     over = cgen_state_->ir_builder_.CreateICmpSGT(operand_lv, operand_max_lv);
     under = cgen_state_->ir_builder_.CreateICmpSLE(operand_lv, operand_min_lv);
   } else {
     const auto type_name =
         is_narrowing ? numeric_type_name(operand_ti) : numeric_type_name(ti);
     const auto null_operand_val = cgen_state_->llInt(inline_int_null_val(operand_ti));
     const auto null_bool_val = cgen_state_->inlineIntNull(SQLTypeInfo(kBOOLEAN, false));
     over = toBool(cgen_state_->emitCall(
         "gt_" + type_name + "_nullable_lhs",
         {operand_lv, operand_max_lv, null_operand_val, null_bool_val}));
     under = toBool(cgen_state_->emitCall(
         "le_" + type_name + "_nullable_lhs",
         {operand_lv, operand_min_lv, null_operand_val, null_bool_val}));
   }
   const auto detected = cgen_state_->ir_builder_.CreateOr(over, under, "overflow");
   cgen_state_->ir_builder_.CreateCondBr(detected, cast_fail, cast_ok);
 
   cgen_state_->ir_builder_.SetInsertPoint(cast_fail);
   cgen_state_->ir_builder_.CreateRet(
       cgen_state_->llInt(int32_t(heavyai::ErrorCode::OVERFLOW_OR_UNDERFLOW)));
 
   cgen_state_->ir_builder_.SetInsertPoint(cast_ok);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCastBetweenTimestamps	(	llvm::Value *	ts_lv,
		const SQLTypeInfo &	operand_dimen,
		const SQLTypeInfo &	target_dimen,
		const bool	nullable
	)

Definition at line 199 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegenCastBetweenIntTypesOverflowChecks(), CgenState::emitCall(), SQLTypeInfo::get_dimension(), DateTimeUtils::get_timestamp_precision_scale(), CgenState::inlineIntNull(), CgenState::ir_builder_, and CgenState::llInt().

Referenced by codegenCast().

                                                                               {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto operand_dimen = operand_ti.get_dimension();
   const auto target_dimen = target_ti.get_dimension();
   if (operand_dimen == target_dimen) {
     return ts_lv;
   }
   CHECK(ts_lv->getType()->isIntegerTy(64));
   const auto scale =
       DateTimeUtils::get_timestamp_precision_scale(abs(operand_dimen - target_dimen));
   if (operand_dimen < target_dimen) {
     codegenCastBetweenIntTypesOverflowChecks(ts_lv, operand_ti, target_ti, scale);
     return nullable
                ? cgen_state_->emitCall("mul_int64_t_nullable_lhs",
                                        {ts_lv,
                                         cgen_state_->llInt(static_cast<int64_t>(scale)),
                                         cgen_state_->inlineIntNull(operand_ti)})
                : cgen_state_->ir_builder_.CreateMul(
                      ts_lv, cgen_state_->llInt(static_cast<int64_t>(scale)));
   }
   return nullable
              ? cgen_state_->emitCall("floor_div_nullable_lhs",
                                      {ts_lv,
                                       cgen_state_->llInt(static_cast<int64_t>(scale)),
                                       cgen_state_->inlineIntNull(operand_ti)})
              : cgen_state_->ir_builder_.CreateSDiv(
                    ts_lv, cgen_state_->llInt(static_cast<int64_t>(scale)));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCastFromFp	(	llvm::Value *	operand_lv,
		const SQLTypeInfo &	operand_ti,
		const SQLTypeInfo &	ti
	)

private

Definition at line 601 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CgenState::context_, CgenState::emitCall(), get_bit_width(), get_int_type(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_type(), SQLTypeInfo::get_type_name(), CgenState::inlineFpNull(), CgenState::inlineIntNull(), CgenState::ir_builder_, SQLTypeInfo::is_decimal(), SQLTypeInfo::is_fp(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_number(), kDOUBLE, kFLOAT, and numeric_type_name().

Referenced by codegenCast().

                                                                      {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (!operand_ti.is_fp() || !ti.is_number() || ti.is_decimal()) {
     throw std::runtime_error("Cast from " + operand_ti.get_type_name() + " to " +
                              ti.get_type_name() + " not supported");
   }
   if (operand_ti.get_type() == ti.get_type()) {
     // Should not have been called when both dimensions are same.
     return operand_lv;
   }
   CHECK(operand_lv->getType()->isFloatTy() || operand_lv->getType()->isDoubleTy());
   if (operand_ti.get_notnull()) {
     if (ti.get_type() == kDOUBLE) {
       return cgen_state_->ir_builder_.CreateFPExt(
           operand_lv, llvm::Type::getDoubleTy(cgen_state_->context_));
     } else if (ti.get_type() == kFLOAT) {
       return cgen_state_->ir_builder_.CreateFPTrunc(
           operand_lv, llvm::Type::getFloatTy(cgen_state_->context_));
     } else if (ti.is_integer()) {
       // Round by adding/subtracting 0.5 before fptosi.
       auto* fp_type = operand_lv->getType()->isFloatTy()
                           ? llvm::Type::getFloatTy(cgen_state_->context_)
                           : llvm::Type::getDoubleTy(cgen_state_->context_);
       auto* zero = llvm::ConstantFP::get(fp_type, 0.0);
       auto* mhalf = llvm::ConstantFP::get(fp_type, -0.5);
       auto* phalf = llvm::ConstantFP::get(fp_type, 0.5);
       auto* is_negative = cgen_state_->ir_builder_.CreateFCmpOLT(operand_lv, zero);
       auto* offset = cgen_state_->ir_builder_.CreateSelect(is_negative, mhalf, phalf);
       operand_lv = cgen_state_->ir_builder_.CreateFAdd(operand_lv, offset);
       return cgen_state_->ir_builder_.CreateFPToSI(
           operand_lv, get_int_type(get_bit_width(ti), cgen_state_->context_));
     } else {
       CHECK(false);
     }
   } else {
     const auto from_tname = numeric_type_name(operand_ti);
     const auto to_tname = numeric_type_name(ti);
     if (ti.is_fp()) {
       return cgen_state_->emitCall("cast_" + from_tname + "_to_" + to_tname + "_nullable",
                                    {operand_lv,
                                     cgen_state_->inlineFpNull(operand_ti),
                                     cgen_state_->inlineFpNull(ti)});
     } else if (ti.is_integer()) {
       return cgen_state_->emitCall("cast_" + from_tname + "_to_" + to_tname + "_nullable",
                                    {operand_lv,
                                     cgen_state_->inlineFpNull(operand_ti),
                                     cgen_state_->inlineIntNull(ti)});
     } else {
       CHECK(false);
     }
   }
   CHECK(false);
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCastFromString	(	llvm::Value *	operand_lv,
		const SQLTypeInfo &	operand_ti,
		const SQLTypeInfo &	ti,
		const bool	operand_is_const,
		const CompilationOptions &	co
	)

private

Definition at line 231 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, StringDictionaryTranslationMgr::codegen(), CgenState::context_, CPU, Data_Namespace::CPU_LEVEL, createStringViewStructType(), CompilationOptions::device_type, shared::StringDictKey::dict_id, CgenState::emitExternalCall(), executor(), g_cluster, SQLTypeInfo::get_compression(), get_int_type(), SQLTypeInfo::get_type_name(), SQLTypeInfo::getStringDictKey(), GPU, Data_Namespace::GPU_LEVEL, SQLTypeInfo::is_dict_intersection(), SQLTypeInfo::is_string(), kENCODING_DICT, kENCODING_NONE, dict_ref_t::literalsDictId, CgenState::llInt(), and CgenState::moveStringDictionaryTranslationMgr().

Referenced by codegenCast().

                                                                                 {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (!ti.is_string()) {
     throw std::runtime_error("Cast from " + operand_ti.get_type_name() + " to " +
                              ti.get_type_name() + " not supported");
   }
   if (operand_ti.get_compression() == kENCODING_NONE &&
       ti.get_compression() == kENCODING_NONE) {
     return operand_lv;
   }
   if (ti.get_compression() == kENCODING_DICT &&
       operand_ti.get_compression() == kENCODING_DICT) {
     if (ti.getStringDictKey() == operand_ti.getStringDictKey()) {
       return operand_lv;
     }
     if (operand_ti.getStringDictKey().dict_id == DictRef::literalsDictId) {
       // Anything being casted from a literal dictionary is not materialized at this point
       // Should already have been kicked to CPU if it was originally a GPU query
 
       CHECK(co.device_type == ExecutorDeviceType::CPU);
       const int64_t source_string_proxy_handle =
           reinterpret_cast<int64_t>(executor()->getStringDictionaryProxy(
               operand_ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true));
 
       const int64_t dest_string_proxy_handle =
           reinterpret_cast<int64_t>(executor()->getStringDictionaryProxy(
               ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true));
 
       auto source_string_proxy_handle_lv = cgen_state_->llInt(source_string_proxy_handle);
       auto dest_string_proxy_handle_lv = cgen_state_->llInt(dest_string_proxy_handle);
 
       std::vector<llvm::Value*> string_cast_lvs{
           operand_lv, source_string_proxy_handle_lv, dest_string_proxy_handle_lv};
       if (ti.is_dict_intersection()) {
         return cgen_state_->emitExternalCall(
             "intersect_translate_string_id_to_other_dict",
             get_int_type(32, cgen_state_->context_),
             string_cast_lvs);
       } else {
         return cgen_state_->emitExternalCall("union_translate_string_id_to_other_dict",
                                              get_int_type(32, cgen_state_->context_),
                                              string_cast_lvs);
       }
     }
 
     const std::vector<StringOps_Namespace::StringOpInfo> string_op_infos;
     auto string_dictionary_translation_mgr =
         std::make_unique<StringDictionaryTranslationMgr>(
             operand_ti.getStringDictKey(),
             ti.getStringDictKey(),
             ti.is_dict_intersection(),
             ti,
             string_op_infos,
             co.device_type == ExecutorDeviceType::GPU ? Data_Namespace::GPU_LEVEL
                                                       : Data_Namespace::CPU_LEVEL,
             executor()->deviceCount(co.device_type),
             executor(),
             executor()->getDataMgr(),
             false /* delay_translation */);
 
     return cgen_state_
         ->moveStringDictionaryTranslationMgr(std::move(string_dictionary_translation_mgr))
         ->codegen(operand_lv, operand_ti, true /* add_nullcheck */, co);
   }
   // dictionary encode non-constant
   if (operand_ti.get_compression() != kENCODING_DICT && !operand_is_const) {
     if (g_cluster) {
       throw std::runtime_error(
           "Cast from none-encoded string to dictionary-encoded not supported for "
           "distributed queries");
     }
     CHECK_EQ(kENCODING_NONE, operand_ti.get_compression());
     CHECK_EQ(kENCODING_DICT, ti.get_compression());
     CHECK(operand_lv->getType()->isStructTy());  // StringView
     if (co.device_type == ExecutorDeviceType::GPU) {
       throw QueryMustRunOnCpu();
     }
     return cgen_state_->emitExternalCall(
         "string_compress",
         get_int_type(32, cgen_state_->context_),
         {operand_lv,
          cgen_state_->llInt(int64_t(executor()->getStringDictionaryProxy(
              ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true)))});
   }
   CHECK(operand_lv->getType()->isIntegerTy(32));
   if (ti.get_compression() == kENCODING_NONE) {
     if (g_cluster) {
       throw std::runtime_error(
           "Cast from dictionary-encoded string to none-encoded not "
           "currently supported for distributed queries.");
     }
     // Removed watchdog check here in exchange for row cardinality based check in
     // RelAlgExecutor
     CHECK_EQ(kENCODING_DICT, operand_ti.get_compression());
     if (co.device_type == ExecutorDeviceType::GPU) {
       throw QueryMustRunOnCpu();
     }
     const int64_t string_dictionary_ptr =
         operand_ti.getStringDictKey().dict_id == 0
             ? reinterpret_cast<int64_t>(
                   executor()->getRowSetMemoryOwner()->getLiteralStringDictProxy())
             : reinterpret_cast<int64_t>(
                   executor()->getStringDictionaryProxy(operand_ti.getStringDictKey(),
                                                        executor()->getRowSetMemoryOwner(),
                                                        true));
     return cgen_state_->emitExternalCall(
         "string_decompress",
         createStringViewStructType(),
         {operand_lv, cgen_state_->llInt(string_dictionary_ptr)});
   }
   CHECK(operand_is_const);
   CHECK_EQ(kENCODING_DICT, ti.get_compression());
   return operand_lv;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCastNonStringToString	(	llvm::Value *	operand_lv,
		const SQLTypeInfo &	operand_ti,
		const SQLTypeInfo &	ti,
		const bool	operand_is_const,
		const CompilationOptions &	co
	)

private

Definition at line 350 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CgenState::context_, CompilationOptions::device_type, CgenState::emitExternalCall(), executor(), g_cluster, SQLTypeInfo::get_compression(), SQLTypeInfo::get_dimension(), get_int_type(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_precision(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_type(), SQLTypeInfo::getStringDictKey(), GPU, SQLTypeInfo::is_string(), kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kENCODING_NONE, kFLOAT, kINT, kNUMERIC, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, CgenState::llInt(), to_lower(), and toString().

Referenced by codegenCast().

                                                                                        {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(!operand_ti.is_string());
   if (ti.get_compression() == kENCODING_NONE) {
     throw std::runtime_error("Cast to none-encoded strings currently unsupported.");
   }
   if (g_cluster) {
     throw std::runtime_error(
         "Cast to dictionary-encoded string type not supported for "
         "distributed queries");
   }
   if (co.device_type == ExecutorDeviceType::GPU) {
     throw QueryMustRunOnCpu();
   }
   std::string fn_call{"convert_to_string_and_encode_"};
   const auto operand_type = operand_ti.get_type();
   std::vector operand_lvs{operand_lv};
   switch (operand_type) {
     case kBOOLEAN:
       fn_call += "bool";
       break;
     case kTINYINT:
     case kSMALLINT:
     case kINT:
     case kBIGINT:
     case kFLOAT:
     case kDOUBLE:
       fn_call += to_lower(toString(operand_type));
       break;
     case kNUMERIC:
     case kDECIMAL:
       fn_call += "decimal";
       operand_lvs.emplace_back(llvm::ConstantInt::get(
           get_int_type(32, cgen_state_->context_), operand_ti.get_precision()));
       operand_lvs.emplace_back(llvm::ConstantInt::get(
           get_int_type(32, cgen_state_->context_), operand_ti.get_scale()));
       break;
     case kTIME:
       fn_call += "time";
       break;
     case kTIMESTAMP:
       fn_call += "timestamp";
       operand_lvs.emplace_back(llvm::ConstantInt::get(
           get_int_type(32, cgen_state_->context_), operand_ti.get_dimension()));
       break;
     case kDATE:
       fn_call += "date";
       break;
     default:
       throw std::runtime_error("Unimplemented type for string cast");
   }
   operand_lvs.emplace_back(
       cgen_state_->llInt(int64_t(executor()->getStringDictionaryProxy(
           ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true))));
 
   auto ret = cgen_state_->emitExternalCall(
       fn_call, get_int_type(32, cgen_state_->context_), operand_lvs);
 
   std::unique_ptr<CodeGenerator::NullCheckCodegen> nullcheck_codegen;
   const bool is_nullable = !operand_ti.get_notnull();
   if (is_nullable) {
     nullcheck_codegen =
         std::make_unique<NullCheckCodegen>(cgen_state_,
                                            executor(),
                                            operand_lvs.front(),
                                            operand_ti,
                                            "cast_non_string_to_string_nullcheck");
     CHECK(nullcheck_codegen);
     ret = nullcheck_codegen->finalize(cgen_state_->inlineNull(ti), ret);
   }
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCastTimestampToDate	(	llvm::Value *	ts_lv,
		const int	dimen,
		const bool	nullable
	)

private

Definition at line 162 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CgenState::context_, CgenState::emitExternalCall(), get_int_type(), DateTimeUtils::get_timestamp_precision_scale(), CgenState::inlineIntNull(), kBIGINT, and CgenState::llInt().

Referenced by codegenCast().

                                                                             {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(ts_lv->getType()->isIntegerTy(64));
   if (dimen > 0) {
     if (nullable) {
       return cgen_state_->emitExternalCall(
           "DateTruncateHighPrecisionToDateNullable",
           get_int_type(64, cgen_state_->context_),
           {{ts_lv,
             cgen_state_->llInt(DateTimeUtils::get_timestamp_precision_scale(dimen)),
             cgen_state_->inlineIntNull(SQLTypeInfo(kBIGINT, false))}});
     }
     return cgen_state_->emitExternalCall(
         "DateTruncateHighPrecisionToDate",
         get_int_type(64, cgen_state_->context_),
         {{ts_lv,
           cgen_state_->llInt(DateTimeUtils::get_timestamp_precision_scale(dimen))}});
   }
   std::unique_ptr<CodeGenerator::NullCheckCodegen> nullcheck_codegen;
   if (nullable) {
     nullcheck_codegen =
         std::make_unique<NullCheckCodegen>(cgen_state_,
                                            executor(),
                                            ts_lv,
                                            SQLTypeInfo(kTIMESTAMP, dimen, 0, !nullable),
                                            "cast_timestamp_nullcheck");
   }
   auto ret = cgen_state_->emitExternalCall(
       "datetrunc_day", get_int_type(64, cgen_state_->context_), {ts_lv});
   if (nullcheck_codegen) {
     ret = nullcheck_codegen->finalize(ll_int(NULL_BIGINT, cgen_state_->context_), ret);
   }
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCastTimestampToTime	(	llvm::Value *	ts_lv,
		const int	dimen,
		const bool	nullable
	)

private

Definition at line 142 of file CastIR.cpp.

References cgen_state_, CgenState::context_, CgenState::emitExternalCall(), get_int_type(), DateTimeUtils::get_timestamp_precision_scale(), CgenState::inlineIntNull(), kBIGINT, and CgenState::llInt().

Referenced by codegenCast().

                                                                             {
   std::vector<llvm::Value*> datetrunc_args{ts_lv};
   std::string hptodate_fname;
   if (dimen > 0) {
     hptodate_fname = "ExtractTimeFromHPTimestamp";
     datetrunc_args.push_back(
         cgen_state_->llInt(DateTimeUtils::get_timestamp_precision_scale(dimen)));
   } else {
     hptodate_fname = "ExtractTimeFromLPTimestamp";
   }
   if (nullable) {
     datetrunc_args.push_back(cgen_state_->inlineIntNull(SQLTypeInfo(kBIGINT, false)));
     hptodate_fname += "Nullable";
   }
   return cgen_state_->emitExternalCall(
       hptodate_fname, get_int_type(64, cgen_state_->context_), datetrunc_args);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCastToFp	(	llvm::Value *	operand_lv,
		const SQLTypeInfo &	operand_ti,
		const SQLTypeInfo &	ti
	)

private

Definition at line 558 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CgenState::context_, CgenState::emitCall(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_type(), SQLTypeInfo::get_type_name(), CgenState::inlineFpNull(), CgenState::inlineIntNull(), CgenState::ir_builder_, SQLTypeInfo::is_fp(), kFLOAT, numeric_type_name(), and shared::power10().

Referenced by codegenCast().

                                                                    {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (!ti.is_fp()) {
     throw std::runtime_error("Cast from " + operand_ti.get_type_name() + " to " +
                              ti.get_type_name() + " not supported");
   }
   llvm::Value* result_lv;
   if (operand_ti.get_notnull()) {
     auto const fp_type = ti.get_type() == kFLOAT
                              ? llvm::Type::getFloatTy(cgen_state_->context_)
                              : llvm::Type::getDoubleTy(cgen_state_->context_);
     result_lv = cgen_state_->ir_builder_.CreateSIToFP(operand_lv, fp_type);
     if (auto const scale = static_cast<unsigned>(operand_ti.get_scale())) {
       double const divider = shared::power10(scale);
       result_lv = cgen_state_->ir_builder_.CreateFDiv(
           result_lv, llvm::ConstantFP::get(result_lv->getType(), divider));
     }
   } else {
     if (auto const scale = static_cast<unsigned>(operand_ti.get_scale())) {
       double const divider = shared::power10(scale);
       auto const fp_type = ti.get_type() == kFLOAT
                                ? llvm::Type::getFloatTy(cgen_state_->context_)
                                : llvm::Type::getDoubleTy(cgen_state_->context_);
       result_lv = cgen_state_->emitCall("cast_" + numeric_type_name(operand_ti) + "_to_" +
                                             numeric_type_name(ti) + "_scaled_nullable",
                                         {operand_lv,
                                          cgen_state_->inlineIntNull(operand_ti),
                                          cgen_state_->inlineFpNull(ti),
                                          llvm::ConstantFP::get(fp_type, divider)});
     } else {
       result_lv = cgen_state_->emitCall("cast_" + numeric_type_name(operand_ti) + "_to_" +
                                             numeric_type_name(ti) + "_nullable",
                                         {operand_lv,
                                          cgen_state_->inlineIntNull(operand_ti),
                                          cgen_state_->inlineFpNull(ti)});
     }
   }
   CHECK(result_lv);
   return result_lv;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCmp	(	const Analyzer::BinOper *	bin_oper,
		const CompilationOptions &	co
	)

private

Definition at line 230 of file CompareIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, anonymous_namespace{CompareIR.cpp}::check_array_comp_cond(), CHECK_EQ, codegen(), codegenBoundingBoxIntersect(), codegenCmpDecimalConst(), codegenLogical(), codegenStrCmp(), Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_optype(), Analyzer::BinOper::get_own_left_operand(), Analyzer::BinOper::get_own_right_operand(), Analyzer::BinOper::get_qualifier(), Analyzer::BinOper::get_right_operand(), IS_EQUIVALENCE, is_unnest(), kBBOX_INTERSECT, kBW_EQ, kNE, anonymous_namespace{CompareIR.cpp}::lower_bw_eq(), and anonymous_namespace{CompareIR.cpp}::lower_multicol_compare().

Referenced by codegen(), codegenCmpDecimalConst(), and codegenWidthBucketExpr().

                                                                      {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto qualifier = bin_oper->get_qualifier();
   const auto lhs = bin_oper->get_left_operand();
   const auto rhs = bin_oper->get_right_operand();
   if (dynamic_cast<const Analyzer::ExpressionTuple*>(lhs)) {
     CHECK(dynamic_cast<const Analyzer::ExpressionTuple*>(rhs));
     const auto lowered = lower_multicol_compare(bin_oper);
     const auto lowered_lvs = codegen(lowered.get(), true, co);
     CHECK_EQ(size_t(1), lowered_lvs.size());
     return lowered_lvs.front();
   }
   const auto optype = bin_oper->get_optype();
   if (optype == kBW_EQ) {
     const auto bw_eq_oper = lower_bw_eq(bin_oper);
     return codegenLogical(bw_eq_oper.get(), co);
   }
   if (optype == kBBOX_INTERSECT) {
     return codegenBoundingBoxIntersect(optype,
                                        qualifier,
                                        bin_oper->get_own_left_operand(),
                                        bin_oper->get_own_right_operand(),
                                        co);
   }
   if (is_unnest(lhs) || is_unnest(rhs)) {
     throw std::runtime_error("Unnest not supported in comparisons");
   }
   check_array_comp_cond(bin_oper);
   const auto& lhs_ti = lhs->get_type_info();
   const auto& rhs_ti = rhs->get_type_info();
 
   if (lhs_ti.is_string() && rhs_ti.is_string() &&
       !(IS_EQUIVALENCE(optype) || optype == kNE)) {
     auto cmp_str = codegenStrCmp(optype,
                                  qualifier,
                                  bin_oper->get_own_left_operand(),
                                  bin_oper->get_own_right_operand(),
                                  co);
     if (cmp_str) {
       return cmp_str;
     }
   }
 
   if (lhs_ti.is_decimal()) {
     auto cmp_decimal_const =
         codegenCmpDecimalConst(optype, qualifier, lhs, lhs_ti, rhs, co);
     if (cmp_decimal_const) {
       return cmp_decimal_const;
     }
   }
   auto lhs_lvs = codegen(lhs, true, co);
   return codegenCmp(optype, qualifier, lhs_lvs, lhs_ti, rhs, co);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCmp	(	const SQLOps	optype,
		const SQLQualifier	qualifier,
		std::vector< llvm::Value * >	lhs_lvs,
		const SQLTypeInfo &	lhs_ti,
		const Analyzer::Expr *	rhs,
		const CompilationOptions &	co
	)

private

Definition at line 482 of file CompareIR.cpp.

References AUTOMATIC_IR_METADATA, CgenState::castToTypeIn(), cgen_state_, CHECK, CHECK_EQ, codegen(), codegenQualifierCmp(), createStringViewStructType(), CgenState::emitCall(), executor_, SQLTypeInfo::get_compression(), get_null_check_suffix(), SQLTypeInfo::get_type(), Analyzer::Expr::get_type_info(), anonymous_namespace{CompareIR.cpp}::icmp_name(), inline_int_null_val(), CgenState::inlineIntNull(), CgenState::ir_builder_, SQLTypeInfo::is_boolean(), IS_COMPARISON, SQLTypeInfo::is_decimal(), IS_EQUIVALENCE, SQLTypeInfo::is_geometry(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_string(), SQLTypeInfo::is_time(), SQLTypeInfo::is_timeinterval(), kBBOX_INTERSECT, kBOOLEAN, kDOUBLE, kENCODING_DICT, kENCODING_NONE, kFLOAT, kNE, kONE, CgenState::llFp(), CgenState::llInt(), anonymous_namespace{CompareIR.cpp}::llvm_fcmp_pred(), anonymous_namespace{CompareIR.cpp}::llvm_icmp_pred(), NULL_DOUBLE, NULL_FLOAT, numeric_type_name(), anonymous_namespace{CompareIR.cpp}::string_cmp_func(), anonymous_namespace{CompareIR.cpp}::unpack_dict_encoded_string(), and anonymous_namespace{CompareIR.cpp}::unpack_none_encoded_string().

                                                                      {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(IS_COMPARISON(optype));
   const auto& rhs_ti = rhs->get_type_info();
   if (rhs_ti.is_array()) {
     return codegenQualifierCmp(optype, qualifier, lhs_lvs, rhs, co);
   }
   auto rhs_lvs = codegen(rhs, true, co);
   CHECK_EQ(kONE, qualifier);
   if (optype == kBBOX_INTERSECT) {
     CHECK(lhs_ti.is_geometry());
     CHECK(rhs_ti.is_array() ||
           rhs_ti.is_geometry());  // allow geo col or bounds col to pass
   } else {
     CHECK((lhs_ti.get_type() == rhs_ti.get_type()) ||
           (lhs_ti.is_string() && rhs_ti.is_string()));
   }
   const auto null_check_suffix = get_null_check_suffix(lhs_ti, rhs_ti);
   if (lhs_ti.is_integer() || lhs_ti.is_decimal() || lhs_ti.is_time() ||
       lhs_ti.is_boolean() || lhs_ti.is_string() || lhs_ti.is_timeinterval()) {
     if (lhs_ti.is_string()) {
       CHECK(rhs_ti.is_string());
       // we sync two string col's encoding scheme
       // if one of them is dict-encoded before reaching here,
       // i.e., call `codegenCastNonStringToString` or `codegenCastFromString`
       CHECK_EQ(lhs_ti.get_compression(), rhs_ti.get_compression());
       bool unpack_strings = true;
       if (lhs_ti.get_compression() == kENCODING_NONE) {
         unpack_none_encoded_string(cgen_state_, lhs_lvs);
         unpack_none_encoded_string(cgen_state_, rhs_lvs);
       } else if (lhs_ti.get_compression() == kENCODING_DICT) {
         if (IS_EQUIVALENCE(optype) || optype == kNE) {
           // we use `StringDictionaryTranslationMgr` to translate
           // dict-encoded lhs against rhs's string dictionary
           // and then compare their string ids without unpacking strings
           // i.e., call `eq_int32_t_nullable` instead of `string_eq_nullable`
           unpack_strings = false;
         } else {
           auto sv_struct_type_lv = createStringViewStructType();
           unpack_dict_encoded_string(
               cgen_state_, executor_, lhs_ti, sv_struct_type_lv, lhs_lvs);
           unpack_dict_encoded_string(
               cgen_state_, executor_, rhs_ti, sv_struct_type_lv, rhs_lvs);
         }
       }
       if (unpack_strings) {
         // we directly compare two unpacked (i.e., raw) strings
         std::vector<llvm::Value*> str_cmp_args{
             lhs_lvs[1], lhs_lvs[2], rhs_lvs[1], rhs_lvs[2]};
         if (!null_check_suffix.empty()) {
           str_cmp_args.push_back(
               cgen_state_->inlineIntNull(SQLTypeInfo(kBOOLEAN, false)));
         }
         return cgen_state_->emitCall(
             string_cmp_func(optype) + (null_check_suffix.empty() ? "" : "_nullable"),
             str_cmp_args);
       }
     }
 
     if (lhs_ti.is_boolean() && rhs_ti.is_boolean()) {
       auto& lhs_lv = lhs_lvs.front();
       auto& rhs_lv = rhs_lvs.front();
       CHECK(lhs_lv->getType()->isIntegerTy());
       CHECK(rhs_lv->getType()->isIntegerTy());
       if (lhs_lv->getType()->getIntegerBitWidth() <
           rhs_lv->getType()->getIntegerBitWidth()) {
         lhs_lv =
             cgen_state_->castToTypeIn(lhs_lv, rhs_lv->getType()->getIntegerBitWidth());
       } else {
         rhs_lv =
             cgen_state_->castToTypeIn(rhs_lv, lhs_lv->getType()->getIntegerBitWidth());
       }
     }
 
     return null_check_suffix.empty()
                ? cgen_state_->ir_builder_.CreateICmp(
                      llvm_icmp_pred(optype), lhs_lvs.front(), rhs_lvs.front())
                : cgen_state_->emitCall(
                      icmp_name(optype) + "_" + numeric_type_name(lhs_ti) +
                          null_check_suffix,
                      {lhs_lvs.front(),
                       rhs_lvs.front(),
                       cgen_state_->llInt(inline_int_null_val(lhs_ti)),
                       cgen_state_->inlineIntNull(SQLTypeInfo(kBOOLEAN, false))});
   }
   if (lhs_ti.get_type() == kFLOAT || lhs_ti.get_type() == kDOUBLE) {
     return null_check_suffix.empty()
                ? cgen_state_->ir_builder_.CreateFCmp(
                      llvm_fcmp_pred(optype), lhs_lvs.front(), rhs_lvs.front())
                : cgen_state_->emitCall(
                      icmp_name(optype) + "_" + numeric_type_name(lhs_ti) +
                          null_check_suffix,
                      {lhs_lvs.front(),
                       rhs_lvs.front(),
                       lhs_ti.get_type() == kFLOAT ? cgen_state_->llFp(NULL_FLOAT)
                                                   : cgen_state_->llFp(NULL_DOUBLE),
                       cgen_state_->inlineIntNull(SQLTypeInfo(kBOOLEAN, false))});
   }
   CHECK(false);
   return nullptr;
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegenCmpDecimalConst	(	const SQLOps	optype,
		const SQLQualifier	qualifier,
		const Analyzer::Expr *	lhs,
		const SQLTypeInfo &	lhs_ti,
		const Analyzer::Expr *	rhs,
		const CompilationOptions &	co
	)

private

Definition at line 402 of file CompareIR.cpp.

References AUTOMATIC_IR_METADATA, Datum::bigintval, cgen_state_, codegen(), codegenCast(), codegenCmp(), exp_to_scale(), SQLTypeInfo::get_scale(), Analyzer::Expr::get_type_info(), kCAST, kDECIMAL, and sql_constants::kMaxRepresentableNumericPrecision.

Referenced by codegenCmp().

                                                                                  {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto u_oper = dynamic_cast<const Analyzer::UOper*>(lhs);
   if (!u_oper || u_oper->get_optype() != kCAST) {
     return nullptr;
   }
   auto rhs_constant = dynamic_cast<const Analyzer::Constant*>(rhs);
   if (!rhs_constant) {
     return nullptr;
   }
   const auto operand = u_oper->get_operand();
   const auto& operand_ti = operand->get_type_info();
   if (operand_ti.is_decimal() && operand_ti.get_scale() < lhs_ti.get_scale()) {
     // lhs decimal type has smaller scale
   } else if (operand_ti.is_integer() && 0 < lhs_ti.get_scale()) {
     // lhs is integer, no need to scale it all the way up to the cmp expr scale
   } else {
     return nullptr;
   }
 
   auto scale_diff = lhs_ti.get_scale() - operand_ti.get_scale() - 1;
   int64_t bigintval = rhs_constant->get_constval().bigintval;
   bool negative = false;
   if (bigintval < 0) {
     negative = true;
     bigintval = -bigintval;
   }
   int64_t truncated_decimal = bigintval / exp_to_scale(scale_diff);
   int64_t decimal_tail = bigintval % exp_to_scale(scale_diff);
   if (truncated_decimal % 10 == 0 && decimal_tail > 0) {
     truncated_decimal += 1;
   }
   SQLTypeInfo new_ti = SQLTypeInfo(kDECIMAL,
                                    sql_constants::kMaxRepresentableNumericPrecision,
                                    lhs_ti.get_scale() - scale_diff,
                                    operand_ti.get_notnull());
   if (negative) {
     truncated_decimal = -truncated_decimal;
   }
   Datum d;
   d.bigintval = truncated_decimal;
   const auto new_rhs_lit =
       makeExpr<Analyzer::Constant>(new_ti, rhs_constant->get_is_null(), d);
   const auto operand_lv = codegen(operand, true, co).front();
   const auto lhs_lv = codegenCast(operand_lv, operand_ti, new_ti, false, co);
   return codegenCmp(optype, qualifier, {lhs_lv}, new_ti, new_rhs_lit.get(), co);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenColumn	(	const Analyzer::ColumnVar *	col_var,
		const bool	fetch_column,
		const CompilationOptions &	co
	)

privatevirtual

Reimplemented in ScalarCodeGenerator.

Definition at line 94 of file ColumnIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, codegenColVar(), codegenOuterJoinNullPlaceholder(), foundOuterJoinMatch(), Analyzer::ColumnVar::get_rte_idx(), and CgenState::outer_join_match_found_per_level_.

Referenced by codegen().

                                                                                      {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (col_var->get_rte_idx() <= 0 ||
       cgen_state_->outer_join_match_found_per_level_.empty() ||
       !foundOuterJoinMatch(col_var->get_rte_idx())) {
     return codegenColVar(col_var, fetch_column, true, co);
   }
   return codegenOuterJoinNullPlaceholder(col_var, fetch_column, co);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenColVar	(	const Analyzer::ColumnVar *	col_var,
		const bool	fetch_column,
		const bool	update_query_plan,
		const CompilationOptions &	co
	)

private

Definition at line 106 of file ColumnIR.cpp.

References PlanState::addColumnToFetch(), PlanState::addColumnToNotFetch(), anonymous_namespace{ColumnIR.cpp}::adjusted_range_table_index(), AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_LT, codegen(), codegenFixedLengthColVar(), codegenFixedLengthColVarInWindow(), codegenRowId(), codegenVariableLengthStringColVar(), codegenWindowPosition(), colByteStream(), executor(), CgenState::fetch_cache_, CgenState::frag_offsets_, get_column_descriptor(), Analyzer::Expr::get_type_info(), WindowProjectNodeContext::getActiveWindowFunctionContext(), Analyzer::ColumnVar::getColumnKey(), hash_value(), hashJoinLhs(), CompilationOptions::hoist_literals, CgenState::ir_builder_, PlanState::isColumnToFetch(), PlanState::isLazyFetchColumn(), kENCODING_NONE, kPOINT, plan_state_, posArg(), resolveGroupedColumnReference(), and Analyzer::ColumnVar::toString().

Referenced by codegenColumn(), and codegenOuterJoinNullPlaceholder().

                                                                                      {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const bool hoist_literals = co.hoist_literals;
   const int rte_idx = adjusted_range_table_index(col_var);
   CHECK_LT(static_cast<size_t>(rte_idx), cgen_state_->frag_offsets_.size());
   const auto& column_key = col_var->getColumnKey();
   if (column_key.table_id > 0) {
     const auto cd = get_column_descriptor(column_key);
     if (cd->isVirtualCol) {
       CHECK(cd->columnName == "rowid");
       return {codegenRowId(col_var, co)};
     }
     const auto col_ti = cd->columnType;
     if (col_ti.usesFlatBuffer()) {
       throw std::runtime_error(
           "Flatbuffer storage in a real table column not supported yet");
     }
     if (col_ti.get_physical_coord_cols() > 0) {
       std::vector<llvm::Value*> cols;
       const auto col_id = column_key.column_id;
       auto temp_column_key = column_key;
       bool fetch_physical_columns = fetch_column;
       for (auto i = 0; i < col_ti.get_physical_coord_cols(); i++) {
         temp_column_key.column_id = col_id + i + 1;
         const auto cd0 = get_column_descriptor(temp_column_key);
         CHECK(cd0);
         const auto col0_ti = cd0->columnType;
         CHECK(!cd0->isVirtualCol);
         const auto col0_var =
             makeExpr<Analyzer::ColumnVar>(col0_ti, temp_column_key, rte_idx);
         if (plan_state_->isColumnToFetch(temp_column_key)) {
           // sync the fetch status for all physical columns
           fetch_physical_columns = true;
         }
         const auto col = codegenColVar(col0_var.get(), fetch_physical_columns, false, co);
         cols.insert(cols.end(), col.begin(), col.end());
         if (!fetch_physical_columns && plan_state_->isLazyFetchColumn(col_var)) {
           plan_state_->addColumnToNotFetch(temp_column_key);
         }
       }
       if (!fetch_physical_columns && plan_state_->isLazyFetchColumn(col_var)) {
         plan_state_->addColumnToNotFetch(column_key);
       } else {
         plan_state_->addColumnToFetch(column_key);
       }
       return cols;
     }
   }
   const auto grouped_col_lv = resolveGroupedColumnReference(col_var);
   if (grouped_col_lv) {
     return {grouped_col_lv};
   }
   const auto col_var_hash = boost::hash_value(col_var->toString());
   const auto window_func_context =
       WindowProjectNodeContext::getActiveWindowFunctionContext(executor());
   // only generate the decoding code once; if a column has been previously
   // fetched in the generated IR, we'll reuse it
   // here, we do not just use (local) column id since our analyzer may cast the same
   // col_var with different types depending on the (aggregate) function that the col_var
   // is used i.e., SELECT COUNT(DISTINCT x), MIN(x) FROM ...
   if (!window_func_context) {
     auto it = cgen_state_->fetch_cache_.find(col_var_hash);
     if (it != cgen_state_->fetch_cache_.end()) {
       return {it->second};
     }
   }
   const auto hash_join_lhs = hashJoinLhs(col_var);
   // Note(jclay): This has been prone to cause failures in some bounding box intersection.
   // I believe most of the issues are worked out now, but a good place to check if
   // failures are happening.
 
   // Use the already fetched left-hand side of an equi-join if the types are identical.
   // Currently, types can only be different because of different underlying dictionaries.
   if (hash_join_lhs && hash_join_lhs->get_type_info() == col_var->get_type_info()) {
     if (plan_state_->isLazyFetchColumn(col_var)) {
       plan_state_->addColumnToFetch(col_var->getColumnKey(), true);
     }
     return codegen(hash_join_lhs.get(), fetch_column, co);
   }
   auto pos_arg = posArg(col_var);
   if (window_func_context) {
     pos_arg = codegenWindowPosition(window_func_context, pos_arg);
   }
   auto col_byte_stream = colByteStream(col_var, fetch_column, hoist_literals);
   if (plan_state_->isLazyFetchColumn(col_var)) {
     if (update_query_plan) {
       plan_state_->addColumnToNotFetch(col_var->getColumnKey());
     }
     if (rte_idx > 0) {
       const auto offset = cgen_state_->frag_offsets_[rte_idx];
       if (offset) {
         return {cgen_state_->ir_builder_.CreateAdd(pos_arg, offset)};
       } else {
         return {pos_arg};
       }
     }
     return {pos_arg};
   }
   const auto& col_ti = col_var->get_type_info();
   if (col_ti.is_string() && col_ti.get_compression() == kENCODING_NONE) {
     const auto varlen_str_column_lvs =
         codegenVariableLengthStringColVar(col_byte_stream, pos_arg);
     if (!window_func_context) {
       auto it_ok = cgen_state_->fetch_cache_.insert(
           std::make_pair(col_var_hash, varlen_str_column_lvs));
       CHECK(it_ok.second);
     }
     return varlen_str_column_lvs;
   }
   if (col_ti.usesFlatBuffer()) {
     return {col_byte_stream};
   }
   if (col_ti.is_array() || col_ti.get_type() == kPOINT) {
     return {col_byte_stream};
   }
   if (window_func_context) {
     return {codegenFixedLengthColVarInWindow(
         col_var, col_byte_stream, pos_arg, co, window_func_context)};
   }
   const auto fixed_length_column_lv =
       codegenFixedLengthColVar(col_var, col_byte_stream, pos_arg);
   auto it_ok = cgen_state_->fetch_cache_.insert(
       std::make_pair(col_var_hash, std::vector<llvm::Value*>{fixed_length_column_lv}));
   return {it_ok.first->second};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCompression ( const SQLTypeInfo & type_info )

private

Definition at line 675 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), kENCODING_GEOINT, and CgenState::llInt().

Referenced by codegenFunctionOperCastArgs().

                                                                          {
   AUTOMATIC_IR_METADATA(cgen_state_);
   int32_t compression = (type_info.get_compression() == kENCODING_GEOINT &&
                          type_info.get_comp_param() == 32)
                             ? 1
                             : 0;
 
   return cgen_state_->llInt(compression);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenConstantWidthBucketExpr	(	const Analyzer::WidthBucketExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 364 of file IRCodegen.cpp.

References Analyzer::WidthBucketExpr::can_skip_out_of_bound_check(), cgen_state_, CHECK_EQ, codegen(), Datum::doubleval, CgenState::emitCall(), Analyzer::WidthBucketExpr::get_bound_val(), Analyzer::WidthBucketExpr::get_lower_bound(), Analyzer::WidthBucketExpr::get_partition_count(), Analyzer::WidthBucketExpr::get_partition_count_val(), Analyzer::WidthBucketExpr::get_target_value(), Analyzer::WidthBucketExpr::get_upper_bound(), inline_fp_null_val(), inline_int_null_val(), kDOUBLE, and NULL_DOUBLE.

Referenced by codegen().

                                   {
   auto target_value_expr = expr->get_target_value();
   auto lower_bound_expr = expr->get_lower_bound();
   auto upper_bound_expr = expr->get_upper_bound();
   auto partition_count_expr = expr->get_partition_count();
 
   auto num_partitions = expr->get_partition_count_val();
   if (num_partitions < 1 || num_partitions > INT32_MAX) {
     throw std::runtime_error(
         "PARTITION_COUNT expression of width_bucket function should be in a valid "
         "range: 0 < PARTITION_COUNT <= 2147483647");
   }
   double lower = expr->get_bound_val(lower_bound_expr);
   double upper = expr->get_bound_val(upper_bound_expr);
   if (lower == upper) {
     throw std::runtime_error(
         "LOWER_BOUND and UPPER_BOUND expressions of width_bucket function cannot have "
         "the same constant value");
   }
   if (lower == NULL_DOUBLE || upper == NULL_DOUBLE) {
     throw std::runtime_error(
         "Both LOWER_BOUND and UPPER_BOUND of width_bucket function should be finite "
         "numeric constants.");
   }
 
   bool const reversed = lower > upper;
   double const scale_factor = num_partitions / (reversed ? lower - upper : upper - lower);
   std::string func_name = reversed ? "width_bucket_reversed" : "width_bucket";
 
   auto get_double_constant_lvs = [this, &co](double const_val) {
     Datum d;
     d.doubleval = const_val;
     auto double_const_expr =
         makeExpr<Analyzer::Constant>(SQLTypeInfo(kDOUBLE, false), false, d);
     return codegen(double_const_expr.get(), false, co);
   };
 
   auto target_value_ti = target_value_expr->get_type_info();
   auto target_value_expr_lvs = codegen(target_value_expr, true, co);
   CHECK_EQ(size_t(1), target_value_expr_lvs.size());
   auto lower_expr_lvs = codegen(lower_bound_expr, true, co);
   CHECK_EQ(size_t(1), lower_expr_lvs.size());
   auto scale_factor_lvs = get_double_constant_lvs(scale_factor);
   CHECK_EQ(size_t(1), scale_factor_lvs.size());
 
   std::vector<llvm::Value*> width_bucket_args{target_value_expr_lvs[0],
                                               lower_expr_lvs[0]};
   if (expr->can_skip_out_of_bound_check()) {
     func_name += "_no_oob_check";
     width_bucket_args.push_back(scale_factor_lvs[0]);
   } else {
     auto upper_expr_lvs = codegen(upper_bound_expr, true, co);
     CHECK_EQ(size_t(1), upper_expr_lvs.size());
     auto partition_count_expr_lvs = codegen(partition_count_expr, true, co);
     CHECK_EQ(size_t(1), partition_count_expr_lvs.size());
     width_bucket_args.push_back(upper_expr_lvs[0]);
     width_bucket_args.push_back(scale_factor_lvs[0]);
     width_bucket_args.push_back(partition_count_expr_lvs[0]);
     if (!target_value_ti.get_notnull()) {
       func_name += "_nullable";
       auto translated_null_value = target_value_ti.is_fp()
                                        ? inline_fp_null_val(target_value_ti)
                                        : inline_int_null_val(target_value_ti);
       auto null_value_lvs = get_double_constant_lvs(translated_null_value);
       CHECK_EQ(size_t(1), null_value_lvs.size());
       width_bucket_args.push_back(null_value_lvs[0]);
     }
   }
   return cgen_state_->emitCall(func_name, width_bucket_args);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenDateTruncHighPrecisionTimestamps	(	llvm::Value *	ts_lv,
		const SQLTypeInfo &	ti,
		const DatetruncField &	field
	)

private

Definition at line 304 of file DateTimeIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CgenState::context_, datetrunc_fname_lookup, dtMICROSECOND, dtMILLISECOND, dtNANOSECOND, dtSECOND, CgenState::emitCall(), CgenState::emitExternalCall(), executor(), SQLTypeInfo::get_dimension(), get_int_type(), SQLTypeInfo::get_notnull(), CgenState::inlineIntNull(), CgenState::ir_builder_, SQLTypeInfo::is_high_precision_timestamp(), and CgenState::llInt().

Referenced by codegen().

                                  {
   // Only needed for i in { 0, 3, 6, 9 }.
   constexpr int64_t pow10[10]{1, 0, 0, 1000, 0, 0, 1000000, 0, 0, 1000000000};
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(ti.is_high_precision_timestamp());
   CHECK(ts_lv->getType()->isIntegerTy(64));
   bool const is_nullable = !ti.get_notnull();
   static_assert(dtSECOND + 1 == dtMILLISECOND, "Please keep these consecutive.");
   static_assert(dtMILLISECOND + 1 == dtMICROSECOND, "Please keep these consecutive.");
   static_assert(dtMICROSECOND + 1 == dtNANOSECOND, "Please keep these consecutive.");
   if (dtSECOND <= field && field <= dtNANOSECOND) {
     unsigned const start_dim = ti.get_dimension();      // 0, 3, 6, 9
     unsigned const trunc_dim = (field - dtSECOND) * 3;  // 0, 3, 6, 9
     if (start_dim <= trunc_dim) {
       return ts_lv;  // Truncating to an equal or higher precision has no effect.
     }
     int64_t const dscale = pow10[start_dim - trunc_dim];  // 1e3, 1e6, 1e9
     if (is_nullable) {
       ts_lv = cgen_state_->emitCall(
           "floor_div_nullable_lhs",
           {ts_lv, cgen_state_->llInt(dscale), cgen_state_->inlineIntNull(ti)});
       return cgen_state_->emitCall(
           "mul_int64_t_nullable_lhs",
           {ts_lv, cgen_state_->llInt(dscale), cgen_state_->inlineIntNull(ti)});
     } else {
       ts_lv = cgen_state_->ir_builder_.CreateSDiv(ts_lv, cgen_state_->llInt(dscale));
       return cgen_state_->ir_builder_.CreateMul(ts_lv, cgen_state_->llInt(dscale));
     }
   }
   int64_t const scale = pow10[ti.get_dimension()];
   ts_lv = is_nullable
               ? cgen_state_->emitCall(
                     "floor_div_nullable_lhs",
                     {ts_lv, cgen_state_->llInt(scale), cgen_state_->inlineIntNull(ti)})
               : cgen_state_->ir_builder_.CreateSDiv(ts_lv, cgen_state_->llInt(scale));
 
   std::unique_ptr<CodeGenerator::NullCheckCodegen> nullcheck_codegen;
   if (is_nullable) {
     nullcheck_codegen = std::make_unique<NullCheckCodegen>(
         cgen_state_, executor(), ts_lv, ti, "date_trunc_hp_nullcheck");
   }
   char const* const fname = datetrunc_fname_lookup.at(field);
   ts_lv = cgen_state_->emitExternalCall(
       fname, get_int_type(64, cgen_state_->context_), {ts_lv});
   if (is_nullable) {
     ts_lv =
         nullcheck_codegen->finalize(ll_int(NULL_BIGINT, cgen_state_->context_), ts_lv);
   }
 
   return is_nullable
              ? cgen_state_->emitCall(
                    "mul_int64_t_nullable_lhs",
                    {ts_lv, cgen_state_->llInt(scale), cgen_state_->inlineIntNull(ti)})
              : cgen_state_->ir_builder_.CreateMul(ts_lv, cgen_state_->llInt(scale));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenDeciDiv	(	const Analyzer::BinOper *	bin_oper,
		const CompilationOptions &	co
	)

private

Definition at line 546 of file ArithmeticIR.cpp.

References Parser::IntLiteral::analyzeValue(), AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegen(), codegenCastBetweenIntTypes(), codegenDiv(), codegenIntConst(), exp_to_scale(), Analyzer::BinOper::get_left_operand(), get_null_check_suffix(), Analyzer::BinOper::get_right_operand(), Analyzer::Expr::get_type_info(), kCAST, and anonymous_namespace{ArithmeticIR.cpp}::numeric_or_time_interval_type_name().

Referenced by codegenArith().

                                                                          {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto lhs = bin_oper->get_left_operand();
   auto rhs = bin_oper->get_right_operand();
   const auto& lhs_type = lhs->get_type_info();
   const auto& rhs_type = rhs->get_type_info();
   CHECK(lhs_type.is_decimal() && rhs_type.is_decimal() &&
         lhs_type.get_scale() == rhs_type.get_scale());
 
   auto rhs_constant = dynamic_cast<const Analyzer::Constant*>(rhs);
   auto rhs_cast = dynamic_cast<const Analyzer::UOper*>(rhs);
   if (rhs_constant && !rhs_constant->get_is_null() &&
       rhs_constant->get_constval().bigintval != 0LL &&
       (rhs_constant->get_constval().bigintval % exp_to_scale(rhs_type.get_scale())) ==
           0LL) {
     // can safely downscale a scaled constant
   } else if (rhs_cast && rhs_cast->get_optype() == kCAST &&
              rhs_cast->get_operand()->get_type_info().is_integer()) {
     // can skip upscale in the int to dec cast
   } else {
     return nullptr;
   }
 
   auto lhs_lv = codegen(lhs, true, co).front();
   llvm::Value* rhs_lv{nullptr};
   if (rhs_constant) {
     const auto rhs_lit = Parser::IntLiteral::analyzeValue(
         rhs_constant->get_constval().bigintval / exp_to_scale(rhs_type.get_scale()));
     auto rhs_lit_lv = CodeGenerator::codegenIntConst(
         dynamic_cast<const Analyzer::Constant*>(rhs_lit.get()), cgen_state_);
     rhs_lv = codegenCastBetweenIntTypes(
         rhs_lit_lv, rhs_lit->get_type_info(), lhs_type, /*upscale*/ false);
   } else if (rhs_cast) {
     auto rhs_cast_oper = rhs_cast->get_operand();
     const auto& rhs_cast_oper_ti = rhs_cast_oper->get_type_info();
     auto rhs_cast_oper_lv = codegen(rhs_cast_oper, true, co).front();
     rhs_lv = codegenCastBetweenIntTypes(
         rhs_cast_oper_lv, rhs_cast_oper_ti, lhs_type, /*upscale*/ false);
   } else {
     CHECK(false);
   }
   const auto int_typename = numeric_or_time_interval_type_name(lhs_type, rhs_type);
   const auto null_check_suffix = get_null_check_suffix(lhs_type, rhs_type);
   return codegenDiv(lhs_lv,
                     rhs_lv,
                     null_check_suffix.empty() ? "" : int_typename,
                     null_check_suffix,
                     lhs_type,
                     /*upscale*/ false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenDictLike	(	const std::shared_ptr< Analyzer::Expr >	arg,
		const Analyzer::Constant *	pattern,
		const bool	ilike,
		const bool	is_simple,
		const char	escape_char,
		const CompilationOptions &	co
	)

private

Definition at line 671 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), executor(), Analyzer::Constant::get_constval(), Analyzer::Expr::get_type_info(), kCAST, kENCODING_DICT, kENCODING_NONE, pre_translate_string_ops(), Datum::stringval, timer_start(), timer_stop(), and VLOG.

Referenced by codegen().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto cast_oper = std::dynamic_pointer_cast<Analyzer::UOper>(like_arg);
   if (!cast_oper) {
     return nullptr;
   }
   CHECK(cast_oper);
   CHECK_EQ(kCAST, cast_oper->get_optype());
   const auto dict_like_arg = cast_oper->get_own_operand();
   const auto& dict_like_arg_ti = dict_like_arg->get_type_info();
   if (!dict_like_arg_ti.is_string()) {
     throw(std::runtime_error("Cast from " + dict_like_arg_ti.get_type_name() + " to " +
                              cast_oper->get_type_info().get_type_name() +
                              " not supported"));
   }
   CHECK_EQ(kENCODING_DICT, dict_like_arg_ti.get_compression());
   const auto sdp = executor()->getStringDictionaryProxy(
       dict_like_arg_ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true);
   if (sdp->storageEntryCount() > 200000000) {
     return nullptr;
   }
   if (sdp->getDictKey().isTransientDict()) {
     // If we have a literal dictionary it was a product
     // of string ops applied to none-encoded strings, and
     // will not be populated at codegen-time, so we
     // cannot use the fast path
 
     // Todo(todd): Once string ops support non-string producting
     // operators (like like/ilike), like/ilike can be chained and
     // we can avoid the string translation
     return nullptr;
   }
   const auto string_oper = dynamic_cast<const Analyzer::StringOper*>(dict_like_arg.get());
   if (string_oper) {
     pre_translate_string_ops(string_oper, executor());
   }
   const auto& pattern_ti = pattern->get_type_info();
   CHECK(pattern_ti.is_string());
   CHECK_EQ(kENCODING_NONE, pattern_ti.get_compression());
   const auto& pattern_datum = pattern->get_constval();
   const auto& pattern_str = *pattern_datum.stringval;
   auto work_timer = timer_start();
   const auto matching_ids =
       sdp->getLike<int64_t>(pattern_str, ilike, is_simple, escape_char);
   auto const work_ms = timer_stop(work_timer);
   VLOG(3) << "Processing like operator with the pattern " << pattern_str << " took "
           << work_ms << " ms (# matching elems: " << matching_ids.size() << ")";
   const auto in_values = std::make_shared<Analyzer::InIntegerSet>(
       dict_like_arg, matching_ids, dict_like_arg_ti.get_notnull());
   return codegen(in_values.get(), co);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenDictRegexp	(	const std::shared_ptr< Analyzer::Expr >	arg,
		const Analyzer::Constant *	pattern,
		const char	escape_char,
		const CompilationOptions &	co
	)

private

Definition at line 903 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), gpu_enabled::copy(), executor(), Analyzer::Constant::get_constval(), Analyzer::Expr::get_type_info(), kCAST, kENCODING_DICT, kENCODING_NONE, pre_translate_string_ops(), and Datum::stringval.

Referenced by codegen().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto cast_oper = std::dynamic_pointer_cast<Analyzer::UOper>(pattern_arg);
   if (!cast_oper) {
     return nullptr;
   }
   CHECK(cast_oper);
   CHECK_EQ(kCAST, cast_oper->get_optype());
   const auto dict_regexp_arg = cast_oper->get_own_operand();
   const auto& dict_regexp_arg_ti = dict_regexp_arg->get_type_info();
   CHECK(dict_regexp_arg_ti.is_string());
   CHECK_EQ(kENCODING_DICT, dict_regexp_arg_ti.get_compression());
   const auto& dict_key = dict_regexp_arg_ti.getStringDictKey();
   const auto sdp = executor()->getStringDictionaryProxy(
       dict_key, executor()->getRowSetMemoryOwner(), true);
   if (sdp->storageEntryCount() > 15000000) {
     return nullptr;
   }
   if (sdp->getDictKey().isTransientDict()) {
     // If we have a literal dictionary it was a product
     // of string ops applied to none-encoded strings, and
     // will not be populated at codegen-time, so we
     // cannot use the fast path
 
     // Todo(todd): Once string ops support non-string producting
     // operators (like regexp_like), these operators can be chained
     // and we can avoid the string translation
     return nullptr;
   }
   const auto string_oper =
       dynamic_cast<const Analyzer::StringOper*>(dict_regexp_arg.get());
   if (string_oper) {
     pre_translate_string_ops(string_oper, executor());
   }
   const auto& pattern_ti = pattern->get_type_info();
   CHECK(pattern_ti.is_string());
   CHECK_EQ(kENCODING_NONE, pattern_ti.get_compression());
   const auto& pattern_datum = pattern->get_constval();
   const auto& pattern_str = *pattern_datum.stringval;
   const auto matching_ids = sdp->getRegexpLike(pattern_str, escape_char);
   // InIntegerSet requires 64-bit values
   std::vector<int64_t> matching_ids_64(matching_ids.size());
   std::copy(matching_ids.begin(), matching_ids.end(), matching_ids_64.begin());
   const auto in_values = std::make_shared<Analyzer::InIntegerSet>(
       dict_regexp_arg, matching_ids_64, dict_regexp_arg_ti.get_notnull());
   return codegen(in_values.get(), co);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenDictStrCmp	(	const std::shared_ptr< Analyzer::Expr >	lhs,
		const std::shared_ptr< Analyzer::Expr >	rhs,
		const SQLOps	compare_operator,
		const CompilationOptions &	co
	)

private

Definition at line 762 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), gpu_enabled::copy(), executor(), anonymous_namespace{StringOpsIR.cpp}::get_compared_ids(), Analyzer::Constant::get_constval(), kCAST, kENCODING_DICT, kEQ, kGE, kGT, kLE, kLT, and kNE.

Referenced by codegenStrCmp().

                                                                             {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto rhs_cast_oper = std::dynamic_pointer_cast<const Analyzer::UOper>(rhs);
   auto lhs_cast_oper = std::dynamic_pointer_cast<const Analyzer::UOper>(lhs);
   auto rhs_col_var = std::dynamic_pointer_cast<const Analyzer::ColumnVar>(rhs);
   auto lhs_col_var = std::dynamic_pointer_cast<const Analyzer::ColumnVar>(lhs);
   std::shared_ptr<const Analyzer::UOper> cast_oper;
   std::shared_ptr<const Analyzer::ColumnVar> col_var;
   auto compare_opr = compare_operator;
   if (lhs_col_var && rhs_col_var) {
     if (lhs_col_var->get_type_info().getStringDictKey() ==
         rhs_col_var->get_type_info().getStringDictKey()) {
       if (compare_operator == kEQ || compare_operator == kNE) {
         // TODO (vraj): implement compare between two dictionary encoded columns which
         // share a dictionary
         return nullptr;
       }
     }
     // TODO (vraj): implement compare between two dictionary encoded columns which don't
     // shared dictionary
     throw std::runtime_error("Decoding two Dictionary encoded columns will be slow");
   } else if (lhs_col_var && rhs_cast_oper) {
     cast_oper.swap(rhs_cast_oper);
     col_var.swap(lhs_col_var);
   } else if (lhs_cast_oper && rhs_col_var) {
     cast_oper.swap(lhs_cast_oper);
     col_var.swap(rhs_col_var);
     switch (compare_operator) {
       case kLT:
         compare_opr = kGT;
         break;
       case kLE:
         compare_opr = kGE;
         break;
       case kGT:
         compare_opr = kLT;
         break;
       case kGE:
         compare_opr = kLE;
       default:
         break;
     }
   }
   if (!cast_oper || !col_var) {
     return nullptr;
   }
   CHECK_EQ(kCAST, cast_oper->get_optype());
 
   const auto const_expr =
       dynamic_cast<Analyzer::Constant*>(cast_oper->get_own_operand().get());
   if (!const_expr) {
     // Analyzer casts dictionary encoded columns to none encoded if there is a comparison
     // between two encoded columns. Which we currently do not handle.
     return nullptr;
   }
   const auto& const_val = const_expr->get_constval();
 
   const auto col_ti = col_var->get_type_info();
   CHECK(col_ti.is_string());
   CHECK_EQ(kENCODING_DICT, col_ti.get_compression());
   const auto sdp = executor()->getStringDictionaryProxy(
       col_ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true);
 
   if (sdp->storageEntryCount() > 200000000) {
     std::runtime_error("Cardinality for string dictionary is too high");
     return nullptr;
   }
 
   const auto& pattern_str = *const_val.stringval;
   const auto matching_ids = get_compared_ids(sdp, compare_opr, pattern_str);
 
   // InIntegerSet requires 64-bit values
   std::vector<int64_t> matching_ids_64(matching_ids.size());
   std::copy(matching_ids.begin(), matching_ids.end(), matching_ids_64.begin());
 
   const auto in_values = std::make_shared<Analyzer::InIntegerSet>(
       col_var, matching_ids_64, col_ti.get_notnull());
   return codegen(in_values.get(), co);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenDiv	(	llvm::Value *	lhs_lv,
		llvm::Value *	rhs_lv,
		const std::string &	null_typename,
		const std::string &	null_check_suffix,
		const SQLTypeInfo &	ti,
		bool	upscale = `true`
	)

private

Definition at line 433 of file ArithmeticIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegenSkipOverflowCheckForNull(), CgenState::context_, CgenState::current_func_, CgenState::emitCall(), exp_to_scale(), g_null_div_by_zero, get_int_type(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_type(), inline_int_null_val(), CgenState::inlineIntMaxMin(), CgenState::inlineIntNull(), CgenState::ir_builder_, SQLTypeInfo::is_decimal(), SQLTypeInfo::is_fp(), kBOOLEAN, kFLOAT, CgenState::llFp(), CgenState::llInt(), CgenState::needs_error_check_, NULL_DOUBLE, NULL_FLOAT, numeric_type_name(), and toBool().

Referenced by codegenDeciDiv(), codegenFpArith(), and codegenIntArith().

                                                      {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK_EQ(lhs_lv->getType(), rhs_lv->getType());
   if (ti.is_decimal()) {
     if (upscale) {
       CHECK(lhs_lv->getType()->isIntegerTy());
       const auto scale_lv =
           llvm::ConstantInt::get(lhs_lv->getType(), exp_to_scale(ti.get_scale()));
 
       lhs_lv = cgen_state_->ir_builder_.CreateSExt(
           lhs_lv, get_int_type(64, cgen_state_->context_));
       llvm::Value* chosen_max{nullptr};
       llvm::Value* chosen_min{nullptr};
       std::tie(chosen_max, chosen_min) = cgen_state_->inlineIntMaxMin(8, true);
       auto decimal_div_ok = llvm::BasicBlock::Create(
           cgen_state_->context_, "decimal_div_ok", cgen_state_->current_func_);
       if (!null_check_suffix.empty()) {
         codegenSkipOverflowCheckForNull(lhs_lv, rhs_lv, decimal_div_ok, ti);
       }
       auto decimal_div_fail = llvm::BasicBlock::Create(
           cgen_state_->context_, "decimal_div_fail", cgen_state_->current_func_);
       auto lhs_max = static_cast<llvm::ConstantInt*>(chosen_max)->getSExtValue() /
                      exp_to_scale(ti.get_scale());
       auto lhs_max_lv =
           llvm::ConstantInt::get(get_int_type(64, cgen_state_->context_), lhs_max);
       llvm::Value* detected{nullptr};
       if (ti.get_notnull()) {
         detected = cgen_state_->ir_builder_.CreateICmpSGT(lhs_lv, lhs_max_lv);
       } else {
         detected = toBool(cgen_state_->emitCall(
             "gt_" + numeric_type_name(ti) + "_nullable",
             {lhs_lv,
              lhs_max_lv,
              cgen_state_->llInt(inline_int_null_val(ti)),
              cgen_state_->inlineIntNull(SQLTypeInfo(kBOOLEAN, false))}));
       }
       cgen_state_->ir_builder_.CreateCondBr(detected, decimal_div_fail, decimal_div_ok);
 
       cgen_state_->ir_builder_.SetInsertPoint(decimal_div_fail);
       cgen_state_->ir_builder_.CreateRet(
           cgen_state_->llInt(int32_t(ErrorCode::OVERFLOW_OR_UNDERFLOW)));
 
       cgen_state_->ir_builder_.SetInsertPoint(decimal_div_ok);
 
       lhs_lv = null_typename.empty()
                    ? cgen_state_->ir_builder_.CreateMul(lhs_lv, scale_lv)
                    : cgen_state_->emitCall(
                          "mul_" + numeric_type_name(ti) + null_check_suffix,
                          {lhs_lv, scale_lv, cgen_state_->llInt(inline_int_null_val(ti))});
     }
   }
   if (g_null_div_by_zero) {
     llvm::Value* null_lv{nullptr};
     if (ti.is_fp()) {
       null_lv = ti.get_type() == kFLOAT ? cgen_state_->llFp(NULL_FLOAT)
                                         : cgen_state_->llFp(NULL_DOUBLE);
     } else {
       null_lv = cgen_state_->llInt(inline_int_null_val(ti));
     }
     return cgen_state_->emitCall("safe_div_" + numeric_type_name(ti),
                                  {lhs_lv, rhs_lv, null_lv});
   }
   cgen_state_->needs_error_check_ = true;
   auto div_ok = llvm::BasicBlock::Create(
       cgen_state_->context_, "div_ok", cgen_state_->current_func_);
   if (!null_check_suffix.empty()) {
     codegenSkipOverflowCheckForNull(lhs_lv, rhs_lv, div_ok, ti);
   }
   auto div_zero = llvm::BasicBlock::Create(
       cgen_state_->context_, "div_zero", cgen_state_->current_func_);
   auto zero_const = rhs_lv->getType()->isIntegerTy()
                         ? llvm::ConstantInt::get(rhs_lv->getType(), 0, true)
                         : llvm::ConstantFP::get(rhs_lv->getType(), 0.);
   cgen_state_->ir_builder_.CreateCondBr(
       zero_const->getType()->isFloatingPointTy()
           ? cgen_state_->ir_builder_.CreateFCmp(
                 llvm::FCmpInst::FCMP_ONE, rhs_lv, zero_const)
           : cgen_state_->ir_builder_.CreateICmp(
                 llvm::ICmpInst::ICMP_NE, rhs_lv, zero_const),
       div_ok,
       div_zero);
   cgen_state_->ir_builder_.SetInsertPoint(div_ok);
   auto ret =
       zero_const->getType()->isIntegerTy()
           ? (null_typename.empty()
                  ? cgen_state_->ir_builder_.CreateSDiv(lhs_lv, rhs_lv)
                  : cgen_state_->emitCall(
                        "div_" + null_typename + null_check_suffix,
                        {lhs_lv, rhs_lv, cgen_state_->llInt(inline_int_null_val(ti))}))
           : (null_typename.empty()
                  ? cgen_state_->ir_builder_.CreateFDiv(lhs_lv, rhs_lv)
                  : cgen_state_->emitCall(
                        "div_" + null_typename + null_check_suffix,
                        {lhs_lv,
                         rhs_lv,
                         ti.get_type() == kFLOAT ? cgen_state_->llFp(NULL_FLOAT)
                                                 : cgen_state_->llFp(NULL_DOUBLE)}));
   cgen_state_->ir_builder_.SetInsertPoint(div_zero);
   cgen_state_->ir_builder_.CreateRet(cgen_state_->llInt(int32_t(ErrorCode::DIV_BY_ZERO)));
   cgen_state_->ir_builder_.SetInsertPoint(div_ok);
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenExtractHighPrecisionTimestamps	(	llvm::Value *	ts_lv,
		const SQLTypeInfo &	ti,
		const ExtractField &	field
	)

private

Definition at line 260 of file DateTimeIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CgenState::emitCall(), SQLTypeInfo::get_dimension(), DateTimeUtils::get_extract_high_precision_adjusted_scale(), SQLTypeInfo::get_notnull(), CgenState::inlineIntNull(), CgenState::ir_builder_, SQLTypeInfo::is_high_precision_timestamp(), DateTimeUtils::is_subsecond_extract_field(), kDIVIDE, kMULTIPLY, CgenState::llInt(), and run_benchmark_import::result.

                                {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(ti.is_high_precision_timestamp());
   CHECK(ts_lv->getType()->isIntegerTy(64));
   if (is_subsecond_extract_field(field)) {
     const auto result =
         get_extract_high_precision_adjusted_scale(field, ti.get_dimension());
     if (result.first == kMULTIPLY) {
       return ti.get_notnull()
                  ? cgen_state_->ir_builder_.CreateMul(
                        ts_lv, cgen_state_->llInt(static_cast<int64_t>(result.second)))
                  : cgen_state_->emitCall(
                        "mul_int64_t_nullable_lhs",
                        {ts_lv,
                         cgen_state_->llInt(static_cast<int64_t>(result.second)),
                         cgen_state_->inlineIntNull(ti)});
     } else if (result.first == kDIVIDE) {
       return ti.get_notnull()
                  ? cgen_state_->ir_builder_.CreateSDiv(
                        ts_lv, cgen_state_->llInt(static_cast<int64_t>(result.second)))
                  : cgen_state_->emitCall(
                        "floor_div_nullable_lhs",
                        {ts_lv,
                         cgen_state_->llInt(static_cast<int64_t>(result.second)),
                         cgen_state_->inlineIntNull(ti)});
     } else {
       return ts_lv;
     }
   }
   return ti.get_notnull()
              ? cgen_state_->ir_builder_.CreateSDiv(
                    ts_lv,
                    cgen_state_->llInt(static_cast<int64_t>(
                        get_timestamp_precision_scale(ti.get_dimension()))))
              : cgen_state_->emitCall(
                    "floor_div_nullable_lhs",
                    {ts_lv,
                     cgen_state_->llInt(get_timestamp_precision_scale(ti.get_dimension())),
                     cgen_state_->inlineIntNull(ti)});
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegenFixedLengthColVar	(	const Analyzer::ColumnVar *	col_var,
		llvm::Value *	col_byte_stream,
		llvm::Value *	pos_arg,
		const WindowFunctionContext *	window_function_context = `nullptr`
	)

private

Definition at line 248 of file ColumnIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codgenAdjustFixedEncNull(), CgenState::context_, anonymous_namespace{ColumnIR.cpp}::get_col_bit_width(), anonymous_namespace{ColumnIR.cpp}::get_col_decoder(), get_int_type(), Analyzer::Expr::get_type_info(), WindowFunctionContext::getOrderKeyColumnBufferTypes(), WindowFunctionContext::getWindowFunction(), Analyzer::WindowFunction::hasRangeModeFraming(), CgenState::ir_builder_, kDOUBLE, kENCODING_DICT, kENCODING_FIXED, kENCODING_NONE, kFLOAT, and CgenState::module_.

Referenced by codegenColVar(), and codegenFixedLengthColVarInWindow().

                                                           {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto decoder = get_col_decoder(col_var);
   auto dec_val = decoder->codegenDecode(col_byte_stream, pos_arg, cgen_state_->module_);
   cgen_state_->ir_builder_.Insert(dec_val);
   auto dec_type = dec_val->getType();
   llvm::Value* dec_val_cast{nullptr};
   const auto& col_ti = col_var->get_type_info();
   if (dec_type->isIntegerTy()) {
     auto dec_width = static_cast<llvm::IntegerType*>(dec_type)->getBitWidth();
     auto col_width = get_col_bit_width(col_var);
     dec_val_cast = cgen_state_->ir_builder_.CreateCast(
         static_cast<size_t>(col_width) > dec_width ? llvm::Instruction::CastOps::SExt
                                                    : llvm::Instruction::CastOps::Trunc,
         dec_val,
         get_int_type(col_width, cgen_state_->context_));
     bool adjust_fixed_enc_null = true;
     if (window_function_context &&
         window_function_context->getWindowFunction()->hasRangeModeFraming()) {
       // we only need to cast it to 8 byte iff it is encoded type
       // (i.e., the size of non-encoded timestamp type is 8 byte)
       const auto order_key_ti =
           window_function_context->getOrderKeyColumnBufferTypes().front();
       if (order_key_ti.is_timestamp() && order_key_ti.get_size() == 4) {
         adjust_fixed_enc_null = false;
       }
     }
     if (adjust_fixed_enc_null &&
         (col_ti.get_compression() == kENCODING_FIXED ||
          (col_ti.get_compression() == kENCODING_DICT && col_ti.get_size() < 4)) &&
         !col_ti.get_notnull()) {
       dec_val_cast = codgenAdjustFixedEncNull(dec_val_cast, col_ti);
     }
   } else {
     CHECK_EQ(kENCODING_NONE, col_ti.get_compression());
     CHECK(dec_type->isFloatTy() || dec_type->isDoubleTy());
     if (dec_type->isDoubleTy()) {
       CHECK(col_ti.get_type() == kDOUBLE);
     } else if (dec_type->isFloatTy()) {
       CHECK(col_ti.get_type() == kFLOAT);
     }
     dec_val_cast = dec_val;
   }
   CHECK(dec_val_cast);
   return dec_val_cast;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenFixedLengthColVarInWindow	(	const Analyzer::ColumnVar *	col_var,
		llvm::Value *	col_byte_stream,
		llvm::Value *	pos_arg,
		const CompilationOptions &	co,
		const WindowFunctionContext *	window_function_context = `nullptr`
	)

private

Definition at line 299 of file ColumnIR.cpp.

References AUTOMATIC_IR_METADATA, CgenState::castToTypeIn(), cgen_state_, CHECK, codegenFixedLengthColVar(), CgenState::context_, WindowFunctionContext::counts(), CodegenUtil::createPtrWithHoistedMemoryAddr(), CgenState::current_func_, executor_, get_int_type(), Analyzer::Expr::get_type_info(), Analyzer::WindowFunction::getArgs(), Analyzer::WindowFunction::getKind(), WindowFunctionContext::getWindowFunction(), CgenState::inlineFpNull(), CgenState::inlineIntNull(), CgenState::ir_builder_, SQLTypeInfo::is_fp(), CgenState::llInt(), NTH_VALUE, and WindowFunctionContext::NUM_EXECUTION_DEVICES.

Referenced by codegenColVar().

                                                           {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto orig_bb = cgen_state_->ir_builder_.GetInsertBlock();
   const auto pos_valid_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "window.pos_valid", cgen_state_->current_func_);
   const auto pos_notvalid_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "window.pos_notvalid", cgen_state_->current_func_);
   const auto pos_is_valid =
       cgen_state_->ir_builder_.CreateICmpSGE(pos_arg, cgen_state_->llInt(int64_t(0)));
   if (window_function_context->getWindowFunction()->getKind() ==
       SqlWindowFunctionKind::NTH_VALUE) {
     // NTH_VALUE needs to return null if N > partition size
     // To do this, we store null value to the output buffer of the current row
     // if following requirements for processing NTH_VALUE are not satisfied
     // 1. current row is valid
     // 2. N < partition size that the current row is included
     const auto window_func_args = window_function_context->getWindowFunction()->getArgs();
     auto n_value_ptr = dynamic_cast<Analyzer::Constant*>(window_func_args[1].get());
     auto n_value_lv = cgen_state_->llInt((int64_t)n_value_ptr->get_constval().intval);
     CHECK(n_value_lv);
 
     auto partition_index_lv = executor_->codegenCurrentPartitionIndex(
         window_function_context, this, co, pos_arg);
     // # elems per partition
     const auto pi32_type =
         llvm::PointerType::get(get_int_type(32, cgen_state_->context_), 0);
     const auto partition_count_buf =
         cgen_state_->llInt(reinterpret_cast<int64_t>(window_function_context->counts()));
     auto partition_count_buf_ptr_lv = CodegenUtil::createPtrWithHoistedMemoryAddr(
                                           cgen_state_,
                                           this,
                                           co,
                                           partition_count_buf,
                                           pi32_type,
                                           WindowFunctionContext::NUM_EXECUTION_DEVICES)
                                           .front();
 
     // # elems of the given partition
     const auto num_elem_current_partition_ptr =
         cgen_state_->ir_builder_.CreateGEP(get_int_type(32, cgen_state_->context_),
                                            partition_count_buf_ptr_lv,
                                            partition_index_lv);
     const auto num_elem_current_partition_lv = cgen_state_->castToTypeIn(
         cgen_state_->ir_builder_.CreateLoad(
             num_elem_current_partition_ptr->getType()->getPointerElementType(),
             num_elem_current_partition_ptr),
         64);
     auto is_valid_n_value_lv = cgen_state_->ir_builder_.CreateICmpSLT(
         n_value_lv, num_elem_current_partition_lv, "is_valid_nth_value");
     auto cond_lv = cgen_state_->ir_builder_.CreateAnd(
         is_valid_n_value_lv, pos_is_valid, "is_valid_row_for_nth_value");
     // return the current row value iff 1) it is a valid row and 2) N < partition_size
     cgen_state_->ir_builder_.CreateCondBr(cond_lv, pos_valid_bb, pos_notvalid_bb);
   } else {
     // return the current row value if it is valid
     cgen_state_->ir_builder_.CreateCondBr(pos_is_valid, pos_valid_bb, pos_notvalid_bb);
   }
   cgen_state_->ir_builder_.SetInsertPoint(pos_valid_bb);
   const auto fixed_length_column_lv = codegenFixedLengthColVar(
       col_var, col_byte_stream, pos_arg, window_function_context);
   cgen_state_->ir_builder_.CreateBr(pos_notvalid_bb);
   cgen_state_->ir_builder_.SetInsertPoint(pos_notvalid_bb);
   const auto window_func_call_phi =
       cgen_state_->ir_builder_.CreatePHI(fixed_length_column_lv->getType(), 2);
   window_func_call_phi->addIncoming(fixed_length_column_lv, pos_valid_bb);
   const auto& col_ti = col_var->get_type_info();
   const auto null_lv =
       col_ti.is_fp() ? static_cast<llvm::Value*>(cgen_state_->inlineFpNull(col_ti))
                      : static_cast<llvm::Value*>(cgen_state_->inlineIntNull(col_ti));
   window_func_call_phi->addIncoming(null_lv, orig_bb);
   return window_func_call_phi;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenFpArith	(	const Analyzer::BinOper *	bin_oper,
		llvm::Value *	lhs_lv,
		llvm::Value *	rhs_lv
	)

private

Definition at line 134 of file ArithmeticIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegenDiv(), CgenState::emitCall(), Analyzer::BinOper::get_left_operand(), get_null_check_suffix(), Analyzer::BinOper::get_optype(), Analyzer::BinOper::get_right_operand(), Analyzer::Expr::get_type_info(), CgenState::ir_builder_, kDIVIDE, kFLOAT, kMINUS, kMULTIPLY, kPLUS, CgenState::llFp(), NULL_DOUBLE, NULL_FLOAT, and numeric_type_name().

Referenced by codegenArith().

                                                               {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto lhs = bin_oper->get_left_operand();
   const auto rhs = bin_oper->get_right_operand();
   const auto& lhs_type = lhs->get_type_info();
   const auto& rhs_type = rhs->get_type_info();
   const auto fp_typename = numeric_type_name(lhs_type);
   const auto null_check_suffix = get_null_check_suffix(lhs_type, rhs_type);
   llvm::ConstantFP* fp_null{lhs_type.get_type() == kFLOAT
                                 ? cgen_state_->llFp(NULL_FLOAT)
                                 : cgen_state_->llFp(NULL_DOUBLE)};
   switch (bin_oper->get_optype()) {
     case kMINUS:
       return null_check_suffix.empty()
                  ? cgen_state_->ir_builder_.CreateFSub(lhs_lv, rhs_lv)
                  : cgen_state_->emitCall("sub_" + fp_typename + null_check_suffix,
                                          {lhs_lv, rhs_lv, fp_null});
     case kPLUS:
       return null_check_suffix.empty()
                  ? cgen_state_->ir_builder_.CreateFAdd(lhs_lv, rhs_lv)
                  : cgen_state_->emitCall("add_" + fp_typename + null_check_suffix,
                                          {lhs_lv, rhs_lv, fp_null});
     case kMULTIPLY:
       return null_check_suffix.empty()
                  ? cgen_state_->ir_builder_.CreateFMul(lhs_lv, rhs_lv)
                  : cgen_state_->emitCall("mul_" + fp_typename + null_check_suffix,
                                          {lhs_lv, rhs_lv, fp_null});
     case kDIVIDE:
       return codegenDiv(lhs_lv,
                         rhs_lv,
                         null_check_suffix.empty() ? "" : fp_typename,
                         null_check_suffix,
                         lhs_type);
     default:
       CHECK(false);
   }
   CHECK(false);
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenFunctionOper	(	const Analyzer::FunctionOper *	function_oper,
		const CompilationOptions &	co
	)

private

Definition at line 240 of file ExtensionsIR.cpp.

References run_benchmark_import::args, AUTOMATIC_IR_METADATA, beginArgsNullcheck(), bind_function(), cgen_state_, CHECK, CHECK_EQ, CHECK_GE, codegen(), codegenCast(), codegenFunctionOperCastArgs(), CgenState::context_, gpu_enabled::copy(), CompilationOptions::device_type, CgenState::emitExternalCall(), endArgsNullcheck(), anonymous_namespace{ExtensionsIR.cpp}::ext_arg_type_to_llvm_type(), CgenState::ext_call_cache_, get_arg_by_name(), anonymous_namespace{ExtensionsIR.cpp}::get_buffer_struct_type(), anonymous_namespace{ExtensionsIR.cpp}::get_llvm_type_from_sql_array_type(), Analyzer::UOper::get_operand(), anonymous_namespace{ExtensionsIR.cpp}::get_sql_type_from_llvm_type(), SQLTypeInfo::get_type(), Analyzer::Expr::get_type_info(), Analyzer::FunctionOper::getArg(), Analyzer::FunctionOper::getArity(), ExtensionFunction::getName(), Analyzer::FunctionOper::getName(), ExtensionFunction::getRet(), GPU, CgenState::ir_builder_, Analyzer::ArrayExpr::isLocalAlloc(), kCAST, kPOINT, CgenState::llInt(), LOG, CgenState::row_func_, ExtensionFunction::usesManager(), and logger::WARNING.

Referenced by codegen(), codegenBoundingBoxIntersect(), and codegenFunctionOperWithCustomTypeHandling().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   ExtensionFunction ext_func_sig = [=]() {
     if (co.device_type == ExecutorDeviceType::GPU) {
       try {
         return bind_function(function_oper, /* is_gpu= */ true);
       } catch (ExtensionFunctionBindingError& e) {
         LOG(WARNING) << "codegenFunctionOper[GPU]: " << e.what() << " Redirecting "
                      << function_oper->getName() << " to run on CPU.";
         throw QueryMustRunOnCpu();
       }
     } else {
       try {
         return bind_function(function_oper, /* is_gpu= */ false);
       } catch (ExtensionFunctionBindingError& e) {
         LOG(WARNING) << "codegenFunctionOper[CPU]: " << e.what();
         throw;
       }
     }
   }();
 
   const auto& ret_ti = function_oper->get_type_info();
   CHECK(ret_ti.is_integer() || ret_ti.is_fp() || ret_ti.is_boolean() ||
         ret_ti.is_buffer() || ret_ti.is_text_encoding_dict());
   if (ret_ti.is_buffer() && co.device_type == ExecutorDeviceType::GPU) {
     // TODO: This is not necessary for runtime UDFs because RBC does
     // not generated GPU LLVM IR when the UDF is using Buffer objects.
     // However, we cannot remove it until C++ UDFs can be defined for
     // different devices independently.
     throw QueryMustRunOnCpu();
   }
 
   auto ret_ty = ext_arg_type_to_llvm_type(ext_func_sig.getRet(), cgen_state_->context_);
   const auto current_bb = cgen_state_->ir_builder_.GetInsertBlock();
   for (auto it : cgen_state_->ext_call_cache_) {
     if (*it.foper == *function_oper) {
       auto inst = llvm::dyn_cast<llvm::Instruction>(it.lv);
       if (inst && inst->getParent() == current_bb) {
         return it.lv;
       }
     }
   }
   std::vector<llvm::Value*> orig_arg_lvs;
   std::vector<size_t> orig_arg_lvs_index;
   std::unordered_map<llvm::Value*, llvm::Value*> const_arr_size;
 
   for (size_t i = 0; i < function_oper->getArity(); ++i) {
     orig_arg_lvs_index.push_back(orig_arg_lvs.size());
     const auto arg = function_oper->getArg(i);
     const auto arg_cast = dynamic_cast<const Analyzer::UOper*>(arg);
     const auto arg0 =
         (arg_cast && arg_cast->get_optype() == kCAST) ? arg_cast->get_operand() : arg;
     const auto array_expr_arg = dynamic_cast<const Analyzer::ArrayExpr*>(arg0);
     auto is_local_alloc = array_expr_arg && array_expr_arg->isLocalAlloc();
     const auto& arg_ti = arg->get_type_info();
     const auto arg_lvs = codegen(arg, true, co);
     auto geo_uoper_arg = dynamic_cast<const Analyzer::GeoUOper*>(arg);
     auto geo_binoper_arg = dynamic_cast<const Analyzer::GeoBinOper*>(arg);
     auto geo_expr_arg = dynamic_cast<const Analyzer::GeoExpr*>(arg);
     // TODO(adb / d): Assuming no const array cols for geo (for now)
     if ((geo_uoper_arg || geo_binoper_arg) && arg_ti.is_geometry()) {
       // Extract arr sizes and put them in the map, forward arr pointers
       CHECK_EQ(2 * static_cast<size_t>(arg_ti.get_physical_coord_cols()), arg_lvs.size());
       for (size_t i = 0; i < arg_lvs.size(); i++) {
         auto arr = arg_lvs[i++];
         auto size = arg_lvs[i];
         orig_arg_lvs.push_back(arr);
         const_arr_size[arr] = size;
       }
     } else if (geo_expr_arg && geo_expr_arg->get_type_info().is_geometry()) {
       CHECK(geo_expr_arg->get_type_info().get_type() == kPOINT);
       CHECK_EQ(arg_lvs.size(), size_t(2));
       for (size_t j = 0; j < arg_lvs.size(); j++) {
         orig_arg_lvs.push_back(arg_lvs[j]);
       }
     } else if (arg_ti.is_geometry()) {
       CHECK_EQ(static_cast<size_t>(arg_ti.get_physical_coord_cols()), arg_lvs.size());
       for (size_t j = 0; j < arg_lvs.size(); j++) {
         orig_arg_lvs.push_back(arg_lvs[j]);
       }
     } else if (arg_ti.is_text_encoding_none()) {
       if (arg_lvs.size() == 3) {
         // arg_lvs contains:
         // arg_lvs[0] StringView struct { i8*, i64 }
         // arg_lvs[1] i8* pointer
         // arg_lvs[2] i32 string length (truncated from i64)
         std::copy(
             std::begin(arg_lvs), std::end(arg_lvs), std::back_inserter(orig_arg_lvs));
       } else if (arg_lvs.size() == 1) {
         // TextEncodingNone*
         // orig_arg_lvs should contain:
         // orig_arg_lvs[0]: TextEncodingNone struct { i8*, i64, i8* }
         // orig_arg_lvs[1]: i8*
         // orig_arg_lvs[1]: i32 string length (truncated from i64)
         CHECK(arg_lvs[0]->getType()->isPointerTy());
         auto none_enc_string = cgen_state_->ir_builder_.CreateLoad(
             arg_lvs[0]->getType()->getPointerElementType(), arg_lvs[0]);
         orig_arg_lvs.push_back(none_enc_string);
         orig_arg_lvs.push_back(
             cgen_state_->ir_builder_.CreateExtractValue(none_enc_string, 0));
         orig_arg_lvs.push_back(cgen_state_->ir_builder_.CreateTrunc(
             cgen_state_->ir_builder_.CreateExtractValue(none_enc_string, 1),
             llvm::Type::getInt32Ty(cgen_state_->context_)));
       }
     } else if (arg_ti.is_text_encoding_dict()) {
       CHECK_EQ(size_t(1), arg_lvs.size());
       orig_arg_lvs.push_back(arg_lvs[0]);
     } else {
       if (arg_lvs.size() > 1) {
         CHECK(arg_ti.is_array());
         CHECK_EQ(size_t(2), arg_lvs.size());
         const_arr_size[arg_lvs.front()] = arg_lvs.back();
       } else {
         CHECK_EQ(size_t(1), arg_lvs.size());
         /* arg_lvs contains:
              &col_buf1
          */
         if (is_local_alloc && arg_ti.get_size() > 0) {
           const_arr_size[arg_lvs.front()] = cgen_state_->llInt(arg_ti.get_size());
         }
       }
       orig_arg_lvs.push_back(arg_lvs.front());
     }
   }
   // The extension function implementations don't handle NULL, they work under
   // the assumption that the inputs are validated before calling them. Generate
   // code to do the check at the call site: if any argument is NULL, return NULL
   // without calling the function at all.
   const auto [bbs, null_buffer_ptr] = beginArgsNullcheck(function_oper, orig_arg_lvs);
   CHECK_GE(orig_arg_lvs.size(), function_oper->getArity());
   // Arguments must be converted to the types the extension function can handle.
   auto args = codegenFunctionOperCastArgs(
       function_oper, &ext_func_sig, orig_arg_lvs, orig_arg_lvs_index, const_arr_size, co);
 
   if (ext_func_sig.usesManager()) {
     if (co.device_type == ExecutorDeviceType::GPU) {
       throw QueryMustRunOnCpu();
     }
     llvm::Value* row_func_mgr = get_arg_by_name(cgen_state_->row_func_, "row_func_mgr");
     args.insert(args.begin(), row_func_mgr);
   }
 
   llvm::Value* buffer_ret{nullptr};
   if (ret_ti.is_buffer()) {
     // codegen buffer return as first arg
     CHECK(ret_ti.is_array() || ret_ti.is_text_encoding_none());
     ret_ty = llvm::Type::getVoidTy(cgen_state_->context_);
     const auto struct_ty = get_buffer_struct_type(
         cgen_state_,
         function_oper->getName(),
         0,
         get_llvm_type_from_sql_array_type(ret_ti, cgen_state_->context_));
     buffer_ret = cgen_state_->ir_builder_.CreateAlloca(struct_ty);
     args.insert(args.begin(), buffer_ret);
   }
 
   const auto ext_call = cgen_state_->emitExternalCall(
       ext_func_sig.getName(), ret_ty, args, {}, ret_ti.is_buffer());
   auto ext_call_nullcheck = endArgsNullcheck(
       bbs, ret_ti.is_buffer() ? buffer_ret : ext_call, null_buffer_ptr, function_oper);
 
   // Cast the return of the extension function to match the FunctionOper
   if (!(ret_ti.is_buffer() || ret_ti.is_text_encoding_dict())) {
     const auto extension_ret_ti = get_sql_type_from_llvm_type(ret_ty);
     if (bbs.args_null_bb &&
         extension_ret_ti.get_type() != function_oper->get_type_info().get_type() &&
         // Skip i1-->i8 casts for ST_ functions.
         // function_oper ret type is i1, extension ret type is 'upgraded' to i8
         // during type deserialization to 'handle' NULL returns, hence i1-->i8.
         // ST_ functions can't return NULLs, we just need to check arg nullness
         // and if any args are NULL then ST_ function is not called
         function_oper->getName().substr(0, 3) != std::string("ST_")) {
       ext_call_nullcheck = codegenCast(ext_call_nullcheck,
                                        extension_ret_ti,
                                        function_oper->get_type_info(),
                                        false,
                                        co);
     }
   }
 
   cgen_state_->ext_call_cache_.push_back({function_oper, ext_call_nullcheck});
   return ext_call_nullcheck;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenFunctionOperCastArgs	(	const Analyzer::FunctionOper *	function_oper,
		const ExtensionFunction *	ext_func_sig,
		const std::vector< llvm::Value * > &	orig_arg_lvs,
		const std::vector< size_t > &	orig_arg_lvs_index,
		const std::unordered_map< llvm::Value , llvm::Value > &	const_arr_size,
		const CompilationOptions &	co
	)

private

Definition at line 1368 of file ExtensionsIR.cpp.

References run_benchmark_import::args, AUTOMATIC_IR_METADATA, castArrayPointer(), cgen_state_, CHECK, CHECK_EQ, CHECK_LE, codegenArrayBuff(), codegenBufferArgs(), codegenCompression(), codegenGeoLineStringArgs(), codegenGeoMultiLineStringArgs(), codegenGeoMultiPointArgs(), codegenGeoMultiPolygonArgs(), codegenGeoPointArgs(), codegenGeoPolygonArgs(), CgenState::context_, CgenState::emitExternalCall(), executor(), GeoMultiLineString, GeoMultiPolygon, GeoPolygon, SQLTypeInfo::get_elem_type(), get_int_type(), Analyzer::Expr::get_type_info(), Analyzer::FunctionOper::getArg(), Analyzer::FunctionOper::getArity(), ExtensionFunction::getInputArgs(), ExtensionFunction::getName(), CgenState::ir_builder_, is_ext_arg_type_array(), is_ext_arg_type_geo(), is_ext_arg_type_pointer(), kARRAY, kENCODING_NONE, kINT, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kPOINT, kPOLYGON, kTINYINT, ll_bool(), CgenState::llInt(), log2_bytes(), PInt8, posArg(), TextEncodingDict, TextEncodingNone, toString(), and UNREACHABLE.

Referenced by codegenFunctionOper().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(ext_func_sig);
   const auto& ext_func_args = ext_func_sig->getInputArgs();
   CHECK_LE(function_oper->getArity(), ext_func_args.size());
   const auto func_ti = function_oper->get_type_info();
   std::vector<llvm::Value*> args;
   /*
     i: argument in RA for the function operand
     j: extra offset in ext_func_args
     k: origin_arg_lvs counter, equal to orig_arg_lvs_index[i]
     ij: ext_func_args counter, equal to i + j
     dj: offset when UDF implementation first argument corresponds to return value
    */
   for (size_t i = 0, j = 0, dj = (func_ti.is_buffer() ? 1 : 0);
        i < function_oper->getArity();
        ++i) {
     size_t k = orig_arg_lvs_index[i];
     size_t ij = i + j;
     const auto arg = function_oper->getArg(i);
     const auto ext_func_arg = ext_func_args[ij];
     const auto& arg_ti = arg->get_type_info();
     llvm::Value* arg_lv{nullptr};
     if (arg_ti.is_text_encoding_none()) {
       CHECK(ext_func_arg == ExtArgumentType::TextEncodingNone)
           << ::toString(ext_func_arg);
       const auto ptr_lv = orig_arg_lvs[k + 1];
       const auto len_lv = orig_arg_lvs[k + 2];
       auto& builder = cgen_state_->ir_builder_;
       auto string_buf_arg = builder.CreatePointerCast(
           ptr_lv, llvm::Type::getInt8PtrTy(cgen_state_->context_));
       auto string_size_arg =
           builder.CreateZExt(len_lv, get_int_type(64, cgen_state_->context_));
       auto padding = ll_int<int8_t>(0, cgen_state_->context_);
       codegenBufferArgs(ext_func_sig->getName(),
                         ij + dj,
                         string_buf_arg,
                         string_size_arg,
                         padding,
                         args);
     } else if (arg_ti.is_text_encoding_dict()) {
       CHECK(ext_func_arg == ExtArgumentType::TextEncodingDict)
           << ::toString(ext_func_arg);
       arg_lv = orig_arg_lvs[k];
       args.push_back(arg_lv);
     } else if (arg_ti.is_array()) {
       bool const_arr = (const_arr_size.count(orig_arg_lvs[k]) > 0);
       const auto elem_ti = arg_ti.get_elem_type();
       // TODO: switch to fast fixlen variants
       const auto ptr_lv = (const_arr)
                               ? orig_arg_lvs[k]
                               : cgen_state_->emitExternalCall(
                                     "array_buff",
                                     llvm::Type::getInt8PtrTy(cgen_state_->context_),
                                     {orig_arg_lvs[k], posArg(arg)});
       const auto len_lv =
           (const_arr) ? const_arr_size.at(orig_arg_lvs[k])
                       : cgen_state_->emitExternalCall(
                             "array_size",
                             get_int_type(32, cgen_state_->context_),
                             {orig_arg_lvs[k],
                              posArg(arg),
                              cgen_state_->llInt(log2_bytes(elem_ti.get_logical_size()))});
 
       if (is_ext_arg_type_pointer(ext_func_arg)) {
         args.push_back(castArrayPointer(ptr_lv, elem_ti));
         args.push_back(cgen_state_->ir_builder_.CreateZExt(
             len_lv, get_int_type(64, cgen_state_->context_)));
         j++;
       } else if (is_ext_arg_type_array(ext_func_arg)) {
         auto array_buf_arg = castArrayPointer(ptr_lv, elem_ti);
         auto& builder = cgen_state_->ir_builder_;
         auto array_size_arg =
             builder.CreateZExt(len_lv, get_int_type(64, cgen_state_->context_));
         llvm::Value* array_null_arg = nullptr;
         if (auto gep = llvm::dyn_cast<llvm::GetElementPtrInst>(ptr_lv)) {
           CHECK(gep->getSourceElementType()->isArrayTy());
           // gep has the form
           // %17 = getelementptr [9 x i32], [9 x i32]* %7, i32 0
           // and was created by passing a const array to the UDF function:
           // select array_append({11, 22, 33}, 4);
           array_null_arg = ll_bool(false, cgen_state_->context_);
         } else {
           array_null_arg =
               cgen_state_->emitExternalCall("array_is_null",
                                             get_int_type(1, cgen_state_->context_),
                                             {orig_arg_lvs[k], posArg(arg)});
         }
         codegenBufferArgs(ext_func_sig->getName(),
                           ij + dj,
                           array_buf_arg,
                           array_size_arg,
                           array_null_arg,
                           args);
       } else {
         UNREACHABLE();
       }
 
     } else if (arg_ti.is_geometry()) {
       auto geo_expr_arg = dynamic_cast<const Analyzer::GeoExpr*>(arg);
       if (geo_expr_arg) {
         auto ptr_lv = cgen_state_->ir_builder_.CreateBitCast(
             orig_arg_lvs[k], llvm::Type::getInt8PtrTy(cgen_state_->context_));
         args.push_back(ptr_lv);
         // TODO: remove when we normalize extension functions geo sizes to int32
         auto size_lv = cgen_state_->ir_builder_.CreateSExt(
             orig_arg_lvs[k + 1], llvm::Type::getInt64Ty(cgen_state_->context_));
         args.push_back(size_lv);
         j++;
         continue;
       }
       // Coords
       bool const_arr = (const_arr_size.count(orig_arg_lvs[k]) > 0);
       // NOTE(adb): We're generating code to handle the TINYINT array only -- the actual
       // geo encoding (or lack thereof) does not matter here
       const auto elem_ti = SQLTypeInfo(SQLTypes::kARRAY,
                                        0,
                                        0,
                                        false,
                                        EncodingType::kENCODING_NONE,
                                        0,
                                        SQLTypes::kTINYINT)
                                .get_elem_type();
       llvm::Value* ptr_lv;
       llvm::Value* len_lv;
       int32_t fixlen = -1;
       if (arg_ti.get_type() == kPOINT) {
         const auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(arg);
         if (col_var) {
           const auto coords_cd = executor()->getPhysicalColumnDescriptor(col_var, 1);
           if (coords_cd && coords_cd->columnType.get_type() == kARRAY) {
             fixlen = coords_cd->columnType.get_size();
           }
         }
       }
       if (fixlen > 0) {
         ptr_lv =
             cgen_state_->emitExternalCall("fast_fixlen_array_buff",
                                           llvm::Type::getInt8PtrTy(cgen_state_->context_),
                                           {orig_arg_lvs[k], posArg(arg)});
         len_lv = cgen_state_->llInt(int32_t(fixlen));
       } else {
         // TODO: remove const_arr  and related code if it's not needed
         ptr_lv = (const_arr) ? orig_arg_lvs[k]
                              : cgen_state_->emitExternalCall(
                                    "array_buff",
                                    llvm::Type::getInt8PtrTy(cgen_state_->context_),
                                    {orig_arg_lvs[k], posArg(arg)});
         len_lv = (const_arr)
                      ? const_arr_size.at(orig_arg_lvs[k])
                      : cgen_state_->emitExternalCall(
                            "array_size",
                            get_int_type(32, cgen_state_->context_),
                            {orig_arg_lvs[k],
                             posArg(arg),
                             cgen_state_->llInt(log2_bytes(elem_ti.get_logical_size()))});
       }
 
       if (is_ext_arg_type_geo(ext_func_arg)) {
         if (arg_ti.get_type() == kPOINT || arg_ti.get_type() == kLINESTRING ||
             arg_ti.get_type() == kMULTIPOINT) {
           auto array_buf_arg = castArrayPointer(ptr_lv, elem_ti);
           auto compression_val = codegenCompression(arg_ti);
           auto input_srid_val = cgen_state_->llInt(arg_ti.get_input_srid());
           auto output_srid_val = cgen_state_->llInt(arg_ti.get_output_srid());
 
           if (arg_ti.get_type() == kPOINT) {
             CHECK_EQ(k, ij);
             codegenGeoPointArgs(ext_func_sig->getName(),
                                 ij + dj,
                                 array_buf_arg,
                                 len_lv,
                                 compression_val,
                                 input_srid_val,
                                 output_srid_val,
                                 args);
           } else if (arg_ti.get_type() == kMULTIPOINT) {
             CHECK_EQ(k, ij);
             codegenGeoMultiPointArgs(ext_func_sig->getName(),
                                      ij + dj,
                                      array_buf_arg,
                                      len_lv,
                                      compression_val,
                                      input_srid_val,
                                      output_srid_val,
                                      args);
           } else {
             CHECK_EQ(k, ij);
             codegenGeoLineStringArgs(ext_func_sig->getName(),
                                      ij + dj,
                                      array_buf_arg,
                                      len_lv,
                                      compression_val,
                                      input_srid_val,
                                      output_srid_val,
                                      args);
           }
         }
       } else {
         CHECK(ext_func_arg == ExtArgumentType::PInt8);
         args.push_back(castArrayPointer(ptr_lv, elem_ti));
         args.push_back(cgen_state_->ir_builder_.CreateZExt(
             len_lv, get_int_type(64, cgen_state_->context_)));
         j++;
       }
 
       switch (arg_ti.get_type()) {
         case kPOINT:
         case kMULTIPOINT:
         case kLINESTRING:
           break;
         case kMULTILINESTRING: {
           if (ext_func_arg == ExtArgumentType::GeoMultiLineString) {
             auto multi_linestring_coords = castArrayPointer(ptr_lv, elem_ti);
             auto compression_val = codegenCompression(arg_ti);
             auto input_srid_val = cgen_state_->llInt(arg_ti.get_input_srid());
             auto output_srid_val = cgen_state_->llInt(arg_ti.get_output_srid());
 
             auto [linestring_sizes, linestring_sizes_size] =
                 codegenArrayBuff(orig_arg_lvs[k + 1],
                                  posArg(arg),
                                  SQLTypes::kINT,
                                  /*cast_and_extend=*/false);
             CHECK_EQ(k, ij);
             codegenGeoMultiLineStringArgs(ext_func_sig->getName(),
                                           ij + dj,
                                           multi_linestring_coords,
                                           len_lv,
                                           linestring_sizes,
                                           linestring_sizes_size,
                                           compression_val,
                                           input_srid_val,
                                           output_srid_val,
                                           args);
           } else {
             CHECK(ext_func_arg == ExtArgumentType::PInt8);
             // Linestring Sizes
             auto const_arr = const_arr_size.count(orig_arg_lvs[k + 1]) > 0;
             auto [linestring_sizes, linestring_sizes_size] =
                 (const_arr) ? std::make_pair(orig_arg_lvs[k + 1],
                                              const_arr_size.at(orig_arg_lvs[k + 1]))
                             : codegenArrayBuff(orig_arg_lvs[k + 1],
                                                posArg(arg),
                                                SQLTypes::kINT,
                                                /*cast_and_extend=*/true);
             args.push_back(linestring_sizes);
             args.push_back(linestring_sizes_size);
             j += 2;
           }
           break;
         }
         case kPOLYGON: {
           if (ext_func_arg == ExtArgumentType::GeoPolygon) {
             auto array_buf_arg = castArrayPointer(ptr_lv, elem_ti);
             auto compression_val = codegenCompression(arg_ti);
             auto input_srid_val = cgen_state_->llInt(arg_ti.get_input_srid());
             auto output_srid_val = cgen_state_->llInt(arg_ti.get_output_srid());
 
             auto [ring_size_buff, ring_size] =
                 codegenArrayBuff(orig_arg_lvs[k + 1],
                                  posArg(arg),
                                  SQLTypes::kINT,
                                  /*cast_and_extend=*/false);
             CHECK_EQ(k, ij);
             codegenGeoPolygonArgs(ext_func_sig->getName(),
                                   ij + dj,
                                   array_buf_arg,
                                   len_lv,
                                   ring_size_buff,
                                   ring_size,
                                   compression_val,
                                   input_srid_val,
                                   output_srid_val,
                                   args);
           } else {
             CHECK(ext_func_arg == ExtArgumentType::PInt8);
             // Ring Sizes
             auto const_arr = const_arr_size.count(orig_arg_lvs[k + 1]) > 0;
             auto [ring_size_buff, ring_size] =
                 (const_arr) ? std::make_pair(orig_arg_lvs[k + 1],
                                              const_arr_size.at(orig_arg_lvs[k + 1]))
                             : codegenArrayBuff(orig_arg_lvs[k + 1],
                                                posArg(arg),
                                                SQLTypes::kINT,
                                                /*cast_and_extend=*/true);
             args.push_back(ring_size_buff);
             args.push_back(ring_size);
             j += 2;
           }
           break;
         }
         case kMULTIPOLYGON: {
           if (ext_func_arg == ExtArgumentType::GeoMultiPolygon) {
             auto array_buf_arg = castArrayPointer(ptr_lv, elem_ti);
             auto compression_val = codegenCompression(arg_ti);
             auto input_srid_val = cgen_state_->llInt(arg_ti.get_input_srid());
             auto output_srid_val = cgen_state_->llInt(arg_ti.get_output_srid());
 
             auto [ring_size_buff, ring_size] =
                 codegenArrayBuff(orig_arg_lvs[k + 1],
                                  posArg(arg),
                                  SQLTypes::kINT,
                                  /*cast_and_extend=*/false);
 
             auto [poly_bounds_buff, poly_bounds_size] =
                 codegenArrayBuff(orig_arg_lvs[k + 2],
                                  posArg(arg),
                                  SQLTypes::kINT,
                                  /*cast_and_extend=*/false);
             CHECK_EQ(k, ij);
             codegenGeoMultiPolygonArgs(ext_func_sig->getName(),
                                        ij + dj,
                                        array_buf_arg,
                                        len_lv,
                                        ring_size_buff,
                                        ring_size,
                                        poly_bounds_buff,
                                        poly_bounds_size,
                                        compression_val,
                                        input_srid_val,
                                        output_srid_val,
                                        args);
           } else {
             CHECK(ext_func_arg == ExtArgumentType::PInt8);
             // Ring Sizes
             {
               auto const_arr = const_arr_size.count(orig_arg_lvs[k + 1]) > 0;
               auto [ring_size_buff, ring_size] =
                   (const_arr) ? std::make_pair(orig_arg_lvs[k + 1],
                                                const_arr_size.at(orig_arg_lvs[k + 1]))
                               : codegenArrayBuff(orig_arg_lvs[k + 1],
                                                  posArg(arg),
                                                  SQLTypes::kINT,
                                                  /*cast_and_extend=*/true);
 
               args.push_back(ring_size_buff);
               args.push_back(ring_size);
             }
             // Poly Rings
             {
               auto const_arr = const_arr_size.count(orig_arg_lvs[k + 2]) > 0;
               auto [poly_bounds_buff, poly_bounds_size] =
                   (const_arr)
                       ? std::make_pair(orig_arg_lvs[k + 2],
                                        const_arr_size.at(orig_arg_lvs[k + 2]))
                       : codegenArrayBuff(
                             orig_arg_lvs[k + 2], posArg(arg), SQLTypes::kINT, true);
 
               args.push_back(poly_bounds_buff);
               args.push_back(poly_bounds_size);
             }
             j += 4;
           }
           break;
         }
         default:
           CHECK(false);
       }
     } else {
       CHECK(is_ext_arg_type_scalar(ext_func_arg));
       const auto arg_target_ti = ext_arg_type_to_type_info(ext_func_arg);
       if (arg_ti.get_type() != arg_target_ti.get_type()) {
         arg_lv = codegenCast(orig_arg_lvs[k], arg_ti, arg_target_ti, false, co);
       } else {
         arg_lv = orig_arg_lvs[k];
       }
       CHECK_EQ(arg_lv->getType(),
                ext_arg_type_to_llvm_type(ext_func_arg, cgen_state_->context_));
       args.push_back(arg_lv);
     }
   }
   return args;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenFunctionOperNullArg	(	const Analyzer::FunctionOper *	function_oper,
		const std::vector< llvm::Value * > &	orig_arg_lvs
	)

private

Definition at line 607 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegenIsNullNumber(), CgenState::context_, CgenState::emitExternalCall(), get_int_type(), SQLTypeInfo::get_physical_coord_cols(), Analyzer::Expr::get_type_info(), Analyzer::FunctionOper::getArg(), Analyzer::FunctionOper::getArity(), CgenState::ir_builder_, kENCODING_GEOINT, kPOINT, and posArg().

Referenced by beginArgsNullcheck().

                                                {
   AUTOMATIC_IR_METADATA(cgen_state_);
   llvm::Value* one_arg_null =
       llvm::ConstantInt::get(llvm::IntegerType::getInt1Ty(cgen_state_->context_), false);
   size_t physical_coord_cols = 0;
   for (size_t i = 0, j = 0; i < function_oper->getArity();
        ++i, j += std::max(size_t(1), physical_coord_cols)) {
     const auto arg = function_oper->getArg(i);
     const auto& arg_ti = arg->get_type_info();
     physical_coord_cols = arg_ti.get_physical_coord_cols();
     if (arg_ti.get_notnull()) {
       continue;
     }
     auto geo_expr_arg = dynamic_cast<const Analyzer::GeoExpr*>(arg);
     if (geo_expr_arg && arg_ti.is_geometry()) {
       CHECK(arg_ti.get_type() == kPOINT);
       auto is_null_lv = cgen_state_->ir_builder_.CreateICmp(
           llvm::CmpInst::ICMP_EQ,
           orig_arg_lvs[j],
           llvm::ConstantPointerNull::get(  // TODO: centralize logic; in geo expr?
               arg_ti.get_compression() == kENCODING_GEOINT
                   ? llvm::Type::getInt32PtrTy(cgen_state_->context_)
                   : llvm::Type::getDoublePtrTy(cgen_state_->context_)));
       one_arg_null = cgen_state_->ir_builder_.CreateOr(one_arg_null, is_null_lv);
       physical_coord_cols = 2;  // number of lvs to advance
       continue;
     }
 #ifdef ENABLE_GEOS
     // If geo arg is coming from geos, skip the null check, assume it's a valid geo
     if (arg_ti.is_geometry()) {
       auto* coords_load = llvm::dyn_cast<llvm::LoadInst>(orig_arg_lvs[i]);
       if (coords_load) {
         continue;
       }
     }
 #endif
     if (arg_ti.is_geometry()) {
       auto* coords_alloca = llvm::dyn_cast<llvm::AllocaInst>(orig_arg_lvs[j]);
       auto* coords_phi = llvm::dyn_cast<llvm::PHINode>(orig_arg_lvs[j]);
       if (coords_alloca || coords_phi) {
         // TODO: null check dynamically generated geometries
         continue;
       }
     }
     if (arg_ti.is_text_encoding_dict()) {
       one_arg_null = cgen_state_->ir_builder_.CreateOr(
           one_arg_null, codegenIsNullNumber(orig_arg_lvs[j], arg_ti));
       continue;
     }
     if (arg_ti.is_buffer() || arg_ti.is_geometry()) {
       // POINT [un]compressed coord check requires custom checker and chunk iterator
       // Non-POINT NULL geographies will have a normally encoded null coord array
       auto fname =
           (arg_ti.get_type() == kPOINT) ? "point_coord_array_is_null" : "array_is_null";
       auto is_null_lv = cgen_state_->emitExternalCall(
           fname, get_int_type(1, cgen_state_->context_), {orig_arg_lvs[j], posArg(arg)});
       one_arg_null = cgen_state_->ir_builder_.CreateOr(one_arg_null, is_null_lv);
       continue;
     }
     CHECK(arg_ti.is_number() or arg_ti.is_boolean());
     one_arg_null = cgen_state_->ir_builder_.CreateOr(
         one_arg_null, codegenIsNullNumber(orig_arg_lvs[j], arg_ti));
   }
   return one_arg_null;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenFunctionOperWithCustomTypeHandling	(	const Analyzer::FunctionOperWithCustomTypeHandling *	function_oper,
		const CompilationOptions &	co
	)

private

Definition at line 539 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, beginArgsNullcheck(), anonymous_namespace{ExtensionsIR.cpp}::call_requires_custom_type_handling(), cgen_state_, CHECK, CHECK_EQ, codegen(), codegenCast(), codegenFunctionOper(), CgenState::context_, CgenState::emitCall(), CgenState::emitExternalCall(), endArgsNullcheck(), exp_to_scale(), get_int_type(), Analyzer::Expr::get_type_info(), Analyzer::FunctionOper::getArg(), Analyzer::FunctionOper::getArity(), Analyzer::FunctionOper::getName(), CgenState::ir_builder_, SQLTypeInfo::is_decimal(), kINT, and CgenState::llInt().

Referenced by codegen().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (call_requires_custom_type_handling(function_oper)) {
     // Some functions need the return type to be the same as the input type.
     if (function_oper->getName() == "FLOOR" || function_oper->getName() == "CEIL") {
       CHECK_EQ(size_t(1), function_oper->getArity());
       const auto arg = function_oper->getArg(0);
       const auto& arg_ti = arg->get_type_info();
       CHECK(arg_ti.is_decimal());
       const auto arg_lvs = codegen(arg, true, co);
       CHECK_EQ(size_t(1), arg_lvs.size());
       const auto arg_lv = arg_lvs.front();
       CHECK(arg_lv->getType()->isIntegerTy(64));
       CodeGenerator::ArgNullcheckBBs bbs;
       std::tie(bbs, std::ignore) = beginArgsNullcheck(function_oper, {arg_lvs});
       const std::string func_name =
           (function_oper->getName() == "FLOOR") ? "decimal_floor" : "decimal_ceil";
       const auto covar_result_lv = cgen_state_->emitCall(
           func_name, {arg_lv, cgen_state_->llInt(exp_to_scale(arg_ti.get_scale()))});
       const auto ret_ti = function_oper->get_type_info();
       CHECK(ret_ti.is_decimal());
       CHECK_EQ(0, ret_ti.get_scale());
       const auto result_lv = cgen_state_->ir_builder_.CreateSDiv(
           covar_result_lv, cgen_state_->llInt(exp_to_scale(arg_ti.get_scale())));
       return endArgsNullcheck(bbs, result_lv, nullptr, function_oper);
     } else if (function_oper->getName() == "ROUND" &&
                function_oper->getArg(0)->get_type_info().is_decimal()) {
       CHECK_EQ(size_t(2), function_oper->getArity());
 
       const auto arg0 = function_oper->getArg(0);
       const auto& arg0_ti = arg0->get_type_info();
       const auto arg0_lvs = codegen(arg0, true, co);
       CHECK_EQ(size_t(1), arg0_lvs.size());
       const auto arg0_lv = arg0_lvs.front();
       CHECK(arg0_lv->getType()->isIntegerTy(64));
 
       const auto arg1 = function_oper->getArg(1);
       const auto& arg1_ti = arg1->get_type_info();
       CHECK(arg1_ti.is_integer());
       const auto arg1_lvs = codegen(arg1, true, co);
       auto arg1_lv = arg1_lvs.front();
       if (arg1_ti.get_type() != kINT) {
         arg1_lv = codegenCast(arg1_lv, arg1_ti, SQLTypeInfo(kINT, true), false, co);
       }
 
       CodeGenerator::ArgNullcheckBBs bbs0;
       std::tie(bbs0, std::ignore) =
           beginArgsNullcheck(function_oper, {arg0_lv, arg1_lvs.front()});
 
       const std::string func_name = "Round__4";
       const auto ret_ti = function_oper->get_type_info();
       CHECK(ret_ti.is_decimal());
       const auto result_lv = cgen_state_->emitExternalCall(
           func_name,
           get_int_type(64, cgen_state_->context_),
           {arg0_lv, arg1_lv, cgen_state_->llInt(arg0_ti.get_scale())});
 
       return endArgsNullcheck(bbs0, result_lv, nullptr, function_oper);
     }
     throw std::runtime_error("Type combination not supported for function " +
                              function_oper->getName());
   }
   return codegenFunctionOper(function_oper, co);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenGeoArgs	(	const std::vector< std::shared_ptr< Analyzer::Expr >> &	geo_args,
		const CompilationOptions &	co
	)

private

Definition at line 371 of file GeoIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), CgenState::context_, CgenState::emitExternalCall(), get_int_type(), CgenState::ir_builder_, CgenState::llInt(), log2_bytes(), and posArg().

Referenced by codegenGeoBinOper(), and codegenGeoUOper().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   std::vector<llvm::Value*> argument_list;
   bool coord_col = true;
   for (const auto& geo_arg : geo_args) {
     const auto arg = geo_arg.get();
     const auto& arg_ti = arg->get_type_info();
     const auto elem_ti = arg_ti.get_elem_type();
     const auto arg_lvs = codegen(arg, true, co);
     if (arg_ti.is_number()) {
       argument_list.emplace_back(arg_lvs.front());
       continue;
     }
     if (arg_ti.is_geometry()) {
       argument_list.insert(argument_list.end(), arg_lvs.begin(), arg_lvs.end());
       continue;
     }
     CHECK(arg_ti.is_array());
     if (arg_lvs.size() > 1) {
       CHECK_EQ(size_t(2), arg_lvs.size());
       auto ptr_lv = arg_lvs.front();
       if (coord_col) {
         coord_col = false;
       } else {
         ptr_lv = cgen_state_->ir_builder_.CreatePointerCast(
             ptr_lv, llvm::Type::getInt32PtrTy(cgen_state_->context_));
       }
       argument_list.emplace_back(ptr_lv);
       auto cast_len_lv = cgen_state_->ir_builder_.CreateZExt(
           arg_lvs.back(), get_int_type(64, cgen_state_->context_));
       argument_list.emplace_back(cast_len_lv);
     } else {
       CHECK_EQ(size_t(1), arg_lvs.size());
       if (arg_ti.get_size() > 0) {
         // Set up the pointer lv for a dynamically generated point
         auto ptr_lv = arg_lvs.front();
         auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(arg);
         // Override for point coord column access
         if (col_var) {
           ptr_lv = cgen_state_->emitExternalCall(
               "fast_fixlen_array_buff",
               llvm::Type::getInt8PtrTy(cgen_state_->context_),
               {arg_lvs.front(), posArg(arg)});
         }
         if (coord_col) {
           coord_col = false;
         } else {
           ptr_lv = cgen_state_->ir_builder_.CreatePointerCast(
               ptr_lv, llvm::Type::getInt32PtrTy(cgen_state_->context_));
         }
         argument_list.emplace_back(ptr_lv);
         argument_list.emplace_back(cgen_state_->llInt<int64_t>(arg_ti.get_size()));
       } else {
         auto ptr_lv =
             cgen_state_->emitExternalCall("array_buff",
                                           llvm::Type::getInt8PtrTy(cgen_state_->context_),
                                           {arg_lvs.front(), posArg(arg)});
         if (coord_col) {
           coord_col = false;
         } else {
           ptr_lv = cgen_state_->ir_builder_.CreatePointerCast(
               ptr_lv, llvm::Type::getInt32PtrTy(cgen_state_->context_));
         }
         argument_list.emplace_back(ptr_lv);
         const auto len_lv = cgen_state_->emitExternalCall(
             "array_size",
             get_int_type(32, cgen_state_->context_),
             {arg_lvs.front(),
              posArg(arg),
              cgen_state_->llInt(log2_bytes(elem_ti.get_logical_size()))});
         auto cast_len_lv = cgen_state_->ir_builder_.CreateZExt(
             len_lv, get_int_type(64, cgen_state_->context_));
         argument_list.emplace_back(cast_len_lv);
       }
     }
   }
   return argument_list;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ArrayLoadCodegen CodeGenerator::codegenGeoArrayLoadAndNullcheck	(	llvm::Value *	byte_stream,
		llvm::Value *	pos,
		const SQLTypeInfo &	ti,
		CgenState *	cgen_state
	)

static

Definition at line 25 of file GeoIR.cpp.

References CgenState::array_load_cache_, CHECK, CgenState::context_, CgenState::emitExternalCall(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_type(), and kPOINT.

Referenced by spatial_type::PointAccessors::codegenLoads(), and spatial_type::Transform::codegenLoads().

                                                                                        {
   CHECK(byte_stream);
 
   const auto key = std::make_pair(byte_stream, pos);
   auto cache_itr = cgen_state->array_load_cache_.find(key);
   if (cache_itr != cgen_state->array_load_cache_.end()) {
     return cache_itr->second;
   }
   const bool is_nullable = !ti.get_notnull();
   CHECK(ti.get_type() == kPOINT);  // TODO: lift this
 
   auto pt_arr_buf =
       cgen_state->emitExternalCall("array_buff",
                                    llvm::Type::getInt8PtrTy(cgen_state->context_),
                                    {key.first, key.second});
   llvm::Value* pt_is_null{nullptr};
   if (is_nullable) {
     pt_is_null = cgen_state->emitExternalCall("point_coord_array_is_null",
                                               llvm::Type::getInt1Ty(cgen_state->context_),
                                               {key.first, key.second});
   }
   ArrayLoadCodegen arr_load{pt_arr_buf, nullptr, pt_is_null};
   cgen_state->array_load_cache_.insert(std::make_pair(key, arr_load));
   return arr_load;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenGeoBinOper	(	const Analyzer::GeoBinOper *	geo_expr,
		const CompilationOptions &	co
	)

private

Definition at line 263 of file GeoIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, codegenGeoArgs(), codegenGeosConstructorCall(), codegenGeosPredicateCall(), CgenState::context_, CompilationOptions::device_type, Geospatial::get_compression_scheme(), SQLTypeInfo::get_input_srid(), SQLTypeInfo::get_output_srid(), SQLTypeInfo::get_physical_coord_cols(), SQLTypeInfo::get_type(), Analyzer::Expr::get_type_info(), Analyzer::GeoBinOper::getArgs0(), Analyzer::GeoBinOper::getArgs1(), Analyzer::GeoBinOper::getOp(), Analyzer::GeoBinOper::getTypeInfo0(), Analyzer::GeoBinOper::getTypeInfo1(), GPU, Geospatial::GeoBase::kBUFFER, Geospatial::GeoBase::kCONCAVEHULL, Geospatial::GeoBase::kDIFFERENCE, Geospatial::GeoBase::kEQUALS, Geospatial::GeoBase::kINTERSECTION, Geospatial::GeoBase::kUNION, CgenState::llInt(), and SQLTypeInfo::transforms().

Referenced by codegen().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (co.device_type == ExecutorDeviceType::GPU) {
     throw QueryMustRunOnCpu();
   }
 #ifndef ENABLE_GEOS
   throw std::runtime_error("Geo operation requires GEOS support.");
 #endif
 
   auto argument_list = codegenGeoArgs(geo_expr->getArgs0(), co);
 
   // Basic set of arguments is currently common to all Geos_* func invocations:
   // op kind, type of the first geo arg0, geo arg0 components
   std::string func = "Geos_Wkb"s;
   if (geo_expr->getTypeInfo0().transforms() || geo_expr->get_type_info().transforms()) {
     // If there is a transform on the argument and/or on the result of the operation,
     // verify that the argument's output srid is equal to result's input srid
     if (geo_expr->getTypeInfo0().get_output_srid() !=
         geo_expr->get_type_info().get_input_srid()) {
       throw std::runtime_error("GEOS runtime: input/output srids have to match.");
     }
   }
   // Prepend arg0 geo SQLType
   argument_list.insert(
       argument_list.begin(),
       cgen_state_->llInt(static_cast<int>(geo_expr->getTypeInfo0().get_type())));
   // Prepend geo expr op
   argument_list.insert(argument_list.begin(),
                        cgen_state_->llInt(static_cast<int>(geo_expr->getOp())));
   for (auto i = 3; i > geo_expr->getTypeInfo0().get_physical_coord_cols(); i--) {
     argument_list.insert(argument_list.end(),
                          llvm::ConstantPointerNull::get(
                              llvm::Type::getInt32PtrTy(cgen_state_->context_, 0)));
     argument_list.insert(argument_list.end(), cgen_state_->llInt(int64_t(0)));
   }
   // Append geo expr compression
   argument_list.insert(
       argument_list.end(),
       cgen_state_->llInt(static_cast<int>(
           Geospatial::get_compression_scheme(geo_expr->getTypeInfo0()))));
   // Append geo expr input srid
   argument_list.insert(
       argument_list.end(),
       cgen_state_->llInt(static_cast<int>(geo_expr->getTypeInfo0().get_input_srid())));
   // Append geo expr output srid
   argument_list.insert(
       argument_list.end(),
       cgen_state_->llInt(static_cast<int>(geo_expr->getTypeInfo0().get_output_srid())));
 
   auto arg1_list = codegenGeoArgs(geo_expr->getArgs1(), co);
 
   if (geo_expr->getOp() == Geospatial::GeoBase::GeoOp::kDIFFERENCE ||
       geo_expr->getOp() == Geospatial::GeoBase::GeoOp::kINTERSECTION ||
       geo_expr->getOp() == Geospatial::GeoBase::GeoOp::kUNION ||
       geo_expr->getOp() == Geospatial::GeoBase::GeoOp::kEQUALS) {
     func += "_Wkb"s;
     if (geo_expr->getOp() == Geospatial::GeoBase::GeoOp::kEQUALS) {
       func += "_Predicate"s;
     }
     // Prepend arg1 geo SQLType
     arg1_list.insert(
         arg1_list.begin(),
         cgen_state_->llInt(static_cast<int>(geo_expr->getTypeInfo1().get_type())));
     for (auto i = 3; i > geo_expr->getTypeInfo1().get_physical_coord_cols(); i--) {
       arg1_list.insert(arg1_list.end(),
                        llvm::ConstantPointerNull::get(
                            llvm::Type::getInt32PtrTy(cgen_state_->context_, 0)));
       arg1_list.insert(arg1_list.end(), cgen_state_->llInt(int64_t(0)));
     }
     // Append geo expr compression
     arg1_list.insert(arg1_list.end(),
                      cgen_state_->llInt(static_cast<int>(
                          Geospatial::get_compression_scheme(geo_expr->getTypeInfo1()))));
     // Append geo expr input srid
     arg1_list.insert(arg1_list.end(),
                      cgen_state_->llInt(geo_expr->getTypeInfo1().get_input_srid()));
     // Append geo expr output srid
     arg1_list.insert(arg1_list.end(),
                      cgen_state_->llInt(geo_expr->getTypeInfo1().get_output_srid()));
   } else if (geo_expr->getOp() == Geospatial::GeoBase::GeoOp::kBUFFER) {
     // Extra argument in this case is double
     func += "_double"s;
   } else if (geo_expr->getOp() == Geospatial::GeoBase::GeoOp::kCONCAVEHULL) {
 #if (GEOS_VERSION_MAJOR > 3) || (GEOS_VERSION_MAJOR == 3 && GEOS_VERSION_MINOR >= 11)
     // Extra argument in this case is double
     func += "_double"s;
 #else
     throw std::runtime_error("ST_ConcaveHull requires GEOS 3.11 or newer");
 #endif
   } else {
     throw std::runtime_error("Unsupported binary geo operation.");
   }
 
   // Append arg1 to the list
   argument_list.insert(argument_list.end(), arg1_list.begin(), arg1_list.end());
 
   // Deal with binary geo predicates
   if (geo_expr->getOp() == Geospatial::GeoBase::GeoOp::kEQUALS) {
     return codegenGeosPredicateCall(func, argument_list, co);
   }
 
   auto result_srid = cgen_state_->llInt(geo_expr->get_type_info().get_output_srid());
 
   return codegenGeosConstructorCall(func, argument_list, result_srid, co);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenGeoColumnVar	(	const Analyzer::GeoColumnVar *	geo_col_var,
		const bool	fetch_columns,
		const CompilationOptions &	co
	)

private

Definition at line 54 of file GeoIR.cpp.

References CHECK, CHECK_EQ, codegen(), shared::ColumnKey::column_id, get_column_descriptor(), Analyzer::ColumnVar::get_rte_idx(), Analyzer::Expr::get_type_info(), Analyzer::ColumnVar::getColumnKey(), kLINESTRING, kMULTILINESTRING, kMULTIPOLYGON, kPOINT, kPOLYGON, Analyzer::ColumnVar::toString(), and UNREACHABLE.

Referenced by codegen().

                                   {
   auto generate_column_lvs = [this, geo_col_var, &co](const int column_id) {
     auto column_key = geo_col_var->getColumnKey();
     column_key.column_id = column_id;
 
     auto cd = get_column_descriptor(column_key);
     CHECK(cd);
 
     const auto col_var =
         Analyzer::ColumnVar(cd->columnType, column_key, geo_col_var->get_rte_idx());
     const auto lv_vec = codegen(&col_var, /*fetch_columns=*/true, co);
     CHECK_EQ(lv_vec.size(), size_t(1));  // ptr
     return lv_vec;
   };
 
   const auto& ti = geo_col_var->get_type_info();
   switch (ti.get_type()) {
     case kPOINT:
     case kLINESTRING:
     case kMULTILINESTRING:
     case kPOLYGON:
     case kMULTIPOLYGON: {
       std::vector<llvm::Value*> geo_lvs;
       // iterate over physical columns
       for (int i = 0; i < ti.get_physical_coord_cols(); i++) {
         const auto column_id = geo_col_var->getColumnKey().column_id + 1 + i;
         const auto lvs = generate_column_lvs(column_id);
         CHECK_EQ(lvs.size(), size_t(1));  // expecting ptr for each column
         geo_lvs.insert(geo_lvs.end(), lvs.begin(), lvs.end());
       }
 
       return geo_lvs;
     }
     default:
       UNREACHABLE() << geo_col_var->toString();
   }
   UNREACHABLE();
   return {};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenGeoConstant	(	const Analyzer::GeoConstant *	geo_constant,
		const CompilationOptions &	co
	)

private

Definition at line 111 of file GeoIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK_EQ, codegen(), CgenState::context_, CgenState::ir_builder_, Analyzer::GeoConstant::makePhysicalConstant(), and Analyzer::GeoConstant::physicalCols().

Referenced by codegen(), and codegenGeoExpr().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
 
   std::vector<llvm::Value*> ret;
   for (size_t i = 0; i < geo_constant->physicalCols(); i++) {
     auto physical_constant = geo_constant->makePhysicalConstant(i);
     auto operand_lvs = codegen(physical_constant.get(), /*fetch_columns=*/true, co);
     CHECK_EQ(operand_lvs.size(), size_t(2));
     auto array_buff_lv = operand_lvs[0];
     if (i > 0) {
       array_buff_lv = cgen_state_->ir_builder_.CreateBitCast(
           operand_lvs[0], llvm::Type::getInt8PtrTy(cgen_state_->context_));
     }
     ret.push_back(array_buff_lv);
     ret.push_back(operand_lvs[1]);
   }
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenGeoExpr	(	const Analyzer::GeoExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 97 of file GeoIR.cpp.

References codegenGeoConstant(), codegenGeoOperator(), Analyzer::Expr::toString(), and UNREACHABLE.

Referenced by codegen().

                                                                                       {
   auto geo_constant = dynamic_cast<const Analyzer::GeoConstant*>(expr);
   if (geo_constant) {
     return codegenGeoConstant(geo_constant, co);
   }
   auto geo_operator = dynamic_cast<const Analyzer::GeoOperator*>(expr);
   if (geo_operator) {
     return codegenGeoOperator(geo_operator, co);
   }
   UNREACHABLE() << expr->toString();
   return {};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CodeGenerator::codegenGeoLineStringArgs	(	const std::string &	udf_func_name,
		size_t	param_num,
		llvm::Value *	line_string_buf,
		llvm::Value *	line_string_size,
		llvm::Value *	compression,
		llvm::Value *	input_srid,
		llvm::Value *	output_srid,
		std::vector< llvm::Value * > &	output_args
	)

private

Definition at line 972 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, createLineStringStructType(), and CgenState::ir_builder_.

Referenced by codegenFunctionOperCastArgs().

                                                                                  {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(line_string_buf);
   CHECK(line_string_size);
   CHECK(compression);
   CHECK(input_srid);
   CHECK(output_srid);
 
   auto line_string_abstraction = createLineStringStructType(udf_func_name, param_num);
   auto alloc_mem =
       cgen_state_->ir_builder_.CreateAlloca(line_string_abstraction, nullptr);
 
   auto line_string_buf_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(line_string_abstraction, alloc_mem, 0);
   cgen_state_->ir_builder_.CreateStore(line_string_buf, line_string_buf_ptr);
 
   auto line_string_size_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(line_string_abstraction, alloc_mem, 1);
   cgen_state_->ir_builder_.CreateStore(line_string_size, line_string_size_ptr);
 
   auto line_string_compression_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(line_string_abstraction, alloc_mem, 2);
   cgen_state_->ir_builder_.CreateStore(compression, line_string_compression_ptr);
 
   auto input_srid_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(line_string_abstraction, alloc_mem, 3);
   cgen_state_->ir_builder_.CreateStore(input_srid, input_srid_ptr);
 
   auto output_srid_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(line_string_abstraction, alloc_mem, 4);
   cgen_state_->ir_builder_.CreateStore(output_srid, output_srid_ptr);
 
   output_args.push_back(alloc_mem);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CodeGenerator::codegenGeoMultiLineStringArgs	(	const std::string &	udf_func_name,
		size_t	param_num,
		llvm::Value *	multi_linestring_coords,
		llvm::Value *	multi_linestring_size,
		llvm::Value *	linestring_sizes,
		llvm::Value *	linestring_sizes_size,
		llvm::Value *	compression,
		llvm::Value *	input_srid,
		llvm::Value *	output_srid,
		std::vector< llvm::Value * > &	output_args
	)

private

Definition at line 1066 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, createMultiLineStringStructType(), and CgenState::ir_builder_.

Referenced by codegenFunctionOperCastArgs().

                                         {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(multi_linestring_coords);
   CHECK(multi_linestring_coords_size);
   CHECK(linestring_sizes);
   CHECK(linestring_sizes_size);
   CHECK(compression);
   CHECK(input_srid);
   CHECK(output_srid);
 
   auto multi_linestring_abstraction =
       createMultiLineStringStructType(udf_func_name, param_num);
   auto alloc_mem =
       cgen_state_->ir_builder_.CreateAlloca(multi_linestring_abstraction, nullptr);
 
   auto multi_linestring_coords_ptr = cgen_state_->ir_builder_.CreateStructGEP(
       multi_linestring_abstraction, alloc_mem, 0);
   cgen_state_->ir_builder_.CreateStore(multi_linestring_coords,
                                        multi_linestring_coords_ptr);
 
   auto multi_linestring_coords_size_ptr = cgen_state_->ir_builder_.CreateStructGEP(
       multi_linestring_abstraction, alloc_mem, 1);
   cgen_state_->ir_builder_.CreateStore(multi_linestring_coords_size,
                                        multi_linestring_coords_size_ptr);
 
   auto linestring_sizes_ptr = cgen_state_->ir_builder_.CreateStructGEP(
       multi_linestring_abstraction, alloc_mem, 2);
   const auto linestring_sizes_ptr_ty =
       llvm::dyn_cast<llvm::PointerType>(linestring_sizes_ptr->getType());
   CHECK(linestring_sizes_ptr_ty);
   cgen_state_->ir_builder_.CreateStore(
       cgen_state_->ir_builder_.CreateBitCast(
           linestring_sizes, linestring_sizes_ptr_ty->getPointerElementType()),
       linestring_sizes_ptr);
 
   auto linestring_sizes_size_ptr = cgen_state_->ir_builder_.CreateStructGEP(
       multi_linestring_abstraction, alloc_mem, 3);
   cgen_state_->ir_builder_.CreateStore(linestring_sizes_size, linestring_sizes_size_ptr);
 
   auto multi_linestring_compression_ptr = cgen_state_->ir_builder_.CreateStructGEP(
       multi_linestring_abstraction, alloc_mem, 4);
   cgen_state_->ir_builder_.CreateStore(compression, multi_linestring_compression_ptr);
 
   auto input_srid_ptr = cgen_state_->ir_builder_.CreateStructGEP(
       multi_linestring_abstraction, alloc_mem, 5);
   cgen_state_->ir_builder_.CreateStore(input_srid, input_srid_ptr);
 
   auto output_srid_ptr = cgen_state_->ir_builder_.CreateStructGEP(
       multi_linestring_abstraction, alloc_mem, 6);
   cgen_state_->ir_builder_.CreateStore(output_srid, output_srid_ptr);
 
   output_args.push_back(alloc_mem);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CodeGenerator::codegenGeoMultiPointArgs	(	const std::string &	udf_func_name,
		size_t	param_num,
		llvm::Value *	multi_point_buf,
		llvm::Value *	multi_point_size,
		llvm::Value *	compression,
		llvm::Value *	input_srid,
		llvm::Value *	output_srid,
		std::vector< llvm::Value * > &	output_args
	)

private

Definition at line 881 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, createMultiPointStructType(), and CgenState::ir_builder_.

Referenced by codegenFunctionOperCastArgs().

                                                                                  {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(multi_point_buf);
   CHECK(multi_point_size);
   CHECK(compression);
   CHECK(input_srid);
   CHECK(output_srid);
 
   auto multi_point_abstraction = createMultiPointStructType(udf_func_name, param_num);
   auto alloc_mem =
       cgen_state_->ir_builder_.CreateAlloca(multi_point_abstraction, nullptr);
 
   auto multi_point_buf_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(multi_point_abstraction, alloc_mem, 0);
   cgen_state_->ir_builder_.CreateStore(multi_point_buf, multi_point_buf_ptr);
 
   auto multi_point_size_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(multi_point_abstraction, alloc_mem, 1);
   cgen_state_->ir_builder_.CreateStore(multi_point_size, multi_point_size_ptr);
 
   auto compression_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(multi_point_abstraction, alloc_mem, 2);
   cgen_state_->ir_builder_.CreateStore(compression, compression_ptr);
 
   auto input_srid_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(multi_point_abstraction, alloc_mem, 3);
   cgen_state_->ir_builder_.CreateStore(input_srid, input_srid_ptr);
 
   auto output_srid_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(multi_point_abstraction, alloc_mem, 4);
   cgen_state_->ir_builder_.CreateStore(output_srid, output_srid_ptr);
 
   output_args.push_back(alloc_mem);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CodeGenerator::codegenGeoMultiPolygonArgs	(	const std::string &	udf_func_name,
		size_t	param_num,
		llvm::Value *	polygon_coords,
		llvm::Value *	polygon_coords_size,
		llvm::Value *	ring_sizes_buf,
		llvm::Value *	ring_sizes,
		llvm::Value *	polygon_bounds,
		llvm::Value *	polygon_bounds_sizes,
		llvm::Value *	compression,
		llvm::Value *	input_srid,
		llvm::Value *	output_srid,
		std::vector< llvm::Value * > &	output_args
	)

private

Definition at line 1289 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, createMultiPolygonStructType(), and CgenState::ir_builder_.

Referenced by codegenFunctionOperCastArgs().

                                                                                    {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(polygon_coords);
   CHECK(polygon_coords_size);
   CHECK(ring_sizes_buf);
   CHECK(ring_sizes);
   CHECK(polygon_bounds);
   CHECK(polygon_bounds_sizes);
   CHECK(compression);
   CHECK(input_srid);
   CHECK(output_srid);
 
   auto& builder = cgen_state_->ir_builder_;
 
   auto multi_polygon_abstraction = createMultiPolygonStructType(udf_func_name, param_num);
   auto alloc_mem = builder.CreateAlloca(multi_polygon_abstraction, nullptr);
 
   const auto polygon_coords_ptr =
       builder.CreateStructGEP(multi_polygon_abstraction, alloc_mem, 0);
   builder.CreateStore(polygon_coords, polygon_coords_ptr);
 
   const auto polygon_coords_size_ptr =
       builder.CreateStructGEP(multi_polygon_abstraction, alloc_mem, 1);
   builder.CreateStore(polygon_coords_size, polygon_coords_size_ptr);
 
   const auto ring_sizes_buf_ptr =
       builder.CreateStructGEP(multi_polygon_abstraction, alloc_mem, 2);
   const auto ring_sizes_ptr_ty =
       llvm::dyn_cast<llvm::PointerType>(ring_sizes_buf_ptr->getType());
   CHECK(ring_sizes_ptr_ty);
   builder.CreateStore(
       builder.CreateBitCast(ring_sizes_buf, ring_sizes_ptr_ty->getPointerElementType()),
       ring_sizes_buf_ptr);
 
   const auto ring_sizes_ptr =
       builder.CreateStructGEP(multi_polygon_abstraction, alloc_mem, 3);
   builder.CreateStore(ring_sizes, ring_sizes_ptr);
 
   const auto polygon_bounds_buf_ptr =
       builder.CreateStructGEP(multi_polygon_abstraction, alloc_mem, 4);
   const auto bounds_ptr_ty =
       llvm::dyn_cast<llvm::PointerType>(polygon_bounds_buf_ptr->getType());
   CHECK(bounds_ptr_ty);
   builder.CreateStore(
       builder.CreateBitCast(polygon_bounds, bounds_ptr_ty->getPointerElementType()),
       polygon_bounds_buf_ptr);
 
   const auto polygon_bounds_sizes_ptr =
       builder.CreateStructGEP(multi_polygon_abstraction, alloc_mem, 5);
   builder.CreateStore(polygon_bounds_sizes, polygon_bounds_sizes_ptr);
 
   const auto polygon_compression_ptr =
       builder.CreateStructGEP(multi_polygon_abstraction, alloc_mem, 6);
   builder.CreateStore(compression, polygon_compression_ptr);
 
   const auto input_srid_ptr =
       builder.CreateStructGEP(multi_polygon_abstraction, alloc_mem, 7);
   builder.CreateStore(input_srid, input_srid_ptr);
 
   const auto output_srid_ptr =
       builder.CreateStructGEP(multi_polygon_abstraction, alloc_mem, 8);
   builder.CreateStore(output_srid, output_srid_ptr);
 
   output_args.push_back(alloc_mem);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenGeoOperator	(	const Analyzer::GeoOperator *	geo_operator,
		const CompilationOptions &	co
	)

private

Definition at line 149 of file GeoIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegen(), executor(), CgenState::geo_target_cache_, Analyzer::GeoOperator::getName(), spatial_type::Codegen::init(), anonymous_namespace{GeoIR.cpp}::mark_logical_column_to_fetch(), plan_state_, posArg(), and Analyzer::GeoOperator::toString().

Referenced by codegenGeoExpr().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
 
   if (geo_operator->getName() == "ST_X" || geo_operator->getName() == "ST_Y") {
     const auto key = geo_operator->toString();
     auto geo_target_cache_it = cgen_state_->geo_target_cache_.find(key);
     if (geo_target_cache_it != cgen_state_->geo_target_cache_.end()) {
       return {geo_target_cache_it->second};
     }
   }
 
   auto op_codegen = spatial_type::Codegen::init(geo_operator);
   CHECK(op_codegen);
   // we fetch all physical columns, so we sync the logical geo column w/ it
   mark_logical_column_to_fetch(geo_operator, plan_state_);
 
   std::vector<llvm::Value*> load_lvs;
   std::vector<llvm::Value*> pos_lvs;
   for (size_t i = 0; i < op_codegen->size(); i++) {
     auto intermediate_lvs =
         codegen(op_codegen->getOperand(i), /*fetch_columns=*/true, co);
     load_lvs.insert(load_lvs.end(), intermediate_lvs.begin(), intermediate_lvs.end());
     pos_lvs.push_back(posArg(op_codegen->getOperand(i)));
   }
 
   auto [arg_lvs, null_lv] = op_codegen->codegenLoads(load_lvs, pos_lvs, cgen_state_);
 
   std::unique_ptr<CodeGenerator::NullCheckCodegen> nullcheck_codegen =
       op_codegen->getNullCheckCodegen(null_lv, cgen_state_, executor());
   return op_codegen->codegen(arg_lvs, nullcheck_codegen.get(), cgen_state_, co);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CodeGenerator::codegenGeoPointArgs	(	const std::string &	udf_func_name,
		size_t	param_num,
		llvm::Value *	point_buf,
		llvm::Value *	point_size,
		llvm::Value *	compression,
		llvm::Value *	input_srid,
		llvm::Value *	output_srid,
		std::vector< llvm::Value * > &	output_args
	)

private

Definition at line 791 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, createPointStructType(), and CgenState::ir_builder_.

Referenced by codegenFunctionOperCastArgs().

                                                                             {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(point_buf);
   CHECK(point_size);
   CHECK(compression);
   CHECK(input_srid);
   CHECK(output_srid);
 
   auto point_abstraction = createPointStructType(udf_func_name, param_num);
   auto alloc_mem = cgen_state_->ir_builder_.CreateAlloca(point_abstraction, nullptr);
 
   auto point_buf_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(point_abstraction, alloc_mem, 0);
   cgen_state_->ir_builder_.CreateStore(point_buf, point_buf_ptr);
 
   auto point_size_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(point_abstraction, alloc_mem, 1);
   cgen_state_->ir_builder_.CreateStore(point_size, point_size_ptr);
 
   auto point_compression_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(point_abstraction, alloc_mem, 2);
   cgen_state_->ir_builder_.CreateStore(compression, point_compression_ptr);
 
   auto input_srid_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(point_abstraction, alloc_mem, 3);
   cgen_state_->ir_builder_.CreateStore(input_srid, input_srid_ptr);
 
   auto output_srid_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(point_abstraction, alloc_mem, 4);
   cgen_state_->ir_builder_.CreateStore(output_srid, output_srid_ptr);
 
   output_args.push_back(alloc_mem);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CodeGenerator::codegenGeoPolygonArgs	(	const std::string &	udf_func_name,
		size_t	param_num,
		llvm::Value *	polygon_buf,
		llvm::Value *	polygon_size,
		llvm::Value *	ring_sizes_buf,
		llvm::Value *	num_rings,
		llvm::Value *	compression,
		llvm::Value *	input_srid,
		llvm::Value *	output_srid,
		std::vector< llvm::Value * > &	output_args
	)

private

Definition at line 1182 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, createPolygonStructType(), and CgenState::ir_builder_.

Referenced by codegenFunctionOperCastArgs().

                                                                               {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(polygon_buf);
   CHECK(polygon_size);
   CHECK(ring_sizes_buf);
   CHECK(num_rings);
   CHECK(compression);
   CHECK(input_srid);
   CHECK(output_srid);
 
   auto& builder = cgen_state_->ir_builder_;
 
   auto polygon_abstraction = createPolygonStructType(udf_func_name, param_num);
   auto alloc_mem = builder.CreateAlloca(polygon_abstraction, nullptr);
 
   const auto polygon_buf_ptr = builder.CreateStructGEP(polygon_abstraction, alloc_mem, 0);
   builder.CreateStore(polygon_buf, polygon_buf_ptr);
 
   const auto polygon_size_ptr =
       builder.CreateStructGEP(polygon_abstraction, alloc_mem, 1);
   builder.CreateStore(polygon_size, polygon_size_ptr);
 
   const auto ring_sizes_buf_ptr =
       builder.CreateStructGEP(polygon_abstraction, alloc_mem, 2);
   const auto ring_sizes_ptr_ty =
       llvm::dyn_cast<llvm::PointerType>(ring_sizes_buf_ptr->getType());
   CHECK(ring_sizes_ptr_ty);
   builder.CreateStore(
       builder.CreateBitCast(ring_sizes_buf, ring_sizes_ptr_ty->getPointerElementType()),
       ring_sizes_buf_ptr);
 
   const auto ring_size_ptr = builder.CreateStructGEP(polygon_abstraction, alloc_mem, 3);
   builder.CreateStore(num_rings, ring_size_ptr);
 
   const auto polygon_compression_ptr =
       builder.CreateStructGEP(polygon_abstraction, alloc_mem, 4);
   builder.CreateStore(compression, polygon_compression_ptr);
 
   const auto input_srid_ptr = builder.CreateStructGEP(polygon_abstraction, alloc_mem, 5);
   builder.CreateStore(input_srid, input_srid_ptr);
 
   const auto output_srid_ptr = builder.CreateStructGEP(polygon_abstraction, alloc_mem, 6);
   builder.CreateStore(output_srid, output_srid_ptr);
 
   output_args.push_back(alloc_mem);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenGeosConstructorCall	(	const std::string &	func,
		std::vector< llvm::Value * >	argument_list,
		llvm::Value *	result_srid,
		const CompilationOptions &	co
	)

private

Definition at line 485 of file GeoIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CgenState::context_, CgenState::current_func_, CgenState::emitExternalCall(), executor(), get_int_type(), CgenState::ir_builder_, CgenState::llBool(), CgenState::llInt(), CgenState::needs_error_check_, and CgenState::needs_geos_.

Referenced by codegenGeoBinOper(), and codegenGeoUOper().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   // Create output buffer pointers, append pointers to output args to
   auto i8_type = get_int_type(8, cgen_state_->context_);
   auto i32_type = get_int_type(32, cgen_state_->context_);
   auto i64_type = get_int_type(64, cgen_state_->context_);
   auto pi8_type = llvm::PointerType::get(i8_type, 0);
   auto pi32_type = llvm::PointerType::get(i32_type, 0);
 
   auto result_type =
       cgen_state_->ir_builder_.CreateAlloca(i32_type, nullptr, "result_type");
   auto result_coords =
       cgen_state_->ir_builder_.CreateAlloca(pi8_type, nullptr, "result_coords");
   auto result_coords_size =
       cgen_state_->ir_builder_.CreateAlloca(i64_type, nullptr, "result_coords_size");
   auto result_ring_sizes =
       cgen_state_->ir_builder_.CreateAlloca(pi32_type, nullptr, "result_ring_sizes");
   auto result_ring_sizes_size =
       cgen_state_->ir_builder_.CreateAlloca(i64_type, nullptr, "result_ring_sizes_size");
   auto result_poly_rings =
       cgen_state_->ir_builder_.CreateAlloca(pi32_type, nullptr, "result_poly_rings");
   auto result_poly_rings_size =
       cgen_state_->ir_builder_.CreateAlloca(i64_type, nullptr, "result_poly_rings_size");
 
   argument_list.emplace_back(result_type);
   argument_list.emplace_back(result_coords);
   argument_list.emplace_back(result_coords_size);
   argument_list.emplace_back(result_ring_sizes);
   argument_list.emplace_back(result_ring_sizes_size);
   argument_list.emplace_back(result_poly_rings);
   argument_list.emplace_back(result_poly_rings_size);
   argument_list.emplace_back(result_srid);
 
   // Generate call to GEOS wrapper
   cgen_state_->needs_geos_ = true;
   auto status_lv = cgen_state_->emitExternalCall(
       func, llvm::Type::getInt1Ty(cgen_state_->context_), argument_list);
   // Need to check the status and throw an error if this call has failed.
   llvm::BasicBlock* geos_ok_bb{nullptr};
   llvm::BasicBlock* geos_fail_bb{nullptr};
   geos_ok_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "geos_ok_bb", cgen_state_->current_func_);
   geos_fail_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "geos_fail_bb", cgen_state_->current_func_);
   if (!status_lv) {
     status_lv = cgen_state_->llBool(false);
   }
   cgen_state_->ir_builder_.CreateCondBr(status_lv, geos_ok_bb, geos_fail_bb);
   cgen_state_->ir_builder_.SetInsertPoint(geos_fail_bb);
   cgen_state_->ir_builder_.CreateRet(cgen_state_->llInt(int32_t(ErrorCode::GEOS)));
   cgen_state_->needs_error_check_ = true;
   cgen_state_->ir_builder_.SetInsertPoint(geos_ok_bb);
 
   // TODO: Currently forcing the output to MULTIPOLYGON, but need to handle
   // other possible geometries that geos may return, e.g. a POINT, a LINESTRING
   // Need to handle empty result, e.g. empty intersection.
   // The type of result is returned in `result_type`
 
   // Load return values
   auto buf1 = cgen_state_->ir_builder_.CreateLoad(
       result_coords->getType()->getPointerElementType(), result_coords);
   auto buf1s = cgen_state_->ir_builder_.CreateLoad(
       result_coords_size->getType()->getPointerElementType(), result_coords_size);
   auto buf2 = cgen_state_->ir_builder_.CreateLoad(
       result_ring_sizes->getType()->getPointerElementType(), result_ring_sizes);
   auto buf2s = cgen_state_->ir_builder_.CreateLoad(
       result_ring_sizes_size->getType()->getPointerElementType(), result_ring_sizes_size);
   auto buf3 = cgen_state_->ir_builder_.CreateLoad(
       result_poly_rings->getType()->getPointerElementType(), result_poly_rings);
   auto buf3s = cgen_state_->ir_builder_.CreateLoad(
       result_poly_rings_size->getType()->getPointerElementType(), result_poly_rings_size);
 
   // generate register_buffer_with_executor_rsm() calls to register all output buffers
   cgen_state_->emitExternalCall(
       "register_buffer_with_executor_rsm",
       llvm::Type::getVoidTy(cgen_state_->context_),
       {cgen_state_->llInt(reinterpret_cast<int64_t>(executor())),
        cgen_state_->ir_builder_.CreatePointerCast(buf1, pi8_type)});
   cgen_state_->emitExternalCall(
       "register_buffer_with_executor_rsm",
       llvm::Type::getVoidTy(cgen_state_->context_),
       {cgen_state_->llInt(reinterpret_cast<int64_t>(executor())),
        cgen_state_->ir_builder_.CreatePointerCast(buf2, pi8_type)});
   cgen_state_->emitExternalCall(
       "register_buffer_with_executor_rsm",
       llvm::Type::getVoidTy(cgen_state_->context_),
       {cgen_state_->llInt(reinterpret_cast<int64_t>(executor())),
        cgen_state_->ir_builder_.CreatePointerCast(buf3, pi8_type)});
 
   return {cgen_state_->ir_builder_.CreatePointerCast(buf1, pi8_type),
           buf1s,
           cgen_state_->ir_builder_.CreatePointerCast(buf2, pi32_type),
           buf2s,
           cgen_state_->ir_builder_.CreatePointerCast(buf3, pi32_type),
           buf3s};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenGeosPredicateCall	(	const std::string &	func,
		std::vector< llvm::Value * >	argument_list,
		const CompilationOptions &	co
	)

private

Definition at line 452 of file GeoIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CgenState::context_, CgenState::current_func_, CgenState::emitExternalCall(), get_int_type(), CgenState::ir_builder_, CgenState::llBool(), CgenState::llInt(), CgenState::needs_error_check_, CgenState::needs_geos_, run_benchmark_import::res, and run_benchmark_import::result.

Referenced by codegenGeoBinOper(), and codegenGeoUOper().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto i8_type = get_int_type(8, cgen_state_->context_);
   auto result = cgen_state_->ir_builder_.CreateAlloca(i8_type, nullptr, "result");
   argument_list.emplace_back(result);
 
   // Generate call to GEOS wrapper
   cgen_state_->needs_geos_ = true;
   auto status_lv = cgen_state_->emitExternalCall(
       func, llvm::Type::getInt1Ty(cgen_state_->context_), argument_list);
   // Need to check the status and throw an error if this call has failed.
   llvm::BasicBlock* geos_pred_ok_bb{nullptr};
   llvm::BasicBlock* geos_pred_fail_bb{nullptr};
   geos_pred_ok_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "geos_pred_ok_bb", cgen_state_->current_func_);
   geos_pred_fail_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "geos_pred_fail_bb", cgen_state_->current_func_);
   if (!status_lv) {
     status_lv = cgen_state_->llBool(false);
   }
   cgen_state_->ir_builder_.CreateCondBr(status_lv, geos_pred_ok_bb, geos_pred_fail_bb);
   cgen_state_->ir_builder_.SetInsertPoint(geos_pred_fail_bb);
   cgen_state_->ir_builder_.CreateRet(cgen_state_->llInt(int32_t(ErrorCode::GEOS)));
   cgen_state_->needs_error_check_ = true;
   cgen_state_->ir_builder_.SetInsertPoint(geos_pred_ok_bb);
   auto res = cgen_state_->ir_builder_.CreateLoad(
       result->getType()->getPointerElementType(), result);
   return {res};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenGeoUOper	(	const Analyzer::GeoUOper *	geo_expr,
		const CompilationOptions &	co
	)

private

Definition at line 183 of file GeoIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, codegenGeoArgs(), codegenGeosConstructorCall(), codegenGeosPredicateCall(), CgenState::context_, CompilationOptions::device_type, Geospatial::get_compression_scheme(), SQLTypeInfo::get_input_srid(), SQLTypeInfo::get_output_srid(), SQLTypeInfo::get_physical_coord_cols(), SQLTypeInfo::get_type(), Analyzer::Expr::get_type_info(), Analyzer::GeoUOper::getArgs0(), Analyzer::GeoUOper::getOp(), Analyzer::GeoUOper::getTypeInfo0(), GPU, Geospatial::GeoBase::kCONVEXHULL, Geospatial::GeoBase::kISEMPTY, Geospatial::GeoBase::kISVALID, Geospatial::GeoBase::kPROJECTION, CgenState::llFp(), CgenState::llInt(), and SQLTypeInfo::transforms().

Referenced by codegen().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (co.device_type == ExecutorDeviceType::GPU) {
     if (geo_expr->getOp() != Geospatial::GeoBase::GeoOp::kPROJECTION) {
       throw QueryMustRunOnCpu();
     }
   }
 
   auto argument_list = codegenGeoArgs(geo_expr->getArgs0(), co);
 
   if (geo_expr->getOp() == Geospatial::GeoBase::GeoOp::kPROJECTION) {
     return argument_list;
   }
 
 #ifndef ENABLE_GEOS
   throw std::runtime_error("Geo operation requires GEOS support.");
 #endif
 
   // Basic set of arguments is currently common to all Geos_* func invocations:
   // op kind, type of the first geo arg0, geo arg0 components
   std::string func = "Geos_Wkb"s;
 
   if (geo_expr->getTypeInfo0().transforms() || geo_expr->get_type_info().transforms()) {
     // If there is a transform on the argument and/or on the result of the operation,
     // verify that the argument's output srid is equal to result's input srid
     if (geo_expr->getTypeInfo0().get_output_srid() !=
         geo_expr->get_type_info().get_input_srid()) {
       throw std::runtime_error("GEOS runtime: input/output srids have to match.");
     }
   }
   // Prepend arg0 geo SQLType
   argument_list.insert(
       argument_list.begin(),
       cgen_state_->llInt(static_cast<int>(geo_expr->getTypeInfo0().get_type())));
   // Prepend geo expr op
   argument_list.insert(argument_list.begin(),
                        cgen_state_->llInt(static_cast<int>(geo_expr->getOp())));
   for (auto i = 3; i > geo_expr->getTypeInfo0().get_physical_coord_cols(); i--) {
     argument_list.insert(argument_list.end(),
                          llvm::ConstantPointerNull::get(
                              llvm::Type::getInt32PtrTy(cgen_state_->context_, 0)));
     argument_list.insert(argument_list.end(), cgen_state_->llInt(int64_t(0)));
   }
   // Append geo expr compression
   argument_list.insert(
       argument_list.end(),
       cgen_state_->llInt(static_cast<int>(
           Geospatial::get_compression_scheme(geo_expr->getTypeInfo0()))));
   // Append geo expr input srid
   argument_list.insert(
       argument_list.end(),
       cgen_state_->llInt(static_cast<int>(geo_expr->getTypeInfo0().get_input_srid())));
   // Append geo expr output srid
   argument_list.insert(
       argument_list.end(),
       cgen_state_->llInt(static_cast<int>(geo_expr->getTypeInfo0().get_output_srid())));
 
   // Deal with unary geo predicates
   if (geo_expr->getOp() == Geospatial::GeoBase::GeoOp::kISEMPTY ||
       geo_expr->getOp() == Geospatial::GeoBase::GeoOp::kISVALID) {
     return codegenGeosPredicateCall(func, argument_list, co);
   }
 
   if (geo_expr->getOp() == Geospatial::GeoBase::GeoOp::kCONVEXHULL) {
     func += "_double"s;  // Use same interface as ST_ConcaveHull, with a dummy double
 
     // Insert that dummy double arg
     argument_list.insert(argument_list.end(), cgen_state_->llFp(double(0)));
 
     auto result_srid = cgen_state_->llInt(geo_expr->get_type_info().get_output_srid());
 
     return codegenGeosConstructorCall(func, argument_list, result_srid, co);
   }
 
   throw std::runtime_error("Unsupported unary geo operation.");
   return {};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenHoistedConstants	(	const std::vector< const Analyzer::Constant * > &	constants,
		const EncodingType	enc_type,
		const shared::StringDictKey &	dict_id
	)

Definition at line 373 of file ConstantIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, CHECK_GE, codegenHoistedConstantsLoads(), codegenHoistedConstantsPlaceholders(), Analyzer::Expr::get_type_info(), CgenState::getOrAddLiteral(), and CgenState::query_func_literal_loads_.

Referenced by TreeModelPredictionMgr::codegen(), codegen(), CodegenUtil::createPtrWithHoistedMemoryAddr(), CodegenUtil::hoistLiteral(), and InValuesBitmap::prepareBitIsSetParams().

                                         {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(!constants.empty());
   const auto& type_info = constants.front()->get_type_info();
   checked_int16_t checked_lit_off{0};
   size_t next_lit_bytes{0};
   int16_t lit_off{-1};
   size_t lit_bytes;
   try {
     // currently, we assume that `constants.size()` indicates the number of devices
     // which is equivalent to the total number of devices that a system has
     // so we need to revisit this to support the selection of devices to execute
     // the query (i.e., use GPU 1 and 4 to execute the query among eight GPUs)
     // todo (yoonmin) : indicate a set of devices to hoist a literal
     for (size_t device_id = 0; device_id < constants.size(); ++device_id) {
       const auto constant = constants[device_id];
       const auto& crt_type_info = constant->get_type_info();
       CHECK(type_info == crt_type_info);
       std::tie(checked_lit_off, next_lit_bytes) =
           cgen_state_->getOrAddLiteral(constant, enc_type, dict_id, device_id);
       if (device_id) {
         CHECK_EQ(lit_off, checked_lit_off);
         CHECK_EQ(lit_bytes, next_lit_bytes);
       } else {
         lit_off = static_cast<int16_t>(checked_lit_off);
         lit_bytes = next_lit_bytes;
       }
     }
   } catch (const std::range_error& e) {
     // detect literal buffer overflow when trying to
     // assign literal buf offset which is not in a valid range
     // to checked_type variable
     throw TooManyLiterals();
   }
   CHECK_GE(lit_off, 0);
   std::vector<llvm::Value*> hoisted_literal_loads;
   auto entry = cgen_state_->query_func_literal_loads_.find(lit_off);
 
   if (entry == cgen_state_->query_func_literal_loads_.end()) {
     hoisted_literal_loads =
         codegenHoistedConstantsLoads(type_info, enc_type, dict_id, lit_off, lit_bytes);
     cgen_state_->query_func_literal_loads_[lit_off] = hoisted_literal_loads;
   } else {
     hoisted_literal_loads = entry->second;
   }
 
   std::vector<llvm::Value*> literal_placeholders = codegenHoistedConstantsPlaceholders(
       type_info, enc_type, lit_off, hoisted_literal_loads);
   return literal_placeholders;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenHoistedConstantsLoads	(	const SQLTypeInfo &	type_info,
		const EncodingType	enc_type,
		const shared::StringDictKey &	dict_id,
		const int16_t	lit_off,
		const size_t	lit_bytes
	)

private

Definition at line 142 of file ConstantIR.cpp.

References AUTOMATIC_IR_METADATA, shared::bit_cast(), cgen_state_, CHECK, CHECK_EQ, CgenState::context_, CgenState::emitEntryCall(), logger::ERROR, g_allow_invalid_literal_buffer_reads, get_arg_by_name(), get_bit_width(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_dimension(), get_int_type(), anonymous_namespace{ColumnIR.cpp}::get_phys_int_type(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), CgenState::inlineIntNull(), SQLTypeInfo::is_array(), SQLTypeInfo::is_boolean(), SQLTypeInfo::is_decimal(), SQLTypeInfo::is_geometry(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_string(), SQLTypeInfo::is_time(), SQLTypeInfo::is_timeinterval(), kDOUBLE, kENCODING_DICT, kENCODING_GEOINT, kENCODING_NONE, kFLOAT, kTINYINT, CgenState::literalBytes(), CgenState::llInt(), LOG, CgenState::query_func_, CgenState::query_func_entry_ir_builder_, to_string(), SQLTypeInfo::to_string(), and toString().

Referenced by codegenHoistedConstants().

                             {
   AUTOMATIC_IR_METADATA(cgen_state_);
   std::string literal_name = "literal_" + std::to_string(lit_off);
   auto lit_buff_query_func_lv = get_arg_by_name(cgen_state_->query_func_, "literals");
   const auto lit_buf_start = cgen_state_->query_func_entry_ir_builder_.CreateGEP(
       lit_buff_query_func_lv->getType()->getScalarType()->getPointerElementType(),
       lit_buff_query_func_lv,
       cgen_state_->llInt(lit_off));
   CHECK(!type_info.is_geometry());
   if (type_info.is_string() && enc_type != kENCODING_DICT) {
     CHECK_EQ(kENCODING_NONE, type_info.get_compression());
     CHECK_EQ(size_t(4),
              CgenState::literalBytes(CgenState::LiteralValue(std::string(""))));
     auto off_and_len_ptr = cgen_state_->query_func_entry_ir_builder_.CreateBitCast(
         lit_buf_start,
         llvm::PointerType::get(get_int_type(32, cgen_state_->context_), 0));
     // packed offset + length, 16 bits each
     auto off_and_len = cgen_state_->query_func_entry_ir_builder_.CreateLoad(
         off_and_len_ptr->getType()->getPointerElementType(), off_and_len_ptr);
     auto off_lv = cgen_state_->query_func_entry_ir_builder_.CreateLShr(
         cgen_state_->query_func_entry_ir_builder_.CreateAnd(
             off_and_len, cgen_state_->llInt(int32_t(0xffff0000))),
         cgen_state_->llInt(int32_t(16)));
     auto len_lv = cgen_state_->query_func_entry_ir_builder_.CreateAnd(
         off_and_len, cgen_state_->llInt(int32_t(0x0000ffff)));
 
     auto var_start = cgen_state_->llInt(int64_t(0));
     auto var_start_address = cgen_state_->query_func_entry_ir_builder_.CreateGEP(
         lit_buff_query_func_lv->getType()->getScalarType()->getPointerElementType(),
         lit_buff_query_func_lv,
         off_lv);
     auto var_length = len_lv;
 
     var_start->setName(literal_name + "_start");
     var_start_address->setName(literal_name + "_start_address");
     var_length->setName(literal_name + "_length");
 
     return {var_start, var_start_address, var_length};
   } else if (type_info.is_array() &&
              (enc_type == kENCODING_NONE || enc_type == kENCODING_GEOINT)) {
     if (enc_type == kENCODING_NONE) {
       CHECK_EQ(kENCODING_NONE, type_info.get_compression());
     } else if (enc_type == kENCODING_GEOINT) {
       CHECK_EQ(kENCODING_GEOINT, type_info.get_compression());
       CHECK_EQ(kTINYINT, type_info.get_subtype());
     }
 
     auto off_and_len_ptr = cgen_state_->query_func_entry_ir_builder_.CreateBitCast(
         lit_buf_start,
         llvm::PointerType::get(get_int_type(32, cgen_state_->context_), 0));
     // packed offset + length, 16 bits each
     auto off_and_len = cgen_state_->query_func_entry_ir_builder_.CreateLoad(
         off_and_len_ptr->getType()->getPointerElementType(), off_and_len_ptr);
     auto off_lv = cgen_state_->query_func_entry_ir_builder_.CreateLShr(
         cgen_state_->query_func_entry_ir_builder_.CreateAnd(
             off_and_len, cgen_state_->llInt(int32_t(0xffff0000))),
         cgen_state_->llInt(int32_t(16)));
     auto len_lv = cgen_state_->query_func_entry_ir_builder_.CreateAnd(
         off_and_len, cgen_state_->llInt(int32_t(0x0000ffff)));
 
     auto var_start_address = cgen_state_->query_func_entry_ir_builder_.CreateGEP(
         lit_buff_query_func_lv->getType()->getScalarType()->getPointerElementType(),
         lit_buff_query_func_lv,
         off_lv);
     auto var_length = len_lv;
 
     var_start_address->setName(literal_name + "_start_address");
     var_length->setName(literal_name + "_length");
 
     return {var_start_address, var_length};
   }
 
   // Load a literal from the literal buffer. See also getOrAddLiteral().
   llvm::Type* val_ptr_type{nullptr};
   // NOTE(sy): If val_bits_in is ever different from val_bits_out, that means we need to
   // generate casting below for the type that has this happen. Currently only the decimal
   // type is known to ever have this happen.
   const size_t lit_bits = lit_bytes * 8;
   const size_t val_bits_out = get_bit_width(type_info);
   const size_t val_bits_in = type_info.is_decimal() ? lit_bits : val_bits_out;
   if (val_bits_in != lit_bits && !g_allow_invalid_literal_buffer_reads) {
     // Refuse to read the wrong number of bytes from the literal buffer.
     std::stringstream ss;
     ss << "Invalid literal buffer read size " << val_bits_in << " (expected " << lit_bits
        << ") for type " << toString(type_info.get_type())
        << ". See also: --allow-invalid-literal-buffer-reads";
     LOG(ERROR) << "ERROR: " << ss.str();
     LOG(ERROR) << type_info.to_string();
     throw std::runtime_error(ss.str());
   }
   CHECK_EQ(size_t(0), val_bits_in % 8);
   CHECK_EQ(size_t(0), val_bits_out % 8);
   if (type_info.is_integer() || type_info.is_decimal() || type_info.is_time() ||
       type_info.is_timeinterval() || type_info.is_string() || type_info.is_boolean()) {
     val_ptr_type = llvm::PointerType::get(
         llvm::IntegerType::get(cgen_state_->context_, val_bits_in), 0);
   } else {
     CHECK(type_info.get_type() == kFLOAT || type_info.get_type() == kDOUBLE);
     val_ptr_type = (type_info.get_type() == kFLOAT)
                        ? llvm::Type::getFloatPtrTy(cgen_state_->context_)
                        : llvm::Type::getDoublePtrTy(cgen_state_->context_);
   }
   auto* bit_cast = cgen_state_->query_func_entry_ir_builder_.CreateBitCast(lit_buf_start,
                                                                            val_ptr_type);
   llvm::Value* lit_lv = cgen_state_->query_func_entry_ir_builder_.CreateLoad(
       bit_cast->getType()->getPointerElementType(), bit_cast);
   if (type_info.is_decimal() && val_bits_in != val_bits_out) {
     // Generate casting.
     SQLTypeInfo type_info_in(get_phys_int_type(val_bits_in / 8),
                              type_info.get_dimension(),
                              type_info.get_scale(),
                              false,
                              kENCODING_NONE,
                              0,
                              type_info.get_subtype());
     SQLTypeInfo type_info_out(get_phys_int_type(val_bits_out / 8),
                               type_info.get_dimension(),
                               type_info.get_scale(),
                               false,
                               kENCODING_NONE,
                               0,
                               type_info.get_subtype());
     lit_lv = cgen_state_->emitEntryCall("cast_int" + std::to_string(val_bits_in) +
                                             "_t_to_int" + std::to_string(val_bits_out) +
                                             "_t_nullable",
                                         {lit_lv,
                                          cgen_state_->inlineIntNull(type_info_in),
                                          cgen_state_->inlineIntNull(type_info_out)});
   }
   lit_lv->setName(literal_name);
   return {lit_lv};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenHoistedConstantsPlaceholders	(	const SQLTypeInfo &	type_info,
		const EncodingType	enc_type,
		const int16_t	lit_off,
		const std::vector< llvm::Value * > &	literal_loads
	)

private

Definition at line 280 of file ConstantIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, CgenState::ir_builder_, SQLTypeInfo::is_array(), SQLTypeInfo::is_geometry(), SQLTypeInfo::is_string(), kENCODING_DICT, kENCODING_GEOINT, kENCODING_NONE, CgenState::llInt(), CgenState::row_func_hoisted_literals_, and to_string().

Referenced by codegenHoistedConstants().

                                                 {
   AUTOMATIC_IR_METADATA(cgen_state_);
   std::string literal_name = "literal_" + std::to_string(lit_off);
   CHECK(!type_info.is_geometry());
 
   if (type_info.is_string() && enc_type != kENCODING_DICT) {
     CHECK_EQ(literal_loads.size(), 3u);
 
     llvm::Value* var_start = literal_loads[0];
     llvm::Value* var_start_address = literal_loads[1];
     llvm::Value* var_length = literal_loads[2];
 
     llvm::PointerType* placeholder0_type =
         llvm::PointerType::get(var_start->getType(), 0);
     auto* int_to_ptr0 =
         cgen_state_->ir_builder_.CreateIntToPtr(cgen_state_->llInt(0), placeholder0_type);
     auto placeholder0 = cgen_state_->ir_builder_.CreateLoad(
         int_to_ptr0->getType()->getPointerElementType(),
         int_to_ptr0,
         "__placeholder__" + literal_name + "_start");
     llvm::PointerType* placeholder1_type =
         llvm::PointerType::get(var_start_address->getType(), 0);
     auto* int_to_ptr1 =
         cgen_state_->ir_builder_.CreateIntToPtr(cgen_state_->llInt(0), placeholder1_type);
     auto placeholder1 = cgen_state_->ir_builder_.CreateLoad(
         int_to_ptr1->getType()->getPointerElementType(),
         int_to_ptr1,
         "__placeholder__" + literal_name + "_start_address");
     llvm::PointerType* placeholder2_type =
         llvm::PointerType::get(var_length->getType(), 0);
     auto* int_to_ptr2 =
         cgen_state_->ir_builder_.CreateIntToPtr(cgen_state_->llInt(0), placeholder2_type);
     auto placeholder2 = cgen_state_->ir_builder_.CreateLoad(
         int_to_ptr2->getType()->getPointerElementType(),
         int_to_ptr2,
         "__placeholder__" + literal_name + "_length");
 
     cgen_state_->row_func_hoisted_literals_[placeholder0] = {lit_off, 0};
     cgen_state_->row_func_hoisted_literals_[placeholder1] = {lit_off, 1};
     cgen_state_->row_func_hoisted_literals_[placeholder2] = {lit_off, 2};
 
     return {placeholder0, placeholder1, placeholder2};
   }
 
   if (type_info.is_array() &&
       (enc_type == kENCODING_NONE || enc_type == kENCODING_GEOINT)) {
     CHECK_EQ(literal_loads.size(), 2u);
 
     llvm::Value* var_start_address = literal_loads[0];
     llvm::Value* var_length = literal_loads[1];
 
     llvm::PointerType* placeholder0_type =
         llvm::PointerType::get(var_start_address->getType(), 0);
     auto* int_to_ptr0 =
         cgen_state_->ir_builder_.CreateIntToPtr(cgen_state_->llInt(0), placeholder0_type);
     auto placeholder0 = cgen_state_->ir_builder_.CreateLoad(
         int_to_ptr0->getType()->getPointerElementType(),
         int_to_ptr0,
         "__placeholder__" + literal_name + "_start_address");
     llvm::PointerType* placeholder1_type =
         llvm::PointerType::get(var_length->getType(), 0);
     auto* int_to_ptr1 =
         cgen_state_->ir_builder_.CreateIntToPtr(cgen_state_->llInt(0), placeholder1_type);
     auto placeholder1 = cgen_state_->ir_builder_.CreateLoad(
         int_to_ptr1->getType()->getPointerElementType(),
         int_to_ptr1,
         "__placeholder__" + literal_name + "_length");
 
     cgen_state_->row_func_hoisted_literals_[placeholder0] = {lit_off, 0};
     cgen_state_->row_func_hoisted_literals_[placeholder1] = {lit_off, 1};
 
     return {placeholder0, placeholder1};
   }
 
   CHECK_EQ(literal_loads.size(), 1u);
   llvm::Value* to_return_lv = literal_loads[0];
 
   auto* int_to_ptr = cgen_state_->ir_builder_.CreateIntToPtr(
       cgen_state_->llInt(0), llvm::PointerType::get(to_return_lv->getType(), 0));
   auto placeholder0 =
       cgen_state_->ir_builder_.CreateLoad(int_to_ptr->getType()->getPointerElementType(),
                                           int_to_ptr,
                                           "__placeholder__" + literal_name);
 
   cgen_state_->row_func_hoisted_literals_[placeholder0] = {lit_off, 0};
 
   return {placeholder0};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenIntArith	(	const Analyzer::BinOper *	bin_oper,
		llvm::Value *	lhs_lv,
		llvm::Value *	rhs_lv,
		const CompilationOptions &	co
	)

private

Definition at line 77 of file ArithmeticIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegenAdd(), codegenDiv(), codegenMod(), codegenMul(), codegenSub(), Analyzer::BinOper::get_left_operand(), get_null_check_suffix(), Analyzer::BinOper::get_optype(), Analyzer::BinOper::get_right_operand(), Analyzer::Expr::get_type_info(), kDIVIDE, kMINUS, kMODULO, kMULTIPLY, kPLUS, and anonymous_namespace{ArithmeticIR.cpp}::numeric_or_time_interval_type_name().

Referenced by codegenArith().

                                                                           {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto lhs = bin_oper->get_left_operand();
   const auto rhs = bin_oper->get_right_operand();
   const auto& lhs_type = lhs->get_type_info();
   const auto& rhs_type = rhs->get_type_info();
   const auto int_typename = numeric_or_time_interval_type_name(lhs_type, rhs_type);
   const auto null_check_suffix = get_null_check_suffix(lhs_type, rhs_type);
   const auto& oper_type = rhs_type.is_timeinterval() ? rhs_type : lhs_type;
   switch (bin_oper->get_optype()) {
     case kMINUS:
       return codegenSub(bin_oper,
                         lhs_lv,
                         rhs_lv,
                         null_check_suffix.empty() ? "" : int_typename,
                         null_check_suffix,
                         oper_type,
                         co);
     case kPLUS:
       return codegenAdd(bin_oper,
                         lhs_lv,
                         rhs_lv,
                         null_check_suffix.empty() ? "" : int_typename,
                         null_check_suffix,
                         oper_type,
                         co);
     case kMULTIPLY:
       return codegenMul(bin_oper,
                         lhs_lv,
                         rhs_lv,
                         null_check_suffix.empty() ? "" : int_typename,
                         null_check_suffix,
                         oper_type,
                         co);
     case kDIVIDE:
       return codegenDiv(lhs_lv,
                         rhs_lv,
                         null_check_suffix.empty() ? "" : int_typename,
                         null_check_suffix,
                         oper_type);
     case kMODULO:
       return codegenMod(lhs_lv,
                         rhs_lv,
                         null_check_suffix.empty() ? "" : int_typename,
                         null_check_suffix,
                         oper_type);
     default:
       CHECK(false);
   }
   CHECK(false);
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::ConstantInt * CodeGenerator::codegenIntConst	(	const Analyzer::Constant *	constant,
		CgenState *	cgen_state
	)

static

Definition at line 89 of file ConstantIR.cpp.

References Datum::bigintval, decimal_to_int_type(), Analyzer::Constant::get_constval(), Analyzer::Constant::get_is_null(), Analyzer::Expr::get_type_info(), CgenState::inlineIntNull(), Datum::intval, kBIGINT, kDATE, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, CgenState::llInt(), Datum::smallintval, Datum::tinyintval, run_benchmark_import::type, and UNREACHABLE.

Referenced by codegen(), codegenDeciDiv(), createInValuesBitmap(), and Executor::skipFragment().

                                                                          {
   const auto& type_info = constant->get_type_info();
   if (constant->get_is_null()) {
     return cgen_state->inlineIntNull(type_info);
   }
   const auto type =
       type_info.is_decimal() ? decimal_to_int_type(type_info) : type_info.get_type();
   switch (type) {
     case kTINYINT:
       return cgen_state->llInt(constant->get_constval().tinyintval);
     case kSMALLINT:
       return cgen_state->llInt(constant->get_constval().smallintval);
     case kINT:
       return cgen_state->llInt(constant->get_constval().intval);
     case kBIGINT:
       return cgen_state->llInt(constant->get_constval().bigintval);
     case kTIME:
     case kTIMESTAMP:
     case kDATE:
     case kINTERVAL_DAY_TIME:
     case kINTERVAL_YEAR_MONTH:
       return cgen_state->llInt(constant->get_constval().bigintval);
     default:
       UNREACHABLE();
   }
   UNREACHABLE();
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenIsNull	(	const Analyzer::UOper *	uoper,
		const CompilationOptions &	co
	)

private

Definition at line 381 of file LogicalIR.cpp.

References AUTOMATIC_IR_METADATA, CgenState::castToTypeIn(), cgen_state_, CHECK, codegen(), codegenIsNullNumber(), CgenState::context_, CgenState::emitCall(), CgenState::emitExternalCall(), get_int_type(), Analyzer::UOper::get_operand(), CgenState::ir_builder_, kPOINT, spatial_type::Codegen::pointIsNullFunctionName(), and posArg().

Referenced by codegen().

                                                                         {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto operand = uoper->get_operand();
   if (dynamic_cast<const Analyzer::Constant*>(operand) &&
       dynamic_cast<const Analyzer::Constant*>(operand)->get_is_null()) {
     // for null constants, short-circuit to true
     return llvm::ConstantInt::get(get_int_type(1, cgen_state_->context_), 1);
   }
   const auto& ti = operand->get_type_info();
   CHECK(ti.is_integer() || ti.is_boolean() || ti.is_decimal() || ti.is_time() ||
         ti.is_string() || ti.is_fp() || ti.is_array() || ti.is_geometry());
   // if the type is inferred as non null, short-circuit to false
   if (ti.get_notnull()) {
     return llvm::ConstantInt::get(get_int_type(1, cgen_state_->context_), 0);
   }
   llvm::Value* operand_lv = codegen(operand, true, co).front();
   // NULL-check array or geo's coords array
   if (ti.get_type() == kPOINT && dynamic_cast<Analyzer::GeoOperator const*>(operand)) {
     char const* const fname = spatial_type::Codegen::pointIsNullFunctionName(ti);
     return cgen_state_->emitCall(fname, {operand_lv});
   } else if (ti.is_array() || ti.is_geometry()) {
     // POINT [un]compressed coord check requires custom checker and chunk iterator
     // Non-POINT NULL geographies will have a normally encoded null coord array
     auto fname =
         (ti.get_type() == kPOINT) ? "point_coord_array_is_null" : "array_is_null";
     return cgen_state_->emitExternalCall(
         fname, get_int_type(1, cgen_state_->context_), {operand_lv, posArg(operand)});
   } else if (ti.is_none_encoded_string()) {
     operand_lv = cgen_state_->ir_builder_.CreateExtractValue(operand_lv, 0);
     operand_lv = cgen_state_->castToTypeIn(operand_lv, sizeof(int64_t) * 8);
   }
   return codegenIsNullNumber(operand_lv, ti);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenIsNullNumber	(	llvm::Value *	operand_lv,
		const SQLTypeInfo &	ti
	)

private

Definition at line 416 of file LogicalIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, SQLTypeInfo::get_type(), CgenState::inlineIntNull(), CgenState::ir_builder_, SQLTypeInfo::is_fp(), kFLOAT, CgenState::llFp(), NULL_DOUBLE, and NULL_FLOAT.

Referenced by codegenFunctionOperNullArg(), codegenIsNull(), and codegenSkipOverflowCheckForNull().

                                                                        {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (ti.is_fp()) {
     return cgen_state_->ir_builder_.CreateFCmp(llvm::FCmpInst::FCMP_OEQ,
                                                operand_lv,
                                                ti.get_type() == kFLOAT
                                                    ? cgen_state_->llFp(NULL_FLOAT)
                                                    : cgen_state_->llFp(NULL_DOUBLE));
   }
   return cgen_state_->ir_builder_.CreateICmp(
       llvm::ICmpInst::ICMP_EQ, operand_lv, cgen_state_->inlineIntNull(ti));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenLinRegPredict	(	const Analyzer::MLPredictExpr *	expr,
		const std::shared_ptr< AbstractMLModel > &	model,
		const CompilationOptions &	co
	)

private

Definition at line 119 of file MLPredictCodegen.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegenArith(), Datum::doubleval, executor(), generated_encoded_and_casted_features(), Analyzer::MLPredictExpr::get_regressor_values(), kDOUBLE, kMULTIPLY, kONE, kPLUS, and run_benchmark_import::result.

Referenced by codegen().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto linear_reg_model =
       std::dynamic_pointer_cast<LinearRegressionModel>(abstract_model);
   // The parent codegen function called this function `codegenLinRegPredict`
   // iff we had MLModelType::LINEAR_REG_PREDICT, so below is just a sanity
   // check
   CHECK(linear_reg_model);
   const auto& model_coefs = linear_reg_model->getCoefs();
   const auto& cat_feature_keys = linear_reg_model->getCatFeatureKeys();
 
   const auto& regressor_exprs = expr->get_regressor_values();
 
   const auto casted_regressor_exprs = generated_encoded_and_casted_features(
       regressor_exprs,
       cat_feature_keys,
       linear_reg_model->getModelMetadata().getFeaturePermutations(),
       executor());
 
   auto get_double_constant_expr = [](double const_val) {
     Datum d;
     d.doubleval = const_val;
     return makeExpr<Analyzer::Constant>(SQLTypeInfo(kDOUBLE, false), false, d);
   };
 
   std::shared_ptr<Analyzer::Expr> result;
 
   // Linear regression models are of the form
   // y = b0 + b1*x1 + b2*x2 + ... + bn*xn
   // Where b0 is the constant y-intercept, x1..xn are the dependent
   // varabiles (aka regressors or predictors), and b1..bn are the
   // regression coefficients
 
   for (size_t model_coef_idx = 0; model_coef_idx < model_coefs.size(); ++model_coef_idx) {
     auto coef_value_expr = get_double_constant_expr(model_coefs[model_coef_idx]);
     if (model_coef_idx == size_t(0)) {
       // We have the y-intercept b0, this is not multiplied by any regressor
       result = coef_value_expr;
     } else {
       // We have a term with a regressor (xi) and regression coefficient (bi)
       const auto& casted_regressor_expr = casted_regressor_exprs[model_coef_idx - 1];
       // Multiply regressor by coefficient
       auto mul_expr = makeExpr<Analyzer::BinOper>(SQLTypeInfo(kDOUBLE, false),
                                                   false,
                                                   kMULTIPLY,
                                                   kONE,
                                                   coef_value_expr,
                                                   casted_regressor_expr);
       // Add term to result
       result = makeExpr<Analyzer::BinOper>(
           SQLTypeInfo(kDOUBLE, false), false, kPLUS, kONE, result, mul_expr);
     }
   }
 
   // The following will codegen the expression tree we just created modeling
   // the linear regression formula
   return codegenArith(dynamic_cast<Analyzer::BinOper*>(result.get()), co);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenLogical	(	const Analyzer::BinOper *	bin_oper,
		const CompilationOptions &	co
	)

private

Definition at line 299 of file LogicalIR.cpp.

References AUTOMATIC_IR_METADATA, CgenState::castToTypeIn(), cgen_state_, CHECK, codegen(), codegenLogicalShortCircuit(), CgenState::emitCall(), Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_optype(), Analyzer::BinOper::get_right_operand(), Analyzer::Expr::get_type_info(), CgenState::inlineIntNull(), CgenState::ir_builder_, IS_LOGIC, kAND, kOR, and toBool().

Referenced by codegen(), and codegenCmp().

                                                                          {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto optype = bin_oper->get_optype();
   CHECK(IS_LOGIC(optype));
 
   if (llvm::Value* short_circuit = codegenLogicalShortCircuit(bin_oper, co)) {
     return short_circuit;
   }
 
   const auto lhs = bin_oper->get_left_operand();
   const auto rhs = bin_oper->get_right_operand();
   auto lhs_lv = codegen(lhs, true, co).front();
   auto rhs_lv = codegen(rhs, true, co).front();
   const auto& ti = bin_oper->get_type_info();
   if (ti.get_notnull()) {
     switch (optype) {
       case kAND:
         return cgen_state_->ir_builder_.CreateAnd(toBool(lhs_lv), toBool(rhs_lv));
       case kOR:
         return cgen_state_->ir_builder_.CreateOr(toBool(lhs_lv), toBool(rhs_lv));
       default:
         CHECK(false);
     }
   }
   CHECK(lhs_lv->getType()->isIntegerTy(1) || lhs_lv->getType()->isIntegerTy(8));
   CHECK(rhs_lv->getType()->isIntegerTy(1) || rhs_lv->getType()->isIntegerTy(8));
   if (lhs_lv->getType()->isIntegerTy(1)) {
     lhs_lv = cgen_state_->castToTypeIn(lhs_lv, 8);
   }
   if (rhs_lv->getType()->isIntegerTy(1)) {
     rhs_lv = cgen_state_->castToTypeIn(rhs_lv, 8);
   }
   switch (optype) {
     case kAND:
       return cgen_state_->emitCall("logical_and",
                                    {lhs_lv, rhs_lv, cgen_state_->inlineIntNull(ti)});
     case kOR:
       return cgen_state_->emitCall("logical_or",
                                    {lhs_lv, rhs_lv, cgen_state_->inlineIntNull(ti)});
     default:
       abort();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenLogical	(	const Analyzer::UOper *	uoper,
		const CompilationOptions &	co
	)

private

Definition at line 363 of file LogicalIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), CgenState::emitCall(), Analyzer::UOper::get_operand(), Analyzer::UOper::get_optype(), Analyzer::Expr::get_type_info(), CgenState::inlineIntNull(), CgenState::ir_builder_, anonymous_namespace{LogicalIR.cpp}::is_qualified_bin_oper(), kNOT, and toBool().

                                                                          {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto optype = uoper->get_optype();
   CHECK_EQ(kNOT, optype);
   const auto operand = uoper->get_operand();
   const auto& operand_ti = operand->get_type_info();
   CHECK(operand_ti.is_boolean());
   const auto operand_lv = codegen(operand, true, co).front();
   CHECK(operand_lv->getType()->isIntegerTy());
   const bool not_null = (operand_ti.get_notnull() || is_qualified_bin_oper(operand));
   CHECK(not_null || operand_lv->getType()->isIntegerTy(8));
   return not_null
              ? cgen_state_->ir_builder_.CreateNot(toBool(operand_lv))
              : cgen_state_->emitCall(
                    "logical_not", {operand_lv, cgen_state_->inlineIntNull(operand_ti)});
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegenLogicalShortCircuit	(	const Analyzer::BinOper *	bin_oper,
		const CompilationOptions &	co
	)

private

Definition at line 197 of file LogicalIR.cpp.

References AUTOMATIC_IR_METADATA, CgenState::castToTypeIn(), cgen_state_, codegen(), anonymous_namespace{LogicalIR.cpp}::contains_unsafe_division(), CgenState::context_, CgenState::current_func_, Analyzer::BinOper::get_left_operand(), anonymous_namespace{LogicalIR.cpp}::get_likelihood(), Analyzer::BinOper::get_optype(), Analyzer::BinOper::get_right_operand(), Analyzer::Expr::get_type_info(), anonymous_namespace{LogicalIR.cpp}::get_weight(), CgenState::inlineIntNull(), CgenState::ir_builder_, kAND, kOR, and gpu_enabled::swap().

Referenced by codegenLogical().

                                                                                      {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto optype = bin_oper->get_optype();
   auto lhs = bin_oper->get_left_operand();
   auto rhs = bin_oper->get_right_operand();
 
   if (contains_unsafe_division(rhs)) {
     // rhs contains a possible div-by-0: short-circuit
   } else if (contains_unsafe_division(lhs)) {
     // lhs contains a possible div-by-0: swap and short-circuit
     std::swap(rhs, lhs);
   } else if (((optype == kOR && get_likelihood(lhs) > 0.90) ||
               (optype == kAND && get_likelihood(lhs) < 0.10)) &&
              get_weight(rhs) > 10) {
     // short circuit if we're likely to see either (trueA || heavyB) or (falseA && heavyB)
   } else if (((optype == kOR && get_likelihood(rhs) > 0.90) ||
               (optype == kAND && get_likelihood(rhs) < 0.10)) &&
              get_weight(lhs) > 10) {
     // swap and short circuit if we're likely to see either (heavyA || trueB) or (heavyA
     // && falseB)
     std::swap(rhs, lhs);
   } else {
     // no motivation to short circuit
     return nullptr;
   }
 
   const auto& ti = bin_oper->get_type_info();
   auto lhs_lv = codegen(lhs, true, co).front();
 
   // Here the linear control flow will diverge and expressions cached during the
   // code branch code generation (currently just column decoding) are not going
   // to be available once we're done generating the short-circuited logic.
   // Take a snapshot of the cache with FetchCacheAnchor and restore it once
   // the control flow converges.
   Executor::FetchCacheAnchor anchor(cgen_state_);
 
   auto rhs_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "rhs_bb", cgen_state_->current_func_);
   auto ret_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "ret_bb", cgen_state_->current_func_);
   llvm::BasicBlock* nullcheck_ok_bb{nullptr};
   llvm::BasicBlock* nullcheck_fail_bb{nullptr};
 
   if (!ti.get_notnull()) {
     // need lhs nullcheck before short circuiting
     nullcheck_ok_bb = llvm::BasicBlock::Create(
         cgen_state_->context_, "nullcheck_ok_bb", cgen_state_->current_func_);
     nullcheck_fail_bb = llvm::BasicBlock::Create(
         cgen_state_->context_, "nullcheck_fail_bb", cgen_state_->current_func_);
     if (lhs_lv->getType()->isIntegerTy(1)) {
       lhs_lv = cgen_state_->castToTypeIn(lhs_lv, 8);
     }
     auto lhs_nullcheck =
         cgen_state_->ir_builder_.CreateICmpEQ(lhs_lv, cgen_state_->inlineIntNull(ti));
     cgen_state_->ir_builder_.CreateCondBr(
         lhs_nullcheck, nullcheck_fail_bb, nullcheck_ok_bb);
     cgen_state_->ir_builder_.SetInsertPoint(nullcheck_ok_bb);
   }
 
   auto sc_check_bb = cgen_state_->ir_builder_.GetInsertBlock();
   auto cnst_lv = llvm::ConstantInt::get(lhs_lv->getType(), (optype == kOR));
   // Branch to codegen rhs if NOT getting (true || rhs) or (false && rhs), likelihood of
   // the branch is < 0.10
   cgen_state_->ir_builder_.CreateCondBr(
       cgen_state_->ir_builder_.CreateICmpNE(lhs_lv, cnst_lv),
       rhs_bb,
       ret_bb,
       llvm::MDBuilder(cgen_state_->context_).createBranchWeights(10, 90));
 
   // Codegen rhs when unable to short circuit.
   cgen_state_->ir_builder_.SetInsertPoint(rhs_bb);
   auto rhs_lv = codegen(rhs, true, co).front();
   if (!ti.get_notnull()) {
     // need rhs nullcheck as well
     if (rhs_lv->getType()->isIntegerTy(1)) {
       rhs_lv = cgen_state_->castToTypeIn(rhs_lv, 8);
     }
     auto rhs_nullcheck =
         cgen_state_->ir_builder_.CreateICmpEQ(rhs_lv, cgen_state_->inlineIntNull(ti));
     cgen_state_->ir_builder_.CreateCondBr(rhs_nullcheck, nullcheck_fail_bb, ret_bb);
   } else {
     cgen_state_->ir_builder_.CreateBr(ret_bb);
   }
   auto rhs_codegen_bb = cgen_state_->ir_builder_.GetInsertBlock();
 
   if (!ti.get_notnull()) {
     cgen_state_->ir_builder_.SetInsertPoint(nullcheck_fail_bb);
     cgen_state_->ir_builder_.CreateBr(ret_bb);
   }
 
   cgen_state_->ir_builder_.SetInsertPoint(ret_bb);
   auto result_phi =
       cgen_state_->ir_builder_.CreatePHI(lhs_lv->getType(), (!ti.get_notnull()) ? 3 : 2);
   if (!ti.get_notnull()) {
     result_phi->addIncoming(cgen_state_->inlineIntNull(ti), nullcheck_fail_bb);
   }
   result_phi->addIncoming(cnst_lv, sc_check_bb);
   result_phi->addIncoming(rhs_lv, rhs_codegen_bb);
   return result_phi;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenMod	(	llvm::Value *	lhs_lv,
		llvm::Value *	rhs_lv,
		const std::string &	null_typename,
		const std::string &	null_check_suffix,
		const SQLTypeInfo &	ti
	)

private

Definition at line 598 of file ArithmeticIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, CgenState::context_, CgenState::current_func_, CgenState::emitCall(), inline_int_null_val(), CgenState::ir_builder_, SQLTypeInfo::is_integer(), CgenState::llInt(), and CgenState::needs_error_check_.

Referenced by codegenIntArith().

                                                               {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK_EQ(lhs_lv->getType(), rhs_lv->getType());
   CHECK(ti.is_integer());
   cgen_state_->needs_error_check_ = true;
   // Generate control flow for division by zero error handling.
   auto mod_ok = llvm::BasicBlock::Create(
       cgen_state_->context_, "mod_ok", cgen_state_->current_func_);
   auto mod_zero = llvm::BasicBlock::Create(
       cgen_state_->context_, "mod_zero", cgen_state_->current_func_);
   auto zero_const = llvm::ConstantInt::get(rhs_lv->getType(), 0, true);
   cgen_state_->ir_builder_.CreateCondBr(
       cgen_state_->ir_builder_.CreateICmp(llvm::ICmpInst::ICMP_NE, rhs_lv, zero_const),
       mod_ok,
       mod_zero);
   cgen_state_->ir_builder_.SetInsertPoint(mod_ok);
   auto ret = null_typename.empty()
                  ? cgen_state_->ir_builder_.CreateSRem(lhs_lv, rhs_lv)
                  : cgen_state_->emitCall(
                        "mod_" + null_typename + null_check_suffix,
                        {lhs_lv, rhs_lv, cgen_state_->llInt(inline_int_null_val(ti))});
   cgen_state_->ir_builder_.SetInsertPoint(mod_zero);
   cgen_state_->ir_builder_.CreateRet(cgen_state_->llInt(int32_t(ErrorCode::DIV_BY_ZERO)));
   cgen_state_->ir_builder_.SetInsertPoint(mod_ok);
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenMul	(	const Analyzer::BinOper *	bin_oper,
		llvm::Value *	lhs_lv,
		llvm::Value *	rhs_lv,
		const std::string &	null_typename,
		const std::string &	null_check_suffix,
		const SQLTypeInfo &	ti,
		const CompilationOptions &	co,
		bool	downscale = `true`
	)

private

Definition at line 361 of file ArithmeticIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, checkExpressionRanges(), codegenBinOpWithOverflowForCPU(), codegenSkipOverflowCheckForNull(), CgenState::context_, CPU, CgenState::current_func_, CompilationOptions::device_type, CgenState::emitCall(), SQLTypeInfo::get_size(), inline_int_null_val(), CgenState::inlineIntMaxMin(), CgenState::ir_builder_, SQLTypeInfo::is_decimal(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_timeinterval(), CgenState::llInt(), and CgenState::needs_error_check_.

Referenced by codegenIntArith().

                                                        {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK_EQ(lhs_lv->getType(), rhs_lv->getType());
   CHECK(ti.is_integer() || ti.is_decimal() || ti.is_timeinterval());
   llvm::Value* chosen_max{nullptr};
   llvm::Value* chosen_min{nullptr};
   std::tie(chosen_max, chosen_min) = cgen_state_->inlineIntMaxMin(ti.get_size(), true);
   auto need_overflow_check =
       !checkExpressionRanges(bin_oper,
                              static_cast<llvm::ConstantInt*>(chosen_min)->getSExtValue(),
                              static_cast<llvm::ConstantInt*>(chosen_max)->getSExtValue());
 
   if (need_overflow_check && co.device_type == ExecutorDeviceType::CPU) {
     return codegenBinOpWithOverflowForCPU(
         bin_oper, lhs_lv, rhs_lv, null_check_suffix, ti);
   }
 
   llvm::BasicBlock* mul_ok{nullptr};
   llvm::BasicBlock* mul_fail{nullptr};
   if (need_overflow_check) {
     cgen_state_->needs_error_check_ = true;
     mul_ok = llvm::BasicBlock::Create(
         cgen_state_->context_, "mul_ok", cgen_state_->current_func_);
     if (!null_check_suffix.empty()) {
       codegenSkipOverflowCheckForNull(lhs_lv, rhs_lv, mul_ok, ti);
     }
     mul_fail = llvm::BasicBlock::Create(
         cgen_state_->context_, "mul_fail", cgen_state_->current_func_);
     auto mul_check = llvm::BasicBlock::Create(
         cgen_state_->context_, "mul_check", cgen_state_->current_func_);
     auto const_zero = llvm::ConstantInt::get(rhs_lv->getType(), 0, true);
     cgen_state_->ir_builder_.CreateCondBr(
         cgen_state_->ir_builder_.CreateICmpEQ(rhs_lv, const_zero), mul_ok, mul_check);
     cgen_state_->ir_builder_.SetInsertPoint(mul_check);
     auto rhs_is_negative_lv = cgen_state_->ir_builder_.CreateICmpSLT(rhs_lv, const_zero);
     auto positive_rhs_lv = cgen_state_->ir_builder_.CreateSelect(
         rhs_is_negative_lv, cgen_state_->ir_builder_.CreateNeg(rhs_lv), rhs_lv);
     auto adjusted_lhs_lv = cgen_state_->ir_builder_.CreateSelect(
         rhs_is_negative_lv, cgen_state_->ir_builder_.CreateNeg(lhs_lv), lhs_lv);
     auto detected = cgen_state_->ir_builder_.CreateOr(  // overflow
         cgen_state_->ir_builder_.CreateICmpSGT(
             adjusted_lhs_lv,
             cgen_state_->ir_builder_.CreateSDiv(chosen_max, positive_rhs_lv)),
         // underflow
         cgen_state_->ir_builder_.CreateICmpSLT(
             adjusted_lhs_lv,
             cgen_state_->ir_builder_.CreateSDiv(chosen_min, positive_rhs_lv)));
     cgen_state_->ir_builder_.CreateCondBr(detected, mul_fail, mul_ok);
     cgen_state_->ir_builder_.SetInsertPoint(mul_ok);
   }
   const auto ret =
       null_check_suffix.empty()
           ? cgen_state_->ir_builder_.CreateMul(lhs_lv, rhs_lv)
           : cgen_state_->emitCall(
                 "mul_" + null_typename + null_check_suffix,
                 {lhs_lv, rhs_lv, cgen_state_->llInt(inline_int_null_val(ti))});
   if (need_overflow_check) {
     cgen_state_->ir_builder_.SetInsertPoint(mul_fail);
     cgen_state_->ir_builder_.CreateRet(
         cgen_state_->llInt(int32_t(ErrorCode::OVERFLOW_OR_UNDERFLOW)));
     cgen_state_->ir_builder_.SetInsertPoint(mul_ok);
   }
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenOuterJoinNullPlaceholder	(	const Analyzer::ColumnVar *	col_var,
		const bool	fetch_column,
		const CompilationOptions &	co
	)

private

Definition at line 496 of file ColumnIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), codegenColVar(), CgenState::context_, CgenState::current_func_, foundOuterJoinMatch(), Analyzer::ColumnVar::get_rte_idx(), Analyzer::Expr::get_type_info(), CgenState::ir_builder_, needCastForHashJoinLhs(), and resolveGroupedColumnReference().

Referenced by codegenColumn().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto grouped_col_lv = resolveGroupedColumnReference(col_var);
   if (grouped_col_lv) {
     return {grouped_col_lv};
   }
   const auto outer_join_args_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "outer_join_args", cgen_state_->current_func_);
   const auto outer_join_nulls_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "outer_join_nulls", cgen_state_->current_func_);
   const auto phi_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "outer_join_phi", cgen_state_->current_func_);
   const auto outer_join_match_lv = foundOuterJoinMatch(col_var->get_rte_idx());
   CHECK(outer_join_match_lv);
   cgen_state_->ir_builder_.CreateCondBr(
       outer_join_match_lv, outer_join_args_bb, outer_join_nulls_bb);
   const auto back_from_outer_join_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "back_from_outer_join", cgen_state_->current_func_);
   cgen_state_->ir_builder_.SetInsertPoint(outer_join_args_bb);
   Executor::FetchCacheAnchor anchor(cgen_state_);
   const auto orig_lvs = codegenColVar(col_var, fetch_column, true, co);
   // sometimes col_var used in the join qual needs to cast its column to sync with
   // the target join column's type which generates a code with a new bb like cast_bb
   // if so, we need to keep that bb to correctly construct phi_bb
   // i.e., use cast_bb instead of outer_join_args_bb for the "casted" column
   // which is the right end point
   const auto needs_casting_col_var = needCastForHashJoinLhs(col_var);
   auto* cast_bb = cgen_state_->ir_builder_.GetInsertBlock();
   cgen_state_->ir_builder_.CreateBr(phi_bb);
   cgen_state_->ir_builder_.SetInsertPoint(outer_join_nulls_bb);
   const auto& null_ti = col_var->get_type_info();
   // since this represents a null constant, what value the datum object contains is
   // meaningless we need to know what type we need to create a null constant and `null_ti`
   // contains it
   const auto null_constant = makeExpr<Analyzer::Constant>(null_ti, true, Datum{0});
   auto const null_target_lvs = codegen(null_constant.get(), fetch_column, co);
   cgen_state_->ir_builder_.CreateBr(phi_bb);
   CHECK_EQ(orig_lvs.size(), null_target_lvs.size());
   cgen_state_->ir_builder_.SetInsertPoint(phi_bb);
   std::vector<llvm::Value*> target_lvs;
   for (size_t i = 0; i < orig_lvs.size(); ++i) {
     const auto target_type = orig_lvs[i]->getType();
     const auto null_type = null_target_lvs[i]->getType();
     CHECK_EQ(target_type, null_type);
     auto target_phi = cgen_state_->ir_builder_.CreatePHI(target_type, 2);
     const auto orig_lvs_bb = needs_casting_col_var ? cast_bb : outer_join_args_bb;
     target_phi->addIncoming(orig_lvs[i], orig_lvs_bb);
     target_phi->addIncoming(null_target_lvs[i], outer_join_nulls_bb);
     target_lvs.push_back(target_phi);
   }
   cgen_state_->ir_builder_.CreateBr(back_from_outer_join_bb);
   cgen_state_->ir_builder_.SetInsertPoint(back_from_outer_join_bb);
   return target_lvs;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenPerRowStringOper	(	const Analyzer::StringOper *	string_oper,
		const CompilationOptions &	co
	)

Definition at line 351 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, CHECK_GE, CHECK_LE, codegenStringFetchAndEncode(), CONCAT, CgenState::context_, CompilationOptions::device_type, CgenState::emitExternalCall(), executor(), g_cluster, get_fp_type(), get_int_type(), Analyzer::StringOper::get_kind(), Analyzer::Expr::get_type_info(), Analyzer::StringOper::getArity(), Analyzer::StringOper::getNonLiteralsArity(), getStringOpInfos(), GPU, CgenState::inlineNull(), kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kNUMERIC, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, CgenState::llInt(), RCONCAT, to_lower(), and toString().

Referenced by codegen().

                                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK_GE(expr->getArity(), 1UL);
   const auto non_literals_arity = expr->getNonLiteralsArity();
   CHECK_GE(non_literals_arity, 1UL);
   CHECK_LE(non_literals_arity, 2UL);
   const auto& return_ti = expr->get_type_info();
   if (g_cluster && return_ti.is_dict_encoded_string()) {
     throw std::runtime_error(
         "Cast from none-encoded string to dictionary-encoded not supported for "
         "distributed queries");
   }
   if (co.device_type == ExecutorDeviceType::GPU) {
     throw QueryMustRunOnCpu();
   }
   const auto [primary_str_lv, nullcheck_codegen] =
       codegenStringFetchAndEncode(expr, co, 0UL, false);
   CHECK_EQ(size_t(3), primary_str_lv.size());
 
   const auto string_op_infos = getStringOpInfos(expr);
   CHECK(string_op_infos.size());
 
   const auto string_ops =
       executor()->getRowSetMemoryOwner()->getStringOps(string_op_infos);
   const int64_t string_ops_handle = reinterpret_cast<int64_t>(string_ops);
   auto string_ops_handle_lv = cgen_state_->llInt(string_ops_handle);
 
   if (!return_ti.is_string()) {
     CHECK_GE(non_literals_arity, 1UL);
     CHECK_LE(non_literals_arity, 2UL);
     std::vector<llvm::Value*> string_oper_lvs;
     if (non_literals_arity == 1UL) {
       string_oper_lvs = {primary_str_lv[1], primary_str_lv[2], string_ops_handle_lv};
     } else {
       const auto [secondary_str_lv, secondary_nullcheck_codegen] =
           codegenStringFetchAndEncode(expr, co, 1UL, false);
       CHECK_EQ(size_t(3), secondary_str_lv.size());
       string_oper_lvs = {primary_str_lv[1],
                          primary_str_lv[2],
                          secondary_str_lv[1],
                          secondary_str_lv[2],
                          string_ops_handle_lv};
     }
     const auto return_type = return_ti.get_type();
     std::string fn_call = non_literals_arity == 1UL
                               ? "apply_numeric_string_ops_"
                               : "apply_multi_input_numeric_string_ops_";
     switch (return_type) {
       case kBOOLEAN: {
         fn_call += "bool";
         break;
       }
       case kTINYINT:
       case kSMALLINT:
       case kINT:
       case kBIGINT:
       case kFLOAT:
       case kDOUBLE: {
         fn_call += to_lower(toString(return_type));
         break;
       }
       case kNUMERIC:
       case kDECIMAL:
       case kTIME:
       case kTIMESTAMP:
       case kDATE: {
         fn_call += "bigint";
         break;
       }
       default: {
         throw std::runtime_error("Unimplemented type for string-to-numeric translation");
       }
     }
     const auto logical_size = return_ti.get_logical_size() * 8;
     auto llvm_return_type = return_ti.is_fp()
                                 ? get_fp_type(logical_size, cgen_state_->context_)
                                 : get_int_type(logical_size, cgen_state_->context_);
     auto ret = cgen_state_->emitExternalCall(fn_call, llvm_return_type, string_oper_lvs);
     if (nullcheck_codegen) {
       ret = nullcheck_codegen->finalize(cgen_state_->inlineNull(return_ti), ret);
     }
     return ret;
   }
 
   // If here we are outputing a string dictionary column
   CHECK(return_ti.is_dict_encoded_string());
   const int64_t dest_string_proxy_handle =
       reinterpret_cast<int64_t>(executor()->getStringDictionaryProxy(
           return_ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true));
   auto dest_string_proxy_handle_lv = cgen_state_->llInt(dest_string_proxy_handle);
   if (non_literals_arity == 1UL) {
     std::vector<llvm::Value*> string_oper_lvs{primary_str_lv[1],
                                               primary_str_lv[2],
                                               string_ops_handle_lv,
                                               dest_string_proxy_handle_lv};
 
     auto ret = cgen_state_->emitExternalCall("apply_string_ops_and_encode",
                                              get_int_type(32, cgen_state_->context_),
                                              string_oper_lvs);
     if (nullcheck_codegen) {
       ret = nullcheck_codegen->finalize(cgen_state_->inlineNull(return_ti), ret);
     }
     return ret;
   } else {
     // For now only CONCAT is supported, which takes up to 2 non-literal string
     // arguments. In the future (likely when we can codegen the StringOps to enable
     // generic, multi-branch execution rather than linear chains of functors as we do
     // today), we will generalize this to functions that take
     // any number of string and numeric non-literal arguments, in which case
     // we will need to make apply_multi_input_string_ops_and_encode take
     // a vector of arguments. For now, however, expecting exactly 2 arguments
     // suffices.
     CHECK_EQ(non_literals_arity, 2UL);
     CHECK(expr->get_kind() == SqlStringOpKind::CONCAT ||
           expr->get_kind() == SqlStringOpKind::RCONCAT);
     const auto [secondary_str_lv, secondary_nullcheck_codegen] =
         codegenStringFetchAndEncode(expr, co, 1UL, false);
     CHECK_EQ(size_t(3), secondary_str_lv.size());
     std::vector<llvm::Value*> string_oper_lvs{primary_str_lv[1],
                                               primary_str_lv[2],
                                               secondary_str_lv[1],
                                               secondary_str_lv[2],
                                               string_ops_handle_lv,
                                               dest_string_proxy_handle_lv};
     auto ret = cgen_state_->emitExternalCall("apply_multi_input_string_ops_and_encode",
                                              get_int_type(32, cgen_state_->context_),
                                              string_oper_lvs);
     if (secondary_nullcheck_codegen) {
       ret =
           secondary_nullcheck_codegen->finalize(cgen_state_->inlineNull(return_ti), ret);
     }
     if (nullcheck_codegen) {
       ret = nullcheck_codegen->finalize(cgen_state_->inlineNull(return_ti), ret);
     }
     return ret;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenPseudoStringOper	(	const Analyzer::ColumnVar *	expr,
		const std::vector< StringOps_Namespace::StringOpInfo > &	string_op_infos,
		const CompilationOptions &	co
	)

Definition at line 557 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK_EQ, codegen(), StringDictionaryTranslationMgr::codegen(), Data_Namespace::CPU_LEVEL, CompilationOptions::device_type, executor(), Analyzer::Expr::get_type_info(), SQLTypeInfo::getStringDictKey(), GPU, Data_Namespace::GPU_LEVEL, and CgenState::moveStringDictionaryTranslationMgr().

Referenced by HashJoin::codegenColOrStringOper().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto& expr_ti = expr->get_type_info();
   const auto& dict_id = expr_ti.getStringDictKey();
 
   auto string_dictionary_translation_mgr =
       std::make_unique<StringDictionaryTranslationMgr>(
           dict_id,
           dict_id,
           false,  // translate_intersection_only
           expr->get_type_info(),
           string_op_infos,
           co.device_type == ExecutorDeviceType::GPU ? Data_Namespace::GPU_LEVEL
                                                     : Data_Namespace::CPU_LEVEL,
           executor()->deviceCount(co.device_type),
           executor(),
           executor()->getDataMgr(),
           false /* delay_translation */);
 
   auto str_id_lv = codegen(expr, true /* fetch_column */, co);
   CHECK_EQ(size_t(1), str_id_lv.size());
 
   return cgen_state_
       ->moveStringDictionaryTranslationMgr(std::move(string_dictionary_translation_mgr))
       ->codegen(str_id_lv[0], expr_ti, true /* add_nullcheck */, co);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenQualifierCmp	(	const SQLOps	optype,
		const SQLQualifier	qualifier,
		std::vector< llvm::Value * >	lhs_lvs,
		const Analyzer::Expr *	rhs,
		const CompilationOptions &	co
	)

private

Definition at line 589 of file CompareIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, CHECK_NE, codegen(), CgenState::context_, CompilationOptions::device_type, CgenState::emitExternalCall(), executor(), g_cluster, g_enable_watchdog, get_int_type(), Analyzer::Expr::get_type_info(), GPU, anonymous_namespace{CompareIR.cpp}::icmp_arr_name(), CgenState::inlineIntNull(), kANY, kCAST, kDOUBLE, kENCODING_DICT, kENCODING_NONE, kONE, CgenState::llInt(), numeric_type_name(), and posArg().

Referenced by codegenCmp().

                                                                               {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto& rhs_ti = rhs->get_type_info();
   const Analyzer::Expr* arr_expr{rhs};
   if (dynamic_cast<const Analyzer::UOper*>(rhs)) {
     const auto cast_arr = static_cast<const Analyzer::UOper*>(rhs);
     CHECK_EQ(kCAST, cast_arr->get_optype());
     arr_expr = cast_arr->get_operand();
   }
   const auto& arr_ti = arr_expr->get_type_info();
   const auto& elem_ti = arr_ti.get_elem_type();
   auto rhs_lvs = codegen(arr_expr, true, co);
   CHECK_NE(kONE, qualifier);
   std::string fname{std::string("array_") + (qualifier == kANY ? "any" : "all") + "_" +
                     icmp_arr_name(optype)};
   const auto& target_ti = rhs_ti.get_elem_type();
   const bool is_real_string{target_ti.is_string() &&
                             target_ti.get_compression() != kENCODING_DICT};
   if (is_real_string) {
     if (g_cluster) {
       throw std::runtime_error(
           "Comparison between a dictionary-encoded and a none-encoded string not "
           "supported for distributed queries");
     }
     if (g_enable_watchdog) {
       throw WatchdogException(
           "Comparison between a dictionary-encoded and a none-encoded string would be "
           "slow");
     }
     if (co.device_type == ExecutorDeviceType::GPU) {
       throw QueryMustRunOnCpu();
     }
     CHECK_EQ(kENCODING_NONE, target_ti.get_compression());
     fname += "_str";
   }
   if (elem_ti.is_integer() || elem_ti.is_boolean() || elem_ti.is_string() ||
       elem_ti.is_decimal()) {
     fname += ("_" + numeric_type_name(elem_ti));
   } else {
     CHECK(elem_ti.is_fp());
     fname += elem_ti.get_type() == kDOUBLE ? "_double" : "_float";
   }
   if (is_real_string) {
     CHECK_EQ(size_t(3), lhs_lvs.size());
     return cgen_state_->emitExternalCall(
         fname,
         get_int_type(1, cgen_state_->context_),
         {rhs_lvs.front(),
          posArg(arr_expr),
          lhs_lvs[1],
          lhs_lvs[2],
          cgen_state_->llInt(int64_t(executor()->getStringDictionaryProxy(
              elem_ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true))),
          cgen_state_->inlineIntNull(elem_ti)});
   }
   if (target_ti.is_integer() || target_ti.is_boolean() || target_ti.is_string() ||
       target_ti.is_decimal()) {
     fname += ("_" + numeric_type_name(target_ti));
   } else {
     CHECK(target_ti.is_fp());
     fname += target_ti.get_type() == kDOUBLE ? "_double" : "_float";
   }
   return cgen_state_->emitExternalCall(
       fname,
       get_int_type(1, cgen_state_->context_),
       {rhs_lvs.front(),
        posArg(arr_expr),
        lhs_lvs.front(),
        elem_ti.is_fp() ? static_cast<llvm::Value*>(cgen_state_->inlineFpNull(elem_ti))
                        : static_cast<llvm::Value*>(cgen_state_->inlineIntNull(elem_ti))});
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenRowId	(	const Analyzer::ColumnVar *	col_var,
		const CompilationOptions &	co
	)

private

Definition at line 391 of file ColumnIR.cpp.

References anonymous_namespace{ColumnIR.cpp}::adjusted_range_table_index(), AUTOMATIC_IR_METADATA, Datum::bigintval, cgen_state_, CHECK, CHECK_EQ, codegen(), executor(), CgenState::frag_offsets_, get_arg_by_name(), Analyzer::ColumnVar::get_rte_idx(), Analyzer::ColumnVar::getTableKey(), CgenState::ir_builder_, kBIGINT, kENCODING_NONE, CgenState::llInt(), posArg(), and CgenState::row_func_.

Referenced by codegenColVar().

                                                                        {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto offset_lv = cgen_state_->frag_offsets_[adjusted_range_table_index(col_var)];
   llvm::Value* start_rowid_lv{nullptr};
   const auto& table_generation = executor()->getTableGeneration(col_var->getTableKey());
   if (table_generation.start_rowid > 0) {
     // Handle the multi-node case: each leaf receives a start rowid used
     // to offset the local rowid and generate a cluster-wide unique rowid.
     Datum d;
     d.bigintval = table_generation.start_rowid;
     const auto start_rowid = makeExpr<Analyzer::Constant>(kBIGINT, false, d);
     const auto start_rowid_lvs = codegen(start_rowid.get(), kENCODING_NONE, {}, co);
     CHECK_EQ(size_t(1), start_rowid_lvs.size());
     start_rowid_lv = start_rowid_lvs.front();
   }
   auto rowid_lv = posArg(col_var);
   if (offset_lv) {
     rowid_lv = cgen_state_->ir_builder_.CreateAdd(rowid_lv, offset_lv);
   } else if (col_var->get_rte_idx() > 0) {
     auto frag_off_ptr = get_arg_by_name(cgen_state_->row_func_, "frag_row_off");
     auto input_off_ptr = cgen_state_->ir_builder_.CreateGEP(
         frag_off_ptr->getType()->getScalarType()->getPointerElementType(),
         frag_off_ptr,
         cgen_state_->llInt(int32_t(col_var->get_rte_idx())));
     auto rowid_offset_lv = cgen_state_->ir_builder_.CreateLoad(
         input_off_ptr->getType()->getPointerElementType(), input_off_ptr);
     rowid_lv = cgen_state_->ir_builder_.CreateAdd(rowid_lv, rowid_offset_lv);
   }
   if (table_generation.start_rowid > 0) {
     CHECK(start_rowid_lv);
     rowid_lv = cgen_state_->ir_builder_.CreateAdd(rowid_lv, start_rowid_lv);
   }
   return rowid_lv;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CodeGenerator::codegenSkipOverflowCheckForNull	(	llvm::Value *	lhs_lv,
		llvm::Value *	rhs_lv,
		llvm::BasicBlock *	no_overflow_bb,
		const SQLTypeInfo &	ti
	)

private

Definition at line 345 of file ArithmeticIR.cpp.

References cgen_state_, codegenIsNullNumber(), CgenState::context_, CgenState::current_func_, and CgenState::ir_builder_.

Referenced by codegenAdd(), codegenBinOpWithOverflowForCPU(), codegenDiv(), codegenMul(), codegenSub(), and codegenUMinus().

                                                                            {
   const auto lhs_is_null_lv = codegenIsNullNumber(lhs_lv, ti);
   const auto has_null_operand_lv =
       rhs_lv ? cgen_state_->ir_builder_.CreateOr(lhs_is_null_lv,
                                                  codegenIsNullNumber(rhs_lv, ti))
              : lhs_is_null_lv;
   auto operands_not_null = llvm::BasicBlock::Create(
       cgen_state_->context_, "operands_not_null", cgen_state_->current_func_);
   cgen_state_->ir_builder_.CreateCondBr(
       has_null_operand_lv, no_overflow_bb, operands_not_null);
   cgen_state_->ir_builder_.SetInsertPoint(operands_not_null);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenStrCmp	(	const SQLOps	optype,
		const SQLQualifier	qualifier,
		const std::shared_ptr< Analyzer::Expr >	lhs,
		const std::shared_ptr< Analyzer::Expr >	rhs,
		const CompilationOptions &	co
	)

private

Definition at line 372 of file CompareIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegenDictStrCmp(), get_null_check_suffix(), and kENCODING_DICT.

Referenced by codegenCmp().

                                                                         {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto lhs_ti = lhs->get_type_info();
   const auto rhs_ti = rhs->get_type_info();
 
   CHECK(lhs_ti.is_string());
   CHECK(rhs_ti.is_string());
 
   const auto null_check_suffix = get_null_check_suffix(lhs_ti, rhs_ti);
   if (lhs_ti.get_compression() == kENCODING_DICT &&
       rhs_ti.get_compression() == kENCODING_DICT) {
     if (lhs_ti.getStringDictKey() == rhs_ti.getStringDictKey()) {
       // Both operands share a dictionary
       // check if query is trying to compare a column against literal
       auto ir = codegenDictStrCmp(lhs, rhs, optype, co);
       if (ir) {
         return ir;
       }
     } else {
       // Both operands don't share a dictionary
       return nullptr;
     }
   }
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair< std::vector< llvm::Value * >, std::unique_ptr< CodeGenerator::NullCheckCodegen > > CodeGenerator::codegenStringFetchAndEncode	(	const Analyzer::StringOper *	expr,
		const CompilationOptions &	co,
		const size_t	arg_idx,
		const bool	codegen_nullcheck
	)

private

Definition at line 302 of file StringOpsIR.cpp.

References cgen_state_, CHECK, CHECK_EQ, CHECK_LT, codegen(), CgenState::context_, createStringViewStructType(), CgenState::emitExternalCall(), executor(), executor_, Analyzer::Expr::get_type_info(), Analyzer::StringOper::getArg(), Analyzer::StringOper::getArity(), CgenState::ir_builder_, kENCODING_DICT, kTEXT, and CgenState::llInt().

Referenced by codegenPerRowStringOper().

                                                                          {
   CHECK_LT(arg_idx, expr->getArity());
   const auto& arg_ti = expr->getArg(arg_idx)->get_type_info();
 
   auto primary_str_lv = codegen(expr->getArg(arg_idx), true, co);
   std::unique_ptr<CodeGenerator::NullCheckCodegen> nullcheck_codegen;
   if (primary_str_lv.size() != 3 && arg_ti.is_dict_encoded_string()) {
     // If this is the case we should have a transient dictionary from a previous op
     // We can't use the dictionary values without decoding as this op occurs directly
     // inline on top of whatever operation created the transient dictionary
     CHECK_EQ(size_t(1), primary_str_lv.size());
     const bool is_nullable = !arg_ti.get_notnull();
     if (codegen_nullcheck && is_nullable) {
       const auto decoded_input_ti = SQLTypeInfo(kTEXT, is_nullable, kENCODING_DICT);
       nullcheck_codegen = std::make_unique<CodeGenerator::NullCheckCodegen>(
           cgen_state_,
           executor_,
           primary_str_lv[0],
           decoded_input_ti,
           "transient_dict_per_row_nullcheck");
     }
     const auto sdp_ptr = reinterpret_cast<int64_t>(executor()->getStringDictionaryProxy(
         arg_ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true));
     const auto string_view =
         cgen_state_->emitExternalCall("string_decompress",
                                       createStringViewStructType(),
                                       {primary_str_lv[0], cgen_state_->llInt(sdp_ptr)});
     primary_str_lv.push_back(cgen_state_->ir_builder_.CreateExtractValue(string_view, 0));
     primary_str_lv.push_back(cgen_state_->ir_builder_.CreateExtractValue(string_view, 1));
     primary_str_lv.back() = cgen_state_->ir_builder_.CreateTrunc(
         primary_str_lv.back(), llvm::Type::getInt32Ty(cgen_state_->context_));
   } else if (primary_str_lv.size() == 1 and arg_ti.is_none_encoded_string()) {
     // real (not dictionary-encoded) strings
     CHECK(primary_str_lv[0]->getType()->isPointerTy());
     const auto none_enc_string = cgen_state_->ir_builder_.CreateLoad(
         primary_str_lv[0]->getType()->getPointerElementType(), primary_str_lv[0]);
     primary_str_lv.push_back(
         cgen_state_->ir_builder_.CreateExtractValue(none_enc_string, 0));
     primary_str_lv.push_back(cgen_state_->ir_builder_.CreateTrunc(
         cgen_state_->ir_builder_.CreateExtractValue(none_enc_string, 1),
         llvm::Type::getInt32Ty(cgen_state_->context_)));
   }
   CHECK_EQ(size_t(3), primary_str_lv.size());
   return std::make_pair(primary_str_lv, std::move(nullcheck_codegen));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenSub	(	const Analyzer::BinOper *	bin_oper,
		llvm::Value *	lhs_lv,
		llvm::Value *	rhs_lv,
		const std::string &	null_typename,
		const std::string &	null_check_suffix,
		const SQLTypeInfo &	ti,
		const CompilationOptions &	co
	)

private

Definition at line 281 of file ArithmeticIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, checkExpressionRanges(), codegenBinOpWithOverflowForCPU(), codegenSkipOverflowCheckForNull(), CgenState::context_, CPU, CgenState::current_func_, CompilationOptions::device_type, CgenState::emitCall(), SQLTypeInfo::get_size(), inline_int_null_val(), CgenState::inlineIntMaxMin(), CgenState::ir_builder_, SQLTypeInfo::is_decimal(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_timeinterval(), CgenState::llInt(), and CgenState::needs_error_check_.

Referenced by codegenIntArith().

                                                                      {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK_EQ(lhs_lv->getType(), rhs_lv->getType());
   CHECK(ti.is_integer() || ti.is_decimal() || ti.is_timeinterval());
   llvm::Value* chosen_max{nullptr};
   llvm::Value* chosen_min{nullptr};
   std::tie(chosen_max, chosen_min) = cgen_state_->inlineIntMaxMin(ti.get_size(), true);
   auto need_overflow_check =
       !checkExpressionRanges(bin_oper,
                              static_cast<llvm::ConstantInt*>(chosen_min)->getSExtValue(),
                              static_cast<llvm::ConstantInt*>(chosen_max)->getSExtValue());
 
   if (need_overflow_check && co.device_type == ExecutorDeviceType::CPU) {
     return codegenBinOpWithOverflowForCPU(
         bin_oper, lhs_lv, rhs_lv, null_check_suffix, ti);
   }
 
   llvm::BasicBlock* sub_ok{nullptr};
   llvm::BasicBlock* sub_fail{nullptr};
   if (need_overflow_check) {
     cgen_state_->needs_error_check_ = true;
     sub_ok = llvm::BasicBlock::Create(
         cgen_state_->context_, "sub_ok", cgen_state_->current_func_);
     if (!null_check_suffix.empty()) {
       codegenSkipOverflowCheckForNull(lhs_lv, rhs_lv, sub_ok, ti);
     }
     sub_fail = llvm::BasicBlock::Create(
         cgen_state_->context_, "sub_fail", cgen_state_->current_func_);
     llvm::Value* detected{nullptr};
     auto const_zero = llvm::ConstantInt::get(lhs_lv->getType(), 0, true);
     auto overflow = cgen_state_->ir_builder_.CreateAnd(
         cgen_state_->ir_builder_.CreateICmpSLT(
             rhs_lv, const_zero),  // sub going up, check the max
         cgen_state_->ir_builder_.CreateICmpSGT(
             lhs_lv, cgen_state_->ir_builder_.CreateAdd(chosen_max, rhs_lv)));
     auto underflow = cgen_state_->ir_builder_.CreateAnd(
         cgen_state_->ir_builder_.CreateICmpSGT(
             rhs_lv, const_zero),  // sub going down, check the min
         cgen_state_->ir_builder_.CreateICmpSLT(
             lhs_lv, cgen_state_->ir_builder_.CreateAdd(chosen_min, rhs_lv)));
     detected = cgen_state_->ir_builder_.CreateOr(overflow, underflow);
     cgen_state_->ir_builder_.CreateCondBr(detected, sub_fail, sub_ok);
     cgen_state_->ir_builder_.SetInsertPoint(sub_ok);
   }
   auto ret = null_check_suffix.empty()
                  ? cgen_state_->ir_builder_.CreateSub(lhs_lv, rhs_lv)
                  : cgen_state_->emitCall(
                        "sub_" + null_typename + null_check_suffix,
                        {lhs_lv, rhs_lv, cgen_state_->llInt(inline_int_null_val(ti))});
   if (need_overflow_check) {
     cgen_state_->ir_builder_.SetInsertPoint(sub_fail);
     cgen_state_->ir_builder_.CreateRet(
         cgen_state_->llInt(int32_t(ErrorCode::OVERFLOW_OR_UNDERFLOW)));
     cgen_state_->ir_builder_.SetInsertPoint(sub_ok);
   }
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenTreeRegPredict	(	const Analyzer::MLPredictExpr *	expr,
		const std::shared_ptr< AbstractTreeModel > &	tree_model,
		const CompilationOptions &	co
	)

private

Definition at line 181 of file MLPredictCodegen.cpp.

References cgen_state_, CHECK_EQ, codegen(), TreeModelPredictionMgr::codegen(), Data_Namespace::CPU_LEVEL, DEBUG_TIMER, CompilationOptions::device_type, executor(), generated_encoded_and_casted_features(), Analyzer::MLPredictExpr::get_regressor_values(), GPU, Data_Namespace::GPU_LEVEL, CgenState::moveTreeModelPredictionMgr(), threading_serial::parallel_for(), RANDOM_FOREST_REG, and VLOG.

Referenced by codegen().

                                   {
 #ifdef HAVE_ONEDAL
   const int64_t num_trees = static_cast<int64_t>(tree_model->getNumTrees());
   const auto& regressor_exprs = expr->get_regressor_values();
   const auto& cat_feature_keys = tree_model->getCatFeatureKeys();
   const auto casted_regressor_exprs = generated_encoded_and_casted_features(
       regressor_exprs,
       cat_feature_keys,
       tree_model->getModelMetadata().getFeaturePermutations(),
       executor());
   // We cast all regressors to double for simplicity and to match
   // how feature filters are stored in the tree model.
   // Null checks are handled further down in the generated kernel
   // in the runtime function itself
 
   std::vector<llvm::Value*> regressor_values;
   for (const auto& casted_regressor_expr : casted_regressor_exprs) {
     regressor_values.emplace_back(codegen(casted_regressor_expr.get(), false, co)[0]);
   }
 
   // First build tables, i.e. vectors of DecisionTreeEntry, for each tree
   std::vector<std::vector<DecisionTreeEntry>> decision_trees(num_trees);
   {
     auto tree_build_timer = DEBUG_TIMER("Tree Visitors Dispatched");
     tbb::parallel_for(tbb::blocked_range<int64_t>(0, num_trees),
                       [&](const tbb::blocked_range<int64_t>& r) {
                         const auto start_tree_idx = r.begin();
                         const auto end_tree_idx = r.end();
                         for (int64_t tree_idx = start_tree_idx; tree_idx < end_tree_idx;
                              ++tree_idx) {
                           TreeModelVisitor tree_visitor(decision_trees[tree_idx]);
                           tree_model->traverseDF(tree_idx, tree_visitor);
                         }
                       });
   }
 
   // Next, compute prefix-sum offset such that decision_tree_offsets[k]
   // specifies the starting offset of tree k relative to tree 0, and
   // decision_tree_offsets[k+1] specifies the last entry + 1 of tree
   // k relative to tree 0
   std::vector<int64_t> decision_tree_offsets(num_trees + 1);
   decision_tree_offsets[0] = 0;
   for (int64_t tree_idx = 0; tree_idx < num_trees; ++tree_idx) {
     decision_tree_offsets[tree_idx + 1] =
         decision_tree_offsets[tree_idx] +
         static_cast<int64_t>(decision_trees[tree_idx].size());
   }
 
   VLOG(1) << tree_model->getModelTypeString() << " model has " << num_trees
           << " trees and " << decision_tree_offsets[num_trees] << " total entries.";
 
   // Finally, go back through each tree and adjust all left and right child idx entries
   // such that such values are global relative to the start of tree 0. This will allow
   // the downstream code-generated kernel to be able treat these child idx entries as
   // as absolute offsets from the base pointer for all trees, rather than computing such
   // an offset on the fly
   {
     auto tree_offset_correction_timer = DEBUG_TIMER("Tree Offsets Corrected");
     tbb::parallel_for(
         tbb::blocked_range<int64_t>(1, num_trees),
         [&](const tbb::blocked_range<int64_t>& r) {
           const auto start_tree_idx = r.begin();
           const auto end_tree_idx = r.end();
           for (int64_t tree_idx = start_tree_idx; tree_idx < end_tree_idx; ++tree_idx) {
             const int64_t start_offset = decision_tree_offsets[tree_idx];
             auto& decision_tree = decision_trees[tree_idx];
             const int64_t num_tree_entries = static_cast<int64_t>(decision_tree.size());
             CHECK_EQ(num_tree_entries,
                      decision_tree_offsets[tree_idx + 1] - start_offset);
             for (int64_t decision_entry_idx = 0; decision_entry_idx < num_tree_entries;
                  ++decision_entry_idx) {
               if (decision_tree[decision_entry_idx].isSplitNode()) {
                 decision_tree[decision_entry_idx].left_child_row_idx += start_offset;
                 decision_tree[decision_entry_idx].right_child_row_idx += start_offset;
               }
             }
           }
         });
   }
 
   {
     auto tree_model_prediction_mgr_timer =
         DEBUG_TIMER("TreeModelPredictionMgr generation and codegen");
     // TreeModelPredictionMgr copies the decision trees and offsets to host
     // buffers in RowSetMemoryOwner and onto each GPU if the query is running
     // on GPU, and takes care of the tree traversal codegen itself
 
     const bool compute_avg = tree_model->getModelType() == MLModelType::RANDOM_FOREST_REG;
     auto tree_model_prediction_mgr = std::make_unique<TreeModelPredictionMgr>(
         co.device_type == ExecutorDeviceType::GPU ? Data_Namespace::GPU_LEVEL
                                                   : Data_Namespace::CPU_LEVEL,
         executor(),
         decision_trees,
         decision_tree_offsets,
         compute_avg);
 
     return cgen_state_->moveTreeModelPredictionMgr(std::move(tree_model_prediction_mgr))
         ->codegen(regressor_values, co);
   }
 #else
   throw std::runtime_error("OneDAL not available.");
 #endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenUMinus	(	const Analyzer::UOper *	uoper,
		const CompilationOptions &	co
	)

private

Definition at line 654 of file ArithmeticIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK_EQ, checkExpressionRanges(), codegen(), codegenSkipOverflowCheckForNull(), CgenState::context_, CgenState::current_func_, CgenState::emitCall(), Analyzer::UOper::get_operand(), Analyzer::UOper::get_optype(), Analyzer::Expr::get_type_info(), CgenState::inlineFpNull(), CgenState::inlineIntMaxMin(), CgenState::inlineIntNull(), CgenState::ir_builder_, kUMINUS, CgenState::llInt(), CgenState::needs_error_check_, and numeric_type_name().

Referenced by codegen().

                                                                         {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK_EQ(uoper->get_optype(), kUMINUS);
   const auto operand_lv = codegen(uoper->get_operand(), true, co).front();
   const auto& ti = uoper->get_type_info();
   llvm::Value* chosen_max{nullptr};
   llvm::Value* chosen_min{nullptr};
   bool need_overflow_check = false;
   if (ti.is_integer() || ti.is_decimal() || ti.is_timeinterval()) {
     std::tie(chosen_max, chosen_min) = cgen_state_->inlineIntMaxMin(ti.get_size(), true);
     need_overflow_check = !checkExpressionRanges(
         uoper,
         static_cast<llvm::ConstantInt*>(chosen_min)->getSExtValue(),
         static_cast<llvm::ConstantInt*>(chosen_max)->getSExtValue());
   }
   llvm::BasicBlock* uminus_ok{nullptr};
   llvm::BasicBlock* uminus_fail{nullptr};
   if (need_overflow_check) {
     cgen_state_->needs_error_check_ = true;
     uminus_ok = llvm::BasicBlock::Create(
         cgen_state_->context_, "uminus_ok", cgen_state_->current_func_);
     if (!ti.get_notnull()) {
       codegenSkipOverflowCheckForNull(operand_lv, nullptr, uminus_ok, ti);
     }
     uminus_fail = llvm::BasicBlock::Create(
         cgen_state_->context_, "uminus_fail", cgen_state_->current_func_);
     auto const_min = llvm::ConstantInt::get(
         operand_lv->getType(),
         static_cast<llvm::ConstantInt*>(chosen_min)->getSExtValue(),
         true);
     auto overflow = cgen_state_->ir_builder_.CreateICmpEQ(operand_lv, const_min);
     cgen_state_->ir_builder_.CreateCondBr(overflow, uminus_fail, uminus_ok);
     cgen_state_->ir_builder_.SetInsertPoint(uminus_ok);
   }
   auto ret =
       ti.get_notnull()
           ? (ti.is_fp() ? cgen_state_->ir_builder_.CreateFNeg(operand_lv)
                         : cgen_state_->ir_builder_.CreateNeg(operand_lv))
           : cgen_state_->emitCall(
                 "uminus_" + numeric_type_name(ti) + "_nullable",
                 {operand_lv,
                  ti.is_fp() ? static_cast<llvm::Value*>(cgen_state_->inlineFpNull(ti))
                             : static_cast<llvm::Value*>(cgen_state_->inlineIntNull(ti))});
   if (need_overflow_check) {
     cgen_state_->ir_builder_.SetInsertPoint(uminus_fail);
     cgen_state_->ir_builder_.CreateRet(
         cgen_state_->llInt(int32_t(ErrorCode::OVERFLOW_OR_UNDERFLOW)));
     cgen_state_->ir_builder_.SetInsertPoint(uminus_ok);
   }
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenUnnest	(	const Analyzer::UOper *	uoper,
		const CompilationOptions &	co
	)

private

Definition at line 20 of file ArrayIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, codegen(), and Analyzer::UOper::get_operand().

Referenced by codegen().

                                                                         {
   AUTOMATIC_IR_METADATA(cgen_state_);
   return codegen(uoper->get_operand(), true, co).front();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenVariableLengthStringColVar	(	llvm::Value *	col_byte_stream,
		llvm::Value *	pos_arg
	)

private

Definition at line 377 of file ColumnIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CgenState::context_, createStringViewStructType(), CgenState::emitExternalCall(), and CgenState::ir_builder_.

Referenced by codegenColVar().

                         {
   AUTOMATIC_IR_METADATA(cgen_state_);
   // real (not dictionary-encoded) strings; store the pointer to the payload
   auto* const string_view = cgen_state_->emitExternalCall(
       "string_decode", createStringViewStructType(), {col_byte_stream, pos_arg});
   auto* str_lv = cgen_state_->ir_builder_.CreateExtractValue(string_view, 0);
   auto* len_lv = cgen_state_->ir_builder_.CreateExtractValue(string_view, 1);
   len_lv = cgen_state_->ir_builder_.CreateTrunc(
       len_lv, llvm::Type::getInt32Ty(cgen_state_->context_));
   return {string_view, str_lv, len_lv};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenWidthBucketExpr	(	const Analyzer::WidthBucketExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 437 of file IRCodegen.cpp.

References Analyzer::WidthBucketExpr::can_skip_out_of_bound_check(), cgen_state_, CHECK, CHECK_EQ, codegen(), codegenCastBetweenIntTypes(), codegenCmp(), CgenState::context_, CgenState::current_func_, CgenState::emitCall(), Analyzer::WidthBucketExpr::get_lower_bound(), Analyzer::WidthBucketExpr::get_partition_count(), Analyzer::WidthBucketExpr::get_target_value(), Analyzer::WidthBucketExpr::get_upper_bound(), CgenState::inlineFpNull(), CgenState::ir_builder_, kGT, kINT, kONE, CgenState::llInt(), CgenState::needs_error_check_, and toBool().

Referenced by codegen().

                                                                                  {
   auto target_value_expr = expr->get_target_value();
   auto lower_bound_expr = expr->get_lower_bound();
   auto upper_bound_expr = expr->get_upper_bound();
   auto partition_count_expr = expr->get_partition_count();
 
   std::string func_name = "width_bucket_expr";
   bool nullable_expr = false;
   if (expr->can_skip_out_of_bound_check()) {
     func_name += "_no_oob_check";
   } else if (!target_value_expr->get_type_info().get_notnull()) {
     func_name += "_nullable";
     nullable_expr = true;
   }
 
   auto target_value_expr_lvs = codegen(target_value_expr, true, co);
   CHECK_EQ(size_t(1), target_value_expr_lvs.size());
   auto lower_bound_expr_lvs = codegen(lower_bound_expr, true, co);
   CHECK_EQ(size_t(1), lower_bound_expr_lvs.size());
   auto upper_bound_expr_lvs = codegen(upper_bound_expr, true, co);
   CHECK_EQ(size_t(1), upper_bound_expr_lvs.size());
   auto partition_count_expr_lvs = codegen(partition_count_expr, true, co);
   CHECK_EQ(size_t(1), partition_count_expr_lvs.size());
   auto target_value_ti = target_value_expr->get_type_info();
   auto null_value_lv = cgen_state_->inlineFpNull(target_value_ti);
 
   // check partition count : 1 ~ INT32_MAX
   // INT32_MAX will be checked during casting by OVERFLOW checking step
   auto partition_count_ti = partition_count_expr->get_type_info();
   CHECK(partition_count_ti.is_integer());
   auto int32_ti = SQLTypeInfo(kINT, partition_count_ti.get_notnull());
   auto partition_count_expr_lv =
       codegenCastBetweenIntTypes(partition_count_expr_lvs[0],
                                  partition_count_ti,
                                  int32_ti,
                                  partition_count_ti.get_size() < int32_ti.get_size());
   llvm::Value* chosen_min = cgen_state_->llInt(static_cast<int32_t>(0));
   llvm::Value* partition_count_min =
       cgen_state_->ir_builder_.CreateICmpSLE(partition_count_expr_lv, chosen_min);
   llvm::BasicBlock* width_bucket_partition_count_ok_bb =
       llvm::BasicBlock::Create(cgen_state_->context_,
                                "width_bucket_partition_count_ok_bb",
                                cgen_state_->current_func_);
   llvm::BasicBlock* width_bucket_argument_check_fail_bb =
       llvm::BasicBlock::Create(cgen_state_->context_,
                                "width_bucket_argument_check_fail_bb",
                                cgen_state_->current_func_);
   cgen_state_->ir_builder_.CreateCondBr(partition_count_min,
                                         width_bucket_argument_check_fail_bb,
                                         width_bucket_partition_count_ok_bb);
   cgen_state_->ir_builder_.SetInsertPoint(width_bucket_argument_check_fail_bb);
   cgen_state_->ir_builder_.CreateRet(
       cgen_state_->llInt(int32_t(heavyai::ErrorCode::WIDTH_BUCKET_INVALID_ARGUMENT)));
   cgen_state_->ir_builder_.SetInsertPoint(width_bucket_partition_count_ok_bb);
 
   llvm::BasicBlock* width_bucket_bound_check_ok_bb =
       llvm::BasicBlock::Create(cgen_state_->context_,
                                "width_bucket_bound_check_ok_bb",
                                cgen_state_->current_func_);
   llvm::Value* bound_check{nullptr};
   if (lower_bound_expr->get_type_info().get_notnull() &&
       upper_bound_expr->get_type_info().get_notnull()) {
     bound_check = cgen_state_->ir_builder_.CreateFCmpOEQ(
         lower_bound_expr_lvs[0], upper_bound_expr_lvs[0], "bound_check");
   } else {
     std::vector<llvm::Value*> bound_check_args{
         lower_bound_expr_lvs[0],
         upper_bound_expr_lvs[0],
         null_value_lv,
         cgen_state_->llInt(static_cast<int8_t>(1))};
     bound_check = toBool(cgen_state_->emitCall("eq_double_nullable", bound_check_args));
   }
   cgen_state_->ir_builder_.CreateCondBr(
       bound_check, width_bucket_argument_check_fail_bb, width_bucket_bound_check_ok_bb);
   cgen_state_->ir_builder_.SetInsertPoint(width_bucket_bound_check_ok_bb);
   cgen_state_->needs_error_check_ = true;
   auto reversed_expr = toBool(codegenCmp(SQLOps::kGT,
                                          kONE,
                                          lower_bound_expr_lvs,
                                          lower_bound_expr->get_type_info(),
                                          upper_bound_expr,
                                          co));
   auto lower_bound_expr_lv = lower_bound_expr_lvs[0];
   auto upper_bound_expr_lv = upper_bound_expr_lvs[0];
   std::vector<llvm::Value*> width_bucket_args{target_value_expr_lvs[0],
                                               reversed_expr,
                                               lower_bound_expr_lv,
                                               upper_bound_expr_lv,
                                               partition_count_expr_lv};
   if (nullable_expr) {
     width_bucket_args.push_back(null_value_lv);
   }
   return cgen_state_->emitCall(func_name, width_bucket_args);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenWindowPosition	(	const WindowFunctionContext *	window_func_context,
		llvm::Value *	pos_arg
	)

Definition at line 235 of file ColumnIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CgenState::emitCall(), CgenState::llInt(), and WindowFunctionContext::output().

Referenced by codegenColVar(), Executor::codegenLoadCurrentValueFromColBuf(), and GroupByAndAggregate::codegenWindowRowPointer().

                         {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto window_position = cgen_state_->emitCall(
       "row_number_window_func",
       {cgen_state_->llInt(reinterpret_cast<const int64_t>(window_func_context->output())),
        pos_arg});
   return window_position;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codgenAdjustFixedEncNull	(	llvm::Value *	val,
		const SQLTypeInfo &	col_ti
	)

private

Definition at line 448 of file ColumnIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_LT, CgenState::context_, CgenState::emitCall(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_dimension(), get_int_type(), SQLTypeInfo::get_logical_size(), anonymous_namespace{ColumnIR.cpp}::get_phys_int_type(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_size(), SQLTypeInfo::get_subtype(), CgenState::inlineIntNull(), CgenState::ir_builder_, kENCODING_DICT, kENCODING_NONE, CgenState::llInt(), numeric_type_name(), and to_string().

Referenced by codegenFixedLengthColVar().

                                                                                 {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK_LT(col_ti.get_size(), col_ti.get_logical_size());
   const auto col_phys_width = col_ti.get_size() * 8;
   auto from_typename = "int" + std::to_string(col_phys_width) + "_t";
   auto adjusted = cgen_state_->ir_builder_.CreateCast(
       llvm::Instruction::CastOps::Trunc,
       val,
       get_int_type(col_phys_width, cgen_state_->context_));
   if (col_ti.get_compression() == kENCODING_DICT) {
     from_typename = "u" + from_typename;
     llvm::Value* from_null{nullptr};
     switch (col_ti.get_size()) {
       case 1:
         from_null = cgen_state_->llInt(std::numeric_limits<uint8_t>::max());
         break;
       case 2:
         from_null = cgen_state_->llInt(std::numeric_limits<uint16_t>::max());
         break;
       default:
         CHECK(false);
     }
     return cgen_state_->emitCall(
         "cast_" + from_typename + "_to_" + numeric_type_name(col_ti) + "_nullable",
         {adjusted, from_null, cgen_state_->inlineIntNull(col_ti)});
   }
   SQLTypeInfo col_phys_ti(get_phys_int_type(col_ti.get_size()),
                           col_ti.get_dimension(),
                           col_ti.get_scale(),
                           false,
                           kENCODING_NONE,
                           0,
                           col_ti.get_subtype());
   return cgen_state_->emitCall(
       "cast_" + from_typename + "_to_" + numeric_type_name(col_ti) + "_nullable",
       {adjusted,
        cgen_state_->inlineIntNull(col_phys_ti),
        cgen_state_->inlineIntNull(col_ti)});
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::colByteStream	(	const Analyzer::ColumnVar *	col_var,
		const bool	fetch_column,
		const bool	hoist_literals
	)

private

Definition at line 574 of file ColumnIR.cpp.

References cgen_state_, CHECK, CHECK_GE, CgenState::context_, PlanState::getLocalColumnId(), plan_state_, CgenState::row_func_, and to_string().

Referenced by codegenColVar().

                                                                      {
   CHECK_GE(cgen_state_->row_func_->arg_size(), size_t(3));
   const auto stream_arg_name =
       "col_buf" + std::to_string(plan_state_->getLocalColumnId(col_var, fetch_column));
   for (auto& arg : cgen_state_->row_func_->args()) {
     if (arg.getName() == stream_arg_name) {
       CHECK(arg.getType() == llvm::Type::getInt8PtrTy(cgen_state_->context_));
       return &arg;
     }
   }
   CHECK(false);
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr< InValuesBitmap > CodeGenerator::createInValuesBitmap	(	const Analyzer::InValues *	in_values,
		const CompilationOptions &	co
	)

private

Definition at line 112 of file InValuesIR.cpp.

References threading_serial::async(), AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegenIntConst(), Data_Namespace::CPU_LEVEL, cpu_threads(), CompilationOptions::device_type, executor(), extract_cast_arg(), Analyzer::InValues::get_arg(), get_nullable_type_info(), Analyzer::Expr::get_type_info(), Analyzer::InValues::get_value_list(), GPU, Data_Namespace::GPU_LEVEL, inline_int_null_val(), StringDictionary::INVALID_STR_ID, SQLTypeInfo::is_string(), and kENCODING_DICT.

Referenced by codegen().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto& value_list = in_values->get_value_list();
   const auto val_count = value_list.size();
   const auto& ti = in_values->get_arg()->get_type_info();
   if (!(ti.is_integer() || (ti.is_string() && ti.get_compression() == kENCODING_DICT))) {
     return nullptr;
   }
   const auto sdp =
       ti.is_string()
           ? executor()->getStringDictionaryProxy(
                 ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true)
           : nullptr;
   if (val_count > 3) {
     using ListIterator = decltype(value_list.begin());
     std::vector<int64_t> values;
     const auto needle_null_val = inline_int_null_val(ti);
     const int worker_count = val_count > 10000 ? cpu_threads() : int(1);
     std::vector<std::vector<int64_t>> values_set(worker_count, std::vector<int64_t>());
     std::vector<std::future<bool>> worker_threads;
     auto start_it = value_list.begin();
     for (size_t i = 0,
                 start_val = 0,
                 stride = (val_count + worker_count - 1) / worker_count;
          i < val_count && start_val < val_count;
          ++i, start_val += stride, std::advance(start_it, stride)) {
       auto end_it = start_it;
       std::advance(end_it, std::min(stride, val_count - start_val));
       const auto do_work = [&](std::vector<int64_t>& out_vals,
                                const ListIterator start,
                                const ListIterator end) -> bool {
         for (auto val_it = start; val_it != end; ++val_it) {
           const auto& in_val = *val_it;
           const auto in_val_const =
               dynamic_cast<const Analyzer::Constant*>(extract_cast_arg(in_val.get()));
           if (!in_val_const) {
             return false;
           }
           const auto& in_val_ti = in_val->get_type_info();
           CHECK(in_val_ti == ti || get_nullable_type_info(in_val_ti) == ti);
           if (ti.is_string()) {
             CHECK(sdp);
             const auto string_id =
                 in_val_const->get_is_null()
                     ? needle_null_val
                     : sdp->getIdOfString(*in_val_const->get_constval().stringval);
             if (string_id != StringDictionary::INVALID_STR_ID) {
               out_vals.push_back(string_id);
             }
           } else {
             out_vals.push_back(CodeGenerator::codegenIntConst(in_val_const, cgen_state_)
                                    ->getSExtValue());
           }
         }
         return true;
       };
       if (worker_count > 1) {
         worker_threads.push_back(std::async(
             std::launch::async, do_work, std::ref(values_set[i]), start_it, end_it));
       } else {
         do_work(std::ref(values), start_it, end_it);
       }
     }
     bool success = true;
     for (auto& worker : worker_threads) {
       success &= worker.get();
     }
     if (!success) {
       return nullptr;
     }
     if (worker_count > 1) {
       size_t total_val_count = 0;
       for (auto& vals : values_set) {
         total_val_count += vals.size();
       }
       values.reserve(total_val_count);
       for (auto& vals : values_set) {
         values.insert(values.end(), vals.begin(), vals.end());
       }
     }
     try {
       return std::make_unique<InValuesBitmap>(values,
                                               needle_null_val,
                                               co.device_type == ExecutorDeviceType::GPU
                                                   ? Data_Namespace::GPU_LEVEL
                                                   : Data_Namespace::CPU_LEVEL,
                                               executor()->deviceCount(co.device_type),
                                               executor()->data_mgr_,
                                               co);
     } catch (...) {
       return nullptr;
     }
   }
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::StructType * CodeGenerator::createLineStringStructType	(	const std::string &	udf_func_name,
		size_t	param_num
	)

private

Definition at line 923 of file ExtensionsIR.cpp.

References cgen_state_, CgenState::context_, and CgenState::module_.

Referenced by codegenGeoLineStringArgs().

                       {
   llvm::Module* module_for_lookup = cgen_state_->module_;
   llvm::Function* udf_func = module_for_lookup->getFunction(udf_func_name);
 
   llvm::StructType* generated_struct_type =
       llvm::StructType::get(cgen_state_->context_,
                             {llvm::Type::getInt8PtrTy(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_)},
                             false);
 
   if (udf_func) {
     llvm::FunctionType* udf_func_type = udf_func->getFunctionType();
     CHECK(param_num < udf_func_type->getNumParams());
     llvm::Type* param_pointer_type = udf_func_type->getParamType(param_num);
     CHECK(param_pointer_type->isPointerTy());
     llvm::Type* param_type = param_pointer_type->getPointerElementType();
     CHECK(param_type->isStructTy());
     llvm::StructType* struct_type = llvm::cast<llvm::StructType>(param_type);
     CHECK(struct_type->isStructTy());
     CHECK_EQ(struct_type->getStructNumElements(), 5u);
 
     const auto expected_elems = generated_struct_type->elements();
     const auto current_elems = struct_type->elements();
     for (size_t i = 0; i < expected_elems.size(); i++) {
       CHECK_EQ(expected_elems[i], current_elems[i]);
     }
     if (struct_type->isLiteral()) {
       return struct_type;
     }
 
     llvm::StringRef struct_name = struct_type->getStructName();
 #if LLVM_VERSION_MAJOR >= 12
     llvm::StructType* line_string_type =
         struct_type->getTypeByName(cgen_state_->context_, struct_name);
 #else
     llvm::StructType* line_string_type = module_for_lookup->getTypeByName(struct_name);
 #endif
     CHECK(line_string_type);
 
     return line_string_type;
   }
   return generated_struct_type;
 }

Here is the caller graph for this function:

llvm::StructType * CodeGenerator::createMultiLineStringStructType	(	const std::string &	udf_func_name,
		size_t	param_num
	)

private

Definition at line 1014 of file ExtensionsIR.cpp.

References cgen_state_, CgenState::context_, and CgenState::module_.

Referenced by codegenGeoMultiLineStringArgs().

                       {
   llvm::Module* module_for_lookup = cgen_state_->module_;
   llvm::Function* udf_func = module_for_lookup->getFunction(udf_func_name);
 
   llvm::StructType* generated_struct_type =
       llvm::StructType::get(cgen_state_->context_,
                             {llvm::Type::getInt8PtrTy(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt8PtrTy(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_)},
                             false);
 
   if (udf_func) {
     llvm::FunctionType* udf_func_type = udf_func->getFunctionType();
     CHECK(param_num < udf_func_type->getNumParams());
     llvm::Type* param_pointer_type = udf_func_type->getParamType(param_num);
     CHECK(param_pointer_type->isPointerTy());
     llvm::Type* param_type = param_pointer_type->getPointerElementType();
     CHECK(param_type->isStructTy());
     llvm::StructType* struct_type = llvm::cast<llvm::StructType>(param_type);
     CHECK(struct_type->isStructTy());
     CHECK_EQ(struct_type->getStructNumElements(), 7u);
 
     const auto expected_elems = generated_struct_type->elements();
     const auto current_elems = struct_type->elements();
     for (size_t i = 0; i < expected_elems.size(); i++) {
       CHECK_EQ(expected_elems[i], current_elems[i]);
     }
     if (struct_type->isLiteral()) {
       return struct_type;
     }
 
     llvm::StringRef struct_name = struct_type->getStructName();
 #if LLVM_VERSION_MAJOR >= 12
     llvm::StructType* multi_linestring_type =
         struct_type->getTypeByName(cgen_state_->context_, struct_name);
 #else
     llvm::StructType* multi_linestring_type =
         module_for_lookup->getTypeByName(struct_name);
 #endif
     CHECK(multi_linestring_type);
 
     return multi_linestring_type;
   }
   return generated_struct_type;
 }

Here is the caller graph for this function:

llvm::StructType * CodeGenerator::createMultiPointStructType	(	const std::string &	udf_func_name,
		size_t	param_num
	)

private

Definition at line 832 of file ExtensionsIR.cpp.

References cgen_state_, CgenState::context_, and CgenState::module_.

Referenced by codegenGeoMultiPointArgs().

                       {
   llvm::Module* module_for_lookup = cgen_state_->module_;
   llvm::Function* udf_func = module_for_lookup->getFunction(udf_func_name);
 
   llvm::StructType* generated_struct_type =
       llvm::StructType::get(cgen_state_->context_,
                             {llvm::Type::getInt8PtrTy(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_)},
                             false);
 
   if (udf_func) {
     llvm::FunctionType* udf_func_type = udf_func->getFunctionType();
     CHECK(param_num < udf_func_type->getNumParams());
     llvm::Type* param_pointer_type = udf_func_type->getParamType(param_num);
     CHECK(param_pointer_type->isPointerTy());
     llvm::Type* param_type = param_pointer_type->getPointerElementType();
     CHECK(param_type->isStructTy());
     llvm::StructType* struct_type = llvm::cast<llvm::StructType>(param_type);
     CHECK(struct_type->isStructTy());
     CHECK_EQ(struct_type->getStructNumElements(), 5u);
 
     const auto expected_elems = generated_struct_type->elements();
     const auto current_elems = struct_type->elements();
     for (size_t i = 0; i < expected_elems.size(); i++) {
       CHECK_EQ(expected_elems[i], current_elems[i]);
     }
     if (struct_type->isLiteral()) {
       return struct_type;
     }
 
     llvm::StringRef struct_name = struct_type->getStructName();
 #if LLVM_VERSION_MAJOR >= 12
     llvm::StructType* multi_point_type =
         struct_type->getTypeByName(cgen_state_->context_, struct_name);
 #else
     llvm::StructType* multi_point_type = module_for_lookup->getTypeByName(struct_name);
 #endif
     CHECK(multi_point_type);
 
     return multi_point_type;
   }
   return generated_struct_type;
 }

Here is the caller graph for this function:

llvm::StructType * CodeGenerator::createMultiPolygonStructType	(	const std::string &	udf_func_name,
		size_t	param_num
	)

private

Definition at line 1238 of file ExtensionsIR.cpp.

References cgen_state_, CgenState::context_, and CgenState::module_.

Referenced by codegenGeoMultiPolygonArgs().

                       {
   llvm::Function* udf_func = cgen_state_->module_->getFunction(udf_func_name);
 
   llvm::StructType* generated_struct_type =
       llvm::StructType::get(cgen_state_->context_,
                             {llvm::Type::getInt8PtrTy(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt8PtrTy(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt8PtrTy(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_)},
                             false);
 
   if (udf_func) {
     llvm::FunctionType* udf_func_type = udf_func->getFunctionType();
     CHECK(param_num < udf_func_type->getNumParams());
     llvm::Type* param_pointer_type = udf_func_type->getParamType(param_num);
     CHECK(param_pointer_type->isPointerTy());
     llvm::Type* param_type = param_pointer_type->getPointerElementType();
     CHECK(param_type->isStructTy());
     llvm::StructType* struct_type = llvm::cast<llvm::StructType>(param_type);
     CHECK(struct_type->isStructTy());
     CHECK_EQ(struct_type->getStructNumElements(), 9u);
     const auto expected_elems = generated_struct_type->elements();
     const auto current_elems = struct_type->elements();
     for (size_t i = 0; i < expected_elems.size(); i++) {
       CHECK_EQ(expected_elems[i], current_elems[i]);
     }
     if (struct_type->isLiteral()) {
       return struct_type;
     }
     llvm::StringRef struct_name = struct_type->getStructName();
 
 #if LLVM_VERSION_MAJOR >= 12
     llvm::StructType* polygon_type =
         struct_type->getTypeByName(cgen_state_->context_, struct_name);
 #else
     llvm::StructType* polygon_type = cgen_state_->module_->getTypeByName(struct_name);
 #endif
     CHECK(polygon_type);
 
     return polygon_type;
   }
   return generated_struct_type;
 }

Here is the caller graph for this function:

llvm::StructType * CodeGenerator::createPointStructType	(	const std::string &	udf_func_name,
		size_t	param_num
	)

private

Definition at line 744 of file ExtensionsIR.cpp.

References cgen_state_, CgenState::context_, and CgenState::module_.

Referenced by codegenGeoPointArgs().

                                                                          {
   llvm::Module* module_for_lookup = cgen_state_->module_;
   llvm::Function* udf_func = module_for_lookup->getFunction(udf_func_name);
 
   llvm::StructType* generated_struct_type =
       llvm::StructType::get(cgen_state_->context_,
                             {llvm::Type::getInt8PtrTy(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_)},
                             false);
 
   if (udf_func) {
     llvm::FunctionType* udf_func_type = udf_func->getFunctionType();
     CHECK(param_num < udf_func_type->getNumParams());
     llvm::Type* param_pointer_type = udf_func_type->getParamType(param_num);
     CHECK(param_pointer_type->isPointerTy());
     llvm::Type* param_type = param_pointer_type->getPointerElementType();
     CHECK(param_type->isStructTy());
     llvm::StructType* struct_type = llvm::cast<llvm::StructType>(param_type);
     CHECK_EQ(struct_type->getStructNumElements(), 5u)
         << serialize_llvm_object(struct_type);
     const auto expected_elems = generated_struct_type->elements();
     const auto current_elems = struct_type->elements();
     for (size_t i = 0; i < expected_elems.size(); i++) {
       CHECK_EQ(expected_elems[i], current_elems[i]);
     }
     if (struct_type->isLiteral()) {
       return struct_type;
     }
 
     llvm::StringRef struct_name = struct_type->getStructName();
 #if LLVM_VERSION_MAJOR >= 12
     llvm::StructType* point_type =
         struct_type->getTypeByName(cgen_state_->context_, struct_name);
 #else
     llvm::StructType* point_type = module_for_lookup->getTypeByName(struct_name);
 #endif
     CHECK(point_type);
 
     return point_type;
   }
   return generated_struct_type;
 }

Here is the caller graph for this function:

llvm::StructType * CodeGenerator::createPolygonStructType	(	const std::string &	udf_func_name,
		size_t	param_num
	)

private

Definition at line 1130 of file ExtensionsIR.cpp.

References cgen_state_, CgenState::context_, and CgenState::module_.

Referenced by codegenGeoPolygonArgs().

                                                                            {
   llvm::Module* module_for_lookup = cgen_state_->module_;
   llvm::Function* udf_func = module_for_lookup->getFunction(udf_func_name);
 
   llvm::StructType* generated_struct_type =
       llvm::StructType::get(cgen_state_->context_,
                             {llvm::Type::getInt8PtrTy(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt8PtrTy(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_),
                              llvm::Type::getInt32Ty(cgen_state_->context_)},
                             false);
 
   if (udf_func) {
     llvm::FunctionType* udf_func_type = udf_func->getFunctionType();
     CHECK(param_num < udf_func_type->getNumParams());
     llvm::Type* param_pointer_type = udf_func_type->getParamType(param_num);
     CHECK(param_pointer_type->isPointerTy());
     llvm::Type* param_type = param_pointer_type->getPointerElementType();
     CHECK(param_type->isStructTy());
     llvm::StructType* struct_type = llvm::cast<llvm::StructType>(param_type);
 
     CHECK(struct_type->isStructTy());
     CHECK_EQ(struct_type->getStructNumElements(), 7u);
 
     const auto expected_elems = generated_struct_type->elements();
     const auto current_elems = struct_type->elements();
     for (size_t i = 0; i < expected_elems.size(); i++) {
       CHECK_EQ(expected_elems[i], current_elems[i]);
     }
     if (struct_type->isLiteral()) {
       return struct_type;
     }
 
     llvm::StringRef struct_name = struct_type->getStructName();
 
 #if LLVM_VERSION_MAJOR >= 12
     llvm::StructType* polygon_type =
         struct_type->getTypeByName(cgen_state_->context_, struct_name);
 #else
     llvm::StructType* polygon_type = module_for_lookup->getTypeByName(struct_name);
 #endif
     CHECK(polygon_type);
 
     return polygon_type;
   }
   return generated_struct_type;
 }

Here is the caller graph for this function:

llvm::StructType * CodeGenerator::createStringViewStructType ( )

private

Definition at line 1781 of file ExtensionsIR.cpp.

References cgen_state_, and CgenState::context_.

Referenced by codegen(), codegenCastFromString(), codegenCmp(), codegenStringFetchAndEncode(), and codegenVariableLengthStringColVar().

                                                           {
   auto* const string_view_type =
       llvm::StructType::get(cgen_state_->context_,
                             {llvm::Type::getInt8PtrTy(cgen_state_->context_),
                              llvm::Type::getInt64Ty(cgen_state_->context_)});
   string_view_type->setName("StringView");
   return string_view_type;
 }

Here is the caller graph for this function:

llvm::Value * CodeGenerator::endArgsNullcheck	(	const ArgNullcheckBBs &	bbs,
		llvm::Value *	fn_ret_lv,
		llvm::Value *	null_array_ptr,
		const Analyzer::FunctionOper *	function_oper
	)

private

Definition at line 461 of file ExtensionsIR.cpp.

References CodeGenerator::ArgNullcheckBBs::args_notnull_bb, CodeGenerator::ArgNullcheckBBs::args_null_bb, AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CgenState::context_, anonymous_namespace{ExtensionsIR.cpp}::get_buffer_struct_type(), get_fp_type(), get_int_type(), anonymous_namespace{ExtensionsIR.cpp}::get_llvm_type_from_sql_array_type(), anonymous_namespace{ExtensionsIR.cpp}::get_sql_type_from_llvm_type(), Analyzer::Expr::get_type_info(), Analyzer::FunctionOper::getName(), CgenState::inlineFpNull(), CgenState::inlineIntNull(), CgenState::ir_builder_, and CodeGenerator::ArgNullcheckBBs::orig_bb.

Referenced by codegenFunctionOper(), and codegenFunctionOperWithCustomTypeHandling().

                                                {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (bbs.args_null_bb) {
     CHECK(bbs.args_notnull_bb);
     cgen_state_->ir_builder_.CreateBr(bbs.args_null_bb);
     cgen_state_->ir_builder_.SetInsertPoint(bbs.args_null_bb);
 
     llvm::PHINode* ext_call_phi{nullptr};
     llvm::Value* null_lv{nullptr};
     const auto func_ti = function_oper->get_type_info();
     if (!func_ti.is_buffer()) {
       // The pre-cast SQL equivalent of the type returned by the extension function.
       const auto extension_ret_ti = get_sql_type_from_llvm_type(fn_ret_lv->getType());
 
       ext_call_phi = cgen_state_->ir_builder_.CreatePHI(
           extension_ret_ti.is_fp()
               ? get_fp_type(extension_ret_ti.get_size() * 8, cgen_state_->context_)
               : get_int_type(extension_ret_ti.get_size() * 8, cgen_state_->context_),
           2);
 
       null_lv =
           extension_ret_ti.is_fp()
               ? static_cast<llvm::Value*>(cgen_state_->inlineFpNull(extension_ret_ti))
               : static_cast<llvm::Value*>(cgen_state_->inlineIntNull(extension_ret_ti));
     } else {
       const auto arr_struct_ty = get_buffer_struct_type(
           cgen_state_,
           function_oper->getName(),
           0,
           get_llvm_type_from_sql_array_type(func_ti, cgen_state_->context_));
       ext_call_phi =
           cgen_state_->ir_builder_.CreatePHI(llvm::PointerType::get(arr_struct_ty, 0), 2);
 
       CHECK(null_array_ptr);
       const auto arr_null_bool =
           cgen_state_->ir_builder_.CreateStructGEP(arr_struct_ty, null_array_ptr, 2);
       cgen_state_->ir_builder_.CreateStore(
           llvm::ConstantInt::get(get_int_type(8, cgen_state_->context_), 1),
           arr_null_bool);
 
       const auto arr_null_size =
           cgen_state_->ir_builder_.CreateStructGEP(arr_struct_ty, null_array_ptr, 1);
       cgen_state_->ir_builder_.CreateStore(
           llvm::ConstantInt::get(get_int_type(64, cgen_state_->context_), 0),
           arr_null_size);
     }
     ext_call_phi->addIncoming(fn_ret_lv, bbs.args_notnull_bb);
     ext_call_phi->addIncoming(func_ti.is_buffer() ? null_array_ptr : null_lv,
                               bbs.orig_bb);
 
     return ext_call_phi;
   }
   return fn_ret_lv;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Executor* CodeGenerator::executor ( ) const

inlineprotected

Definition at line 659 of file CodeGenerator.h.

References executor_.

Referenced by checkExpressionRanges(), codegen(), codegenArrayExpr(), codegenCastFromString(), codegenCastNonStringToString(), codegenColVar(), codegenDateTruncHighPrecisionTimestamps(), codegenDictLike(), codegenDictRegexp(), codegenDictStrCmp(), codegenFunctionOperCastArgs(), codegenGeoOperator(), codegenGeosConstructorCall(), codegenLinRegPredict(), codegenPerRowStringOper(), codegenPseudoStringOper(), codegenQualifierCmp(), codegenRowId(), codegenStringFetchAndEncode(), codegenTreeRegPredict(), createInValuesBitmap(), and CodeGenerator::NullCheckCodegen::NullCheckCodegen().

                              {
     if (!executor_) {
       throw ExecutorRequired();
     }
     return executor_;
   }

Here is the caller graph for this function:

llvm::Value * CodeGenerator::foundOuterJoinMatch ( const size_t nesting_level ) const

private

Definition at line 489 of file ColumnIR.cpp.

References cgen_state_, CHECK_GE, CHECK_LE, and CgenState::outer_join_match_found_per_level_.

Referenced by codegenColumn(), and codegenOuterJoinNullPlaceholder().

                                                                               {
   CHECK_GE(nesting_level, size_t(1));
   CHECK_LE(nesting_level,
            static_cast<size_t>(cgen_state_->outer_join_match_found_per_level_.size()));
   return cgen_state_->outer_join_match_found_per_level_[nesting_level - 1];
 }

Here is the caller graph for this function:

ExecutionEngineWrapper CodeGenerator::generateNativeCPUCode	(	llvm::Function *	func,
		const std::unordered_set< llvm::Function * > &	live_funcs,
		const CompilationOptions &	co
	)

static

Definition at line 439 of file NativeCodegen.cpp.

References CHECK, anonymous_namespace{NativeCodegen.cpp}::create_execution_engine(), DEBUG_TIMER, initialize_cpu_backend_mutex_, anonymous_namespace{ExtensionFunctionsGeo.hpp}::None, CompilationOptions::opt_level, anonymous_namespace{NativeCodegen.cpp}::optimize_ir(), and ReductionJIT.

Referenced by TableFunctionCompilationContext::finalize(), ResultSetReductionJIT::finalizeReductionCode(), ScalarCodeGenerator::generateNativeCode(), and StubGenerator::generateStub().

                                   {
   auto timer = DEBUG_TIMER(__func__);
   llvm::Module* llvm_module = func->getParent();
   CHECK(llvm_module);
   // run optimizations
 #ifndef WITH_JIT_DEBUG
   llvm::legacy::PassManager pass_manager;
   optimize_ir(
       func, llvm_module, pass_manager, live_funcs, /*is_gpu_smem_used=*/false, co);
 #endif  // WITH_JIT_DEBUG
 
   // The following lock avoids a data race in two places:
   // 1) in initializaiton of the CPU backend targets
   // 1) in llvm::sys::DynamicLibrary::getPermanentLibrary and
   // GDBJITRegistrationListener::notifyObjectLoaded while creating a
   // new ExecutionEngine instance in the child call create_execution_engine.
 
   // Todo: Initialize backend CPU (and perhaps GPU?) targets at startup
   // instead of for every compilation, and see if we can reduce
   // the scope of the below lock
 
   std::lock_guard<std::mutex> lock(initialize_cpu_backend_mutex_);
   auto init_err = llvm::InitializeNativeTarget();
   CHECK(!init_err);
 
   llvm::InitializeAllTargetMCs();
   llvm::InitializeNativeTargetAsmPrinter();
   llvm::InitializeNativeTargetAsmParser();
 
   std::string err_str;
   std::unique_ptr<llvm::Module> owner(llvm_module);
   CHECK(owner);
   llvm::EngineBuilder eb(std::move(owner));
   eb.setErrorStr(&err_str);
   eb.setEngineKind(llvm::EngineKind::JIT);
   llvm::TargetOptions to;
   to.EnableFastISel = true;
   eb.setTargetOptions(to);
   if (co.opt_level == ExecutorOptLevel::ReductionJIT) {
     eb.setOptLevel(llvm::CodeGenOpt::None);
   }
 
   return create_execution_engine(llvm_module, eb, co);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< GpuCompilationContext > CodeGenerator::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
	)

static

Definition at line 1194 of file NativeCodegen.cpp.

Referenced by TableFunctionCompilationContext::finalize(), and ScalarCodeGenerator::generateNativeGPUCode().

                                  {
 #ifdef HAVE_CUDA
   auto timer = DEBUG_TIMER(__func__);
   auto llvm_module = func->getParent();
   /*
     `func` is one of the following generated functions:
     - `call_table_function(i8** %input_col_buffers, i64*
       %input_row_count, i64** %output_buffers, i64* %output_row_count)`
       that wraps the user-defined table function.
     - `multifrag_query`
     - `multifrag_query_hoisted_literals`
     - ...
 
     `wrapper_func` is table_func_kernel(i32*, i8**, i64*, i64**,
     i64*) that wraps `call_table_function`.
 
     `llvm_module` is from `build/QueryEngine/RuntimeFunctions.bc` and it
     contains `func` and `wrapper_func`.  `llvm_module` should also contain
     the definitions of user-defined table functions.
 
     `live_funcs` contains table_func_kernel and call_table_function
 
     `gpu_target.cgen_state->module_` appears to be the same as `llvm_module`
    */
   CHECK(gpu_target.cgen_state->module_ == llvm_module);
   CHECK(func->getParent() == wrapper_func->getParent());
   llvm_module->setDataLayout(
       "e-p:64:64:64-i1:8:8-i8:8:8-"
       "i16:16:16-i32:32:32-i64:64:64-"
       "f32:32:32-f64:64:64-v16:16:16-"
       "v32:32:32-v64:64:64-v128:128:128-n16:32:64");
   llvm_module->setTargetTriple("nvptx64-nvidia-cuda");
   CHECK(gpu_target.nvptx_target_machine);
   llvm::PassManagerBuilder pass_manager_builder = llvm::PassManagerBuilder();
 
   pass_manager_builder.OptLevel = 0;
   llvm::legacy::PassManager module_pass_manager;
   pass_manager_builder.populateModulePassManager(module_pass_manager);
 
   bool requires_libdevice = check_module_requires_libdevice(llvm_module);
 
   if (requires_libdevice) {
     linkModuleWithLibdevice(executor, *llvm_module, pass_manager_builder, gpu_target);
   }
 
   // run optimizations
   optimize_ir(func, llvm_module, module_pass_manager, live_funcs, is_gpu_smem_used, co);
   legalize_nvvm_ir(func);
 
   std::stringstream ss;
   llvm::raw_os_ostream os(ss);
 
   llvm::LLVMContext& ctx = llvm_module->getContext();
   // Get "nvvm.annotations" metadata node
   llvm::NamedMDNode* md = llvm_module->getOrInsertNamedMetadata("nvvm.annotations");
 
   llvm::Metadata* md_vals[] = {llvm::ConstantAsMetadata::get(wrapper_func),
                                llvm::MDString::get(ctx, "kernel"),
                                llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
                                    llvm::Type::getInt32Ty(ctx), 1))};
 
   // Append metadata to nvvm.annotations
   md->addOperand(llvm::MDNode::get(ctx, md_vals));
 
   std::unordered_set<llvm::Function*> roots{wrapper_func, func};
   if (gpu_target.row_func_not_inlined) {
     clear_function_attributes(gpu_target.cgen_state->row_func_);
     roots.insert(gpu_target.cgen_state->row_func_);
     if (gpu_target.cgen_state->filter_func_) {
       roots.insert(gpu_target.cgen_state->filter_func_);
     }
   }
 
   // prevent helper functions from being removed
   for (auto f : gpu_target.cgen_state->helper_functions_) {
     roots.insert(f);
   }
 
   if (requires_libdevice) {
     for (llvm::Function& F : *llvm_module) {
       // Some libdevice functions calls another functions that starts with "__internal_"
       // prefix.
       // __internal_trig_reduction_slowpathd
       // __internal_accurate_pow
       // __internal_lgamma_pos
       // Those functions have a "noinline" attribute which prevents the optimizer from
       // inlining them into the body of @query_func
       if (F.hasName() && F.getName().startswith("__internal") && !F.isDeclaration()) {
         roots.insert(&F);
       }
       legalize_nvvm_ir(&F);
     }
   }
 
   // Prevent the udf function(s) from being removed the way the runtime functions are
   std::unordered_set<std::string> udf_declarations;
 
   if (executor->has_udf_module(/*is_gpu=*/true)) {
     for (auto& f : executor->get_udf_module(/*is_gpu=*/true)->getFunctionList()) {
       llvm::Function* udf_function = llvm_module->getFunction(f.getName());
 
       if (udf_function) {
         legalize_nvvm_ir(udf_function);
         roots.insert(udf_function);
 
         // If we have a udf that declares a external function
         // note it so we can avoid duplicate declarations
         if (f.isDeclaration()) {
           udf_declarations.insert(f.getName().str());
         }
       }
     }
   }
 
   if (executor->has_rt_udf_module(/*is_gpu=*/true)) {
     for (auto& f : executor->get_rt_udf_module(/*is_gpu=*/true)->getFunctionList()) {
       llvm::Function* udf_function = llvm_module->getFunction(f.getName());
       if (udf_function) {
         legalize_nvvm_ir(udf_function);
         roots.insert(udf_function);
 
         // If we have a udf that declares a external function
         // note it so we can avoid duplicate declarations
         if (f.isDeclaration()) {
           udf_declarations.insert(f.getName().str());
         }
       }
     }
   }
 
   std::vector<llvm::Function*> rt_funcs;
   for (auto& Fn : *llvm_module) {
     if (roots.count(&Fn)) {
       continue;
     }
     rt_funcs.push_back(&Fn);
   }
   for (auto& pFn : rt_funcs) {
     pFn->removeFromParent();
   }
 
   if (requires_libdevice) {
     add_intrinsics_to_module(llvm_module);
   }
 
   if (!llvm_module->getModuleFlag("Debug Info Version")) {
     // Fixes QE-705
     llvm_module->addModuleFlag(
         llvm::Module::Error, "Debug Info Version", llvm::DEBUG_METADATA_VERSION);
   }
 
   llvm_module->print(os, nullptr);
   os.flush();
 
   for (auto& pFn : rt_funcs) {
     llvm_module->getFunctionList().push_back(pFn);
   }
   llvm_module->eraseNamedMetadata(md);
 
   auto cuda_llir = ss.str() + cuda_rt_decls + extension_function_decls(udf_declarations);
   std::string ptx;
   try {
     ptx = generatePTX(
         cuda_llir, gpu_target.nvptx_target_machine, gpu_target.cgen_state->context_);
   } catch (ParseIRError& e) {
     LOG(WARNING) << "Failed to generate PTX: " << e.what()
                  << ". Switching to CPU execution target.";
     throw QueryMustRunOnCpu();
   }
   LOG(PTX) << "PTX for the GPU:\n" << ptx << "\nEnd of PTX";
 
   CubinResult cubin_result = ptx_to_cubin(ptx, gpu_target.cuda_mgr);
   auto func_name = wrapper_func->getName().str();
   auto gpu_compilation_context = std::make_shared<GpuCompilationContext>();
   for (int device_id = 0; device_id < gpu_target.cuda_mgr->getDeviceCount();
        ++device_id) {
     gpu_compilation_context->addDeviceCode(
         std::make_unique<GpuDeviceCompilationContext>(cubin_result.cubin,
                                                       cubin_result.cubin_size,
                                                       func_name,
                                                       device_id,
                                                       gpu_target.cuda_mgr,
                                                       cubin_result.option_keys.size(),
                                                       cubin_result.option_keys.data(),
                                                       cubin_result.option_values.data()));
   }
 
   checkCudaErrors(cuLinkDestroy(cubin_result.link_state));
   return gpu_compilation_context;
 #else
   return {};
 #endif
 }

Here is the caller graph for this function:

std::string CodeGenerator::generatePTX	(	const std::string &	cuda_llir,
		llvm::TargetMachine *	nvptx_target_machine,
		llvm::LLVMContext &	context
	)

static

Definition at line 1478 of file NativeCodegen.cpp.

                                                                  {
   auto timer = DEBUG_TIMER(__func__);
   auto mem_buff = llvm::MemoryBuffer::getMemBuffer(cuda_llir, "", false);
 
   llvm::SMDiagnostic parse_error;
 
   auto llvm_module = llvm::parseIR(mem_buff->getMemBufferRef(), parse_error, context);
   if (!llvm_module) {
     LOG(IR) << "CodeGenerator::generatePTX:NVVM IR:\n" << cuda_llir << "\nEnd of NNVM IR";
     throw_parseIR_error(parse_error, "generatePTX", /* is_gpu= */ true);
   }
 
   llvm::SmallString<256> code_str;
   llvm::raw_svector_ostream formatted_os(code_str);
   CHECK(nvptx_target_machine);
   {
     llvm::legacy::PassManager ptxgen_pm;
     llvm_module->setDataLayout(nvptx_target_machine->createDataLayout());
 
 #if LLVM_VERSION_MAJOR >= 10
     nvptx_target_machine->addPassesToEmitFile(
         ptxgen_pm, formatted_os, nullptr, llvm::CGFT_AssemblyFile);
 #else
     nvptx_target_machine->addPassesToEmitFile(
         ptxgen_pm, formatted_os, nullptr, llvm::TargetMachine::CGFT_AssemblyFile);
 #endif
     ptxgen_pm.run(*llvm_module);
   }
 
 #if LLVM_VERSION_MAJOR >= 11
   return std::string(code_str);
 #else
   return code_str.str();
 #endif
 }

llvm::Function * CodeGenerator::getArithWithOverflowIntrinsic	(	const Analyzer::BinOper *	bin_oper,
		llvm::Type *	type
	)

private

Definition at line 707 of file ArithmeticIR.cpp.

References cgen_state_, logger::FATAL, Analyzer::BinOper::get_optype(), kMINUS, kMULTIPLY, kPLUS, LOG, CgenState::module_, and Analyzer::BinOper::toString().

Referenced by codegenBinOpWithOverflowForCPU().

                     {
   llvm::Intrinsic::ID fn_id{llvm::Intrinsic::not_intrinsic};
   switch (bin_oper->get_optype()) {
     case kMINUS:
       fn_id = llvm::Intrinsic::ssub_with_overflow;
       break;
     case kPLUS:
       fn_id = llvm::Intrinsic::sadd_with_overflow;
       break;
     case kMULTIPLY:
       fn_id = llvm::Intrinsic::smul_with_overflow;
       break;
     default:
       LOG(FATAL) << "unexpected arith with overflow optype: " << bin_oper->toString();
   }
 
   return llvm::Intrinsic::getDeclaration(cgen_state_->module_, fn_id, type);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< const Analyzer::Expr > CodeGenerator::hashJoinLhs ( const Analyzer::ColumnVar * rhs ) const

private

Definition at line 630 of file ColumnIR.cpp.

References CHECK, Analyzer::Expr::get_type_info(), hashJoinLhsTuple(), SQLTypeInfo::is_array(), is_constructed_point(), IS_EQUIVALENCE, SQLTypeInfo::is_string(), PlanState::join_info_, kCAST, plan_state_, and remove_cast_to_int().

Referenced by codegenColVar().

                                         {
   for (const auto& tautological_eq : plan_state_->join_info_.equi_join_tautologies_) {
     CHECK(IS_EQUIVALENCE(tautological_eq->get_optype()));
     if (dynamic_cast<const Analyzer::ExpressionTuple*>(
             tautological_eq->get_left_operand())) {
       auto lhs_col = hashJoinLhsTuple(rhs, tautological_eq.get());
       if (lhs_col) {
         return lhs_col;
       }
     } else {
       auto eq_right_op = tautological_eq->get_right_operand();
       if (!rhs->get_type_info().is_string()) {
         eq_right_op = remove_cast_to_int(eq_right_op);
       }
       if (!eq_right_op) {
         eq_right_op = tautological_eq->get_right_operand();
       }
       if (*eq_right_op == *rhs) {
         auto eq_left_op = tautological_eq->get_left_operand();
         if (!eq_left_op->get_type_info().is_string()) {
           eq_left_op = remove_cast_to_int(eq_left_op);
         }
         if (!eq_left_op) {
           eq_left_op = tautological_eq->get_left_operand();
         }
         if (eq_left_op->get_type_info().is_geometry()) {
           // skip cast for a geospatial lhs, since the rhs is likely to be a geospatial
           // physical col without geospatial type info
           return nullptr;
         }
         if (is_constructed_point(eq_left_op)) {
           // skip cast for a constructed point lhs
           return nullptr;
         }
         auto eq_left_op_col = dynamic_cast<const Analyzer::ColumnVar*>(eq_left_op);
         if (!eq_left_op_col) {
           if (dynamic_cast<const Analyzer::StringOper*>(eq_left_op)) {
             return nullptr;
           }
           if (dynamic_cast<const Analyzer::FunctionOper*>(eq_left_op)) {
             return nullptr;
           }
           auto const cast_expr = dynamic_cast<const Analyzer::UOper*>(eq_left_op);
           if (cast_expr && cast_expr->get_type_info().is_date()) {
             // sometimes we add cast operator explicitly when dealing w/ a join between
             // (encoded) date types. And we have necessary casting logic for hash join
             // depending on encoding types for date column.
             // Therefore, we can just pass the column variable it is originated from
             eq_left_op_col =
                 dynamic_cast<const Analyzer::ColumnVar*>(cast_expr->get_operand());
           }
         }
         CHECK(eq_left_op_col) << "Expect Analyzer::ColumnVar* type expression: "
                               << eq_left_op->toString();
         if (eq_left_op_col->get_rte_idx() != 0) {
           return nullptr;
         }
         if (rhs->get_type_info().is_string()) {
           return eq_left_op->deep_copy();
         }
         if (rhs->get_type_info().is_array()) {
           // Note(jclay): Can this be restored from copy as above?
           // If we fall through to the below return statement,
           // a superfulous cast from DOUBLE[] to DOUBLE[] is made and
           // this fails at a later stage in codegen.
           return nullptr;
         }
         return makeExpr<Analyzer::UOper>(
             rhs->get_type_info(), false, kCAST, eq_left_op->deep_copy());
       }
     }
   }
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< const Analyzer::ColumnVar > CodeGenerator::hashJoinLhsTuple	(	const Analyzer::ColumnVar *	rhs,
		const Analyzer::BinOper *	tautological_eq
	)		const

private

Definition at line 769 of file ColumnIR.cpp.

References CHECK, CHECK_EQ, Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_right_operand(), and Analyzer::ColumnVar::get_rte_idx().

Referenced by hashJoinLhs(), and needCastForHashJoinLhs().

                                                   {
   const auto lhs_tuple_expr =
       dynamic_cast<const Analyzer::ExpressionTuple*>(tautological_eq->get_left_operand());
   const auto rhs_tuple_expr = dynamic_cast<const Analyzer::ExpressionTuple*>(
       tautological_eq->get_right_operand());
   CHECK(lhs_tuple_expr && rhs_tuple_expr);
   const auto& lhs_tuple = lhs_tuple_expr->getTuple();
   const auto& rhs_tuple = rhs_tuple_expr->getTuple();
   CHECK_EQ(lhs_tuple.size(), rhs_tuple.size());
   for (size_t i = 0; i < lhs_tuple.size(); ++i) {
     if (*rhs_tuple[i] == *rhs) {
       const auto lhs_col =
           std::static_pointer_cast<const Analyzer::ColumnVar>(lhs_tuple[i]);
       return lhs_col->get_rte_idx() == 0 ? lhs_col : nullptr;
     }
   }
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr< llvm::TargetMachine > CodeGenerator::initializeNVPTXBackend ( const CudaMgr_Namespace::NvidiaDeviceArch arch )

static

Definition at line 1518 of file NativeCodegen.cpp.

Referenced by ScalarCodeGenerator::generateNativeGPUCode().

                                                   {
   auto timer = DEBUG_TIMER(__func__);
 
   std::lock_guard<std::mutex> lock(initialize_nvptx_mutex_);
 
   llvm::InitializeAllTargets();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmPrinters();
   std::string err;
   auto target = llvm::TargetRegistry::lookupTarget("nvptx64", err);
   if (!target) {
     LOG(FATAL) << err;
   }
   return std::unique_ptr<llvm::TargetMachine>(
       target->createTargetMachine("nvptx64-nvidia-cuda",
                                   CudaMgr_Namespace::CudaMgr::deviceArchToSM(arch),
                                   "",
                                   llvm::TargetOptions(),
                                   llvm::Reloc::Static));
 }

Here is the caller graph for this function:

void CodeGenerator::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`
	)

static

Definition at line 554 of file NativeCodegen.cpp.

References DEBUG_TIMER, logger::ERROR, f(), LOG, anonymous_namespace{ExtensionFunctionsGeo.hpp}::None, VLOG, and CgenState::vmap_.

Referenced by TableFunctionCompilationContext::finalize(), and Executor::optimizeAndCodegenCPU().

                                                            {
   auto timer = DEBUG_TIMER(__func__);
   // throw a runtime error if the target module contains functions
   // with the same name as in module of UDF functions.
   for (auto& f : *udf_module) {
     auto func = llvm_module.getFunction(f.getName());
     if (!(func == nullptr) && !f.isDeclaration() && flags == llvm::Linker::Flags::None) {
       LOG(ERROR) << "  Attempt to overwrite " << f.getName().str() << " in "
                  << llvm_module.getModuleIdentifier() << " from `"
                  << udf_module->getModuleIdentifier() << "`" << std::endl;
       throw std::runtime_error(
           "link_udf_module: *** attempt to overwrite a runtime function with a UDF "
           "function ***");
     } else {
       VLOG(1) << "  Adding " << f.getName().str() << " to "
               << llvm_module.getModuleIdentifier() << " from `"
               << udf_module->getModuleIdentifier() << "`" << std::endl;
     }
   }
 
   auto udf_module_copy = llvm::CloneModule(*udf_module, cgen_state->vmap_);
 
   udf_module_copy->setDataLayout(llvm_module.getDataLayout());
   udf_module_copy->setTargetTriple(llvm_module.getTargetTriple());
 
   // Initialize linker with module for RuntimeFunctions.bc
   llvm::Linker ld(llvm_module);
   bool link_error = false;
 
   link_error = ld.linkInModule(std::move(udf_module_copy), flags);
 
   if (link_error) {
     throw std::runtime_error("link_udf_module: *** error linking module ***");
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CodeGenerator::linkModuleWithLibdevice	(	Executor *	executor,
		llvm::Module &	module,
		llvm::PassManagerBuilder &	pass_manager_builder,
		const GPUTarget &	gpu_target
	)

static

Definition at line 1123 of file NativeCodegen.cpp.

                                  {
 #ifdef HAVE_CUDA
   auto timer = DEBUG_TIMER(__func__);
 
   if (!executor->has_libdevice_module()) {
     // raise error
     throw std::runtime_error(
         "libdevice library is not available but required by the UDF module");
   }
 
   // Saves functions \in module
   std::vector<llvm::Function*> roots;
   for (llvm::Function& fn : llvm_module) {
     if (!fn.isDeclaration()) {
       roots.emplace_back(&fn);
     }
   }
 
   // Bind libdevice to the current module
   CodeGenerator::link_udf_module(executor->get_libdevice_module(),
                                  llvm_module,
                                  gpu_target.cgen_state,
                                  llvm::Linker::Flags::OverrideFromSrc);
 
   std::unordered_set<llvm::Function*> live_funcs =
       findAliveRuntimeFuncs(llvm_module, roots);
 
   std::vector<llvm::Function*> funcs_to_delete;
   for (llvm::Function& fn : llvm_module) {
     if (!live_funcs.count(&fn)) {
       // deleting the function were would invalidate the iterator
       funcs_to_delete.emplace_back(&fn);
     }
   }
 
   for (llvm::Function* f : funcs_to_delete) {
     f->eraseFromParent();
   }
 
   // activate nvvm-reflect-ftz flag on the module
 #if LLVM_VERSION_MAJOR >= 11
   llvm::LLVMContext& ctx = llvm_module.getContext();
   llvm_module.setModuleFlag(llvm::Module::Override,
                             "nvvm-reflect-ftz",
                             llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
                                 llvm::Type::getInt32Ty(ctx), uint32_t(1))));
 #else
   llvm_module.addModuleFlag(llvm::Module::Override, "nvvm-reflect-ftz", uint32_t(1));
 #endif
   for (llvm::Function& fn : llvm_module) {
     fn.addFnAttr("nvptx-f32ftz", "true");
   }
 
   // add nvvm reflect pass replacing any NVVM conditionals with constants
   gpu_target.nvptx_target_machine->adjustPassManager(pass_manager_builder);
   llvm::legacy::FunctionPassManager FPM(&llvm_module);
   pass_manager_builder.populateFunctionPassManager(FPM);
 
   // Run the NVVMReflectPass here rather than inside optimize_ir
   FPM.doInitialization();
   for (auto& F : llvm_module) {
     FPM.run(F);
   }
   FPM.doFinalization();
 #endif
 }

std::unordered_set< llvm::Function * > CodeGenerator::markDeadRuntimeFuncs	(	llvm::Module &	module,
		const std::vector< llvm::Function * > &	roots,
		const std::vector< llvm::Function * > &	leaves
	)

static

Definition at line 1964 of file NativeCodegen.cpp.

                                             {
   auto timer = DEBUG_TIMER(__func__);
   std::unordered_set<llvm::Function*> live_funcs;
   live_funcs.insert(roots.begin(), roots.end());
   live_funcs.insert(leaves.begin(), leaves.end());
 
   if (auto F = llvm_module.getFunction("init_shared_mem_nop")) {
     live_funcs.insert(F);
   }
   if (auto F = llvm_module.getFunction("write_back_nop")) {
     live_funcs.insert(F);
   }
 
   for (const llvm::Function* F : roots) {
     for (const llvm::BasicBlock& BB : *F) {
       for (const llvm::Instruction& I : BB) {
         if (const llvm::CallInst* CI = llvm::dyn_cast<const llvm::CallInst>(&I)) {
           live_funcs.insert(CI->getCalledFunction());
         }
       }
     }
   }
 
   for (llvm::Function& F : llvm_module) {
     if (!live_funcs.count(&F) && !F.isDeclaration()) {
       F.setLinkage(llvm::GlobalValue::InternalLinkage);
     }
   }
 
   return live_funcs;
 }

bool CodeGenerator::needCastForHashJoinLhs ( const Analyzer::ColumnVar * rhs ) const

private

Definition at line 706 of file ColumnIR.cpp.

References CHECK, Analyzer::Expr::get_type_info(), hashJoinLhsTuple(), SQLTypeInfo::is_array(), is_constructed_point(), IS_EQUIVALENCE, SQLTypeInfo::is_string(), PlanState::join_info_, plan_state_, and remove_cast_to_int().

Referenced by codegenOuterJoinNullPlaceholder().

                                                                              {
   for (const auto& tautological_eq : plan_state_->join_info_.equi_join_tautologies_) {
     CHECK(IS_EQUIVALENCE(tautological_eq->get_optype()));
     if (dynamic_cast<const Analyzer::ExpressionTuple*>(
             tautological_eq->get_left_operand())) {
       auto lhs_col = hashJoinLhsTuple(rhs, tautological_eq.get());
       if (lhs_col) {
         // our join column normalizer falls back to the loop join
         // when columns of two join tables do not have the same types
         // todo (yoonmin): relax this
         return false;
       }
     } else {
       auto eq_right_op = tautological_eq->get_right_operand();
       if (!rhs->get_type_info().is_string()) {
         eq_right_op = remove_cast_to_int(eq_right_op);
       }
       if (!eq_right_op) {
         eq_right_op = tautological_eq->get_right_operand();
       }
       if (*eq_right_op == *rhs) {
         auto eq_left_op = tautological_eq->get_left_operand();
         if (!eq_left_op->get_type_info().is_string()) {
           eq_left_op = remove_cast_to_int(eq_left_op);
         }
         if (!eq_left_op) {
           eq_left_op = tautological_eq->get_left_operand();
         }
         if (eq_left_op->get_type_info().is_geometry()) {
           // skip cast for a geospatial lhs, since the rhs is likely to be a geospatial
           // physical col without geospatial type info
           return false;
         }
         if (is_constructed_point(eq_left_op)) {
           // skip cast for a constructed point lhs
           return false;
         }
         auto eq_left_op_col = dynamic_cast<const Analyzer::ColumnVar*>(eq_left_op);
         if (!eq_left_op_col) {
           if (dynamic_cast<const Analyzer::StringOper*>(eq_left_op)) {
             return false;
           }
           if (dynamic_cast<const Analyzer::FunctionOper*>(eq_left_op)) {
             return false;
           }
         }
         CHECK(eq_left_op_col);
         if (eq_left_op_col->get_rte_idx() != 0) {
           return false;
         }
         if (rhs->get_type_info().is_string()) {
           return false;
         }
         if (rhs->get_type_info().is_array()) {
           return false;
         }
         return true;
       }
     }
   }
   return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::posArg ( const Analyzer::Expr * expr ) const

Definition at line 590 of file ColumnIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CgenState::context_, get_int_type(), CgenState::ir_builder_, run_benchmark_import::result, CgenState::row_func_, and CgenState::scan_idx_to_hash_pos_.

Referenced by GroupByAndAggregate::codegen(), codegen(), GroupByAndAggregate::codegenAggArg(), TargetExprCodegen::codegenAggregate(), codegenArrayAt(), codegenColVar(), codegenFunctionOperCastArgs(), codegenFunctionOperNullArg(), codegenGeoArgs(), codegenGeoOperator(), codegenIsNull(), Executor::codegenJoinLoops(), RangeJoinHashTable::codegenKey(), BoundingBoxIntersectJoinHashTable::codegenKey(), BoundingBoxIntersectJoinHashTable::codegenManyKey(), GroupByAndAggregate::codegenOutputSlot(), codegenQualifierCmp(), codegenRowId(), Executor::codegenWindowFunctionAggregateCalls(), Executor::codegenWindowResetStateControlFlow(), GroupByAndAggregate::codegenWindowRowPointer(), and Executor::groupByColumnCodegen().

                                                                {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(expr);
   if (col_var && col_var->get_rte_idx() > 0) {
     const auto hash_pos_it =
         cgen_state_->scan_idx_to_hash_pos_.find(col_var->get_rte_idx());
     CHECK(hash_pos_it != cgen_state_->scan_idx_to_hash_pos_.end());
     if (hash_pos_it->second->getType()->isPointerTy()) {
       CHECK(hash_pos_it->second->getType()->getPointerElementType()->isIntegerTy(32));
       llvm::Value* result = cgen_state_->ir_builder_.CreateLoad(
           hash_pos_it->second->getType()->getPointerElementType(), hash_pos_it->second);
       result = cgen_state_->ir_builder_.CreateSExt(
           result, get_int_type(64, cgen_state_->context_));
       return result;
     }
     return hash_pos_it->second;
   }
   for (auto& arg : cgen_state_->row_func_->args()) {
     if (arg.getName() == "pos") {
       CHECK(arg.getType()->isIntegerTy(64));
       return &arg;
     }
   }
   abort();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CodeGenerator::prioritizeQuals	(	const RelAlgExecutionUnit &	ra_exe_unit,
		std::vector< Analyzer::Expr * > &	primary_quals,
		std::vector< Analyzer::Expr * > &	deferred_quals,
		const PlanState::HoistedFiltersSet &	hoisted_quals
	)

static

Definition at line 158 of file LogicalIR.cpp.

References anonymous_namespace{LogicalIR.cpp}::contains_unsafe_division(), anonymous_namespace{LogicalIR.cpp}::get_likelihood(), RelAlgExecutionUnit::quals, anonymous_namespace{LogicalIR.cpp}::should_defer_eval(), and RelAlgExecutionUnit::simple_quals.

                                                                                      {
   for (auto expr : ra_exe_unit.simple_quals) {
     if (hoisted_quals.find(expr) != hoisted_quals.end()) {
       continue;
     }
     if (should_defer_eval(expr)) {
       deferred_quals.push_back(expr.get());
       continue;
     }
     primary_quals.push_back(expr.get());
   }
 
   bool short_circuit = false;
 
   for (auto expr : ra_exe_unit.quals) {
     if (hoisted_quals.find(expr) != hoisted_quals.end()) {
       continue;
     }
 
     if (get_likelihood(expr.get()) < 0.10 && !contains_unsafe_division(expr.get())) {
       if (!short_circuit) {
         primary_quals.push_back(expr.get());
         short_circuit = true;
         continue;
       }
     }
     if (short_circuit || should_defer_eval(expr)) {
       deferred_quals.push_back(expr.get());
       continue;
     }
     primary_quals.push_back(expr.get());
   }
 
   return short_circuit;
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::resolveGroupedColumnReference ( const Analyzer::ColumnVar * col_var )

private

Definition at line 554 of file ColumnIR.cpp.

References cgen_state_, CHECK, CHECK_GE, CHECK_LE, Analyzer::ColumnVar::get_rte_idx(), Analyzer::ColumnVar::getColumnKey(), CgenState::group_by_expr_cache_, and Analyzer::Var::kGROUPBY.

Referenced by codegenColVar(), and codegenOuterJoinNullPlaceholder().

                                       {
   if (col_var->get_rte_idx() >= 0) {
     return nullptr;
   }
   const auto& column_key = col_var->getColumnKey();
   CHECK((column_key.column_id == 0) ||
         (col_var->get_rte_idx() >= 0 && column_key.table_id > 0));
   const auto var = dynamic_cast<const Analyzer::Var*>(col_var);
   CHECK(var);
   const auto var_no = var->get_varno();
   CHECK_GE(var_no, 1);
   if (var->get_which_row() == Analyzer::Var::kGROUPBY) {
     CHECK_LE(static_cast<size_t>(var_no), cgen_state_->group_by_expr_cache_.size());
     return cgen_state_->group_by_expr_cache_[var_no - 1];
   }
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::toBool ( llvm::Value * lv )

Definition at line 344 of file LogicalIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, and CgenState::ir_builder_.

Referenced by Executor::buildHoistLeftHandSideFiltersCb(), Executor::buildIsDeletedCb(), Executor::buildJoinLoops(), codegen(), codegenCase(), codegenCastBetweenIntTypesOverflowChecks(), codegenDiv(), codegenLogical(), codegenWidthBucketExpr(), and Executor::codegenWindowResetStateControlFlow().

                                               {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(lv->getType()->isIntegerTy());
   if (static_cast<llvm::IntegerType*>(lv->getType())->getBitWidth() > 1) {
     return cgen_state_->ir_builder_.CreateICmp(
         llvm::ICmpInst::ICMP_SGT, lv, llvm::ConstantInt::get(lv->getType(), 0));
   }
   return lv;
 }

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class GroupByAndAggregate

friend

Definition at line 668 of file CodeGenerator.h.

Member Data Documentation

CgenState* CodeGenerator::cgen_state_

protected

Definition at line 666 of file CodeGenerator.h.

Referenced by beginArgsNullcheck(), Executor::buildJoinLoops(), castArrayPointer(), codegen(), codegenAdd(), GroupByAndAggregate::codegenAggArg(), codegenArith(), codegenArrayAt(), codegenArrayBuff(), codegenArrayExpr(), codegenBinOpWithOverflowForCPU(), codegenBoundingBoxIntersect(), codegenBufferArgs(), codegenCase(), codegenCast(), codegenCastBetweenIntTypes(), codegenCastBetweenIntTypesOverflowChecks(), codegenCastBetweenTimestamps(), codegenCastFromFp(), codegenCastFromString(), codegenCastNonStringToString(), codegenCastTimestampToDate(), codegenCastTimestampToTime(), codegenCastToFp(), codegenCmp(), codegenCmpDecimalConst(), codegenColumn(), ScalarCodeGenerator::codegenColumn(), codegenColVar(), codegenCompression(), codegenConstantWidthBucketExpr(), codegenDateTruncHighPrecisionTimestamps(), codegenDeciDiv(), codegenDictLike(), codegenDictRegexp(), codegenDictStrCmp(), codegenDiv(), codegenExtractHighPrecisionTimestamps(), codegenFixedLengthColVar(), codegenFixedLengthColVarInWindow(), codegenFpArith(), codegenFunctionOper(), codegenFunctionOperCastArgs(), codegenFunctionOperNullArg(), codegenFunctionOperWithCustomTypeHandling(), codegenGeoArgs(), codegenGeoBinOper(), codegenGeoConstant(), codegenGeoLineStringArgs(), codegenGeoMultiLineStringArgs(), codegenGeoMultiPointArgs(), codegenGeoMultiPolygonArgs(), codegenGeoOperator(), codegenGeoPointArgs(), codegenGeoPolygonArgs(), codegenGeosConstructorCall(), codegenGeosPredicateCall(), codegenGeoUOper(), codegenHoistedConstants(), codegenHoistedConstantsLoads(), codegenHoistedConstantsPlaceholders(), codegenIntArith(), codegenIsNull(), codegenIsNullNumber(), codegenLinRegPredict(), codegenLogical(), codegenLogicalShortCircuit(), codegenMod(), codegenMul(), codegenOuterJoinNullPlaceholder(), codegenPerRowStringOper(), codegenPseudoStringOper(), codegenQualifierCmp(), codegenRowId(), codegenSkipOverflowCheckForNull(), codegenStrCmp(), codegenStringFetchAndEncode(), codegenSub(), codegenTreeRegPredict(), codegenUMinus(), codegenUnnest(), codegenVariableLengthStringColVar(), codegenWidthBucketExpr(), codegenWindowPosition(), codgenAdjustFixedEncNull(), colByteStream(), ScalarCodeGenerator::compile(), createInValuesBitmap(), createLineStringStructType(), createMultiLineStringStructType(), createMultiPointStructType(), createMultiPolygonStructType(), createPointStructType(), createPolygonStructType(), createStringViewStructType(), endArgsNullcheck(), foundOuterJoinMatch(), ScalarCodeGenerator::generateNativeGPUCode(), getArithWithOverflowIntrinsic(), posArg(), resolveGroupedColumnReference(), and toBool().

Executor* CodeGenerator::executor_

private

Definition at line 656 of file CodeGenerator.h.

Referenced by checkExpressionRanges(), codegen(), codegenCast(), codegenCmp(), codegenFixedLengthColVarInWindow(), codegenStringFetchAndEncode(), and executor().

std::mutex CodeGenerator::initialize_cpu_backend_mutex_

staticprivate

Definition at line 675 of file CodeGenerator.h.

Referenced by generateNativeCPUCode().

std::mutex CodeGenerator::initialize_nvptx_mutex_

staticprivate

Definition at line 672 of file CodeGenerator.h.

PlanState* CodeGenerator::plan_state_

protected

Definition at line 667 of file CodeGenerator.h.

Referenced by Executor::buildJoinLoops(), checkExpressionRanges(), codegen(), ScalarCodeGenerator::codegenColumn(), codegenColVar(), codegenGeoOperator(), colByteStream(), ScalarCodeGenerator::compile(), hashJoinLhs(), needCastForHashJoinLhs(), and ScalarCodeGenerator::prepare().

The documentation for this class was generated from the following files:

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/CodeGenerator.h
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ArithmeticIR.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ArrayIR.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/CaseIR.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/CastIR.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ColumnIR.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/CompareIR.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ConstantIR.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/DateTimeIR.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ExtensionsIR.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/GeoIR.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/InValuesIR.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/IRCodegen.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/LogicalIR.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/MLPredictCodegen.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/NativeCodegen.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/StringOpsIR.cpp

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation