CgenState Struct Reference

#include <CgenState.h>

Classes
struct	FunctionOperValue
struct	HoistedLiteralLoadLocator

Public Types
using	LiteralValue = boost::variant< int8_t, int16_t, int32_t, int64_t, float, double, std::pair< std::string, int >, std::string, std::vector< double >, std::vector< int32_t >, std::vector< int8_t >, std::pair< std::vector< int8_t >, int > >
using	LiteralValues = std::vector< LiteralValue >

Public Member Functions
	CgenState (const std::vector< InputTableInfo > &query_infos, const bool contains_left_deep_outer_join)
size_t	getOrAddLiteral (const Analyzer::Constant *constant, const EncodingType enc_type, const int dict_id, const int device_id)
const std::unordered_map< int, LiteralValues > &	getLiterals () const
llvm::Value *	addStringConstant (const std::string &str)
const InValuesBitmap *	addInValuesBitmap (std::unique_ptr< InValuesBitmap > &in_values_bitmap)
llvm::Value *	emitExternalCall (const std::string &fname, llvm::Type *ret_type, const std::vector< llvm::Value *> args, const std::vector< llvm::Attribute::AttrKind > &fnattrs={})
llvm::Value *	emitCall (const std::string &fname, const std::vector< llvm::Value *> &args)
size_t	getLiteralBufferUsage (const int device_id)
llvm::Value *	castToTypeIn (llvm::Value *val, const size_t bit_width)
std::pair< llvm::ConstantInt *, llvm::ConstantInt * >	inlineIntMaxMin (const size_t byte_width, const bool is_signed)
llvm::ConstantInt *	inlineIntNull (const SQLTypeInfo &)
llvm::ConstantFP *	inlineFpNull (const SQLTypeInfo &)
template<class T >
llvm::ConstantInt *	llInt (const T v) const
llvm::ConstantFP *	llFp (const float v) const
llvm::ConstantFP *	llFp (const double v) const
llvm::ConstantInt *	llBool (const bool v) const
void	emitErrorCheck (llvm::Value *condition, llvm::Value *errorCode, std::string label)

Static Public Member Functions
static size_t	literalBytes (const CgenState::LiteralValue &lit)
static size_t	addAligned (const size_t off_in, const size_t alignment)

Public Attributes
llvm::Module *	module_
llvm::Function *	row_func_
std::vector< llvm::Function * >	helper_functions_
llvm::LLVMContext &	context_
llvm::ValueToValueMapTy	vmap_
llvm::IRBuilder	ir_builder_
std::unordered_map< int, std::vector< llvm::Value * > >	fetch_cache_
std::vector< FunctionOperValue >	ext_call_cache_
std::vector< llvm::Value * >	group_by_expr_cache_
std::vector< llvm::Value * >	str_constants_
std::vector< llvm::Value * >	frag_offsets_
const bool	contains_left_deep_outer_join_
std::vector< llvm::Value * >	outer_join_match_found_per_level_
std::unordered_map< int, llvm::Value * >	scan_idx_to_hash_pos_
std::vector< std::unique_ptr< const InValuesBitmap > >	in_values_bitmaps_
const std::vector< InputTableInfo > &	query_infos_
bool	needs_error_check_
llvm::Function *	query_func_
llvm::IRBuilder	query_func_entry_ir_builder_
std::unordered_map< int, std::vector< llvm::Value * > >	query_func_literal_loads_
std::unordered_map< llvm::Value *, HoistedLiteralLoadLocator >	row_func_hoisted_literals_

Private Member Functions
template<class T >
size_t	getOrAddLiteral (const T &val, const int device_id)

Private Attributes
std::unordered_map< int, LiteralValues >	literals_
std::unordered_map< int, size_t >	literal_bytes_

Detailed Description

Definition at line 30 of file CgenState.h.

Member Typedef Documentation

LiteralValue

using CgenState::LiteralValue = boost::variant<int8_t, int16_t, int32_t, int64_t, float, double, std::pair<std::string, int>, std::string, std::vector<double>, std::vector<int32_t>, std::vector<int8_t>, std::pair<std::vector<int8_t>, int> >

Definition at line 181 of file CgenState.h.

LiteralValues

using CgenState::LiteralValues = std::vector<LiteralValue>

Definition at line 182 of file CgenState.h.

Constructor & Destructor Documentation

CgenState()

CgenState::CgenState ( const std::vector< InputTableInfo > &  query_infos, const bool  contains_left_deep_outer_join  )

inline

Definition at line 32 of file CgenState.h.

      : module_(nullptr)
      , row_func_(nullptr)
      , context_(getGlobalLLVMContext())
      , ir_builder_(context_)
      , contains_left_deep_outer_join_(contains_left_deep_outer_join)
      , outer_join_match_found_per_level_(std::max(query_infos.size(), size_t(1)) - 1)
      , query_infos_(query_infos)
      , needs_error_check_(false)
      , query_func_(nullptr)
      , query_func_entry_ir_builder_(context_){};

Member Function Documentation

addAligned()

static size_t CgenState::addAligned ( const size_t  off_in, const size_t  alignment  )

inlinestatic

Definition at line 329 of file CgenState.h.

Referenced by getOrAddLiteral(), and Executor::serializeLiterals().

                                                                        {
    size_t off = off_in;
    if (off % alignment != 0) {
      off += (alignment - off % alignment);
    }
    return off + alignment;
  }

Here is the caller graph for this function:

addInValuesBitmap()

const InValuesBitmap* CgenState::addInValuesBitmap ( std::unique_ptr< InValuesBitmap > &  in_values_bitmap )

inline

Definition at line 195 of file CgenState.h.

References in_values_bitmaps_.

Referenced by CodeGenerator::codegen().

                                                       {
    if (in_values_bitmap->isEmpty()) {
      return in_values_bitmap.get();
    }
    in_values_bitmaps_.emplace_back(std::move(in_values_bitmap));
    return in_values_bitmaps_.back().get();
  }

Here is the caller graph for this function:

addStringConstant()

llvm::Value* CgenState::addStringConstant ( const std::string &  str )

inline

Definition at line 186 of file CgenState.h.

References context_, get_int_type(), ir_builder_, str_constants_, and to_string().

Referenced by CodeGenerator::codegen().

                                                     {
    llvm::Value* str_lv = ir_builder_.CreateGlobalString(
        str, "str_const_" + std::to_string(std::hash<std::string>()(str)));
    auto i8_ptr = llvm::PointerType::get(get_int_type(8, context_), 0);
    str_constants_.push_back(str_lv);
    str_lv = ir_builder_.CreateBitCast(str_lv, i8_ptr);
    return str_lv;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

castToTypeIn()

llvm::Value * CgenState::castToTypeIn	(	llvm::Value *	val,
		const size_t	bit_width
	)

Definition at line 103 of file CgenState.cpp.

References CHECK, context_, get_int_type(), and ir_builder_.

Referenced by CodeGenerator::codegenCast(), CodeGenerator::codegenLogical(), CodeGenerator::codegenLogicalShortCircuit(), getLiteralBufferUsage(), and Executor::groupByColumnCodegen().

                                                                        {
  auto src_bits = val->getType()->getScalarSizeInBits();
  if (src_bits == dst_bits) {
    return val;
  }
  if (val->getType()->isIntegerTy()) {
    return ir_builder_.CreateIntCast(
        val, get_int_type(dst_bits, context_), src_bits != 1);
  }
  // real (not dictionary-encoded) strings; store the pointer to the payload
  if (val->getType()->isPointerTy()) {
    return ir_builder_.CreatePointerCast(val, get_int_type(dst_bits, context_));
  }

  CHECK(val->getType()->isFloatTy() || val->getType()->isDoubleTy());

  llvm::Type* dst_type = nullptr;
  switch (dst_bits) {
    case 64:
      dst_type = llvm::Type::getDoubleTy(context_);
      break;
    case 32:
      dst_type = llvm::Type::getFloatTy(context_);
      break;
    default:
      CHECK(false);
  }

  return ir_builder_.CreateFPCast(val, dst_type);
}

Here is the call graph for this function:

Here is the caller graph for this function:

emitCall()

llvm::Value * CgenState::emitCall	(	const std::string &	fname,
		const std::vector< llvm::Value *> &	args
	)

Definition at line 134 of file CgenState.cpp.

References CHECK, g_rt_module, ir_builder_, module_, and vmap_.

Referenced by CodeGenerator::codegen(), CodeGenerator::codegenAdd(), CodeGenerator::codegenCase(), CodeGenerator::codegenCast(), CodeGenerator::codegenCastBetweenIntTypes(), CodeGenerator::codegenCastBetweenIntTypesOverflowChecks(), CodeGenerator::codegenCastBetweenTimestamps(), CodeGenerator::codegenCastFromFp(), CodeGenerator::codegenCastToFp(), CodeGenerator::codegenCmp(), CodeGenerator::codegenDiv(), CodeGenerator::codegenFpArith(), CodeGenerator::codegenFunctionOperWithCustomTypeHandling(), CodeGenerator::codegenLogical(), CodeGenerator::codegenMod(), CodeGenerator::codegenMul(), CodeGenerator::codegenSub(), CodeGenerator::codegenUMinus(), emitExternalCall(), and Executor::groupByColumnCodegen().

                                                                    {
  // Get the implementation from the runtime module.
  auto func_impl = g_rt_module->getFunction(fname);
  CHECK(func_impl);
  // Get the function reference from the query module.
  auto func = module_->getFunction(fname);
  CHECK(func);
  // If the function called isn't external, clone the implementation from the runtime
  // module.
  if (func->isDeclaration() && !func_impl->isDeclaration()) {
    auto DestI = func->arg_begin();
    for (auto arg_it = func_impl->arg_begin(); arg_it != func_impl->arg_end(); ++arg_it) {
      DestI->setName(arg_it->getName());
      vmap_[&*arg_it] = &*DestI++;
    }

    llvm::SmallVector<llvm::ReturnInst*, 8> Returns;  // Ignore returns cloned.
    llvm::CloneFunctionInto(func, func_impl, vmap_, /*ModuleLevelChanges=*/true, Returns);
  }

  return ir_builder_.CreateCall(func, args);
}

Here is the caller graph for this function:

emitErrorCheck()

void CgenState::emitErrorCheck	(	llvm::Value *	condition,
		llvm::Value *	errorCode,
		std::string	label
	)

Definition at line 158 of file CgenState.cpp.

References context_, ir_builder_, needs_error_check_, and row_func_.

Referenced by llBool().

                                                {
  needs_error_check_ = true;
  auto check_ok = llvm::BasicBlock::Create(context_, label + "_ok", row_func_);
  auto check_fail = llvm::BasicBlock::Create(context_, label + "_fail", row_func_);
  ir_builder_.CreateCondBr(condition, check_ok, check_fail);
  ir_builder_.SetInsertPoint(check_fail);
  ir_builder_.CreateRet(errorCode);
  ir_builder_.SetInsertPoint(check_ok);
}

Here is the caller graph for this function:

emitExternalCall()

llvm::Value* CgenState::emitExternalCall ( const std::string &  fname, llvm::Type *  ret_type, const std::vector< llvm::Value *>  args, const std::vector< llvm::Attribute::AttrKind > &  fnattrs = {}  )

inline

Definition at line 205 of file CgenState.h.

References CHECK, CHECK_EQ, context_, emitCall(), ir_builder_, module_, and run_benchmark_import::result.

Referenced by CodeGenerator::codegen(), CodeGenerator::codegenArrayAt(), CodeGenerator::codegenArrayExpr(), CodeGenerator::codegenCastFromString(), CodeGenerator::codegenCastTimestampToDate(), CodeGenerator::codegenFunctionOper(), CodeGenerator::codegenFunctionOperCastArgs(), CodeGenerator::codegenFunctionOperWithCustomTypeHandling(), CodeGenerator::codegenIsNull(), CodeGenerator::codegenQualifierCmp(), and Executor::groupByColumnCodegen().

                                                        {}) {
    std::vector<llvm::Type*> arg_types;
    for (const auto arg : args) {
      arg_types.push_back(arg->getType());
    }
    auto func_ty = llvm::FunctionType::get(ret_type, arg_types, false);
    llvm::AttributeList attrs;
    if (!fnattrs.empty()) {
      std::vector<std::pair<unsigned, llvm::Attribute>> indexedAttrs;
      indexedAttrs.reserve(fnattrs.size());
      for (auto attr : fnattrs)
        indexedAttrs.emplace_back(llvm::AttributeList::FunctionIndex,
                                  llvm::Attribute::get(context_, attr));
      attrs = llvm::AttributeList::get(context_,
                                       {&indexedAttrs.front(), indexedAttrs.size()});
    }
    auto func_p = module_->getOrInsertFunction(fname, func_ty, attrs);
    CHECK(func_p);
    llvm::Value* result = ir_builder_.CreateCall(func_p, args);
    // check the assumed type
    CHECK_EQ(result->getType(), ret_type);
    return result;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

getLiteralBufferUsage()

size_t CgenState::getLiteralBufferUsage ( const int  device_id )

inline

Definition at line 235 of file CgenState.h.

References castToTypeIn(), inlineFpNull(), inlineIntMaxMin(), inlineIntNull(), and literal_bytes_.

{ return literal_bytes_[device_id]; }

Here is the call graph for this function:

getLiterals()

const std::unordered_map<int, LiteralValues>& CgenState::getLiterals ( ) const

inline

Definition at line 184 of file CgenState.h.

References literals_.

{ return literals_; }

getOrAddLiteral() [1/2]

size_t CgenState::getOrAddLiteral ( const Analyzer::Constant *  constant, const EncodingType  enc_type, const int  dict_id, const int  device_id  )

inline

Definition at line 45 of file CgenState.h.

References Datum::bigintval, Datum::boolval, CHECK, CHECK_EQ, decimal_to_int_type(), Datum::doubleval, Datum::floatval, Analyzer::Constant::get_constval(), Analyzer::Constant::get_is_null(), Analyzer::Expr::get_type_info(), Analyzer::Constant::get_value_list(), inline_fp_null_val(), inline_int_null_val(), Datum::intval, kARRAY, kBIGINT, kBOOLEAN, kCHAR, kDATE, kDOUBLE, kENCODING_DICT, kENCODING_GEOINT, kENCODING_NONE, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, Datum::smallintval, Datum::stringval, Datum::tinyintval, and run_benchmark_import::type.

Referenced by CodeGenerator::codegenHoistedConstants().

                                              {
    const auto& ti = constant->get_type_info();
    const auto type = ti.is_decimal() ? decimal_to_int_type(ti) : ti.get_type();
    switch (type) {
      case kBOOLEAN:
        return getOrAddLiteral(constant->get_is_null()
                                   ? int8_t(inline_int_null_val(ti))
                                   : int8_t(constant->get_constval().boolval ? 1 : 0),
                               device_id);
      case kTINYINT:
        return getOrAddLiteral(constant->get_is_null()
                                   ? int8_t(inline_int_null_val(ti))
                                   : constant->get_constval().tinyintval,
                               device_id);
      case kSMALLINT:
        return getOrAddLiteral(constant->get_is_null()
                                   ? int16_t(inline_int_null_val(ti))
                                   : constant->get_constval().smallintval,
                               device_id);
      case kINT:
        return getOrAddLiteral(constant->get_is_null() ? int32_t(inline_int_null_val(ti))
                                                       : constant->get_constval().intval,
                               device_id);
      case kBIGINT:
        return getOrAddLiteral(constant->get_is_null()
                                   ? int64_t(inline_int_null_val(ti))
                                   : constant->get_constval().bigintval,
                               device_id);
      case kFLOAT:
        return getOrAddLiteral(constant->get_is_null()
                                   ? float(inline_fp_null_val(ti))
                                   : constant->get_constval().floatval,
                               device_id);
      case kDOUBLE:
        return getOrAddLiteral(constant->get_is_null()
                                   ? inline_fp_null_val(ti)
                                   : constant->get_constval().doubleval,
                               device_id);
      case kCHAR:
      case kTEXT:
      case kVARCHAR:
        if (enc_type == kENCODING_DICT) {
          if (constant->get_is_null()) {
            return getOrAddLiteral(int32_t(inline_int_null_val(ti)), device_id);
          }
          return getOrAddLiteral(
              std::make_pair(*constant->get_constval().stringval, dict_id), device_id);
        }
        CHECK_EQ(kENCODING_NONE, enc_type);
        if (constant->get_is_null()) {
          throw std::runtime_error(
              "CHAR / VARCHAR NULL literal not supported in this context");  // TODO(alex):
                                                                             // support
                                                                             // null
        }
        return getOrAddLiteral(*constant->get_constval().stringval, device_id);
      case kTIME:
      case kTIMESTAMP:
      case kDATE:
      case kINTERVAL_DAY_TIME:
      case kINTERVAL_YEAR_MONTH:
        // TODO(alex): support null
        return getOrAddLiteral(constant->get_constval().bigintval, device_id);
      case kARRAY: {
        if (enc_type == kENCODING_NONE) {
          if (ti.get_subtype() == kDOUBLE) {
            std::vector<double> double_array_literal;
            for (const auto& value : constant->get_value_list()) {
              const auto c = dynamic_cast<const Analyzer::Constant*>(value.get());
              CHECK(c);
              double d = c->get_constval().doubleval;
              double_array_literal.push_back(d);
            }
            return getOrAddLiteral(double_array_literal, device_id);
          }
          if (ti.get_subtype() == kINT) {
            std::vector<int32_t> int32_array_literal;
            for (const auto& value : constant->get_value_list()) {
              const auto c = dynamic_cast<const Analyzer::Constant*>(value.get());
              CHECK(c);
              int32_t i = c->get_constval().intval;
              int32_array_literal.push_back(i);
            }
            return getOrAddLiteral(int32_array_literal, device_id);
          }
          if (ti.get_subtype() == kTINYINT) {
            std::vector<int8_t> int8_array_literal;
            for (const auto& value : constant->get_value_list()) {
              const auto c = dynamic_cast<const Analyzer::Constant*>(value.get());
              CHECK(c);
              int8_t i = c->get_constval().tinyintval;
              int8_array_literal.push_back(i);
            }
            if (ti.get_comp_param() == 64) {
              return getOrAddLiteral(std::make_pair(int8_array_literal, 64), device_id);
            }
            return getOrAddLiteral(int8_array_literal, device_id);
          }
          throw std::runtime_error("Unsupported literal array");
        }
        if (enc_type == kENCODING_GEOINT) {
          if (ti.get_subtype() == kTINYINT) {
            std::vector<int8_t> int8_array_literal;
            for (const auto& value : constant->get_value_list()) {
              const auto c = dynamic_cast<const Analyzer::Constant*>(value.get());
              CHECK(c);
              int8_t i = c->get_constval().tinyintval;
              int8_array_literal.push_back(i);
            }
            if (ti.get_comp_param() == 32) {
              return getOrAddLiteral(std::make_pair(int8_array_literal, 32), device_id);
            }
            return getOrAddLiteral(int8_array_literal, device_id);
          }
        }
        throw std::runtime_error("Encoded literal arrays are not supported");
      }
      default:
        abort();
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

getOrAddLiteral() [2/2]

template<class T >

size_t CgenState::getOrAddLiteral ( const T &  val, const int  device_id  )

inlineprivate

Definition at line 339 of file CgenState.h.

References addAligned(), literal_bytes_, literalBytes(), literals, and literals_.

                                                            {
    const LiteralValue var_val(val);
    size_t literal_found_off{0};
    auto& literals = literals_[device_id];
    for (const auto& literal : literals) {
      const auto lit_bytes = literalBytes(literal);
      literal_found_off = addAligned(literal_found_off, lit_bytes);
      if (literal == var_val) {
        return literal_found_off - lit_bytes;
      }
    }
    literals.emplace_back(val);
    const auto lit_bytes = literalBytes(var_val);
    literal_bytes_[device_id] = addAligned(literal_bytes_[device_id], lit_bytes);
    return literal_bytes_[device_id] - lit_bytes;
  }

Here is the call graph for this function:

inlineFpNull()

llvm::ConstantFP * CgenState::inlineFpNull

(

const SQLTypeInfo &

type_info

)

Definition at line 62 of file CgenState.cpp.

References CHECK, SQLTypeInfoCore< TYPE_FACET_PACK >::get_type(), SQLTypeInfoCore< TYPE_FACET_PACK >::is_fp(), kDOUBLE, kFLOAT, llFp(), NULL_DOUBLE, and NULL_FLOAT.

Referenced by CodeGenerator::codegenArrayAt(), CodeGenerator::codegenCastFromFp(), CodeGenerator::codegenCastToFp(), CodeGenerator::codegenUMinus(), CodeGenerator::endArgsNullcheck(), and getLiteralBufferUsage().

                                                                    {
  CHECK(type_info.is_fp());
  switch (type_info.get_type()) {
    case kFLOAT:
      return llFp(NULL_FLOAT);
    case kDOUBLE:
      return llFp(NULL_DOUBLE);
    default:
      abort();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

inlineIntMaxMin()

std::pair< llvm::ConstantInt *, llvm::ConstantInt * > CgenState::inlineIntMaxMin	(	const size_t	byte_width,
		const bool	is_signed
	)

Definition at line 74 of file CgenState.cpp.

References CHECK_EQ, context_, inline_int_max_min(), inline_uint_max_min(), and ll_int().

Referenced by CodeGenerator::codegenAdd(), CodeGenerator::codegenCastBetweenIntTypesOverflowChecks(), CodeGenerator::codegenDiv(), CodeGenerator::codegenMul(), CodeGenerator::codegenSub(), CodeGenerator::codegenUMinus(), and getLiteralBufferUsage().

                          {
  int64_t max_int{0}, min_int{0};
  if (is_signed) {
    std::tie(max_int, min_int) = inline_int_max_min(byte_width);
  } else {
    uint64_t max_uint{0}, min_uint{0};
    std::tie(max_uint, min_uint) = inline_uint_max_min(byte_width);
    max_int = static_cast<int64_t>(max_uint);
    CHECK_EQ(uint64_t(0), min_uint);
  }
  switch (byte_width) {
    case 1:
      return std::make_pair(::ll_int(static_cast<int8_t>(max_int), context_),
                            ::ll_int(static_cast<int8_t>(min_int), context_));
    case 2:
      return std::make_pair(::ll_int(static_cast<int16_t>(max_int), context_),
                            ::ll_int(static_cast<int16_t>(min_int), context_));
    case 4:
      return std::make_pair(::ll_int(static_cast<int32_t>(max_int), context_),
                            ::ll_int(static_cast<int32_t>(min_int), context_));
    case 8:
      return std::make_pair(::ll_int(max_int, context_), ::ll_int(min_int, context_));
    default:
      abort();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

inlineIntNull()

llvm::ConstantInt * CgenState::inlineIntNull

(

const SQLTypeInfo &

type_info

)

Definition at line 24 of file CgenState.cpp.

References CHECK, SQLTypeInfoCore< TYPE_FACET_PACK >::get_compression(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_type(), inline_int_null_val(), SQLTypeInfoCore< TYPE_FACET_PACK >::is_string(), kARRAY, kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kENCODING_DICT, kENCODING_NONE, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNUMERIC, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, llInt(), and run_benchmark_import::type.

Referenced by CodeGenerator::codegen(), CodeGenerator::codegenArrayAt(), CodeGenerator::codegenCastBetweenIntTypes(), CodeGenerator::codegenCastBetweenIntTypesOverflowChecks(), CodeGenerator::codegenCastBetweenTimestamps(), CodeGenerator::codegenCastFromFp(), CodeGenerator::codegenCastTimestampToDate(), CodeGenerator::codegenCastToFp(), CodeGenerator::codegenCmp(), CodeGenerator::codegenDiv(), CodeGenerator::codegenIntConst(), CodeGenerator::codegenIsNullNumber(), CodeGenerator::codegenLogical(), CodeGenerator::codegenLogicalShortCircuit(), CodeGenerator::codegenUMinus(), CodeGenerator::endArgsNullcheck(), and getLiteralBufferUsage().

                                                                      {
  auto type = type_info.get_type();
  if (type_info.is_string()) {
    switch (type_info.get_compression()) {
      case kENCODING_DICT:
        return llInt(static_cast<int32_t>(inline_int_null_val(type_info)));
      case kENCODING_NONE:
        return llInt(int64_t(0));
      default:
        CHECK(false);
    }
  }
  switch (type) {
    case kBOOLEAN:
      return llInt(static_cast<int8_t>(inline_int_null_val(type_info)));
    case kTINYINT:
      return llInt(static_cast<int8_t>(inline_int_null_val(type_info)));
    case kSMALLINT:
      return llInt(static_cast<int16_t>(inline_int_null_val(type_info)));
    case kINT:
      return llInt(static_cast<int32_t>(inline_int_null_val(type_info)));
    case kBIGINT:
    case kTIME:
    case kTIMESTAMP:
    case kDATE:
    case kINTERVAL_DAY_TIME:
    case kINTERVAL_YEAR_MONTH:
      return llInt(inline_int_null_val(type_info));
    case kDECIMAL:
    case kNUMERIC:
      return llInt(inline_int_null_val(type_info));
    case kARRAY:
      return llInt(int64_t(0));
    default:
      abort();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

literalBytes()

static size_t CgenState::literalBytes ( const CgenState::LiteralValue &  lit )

inlinestatic

Definition at line 298 of file CgenState.h.

Referenced by CodeGenerator::codegenHoistedConstantsLoads(), getOrAddLiteral(), and Executor::serializeLiterals().

                                                               {
    switch (lit.which()) {
      case 0:
        return 1;  // int8_t
      case 1:
        return 2;  // int16_t
      case 2:
        return 4;  // int32_t
      case 3:
        return 8;  // int64_t
      case 4:
        return 4;  // float
      case 5:
        return 8;  // double
      case 6:
        return 4;  // std::pair<std::string, int>
      case 7:
        return 4;  // std::string
      case 8:
        return 4;  // std::vector<double>
      case 9:
        return 4;  // std::vector<int32_t>
      case 10:
        return 4;  // std::vector<int8_t>
      case 11:
        return 4;  // std::pair<std::vector<int8_t>, int>
      default:
        abort();
    }
  }

Here is the caller graph for this function:

llBool()

llvm::ConstantInt* CgenState::llBool ( const bool  v ) const

inline

Definition at line 262 of file CgenState.h.

References context_, emitErrorCheck(), run_benchmark_import::label, and ll_bool().

Referenced by Executor::buildIsDeletedCb(), and Executor::buildJoinLoops().

{ return ::ll_bool(v, context_); }

Here is the call graph for this function:

Here is the caller graph for this function:

llFp() [1/2]

llvm::ConstantFP* CgenState::llFp ( const float  v ) const

inline

Definition at line 252 of file CgenState.h.

References context_.

Referenced by CodeGenerator::codegenCmp(), CodeGenerator::codegenDiv(), CodeGenerator::codegenFpArith(), CodeGenerator::codegenIsNullNumber(), and inlineFpNull().

                                            {
    return static_cast<llvm::ConstantFP*>(
        llvm::ConstantFP::get(llvm::Type::getFloatTy(context_), v));
  }

Here is the caller graph for this function:

llFp() [2/2]

llvm::ConstantFP* CgenState::llFp ( const double  v ) const

inline

Definition at line 257 of file CgenState.h.

References context_.

                                             {
    return static_cast<llvm::ConstantFP*>(
        llvm::ConstantFP::get(llvm::Type::getDoubleTy(context_), v));
  }

llInt()

template<class T >

llvm::ConstantInt* CgenState::llInt ( const T  v ) const

inline

Definition at line 248 of file CgenState.h.

References context_, and ll_int().

Referenced by Executor::buildIsDeletedCb(), Executor::buildJoinLoops(), CodeGenerator::codegen(), CodeGenerator::codegenAdd(), CodeGenerator::codegenArrayExpr(), CodeGenerator::codegenBinOpWithOverflowForCPU(), CodeGenerator::codegenCastBetweenIntTypes(), CodeGenerator::codegenCastBetweenIntTypesOverflowChecks(), CodeGenerator::codegenCastBetweenTimestamps(), CodeGenerator::codegenCastTimestampToDate(), CodeGenerator::codegenCmp(), CodeGenerator::codegenDiv(), CodeGenerator::codegenFunctionOper(), CodeGenerator::codegenFunctionOperCastArgs(), CodeGenerator::codegenFunctionOperWithCustomTypeHandling(), CodeGenerator::codegenGeoExpr(), CodeGenerator::codegenHoistedConstantsLoads(), CodeGenerator::codegenHoistedConstantsPlaceholders(), CodeGenerator::codegenIntConst(), Executor::codegenJoinLoops(), CodeGenerator::codegenMod(), CodeGenerator::codegenMul(), CodeGenerator::codegenSub(), CodeGenerator::codegenUMinus(), Executor::groupByColumnCodegen(), and inlineIntNull().

                                          {
    return ::ll_int(v, context_);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

contains_left_deep_outer_join_

const bool CgenState::contains_left_deep_outer_join_

Definition at line 281 of file CgenState.h.

context_

llvm::LLVMContext& CgenState::context_

Definition at line 269 of file CgenState.h.

Referenced by addStringConstant(), CodeGenerator::beginArgsNullcheck(), Executor::buildIsDeletedCb(), CodeGenerator::castArrayPointer(), castToTypeIn(), CodeGenerator::codegen(), CodeGenerator::codegenAdd(), CodeGenerator::codegenArrayArgs(), CodeGenerator::codegenArrayAt(), CodeGenerator::codegenArrayExpr(), CodeGenerator::codegenBinOpWithOverflowForCPU(), CodeGenerator::codegenCase(), CodeGenerator::codegenCast(), CodeGenerator::codegenCastBetweenIntTypes(), CodeGenerator::codegenCastBetweenIntTypesOverflowChecks(), CodeGenerator::codegenCastFromFp(), CodeGenerator::codegenCastFromString(), CodeGenerator::codegenCastTimestampToDate(), CodeGenerator::codegenCastToFp(), CodeGenerator::codegenDiv(), CodeGenerator::codegenFunctionOper(), CodeGenerator::codegenFunctionOperCastArgs(), CodeGenerator::codegenFunctionOperNullArg(), CodeGenerator::codegenFunctionOperWithCustomTypeHandling(), CodeGenerator::codegenHoistedConstantsLoads(), CodeGenerator::codegenIsNull(), Executor::codegenJoinLoops(), CodeGenerator::codegenLogicalShortCircuit(), CodeGenerator::codegenMod(), CodeGenerator::codegenMul(), CodeGenerator::codegenQualifierCmp(), CodeGenerator::codegenSkipOverflowCheckForNull(), CodeGenerator::codegenSub(), CodeGenerator::codegenUMinus(), anonymous_namespace{ResultSetReductionCodegen.cpp}::create_entry_block(), anonymous_namespace{ResultSetReductionJIT.cpp}::create_llvm_function(), anonymous_namespace{ResultSetReductionInterpreterStubs.cpp}::create_stub_function(), emitErrorCheck(), emitExternalCall(), CodeGenerator::endArgsNullcheck(), anonymous_namespace{TableFunctionCompilationContext.cpp}::generate_entry_point(), CodeGenerator::generatePTX(), Executor::groupByColumnCodegen(), inlineIntMaxMin(), llBool(), llFp(), and llInt().

ext_call_cache_

std::vector<FunctionOperValue> CgenState::ext_call_cache_

Definition at line 277 of file CgenState.h.

Referenced by CodeGenerator::codegenFunctionOper().

fetch_cache_

std::unordered_map<int, std::vector<llvm::Value*> > CgenState::fetch_cache_

Definition at line 272 of file CgenState.h.

frag_offsets_

std::vector<llvm::Value*> CgenState::frag_offsets_

Definition at line 280 of file CgenState.h.

group_by_expr_cache_

std::vector<llvm::Value*> CgenState::group_by_expr_cache_

Definition at line 278 of file CgenState.h.

Referenced by Executor::groupByColumnCodegen().

helper_functions_

std::vector<llvm::Function*> CgenState::helper_functions_

Definition at line 268 of file CgenState.h.

in_values_bitmaps_

std::vector<std::unique_ptr<const InValuesBitmap> > CgenState::in_values_bitmaps_

Definition at line 284 of file CgenState.h.

Referenced by addInValuesBitmap().

ir_builder_

llvm::IRBuilder CgenState::ir_builder_

Definition at line 271 of file CgenState.h.

Referenced by addStringConstant(), CodeGenerator::beginArgsNullcheck(), Executor::buildIsDeletedCb(), Executor::buildJoinLoops(), CodeGenerator::castArrayPointer(), castToTypeIn(), CodeGenerator::codegen(), CodeGenerator::codegenAdd(), CodeGenerator::codegenArrayArgs(), CodeGenerator::codegenArrayAt(), CodeGenerator::codegenArrayExpr(), CodeGenerator::codegenBinOpWithOverflowForCPU(), CodeGenerator::codegenCase(), CodeGenerator::codegenCast(), CodeGenerator::codegenCastBetweenIntTypes(), CodeGenerator::codegenCastBetweenIntTypesOverflowChecks(), CodeGenerator::codegenCastBetweenTimestamps(), CodeGenerator::codegenCastFromFp(), CodeGenerator::codegenCastToFp(), CodeGenerator::codegenCmp(), CodeGenerator::codegenDiv(), CodeGenerator::codegenFpArith(), CodeGenerator::codegenFunctionOper(), CodeGenerator::codegenFunctionOperCastArgs(), CodeGenerator::codegenFunctionOperNullArg(), CodeGenerator::codegenFunctionOperWithCustomTypeHandling(), CodeGenerator::codegenGeoLineStringArgs(), CodeGenerator::codegenGeoPointArgs(), CodeGenerator::codegenGeoPolygonArgs(), CodeGenerator::codegenHoistedConstantsPlaceholders(), CodeGenerator::codegenIsNullNumber(), Executor::codegenJoinLoops(), CodeGenerator::codegenLogical(), CodeGenerator::codegenLogicalShortCircuit(), CodeGenerator::codegenMod(), CodeGenerator::codegenMul(), CodeGenerator::codegenSkipOverflowCheckForNull(), CodeGenerator::codegenSub(), CodeGenerator::codegenUMinus(), anonymous_namespace{ResultSetReductionCodegen.cpp}::create_entry_block(), anonymous_namespace{ResultSetReductionInterpreterStubs.cpp}::create_stub_function(), emitCall(), emitErrorCheck(), emitExternalCall(), CodeGenerator::endArgsNullcheck(), Executor::groupByColumnCodegen(), and CodeGenerator::toBool().

literal_bytes_

std::unordered_map<int, size_t> CgenState::literal_bytes_

private

Definition at line 357 of file CgenState.h.

Referenced by getLiteralBufferUsage(), and getOrAddLiteral().

literals_

std::unordered_map<int, LiteralValues> CgenState::literals_

private

Definition at line 356 of file CgenState.h.

Referenced by getLiterals(), and getOrAddLiteral().

module_

llvm::Module* CgenState::module_

Definition at line 266 of file CgenState.h.

Referenced by anonymous_namespace{ResultSetReductionJIT.cpp}::create_llvm_function(), anonymous_namespace{ResultSetReductionInterpreterStubs.cpp}::create_stub_function(), CodeGenerator::createArrayStructType(), CodeGenerator::createLineStringStructType(), CodeGenerator::createPointStructType(), CodeGenerator::createPolygonStructType(), emitCall(), emitExternalCall(), anonymous_namespace{TableFunctionCompilationContext.cpp}::generate_entry_point(), and CodeGenerator::getArithWithOverflowIntrinsic().

needs_error_check_

bool CgenState::needs_error_check_

Definition at line 286 of file CgenState.h.

Referenced by CodeGenerator::codegenAdd(), CodeGenerator::codegenBinOpWithOverflowForCPU(), CodeGenerator::codegenCastBetweenIntTypesOverflowChecks(), CodeGenerator::codegenDiv(), Executor::codegenJoinLoops(), CodeGenerator::codegenMod(), CodeGenerator::codegenMul(), CodeGenerator::codegenSub(), CodeGenerator::codegenUMinus(), and emitErrorCheck().

outer_join_match_found_per_level_

std::vector<llvm::Value*> CgenState::outer_join_match_found_per_level_

Definition at line 282 of file CgenState.h.

Referenced by Executor::buildJoinLoops().

query_func_

llvm::Function* CgenState::query_func_

Definition at line 288 of file CgenState.h.

Referenced by CodeGenerator::codegenHoistedConstantsLoads().

query_func_entry_ir_builder_

llvm::IRBuilder CgenState::query_func_entry_ir_builder_

Definition at line 289 of file CgenState.h.

Referenced by CodeGenerator::codegenHoistedConstantsLoads().

query_func_literal_loads_

std::unordered_map<int, std::vector<llvm::Value*> > CgenState::query_func_literal_loads_

Definition at line 290 of file CgenState.h.

Referenced by CodeGenerator::codegenHoistedConstants().

query_infos_

const std::vector<InputTableInfo>& CgenState::query_infos_

Definition at line 285 of file CgenState.h.

Referenced by CodeGenerator::checkExpressionRanges().

row_func_

llvm::Function* CgenState::row_func_

Definition at line 267 of file CgenState.h.

Referenced by CodeGenerator::beginArgsNullcheck(), Executor::buildIsDeletedCb(), Executor::buildJoinLoops(), CodeGenerator::codegenAdd(), CodeGenerator::codegenBinOpWithOverflowForCPU(), CodeGenerator::codegenCase(), CodeGenerator::codegenCastBetweenIntTypesOverflowChecks(), CodeGenerator::codegenDiv(), Executor::codegenJoinLoops(), CodeGenerator::codegenLogicalShortCircuit(), CodeGenerator::codegenMod(), CodeGenerator::codegenMul(), CodeGenerator::codegenSkipOverflowCheckForNull(), CodeGenerator::codegenSub(), CodeGenerator::codegenUMinus(), emitErrorCheck(), CodeGenerator::generateNativeGPUCode(), and Executor::groupByColumnCodegen().

row_func_hoisted_literals_

std::unordered_map<llvm::Value*, HoistedLiteralLoadLocator> CgenState::row_func_hoisted_literals_

Definition at line 296 of file CgenState.h.

Referenced by CodeGenerator::codegenHoistedConstantsPlaceholders().

scan_idx_to_hash_pos_

std::unordered_map<int, llvm::Value*> CgenState::scan_idx_to_hash_pos_

Definition at line 283 of file CgenState.h.

Referenced by Executor::addJoinLoopIterator().

str_constants_

std::vector<llvm::Value*> CgenState::str_constants_

Definition at line 279 of file CgenState.h.

Referenced by addStringConstant().

vmap_

llvm::ValueToValueMapTy CgenState::vmap_

Definition at line 270 of file CgenState.h.

Referenced by emitCall(), CodeGenerator::link_udf_module(), and runtime_module_shallow_copy().

---

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

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/CgenState.h
• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/CgenState.cpp