This is an automated email from the ASF dual-hosted git repository.
kparzysz pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tvm.git
The following commit(s) were added to refs/heads/main by this push:
new 79e64ad8e0 [LLVM] Remove `using llvm::BasicBlock`, NFC (#11850)
79e64ad8e0 is described below
commit 79e64ad8e004884d6332061339194022ced2430d
Author: Krzysztof Parzyszek <[email protected]>
AuthorDate: Thu Jun 23 11:11:50 2022 -0500
[LLVM] Remove `using llvm::BasicBlock`, NFC (#11850)
There are a few places in CodeGenLLVM and CodeGenCPU that have this
directive. There is no other `using` directive for any other LLVM
type anywhere. Remove it for consistency with the rest of the code.
---
src/target/llvm/codegen_cpu.cc | 34 ++++++++++++++--------------------
src/target/llvm/codegen_llvm.cc | 34 +++++++++++++++-------------------
2 files changed, 29 insertions(+), 39 deletions(-)
diff --git a/src/target/llvm/codegen_cpu.cc b/src/target/llvm/codegen_cpu.cc
index 3762514c1e..b7b40f155e 100644
--- a/src/target/llvm/codegen_cpu.cc
+++ b/src/target/llvm/codegen_cpu.cc
@@ -479,10 +479,9 @@ void CodeGenCPU::InitGlobalContext(bool dynamic_lookup) {
llvm::BasicBlock* CodeGenCPU::CheckCallSuccess(llvm::Value* retcode) {
// create emit codes that checks and load the function.
- using llvm::BasicBlock;
- BasicBlock* fail_block = BasicBlock::Create(*ctx_, "call_fail", function_);
- BasicBlock* end_block = BasicBlock::Create(*ctx_, "call_end", function_);
- llvm::Value* succ = builder_->CreateICmpEQ(retcode,
llvm::ConstantInt::get(t_int_, 0));
+ auto* fail_block = llvm::BasicBlock::Create(*ctx_, "call_fail", function_);
+ auto* end_block = llvm::BasicBlock::Create(*ctx_, "call_end", function_);
+ auto* succ = builder_->CreateICmpEQ(retcode, llvm::ConstantInt::get(t_int_,
0));
builder_->CreateCondBr(succ, end_block, fail_block, md_very_likely_branch_);
builder_->SetInsertPoint(fail_block);
// return the code.
@@ -519,7 +518,6 @@ void CodeGenCPU::CreateComputeScope(const AttrStmtNode* op)
{
// - Make sure the generated compute function is clearly separately(though
it can get inlined)
// - Set noalias on all the pointer arguments, some of them are loaded from
TVMArgs.
// This is easier than set the alias scope manually.
- using llvm::BasicBlock;
Array<Var> vargs = tir::UndefinedVars(op->body, {});
std::vector<llvm::Value*> arg_values;
std::vector<llvm::Type*> arg_types;
@@ -539,7 +537,7 @@ void CodeGenCPU::CreateComputeScope(const AttrStmtNode* op)
{
MakeStringRef(value->value), module_.get());
SetTargetAttributes(fcompute);
- BasicBlock* compute_call_end =
CheckCallSuccess(builder_->CreateCall(fcompute, arg_values));
+ llvm::BasicBlock* compute_call_end =
CheckCallSuccess(builder_->CreateCall(fcompute, arg_values));
// enter compute scope and setup compute function.
With<ComputeScopeStates> scope_states_guard(this);
size_t idx = 0;
@@ -571,7 +569,7 @@ void CodeGenCPU::CreateComputeScope(const AttrStmtNode* op)
{
}
function_ = fcompute;
- BasicBlock* compute_entry = BasicBlock::Create(*ctx_, "entry", function_);
+ auto* compute_entry = llvm::BasicBlock::Create(*ctx_, "entry", function_);
builder_->SetInsertPoint(compute_entry);
this->VisitStmt(op->body);
builder_->CreateRet(ConstInt32(0));
@@ -616,7 +614,6 @@ void CodeGenCPU::UnpackClosureData(TypedPointer cdata,
const Array<Var>& vfields
}
void CodeGenCPU::CreateParallelLaunch(const Stmt& body, int num_task,
std::string name) {
- using llvm::BasicBlock;
// closure data
llvm::Function* f =
llvm::Function::Create(ftype_tvm_parallel_lambda_,
llvm::Function::PrivateLinkage,
@@ -632,11 +629,11 @@ void CodeGenCPU::CreateParallelLaunch(const Stmt& body,
int num_task, std::strin
#else
auto launch_callee = RuntimeTVMParallelLaunch();
#endif
- BasicBlock* par_launch_end = CheckCallSuccess(builder_->CreateCall(
+ llvm::BasicBlock* par_launch_end = CheckCallSuccess(builder_->CreateCall(
launch_callee,
{f, builder_->CreatePointerCast(cdata.addr, t_void_p_),
ConstInt32(num_task)}));
// Setup the closure function.
- BasicBlock* lambda_entry = BasicBlock::Create(*ctx_,
"parallel_closure_entry", f);
+ auto* lambda_entry = llvm::BasicBlock::Create(*ctx_,
"parallel_closure_entry", f);
builder_->SetInsertPoint(lambda_entry);
auto it = f->arg_begin();
llvm::Value* task_id = &(*it++);
@@ -686,7 +683,6 @@ llvm::Value* CodeGenCPU::CreateStaticHandle() {
}
void CodeGenCPU::CreateStaticInit(const std::string& init_fname, const Stmt&
body) {
- using llvm::BasicBlock;
// closure data
llvm::Function* f =
llvm::Function::Create(ftype_tvm_static_init_callback_,
llvm::Function::PrivateLinkage,
@@ -702,10 +698,10 @@ void CodeGenCPU::CreateStaticInit(const std::string&
init_fname, const Stmt& bod
uint64_t nbytes;
Array<Var> vfields = tir::UndefinedVars(body, {});
TypedPointer cdata = PackClosureData(vfields, &nbytes);
- BasicBlock* init_end = CheckCallSuccess(builder_->CreateCall(
+ llvm::BasicBlock* init_end = CheckCallSuccess(builder_->CreateCall(
finit, {gv, f, builder_->CreatePointerCast(cdata.addr, t_void_p_),
ConstInt32(nbytes)}));
// Setup the closure function.
- BasicBlock* lambda_entry = BasicBlock::Create(*ctx_, "entry", f);
+ auto* lambda_entry = llvm::BasicBlock::Create(*ctx_, "entry", f);
builder_->SetInsertPoint(lambda_entry);
auto it = f->arg_begin();
cdata.addr = builder_->CreatePointerCast(&(*it++), cdata.addr->getType());
@@ -727,7 +723,6 @@ void CodeGenCPU::CreateStaticInit(const std::string&
init_fname, const Stmt& bod
}
llvm::Value* CodeGenCPU::GetPackedFuncHandle(const std::string& fname) {
- using llvm::BasicBlock;
// We will store the packed function handle in global space.
// Initialize it during the first call.
llvm::DataLayout layout(module_.get());
@@ -752,9 +747,9 @@ llvm::Value* CodeGenCPU::GetPackedFuncHandle(const
std::string& fname) {
hptr = it->second;
}
// create emit codes that checks and load the function.
- BasicBlock* pre_block = builder_->GetInsertBlock();
- BasicBlock* init_block = BasicBlock::Create(*ctx_, "handle_init", function_);
- BasicBlock* end_block = BasicBlock::Create(*ctx_, "handle_init_end",
function_);
+ llvm::BasicBlock* pre_block = builder_->GetInsertBlock();
+ auto* init_block = llvm::BasicBlock::Create(*ctx_, "handle_init", function_);
+ auto* end_block = llvm::BasicBlock::Create(*ctx_, "handle_init_end",
function_);
#if TVM_LLVM_VERSION >= 110
llvm::Value* handle = builder_->CreateAlignedLoad(hptr->getValueType(),
hptr, llvm::Align(align));
#elif TVM_LLVM_VERSION >= 80
@@ -1395,7 +1390,6 @@ llvm::Value* CodeGenCPU::CreateIntrinsic(const CallNode*
op) {
}
void CodeGenCPU::VisitStmt_(const AssertStmtNode* op) {
- using llvm::BasicBlock;
llvm::Value* cond = MakeValue(op->condition);
std::ostringstream os;
os << "Assert fail: " << op->condition;
@@ -1403,8 +1397,8 @@ void CodeGenCPU::VisitStmt_(const AssertStmtNode* op) {
os << ", " << op->message.as<StringImmNode>()->value;
}
llvm::Value* msg = GetConstString(os.str());
- BasicBlock* fail_block = BasicBlock::Create(*ctx_, "assert_fail", function_);
- BasicBlock* end_block = BasicBlock::Create(*ctx_, "assert_end", function_);
+ auto* fail_block = llvm::BasicBlock::Create(*ctx_, "assert_fail", function_);
+ auto* end_block = llvm::BasicBlock::Create(*ctx_, "assert_end", function_);
builder_->CreateCondBr(cond, end_block, fail_block, md_very_likely_branch_);
// fail condition.
builder_->SetInsertPoint(fail_block);
diff --git a/src/target/llvm/codegen_llvm.cc b/src/target/llvm/codegen_llvm.cc
index cf19d391cc..f56c6765a6 100644
--- a/src/target/llvm/codegen_llvm.cc
+++ b/src/target/llvm/codegen_llvm.cc
@@ -633,12 +633,11 @@ llvm::Value*
CodeGenLLVM::CreateVecConcat(std::vector<llvm::Value*> vecs) {
void CodeGenLLVM::CreateSerialFor(llvm::Value* begin, llvm::Value* end,
llvm::Value* stride,
const Var& loop_var, const Stmt& body) {
- using llvm::BasicBlock;
- BasicBlock* pre_block = builder_->GetInsertBlock();
+ llvm::BasicBlock* pre_block = builder_->GetInsertBlock();
std::string loop_var_name = loop_var->name_hint;
- BasicBlock* for_begin = BasicBlock::Create(*ctx_, "for_begin_" +
loop_var_name, function_);
- BasicBlock* for_body = BasicBlock::Create(*ctx_, "for_body_" +
loop_var_name, function_);
- BasicBlock* for_end = BasicBlock::Create(*ctx_, "for_end_" + loop_var_name,
function_);
+ auto* for_begin = llvm::BasicBlock::Create(*ctx_, "for_begin_" +
loop_var_name, function_);
+ auto* for_body = llvm::BasicBlock::Create(*ctx_, "for_body_" +
loop_var_name, function_);
+ auto* for_end = llvm::BasicBlock::Create(*ctx_, "for_end_" + loop_var_name,
function_);
builder_->CreateBr(for_begin);
builder_->SetInsertPoint(for_begin);
llvm::PHINode* loop_value = builder_->CreatePHI(begin->getType(), 2);
@@ -973,18 +972,17 @@ llvm::Value* CodeGenLLVM::CreateIntrinsic(const CallNode*
op) {
return llvm::ConstantInt::get(DTypeToLLVMType(op->dtype), val);
} else if (op->op.same_as(builtin::if_then_else())) {
ICHECK_EQ(op->args[0].dtype().lanes(), 1) << "if_then_else can only take
scalar condition";
- using llvm::BasicBlock;
- BasicBlock* then_block = BasicBlock::Create(*ctx_, "if_then", function_);
- BasicBlock* else_block = BasicBlock::Create(*ctx_, "if_else", function_);
- BasicBlock* end_block = BasicBlock::Create(*ctx_, "if_end", function_);
+ auto* then_block = llvm::BasicBlock::Create(*ctx_, "if_then", function_);
+ auto* else_block = llvm::BasicBlock::Create(*ctx_, "if_else", function_);
+ auto* end_block = llvm::BasicBlock::Create(*ctx_, "if_end", function_);
builder_->CreateCondBr(MakeValue(op->args[0]), then_block, else_block);
builder_->SetInsertPoint(then_block);
llvm::Value* then_value = MakeValue(op->args[1]);
- BasicBlock* then_value_block = builder_->GetInsertBlock();
+ llvm::BasicBlock* then_value_block = builder_->GetInsertBlock();
builder_->CreateBr(end_block);
builder_->SetInsertPoint(else_block);
llvm::Value* else_value = MakeValue(op->args[2]);
- BasicBlock* else_value_block = builder_->GetInsertBlock();
+ llvm::BasicBlock* else_value_block = builder_->GetInsertBlock();
builder_->CreateBr(end_block);
builder_->SetInsertPoint(end_block);
llvm::PHINode* value = builder_->CreatePHI(then_value->getType(), 2);
@@ -1454,10 +1452,9 @@ void CodeGenLLVM::VisitStmt_(const ForNode* op) {
}
void CodeGenLLVM::VisitStmt_(const WhileNode* op) {
- using llvm::BasicBlock;
- BasicBlock* while_cond = BasicBlock::Create(*ctx_, "while_cond", function_);
- BasicBlock* while_body = BasicBlock::Create(*ctx_, "while_body", function_);
- BasicBlock* while_merge = BasicBlock::Create(*ctx_, "while_merge",
function_);
+ auto* while_cond = llvm::BasicBlock::Create(*ctx_, "while_cond", function_);
+ auto* while_body = llvm::BasicBlock::Create(*ctx_, "while_body", function_);
+ auto* while_merge = llvm::BasicBlock::Create(*ctx_, "while_merge",
function_);
builder_->CreateBr(while_cond);
builder_->SetInsertPoint(while_cond);
builder_->CreateCondBr(MakeValue(op->condition), while_body, while_merge);
@@ -1468,12 +1465,11 @@ void CodeGenLLVM::VisitStmt_(const WhileNode* op) {
}
void CodeGenLLVM::VisitStmt_(const IfThenElseNode* op) {
- using llvm::BasicBlock;
llvm::Value* cond = MakeValue(op->condition);
- BasicBlock* then_block = BasicBlock::Create(*ctx_, "if_then", function_);
- BasicBlock* end_block = BasicBlock::Create(*ctx_, "if_end", function_);
+ auto* then_block = llvm::BasicBlock::Create(*ctx_, "if_then", function_);
+ auto* end_block = llvm::BasicBlock::Create(*ctx_, "if_end", function_);
if (op->else_case.defined()) {
- BasicBlock* else_block = BasicBlock::Create(*ctx_, "if_else", function_);
+ auto* else_block = llvm::BasicBlock::Create(*ctx_, "if_else", function_);
builder_->CreateCondBr(cond, then_block, else_block);
builder_->SetInsertPoint(then_block);
this->VisitStmt(op->then_case);
