#include <PointConstructor.h>

Inheritance diagram for spatial_type::PointConstructor:

Collaboration diagram for spatial_type::PointConstructor:

Public Member Functions
	PointConstructor (const Analyzer::GeoOperator *geo_operator)

std::unique_ptr < CodeGenerator::NullCheckCodegen >	getNullCheckCodegen (llvm::Value null_lv, CgenState cgen_state, Executor *executor) final

size_t	size () const final

SQLTypeInfo	getNullType () const final

std::tuple< std::vector < llvm::Value * >, llvm::Value * >	codegenLoads (const std::vector< llvm::Value * > &arg_lvs, const std::vector< llvm::Value * > &pos_lvs, CgenState *cgen_state) final

std::vector< llvm::Value * >	codegen (const std::vector< llvm::Value * > &args, CodeGenerator::NullCheckCodegen nullcheck_codegen, CgenState cgen_state, const CompilationOptions &co) final

Public Member Functions inherited from spatial_type::Codegen
	Codegen (const Analyzer::GeoOperator *geo_operator)

auto	isNullable () const

auto	getTypeInfo () const

std::string	getName () const

virtual const Analyzer::Expr *	getOperand (const size_t index)

virtual	~Codegen ()

Private Member Functions
llvm::Value *	codegenOperandIsNull (size_t idx, llvm::Value value, CgenState cgen_state)

Private Attributes
llvm::AllocaInst *	pt_local_storage_lv_ {nullptr}

Additional Inherited Members
Static Public Member Functions inherited from spatial_type::Codegen
static std::unique_ptr< Codegen >	init (const Analyzer::GeoOperator *geo_operator)

static char const *	pointIsNullFunctionName (SQLTypeInfo const &)

Protected Attributes inherited from spatial_type::Codegen
const Analyzer::GeoOperator *	operator_

bool	is_nullable_ {true}

Detailed Description

Definition at line 26 of file PointConstructor.h.

Constructor & Destructor Documentation

spatial_type::PointConstructor::PointConstructor ( const Analyzer::GeoOperator * geo_operator )

inline

Definition at line 28 of file PointConstructor.h.

References CHECK_EQ, Analyzer::Expr::get_type_info(), spatial_type::Codegen::is_nullable_, spatial_type::Codegen::operator_, and Analyzer::GeoOperator::size().

                                                             : Codegen(geo_operator) {
     CHECK_EQ(operator_->size(), size_t(2));
     const auto& ti = geo_operator->get_type_info();
     if (ti.get_notnull()) {
       is_nullable_ = false;
     } else {
       is_nullable_ = true;
     }
   }

Here is the call graph for this function:

Member Function Documentation

std::vector<llvm::Value*> spatial_type::PointConstructor::codegen	(	const std::vector< llvm::Value * > &	args,
		CodeGenerator::NullCheckCodegen *	nullcheck_codegen,
		CgenState *	cgen_state,
		const CompilationOptions &	co
	)

inlinefinalvirtual

Implements spatial_type::Codegen.

Definition at line 127 of file PointConstructor.h.

References run_benchmark_import::args, CHECK, CHECK_EQ, Analyzer::Expr::get_type_info(), kENCODING_GEOINT, kPOINT, spatial_type::Codegen::operator_, and pt_local_storage_lv_.

                                                                         {
     CHECK_EQ(args.size(), size_t(2));
 
     const auto& geo_ti = operator_->get_type_info();
     CHECK(geo_ti.get_type() == kPOINT);
 
     auto& builder = cgen_state->ir_builder_;
     CHECK(pt_local_storage_lv_);
 
     const bool is_compressed = geo_ti.get_compression() == kENCODING_GEOINT;
 
     // store x coord
     auto x_coord_ptr = builder.CreateGEP(
         pt_local_storage_lv_->getType()->getScalarType()->getPointerElementType(),
         pt_local_storage_lv_,
         {cgen_state->llInt(0), cgen_state->llInt(0)},
         "x_coord_ptr");
     if (is_compressed) {
       auto compressed_lv =
           cgen_state->emitExternalCall("compress_x_coord_geoint",
                                        llvm::Type::getInt32Ty(cgen_state->context_),
                                        {args.front()});
       builder.CreateStore(compressed_lv, x_coord_ptr);
     } else {
       builder.CreateStore(args.front(), x_coord_ptr);
     }
 
     // store y coord
     auto y_coord_ptr = builder.CreateGEP(
         pt_local_storage_lv_->getType()->getScalarType()->getPointerElementType(),
         pt_local_storage_lv_,
         {cgen_state->llInt(0), cgen_state->llInt(1)},
         "y_coord_ptr");
     if (is_compressed) {
       auto compressed_lv =
           cgen_state->emitExternalCall("compress_y_coord_geoint",
                                        llvm::Type::getInt32Ty(cgen_state->context_),
                                        {args.back()});
       builder.CreateStore(compressed_lv, y_coord_ptr);
     } else {
       builder.CreateStore(args.back(), y_coord_ptr);
     }
 
     llvm::Value* ret = pt_local_storage_lv_;
     if (is_nullable_) {
       CHECK(nullcheck_codegen);
       ret = nullcheck_codegen->finalize(ret, ret);
     }
     return {builder.CreateBitCast(ret,
                                   geo_ti.get_compression() == kENCODING_GEOINT
                                       ? llvm::Type::getInt32PtrTy(cgen_state->context_)
                                       : llvm::Type::getDoublePtrTy(cgen_state->context_)),
             cgen_state->llInt(static_cast<int32_t>(
                 geo_ti.get_compression() == kENCODING_GEOINT ? 8 : 16))};
   }

Here is the call graph for this function:

std::tuple<std::vector<llvm::Value>, llvm::Value> spatial_type::PointConstructor::codegenLoads	(	const std::vector< llvm::Value * > &	arg_lvs,
		const std::vector< llvm::Value * > &	pos_lvs,
		CgenState *	cgen_state
	)

inlinefinalvirtual

Implements spatial_type::Codegen.

Definition at line 85 of file PointConstructor.h.

References CHECK, CHECK_EQ, codegenOperandIsNull(), Analyzer::Expr::get_type_info(), Analyzer::GeoOperator::getName(), is_null(), spatial_type::Codegen::is_nullable_, kENCODING_GEOINT, kENCODING_NONE, kPOINT, spatial_type::Codegen::operator_, pt_local_storage_lv_, and size().

                                    {
     CHECK_EQ(pos_lvs.size(),
              size());  // note both pos arguments should be the same, as both inputs are
                        // expected to be from the same table, though this is moot in this
                        // function as position argumnts are not used here
     CHECK_EQ(arg_lvs.size(), size_t(2));
 
     // TODO(adb): centralize nullcheck logic for all sqltypes
     llvm::Value* const x_is_null = codegenOperandIsNull(0u, arg_lvs[0], cgen_state);
     llvm::Value* const y_is_null = codegenOperandIsNull(1u, arg_lvs[1], cgen_state);
     llvm::Value* const is_null =
         x_is_null && y_is_null ? cgen_state->ir_builder_.CreateOr(x_is_null, y_is_null)
                                : std::max(x_is_null, y_is_null);
 
     if (is_nullable_ && !is_null) {
       // if the inputs are not null, set the output to be not null
       // TODO: we should do this in the translator and just confirm it here
       is_nullable_ = false;
     }
 
     // do the alloca before nullcheck codegen, as either way we will return a point array
     const auto& geo_ti = operator_->get_type_info();
     CHECK(geo_ti.get_type() == kPOINT);
 
     llvm::ArrayType* arr_type{nullptr};
     if (geo_ti.get_compression() == kENCODING_GEOINT) {
       auto elem_ty = llvm::Type::getInt32Ty(cgen_state->context_);
       arr_type = llvm::ArrayType::get(elem_ty, 2);
     } else {
       CHECK(geo_ti.get_compression() == kENCODING_NONE);
       auto elem_ty = llvm::Type::getDoubleTy(cgen_state->context_);
       arr_type = llvm::ArrayType::get(elem_ty, 2);
     }
     pt_local_storage_lv_ = cgen_state->ir_builder_.CreateAlloca(
         arr_type, nullptr, operator_->getName() + "_Local_Storage");
 
     return std::make_tuple(arg_lvs, is_null);
   }

Here is the call graph for this function:

llvm::Value* spatial_type::PointConstructor::codegenOperandIsNull	(	size_t	idx,
		llvm::Value *	value,
		CgenState *	cgen_state
	)

inlineprivate

Definition at line 187 of file PointConstructor.h.

References inline_fp_null_val(), inline_int_null_val(), CgenState::ir_builder_, CgenState::llFp(), CgenState::llInt(), and UNREACHABLE.

Referenced by codegenLoads().

                                                            {
     auto const& ti = getOperand(idx)->get_type_info();
     if (ti.get_notnull()) {
       return nullptr;
     } else if (ti.is_integer()) {
       return cgen_state->ir_builder_.CreateICmpEQ(
           value, cgen_state->llInt(inline_int_null_val(ti)));
     } else if (ti.is_fp()) {
       return cgen_state->ir_builder_.CreateFCmpOEQ(
           value, cgen_state->llFp(inline_fp_null_val(ti)));
     } else {
       UNREACHABLE() << "Type is expected to be integer or floating point.";
       return {};
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<CodeGenerator::NullCheckCodegen> spatial_type::PointConstructor::getNullCheckCodegen	(	llvm::Value *	null_lv,
		CgenState *	cgen_state,
		Executor *	executor
	)

inlinefinalvirtual

Reimplemented from spatial_type::Codegen.

Definition at line 38 of file PointConstructor.h.

References CHECK, CHECK_EQ, Analyzer::Expr::get_type_info(), spatial_type::Codegen::getName(), getNullType(), inline_int_null_val(), spatial_type::Codegen::isNullable(), kENCODING_GEOINT, kINT, NULL_ARRAY_DOUBLE, spatial_type::Codegen::operator_, and pt_local_storage_lv_.

                                 {
     if (isNullable()) {
       // do the standard nullcheck codegen, but modify the null basic block to emplace the
       // null sentinel into the array
       auto nullcheck_codegen = std::make_unique<CodeGenerator::NullCheckCodegen>(
           cgen_state, executor, null_lv, getNullType(), getName() + "_nullcheck");
 
       auto& builder = cgen_state->ir_builder_;
       CHECK(pt_local_storage_lv_);
 
       auto prev_insert_block = builder.GetInsertBlock();
       auto crt_insert_block = nullcheck_codegen->null_check->cond_true_;
       CHECK(crt_insert_block);
       auto& instruction_list = crt_insert_block->getInstList();
       CHECK_EQ(instruction_list.size(), size_t(1));
       builder.SetInsertPoint(crt_insert_block, instruction_list.begin());
 
       auto x_coord_ptr = builder.CreateGEP(
           pt_local_storage_lv_->getType()->getScalarType()->getPointerElementType(),
           pt_local_storage_lv_,
           {cgen_state->llInt(0), cgen_state->llInt(0)},
           "x_coord_ptr");
       const auto& geo_ti = operator_->get_type_info();
       if (geo_ti.get_compression() == kENCODING_GEOINT) {
         // TODO: probably wrong
         builder.CreateStore(cgen_state->llInt(inline_int_null_val(SQLTypeInfo(kINT))),
                             x_coord_ptr);
       } else {
         builder.CreateStore(cgen_state->llFp(static_cast<double>(NULL_ARRAY_DOUBLE)),
                             x_coord_ptr);
       }
       builder.SetInsertPoint(prev_insert_block);
 
       return nullcheck_codegen;
     } else {
       return nullptr;
     }
   }