OmniSciDB  085a039ca4
 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 2021 OmniSci, 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  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  std::vector<llvm::Type*> arg_types;
224  for (const auto arg : args) {
225  CHECK(arg);
226  arg_types.push_back(arg->getType());
227  }
228  auto func_ty = llvm::FunctionType::get(ret_type, arg_types, false);
229  llvm::AttributeList attrs;
230  if (!fnattrs.empty()) {
231  std::vector<std::pair<unsigned, llvm::Attribute>> indexedAttrs;
232  indexedAttrs.reserve(fnattrs.size());
233  for (auto attr : fnattrs) {
234  indexedAttrs.emplace_back(llvm::AttributeList::FunctionIndex,
235  llvm::Attribute::get(context_, attr));
236  }
237  attrs = llvm::AttributeList::get(context_,
238  {&indexedAttrs.front(), indexedAttrs.size()});
239  }
240 
241  auto func_p = module_->getOrInsertFunction(fname, func_ty, attrs);
242  CHECK(func_p);
243  auto callee = func_p.getCallee();
244  llvm::Function* func{nullptr};
245  if (auto callee_cast = llvm::dyn_cast<llvm::ConstantExpr>(callee)) {
246  // Get or insert function automatically adds a ConstantExpr cast if the return type
247  // of the existing function does not match the supplied return type.
248  CHECK(callee_cast->isCast());
249  CHECK_EQ(callee_cast->getNumOperands(), size_t(1));
250  func = llvm::dyn_cast<llvm::Function>(callee_cast->getOperand(0));
251  } else {
252  func = llvm::dyn_cast<llvm::Function>(callee);
253  }
254  CHECK(func);
255  llvm::FunctionType* func_type = func_p.getFunctionType();
256  CHECK(func_type);
257  if (has_struct_return) {
258  const auto arg_ti = func_type->getParamType(0);
259  CHECK(arg_ti->isPointerTy() && arg_ti->getPointerElementType()->isStructTy());
260  auto attr_list = func->getAttributes();
261  llvm::AttrBuilder arr_arg_builder(attr_list.getParamAttributes(0));
262  arr_arg_builder.addAttribute(llvm::Attribute::StructRet);
263  func->addParamAttrs(0, arr_arg_builder);
264  }
265  const size_t arg_start = has_struct_return ? 1 : 0;
266  for (size_t i = arg_start; i < func->arg_size(); i++) {
267  const auto arg_ti = func_type->getParamType(i);
268  if (arg_ti->isPointerTy() && arg_ti->getPointerElementType()->isStructTy()) {
269  auto attr_list = func->getAttributes();
270  llvm::AttrBuilder arr_arg_builder(attr_list.getParamAttributes(i));
271  arr_arg_builder.addByValAttr(arg_ti->getPointerElementType());
272  func->addParamAttrs(i, arr_arg_builder);
273  }
274  }
275  llvm::Value* result = ir_builder_.CreateCall(func_p, args);
276  // check the assumed type
277  CHECK_EQ(result->getType(), ret_type);
278  return result;
279  }
280 
281  llvm::Value* emitCall(const std::string& fname, const std::vector<llvm::Value*>& args);
282 
283  size_t getLiteralBufferUsage(const int device_id) { return literal_bytes_[device_id]; }
284 
285  llvm::Value* castToTypeIn(llvm::Value* val, const size_t bit_width);
286 
287  std::pair<llvm::ConstantInt*, llvm::ConstantInt*> inlineIntMaxMin(
288  const size_t byte_width,
289  const bool is_signed);
290 
291  llvm::ConstantInt* inlineIntNull(const SQLTypeInfo&);
292  llvm::ConstantFP* inlineFpNull(const SQLTypeInfo&);
293  llvm::Constant* inlineNull(const SQLTypeInfo&);
294 
295  template <class T>
296  llvm::ConstantInt* llInt(const T v) const {
298  }
299 
300  llvm::ConstantFP* llFp(const float v) const {
301  return static_cast<llvm::ConstantFP*>(
302  llvm::ConstantFP::get(llvm::Type::getFloatTy(context_), v));
303  }
304 
305  llvm::ConstantFP* llFp(const double v) const {
306  return static_cast<llvm::ConstantFP*>(
307  llvm::ConstantFP::get(llvm::Type::getDoubleTy(context_), v));
308  }
309 
310  llvm::ConstantInt* llBool(const bool v) const { return ::ll_bool(v, context_); }
311 
312  void emitErrorCheck(llvm::Value* condition, llvm::Value* errorCode, std::string label);
313 
314  std::vector<std::string> gpuFunctionsToReplace(llvm::Function* fn);
315 
316  void replaceFunctionForGpu(const std::string& fcn_to_replace, llvm::Function* fn);
317 
318  std::shared_ptr<Executor> getExecutor() const;
319  llvm::LLVMContext& getExecutorContext() const;
320  void set_module_shallow_copy(const std::unique_ptr<llvm::Module>& module,
321  bool always_clone = false);
322 
323  size_t executor_id_;
324  /*
325  Quoting https://groups.google.com/g/llvm-dev/c/kuil5XjasUs/m/7PBpOWZFDAAJ :
326  """
327  The state of Module/Context ownership is very muddled in the
328  codebase. As you have discovered: LLVMContext’s notionally own
329  their modules (via raw pointers deleted upon destruction of the
330  context), however in practice we always hold llvm Modules by
331  unique_ptr. Since the Module destructor removes the raw pointer
332  from the Context, this doesn’t usually blow up. It’s pretty broken
333  though.
334 
335  I would argue that you should use unique_ptr and ignore
336  LLVMContext ownership.
337  """
338 
339  Here we do the opposite to the last argument because we store
340  llvm::Module pointers in CodeCache and it is hard to sync the
341  destruction of LLVMContext and removing its modules from the
342  CodeCache. Instead, we'll never explicitly delete llvm::Module
343  instances and we'll let LLVMContext or unique_ptr to manage the
344  destruction of llvm::Modules. As a result, whenever LLVMContext is
345  destroyed, the corresponding llvm::Module pointers in CodeCache
346  become invalid and it is recommended to clear the CodeCache as
347  well.
348  */
349 
350  llvm::Module* module_;
351  llvm::Function* row_func_;
352  llvm::Function* filter_func_;
353  llvm::Function* current_func_;
354  llvm::BasicBlock* row_func_bb_;
355  llvm::BasicBlock* filter_func_bb_;
356  llvm::CallInst* row_func_call_;
357  llvm::CallInst* filter_func_call_;
358  std::vector<llvm::Function*> helper_functions_;
359  llvm::LLVMContext& context_; // LLVMContext instance is held by an Executor instance.
360  llvm::ValueToValueMapTy vmap_; // used for cloning the runtime module
361  llvm::IRBuilder<> ir_builder_;
362  std::unordered_map<int, std::vector<llvm::Value*>> fetch_cache_;
365  llvm::Value* lv;
366  };
367  std::vector<FunctionOperValue> ext_call_cache_;
368  std::vector<llvm::Value*> group_by_expr_cache_;
369  std::vector<llvm::Value*> str_constants_;
370  std::vector<llvm::Value*> frag_offsets_;
372  std::vector<llvm::Value*> outer_join_match_found_per_level_;
373  std::unordered_map<int, llvm::Value*> scan_idx_to_hash_pos_;
375  std::vector<std::unique_ptr<const InValuesBitmap>> in_values_bitmaps_;
376  std::vector<std::unique_ptr<const StringDictionaryTranslationMgr>>
378  std::map<std::pair<llvm::Value*, llvm::Value*>, ArrayLoadCodegen>
379  array_load_cache_; // byte stream to array info
380  std::unordered_map<std::string, llvm::Value*> geo_target_cache_;
383 
384  llvm::Function* query_func_;
385  llvm::IRBuilder<> query_func_entry_ir_builder_;
386  std::unordered_map<int, std::vector<llvm::Value*>> query_func_literal_loads_;
387 
391  };
392  std::unordered_map<llvm::Value*, HoistedLiteralLoadLocator> row_func_hoisted_literals_;
393 
394  static size_t literalBytes(const CgenState::LiteralValue& lit) {
395  switch (lit.which()) {
396  case 0:
397  return 1; // int8_t
398  case 1:
399  return 2; // int16_t
400  case 2:
401  return 4; // int32_t
402  case 3:
403  return 8; // int64_t
404  case 4:
405  return 4; // float
406  case 5:
407  return 8; // double
408  case 6:
409  return 4; // std::pair<std::string, int>
410  case 7:
411  return 4; // std::string
412  case 8:
413  return 4; // std::vector<double>
414  case 9:
415  return 4; // std::vector<int32_t>
416  case 10:
417  return 4; // std::vector<int8_t>
418  case 11:
419  return 4; // std::pair<std::vector<int8_t>, int>
420  default:
421  abort();
422  }
423  }
424 
425  static size_t addAligned(const size_t off_in, const size_t alignment) {
426  size_t off = off_in;
427  if (off % alignment != 0) {
428  off += (alignment - off % alignment);
429  }
430  return off + alignment;
431  }
432 
433  void maybeCloneFunctionRecursive(llvm::Function* fn);
434 
435  private:
436  template <class T>
437  size_t getOrAddLiteral(const T& val, const int device_id) {
438  const LiteralValue var_val(val);
439  size_t literal_found_off{0};
440  auto& literals = literals_[device_id];
441  for (const auto& literal : literals) {
442  const auto lit_bytes = literalBytes(literal);
443  literal_found_off = addAligned(literal_found_off, lit_bytes);
444  if (literal == var_val) {
445  return literal_found_off - lit_bytes;
446  }
447  }
448  literals.emplace_back(val);
449  const auto lit_bytes = literalBytes(var_val);
450  literal_bytes_[device_id] = addAligned(literal_bytes_[device_id], lit_bytes);
451  return literal_bytes_[device_id] - lit_bytes;
452  }
453 
454  std::unordered_map<int, LiteralValues> literals_;
455  std::unordered_map<int, size_t> literal_bytes_;
456 };
457 
std::vector< llvm::Function * > helper_functions_
Definition: CgenState.h:358
int8_t tinyintval
Definition: sqltypes.h:212
const std::list< std::shared_ptr< Analyzer::Expr > > & get_value_list() const
Definition: Analyzer.h:344
#define CHECK_EQ(x, y)
Definition: Logger.h:231
llvm::Value * castToTypeIn(llvm::Value *val, const size_t bit_width)
Definition: CgenState.cpp:148
std::vector< llvm::Value * > outer_join_match_found_per_level_
Definition: CgenState.h:372
Definition: sqltypes.h:49
llvm::LLVMContext & getExecutorContext() const
Definition: CgenState.cpp:364
std::shared_ptr< Executor > getExecutor() const
Definition: CgenState.cpp:359
std::map< std::pair< llvm::Value *, llvm::Value * >, ArrayLoadCodegen > array_load_cache_
Definition: CgenState.h:379
const Analyzer::FunctionOper * foper
Definition: CgenState.h:364
llvm::Value * addStringConstant(const std::string &str)
Definition: CgenState.h:187
void maybeCloneFunctionRecursive(llvm::Function *fn)
Definition: CgenState.cpp:179
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.h:217
llvm::Function * query_func_
Definition: CgenState.h:384
llvm::ConstantInt * ll_int(const T v, llvm::LLVMContext &context)
std::unordered_map< llvm::Value *, HoistedLiteralLoadLocator > row_func_hoisted_literals_
Definition: CgenState.h:392
llvm::IRBuilder ir_builder_
Definition: CgenState.h:361
int8_t boolval
Definition: sqltypes.h:211
bool get_is_null() const
Definition: Analyzer.h:341
void moveInValuesBitmap(std::unique_ptr< const InValuesBitmap > &in_values_bitmap)
Definition: CgenState.h:210
std::vector< llvm::Value * > str_constants_
Definition: CgenState.h:369
llvm::ConstantInt * llBool(const bool v) const
Definition: CgenState.h:310
std::unordered_map< int, std::vector< llvm::Value * > > query_func_literal_loads_
Definition: CgenState.h:386
bool needs_geos_
Definition: CgenState.h:382
InsertionOrderedMap filter_func_args_
Definition: CgenState.h:374
const bool contains_left_deep_outer_join_
Definition: CgenState.h:371
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: sqltypes.h:214
std::unordered_map< std::string, llvm::Value * > geo_target_cache_
Definition: CgenState.h:380
size_t getOrAddLiteral(const T &val, const int device_id)
Definition: CgenState.h:437
llvm::ConstantFP * llFp(const double v) const
Definition: CgenState.h:305
std::string to_string(char const *&&v)
static size_t literalBytes(const CgenState::LiteralValue &lit)
Definition: CgenState.h:394
std::vector< FunctionOperValue > ext_call_cache_
Definition: CgenState.h:367
llvm::Function * row_func_
Definition: CgenState.h:351
float floatval
Definition: sqltypes.h:216
std::vector< llvm::Value * > group_by_expr_cache_
Definition: CgenState.h:368
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:233
llvm::Module * module_
Definition: CgenState.h:350
size_t executor_id_
Definition: CgenState.h:323
llvm::LLVMContext & context_
Definition: CgenState.h:359
llvm::Function * current_func_
Definition: CgenState.h:353
size_t getOrAddLiteral(const Analyzer::Constant *constant, const EncodingType enc_type, const int dict_id, const int device_id)
Definition: CgenState.h:46
std::unordered_map< int, std::vector< llvm::Value * > > fetch_cache_
Definition: CgenState.h:362
static size_t addAligned(const size_t off_in, const size_t alignment)
Definition: CgenState.h:425
llvm::CallInst * filter_func_call_
Definition: CgenState.h:357
llvm::ConstantInt * inlineIntNull(const SQLTypeInfo &)
Definition: CgenState.cpp:64
int64_t bigintval
Definition: sqltypes.h:215
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:315
std::unordered_map< int, size_t > literal_bytes_
Definition: CgenState.h:455
int16_t smallintval
Definition: sqltypes.h:213
std::unordered_map< int, llvm::Value * > scan_idx_to_hash_pos_
Definition: CgenState.h:373
bool needs_error_check_
Definition: CgenState.h:381
llvm::ConstantFP * llFp(const float v) const
Definition: CgenState.h:300
std::vector< std::string > gpuFunctionsToReplace(llvm::Function *fn)
Definition: CgenState.cpp:292
llvm::IRBuilder query_func_entry_ir_builder_
Definition: CgenState.h:385
llvm::BasicBlock * filter_func_bb_
Definition: CgenState.h:355
const SQLTypeInfo & get_type_info() const
Definition: Analyzer.h:81
llvm::Value * emitCall(const std::string &fname, const std::vector< llvm::Value * > &args)
Definition: CgenState.cpp:215
std::string * stringval
Definition: sqltypes.h:220
SQLTypes decimal_to_int_type(const SQLTypeInfo &ti)
Definition: Datum.cpp:493
llvm::Constant * inlineNull(const SQLTypeInfo &)
Definition: CgenState.cpp:114
void set_module_shallow_copy(const std::unique_ptr< llvm::Module > &module, bool always_clone=false)
Definition: CgenState.cpp:368
std::vector< std::unique_ptr< const InValuesBitmap > > in_values_bitmaps_
Definition: CgenState.h:375
Definition: sqltypes.h:52
Definition: sqltypes.h:53
llvm::Function * filter_func_
Definition: CgenState.h:352
std::unordered_map< int, LiteralValues > literals_
Definition: CgenState.h:454
std::vector< llvm::Value * > frag_offsets_
Definition: CgenState.h:370
llvm::Value * is_null
Definition: CgenState.h:35
size_t getLiteralBufferUsage(const int device_id)
Definition: CgenState.h:283
Datum get_constval() const
Definition: Analyzer.h:342
void emitErrorCheck(llvm::Value *condition, llvm::Value *errorCode, std::string label)
Definition: CgenState.cpp:227
Definition: sqltypes.h:41
llvm::ConstantInt * llInt(const T v) const
Definition: CgenState.h:296
#define CHECK(condition)
Definition: Logger.h:223
llvm::ValueToValueMapTy vmap_
Definition: CgenState.h:360
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:45
std::vector< std::unique_ptr< const StringDictionaryTranslationMgr > > str_dict_translation_mgrs_
Definition: CgenState.h:377
llvm::Value * size
Definition: CgenState.h:34
llvm::CallInst * row_func_call_
Definition: CgenState.h:356
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:119
double doubleval
Definition: sqltypes.h:217
llvm::BasicBlock * row_func_bb_
Definition: CgenState.h:354
llvm::ConstantFP * inlineFpNull(const SQLTypeInfo &)
Definition: CgenState.cpp:102