OmniSciDB  a987f07e93
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CgenState.h
Go to the documentation of this file.
1 /*
2  * Copyright 2022 HEAVY.AI, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #pragma once
18 
19 #include "IRCodegenUtils.h"
20 #include "InValuesBitmap.h"
21 #include "InputMetadata.h"
22 #include "LLVMGlobalContext.h"
24 
25 #include "../Analyzer/Analyzer.h"
26 #include "../Shared/InsertionOrderedMap.h"
27 
28 #include <llvm/IR/Constants.h>
29 #include <llvm/IR/IRBuilder.h>
30 #include <llvm/Transforms/Utils/ValueMapper.h>
31 
33  llvm::Value* buffer;
34  llvm::Value* size;
35  llvm::Value* is_null;
36 };
37 
38 struct CgenState {
39  public:
40  CgenState(const size_t num_query_infos,
41  const bool contains_left_deep_outer_join,
42  Executor* executor);
43  CgenState(const size_t num_query_infos, const bool contains_left_deep_outer_join);
44  CgenState(llvm::LLVMContext& context);
45 
46  std::tuple<size_t, size_t> getOrAddLiteral(const Analyzer::Constant* constant,
47  const EncodingType enc_type,
48  const int dict_id,
49  const int device_id) {
50  const auto& ti = constant->get_type_info();
51  const auto type = ti.is_decimal() ? decimal_to_int_type(ti) : ti.get_type();
52  switch (type) {
53  case kBOOLEAN:
54  return getOrAddLiteral(constant->get_is_null()
55  ? int8_t(inline_int_null_val(ti))
56  : int8_t(constant->get_constval().boolval ? 1 : 0),
57  device_id);
58  case kTINYINT:
59  return getOrAddLiteral(constant->get_is_null()
60  ? int8_t(inline_int_null_val(ti))
61  : constant->get_constval().tinyintval,
62  device_id);
63  case kSMALLINT:
64  return getOrAddLiteral(constant->get_is_null()
65  ? int16_t(inline_int_null_val(ti))
66  : constant->get_constval().smallintval,
67  device_id);
68  case kINT:
69  return getOrAddLiteral(constant->get_is_null() ? int32_t(inline_int_null_val(ti))
70  : constant->get_constval().intval,
71  device_id);
72  case kBIGINT:
73  return getOrAddLiteral(constant->get_is_null()
74  ? int64_t(inline_int_null_val(ti))
75  : constant->get_constval().bigintval,
76  device_id);
77  case kFLOAT:
78  return getOrAddLiteral(constant->get_is_null()
79  ? float(inline_fp_null_val(ti))
80  : constant->get_constval().floatval,
81  device_id);
82  case kDOUBLE:
83  return getOrAddLiteral(constant->get_is_null()
84  ? inline_fp_null_val(ti)
85  : constant->get_constval().doubleval,
86  device_id);
87  case kCHAR:
88  case kTEXT:
89  case kVARCHAR:
90  if (enc_type == kENCODING_DICT) {
91  if (constant->get_is_null()) {
92  return getOrAddLiteral(int32_t(inline_int_null_val(ti)), device_id);
93  }
94  return getOrAddLiteral(
95  std::make_pair(*constant->get_constval().stringval, dict_id), device_id);
96  }
97  CHECK_EQ(kENCODING_NONE, enc_type);
98  if (constant->get_is_null()) {
99  throw std::runtime_error(
100  "CHAR / VARCHAR NULL literal not supported in this context"); // TODO(alex):
101  // support
102  // null
103  }
104  return getOrAddLiteral(*constant->get_constval().stringval, device_id);
105  case kTIME:
106  case kTIMESTAMP:
107  case kDATE:
108  case kINTERVAL_DAY_TIME:
110  // TODO(alex): support null
111  return getOrAddLiteral(constant->get_constval().bigintval, device_id);
112  case kARRAY: {
113  if (enc_type == kENCODING_NONE) {
114  if (ti.get_subtype() == kDOUBLE) {
115  std::vector<double> double_array_literal;
116  for (const auto& value : constant->get_value_list()) {
117  const auto c = dynamic_cast<const Analyzer::Constant*>(value.get());
118  CHECK(c);
119  double d = c->get_constval().doubleval;
120  double_array_literal.push_back(d);
121  }
122  return getOrAddLiteral(double_array_literal, device_id);
123  }
124  if (ti.get_subtype() == kINT) {
125  std::vector<int32_t> int32_array_literal;
126  for (const auto& value : constant->get_value_list()) {
127  const auto c = dynamic_cast<const Analyzer::Constant*>(value.get());
128  CHECK(c);
129  int32_t i = c->get_constval().intval;
130  int32_array_literal.push_back(i);
131  }
132  return getOrAddLiteral(int32_array_literal, device_id);
133  }
134  if (ti.get_subtype() == kTINYINT) {
135  std::vector<int8_t> int8_array_literal;
136  for (const auto& value : constant->get_value_list()) {
137  const auto c = dynamic_cast<const Analyzer::Constant*>(value.get());
138  CHECK(c);
139  int8_t i = c->get_constval().tinyintval;
140  int8_array_literal.push_back(i);
141  }
142  if (ti.get_comp_param() == 64) {
143  return getOrAddLiteral(std::make_pair(int8_array_literal, 64), device_id);
144  }
145  return getOrAddLiteral(int8_array_literal, device_id);
146  }
147  throw std::runtime_error("Unsupported literal array");
148  }
149  if (enc_type == kENCODING_GEOINT) {
150  if (ti.get_subtype() == kTINYINT) {
151  std::vector<int8_t> int8_array_literal;
152  for (const auto& value : constant->get_value_list()) {
153  const auto c = dynamic_cast<const Analyzer::Constant*>(value.get());
154  CHECK(c);
155  int8_t i = c->get_constval().tinyintval;
156  int8_array_literal.push_back(i);
157  }
158  if (ti.get_comp_param() == 32) {
159  return getOrAddLiteral(std::make_pair(int8_array_literal, 32), device_id);
160  }
161  return getOrAddLiteral(int8_array_literal, device_id);
162  }
163  }
164  throw std::runtime_error("Encoded literal arrays are not supported");
165  }
166  default:
167  abort();
168  }
169  }
170 
171  using LiteralValue = boost::variant<int8_t,
172  int16_t,
173  int32_t,
174  int64_t,
175  float,
176  double,
177  std::pair<std::string, int>,
178  std::string,
179  std::vector<double>,
180  std::vector<int32_t>,
181  std::vector<int8_t>,
182  std::pair<std::vector<int8_t>, int>>;
183  using LiteralValues = std::vector<LiteralValue>;
184 
185  const std::unordered_map<int, LiteralValues>& getLiterals() const { return literals_; }
186 
187  llvm::Value* addStringConstant(const std::string& str) {
188  llvm::Value* str_lv = ir_builder_.CreateGlobalString(
189  str, "str_const_" + std::to_string(std::hash<std::string>()(str)));
190  auto i8_ptr = llvm::PointerType::get(get_int_type(8, context_), 0);
191  str_constants_.push_back(str_lv);
192  str_lv = ir_builder_.CreateBitCast(str_lv, i8_ptr);
193  return str_lv;
194  }
195 
197  std::unique_ptr<const StringDictionaryTranslationMgr>&& str_dict_translation_mgr) {
198  str_dict_translation_mgrs_.emplace_back(std::move(str_dict_translation_mgr));
199  return str_dict_translation_mgrs_.back().get();
200  }
201 
203  std::unique_ptr<InValuesBitmap>& in_values_bitmap) {
204  if (in_values_bitmap->isEmpty()) {
205  return in_values_bitmap.get();
206  }
207  in_values_bitmaps_.emplace_back(std::move(in_values_bitmap));
208  return in_values_bitmaps_.back().get();
209  }
210  void moveInValuesBitmap(std::unique_ptr<const InValuesBitmap>& in_values_bitmap) {
211  if (!in_values_bitmap->isEmpty()) {
212  in_values_bitmaps_.emplace_back(std::move(in_values_bitmap));
213  }
214  }
215  // look up a runtime function based on the name, return type and type of
216  // the arguments and call it; x64 only, don't call from GPU codegen
217  llvm::Value* emitExternalCall(
218  const std::string& fname,
219  llvm::Type* ret_type,
220  const std::vector<llvm::Value*> args,
221  const std::vector<llvm::Attribute::AttrKind>& fnattrs = {},
222  const bool has_struct_return = false);
223  llvm::Value* emitCall(const std::string& fname, const std::vector<llvm::Value*>& args);
224  llvm::Value* emitEntryCall(const std::string& fname,
225  const std::vector<llvm::Value*>& args);
226 
227  size_t getLiteralBufferUsage(const int device_id) { return literal_bytes_[device_id]; }
228 
229  llvm::Value* castToTypeIn(llvm::Value* val, const size_t bit_width);
230 
231  std::pair<llvm::ConstantInt*, llvm::ConstantInt*> inlineIntMaxMin(
232  const size_t byte_width,
233  const bool is_signed);
234 
235  llvm::ConstantInt* inlineIntNull(const SQLTypeInfo&);
236  llvm::ConstantFP* inlineFpNull(const SQLTypeInfo&);
237  llvm::Constant* inlineNull(const SQLTypeInfo&);
238 
239  template <class T>
240  llvm::ConstantInt* llInt(const T v) const {
242  }
243 
244  llvm::ConstantFP* llFp(const float v) const {
245  return static_cast<llvm::ConstantFP*>(
246  llvm::ConstantFP::get(llvm::Type::getFloatTy(context_), v));
247  }
248 
249  llvm::ConstantFP* llFp(const double v) const {
250  return static_cast<llvm::ConstantFP*>(
251  llvm::ConstantFP::get(llvm::Type::getDoubleTy(context_), v));
252  }
253 
254  llvm::ConstantInt* llBool(const bool v) const { return ::ll_bool(v, context_); }
255 
256  void emitErrorCheck(llvm::Value* condition, llvm::Value* errorCode, std::string label);
257 
258  std::vector<std::string> gpuFunctionsToReplace(llvm::Function* fn);
259 
260  void replaceFunctionForGpu(const std::string& fcn_to_replace, llvm::Function* fn);
261 
262  std::shared_ptr<Executor> getExecutor() const;
263  llvm::LLVMContext& getExecutorContext() const;
264  void set_module_shallow_copy(const std::unique_ptr<llvm::Module>& module,
265  bool always_clone = false);
266 
267  size_t executor_id_;
268 
269  /*
270  Managing LLVM modules
271  ---------------------
272 
273  Quoting https://groups.google.com/g/llvm-dev/c/kuil5XjasUs/m/7PBpOWZFDAAJ :
274  """
275  The state of Module/Context ownership is very muddled in the
276  codebase. As you have discovered: LLVMContext’s notionally own
277  their modules (via raw pointers deleted upon destruction of the
278  context), however in practice we always hold llvm Modules by
279  unique_ptr. Since the Module destructor removes the raw pointer
280  from the Context, this doesn’t usually blow up. It’s pretty broken
281  though.
282 
283  I would argue that you should use unique_ptr and ignore
284  LLVMContext ownership.
285  """
286 
287  Here we follow the last argument only partially for reasons
288  explained below.
289 
290  HeavyDB supports concurrent query executions. For that, a global
291  cache of Executor instances is used. Each instance is able to
292  generate LLVM code, compile it to machine code (with code
293  caching), and execute the code --- all that concurrently with
294  other Executor instances.
295 
296  Each Executor instance holds as set of extension modules (LLVM
297  Module instances) that are either loaded at Executor construction
298  time (template module from RuntimeFunctions.bc, rt_geos from
299  GeosRuntime.bc, rt_libdevice from libdevice.10.bc, udf_cpu/gpu
300  modules from LLVM IR file), or at run-time (rt_udf_cpu/gpu modules
301  from LLVM IR string). All these extension modules are owned by
302  the Executor instance via unique_ptr. Since Executor also owns the
303  LLVM Context instance that technically also owns these extension
304  modules, then the LLVM Context-Module ownership can be ignored
305  (see the quote above).
306 
307  Code generation is a process that compiles
308  (generated/user-provided) LLVM IR code into machine code that can
309  be executed on a CPU or GPU.
310 
311  Typically, a copy of the template module (let's call this copy as
312  a worker module) is used as an input to code generation that is
313  updated with generated/user-provided LLVM Functions and with other
314  extension modules being linked in. The worker module is created by
315  set_module_shallow_copy and is owned by an Executor instance as a
316  raw pointer (via cgen_state member). Notice that
317  set_module_shallow_copy clones the template module and then
318  releases unique_ptr as a raw pointer. This means that Executor is
319  now responsible of deleting the worker module after the
320  compilation process completes.
321 
322  The reason why the worker module is stored via raw pointer value
323  (rather than using unique_ptr as suggested in the quote above) is
324  as follows. First, the code generation in HeavyDB can be a
325  recursive process (e.g. in the case of multi-step
326  multi-subqueries) that involves temporary "shelving" of parent
327  compilation processes (the corresponding worker modules are put on
328  hold). In addition, the Executor may trigger threaded compilations
329  that involve "resetting" the worker module for different threads
330  (btw, these compilations cannot be concurrent because LLVM Context
331  is not threadsafe. The shelving and resetting of worker modules
332  makes the scope of a worker module dynamic (only one worker module
333  instance can be in scope while other worker modules are on hold)
334  that contradicts with the purpose of unique_ptr (out-of-scope
335  worker modules can be destroyed) and would make managing all
336  worker modules very painful if these would be stored as unique_ptr
337  instances.
338 
339  An entry point to the code generation is Executor::compileWorkUnit
340  method. Its scope includes creating an Executor::CgenStateManager
341  instance that uses RAII pattern to manage the CgenState instance
342  held by an Executor instance. In addition, the CgenStateManager
343  locks other compilations within the same Executor instance. The
344  compilation lock enables the threaded compilation feature.
345 
346  Construction of CgenStateManager (i) stores the existing CgenState
347  instance held by the Executor instance, and (ii) creates an new
348  CgenState instance with un-instantiated worker module. The worker
349  module is instantiated after the construction (unless
350  QueryMustRunOnCpu is thrown) via set_module_shallow_copy, followed
351  by updating the worker module according to the given query and
352  compiling it to machine code. Destruction of CgenStateManager
353  (read: when leaving the compileWorkUnit method) will delete the
354  instantiated worker module and restores the previous CgenState
355  instance. This CgenState management enables the recursive
356  compilation feature.
357 
358  Finally, we note that the worker module compilation caches the
359  compilation results using the full LLVM IR as the cache
360  key. Caching compilation results is especially effective for CUDA
361  target due to a considerable overhead from the CUDA compilation.
362  */
363 
364  llvm::Module* module_;
365  llvm::Function* row_func_;
366  llvm::Function* filter_func_;
367  llvm::Function* current_func_;
368  llvm::BasicBlock* row_func_bb_;
369  llvm::BasicBlock* filter_func_bb_;
370  llvm::CallInst* row_func_call_;
371  llvm::CallInst* filter_func_call_;
372  std::vector<llvm::Function*> helper_functions_;
373  llvm::LLVMContext& context_; // LLVMContext instance is held by an Executor instance.
374  llvm::ValueToValueMapTy vmap_; // used for cloning the runtime module
375  llvm::IRBuilder<> ir_builder_;
376  std::unordered_map<size_t, std::vector<llvm::Value*>> fetch_cache_;
379  llvm::Value* lv;
380  };
381  std::vector<FunctionOperValue> ext_call_cache_;
382  std::vector<llvm::Value*> group_by_expr_cache_;
383  std::vector<llvm::Value*> str_constants_;
384  std::vector<llvm::Value*> frag_offsets_;
386  std::vector<llvm::Value*> outer_join_match_found_per_level_;
387  std::unordered_map<int, llvm::Value*> scan_idx_to_hash_pos_;
389  std::vector<std::unique_ptr<const InValuesBitmap>> in_values_bitmaps_;
390  std::vector<std::unique_ptr<const StringDictionaryTranslationMgr>>
392  std::map<std::pair<llvm::Value*, llvm::Value*>, ArrayLoadCodegen>
393  array_load_cache_; // byte stream to array info
394  std::unordered_map<std::string, llvm::Value*> geo_target_cache_;
397 
398  llvm::Function* query_func_;
399  llvm::IRBuilder<> query_func_entry_ir_builder_;
400  std::unordered_map<int, std::vector<llvm::Value*>> query_func_literal_loads_;
401 
405  };
406  std::unordered_map<llvm::Value*, HoistedLiteralLoadLocator> row_func_hoisted_literals_;
407 
408  static size_t literalBytes(const CgenState::LiteralValue& lit) {
409  switch (lit.which()) {
410  case 0:
411  return 1; // int8_t
412  case 1:
413  return 2; // int16_t
414  case 2:
415  return 4; // int32_t
416  case 3:
417  return 8; // int64_t
418  case 4:
419  return 4; // float
420  case 5:
421  return 8; // double
422  case 6:
423  return 4; // std::pair<std::string, int>
424  case 7:
425  return 4; // std::string
426  case 8:
427  return 4; // std::vector<double>
428  case 9:
429  return 4; // std::vector<int32_t>
430  case 10:
431  return 4; // std::vector<int8_t>
432  case 11:
433  return 4; // std::pair<std::vector<int8_t>, int>
434  default:
435  abort();
436  }
437  }
438 
439  static size_t addAligned(const size_t off_in, const size_t alignment) {
440  size_t off = off_in;
441  if (off % alignment != 0) {
442  off += (alignment - off % alignment);
443  }
444  return off + alignment;
445  }
446 
447  void maybeCloneFunctionRecursive(llvm::Function* fn);
448 
449  private:
450  template <class T>
451  std::tuple<size_t, size_t> getOrAddLiteral(const T& val, const int device_id) {
452  const LiteralValue var_val(val);
453  size_t literal_found_off{0};
454  auto& literals = literals_[device_id];
455  for (const auto& literal : literals) {
456  const auto lit_bytes = literalBytes(literal);
457  literal_found_off = addAligned(literal_found_off, lit_bytes);
458  if (literal == var_val) {
459  return {literal_found_off - lit_bytes, lit_bytes};
460  }
461  }
462  literals.emplace_back(val);
463  const auto lit_bytes = literalBytes(var_val);
464  literal_bytes_[device_id] = addAligned(literal_bytes_[device_id], lit_bytes);
465  return {literal_bytes_[device_id] - lit_bytes, lit_bytes};
466  }
467 
468  std::unordered_map<int, LiteralValues> literals_;
469  std::unordered_map<int, size_t> literal_bytes_;
470 };
471 
std::vector< llvm::Function * > helper_functions_
Definition: CgenState.h:372
int8_t tinyintval
Definition: Datum.h:69
const std::list< std::shared_ptr< Analyzer::Expr > > & get_value_list() const
Definition: Analyzer.h:346
#define CHECK_EQ(x, y)
Definition: Logger.h:297
llvm::Value * castToTypeIn(llvm::Value *val, const size_t bit_width)
Definition: CgenState.cpp:149
llvm::Value * emitEntryCall(const std::string &fname, const std::vector< llvm::Value * > &args)
Definition: CgenState.cpp:228
std::vector< llvm::Value * > outer_join_match_found_per_level_
Definition: CgenState.h:386
std::unordered_map< size_t, std::vector< llvm::Value * > > fetch_cache_
Definition: CgenState.h:376
Definition: sqltypes.h:64
llvm::LLVMContext & getExecutorContext() const
Definition: CgenState.cpp:377
std::shared_ptr< Executor > getExecutor() const
Definition: CgenState.cpp:372
std::map< std::pair< llvm::Value *, llvm::Value * >, ArrayLoadCodegen > array_load_cache_
Definition: CgenState.h:393
const Analyzer::FunctionOper * foper
Definition: CgenState.h:378
llvm::Value * addStringConstant(const std::string &str)
Definition: CgenState.h:187
void maybeCloneFunctionRecursive(llvm::Function *fn)
Definition: CgenState.cpp:180
llvm::Function * query_func_
Definition: CgenState.h:398
llvm::ConstantInt * ll_int(const T v, llvm::LLVMContext &context)
std::unordered_map< llvm::Value *, HoistedLiteralLoadLocator > row_func_hoisted_literals_
Definition: CgenState.h:406
llvm::IRBuilder ir_builder_
Definition: CgenState.h:375
int8_t boolval
Definition: Datum.h:68
bool get_is_null() const
Definition: Analyzer.h:343
void moveInValuesBitmap(std::unique_ptr< const InValuesBitmap > &in_values_bitmap)
Definition: CgenState.h:210
std::vector< llvm::Value * > str_constants_
Definition: CgenState.h:383
llvm::ConstantInt * llBool(const bool v) const
Definition: CgenState.h:254
std::unordered_map< int, std::vector< llvm::Value * > > query_func_literal_loads_
Definition: CgenState.h:400
bool needs_geos_
Definition: CgenState.h:396
InsertionOrderedMap filter_func_args_
Definition: CgenState.h:388
const bool contains_left_deep_outer_join_
Definition: CgenState.h:385
llvm::Value * buffer
Definition: CgenState.h:33
llvm::Type * get_int_type(const int width, llvm::LLVMContext &context)
const std::unordered_map< int, LiteralValues > & getLiterals() const
Definition: CgenState.h:185
double inline_fp_null_val(const SQL_TYPE_INFO &ti)
int32_t intval
Definition: Datum.h:71
std::unordered_map< std::string, llvm::Value * > geo_target_cache_
Definition: CgenState.h:394
llvm::ConstantFP * llFp(const double v) const
Definition: CgenState.h:249
std::string to_string(char const *&&v)
static size_t literalBytes(const CgenState::LiteralValue &lit)
Definition: CgenState.h:408
std::vector< FunctionOperValue > ext_call_cache_
Definition: CgenState.h:381
llvm::Function * row_func_
Definition: CgenState.h:365
float floatval
Definition: Datum.h:73
std::vector< llvm::Value * > group_by_expr_cache_
Definition: CgenState.h:382
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 >> LiteralValue
Definition: CgenState.h:182
EncodingType
Definition: sqltypes.h:228
llvm::Module * module_
Definition: CgenState.h:364
size_t executor_id_
Definition: CgenState.h:267
llvm::LLVMContext & context_
Definition: CgenState.h:373
llvm::Function * current_func_
Definition: CgenState.h:367
llvm::Value * emitExternalCall(const std::string &fname, llvm::Type *ret_type, const std::vector< llvm::Value * > args, const std::vector< llvm::Attribute::AttrKind > &fnattrs={}, const bool has_struct_return=false)
Definition: CgenState.cpp:396
static size_t addAligned(const size_t off_in, const size_t alignment)
Definition: CgenState.h:439
llvm::CallInst * filter_func_call_
Definition: CgenState.h:371
llvm::ConstantInt * inlineIntNull(const SQLTypeInfo &)
Definition: CgenState.cpp:64
int64_t bigintval
Definition: Datum.h:72
std::vector< LiteralValue > LiteralValues
Definition: CgenState.h:183
const InValuesBitmap * addInValuesBitmap(std::unique_ptr< InValuesBitmap > &in_values_bitmap)
Definition: CgenState.h:202
void replaceFunctionForGpu(const std::string &fcn_to_replace, llvm::Function *fn)
Definition: CgenState.cpp:328
std::unordered_map< int, size_t > literal_bytes_
Definition: CgenState.h:469
int16_t smallintval
Definition: Datum.h:70
std::unordered_map< int, llvm::Value * > scan_idx_to_hash_pos_
Definition: CgenState.h:387
bool needs_error_check_
Definition: CgenState.h:395
llvm::ConstantFP * llFp(const float v) const
Definition: CgenState.h:244
std::vector< std::string > gpuFunctionsToReplace(llvm::Function *fn)
Definition: CgenState.cpp:305
llvm::IRBuilder query_func_entry_ir_builder_
Definition: CgenState.h:399
llvm::BasicBlock * filter_func_bb_
Definition: CgenState.h:369
const SQLTypeInfo & get_type_info() const
Definition: Analyzer.h:83
llvm::Value * emitCall(const std::string &fname, const std::vector< llvm::Value * > &args)
Definition: CgenState.cpp:216
std::string * stringval
Definition: Datum.h:77
SQLTypes decimal_to_int_type(const SQLTypeInfo &ti)
Definition: Datum.cpp:559
llvm::Constant * inlineNull(const SQLTypeInfo &)
Definition: CgenState.cpp:115
void set_module_shallow_copy(const std::unique_ptr< llvm::Module > &module, bool always_clone=false)
Definition: CgenState.cpp:381
std::vector< std::unique_ptr< const InValuesBitmap > > in_values_bitmaps_
Definition: CgenState.h:389
Definition: sqltypes.h:67
Definition: sqltypes.h:68
llvm::Function * filter_func_
Definition: CgenState.h:366
std::unordered_map< int, LiteralValues > literals_
Definition: CgenState.h:468
std::vector< llvm::Value * > frag_offsets_
Definition: CgenState.h:384
llvm::Value * is_null
Definition: CgenState.h:35
size_t getLiteralBufferUsage(const int device_id)
Definition: CgenState.h:227
Datum get_constval() const
Definition: Analyzer.h:344
void emitErrorCheck(llvm::Value *condition, llvm::Value *errorCode, std::string label)
Definition: CgenState.cpp:240
Definition: sqltypes.h:56
llvm::ConstantInt * llInt(const T v) const
Definition: CgenState.h:240
#define CHECK(condition)
Definition: Logger.h:289
llvm::ValueToValueMapTy vmap_
Definition: CgenState.h:374
int64_t inline_int_null_val(const SQL_TYPE_INFO &ti)
llvm::ConstantInt * ll_bool(const bool v, llvm::LLVMContext &context)
const StringDictionaryTranslationMgr * moveStringDictionaryTranslationMgr(std::unique_ptr< const StringDictionaryTranslationMgr > &&str_dict_translation_mgr)
Definition: CgenState.h:196
Definition: sqltypes.h:60
std::vector< std::unique_ptr< const StringDictionaryTranslationMgr > > str_dict_translation_mgrs_
Definition: CgenState.h:391
std::tuple< size_t, size_t > getOrAddLiteral(const T &val, const int device_id)
Definition: CgenState.h:451
llvm::Value * size
Definition: CgenState.h:34
std::tuple< size_t, size_t > getOrAddLiteral(const Analyzer::Constant *constant, const EncodingType enc_type, const int dict_id, const int device_id)
Definition: CgenState.h:46
llvm::CallInst * row_func_call_
Definition: CgenState.h:370
CgenState(const size_t num_query_infos, const bool contains_left_deep_outer_join, Executor *executor)
Definition: CgenState.cpp:25
std::pair< llvm::ConstantInt *, llvm::ConstantInt * > inlineIntMaxMin(const size_t byte_width, const bool is_signed)
Definition: CgenState.cpp:120
double doubleval
Definition: Datum.h:74
llvm::BasicBlock * row_func_bb_
Definition: CgenState.h:368
llvm::ConstantFP * inlineFpNull(const SQLTypeInfo &)
Definition: CgenState.cpp:103