OmniSciDB  72c90bc290
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
NativeCodegen.cpp File Reference
#include "QueryEngine/Execute.h"
#include <llvm/Analysis/ScopedNoAliasAA.h>
#include <llvm/Analysis/TypeBasedAliasAnalysis.h>
#include <llvm/Bitcode/BitcodeReader.h>
#include <llvm/Bitcode/BitcodeWriter.h>
#include <llvm/ExecutionEngine/MCJIT.h>
#include <llvm/IR/Attributes.h>
#include <llvm/IR/GlobalValue.h>
#include <llvm/IR/InstIterator.h>
#include <llvm/IR/IntrinsicInst.h>
#include <llvm/IR/Intrinsics.h>
#include <llvm/IR/LegacyPassManager.h>
#include <llvm/IR/Verifier.h>
#include <llvm/IRReader/IRReader.h>
#include <llvm/Support/TargetRegistry.h>
#include <llvm/Support/Casting.h>
#include <llvm/Support/FileSystem.h>
#include <llvm/Support/FormattedStream.h>
#include <llvm/Support/MemoryBuffer.h>
#include <llvm/Support/SourceMgr.h>
#include <llvm/Support/TargetSelect.h>
#include <llvm/Support/raw_os_ostream.h>
#include <llvm/Support/raw_ostream.h>
#include <llvm/Transforms/IPO.h>
#include <llvm/Transforms/IPO/AlwaysInliner.h>
#include <llvm/Transforms/IPO/InferFunctionAttrs.h>
#include <llvm/Transforms/IPO/PassManagerBuilder.h>
#include <llvm/Transforms/InstCombine/InstCombine.h>
#include <llvm/Transforms/Instrumentation.h>
#include <llvm/Transforms/Scalar.h>
#include <llvm/Transforms/Scalar/GVN.h>
#include <llvm/Transforms/Scalar/InstSimplifyPass.h>
#include <llvm/Transforms/Utils.h>
#include <llvm/Transforms/Utils/BasicBlockUtils.h>
#include <llvm/Transforms/Utils/Cloning.h>
#include "CudaMgr/CudaMgr.h"
#include "QueryEngine/CodeGenerator.h"
#include "QueryEngine/CodegenHelper.h"
#include "QueryEngine/ExtensionFunctionsWhitelist.h"
#include "QueryEngine/GpuSharedMemoryUtils.h"
#include "QueryEngine/LLVMFunctionAttributesUtil.h"
#include "QueryEngine/Optimization/AnnotateInternalFunctionsPass.h"
#include "QueryEngine/OutputBufferInitialization.h"
#include "QueryEngine/QueryEngine.h"
#include "QueryEngine/QueryTemplateGenerator.h"
#include "QueryEngine/UsedColumnsVisitor.h"
#include "Shared/InlineNullValues.h"
#include "Shared/MathUtils.h"
#include "StreamingTopN.h"
+ Include dependency graph for NativeCodegen.cpp:

Go to the source code of this file.

Classes

class  anonymous_namespace{NativeCodegen.cpp}::CaseExprDetector
 

Namespaces

 anonymous_namespace{NativeCodegen.cpp}
 

Macros

#define SHOW_DEFINED(MODULE)
 
#define SHOW_FUNCTIONS(MODULE)
 

Functions

void anonymous_namespace{NativeCodegen.cpp}::throw_parseIR_error (const llvm::SMDiagnostic &parse_error, std::string src="", const bool is_gpu=false)
 
template<typename T = void>
void anonymous_namespace{NativeCodegen.cpp}::show_defined (llvm::Module &llvm_module)
 
template<typename T = void>
void anonymous_namespace{NativeCodegen.cpp}::show_defined (llvm::Module *llvm_module)
 
template<typename T = void>
void anonymous_namespace{NativeCodegen.cpp}::show_defined (std::unique_ptr< llvm::Module > &llvm_module)
 
template<typename T = void>
void anonymous_namespace{NativeCodegen.cpp}::scan_function_calls (llvm::Function &F, std::unordered_set< std::string > &defined, std::unordered_set< std::string > &undefined, const std::unordered_set< std::string > &ignored)
 
template<typename T = void>
void anonymous_namespace{NativeCodegen.cpp}::scan_function_calls (llvm::Module &llvm_module, std::unordered_set< std::string > &defined, std::unordered_set< std::string > &undefined, const std::unordered_set< std::string > &ignored)
 
template<typename T = void>
std::tuple< std::unordered_set
< std::string >
, std::unordered_set
< std::string > > 
anonymous_namespace{NativeCodegen.cpp}::scan_function_calls (llvm::Module &llvm_module, const std::unordered_set< std::string > &ignored={})
 
void anonymous_namespace{NativeCodegen.cpp}::eliminate_dead_self_recursive_funcs (llvm::Module &M, const std::unordered_set< llvm::Function * > &live_funcs)
 
void anonymous_namespace{NativeCodegen.cpp}::optimize_ir (llvm::Function *query_func, llvm::Module *llvm_module, llvm::legacy::PassManager &pass_manager, const std::unordered_set< llvm::Function * > &live_funcs, const bool is_gpu_smem_used, const CompilationOptions &co)
 
void verify_function_ir (const llvm::Function *func)
 
std::string anonymous_namespace{NativeCodegen.cpp}::assemblyForCPU (ExecutionEngineWrapper &execution_engine, llvm::Module *llvm_module)
 
ExecutionEngineWrapper anonymous_namespace{NativeCodegen.cpp}::create_execution_engine (llvm::Module *llvm_module, llvm::EngineBuilder &eb, const CompilationOptions &co)
 
std::string anonymous_namespace{NativeCodegen.cpp}::cpp_to_llvm_name (const std::string &s)
 
std::string anonymous_namespace{NativeCodegen.cpp}::gen_array_any_all_sigs ()
 
std::string anonymous_namespace{NativeCodegen.cpp}::gen_translate_null_key_sigs ()
 
llvm::StringRef get_gpu_target_triple_string ()
 
llvm::StringRef get_gpu_data_layout ()
 
std::map< std::string,
std::string > 
get_device_parameters (bool cpu_only)
 
std::unique_ptr< llvm::Module > read_llvm_module_from_bc_file (const std::string &bc_filename, llvm::LLVMContext &context)
 
std::unique_ptr< llvm::Module > read_llvm_module_from_ir_file (const std::string &udf_ir_filename, llvm::LLVMContext &ctx, bool is_gpu=false)
 
std::unique_ptr< llvm::Module > read_llvm_module_from_ir_string (const std::string &udf_ir_string, llvm::LLVMContext &ctx, bool is_gpu=false)
 
void anonymous_namespace{NativeCodegen.cpp}::bind_pos_placeholders (const std::string &pos_fn_name, const bool use_resume_param, llvm::Function *query_func, llvm::Module *llvm_module)
 
void anonymous_namespace{NativeCodegen.cpp}::set_row_func_argnames (llvm::Function *row_func, const size_t in_col_count, const size_t agg_col_count, const bool hoist_literals)
 
llvm::Function * anonymous_namespace{NativeCodegen.cpp}::create_row_function (const size_t in_col_count, const size_t agg_col_count, const bool hoist_literals, llvm::Module *llvm_module, llvm::LLVMContext &context)
 
void anonymous_namespace{NativeCodegen.cpp}::bind_query (llvm::Function *query_func, const std::string &query_fname, llvm::Function *multifrag_query_func, llvm::Module *llvm_module)
 
std::vector< std::string > anonymous_namespace{NativeCodegen.cpp}::get_agg_fnames (const std::vector< Analyzer::Expr * > &target_exprs, const bool is_group_by)
 
template<typename InstType >
llvm::Value * anonymous_namespace{NativeCodegen.cpp}::find_variable_in_basic_block (llvm::Function *func, std::string bb_name, std::string variable_name)
 
size_t anonymous_namespace{NativeCodegen.cpp}::get_shared_memory_size (const bool shared_mem_used, const QueryMemoryDescriptor *query_mem_desc_ptr)
 
bool anonymous_namespace{NativeCodegen.cpp}::has_count_expr (RelAlgExecutionUnit const &ra_exe_unit)
 
bool anonymous_namespace{NativeCodegen.cpp}::has_case_expr_within_groupby_expr (RelAlgExecutionUnit const &ra_exe_unit)
 
bool anonymous_namespace{NativeCodegen.cpp}::is_gpu_shared_mem_supported (const QueryMemoryDescriptor *query_mem_desc_ptr, const RelAlgExecutionUnit &ra_exe_unit, const CudaMgr_Namespace::CudaMgr *cuda_mgr, const ExecutorDeviceType device_type, const unsigned cuda_blocksize, const unsigned num_blocks_per_mp)
 
std::string anonymous_namespace{NativeCodegen.cpp}::serialize_llvm_metadata_footnotes (llvm::Function *query_func, CgenState *cgen_state)
 
std::vector< llvm::Value * > generate_column_heads_load (const int num_columns, llvm::Value *byte_stream_arg, llvm::IRBuilder<> &ir_builder, llvm::LLVMContext &ctx)
 

Variables

float g_fraction_code_cache_to_evict = 0.2
 
const std::string anonymous_namespace{NativeCodegen.cpp}::cuda_rt_decls
 
constexpr std::array
< std::string_view, 18 > 
TARGET_RUNTIME_FUNCTIONS_FOR_MODULE_CLONING
 

Macro Definition Documentation

#define SHOW_DEFINED (   MODULE)
Value:
{ \
std::cout << __func__ << "#" << __LINE__ << ": " #MODULE << " "; \
::show_defined(MODULE); \
}
void show_defined(llvm::Module &llvm_module)

Definition at line 141 of file NativeCodegen.cpp.

#define SHOW_FUNCTIONS (   MODULE)
Value:
{ \
std::cout << __func__ << "#" << __LINE__ << ": " #MODULE << " "; \
::show_functions(MODULE); \
}

Definition at line 147 of file NativeCodegen.cpp.

Function Documentation

std::vector<llvm::Value*> generate_column_heads_load ( const int  num_columns,
llvm::Value *  byte_stream_arg,
llvm::IRBuilder<> &  ir_builder,
llvm::LLVMContext &  ctx 
)

Loads individual columns from a single, packed pointers buffer (the byte stream arg)

Definition at line 3454 of file NativeCodegen.cpp.

Referenced by TableFunctionCompilationContext::generateEntryPoint().

3457  {
3458  CHECK(byte_stream_arg);
3459  const auto max_col_local_id = num_columns - 1;
3460 
3461  std::vector<llvm::Value*> col_heads;
3462  for (int col_id = 0; col_id <= max_col_local_id; ++col_id) {
3463  auto* gep = ir_builder.CreateGEP(
3464  byte_stream_arg->getType()->getScalarType()->getPointerElementType(),
3465  byte_stream_arg,
3466  llvm::ConstantInt::get(llvm::Type::getInt32Ty(ctx), col_id));
3467  auto* load_gep = ir_builder.CreateLoad(gep->getType()->getPointerElementType(), gep);
3468  load_gep->setName(byte_stream_arg->getName() + "_" + std::to_string(col_id) + "_ptr");
3469  col_heads.emplace_back(load_gep);
3470  }
3471  return col_heads;
3472 }
std::string to_string(char const *&&v)
#define CHECK(condition)
Definition: Logger.h:291

+ Here is the caller graph for this function:

std::map<std::string, std::string> get_device_parameters ( bool  cpu_only)

Definition at line 968 of file NativeCodegen.cpp.

968  {
969  std::map<std::string, std::string> result;
970 
971  result.insert(std::make_pair("cpu_name", llvm::sys::getHostCPUName()));
972  result.insert(std::make_pair("cpu_triple", llvm::sys::getProcessTriple()));
973  result.insert(
974  std::make_pair("cpu_cores", std::to_string(llvm::sys::getHostNumPhysicalCores())));
975  result.insert(std::make_pair("cpu_threads", std::to_string(cpu_threads())));
976 
977  // https://en.cppreference.com/w/cpp/language/types
978  std::string sizeof_types;
979  sizeof_types += "bool:" + std::to_string(sizeof(bool)) + ";";
980  sizeof_types += "size_t:" + std::to_string(sizeof(size_t)) + ";";
981  sizeof_types += "ssize_t:" + std::to_string(sizeof(ssize_t)) + ";";
982  sizeof_types += "char:" + std::to_string(sizeof(char)) + ";";
983  sizeof_types += "uchar:" + std::to_string(sizeof(unsigned char)) + ";";
984  sizeof_types += "short:" + std::to_string(sizeof(short)) + ";";
985  sizeof_types += "ushort:" + std::to_string(sizeof(unsigned short int)) + ";";
986  sizeof_types += "int:" + std::to_string(sizeof(int)) + ";";
987  sizeof_types += "uint:" + std::to_string(sizeof(unsigned int)) + ";";
988  sizeof_types += "long:" + std::to_string(sizeof(long int)) + ";";
989  sizeof_types += "ulong:" + std::to_string(sizeof(unsigned long int)) + ";";
990  sizeof_types += "longlong:" + std::to_string(sizeof(long long int)) + ";";
991  sizeof_types += "ulonglong:" + std::to_string(sizeof(unsigned long long int)) + ";";
992  sizeof_types += "float:" + std::to_string(sizeof(float)) + ";";
993  sizeof_types += "double:" + std::to_string(sizeof(double)) + ";";
994  sizeof_types += "longdouble:" + std::to_string(sizeof(long double)) + ";";
995  sizeof_types += "voidptr:" + std::to_string(sizeof(void*)) + ";";
996 
997  result.insert(std::make_pair("type_sizeof", sizeof_types));
998 
999  std::string null_values;
1000  null_values += "boolean1:" + std::to_string(serialized_null_value<bool>()) + ";";
1001  null_values += "boolean8:" + std::to_string(serialized_null_value<int8_t>()) + ";";
1002  null_values += "int8:" + std::to_string(serialized_null_value<int8_t>()) + ";";
1003  null_values += "int16:" + std::to_string(serialized_null_value<int16_t>()) + ";";
1004  null_values += "int32:" + std::to_string(serialized_null_value<int32_t>()) + ";";
1005  null_values += "int64:" + std::to_string(serialized_null_value<int64_t>()) + ";";
1006  null_values += "uint8:" + std::to_string(serialized_null_value<uint8_t>()) + ";";
1007  null_values += "uint16:" + std::to_string(serialized_null_value<uint16_t>()) + ";";
1008  null_values += "uint32:" + std::to_string(serialized_null_value<uint32_t>()) + ";";
1009  null_values += "uint64:" + std::to_string(serialized_null_value<uint64_t>()) + ";";
1010  null_values += "float32:" + std::to_string(serialized_null_value<float>()) + ";";
1011  null_values += "float64:" + std::to_string(serialized_null_value<double>()) + ";";
1012  null_values +=
1013  "Array<boolean8>:" + std::to_string(serialized_null_value<int8_t, true>()) + ";";
1014  null_values +=
1015  "Array<int8>:" + std::to_string(serialized_null_value<int8_t, true>()) + ";";
1016  null_values +=
1017  "Array<int16>:" + std::to_string(serialized_null_value<int16_t, true>()) + ";";
1018  null_values +=
1019  "Array<int32>:" + std::to_string(serialized_null_value<int32_t, true>()) + ";";
1020  null_values +=
1021  "Array<int64>:" + std::to_string(serialized_null_value<int64_t, true>()) + ";";
1022  null_values +=
1023  "Array<float32>:" + std::to_string(serialized_null_value<float, true>()) + ";";
1024  null_values +=
1025  "Array<float64>:" + std::to_string(serialized_null_value<double, true>()) + ";";
1026 
1027  result.insert(std::make_pair("null_values", null_values));
1028 
1029  llvm::StringMap<bool> cpu_features;
1030  if (llvm::sys::getHostCPUFeatures(cpu_features)) {
1031  std::string features_str = "";
1032  for (auto it = cpu_features.begin(); it != cpu_features.end(); ++it) {
1033  features_str += (it->getValue() ? " +" : " -");
1034  features_str += it->getKey().str();
1035  }
1036  result.insert(std::make_pair("cpu_features", features_str));
1037  }
1038 
1039  result.insert(std::make_pair("llvm_version",
1040  std::to_string(LLVM_VERSION_MAJOR) + "." +
1041  std::to_string(LLVM_VERSION_MINOR) + "." +
1042  std::to_string(LLVM_VERSION_PATCH)));
1043 
1044 #ifdef HAVE_CUDA
1045  if (!cpu_only) {
1046  int device_count = 0;
1047  checkCudaErrors(cuDeviceGetCount(&device_count));
1048  if (device_count) {
1049  CUdevice device{};
1050  char device_name[256];
1051  int major = 0, minor = 0;
1052  int driver_version;
1053  checkCudaErrors(cuDeviceGet(&device, 0)); // assuming homogeneous multi-GPU system
1054  checkCudaErrors(cuDeviceGetName(device_name, 256, device));
1055  checkCudaErrors(cuDeviceGetAttribute(
1056  &major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, device));
1057  checkCudaErrors(cuDeviceGetAttribute(
1058  &minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, device));
1059  checkCudaErrors(cuDriverGetVersion(&driver_version));
1060 
1061  result.insert(std::make_pair("gpu_name", device_name));
1062  result.insert(std::make_pair("gpu_count", std::to_string(device_count)));
1063  result.insert(std::make_pair("gpu_compute_capability",
1064  std::to_string(major) + "." + std::to_string(minor)));
1065  result.insert(std::make_pair("gpu_triple", get_gpu_target_triple_string()));
1066  result.insert(std::make_pair("gpu_datalayout", get_gpu_data_layout()));
1067  result.insert(std::make_pair("gpu_driver",
1068  "CUDA " + std::to_string(driver_version / 1000) + "." +
1069  std::to_string((driver_version % 1000) / 10)));
1070 
1071  auto rt_libdevice_path = get_cuda_libdevice_dir() + "/libdevice.10.bc";
1072  result.insert(
1073  std::make_pair("gpu_has_libdevice",
1074  std::to_string(boost::filesystem::exists(rt_libdevice_path))));
1075  }
1076  }
1077 #endif
1078 
1079  return result;
1080 }
std::string get_cuda_libdevice_dir(void)
Definition: CudaMgr.cpp:612
void checkCudaErrors(CUresult err)
Definition: sample.cpp:38
llvm::StringRef get_gpu_data_layout()
std::string to_string(char const *&&v)
llvm::StringRef get_gpu_target_triple_string()
int CUdevice
Definition: nocuda.h:20
int cpu_threads()
Definition: thread_count.h:25
llvm::StringRef get_gpu_data_layout ( )

Definition at line 960 of file NativeCodegen.cpp.

960  {
961  return llvm::StringRef(
962  "e-p:64:64:64-i1:8:8-i8:8:8-"
963  "i16:16:16-i32:32:32-i64:64:64-"
964  "f32:32:32-f64:64:64-v16:16:16-"
965  "v32:32:32-v64:64:64-v128:128:128-n16:32:64");
966 }
llvm::StringRef get_gpu_target_triple_string ( )

Definition at line 956 of file NativeCodegen.cpp.

References DEBUG_TIMER.

956  {
957  return llvm::StringRef("nvptx64-nvidia-cuda");
958 }
std::unique_ptr<llvm::Module> read_llvm_module_from_bc_file ( const std::string &  bc_filename,
llvm::LLVMContext &  context 
)

Definition at line 1587 of file NativeCodegen.cpp.

Referenced by Executor::update_extension_modules().

1589  {
1590  llvm::SMDiagnostic err;
1591 
1592  auto buffer_or_error = llvm::MemoryBuffer::getFile(bc_filename);
1593  CHECK(!buffer_or_error.getError()) << "bc_filename=" << bc_filename;
1594  llvm::MemoryBuffer* buffer = buffer_or_error.get().get();
1595 
1596  auto owner = llvm::parseBitcodeFile(buffer->getMemBufferRef(), context);
1597  CHECK(!owner.takeError());
1598  CHECK(owner->get());
1599  return std::move(owner.get());
1600 }
#define CHECK(condition)
Definition: Logger.h:291

+ Here is the caller graph for this function:

std::unique_ptr<llvm::Module> read_llvm_module_from_ir_file ( const std::string &  udf_ir_filename,
llvm::LLVMContext &  ctx,
bool  is_gpu = false 
)

Definition at line 1602 of file NativeCodegen.cpp.

Referenced by Executor::update_extension_modules().

1605  {
1606  llvm::SMDiagnostic parse_error;
1607 
1608  llvm::StringRef file_name_arg(udf_ir_filename);
1609 
1610  auto owner = llvm::parseIRFile(file_name_arg, parse_error, ctx);
1611  if (!owner) {
1612  throw_parseIR_error(parse_error, udf_ir_filename, is_gpu);
1613  }
1614 
1615  if (is_gpu) {
1616  llvm::Triple gpu_triple(owner->getTargetTriple());
1617  if (!gpu_triple.isNVPTX()) {
1618  LOG(WARNING)
1619  << "Expected triple nvptx64-nvidia-cuda for NVVM IR of loadtime UDFs but got "
1620  << gpu_triple.str() << ". Disabling the NVVM IR module.";
1621  return std::unique_ptr<llvm::Module>();
1622  }
1623  }
1624  return owner;
1625 }
#define LOG(tag)
Definition: Logger.h:285
void throw_parseIR_error(const llvm::SMDiagnostic &parse_error, std::string src="", const bool is_gpu=false)

+ Here is the caller graph for this function:

std::unique_ptr<llvm::Module> read_llvm_module_from_ir_string ( const std::string &  udf_ir_string,
llvm::LLVMContext &  ctx,
bool  is_gpu = false 
)

Definition at line 1627 of file NativeCodegen.cpp.

Referenced by Executor::update_extension_modules().

1630  {
1631  llvm::SMDiagnostic parse_error;
1632 
1633  auto buf = std::make_unique<llvm::MemoryBufferRef>(udf_ir_string,
1634  "Runtime UDF/UDTF LLVM/NVVM IR");
1635 
1636  auto owner = llvm::parseIR(*buf, parse_error, ctx);
1637  if (!owner) {
1638  LOG(IR) << "read_llvm_module_from_ir_string:\n"
1639  << udf_ir_string << "\nEnd of LLVM/NVVM IR";
1640  throw_parseIR_error(parse_error, "", /* is_gpu= */ is_gpu);
1641  }
1642 
1643  if (is_gpu) {
1644  llvm::Triple gpu_triple(owner->getTargetTriple());
1645  if (!gpu_triple.isNVPTX()) {
1646  LOG(IR) << "read_llvm_module_from_ir_string:\n"
1647  << udf_ir_string << "\nEnd of NNVM IR";
1648  LOG(WARNING) << "Expected triple nvptx64-nvidia-cuda for NVVM IR but got "
1649  << gpu_triple.str()
1650  << ". Executing runtime UDF/UDTFs on GPU will be disabled.";
1651  return std::unique_ptr<llvm::Module>();
1652  ;
1653  }
1654  }
1655  return owner;
1656 }
#define LOG(tag)
Definition: Logger.h:285
void throw_parseIR_error(const llvm::SMDiagnostic &parse_error, std::string src="", const bool is_gpu=false)

+ Here is the caller graph for this function:

void verify_function_ir ( const llvm::Function *  func)

Definition at line 386 of file NativeCodegen.cpp.

References logger::FATAL, and LOG.

Referenced by GpuSharedMemCodeBuilder::codegen(), spatial_type::Transform::codegen(), anonymous_namespace{JoinLoopTest.cpp}::create_loop_test_function(), TableFunctionCompilationContext::generateEntryPoint(), StubGenerator::generateStub(), and translate_function().

386  {
387  std::stringstream err_ss;
388  llvm::raw_os_ostream err_os(err_ss);
389  err_os << "\n-----\n";
390  if (llvm::verifyFunction(*func, &err_os)) {
391  err_os << "\n-----\n";
392  func->print(err_os, nullptr);
393  err_os << "\n-----\n";
394  LOG(FATAL) << err_ss.str();
395  }
396 }
#define LOG(tag)
Definition: Logger.h:285

+ Here is the caller graph for this function:

Variable Documentation

float g_fraction_code_cache_to_evict = 0.2

Definition at line 81 of file NativeCodegen.cpp.

Referenced by CommandLineOptions::fillDeveloperOptions().

constexpr std::array<std::string_view, 18> TARGET_RUNTIME_FUNCTIONS_FOR_MODULE_CLONING
Initial value:
{"query_stub_hoisted_literals",
"multifrag_query_hoisted_literals",
"query_stub",
"multifrag_query",
"fixed_width_int_decode",
"fixed_width_unsigned_decode",
"diff_fixed_width_int_decode",
"fixed_width_double_decode",
"fixed_width_float_decode",
"fixed_width_small_date_decode",
"record_error_code",
"get_error_code",
"pos_start_impl",
"pos_step_impl",
"group_buff_idx_impl",
"init_shared_mem",
"init_shared_mem_nop",
"write_back_nop"}}

Definition at line 1560 of file NativeCodegen.cpp.