anonymous_namespace{ExtensionsIR.cpp} Namespace Reference

Functions
llvm::StructType *	get_arr_struct_type (CgenState *cgen_state, const std::string &ext_func_name, llvm::Type *array_type, size_t param_num)
llvm::Type *	ext_arg_type_to_llvm_type (const ExtArgumentType ext_arg_type, llvm::LLVMContext &ctx)
SQLTypeInfo	get_sql_type_from_llvm_type (const llvm::Type *ll_type)
llvm::Type *	get_llvm_type_from_sql_array_type (const SQLTypeInfo ti, llvm::LLVMContext &ctx)
bool	ext_func_call_requires_nullcheck (const Analyzer::FunctionOper *function_oper)
bool	call_requires_custom_type_handling (const Analyzer::FunctionOper *function_oper)

Function Documentation

bool anonymous_namespace{ExtensionsIR.cpp}::call_requires_custom_type_handling

(

const Analyzer::FunctionOper *

function_oper

)

Definition at line 419 of file ExtensionsIR.cpp.

References Analyzer::Expr::get_type_info(), Analyzer::FunctionOper::getArg(), and Analyzer::FunctionOper::getArity().

Referenced by CodeGenerator::codegenFunctionOperWithCustomTypeHandling().

                                                                                   {
  const auto& ret_ti = function_oper->get_type_info();
  if (!ret_ti.is_integer() && !ret_ti.is_fp()) {
    return true;
  }
  for (size_t i = 0; i < function_oper->getArity(); ++i) {
    const auto arg = function_oper->getArg(i);
    const auto& arg_ti = arg->get_type_info();
    if (!arg_ti.is_integer() && !arg_ti.is_fp()) {
      return true;
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Type* anonymous_namespace{ExtensionsIR.cpp}::ext_arg_type_to_llvm_type	(	const ExtArgumentType	ext_arg_type,
		llvm::LLVMContext &	ctx
	)

Definition at line 79 of file ExtensionsIR.cpp.

References ArrayDouble, ArrayFloat, ArrayInt16, ArrayInt32, ArrayInt64, ArrayInt8, Bool, CHECK(), Double, Float, get_int_type(), Int16, Int32, Int64, and Int8.

Referenced by CodeGenerator::codegenFunctionOper().

                                                            {
  switch (ext_arg_type) {
    case ExtArgumentType::Bool:  // pass thru to Int8
    case ExtArgumentType::Int8:
      return get_int_type(8, ctx);
    case ExtArgumentType::Int16:
      return get_int_type(16, ctx);
    case ExtArgumentType::Int32:
      return get_int_type(32, ctx);
    case ExtArgumentType::Int64:
      return get_int_type(64, ctx);
    case ExtArgumentType::Float:
      return llvm::Type::getFloatTy(ctx);
    case ExtArgumentType::Double:
      return llvm::Type::getDoubleTy(ctx);
    case ExtArgumentType::ArrayInt64:
      return llvm::Type::getVoidTy(ctx);
    case ExtArgumentType::ArrayInt32:
      return llvm::Type::getVoidTy(ctx);
    case ExtArgumentType::ArrayInt16:
      return llvm::Type::getVoidTy(ctx);
    case ExtArgumentType::ArrayInt8:
      return llvm::Type::getVoidTy(ctx);
    case ExtArgumentType::ArrayDouble:
      return llvm::Type::getVoidTy(ctx);
    case ExtArgumentType::ArrayFloat:
      return llvm::Type::getVoidTy(ctx);
    default:
      CHECK(false);
  }
  CHECK(false);
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{ExtensionsIR.cpp}::ext_func_call_requires_nullcheck

(

const Analyzer::FunctionOper *

function_oper

)

Definition at line 177 of file ExtensionsIR.cpp.

References Analyzer::Expr::get_type_info(), Analyzer::FunctionOper::getArg(), and Analyzer::FunctionOper::getArity().

Referenced by CodeGenerator::beginArgsNullcheck().

                                                                                 {
  const auto& func_ti = function_oper->get_type_info();
  for (size_t i = 0; i < function_oper->getArity(); ++i) {
    const auto arg = function_oper->getArg(i);
    const auto& arg_ti = arg->get_type_info();
    if (func_ti.is_array() && arg_ti.is_array()) {
      // If the function returns an array and any of the arguments are arrays, allow NULL
      // scalars.
      // TODO: Make this a property of the FunctionOper following `RETURN NULL ON NULL`
      // semantics.
      return false;
    } else if (!arg_ti.get_notnull() && !arg_ti.is_array()) {
      // Nullable geometry args will trigger a null check
      return true;
    } else {
      continue;
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::StructType* anonymous_namespace{ExtensionsIR.cpp}::get_arr_struct_type	(	CgenState *	cgen_state,
		const std::string &	ext_func_name,
		llvm::Type *	array_type,
		size_t	param_num
	)

Definition at line 35 of file ExtensionsIR.cpp.

References CHECK(), CgenState::context_, and CgenState::module_.

Referenced by CodeGenerator::beginArgsNullcheck(), CodeGenerator::codegenArrayArgs(), CodeGenerator::codegenFunctionOper(), and CodeGenerator::endArgsNullcheck().

                                                        {
  llvm::Function* udf_func = cgen_state->module_->getFunction(ext_func_name);
  CHECK(array_type);
  CHECK(array_type->isPointerTy());

  llvm::StructType* generated_struct_type =
      llvm::StructType::get(cgen_state->context_,
                            {array_type,
                             llvm::Type::getInt64Ty(cgen_state->context_),
                             llvm::Type::getInt8Ty(cgen_state->context_)},
                            false);
  if (udf_func) {
    // Compare expected array struct type with type from the function definition from the
    // UDF module, but use the type from the module
    llvm::FunctionType* udf_func_type = udf_func->getFunctionType();
    CHECK_LE(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_GE(struct_type->getStructNumElements(), size_t(3))
        << 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();
    return cgen_state->module_->getTypeByName(struct_name);
  }

  return generated_struct_type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Type* anonymous_namespace{ExtensionsIR.cpp}::get_llvm_type_from_sql_array_type ( const SQLTypeInfo  ti, llvm::LLVMContext &  ctx  )

inline

Definition at line 149 of file ExtensionsIR.cpp.

References CHECK(), SQLTypeInfo::get_elem_type(), SQLTypeInfo::is_array(), and UNREACHABLE.

Referenced by CodeGenerator::beginArgsNullcheck(), CodeGenerator::codegenFunctionOper(), and CodeGenerator::endArgsNullcheck().

                                                                           {
  CHECK(ti.is_array());
  const auto& elem_ti = ti.get_elem_type();
  if (elem_ti.is_fp()) {
    switch (elem_ti.get_size()) {
      case 4:
        return llvm::Type::getFloatPtrTy(ctx);
      case 8:
        return llvm::Type::getDoublePtrTy(ctx);
    }
  }
  CHECK(elem_ti.is_integer());
  switch (elem_ti.get_size()) {
    case 1:
      return llvm::Type::getInt8PtrTy(ctx);
    case 2:
      return llvm::Type::getInt16PtrTy(ctx);
    case 4:
      return llvm::Type::getInt32PtrTy(ctx);
    case 8:
      return llvm::Type::getInt64PtrTy(ctx);
  }

  UNREACHABLE();
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SQLTypeInfo anonymous_namespace{ExtensionsIR.cpp}::get_sql_type_from_llvm_type ( const llvm::Type *  ll_type )

inline

Definition at line 114 of file ExtensionsIR.cpp.

References CHECK(), logger::FATAL, kBIGINT, kBOOLEAN, kDOUBLE, kFLOAT, kINT, kSMALLINT, kTINYINT, LOG, and UNREACHABLE.

Referenced by CodeGenerator::codegenFunctionOper(), and CodeGenerator::endArgsNullcheck().

                                                                        {
  CHECK(ll_type);
  const auto bits = ll_type->getPrimitiveSizeInBits();

  if (ll_type->isFloatingPointTy()) {
    switch (bits) {
      case 32:
        return SQLTypeInfo(kFLOAT, false);
      case 64:
        return SQLTypeInfo(kDOUBLE, false);
      default:
        LOG(FATAL) << "Unsupported llvm floating point type: " << bits
                   << ", only 32 and 64 bit floating point is supported.";
    }
  } else {
    switch (bits) {
      case 1:
        return SQLTypeInfo(kBOOLEAN, false);
      case 8:
        return SQLTypeInfo(kTINYINT, false);
      case 16:
        return SQLTypeInfo(kSMALLINT, false);
      case 32:
        return SQLTypeInfo(kINT, false);
      case 64:
        return SQLTypeInfo(kBIGINT, false);
      default:
        LOG(FATAL) << "Unrecognized llvm type for SQL type: "
                   << bits;  // TODO let's get the real name here
    }
  }
  UNREACHABLE();
  return SQLTypeInfo();
}

Here is the call graph for this function:

Here is the caller graph for this function: