You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@impala.apache.org by ta...@apache.org on 2018/02/21 22:22:09 UTC
[2/6] impala git commit: IMPALA-5801: Clean up codegen GetType()
interface
http://git-wip-us.apache.org/repos/asf/impala/blob/632ee044/be/src/exec/partitioned-hash-join-builder.h
----------------------------------------------------------------------
diff --git a/be/src/exec/partitioned-hash-join-builder.h b/be/src/exec/partitioned-hash-join-builder.h
index 4123b1f..e075beb 100644
--- a/be/src/exec/partitioned-hash-join-builder.h
+++ b/be/src/exec/partitioned-hash-join-builder.h
@@ -270,6 +270,9 @@ class PhjBuilder : public DataSink {
return spillable_buffer_size_ * (num_reserved_buffers - 2) + max_row_buffer_size_ * 2;
}
+ /// Class name in LLVM IR.
+ static const char* LLVM_CLASS_NAME;
+
private:
/// Create and initialize a set of hash partitions for partitioning level 'level'.
/// The previous hash partitions must have been cleared with ClearHashPartitions().
@@ -503,9 +506,6 @@ class PhjBuilder : public DataSink {
/// Jitted Partition::InsertBatch() function pointers. NULL if codegen is disabled.
InsertBatchFn insert_batch_fn_;
InsertBatchFn insert_batch_fn_level0_;
-
- /// Class name in LLVM IR.
- static const char* LLVM_CLASS_NAME;
};
}
http://git-wip-us.apache.org/repos/asf/impala/blob/632ee044/be/src/exec/partitioned-hash-join-node.cc
----------------------------------------------------------------------
diff --git a/be/src/exec/partitioned-hash-join-node.cc b/be/src/exec/partitioned-hash-join-node.cc
index e76a9ba..99e07eb 100644
--- a/be/src/exec/partitioned-hash-join-node.cc
+++ b/be/src/exec/partitioned-hash-join-node.cc
@@ -1295,18 +1295,13 @@ string PartitionedHashJoinNode::NodeDebugString() const {
// }
Status PartitionedHashJoinNode::CodegenCreateOutputRow(
LlvmCodeGen* codegen, llvm::Function** fn) {
- llvm::Type* tuple_row_type = codegen->GetType(TupleRow::LLVM_CLASS_NAME);
- DCHECK(tuple_row_type != NULL);
- llvm::PointerType* tuple_row_ptr_type = llvm::PointerType::get(tuple_row_type, 0);
+ llvm::PointerType* tuple_row_ptr_type = codegen->GetStructPtrType<TupleRow>();
- llvm::Type* this_type = codegen->GetType(BlockingJoinNode::LLVM_CLASS_NAME);
- DCHECK(this_type != NULL);
- llvm::PointerType* this_ptr_type = llvm::PointerType::get(this_type, 0);
+ llvm::PointerType* this_ptr_type = codegen->GetStructPtrType<BlockingJoinNode>();
// TupleRows are really just an array of pointers. Easier to work with them
// this way.
- llvm::PointerType* tuple_row_working_type =
- llvm::PointerType::get(codegen->ptr_type(), 0);
+ llvm::PointerType* tuple_row_working_type = codegen->ptr_ptr_type();
// Construct function signature to match CreateOutputRow()
LlvmCodeGen::FnPrototype prototype(codegen, "CreateOutputRow", codegen->void_type());
@@ -1331,7 +1326,7 @@ Status PartitionedHashJoinNode::CodegenCreateOutputRow(
// Copy probe row
codegen->CodegenMemcpy(&builder, out_row_arg, probe_row_arg, probe_tuple_row_size_);
- llvm::Value* build_row_idx[] = {codegen->GetIntConstant(TYPE_INT, num_probe_tuples)};
+ llvm::Value* build_row_idx[] = {codegen->GetI32Constant(num_probe_tuples)};
llvm::Value* build_row_dst =
builder.CreateInBoundsGEP(out_row_arg, build_row_idx, "build_dst_ptr");
@@ -1354,7 +1349,7 @@ Status PartitionedHashJoinNode::CodegenCreateOutputRow(
builder.SetInsertPoint(build_null_block);
for (int i = 0; i < num_build_tuples; ++i) {
llvm::Value* array_idx[] = {
- codegen->GetIntConstant(TYPE_INT, i + num_probe_tuples)};
+ codegen->GetI32Constant(i + num_probe_tuples)};
llvm::Value* dst =
builder.CreateInBoundsGEP(out_row_arg, array_idx, "dst_tuple_ptr");
builder.CreateStore(codegen->null_ptr_value(), dst);
@@ -1432,8 +1427,7 @@ Status PartitionedHashJoinNode::CodegenProcessProbeBatch(
llvm::Value* prefetch_mode_arg = codegen->GetArgument(process_probe_batch_fn, 1);
DCHECK_GE(prefetch_mode, TPrefetchMode::NONE);
DCHECK_LE(prefetch_mode, TPrefetchMode::HT_BUCKET);
- prefetch_mode_arg->replaceAllUsesWith(
- llvm::ConstantInt::get(llvm::Type::getInt32Ty(codegen->context()), prefetch_mode));
+ prefetch_mode_arg->replaceAllUsesWith(codegen->GetI32Constant(prefetch_mode));
// Codegen HashTable::Equals
llvm::Function* probe_equals_fn;
http://git-wip-us.apache.org/repos/asf/impala/blob/632ee044/be/src/exec/text-converter.cc
----------------------------------------------------------------------
diff --git a/be/src/exec/text-converter.cc b/be/src/exec/text-converter.cc
index ddd0d6e..9e919a3 100644
--- a/be/src/exec/text-converter.cc
+++ b/be/src/exec/text-converter.cc
@@ -133,10 +133,10 @@ Status TextConverter::CodegenWriteSlot(LlvmCodeGen* codegen,
llvm::PointerType* tuple_ptr_type = tuple_type->getPointerTo();
LlvmCodeGen::FnPrototype prototype(
- codegen, "WriteSlot", codegen->GetType(TYPE_BOOLEAN));
+ codegen, "WriteSlot", codegen->bool_type());
prototype.AddArgument(LlvmCodeGen::NamedVariable("tuple_arg", tuple_ptr_type));
prototype.AddArgument(LlvmCodeGen::NamedVariable("data", codegen->ptr_type()));
- prototype.AddArgument(LlvmCodeGen::NamedVariable("len", codegen->GetType(TYPE_INT)));
+ prototype.AddArgument(LlvmCodeGen::NamedVariable("len", codegen->i32_type()));
LlvmBuilder builder(codegen->context());
llvm::Value* args[3];
@@ -161,7 +161,7 @@ Status TextConverter::CodegenWriteSlot(LlvmCodeGen* codegen,
llvm::ArrayRef<llvm::Value*>(
{args[1], args[2], codegen->CastPtrToLlvmPtr(codegen->ptr_type(),
const_cast<char*>(null_col_val)),
- codegen->GetIntConstant(TYPE_INT, len)}));
+ codegen->GetI32Constant(len)}));
}
} else {
// Constant FALSE as branch condition. We rely on later optimization passes
@@ -175,7 +175,7 @@ Status TextConverter::CodegenWriteSlot(LlvmCodeGen* codegen,
builder.SetInsertPoint(check_zero_block);
// If len == 0 and it is not a string col, set slot to NULL
llvm::Value* null_len =
- builder.CreateICmpEQ(args[2], codegen->GetIntConstant(TYPE_INT, 0));
+ builder.CreateICmpEQ(args[2], codegen->GetI32Constant(0));
builder.CreateCondBr(null_len, set_null_block, parse_slot_block);
}
@@ -193,7 +193,7 @@ Status TextConverter::CodegenWriteSlot(LlvmCodeGen* codegen,
DCHECK(slot_desc->type().type != TYPE_CHAR);
if (slot_desc->type().type == TYPE_VARCHAR) {
// determine if we need to truncate the string
- llvm::Value* maxlen = codegen->GetIntConstant(TYPE_INT, slot_desc->type().len);
+ llvm::Value* maxlen = codegen->GetI32Constant(slot_desc->type().len);
llvm::Value* len_lt_maxlen =
builder.CreateICmpSLT(args[2], maxlen, "len_lt_maxlen");
llvm::Value* minlen =
@@ -260,7 +260,7 @@ Status TextConverter::CodegenWriteSlot(LlvmCodeGen* codegen,
llvm::BasicBlock *parse_success_block, *parse_failed_block;
codegen->CreateIfElseBlocks(*fn, "parse_success", "parse_fail",
&parse_success_block, &parse_failed_block);
- LlvmCodeGen::NamedVariable parse_result("parse_result", codegen->GetType(TYPE_INT));
+ LlvmCodeGen::NamedVariable parse_result("parse_result", codegen->i32_type());
llvm::Value* parse_result_ptr = codegen->CreateEntryBlockAlloca(*fn, parse_result);
llvm::CallInst* parse_return;
@@ -269,8 +269,8 @@ Status TextConverter::CodegenWriteSlot(LlvmCodeGen* codegen,
if (slot_desc->type().type == TYPE_DECIMAL) {
// Special case for decimal since it has additional precision/scale parameters
parse_return = builder.CreateCall(parse_fn, {args[1], args[2],
- codegen->GetIntConstant(TYPE_INT, slot_desc->type().precision),
- codegen->GetIntConstant(TYPE_INT, slot_desc->type().scale), parse_result_ptr});
+ codegen->GetI32Constant(slot_desc->type().precision),
+ codegen->GetI32Constant(slot_desc->type().scale), parse_result_ptr});
} else if (slot_desc->type().type == TYPE_TIMESTAMP) {
// If the return value is large (more than 16 bytes in our toolchain) the first
// parameter would be a pointer to value parsed and the return value of callee
@@ -282,7 +282,7 @@ Status TextConverter::CodegenWriteSlot(LlvmCodeGen* codegen,
}
llvm::Value* parse_result_val = builder.CreateLoad(parse_result_ptr, "parse_result");
llvm::Value* failed_value =
- codegen->GetIntConstant(TYPE_INT, StringParser::PARSE_FAILURE);
+ codegen->GetI32Constant(StringParser::PARSE_FAILURE);
// Check for parse error.
llvm::Value* parse_failed =
@@ -290,7 +290,7 @@ Status TextConverter::CodegenWriteSlot(LlvmCodeGen* codegen,
if (strict_mode) {
// In strict_mode, also check if parse_result is PARSE_OVERFLOW.
llvm::Value* overflow_value =
- codegen->GetIntConstant(TYPE_INT, StringParser::PARSE_OVERFLOW);
+ codegen->GetI32Constant(StringParser::PARSE_OVERFLOW);
llvm::Value* parse_overflow =
builder.CreateICmpEQ(parse_result_val, overflow_value, "overflowed");
parse_failed = builder.CreateOr(parse_failed, parse_overflow, "failed_or");
http://git-wip-us.apache.org/repos/asf/impala/blob/632ee044/be/src/exprs/compound-predicates.cc
----------------------------------------------------------------------
diff --git a/be/src/exprs/compound-predicates.cc b/be/src/exprs/compound-predicates.cc
index 4d89cfa..55bc5c6 100644
--- a/be/src/exprs/compound-predicates.cc
+++ b/be/src/exprs/compound-predicates.cc
@@ -213,7 +213,7 @@ Status CompoundPredicate::CodegenComputeFn(
// not-NULL block
builder.SetInsertPoint(not_null_block);
- llvm::PHINode* not_null_phi = builder.CreatePHI(codegen->GetType(TYPE_BOOLEAN), 3);
+ llvm::PHINode* not_null_phi = builder.CreatePHI(codegen->bool_type(), 3);
if (and_fn) {
not_null_phi->addIncoming(codegen->false_value(), lhs_null_rhs_not_null_block);
not_null_phi->addIncoming(codegen->false_value(), lhs_not_null_rhs_null_block);
@@ -227,11 +227,11 @@ Status CompoundPredicate::CodegenComputeFn(
// Ret/merge block
builder.SetInsertPoint(ret_block);
- llvm::PHINode* is_null_phi = builder.CreatePHI(codegen->boolean_type(), 2, "is_null");
+ llvm::PHINode* is_null_phi = builder.CreatePHI(codegen->bool_type(), 2, "is_null");
is_null_phi->addIncoming(codegen->true_value(), null_block);
is_null_phi->addIncoming(codegen->false_value(), not_null_block);
- llvm::PHINode* val_phi = builder.CreatePHI(codegen->boolean_type(), 2, "val");
+ llvm::PHINode* val_phi = builder.CreatePHI(codegen->bool_type(), 2, "val");
val_phi->addIncoming(codegen->false_value(), null_block);
val_phi->addIncoming(not_null_phi, not_null_block);
http://git-wip-us.apache.org/repos/asf/impala/blob/632ee044/be/src/exprs/scalar-expr.cc
----------------------------------------------------------------------
diff --git a/be/src/exprs/scalar-expr.cc b/be/src/exprs/scalar-expr.cc
index 035dad5..42c2867 100644
--- a/be/src/exprs/scalar-expr.cc
+++ b/be/src/exprs/scalar-expr.cc
@@ -367,9 +367,9 @@ llvm::Function* ScalarExpr::CreateIrFunctionPrototype(
LlvmCodeGen::FnPrototype prototype(codegen, name, return_type);
prototype.AddArgument(
LlvmCodeGen::NamedVariable(
- "eval", codegen->GetPtrType(ScalarExprEvaluator::LLVM_CLASS_NAME)));
- prototype.AddArgument(
- LlvmCodeGen::NamedVariable("row", codegen->GetPtrType(TupleRow::LLVM_CLASS_NAME)));
+ "eval", codegen->GetStructPtrType<ScalarExprEvaluator>()));
+ prototype.AddArgument(LlvmCodeGen::NamedVariable(
+ "row", codegen->GetStructPtrType<TupleRow>()));
llvm::Function* function = prototype.GeneratePrototype(NULL, args[0]);
DCHECK(function != NULL);
return function;
@@ -389,8 +389,8 @@ Status ScalarExpr::GetCodegendComputeFnWrapper(
llvm::BasicBlock* entry_block =
llvm::BasicBlock::Create(codegen->context(), "entry", ir_compute_fn_);
LlvmBuilder builder(entry_block);
- llvm::Value* this_ptr =
- codegen->CastPtrToLlvmPtr(codegen->GetPtrType(ScalarExpr::LLVM_CLASS_NAME), this);
+ llvm::Value* this_ptr = codegen->CastPtrToLlvmPtr(
+ codegen->GetStructPtrType<ScalarExpr>(), this);
llvm::Value* compute_fn_args[] = {this_ptr, args[0], args[1]};
llvm::Value* ret = CodegenAnyVal::CreateCall(
codegen, &builder, static_getval_fn, compute_fn_args, "ret");
http://git-wip-us.apache.org/repos/asf/impala/blob/632ee044/be/src/exprs/scalar-fn-call.cc
----------------------------------------------------------------------
diff --git a/be/src/exprs/scalar-fn-call.cc b/be/src/exprs/scalar-fn-call.cc
index ffe8d27..acf6208 100644
--- a/be/src/exprs/scalar-fn-call.cc
+++ b/be/src/exprs/scalar-fn-call.cc
@@ -367,7 +367,7 @@ Status ScalarFnCall::GetCodegendComputeFn(LlvmCodeGen* codegen, llvm::Function**
// Set 'child_fn' to the interpreted function
child_fn = GetStaticGetValWrapper(children_[i]->type(), codegen);
// First argument to interpreted function is children_[i]
- llvm::Type* expr_ptr_type = codegen->GetPtrType(ScalarExpr::LLVM_CLASS_NAME);
+ llvm::Type* expr_ptr_type = codegen->GetStructPtrType<ScalarExpr>();
child_fn_args.push_back(codegen->CastPtrToLlvmPtr(expr_ptr_type, children_[i]));
}
child_fn_args.push_back(eval);
@@ -400,7 +400,7 @@ Status ScalarFnCall::GetCodegendComputeFn(LlvmCodeGen* codegen, llvm::Function**
DCHECK_EQ(udf_args.size(), vararg_start_idx_ + 1);
DCHECK_GE(GetNumChildren(), 1);
// Add the number of varargs
- udf_args.push_back(codegen->GetIntConstant(TYPE_INT, NumVarArgs()));
+ udf_args.push_back(codegen->GetI32Constant(NumVarArgs()));
// Add all the accumulated vararg inputs as one input argument.
llvm::PointerType* vararg_type =
CodegenAnyVal::GetUnloweredPtrType(codegen, VarArgsType());
http://git-wip-us.apache.org/repos/asf/impala/blob/632ee044/be/src/exprs/slot-ref.cc
----------------------------------------------------------------------
diff --git a/be/src/exprs/slot-ref.cc b/be/src/exprs/slot-ref.cc
index d529013..00616b3 100644
--- a/be/src/exprs/slot-ref.cc
+++ b/be/src/exprs/slot-ref.cc
@@ -188,10 +188,10 @@ Status SlotRef::GetCodegendComputeFn(LlvmCodeGen* codegen, llvm::Function** fn)
*fn = CreateIrFunctionPrototype("GetSlotRef", codegen, &args);
llvm::Value* row_ptr = args[1];
- llvm::Value* tuple_offset = llvm::ConstantInt::get(codegen->int_type(), tuple_idx_);
- llvm::Value* slot_offset = llvm::ConstantInt::get(codegen->int_type(), slot_offset_);
- llvm::Value* zero = llvm::ConstantInt::get(codegen->GetType(TYPE_TINYINT), 0);
- llvm::Value* one = llvm::ConstantInt::get(codegen->GetType(TYPE_TINYINT), 1);
+ llvm::Value* tuple_offset = codegen->GetI32Constant(tuple_idx_);
+ llvm::Value* slot_offset = codegen->GetI32Constant(slot_offset_);
+ llvm::Value* zero = codegen->GetI8Constant(0);
+ llvm::Value* one = codegen->GetI8Constant(1);
llvm::BasicBlock* entry_block = llvm::BasicBlock::Create(context, "entry", *fn);
bool slot_is_nullable = null_indicator_offset_.bit_mask != 0;
@@ -206,7 +206,7 @@ Status SlotRef::GetCodegendComputeFn(LlvmCodeGen* codegen, llvm::Function** fn)
LlvmBuilder builder(entry_block);
// Get the tuple offset addr from the row
llvm::Value* cast_row_ptr = builder.CreateBitCast(
- row_ptr, llvm::PointerType::get(codegen->ptr_type(), 0), "cast_row_ptr");
+ row_ptr, codegen->ptr_ptr_type(), "cast_row_ptr");
llvm::Value* tuple_addr =
builder.CreateInBoundsGEP(cast_row_ptr, tuple_offset, "tuple_addr");
// Load the tuple*
@@ -240,8 +240,8 @@ Status SlotRef::GetCodegendComputeFn(LlvmCodeGen* codegen, llvm::Function** fn)
// Branch for slot != NULL
builder.SetInsertPoint(get_slot_block);
llvm::Value* slot_ptr = builder.CreateInBoundsGEP(tuple_ptr, slot_offset, "slot_addr");
- llvm::Value* val_ptr =
- builder.CreateBitCast(slot_ptr, codegen->GetPtrType(type_), "val_ptr");
+ llvm::Value* val_ptr = builder.CreateBitCast(slot_ptr,
+ codegen->GetSlotPtrType(type_), "val_ptr");
// Depending on the type, load the values we need
llvm::Value* val = NULL;
llvm::Value* ptr = NULL;
@@ -256,18 +256,18 @@ Status SlotRef::GetCodegendComputeFn(LlvmCodeGen* codegen, llvm::Function** fn)
} else if (type_.type == TYPE_FIXED_UDA_INTERMEDIATE) {
// ptr and len are the slot and its fixed length.
ptr = builder.CreateBitCast(val_ptr, codegen->ptr_type());
- len = codegen->GetIntConstant(TYPE_INT, type_.len);
+ len = codegen->GetI32Constant(type_.len);
} else if (type_.type == TYPE_TIMESTAMP) {
llvm::Value* time_of_day_ptr =
builder.CreateStructGEP(NULL, val_ptr, 0, "time_of_day_ptr");
// Cast boost::posix_time::time_duration to i64
llvm::Value* time_of_day_cast =
- builder.CreateBitCast(time_of_day_ptr, codegen->GetPtrType(TYPE_BIGINT));
+ builder.CreateBitCast(time_of_day_ptr, codegen->i64_ptr_type());
time_of_day = builder.CreateLoad(time_of_day_cast, "time_of_day");
llvm::Value* date_ptr = builder.CreateStructGEP(NULL, val_ptr, 1, "date_ptr");
// Cast boost::gregorian::date to i32
llvm::Value* date_cast =
- builder.CreateBitCast(date_ptr, codegen->GetPtrType(TYPE_INT));
+ builder.CreateBitCast(date_ptr, codegen->i32_ptr_type());
date = builder.CreateLoad(date_cast, "date");
} else {
// val_ptr is a native type
@@ -278,7 +278,7 @@ Status SlotRef::GetCodegendComputeFn(LlvmCodeGen* codegen, llvm::Function** fn)
// Return block
builder.SetInsertPoint(ret_block);
llvm::PHINode* is_null_phi =
- builder.CreatePHI(codegen->tinyint_type(), 2, "is_null_phi");
+ builder.CreatePHI(codegen->i8_type(), 2, "is_null_phi");
if (tuple_is_nullable_) is_null_phi->addIncoming(one, entry_block);
if (check_slot_null_indicator_block != NULL) {
is_null_phi->addIncoming(one, check_slot_null_indicator_block);
http://git-wip-us.apache.org/repos/asf/impala/blob/632ee044/be/src/runtime/descriptors.cc
----------------------------------------------------------------------
diff --git a/be/src/runtime/descriptors.cc b/be/src/runtime/descriptors.cc
index bd67689..bc983de 100644
--- a/be/src/runtime/descriptors.cc
+++ b/be/src/runtime/descriptors.cc
@@ -76,13 +76,13 @@ string NullIndicatorOffset::DebugString() const {
llvm::Constant* NullIndicatorOffset::ToIR(LlvmCodeGen* codegen) const {
llvm::StructType* null_indicator_offset_type =
- static_cast<llvm::StructType*>(codegen->GetType(LLVM_CLASS_NAME));
+ codegen->GetStructType<NullIndicatorOffset>();
// Populate padding at end of struct with zeroes.
llvm::ConstantAggregateZero* zeroes =
llvm::ConstantAggregateZero::get(null_indicator_offset_type);
return llvm::ConstantStruct::get(null_indicator_offset_type,
- {llvm::ConstantInt::get(codegen->int_type(), byte_offset),
- llvm::ConstantInt::get(codegen->tinyint_type(), bit_mask),
+ {codegen->GetI32Constant(byte_offset),
+ codegen->GetI8Constant(bit_mask),
zeroes->getStructElement(2)});
}
@@ -634,10 +634,9 @@ llvm::Value* SlotDescriptor::CodegenIsNull(LlvmCodeGen* codegen, LlvmBuilder* bu
const NullIndicatorOffset& null_indicator_offset, llvm::Value* tuple) {
llvm::Value* null_byte =
CodegenGetNullByte(codegen, builder, null_indicator_offset, tuple, nullptr);
- llvm::Constant* mask =
- llvm::ConstantInt::get(codegen->tinyint_type(), null_indicator_offset.bit_mask);
+ llvm::Constant* mask = codegen->GetI8Constant(null_indicator_offset.bit_mask);
llvm::Value* null_mask = builder->CreateAnd(null_byte, mask, "null_mask");
- llvm::Constant* zero = llvm::ConstantInt::get(codegen->tinyint_type(), 0);
+ llvm::Constant* zero = codegen->GetI8Constant(0);
return builder->CreateICmpNE(null_mask, zero, "is_null");
}
@@ -653,14 +652,12 @@ llvm::Value* SlotDescriptor::CodegenIsNull(LlvmCodeGen* codegen, LlvmBuilder* bu
void SlotDescriptor::CodegenSetNullIndicator(
LlvmCodeGen* codegen, LlvmBuilder* builder, llvm::Value* tuple, llvm::Value* is_null)
const {
- DCHECK_EQ(is_null->getType(), codegen->boolean_type());
+ DCHECK_EQ(is_null->getType(), codegen->bool_type());
llvm::Value* null_byte_ptr;
llvm::Value* null_byte =
CodegenGetNullByte(codegen, builder, null_indicator_offset_, tuple, &null_byte_ptr);
- llvm::Constant* mask =
- llvm::ConstantInt::get(codegen->tinyint_type(), null_indicator_offset_.bit_mask);
- llvm::Constant* not_mask =
- llvm::ConstantInt::get(codegen->tinyint_type(), ~null_indicator_offset_.bit_mask);
+ llvm::Constant* mask = codegen->GetI8Constant(null_indicator_offset_.bit_mask);
+ llvm::Constant* not_mask = codegen->GetI8Constant(~null_indicator_offset_.bit_mask);
llvm::ConstantInt* constant_is_null = llvm::dyn_cast<llvm::ConstantInt>(is_null);
llvm::Value* result = nullptr;
@@ -677,7 +674,7 @@ void SlotDescriptor::CodegenSetNullIndicator(
llvm::Value* byte_with_cleared_bit =
builder->CreateAnd(null_byte, not_mask, "null_bit_cleared");
llvm::Value* sign_extended_null =
- builder->CreateSExt(is_null, codegen->tinyint_type());
+ builder->CreateSExt(is_null, codegen->i8_type());
llvm::Value* bit_only = builder->CreateAnd(sign_extended_null, mask, "null_bit");
result = builder->CreateOr(byte_with_cleared_bit, bit_only, "null_bit_set");
}
@@ -690,7 +687,7 @@ llvm::Value* SlotDescriptor::CodegenGetNullByte(
const NullIndicatorOffset& null_indicator_offset, llvm::Value* tuple,
llvm::Value** null_byte_ptr) {
llvm::Constant* byte_offset =
- llvm::ConstantInt::get(codegen->int_type(), null_indicator_offset.byte_offset);
+ codegen->GetI32Constant(null_indicator_offset.byte_offset);
llvm::Value* tuple_bytes = builder->CreateBitCast(tuple, codegen->ptr_type());
llvm::Value* byte_ptr =
builder->CreateInBoundsGEP(tuple_bytes, byte_offset, "null_byte_ptr");
@@ -716,18 +713,18 @@ llvm::StructType* TupleDescriptor::GetLlvmStruct(LlvmCodeGen* codegen) const {
if (slot->type().type == TYPE_CHAR) return nullptr;
DCHECK_EQ(curr_struct_offset, slot->tuple_offset());
slot->llvm_field_idx_ = struct_fields.size();
- struct_fields.push_back(codegen->GetType(slot->type()));
+ struct_fields.push_back(codegen->GetSlotType(slot->type()));
curr_struct_offset = slot->tuple_offset() + slot->slot_size();
}
// For each null byte, add a byte to the struct
for (int i = 0; i < num_null_bytes_; ++i) {
- struct_fields.push_back(codegen->GetType(TYPE_TINYINT));
+ struct_fields.push_back(codegen->i8_type());
++curr_struct_offset;
}
DCHECK_LE(curr_struct_offset, byte_size_);
if (curr_struct_offset < byte_size_) {
- struct_fields.push_back(llvm::ArrayType::get(codegen->GetType(TYPE_TINYINT),
+ struct_fields.push_back(llvm::ArrayType::get(codegen->i8_type(),
byte_size_ - curr_struct_offset));
}
http://git-wip-us.apache.org/repos/asf/impala/blob/632ee044/be/src/runtime/tuple.cc
----------------------------------------------------------------------
diff --git a/be/src/runtime/tuple.cc b/be/src/runtime/tuple.cc
index 787c3a4..627c7a4 100644
--- a/be/src/runtime/tuple.cc
+++ b/be/src/runtime/tuple.cc
@@ -330,15 +330,14 @@ Status Tuple::CodegenMaterializeExprs(LlvmCodeGen* codegen, bool collect_string_
// void MaterializeExprs(Tuple* tuple, TupleRow* row, TupleDescriptor* desc,
// ScalarExprEvaluator** slot_materialize_exprs, MemPool* pool,
// StringValue** non_null_string_values, int* total_string_lengths)
- llvm::PointerType* opaque_tuple_type = codegen->GetPtrType(Tuple::LLVM_CLASS_NAME);
- llvm::PointerType* row_type = codegen->GetPtrType(TupleRow::LLVM_CLASS_NAME);
- llvm::PointerType* desc_type = codegen->GetPtrType(TupleDescriptor::LLVM_CLASS_NAME);
+ llvm::PointerType* opaque_tuple_type = codegen->GetStructPtrType<Tuple>();
+ llvm::PointerType* row_type = codegen->GetStructPtrType<TupleRow>();
+ llvm::PointerType* desc_type = codegen->GetStructPtrType<TupleDescriptor>();
llvm::PointerType* expr_evals_type =
- codegen->GetPtrType(codegen->GetPtrType(ScalarExprEvaluator::LLVM_CLASS_NAME));
- llvm::PointerType* pool_type = codegen->GetPtrType(MemPool::LLVM_CLASS_NAME);
- llvm::PointerType* string_values_type =
- codegen->GetPtrType(codegen->GetPtrType(StringValue::LLVM_CLASS_NAME));
- llvm::PointerType* int_ptr_type = codegen->GetPtrType(TYPE_INT);
+ codegen->GetStructPtrPtrType<ScalarExprEvaluator>();
+ llvm::PointerType* pool_type = codegen->GetStructPtrType<MemPool>();
+ llvm::PointerType* string_values_type = codegen->GetStructPtrPtrType<StringValue>();
+ llvm::PointerType* int_ptr_type = codegen->i32_ptr_type();
LlvmCodeGen::FnPrototype prototype(codegen, "MaterializeExprs", codegen->void_type());
prototype.AddArgument("opaque_tuple", opaque_tuple_type);
prototype.AddArgument("row", row_type);
@@ -401,20 +400,18 @@ Status Tuple::CodegenMaterializeExprs(LlvmCodeGen* codegen, bool collect_string_
Status Tuple::CodegenCopyStrings(
LlvmCodeGen* codegen, const TupleDescriptor& desc, llvm::Function** copy_strings_fn) {
- llvm::PointerType* opaque_tuple_type = codegen->GetPtrType(Tuple::LLVM_CLASS_NAME);
- llvm::PointerType* runtime_state_type =
- codegen->GetPtrType(RuntimeState::LLVM_CLASS_NAME);
- llvm::StructType* slot_offsets_type =
- static_cast<llvm::StructType*>(codegen->GetType(SlotOffsets::LLVM_CLASS_NAME));
- llvm::PointerType* pool_type = codegen->GetPtrType(MemPool::LLVM_CLASS_NAME);
- llvm::PointerType* status_type = codegen->GetPtrType(Status::LLVM_CLASS_NAME);
+ llvm::PointerType* opaque_tuple_type = codegen->GetStructPtrType<Tuple>();
+ llvm::PointerType* runtime_state_type = codegen->GetStructPtrType<RuntimeState>();
+ llvm::StructType* slot_offsets_type = codegen->GetStructType<SlotOffsets>();
+ llvm::PointerType* pool_type = codegen->GetStructPtrType<MemPool>();
+ llvm::PointerType* status_type = codegen->GetStructPtrType<Status>();
LlvmCodeGen::FnPrototype prototype(
- codegen, "CopyStringsWrapper", codegen->boolean_type());
+ codegen, "CopyStringsWrapper", codegen->bool_type());
prototype.AddArgument("opaque_tuple", opaque_tuple_type);
prototype.AddArgument("err_ctx", codegen->ptr_type());
prototype.AddArgument("state", runtime_state_type);
prototype.AddArgument("slot_offsets", codegen->GetPtrType(slot_offsets_type));
- prototype.AddArgument("num_string_slots", codegen->int_type());
+ prototype.AddArgument("num_string_slots", codegen->i32_type());
prototype.AddArgument("pool", pool_type);
prototype.AddArgument("status", status_type);
@@ -440,8 +437,7 @@ Status Tuple::CodegenCopyStrings(
}
llvm::Constant* constant_slot_offsets = codegen->ConstantsToGVArrayPtr(
slot_offsets_type, slot_offset_ir_constants, "slot_offsets");
- llvm::Constant* num_string_slots =
- llvm::ConstantInt::get(codegen->int_type(), desc.string_slots().size());
+ llvm::Constant* num_string_slots = codegen->GetI32Constant(desc.string_slots().size());
// Get SlotOffsets* pointer to the first element of the constant array.
llvm::Value* constant_slot_offsets_first_element_ptr =
builder.CreateConstGEP2_64(constant_slot_offsets, 0, 0);
@@ -460,9 +456,9 @@ Status Tuple::CodegenCopyStrings(
llvm::Constant* SlotOffsets::ToIR(LlvmCodeGen* codegen) const {
return llvm::ConstantStruct::get(
- static_cast<llvm::StructType*>(codegen->GetType(LLVM_CLASS_NAME)),
+ codegen->GetStructType<SlotOffsets>(),
{null_indicator_offset.ToIR(codegen),
- llvm::ConstantInt::get(codegen->int_type(), tuple_offset)});
+ codegen->GetI32Constant(tuple_offset)});
}
template void Tuple::MaterializeExprs<false, false>(TupleRow*, const TupleDescriptor&,
http://git-wip-us.apache.org/repos/asf/impala/blob/632ee044/be/src/runtime/types.cc
----------------------------------------------------------------------
diff --git a/be/src/runtime/types.cc b/be/src/runtime/types.cc
index d2b215f..c18c66e 100644
--- a/be/src/runtime/types.cc
+++ b/be/src/runtime/types.cc
@@ -345,18 +345,16 @@ ostream& operator<<(ostream& os, const ColumnType& type) {
llvm::ConstantStruct* ColumnType::ToIR(LlvmCodeGen* codegen) const {
// ColumnType = { i32, i32, i32, i32, <vector>, <vector> }
- llvm::StructType* column_type_type =
- llvm::cast<llvm::StructType>(codegen->GetType(LLVM_CLASS_NAME));
+ llvm::StructType* column_type_type = codegen->GetStructType<ColumnType>();
DCHECK_EQ(sizeof(type), sizeof(int32_t));
- llvm::Constant* type_field = llvm::ConstantInt::get(codegen->int_type(), type);
+ llvm::Constant* type_field = codegen->GetI32Constant(type);
DCHECK_EQ(sizeof(len), sizeof(int32_t));
- llvm::Constant* len_field = llvm::ConstantInt::get(codegen->int_type(), len);
+ llvm::Constant* len_field = codegen->GetI32Constant(len);
DCHECK_EQ(sizeof(precision), sizeof(int32_t));
- llvm::Constant* precision_field =
- llvm::ConstantInt::get(codegen->int_type(), precision);
+ llvm::Constant* precision_field = codegen->GetI32Constant(precision);
DCHECK_EQ(sizeof(scale), sizeof(int32_t));
- llvm::Constant* scale_field = llvm::ConstantInt::get(codegen->int_type(), scale);
+ llvm::Constant* scale_field = codegen->GetI32Constant(scale);
// Create empty 'children' and 'field_names' vectors
DCHECK(children.empty()) << "Nested types NYI";
http://git-wip-us.apache.org/repos/asf/impala/blob/632ee044/be/src/util/tuple-row-compare.cc
----------------------------------------------------------------------
diff --git a/be/src/util/tuple-row-compare.cc b/be/src/util/tuple-row-compare.cc
index ad92e84..5620dae 100644
--- a/be/src/util/tuple-row-compare.cc
+++ b/be/src/util/tuple-row-compare.cc
@@ -221,9 +221,9 @@ Status TupleRowComparator::CodegenCompare(LlvmCodeGen* codegen, llvm::Function**
// ScalarExprEvaluator** ordering_expr_evals_rhs,
// TupleRow* lhs, TupleRow* rhs)
llvm::PointerType* expr_evals_type =
- codegen->GetPtrPtrType(ScalarExprEvaluator::LLVM_CLASS_NAME);
- llvm::PointerType* tuple_row_type = codegen->GetPtrType(TupleRow::LLVM_CLASS_NAME);
- LlvmCodeGen::FnPrototype prototype(codegen, "Compare", codegen->int_type());
+ codegen->GetStructPtrPtrType<ScalarExprEvaluator>();
+ llvm::PointerType* tuple_row_type = codegen->GetStructPtrType<TupleRow>();
+ LlvmCodeGen::FnPrototype prototype(codegen, "Compare", codegen->i32_type());
prototype.AddArgument("ordering_expr_evals_lhs", expr_evals_type);
prototype.AddArgument("ordering_expr_evals_rhs", expr_evals_type);
prototype.AddArgument("lhs", tuple_row_type);