This is an automated email from the ASF dual-hosted git repository.
tlopex 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 ff29817d57 [LLVM] Bump minimum LLVM version to 15 (#18853)
ff29817d57 is described below
commit ff29817d5715d7953053732b5c24d5a3e7e5af60
Author: Tianqi Chen <[email protected]>
AuthorDate: Sat Feb 28 10:50:30 2026 -0500
[LLVM] Bump minimum LLVM version to 15 (#18853)
## Summary
Bump the minimum required LLVM version from 6.0 to 15.0, removing all
compatibility code for older LLVM versions.
- Update CMake minimum version checks in `FindLLVM.cmake` and
`LLVM.cmake`
- Remove ~90 dead `#if TVM_LLVM_VERSION` preprocessor branches across 15
source files
- Update documentation references in `from_source.rst` and
`config.cmake`
- 531 lines of dead code removed, no behavioral changes
All changes are strictly dead-code removal — no live code paths were
modified.
## Test plan
- [x] Build with LLVM 15 (`-DUSE_LLVM=ON`): passed
- [x] `test_target_codegen_llvm.py`: 40/40 passed
- [x] `pre-commit run --all-files`: passed
---
cmake/config.cmake | 2 +-
cmake/modules/LLVM.cmake | 4 +-
cmake/utils/FindLLVM.cmake | 4 +-
docs/install/from_source.rst | 2 +-
src/target/llvm/codegen_aarch64.cc | 2 -
src/target/llvm/codegen_amdgpu.cc | 57 +-------
src/target/llvm/codegen_arm.cc | 6 +-
src/target/llvm/codegen_blob.cc | 21 +--
src/target/llvm/codegen_cpu.cc | 90 +------------
src/target/llvm/codegen_hexagon.cc | 31 +----
src/target/llvm/codegen_llvm.cc | 143 +--------------------
src/target/llvm/codegen_llvm.h | 23 +---
src/target/llvm/codegen_nvptx.cc | 38 +-----
src/target/llvm/codegen_x86_64.cc | 24 +---
src/target/llvm/llvm_instance.cc | 42 ------
src/target/llvm/llvm_instance.h | 16 ---
src/target/llvm/llvm_module.cc | 50 +------
.../cpp/target/canonicalizer/arm_aprofile_test.cc | 2 -
tests/cpp/tir_scalable_datatype.cc | 2 -
19 files changed, 26 insertions(+), 533 deletions(-)
diff --git a/cmake/config.cmake b/cmake/config.cmake
index 03067fa83a..856754c3ec 100644
--- a/cmake/config.cmake
+++ b/cmake/config.cmake
@@ -122,7 +122,7 @@ set(USE_CPP_RTVM OFF)
set(USE_IOS_RPC OFF)
# Whether build with LLVM support
-# Requires LLVM version >= 4.0
+# Requires LLVM version >= 15
#
# Possible values:
# - ON: enable llvm with CMake's find search
diff --git a/cmake/modules/LLVM.cmake b/cmake/modules/LLVM.cmake
index fa1cbf6d1a..59b92fa35b 100644
--- a/cmake/modules/LLVM.cmake
+++ b/cmake/modules/LLVM.cmake
@@ -29,8 +29,8 @@ add_definitions(-DNDEBUG=1)
# It may be a boolean or a string
if(NOT ${USE_LLVM} MATCHES ${IS_FALSE_PATTERN})
find_llvm(${USE_LLVM})
- if (${TVM_LLVM_VERSION} LESS 60)
- message(FATAL_ERROR "LLVM version 6.0 or greater is required.")
+ if (${TVM_LLVM_VERSION} LESS 150)
+ message(FATAL_ERROR "LLVM version 15.0 or greater is required.")
endif()
include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
add_definitions(${LLVM_DEFINITIONS})
diff --git a/cmake/utils/FindLLVM.cmake b/cmake/utils/FindLLVM.cmake
index 09f4dcca7f..d35feef687 100644
--- a/cmake/utils/FindLLVM.cmake
+++ b/cmake/utils/FindLLVM.cmake
@@ -233,8 +233,8 @@ macro(find_llvm use_llvm)
message(STATUS "Found LLVM_DEFINITIONS=" "${LLVM_DEFINITIONS}")
message(STATUS "Found LLVM_LIBS=" "${LLVM_LIBS}")
message(STATUS "Found TVM_LLVM_VERSION=" ${TVM_LLVM_VERSION})
- if (${TVM_LLVM_VERSION} LESS 40)
- message(FATAL_ERROR "TVM requires LLVM 4.0 or higher.")
+ if (${TVM_LLVM_VERSION} LESS 150)
+ message(FATAL_ERROR "TVM requires LLVM 15.0 or higher.")
endif()
message(STATUS "Found TVM_LLVM_HAS_AARCH64_TARGET="
${TVM_LLVM_HAS_AARCH64_TARGET})
endmacro(find_llvm)
diff --git a/docs/install/from_source.rst b/docs/install/from_source.rst
index a016f5ab19..fd423fa7a1 100644
--- a/docs/install/from_source.rst
+++ b/docs/install/from_source.rst
@@ -320,7 +320,7 @@ Currently, ROCm is supported only on linux, so all the
instructions are written
- Set ``set(USE_ROCM ON)``, set ROCM_PATH to the correct path.
- You need to first install HIP runtime from ROCm. Make sure the installation
system has ROCm installed in it.
-- Install latest stable version of LLVM (v6.0.1), and LLD, make sure
``ld.lld`` is available via command line.
+- Install LLVM (>= 15), and LLD, make sure ``ld.lld`` is available via command
line.
.. _install-from-source-cpp-tests:
diff --git a/src/target/llvm/codegen_aarch64.cc
b/src/target/llvm/codegen_aarch64.cc
index 22e7d873b6..ced6d8dc2d 100644
--- a/src/target/llvm/codegen_aarch64.cc
+++ b/src/target/llvm/codegen_aarch64.cc
@@ -55,7 +55,6 @@ void CodeGenAArch64::AddFunction(const GlobalVar& gvar, const
PrimFunc& f) {
}
void CodeGenAArch64::SetTargetAttributes(llvm::Function* func) {
-#if TVM_LLVM_VERSION >= 130
// Add vscale_range() function attribute when appropriate.
if (llvm_target_->TargetHasCPUFeature("sve") ||
llvm_target_->TargetHasCPUFeature("sme")) {
auto kVScaleValues = arith::GetVScaleValues(Target::Current());
@@ -65,7 +64,6 @@ void CodeGenAArch64::SetTargetAttributes(llvm::Function*
func) {
llvm::Attribute::getWithVScaleRangeArgs(*llvm_target_->GetContext(),
1, max_val));
}
}
-#endif
CodeGenCPU::SetTargetAttributes(func);
}
diff --git a/src/target/llvm/codegen_amdgpu.cc
b/src/target/llvm/codegen_amdgpu.cc
index ac250982ce..43262f57e3 100644
--- a/src/target/llvm/codegen_amdgpu.cc
+++ b/src/target/llvm/codegen_amdgpu.cc
@@ -30,19 +30,15 @@
#include <llvm/IR/GlobalValue.h>
#include <llvm/IR/Instructions.h>
#include <llvm/IR/Intrinsics.h>
-#include <tvm/ffi/reflection/registry.h>
-#if TVM_LLVM_VERSION >= 100
#include <llvm/IR/IntrinsicsAMDGPU.h>
-#endif
#include <llvm/IR/LegacyPassManager.h>
#include <llvm/IRReader/IRReader.h>
-#if TVM_LLVM_VERSION >= 100
#include <llvm/Support/Alignment.h>
-#endif
#include <llvm/Support/CodeGen.h>
#include <llvm/Support/SourceMgr.h>
#include <llvm/Support/raw_ostream.h>
#include <llvm/Target/TargetMachine.h>
+#include <tvm/ffi/reflection/registry.h>
#if TVM_LLVM_VERSION < 170
#include <llvm/Transforms/IPO/PassManagerBuilder.h>
#endif
@@ -126,17 +122,9 @@ class CodeGenAMDGPU : public CodeGenLLVM {
llvm::AllocaInst* alloca = WithFunctionEntry([&]() {
return builder_->CreateAlloca(DTypeToLLVMType(op->dtype),
ConstInt32(constant_size));
});
-#if TVM_LLVM_VERSION >= 110
auto alignment = static_cast<unsigned>(alloca->getAlign().value());
-#else
- unsigned alignment = alloca->getAlignment();
-#endif
if (alignment < static_cast<unsigned>(info.alignment)) {
-#if TVM_LLVM_VERSION >= 100
alloca->setAlignment(llvm::Align(info.alignment));
-#else
- alloca->setAlignment(info.alignment);
-#endif
}
buf = alloca;
} else {
@@ -233,25 +221,11 @@ class CodeGenAMDGPU : public CodeGenLLVM {
llvm::Value* v0 = MakeValue(op->args[0]);
llvm::Value* v1 = MakeValue(op->args[1]);
if (op->args[1]->dtype.is_float()) {
-#if TVM_LLVM_VERSION >= 90
-#if TVM_LLVM_VERSION >= 130
return builder_->CreateAtomicRMW(llvm::AtomicRMWInst::FAdd, v0, v1,
llvm::MaybeAlign(),
llvm::AtomicOrdering::Monotonic);
-#else
- return builder_->CreateAtomicRMW(llvm::AtomicRMWInst::FAdd, v0, v1,
- llvm::AtomicOrdering::Monotonic);
-#endif
-#else
- TVM_FFI_THROW(InternalError) << "Floating point atomic requires LLVM 9
or newer";
-#endif
}
-#if TVM_LLVM_VERSION >= 130
return builder_->CreateAtomicRMW(llvm::AtomicRMWInst::Add, v0, v1,
llvm::MaybeAlign(),
llvm::AtomicOrdering::Monotonic);
-#else
- return builder_->CreateAtomicRMW(llvm::AtomicRMWInst::Add, v0, v1,
- llvm::AtomicOrdering::Monotonic);
-#endif
}
return CodeGenLLVM::CreateIntrinsic(op);
}
@@ -268,11 +242,6 @@ ffi::Module BuildAMDGPU(IRModule mod, Target target) {
LLVMInstance llvm_instance;
With<LLVMTarget> llvm_target(llvm_instance, target);
-#if TVM_LLVM_VERSION < 90
- TVM_FFI_THROW(InternalError) << "AMDGPU backend requires at least LLVM 9";
- // Lower versions will crash when loading the bitcode, see
- // issue #4087 for a discussion
-#endif
auto cg = std::make_unique<CodeGenAMDGPU>();
cg->Init("TVMAMDGPUModule", llvm_target.get(), std::nullopt, false, false);
@@ -305,23 +274,11 @@ ffi::Module BuildAMDGPU(IRModule mod, Target target) {
dest_ll.SetUnbuffered();
destAsm.SetUnbuffered();
module->print(dest_ll, nullptr);
-#if TVM_LLVM_VERSION <= 60
- std::unique_ptr<llvm::Module> mAsm = llvm::CloneModule(module.get());
- std::unique_ptr<llvm::Module> mObj = llvm::CloneModule(module.get());
-#else
std::unique_ptr<llvm::Module> mAsm = llvm::CloneModule(*module.get());
std::unique_ptr<llvm::Module> mObj = llvm::CloneModule(*module.get());
-#endif
llvm::legacy::PassManager pass;
-#if TVM_LLVM_VERSION <= 60
- TVM_FFI_ICHECK(tm->addPassesToEmitFile(pass, destObj,
llvm::TargetMachine::CGFT_ObjectFile) == 0)
- << "Cannot emit target CGFT_ObjectFile";
-#elif TVM_LLVM_VERSION <= 90
- TVM_FFI_ICHECK(
- tm->addPassesToEmitFile(pass, destObj, nullptr,
llvm::TargetMachine::CGFT_ObjectFile) == 0)
- << "Cannot emit target CGFT_ObjectFile";
-#elif TVM_LLVM_VERSION <= 170
+#if TVM_LLVM_VERSION <= 170
TVM_FFI_ICHECK(tm->addPassesToEmitFile(pass, destObj, nullptr,
llvm::CGFT_ObjectFile) == 0)
<< "Cannot emit target CGFT_ObjectFile";
#else
@@ -333,15 +290,7 @@ ffi::Module BuildAMDGPU(IRModule mod, Target target) {
std::string obj(dataObj.begin(), dataObj.end());
llvm::legacy::PassManager passAsm;
-#if TVM_LLVM_VERSION <= 60
- TVM_FFI_ICHECK(
- tm->addPassesToEmitFile(passAsm, destAsm,
llvm::TargetMachine::CGFT_AssemblyFile) == 0)
- << "Cannot emit target CGFT_AssemblyFile";
-#elif TVM_LLVM_VERSION <= 90
- TVM_FFI_ICHECK(tm->addPassesToEmitFile(passAsm, destAsm, nullptr,
-
llvm::TargetMachine::CGFT_AssemblyFile) == 0)
- << "Cannot emit target CGFT_AssemblyFile";
-#elif TVM_LLVM_VERSION <= 170
+#if TVM_LLVM_VERSION <= 170
TVM_FFI_ICHECK(tm->addPassesToEmitFile(passAsm, destAsm, nullptr,
llvm::CGFT_AssemblyFile) == 0)
<< "Cannot emit target CGFT_AssemblyFile";
#else
diff --git a/src/target/llvm/codegen_arm.cc b/src/target/llvm/codegen_arm.cc
index c742b2f75f..5f41bf5699 100644
--- a/src/target/llvm/codegen_arm.cc
+++ b/src/target/llvm/codegen_arm.cc
@@ -24,12 +24,10 @@
#ifdef TVM_LLVM_VERSION
#include <llvm/IR/Intrinsics.h>
-#include <tvm/ffi/function.h>
-#include <tvm/ffi/reflection/registry.h>
-#if TVM_LLVM_VERSION >= 100
#include <llvm/IR/IntrinsicsARM.h>
-#endif
#include <llvm/Target/TargetMachine.h>
+#include <tvm/ffi/function.h>
+#include <tvm/ffi/reflection/registry.h>
#include "codegen_cpu.h"
diff --git a/src/target/llvm/codegen_blob.cc b/src/target/llvm/codegen_blob.cc
index 17056c3312..0bba8d492e 100644
--- a/src/target/llvm/codegen_blob.cc
+++ b/src/target/llvm/codegen_blob.cc
@@ -43,9 +43,7 @@
#include <llvm/IR/Module.h>
#include <llvm/IR/Type.h>
#include <llvm/IR/Value.h>
-#if TVM_LLVM_VERSION >= 100
#include <llvm/Support/Alignment.h>
-#endif
#include <llvm/Target/TargetMachine.h>
#include <llvm/Transforms/Utils/ModuleUtils.h>
#include <tvm/runtime/module.h>
@@ -95,11 +93,7 @@ std::unique_ptr<llvm::Module> CodeGenBlob(const std::string&
data, bool system_l
tvm_ffi_library_bin->setSection(".lrodata");
}
-#if TVM_LLVM_VERSION >= 100
tvm_ffi_library_bin->setAlignment(llvm::Align(1));
-#else
- tvm_ffi_library_bin->setAlignment(1);
-#endif
if (triple.isOSWindows()) {
tvm_ffi_library_bin->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
@@ -116,17 +110,8 @@ std::unique_ptr<llvm::Module> CodeGenBlob(const
std::string& data, bool system_l
auto* tvm_ffi_library_bin_reg =
new llvm::GlobalVariable(*module, int32_ty, false,
llvm::GlobalValue::InternalLinkage,
constant_zero, mdev_blob_name + "_reg_");
- auto tvm_ffi_library_bin_reg_alignment =
-#if TVM_LLVM_VERSION >= 110
- module->getDataLayout().getABITypeAlign(int32_ty);
-#else
- module->getDataLayout().getABITypeAlignment(int32_ty);
-#endif
-#if TVM_LLVM_VERSION >= 100
+ auto tvm_ffi_library_bin_reg_alignment =
module->getDataLayout().getABITypeAlign(int32_ty);
tvm_ffi_library_bin_reg->setAlignment(llvm::Align(tvm_ffi_library_bin_reg_alignment));
-#else
- tvm_ffi_library_bin_reg->setAlignment(tvm_ffi_library_bin_reg_alignment);
-#endif
auto* tvm_ffi_library_bin_string_ty =
llvm::ArrayType::get(int8_ty, mdev_blob_name.length() + 1);
@@ -135,11 +120,7 @@ std::unique_ptr<llvm::Module> CodeGenBlob(const
std::string& data, bool system_l
auto* tvm_ffi_library_bin_string = new llvm::GlobalVariable(
*module, tvm_ffi_library_bin_string_ty, true,
llvm::GlobalValue::PrivateLinkage,
tvm_ffi_library_bin_string_value, mdev_blob_name + ".str");
-#if TVM_LLVM_VERSION >= 100
tvm_ffi_library_bin_string->setAlignment(llvm::Align(1));
-#else
- tvm_ffi_library_bin_string->setAlignment(1);
-#endif
// Global init function
llvm::Function* init_fn = llvm::Function::Create(
diff --git a/src/target/llvm/codegen_cpu.cc b/src/target/llvm/codegen_cpu.cc
index 906d79b176..8a9895f72b 100644
--- a/src/target/llvm/codegen_cpu.cc
+++ b/src/target/llvm/codegen_cpu.cc
@@ -43,13 +43,11 @@
#include <llvm/IR/MDBuilder.h>
#include <llvm/IR/Metadata.h>
#include <llvm/IR/Module.h>
-#include <tvm/ffi/reflection/registry.h>
-#if TVM_LLVM_VERSION >= 100
#include <llvm/Support/Alignment.h>
-#endif
#include <llvm/Support/raw_ostream.h>
#include <llvm/Target/TargetMachine.h>
#include <llvm/Transforms/Utils/ModuleUtils.h>
+#include <tvm/ffi/reflection/registry.h>
#include <tvm/runtime/base.h>
#include <tvm/runtime/module.h>
#include <tvm/tir/analysis.h>
@@ -177,10 +175,6 @@ void CodeGenCPU::Init(const std::string& module_name,
LLVMTarget* llvm_target,
llvm::DISubprogram* CodeGenCPU::CreateDebugFunction(llvm::StringRef name,
const ffi::Array<Type>&
param_types,
const Type& return_type) {
-#if TVM_LLVM_VERSION < 50
- return nullptr;
-#else
-
llvm::SmallVector<llvm::Metadata*, 4> paramTys;
paramTys.push_back(GetDebugType(return_type));
@@ -193,12 +187,8 @@ llvm::DISubprogram*
CodeGenCPU::CreateDebugFunction(llvm::StringRef name,
bool local_to_unit =
llvm::GlobalVariable::isLocalLinkage(llvm::GlobalValue::InternalLinkage);
-#if TVM_LLVM_VERSION >= 80
auto SPFlags = llvm::DISubprogram::toSPFlags(local_to_unit,
/*IsDefinition=*/true,
/*IsOptimized=*/true);
-#else
- bool SPFlags = /*IsOptimized=*/true;
-#endif
auto* DIFunction = dbg_info_->di_builder_->createFunction(
/*Scope=*/dbg_info_->file_, /*Name=*/name, /*LinkageName=*/"",
@@ -206,8 +196,6 @@ llvm::DISubprogram*
CodeGenCPU::CreateDebugFunction(llvm::StringRef name,
/*ScopeLine=*/0, /*Flags=*/llvm::DINode::FlagPrototyped,
/*SPFlags=*/SPFlags);
return DIFunction;
-
-#endif
}
llvm::DISubprogram* CodeGenCPU::CreateDebugFunction(const GlobalVar& gvar,
const PrimFunc& func) {
@@ -426,11 +414,7 @@ llvm::Value* CodeGenCPU::CreateCallExtern(Type ret_type,
ffi::String global_symb
llvm::GlobalVariable* CodeGenCPU::InitContextPtr(llvm::Type* p_type,
std::string name) {
llvm::GlobalVariable* gv = new llvm::GlobalVariable(
*module_, p_type, false, llvm::GlobalValue::LinkOnceAnyLinkage, nullptr,
name);
-#if TVM_LLVM_VERSION >= 100
gv->setAlignment(llvm::Align(data_layout_->getTypeAllocSize(p_type)));
-#else
- gv->setAlignment(data_layout_->getTypeAllocSize(p_type));
-#endif
gv->setInitializer(llvm::Constant::getNullValue(p_type));
gv->setDLLStorageClass(llvm::GlobalValue::DLLStorageClassTypes::DLLExportStorageClass);
// comdat is needed for windows select any linking to work
@@ -445,14 +429,8 @@ llvm::GlobalVariable*
CodeGenCPU::InitContextPtr(llvm::Type* p_type, std::string
llvm::Value* CodeGenCPU::GetContextPtr(llvm::GlobalVariable* gv) {
TVM_FFI_ICHECK(gv != nullptr);
-#if TVM_LLVM_VERSION >= 110
llvm::LoadInst* faddr =
builder_->CreateAlignedLoad(gv->getValueType(), gv,
llvm::Align(gv->getAlignment()));
-#elif TVM_LLVM_VERSION >= 80
- llvm::LoadInst* faddr = builder_->CreateAlignedLoad(gv->getValueType(), gv,
gv->getAlignment());
-#else
- llvm::LoadInst* faddr = builder_->CreateAlignedLoad(gv, gv->getAlignment());
-#endif
faddr->setMetadata("tbaa",
md_builder_->createTBAAStructTagNode(md_tbaa_ctx_ptr_,
md_tbaa_ctx_ptr_, 0));
return faddr;
@@ -568,16 +546,11 @@ void CodeGenCPU::CreateComputeScope(const AttrStmtNode*
op) {
var_map_[var.get()] = v;
if (var.dtype().is_handle() && !alias_var_set_.count(var.get())) {
// set non alias.
-#if TVM_LLVM_VERSION >= 50
fcompute->addParamAttr(idx, llvm::Attribute::NoAlias);
// always not inline compute function to make the code structure clean
-#else
- fcompute->setDoesNotAlias(idx + 1);
-#endif
fcompute->addFnAttr(llvm::Attribute::NoInline);
}
// Add alignment attribute if needed.
-#if TVM_LLVM_VERSION >= 50
auto f = alloc_storage_info_.find(var.get());
if (f != alloc_storage_info_.end()) {
unsigned align = f->second.alignment;
@@ -586,7 +559,6 @@ void CodeGenCPU::CreateComputeScope(const AttrStmtNode* op)
{
fcompute->addParamAttr(idx, attr);
}
}
-#endif
}
function_ = fcompute;
@@ -650,11 +622,7 @@ void CodeGenCPU::CreateParallelLaunch(const Stmt& body,
int num_task, std::strin
ffi::Array<Var> vfields = tir::UndefinedVars(body, {});
uint64_t nbytes;
TypedPointer cdata = PackClosureData(vfields, &nbytes, "closure_" + name);
-#if TVM_LLVM_VERSION >= 90
auto launch_callee = llvm::FunctionCallee(ftype_tvm_parallel_launch_,
RuntimeTVMParallelLaunch());
-#else
- auto launch_callee = RuntimeTVMParallelLaunch();
-#endif
llvm::BasicBlock* par_launch_end = CheckCallSuccess(builder_->CreateCall(
launch_callee,
{f, builder_->CreatePointerCast(cdata.addr, t_void_p_),
ConstInt32(num_task)}));
@@ -701,11 +669,7 @@ llvm::Value* CodeGenCPU::CreateStaticHandle() {
llvm::GlobalVariable* gv =
new llvm::GlobalVariable(*module_, t_void_p_, false,
llvm::GlobalValue::PrivateLinkage,
nullptr, "__tvm_static_handle");
-#if TVM_LLVM_VERSION >= 100
gv->setAlignment(llvm::Align(data_layout_->getTypeAllocSize(t_void_p_)));
-#else
- gv->setAlignment(data_layout_->getTypeAllocSize(t_void_p_));
-#endif
gv->setInitializer(llvm::Constant::getNullValue(t_void_p_));
return gv;
}
@@ -768,11 +732,7 @@ llvm::Value* CodeGenCPU::GetPackedFuncHandle(const
std::string& fname) {
hptr =
new llvm::GlobalVariable(*module_, t_tvm_func_handle_, false,
llvm::GlobalValue::InternalLinkage, nullptr,
".tvm_func." + fname);
-#if TVM_LLVM_VERSION >= 100
hptr->setAlignment(llvm::Align(align));
-#else
- hptr->setAlignment(align);
-#endif
hptr->setInitializer(llvm::Constant::getNullValue(t_tvm_func_handle_));
func_handle_map_[fname] = hptr;
} else {
@@ -783,13 +743,7 @@ llvm::Value* CodeGenCPU::GetPackedFuncHandle(const
std::string& fname) {
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
- llvm::Value* handle = builder_->CreateAlignedLoad(hptr->getValueType(),
hptr, align);
-#else
- llvm::Value* handle = builder_->CreateAlignedLoad(hptr, align);
-#endif
llvm::Value* handle_not_null =
builder_->CreateICmpNE(handle,
llvm::Constant::getNullValue(t_tvm_func_handle_));
builder_->CreateCondBr(handle_not_null, end_block, init_block,
md_very_likely_branch_);
@@ -797,32 +751,15 @@ llvm::Value* CodeGenCPU::GetPackedFuncHandle(const
std::string& fname) {
builder_->SetInsertPoint(init_block);
llvm::Value* out =
WithFunctionEntry([&]() { return
builder_->CreateAlloca(t_tvm_func_handle_); });
-#if TVM_LLVM_VERSION >= 110
llvm::LoadInst* ctx_load =
builder_->CreateAlignedLoad(gv_mod_ctx_->getValueType(), gv_mod_ctx_,
llvm::Align(gv_mod_ctx_->getAlignment()));
-#elif TVM_LLVM_VERSION >= 80
- llvm::LoadInst* ctx_load =
builder_->CreateAlignedLoad(gv_mod_ctx_->getValueType(), gv_mod_ctx_,
-
gv_mod_ctx_->getAlignment());
-#else
- llvm::LoadInst* ctx_load = builder_->CreateAlignedLoad(gv_mod_ctx_,
gv_mod_ctx_->getAlignment());
-#endif
ctx_load->setMetadata(
"tbaa", md_builder_->createTBAAStructTagNode(md_tbaa_ctx_ptr_,
md_tbaa_ctx_ptr_, 0));
-#if TVM_LLVM_VERSION >= 90
auto env_callee = llvm::FunctionCallee(ftype_tvm_get_func_from_env_,
RuntimeTVMGetFuncFromEnv());
-#else
- auto env_callee = RuntimeTVMGetFuncFromEnv();
-#endif
llvm::Value* retcode = builder_->CreateCall(env_callee, {ctx_load,
GetConstString(fname), out});
init_block = CheckCallSuccess(retcode);
-#if TVM_LLVM_VERSION >= 110
llvm::Value* loaded_handle =
builder_->CreateAlignedLoad(t_tvm_func_handle_, out, llvm::Align(align));
-#elif TVM_LLVM_VERSION >= 80
- llvm::Value* loaded_handle = builder_->CreateAlignedLoad(t_tvm_func_handle_,
out, align);
-#else
- llvm::Value* loaded_handle = builder_->CreateAlignedLoad(out, align);
-#endif
// Store the handle
builder_->CreateStore(loaded_handle, hptr);
builder_->CreateBr(end_block);
@@ -876,12 +813,7 @@ CodeGenCPU::PackedCall
CodeGenCPU::MakeCallPackedLowered(const ffi::Array<PrimEx
call_args.push_back(llvm::ConstantPointerNull::get(t_void_p_));
call_args.insert(call_args.end(), {packed_args, ConstInt32(nargs),
result});
}
-#if TVM_LLVM_VERSION >= 90
auto call_callee = llvm::FunctionCallee(callee_ftype, callee_value);
-#else
- (void)callee_ftype; // use callee_ftype to avoid unused variable warning
when using older LLVM.
- auto call_callee = callee_value;
-#endif
llvm::Value* call = builder_->CreateCall(call_callee, call_args);
llvm::BasicBlock* end_block = CheckCallSuccess(call);
@@ -896,26 +828,14 @@ CodeGenCPU::PackedCall
CodeGenCPU::MakeCallPackedLowered(const ffi::Array<PrimEx
builder_->CreateInBoundsGEP(t_tvm_ffi_any_, result, {ConstInt32(0),
ConstInt32(2)});
llvm::Value* load_ptr =
builder_->CreatePointerCast(result_value,
llvmGetPointerTo(llvm_r_api_type, 0));
-#if TVM_LLVM_VERSION >= 110
llvm::Value* rvalue = builder_->CreateAlignedLoad(llvm_r_api_type,
load_ptr, llvm::Align(8));
-#elif TVM_LLVM_VERSION >= 80
- llvm::Value* rvalue = builder_->CreateAlignedLoad(llvm_r_api_type,
load_ptr, 8);
-#else
- llvm::Value* rvalue = builder_->CreateAlignedLoad(load_ptr, 8);
-#endif
pc.ret_value = CreateCast(r_api_type, r_type, rvalue);
llvm::Value* result_type_index =
builder_->CreateInBoundsGEP(t_tvm_ffi_any_, result, {ConstInt32(0),
ConstInt32(0)});
// Load the return type code.
-#if TVM_LLVM_VERSION >= 110
pc.ret_type_index = builder_->CreateAlignedLoad(t_int32_,
result_type_index, llvm::Align(4));
-#elif TVM_LLVM_VERSION >= 80
- pc.ret_type_index = builder_->CreateAlignedLoad(t_int32_,
result_type_index, 8);
-#else
- pc.ret_type_index = builder_->CreateAlignedLoad(result_type_index, 8);
-#endif
}
pc.end_block = end_block;
@@ -1095,12 +1015,8 @@ void CodeGenCPU::VisitStmt_(const AssertStmtNode* op) {
// fail condition.
builder_->SetInsertPoint(fail_block);
-#if TVM_LLVM_VERSION >= 90
auto err_callee =
llvm::FunctionCallee(ftype_tvm_ffi_error_set_raised_by_c_str_,
RuntimeTVMFFIErrorSetRaisedFromCStr());
-#else
- auto err_callee = RuntimeTVMFFIErrorSetRaisedFromCStr();
-#endif
builder_->CreateCall(err_callee, {GetConstString("RuntimeError"), msg});
builder_->CreateRet(ConstInt32(-1));
// otherwise set it to be new end.
@@ -1131,12 +1047,8 @@ void CodeGenCPU::VisitStmt_(const AttrStmtNode* op) {
<< "Cannot not place within parallel loop as the workload may
differ, "
<< " place it between parallel and parallel_launch_point";
this->VisitStmt(op->body);
-#if TVM_LLVM_VERSION >= 90
auto bar_callee =
llvm::FunctionCallee(ftype_tvm_parallel_barrier_,
RuntimeTVMParallelBarrier());
-#else
- auto bar_callee = RuntimeTVMParallelBarrier();
-#endif
builder_->CreateCall(bar_callee, {MakeValue(parallel_env_.task_id),
parallel_env_.penv});
} else if (op->attr_key == tir::attr::pragma_import_llvm) {
const StringImmNode* value = op->value.as<StringImmNode>();
diff --git a/src/target/llvm/codegen_hexagon.cc
b/src/target/llvm/codegen_hexagon.cc
index 61922a6342..489cbd04e0 100644
--- a/src/target/llvm/codegen_hexagon.cc
+++ b/src/target/llvm/codegen_hexagon.cc
@@ -17,7 +17,7 @@
* under the License.
*/
-#if defined(TVM_LLVM_VERSION) && TVM_LLVM_VERSION >= 70
+#ifdef TVM_LLVM_VERSION
#include <llvm/ADT/ArrayRef.h>
#include <llvm/ADT/SmallString.h>
@@ -29,23 +29,19 @@
#include <llvm/IR/GlobalVariable.h>
#include <llvm/IR/Instructions.h>
#include <llvm/IR/Intrinsics.h>
-#include <tvm/ffi/reflection/registry.h>
-#if TVM_LLVM_VERSION >= 100
#include <llvm/IR/IntrinsicsHexagon.h>
-#endif
#include <llvm/IR/LLVMContext.h>
#include <llvm/IR/LegacyPassManager.h>
#include <llvm/IR/MDBuilder.h>
#include <llvm/IR/Module.h>
-#if TVM_LLVM_VERSION >= 100
#include <llvm/Support/Alignment.h>
-#endif
#include <llvm/Support/CodeGen.h>
#include <llvm/Support/CommandLine.h>
#include <llvm/Support/FileSystem.h>
#include <llvm/Support/raw_ostream.h>
#include <llvm/Target/TargetMachine.h>
#include <llvm/Transforms/Utils/Cloning.h>
+#include <tvm/ffi/reflection/registry.h>
#include <tvm/runtime/module.h>
#include <tvm/target/codegen.h>
#include <tvm/tir/analysis.h>
@@ -89,10 +85,8 @@ class CodeGenHexagon final : public CodeGenCPU {
uint64_t GetTypeSizeInBits(llvm::Type* type) const {
#if TVM_LLVM_VERSION >= 160
return data_layout_->getTypeSizeInBits(type).getFixedValue();
-#elif TVM_LLVM_VERSION >= 100
- return data_layout_->getTypeSizeInBits(type).getFixedSize();
#else
- return data_layout_->getTypeSizeInBits(type);
+ return data_layout_->getTypeSizeInBits(type).getFixedSize();
#endif
}
@@ -171,11 +165,7 @@ llvm::Value* CodeGenHexagon::CreateCallExternQHL(Type
ret_type, ffi::String glob
f = llvm::Function::Create(ftype, llvm::Function::ExternalLinkage,
MakeStringRef(global_symbol), module_.get());
}
-#if TVM_LLVM_VERSION >= 90
auto ext_callee = llvm::FunctionCallee(f);
-#else
- auto ext_callee = f;
-#endif
vect_split.push_back(builder_->CreateCall(ext_callee, sub_vect_val));
}
return CodeGenCPU::CreateVecConcat(vect_split);
@@ -208,7 +198,6 @@ llvm::Value* CodeGenHexagon::VisitExpr_(const
BufferLoadNode* op) {
}
llvm::Value* CodeGenHexagon::CreateIntrinsic(const CallNode* op) {
-#if TVM_LLVM_VERSION >= 150
if (op->op.same_as(builtin::start_profile_intrinsic()) ||
op->op.same_as(builtin::end_profile_intrinsic())) {
llvm::Value* id = MakeValue(op->args[0]);
@@ -230,7 +219,6 @@ llvm::Value* CodeGenHexagon::CreateIntrinsic(const
CallNode* op) {
llvm::Type* t_int8_p_ = llvmGetPointerTo(t_int8_, 0);
return builder_->CreateCall(func,
{llvm::ConstantExpr::getBitCast(name_var, t_int8_p_), id});
}
-#endif
return CodeGenCPU::CreateIntrinsic(op);
}
@@ -303,11 +291,7 @@ llvm::Value* CodeGenHexagon::Intrinsic(llvm::Intrinsic::ID
IntID,
#else
llvm::Function* intf = llvm::Intrinsic::getDeclaration(module_.get(), IntID);
#endif
-#if TVM_LLVM_VERSION >= 90
auto intf_callee = llvm::FunctionCallee(intf);
-#else
- auto intf_callee = intf;
-#endif
std::vector<llvm::Value*> conv_args;
llvm::FunctionType* intf_type = intf->getFunctionType();
TVM_FFI_ICHECK(args.size() == intf_type->getNumParams());
@@ -400,11 +384,7 @@ llvm::Value* CodeGenHexagon::VectorLookupLoad(Buffer
buffer, DataType buffer_typ
int ret_bits = GetTypeSizeInBits(ret_type);
TVM_FFI_ICHECK_GE(res_bits, ret_bits);
if (ret_bits < res_bits) {
-#if TVM_LLVM_VERSION >= 110
llvm::Type* res_byte_type = llvm::VectorType::get(t_int8_, res_bits / 8,
/*Scalable*/ false);
-#else
- llvm::Type* res_byte_type = llvm::VectorType::get(t_int8_, res_bits / 8);
-#endif
result = CreateVecSlice(builder_->CreateBitCast(result, res_byte_type), 0,
ret_bits / 8);
}
if (result->getType() != ret_type) {
@@ -525,10 +505,7 @@ ffi::Module BuildHexagon(IRModule mod, Target target) {
else
llvm::WriteBitcodeToFile(m, os);
} else if (cgft == Asm || cgft == Obj) {
-#if TVM_LLVM_VERSION <= 90
- auto ft = cgft == Asm ?
llvm::TargetMachine::CodeGenFileType::CGFT_AssemblyFile
- :
llvm::TargetMachine::CodeGenFileType::CGFT_ObjectFile;
-#elif TVM_LLVM_VERSION <= 170
+#if TVM_LLVM_VERSION <= 170
auto ft = cgft == Asm ? llvm::CGFT_AssemblyFile : llvm::CGFT_ObjectFile;
#else
auto ft =
diff --git a/src/target/llvm/codegen_llvm.cc b/src/target/llvm/codegen_llvm.cc
index 472567efc7..6daa2d49a6 100644
--- a/src/target/llvm/codegen_llvm.cc
+++ b/src/target/llvm/codegen_llvm.cc
@@ -34,16 +34,8 @@
#include <llvm/ADT/Triple.h>
#endif
#include <llvm/Analysis/TargetTransformInfo.h>
-#if TVM_LLVM_VERSION >= 50
#include <llvm/BinaryFormat/Dwarf.h>
-#else
-#include <llvm/Support/Dwarf.h>
-#endif
-#if TVM_LLVM_VERSION >= 60
#include <llvm/CodeGen/TargetSubtargetInfo.h>
-#else
-#include <llvm/Target/TargetSubtargetInfo.h>
-#endif
#include <llvm/IR/Argument.h>
#include <llvm/IR/Attributes.h>
#include <llvm/IR/BasicBlock.h>
@@ -53,11 +45,7 @@
#include <llvm/IR/DataLayout.h>
#include <llvm/IR/DebugInfoMetadata.h>
#include <llvm/IR/DerivedTypes.h>
-#if TVM_LLVM_VERSION >= 150
#include <llvm/IR/FMF.h>
-#else
-#include <llvm/IR/Operator.h>
-#endif
#include <llvm/IR/Function.h>
#include <llvm/IR/GlobalVariable.h>
#include <llvm/IR/Instructions.h>
@@ -81,13 +69,11 @@
#include <llvm/Support/Host.h>
#include <llvm/Transforms/IPO/PassManagerBuilder.h>
#endif
-#if TVM_LLVM_VERSION >= 100
#include <llvm/Support/Alignment.h>
-#include <llvm/Support/TypeSize.h>
-#endif
#include <llvm/Support/CodeGen.h>
#include <llvm/Support/MemoryBuffer.h>
#include <llvm/Support/SourceMgr.h>
+#include <llvm/Support/TypeSize.h>
#include <llvm/Target/TargetMachine.h>
#include <llvm/Transforms/IPO.h>
#include <llvm/Transforms/Utils/ModuleUtils.h>
@@ -183,9 +169,7 @@ void CodeGenLLVM::InitTarget() {
if (native_vector_bits_ == 0) {
native_vector_bits_ = llvm_target_->GetVectorWidth();
}
-#if TVM_LLVM_VERSION >= 60
bool use_float16_abi = false;
-#if TVM_LLVM_VERSION >= 150
// For conversions between _Float16 and float, LLVM uses runtime functions
// __extendhfsf2 and __truncsfhf2. On X86 up until version 14, LLVM used
// "uint16_t" for representing _Float16. Starting with LLVM 15,
half-precision
@@ -215,12 +199,10 @@ void CodeGenLLVM::InitTarget() {
TVM_FFI_ICHECK(test_sse2 != nullptr) << "Module creation error";
use_float16_abi = tm->getSubtargetImpl(*test_sse2)->checkFeatures("+sse2");
}
-#endif // TVM_LLVM_VERSION >= 150
// Call this function only with LLVM >= 6.0. The code it emits uses
"dso_local"
// which was introduced in LLVM 6.
EmitFloat16ConversionBuiltins(use_float16_abi);
-#endif // TVM_LLVM_VERSION >= 60
}
llvm::Function* CodeGenLLVM::DeclareFunction(const GlobalVar& gvar, const
PrimFunc& f) {
@@ -306,11 +288,7 @@ void CodeGenLLVM::AddFunctionInternal(const GlobalVar&
gvar, const PrimFunc& f)
if (is_restricted_) {
if (var.dtype().is_handle() && !alias_var_set_.count(var.get())) {
// set non alias.
-#if TVM_LLVM_VERSION >= 50
function_->addParamAttr(i, llvm::Attribute::NoAlias);
-#else
- function_->setDoesNotAlias(i + 1);
-#endif
}
}
}
@@ -320,7 +298,6 @@ void CodeGenLLVM::AddFunctionInternal(const GlobalVar&
gvar, const PrimFunc& f)
this->VisitStmt(f->body);
// Add alignment attribute if needed.
-#if TVM_LLVM_VERSION >= 50
for (size_t i = 0; i < f->params.size(); ++i) {
const Var& var = f->params[i];
auto f = alloc_storage_info_.find(var.get());
@@ -332,7 +309,6 @@ void CodeGenLLVM::AddFunctionInternal(const GlobalVar&
gvar, const PrimFunc& f)
}
}
}
-#endif
EmitDebugLocation(f->span);
@@ -491,7 +467,7 @@ void CodeGenLLVM::Optimize() {
mpass.run(*module_, mam);
}
-#else // TVM_LLVM_VERSION
+#else // TVM_LLVM_VERSION
class FPassManager : public llvm::legacy::FunctionPassManager {
public:
@@ -539,18 +515,12 @@ void CodeGenLLVM::Optimize() {
builder.OptLevel = 3;
}
-#if TVM_LLVM_VERSION >= 50
builder.Inliner = llvm::createFunctionInliningPass(builder.OptLevel, 0,
false);
-#else
- builder.Inliner = llvm::createFunctionInliningPass(builder.OptLevel, 0);
-#endif
builder.LoopVectorize = true;
builder.SLPVectorize = true;
this->InitPassManagerBuilder(&builder);
-#if TVM_LLVM_VERSION >= 50
tm->adjustPassManager(builder);
-#endif
builder.populateFunctionPassManager(fpass);
builder.populateModulePassManager(mpass);
@@ -611,18 +581,11 @@ llvm::Type* CodeGenLLVM::DTypeToLLVMType(const DataType&
dtype) const {
etype = llvm::Type::getIntNTy(*ctx, 4);
}
if (!dtype.is_scalar()) {
-#if TVM_LLVM_VERSION >= 110
if (dtype.is_scalable_vector()) {
return llvm::VectorType::get(etype, dtype.vscale_factor(), true);
} else {
return llvm::FixedVectorType::get(etype, dtype.lanes());
}
-#else
- TVM_FFI_ICHECK(!dtype.is_scalable_vector())
- << "Versions of LLVM < 11 do not support scalable vectors. Please
upgrade to a later "
- "version.";
- return llvm::VectorType::get(etype, dtype.lanes());
-#endif
} else {
return etype;
}
@@ -756,22 +719,13 @@ llvm::GlobalVariable*
CodeGenLLVM::AllocateSharedMemory(DataType dtype, size_t s
llvm::GlobalVariable* global =
new llvm::GlobalVariable(*module_, type, false, linkage,
llvm::UndefValue::get(type), "shmem",
nullptr, llvm::GlobalValue::NotThreadLocal,
shared_address_space);
-#if TVM_LLVM_VERSION >= 100
global->setAlignment(llvm::MaybeAlign(alignment));
-#else
- global->setAlignment(alignment);
-#endif
return global;
}
std::unique_ptr<CodeGenLLVM::DebugInfo>
CodeGenLLVM::CreateDebugInfo(llvm::Module* module) {
-#if TVM_LLVM_VERSION >= 100
auto debug_info = std::make_unique<CodeGenLLVM::DebugInfo>();
debug_info->di_builder_ = std::make_unique<llvm::DIBuilder>(*module);
-#else
- auto debug_info = llvm::make_unique<CodeGenLLVM::DebugInfo>();
- debug_info->di_builder_ = llvm::make_unique<llvm::DIBuilder>(*module);
-#endif
// TODO(tulloch): pass this information through Span classes to the IRModule
instance?
debug_info->file_ =
debug_info->di_builder_->createFile("IRModule.CodeGenLLVM", ".");
const int runtime_version = 0;
@@ -807,11 +761,7 @@ llvm::Value* CodeGenLLVM::CreateVecSlice(llvm::Value* vec,
int begin, int extent
llvm::Value* CodeGenLLVM::CreateVecFlip(llvm::Value* vec) {
int num_elems = GetVectorNumElements(vec);
-#if TVM_LLVM_VERSION >= 110
std::vector<int> indices;
-#else
- std::vector<unsigned> indices;
-#endif
for (int i = 0; i < num_elems; ++i) {
indices.push_back(num_elems - i - 1);
}
@@ -835,11 +785,7 @@ llvm::Value*
CodeGenLLVM::CreateVecConcat(std::vector<llvm::Value*> vecs) {
for (size_t i = 0, e = vecs.size(); i != e; ++i) {
llvm::Value* v = vecs[i];
if (!v->getType()->isVectorTy()) {
-#if TVM_LLVM_VERSION >= 110
llvm::Type* vec_ty = llvm::FixedVectorType::get(v->getType(), 1);
-#else
- llvm::Type* vec_ty = llvm::VectorType::get(v->getType(), 1);
-#endif
vecs[i] = builder_->CreateInsertElement(llvm::UndefValue::get(vec_ty),
v, ConstInt32(0));
}
}
@@ -863,11 +809,7 @@ llvm::Value*
CodeGenLLVM::CreateVecConcat(std::vector<llvm::Value*> vecs) {
rhs = CreateVecPad(rhs, lhs_lanes);
}
const size_t shared_lanes = std::max(lhs_lanes, rhs_lanes);
-#if TVM_LLVM_VERSION >= 110
std::vector<int> mask;
-#else
- std::vector<unsigned> mask;
-#endif
for (size_t i = 0; i < lhs_lanes; ++i) {
mask.push_back(i);
}
@@ -964,11 +906,7 @@ llvm::Constant*
CodeGenLLVM::GetGlobalConstant(llvm::Constant* const_data, const
llvm::Type* ty = const_data->getType();
llvm::GlobalVariable* global =
new llvm::GlobalVariable(*module_, ty, true, linkage_type, const_data,
name);
-#if TVM_LLVM_VERSION >= 100
global->setAlignment(llvm::Align(1));
-#else
- global->setAlignment(1);
-#endif
llvm::Constant* zero = ConstInt32(0);
llvm::Constant* indices[] = {zero, zero};
llvm::Constant* ptr = llvm::ConstantExpr::getGetElementPtr(ty, global,
indices);
@@ -1115,7 +1053,6 @@ llvm::Function*
CodeGenLLVM::GetIntrinsicDecl(llvm::Intrinsic::ID id, llvm::Type
llvm::Intrinsic::getIntrinsicInfoTableEntries(id, infos);
llvm::SmallVector<llvm::Type*, 4> overload_types;
-#if TVM_LLVM_VERSION >= 90
auto try_match = [&](llvm::FunctionType* f_ty, bool var_arg) {
overload_types.clear();
llvm::ArrayRef<llvm::Intrinsic::IITDescriptor> ref(infos);
@@ -1163,25 +1100,6 @@ llvm::Function*
CodeGenLLVM::GetIntrinsicDecl(llvm::Intrinsic::ID id, llvm::Type
}
// Failed to identify the type.
return nullptr;
-
-#else // TVM_LLVM_VERSION
- llvm::ArrayRef<llvm::Intrinsic::IITDescriptor> ref(infos);
- // matchIntrinsicType returns true on error.
- if (llvm::Intrinsic::matchIntrinsicType(ret_type, ref, overload_types)) {
- return nullptr;
- }
- for (llvm::Type* t : arg_types) {
- if (llvm::Intrinsic::matchIntrinsicType(t, ref, overload_types)) {
- return nullptr;
- }
- }
-#if TVM_LLVM_VERSION >= 200
- return llvm::cast<llvm::Function>(
- llvm::Intrinsic::getOrInsertDeclaration(module, id, overload_types));
-#else
- return llvm::Intrinsic::getDeclaration(module, id, overload_types);
-#endif
-#endif // TVM_LLVM_VERSION
}
void CodeGenLLVM::SetTargetAttributes(llvm::Function* func) {
@@ -1527,11 +1445,7 @@ llvm::Value* CodeGenLLVM::CreateIntrinsic(const
CallNode* op) {
llvm::Value* v0 = MakeValue(op->args[0]);
llvm::Value* v1 = MakeValue(op->args[1]);
int num_elems = GetVectorNumElements(v0) * 2;
-#if TVM_LLVM_VERSION >= 110
std::vector<int> indices;
-#else
- std::vector<unsigned> indices;
-#endif
for (int i = 0; i < num_elems; ++i) {
indices.push_back(i);
}
@@ -1548,7 +1462,6 @@ llvm::Value* CodeGenLLVM::CreateIntrinsic(const CallNode*
op) {
return builder_->CreateAssumption(cond);
} else if (op->op.same_as(builtin::tvm_thread_invariant())) {
return MakeValue(op->args[0]);
-#if TVM_LLVM_VERSION >= 110
} else if (op->op.same_as(builtin::vscale())) {
llvm::Intrinsic::ID id = llvm::Intrinsic::vscale;
llvm::Function* f = GetIntrinsicDecl(id, builder_->getInt32Ty(), {});
@@ -1558,7 +1471,6 @@ llvm::Value* CodeGenLLVM::CreateIntrinsic(const CallNode*
op) {
llvm::Function* f = GetIntrinsicDecl(id, DTypeToLLVMType(op->dtype),
{builder_->getInt32Ty(),
builder_->getInt32Ty()});
return builder_->CreateCall(f, {MakeValue(op->args[0]),
MakeValue(op->args[1])});
-#endif
} else {
TVM_FFI_THROW(InternalError) << "unknown intrinsic " << op->op;
}
@@ -1852,23 +1764,11 @@ llvm::Value* CodeGenLLVM::VisitExpr_(const
BufferLoadNode* op) {
if (predicate != nullptr) {
TVM_FFI_ICHECK(!is_volatile)
<< "The masked load intrinsic does not support declaring load as
volatile.";
-#if TVM_LLVM_VERSION >= 130
load = builder_->CreateMaskedLoad(buffer_ptr.type, buffer_ptr.addr,
llvm::Align(alignment),
predicate);
-#elif TVM_LLVM_VERSION >= 110
- load = builder_->CreateMaskedLoad(buffer_ptr.addr,
llvm::Align(alignment), predicate);
-#else
- load = builder_->CreateMaskedLoad(buffer_ptr.addr, alignment, predicate);
-#endif
} else {
-#if TVM_LLVM_VERSION >= 110
load = builder_->CreateAlignedLoad(buffer_ptr.type, buffer_ptr.addr,
llvm::Align(alignment),
is_volatile);
-#elif TVM_LLVM_VERSION >= 80
- load = builder_->CreateAlignedLoad(buffer_ptr.type, buffer_ptr.addr,
alignment, is_volatile);
-#else
- load = builder_->CreateAlignedLoad(buffer_ptr.addr, alignment,
is_volatile);
-#endif
}
loads.push_back(load);
@@ -1970,20 +1870,9 @@ llvm::Value* CodeGenLLVM::VisitExpr_(const
BroadcastNode* op) {
llvm::Constant* undef = llvm::UndefValue::get(type);
llvm::Constant* zero = ConstInt32(0);
value = builder_->CreateInsertElement(undef, value, zero);
-#if TVM_LLVM_VERSION >= 110
llvm::ElementCount ec =
-#if TVM_LLVM_VERSION >= 120
llvm::ElementCount::get(dtype.get_lanes_or_vscale_factor(),
dtype.is_scalable_vector());
-#else
- llvm::ElementCount(dtype.get_lanes_or_vscale_factor(),
dtype.is_scalable_vector());
-#endif
llvm::Constant* mask = llvm::ConstantVector::getSplat(ec, zero);
-#else
- TVM_FFI_ICHECK(!dtype.is_scalable_vector())
- << "Versions of LLVM < 11 do not support scalable vectors. Please
upgrade to a later "
- "version.";
- llvm::Constant* mask = llvm::ConstantVector::getSplat(dtype.lanes(), zero);
-#endif
return builder_->CreateShuffleVector(value, undef, mask);
}
@@ -2006,19 +1895,11 @@ void CodeGenLLVM::VisitStmt_(const BufferStoreNode* op)
{
if (predicate != nullptr) {
TVM_FFI_ICHECK(!is_volatile)
<< "The masked store intrinsic does not support declaring store as
volatile.";
-#if TVM_LLVM_VERSION >= 110
store =
builder_->CreateMaskedStore(to_store, buffer_ptr.addr,
llvm::Align(alignment), predicate);
-#else
- store = builder_->CreateMaskedStore(to_store, buffer_ptr.addr,
alignment, predicate);
-#endif
} else {
-#if TVM_LLVM_VERSION >= 110
store = builder_->CreateAlignedStore(to_store, buffer_ptr.addr,
llvm::Align(alignment),
is_volatile);
-#else
- store = builder_->CreateAlignedStore(to_store, buffer_ptr.addr,
alignment, is_volatile);
-#endif
}
return store;
};
@@ -2108,23 +1989,11 @@ void CodeGenLLVM::VisitStmt_(const AllocateNode* op) {
llvm::AllocaInst* alloca = WithFunctionEntry([&]() {
return builder_->CreateAlloca(DTypeToLLVMType(op->dtype),
ConstInt32(constant_size));
});
-#if TVM_LLVM_VERSION >= 110
auto alignment = static_cast<unsigned>(alloca->getAlign().value());
-#else
- unsigned alignment = alloca->getAlignment();
-#endif
if (alignment < static_cast<unsigned>(info.alignment)) {
-#if TVM_LLVM_VERSION >= 100
alloca->setAlignment(llvm::Align(info.alignment));
-#else
- alloca->setAlignment(info.alignment);
-#endif
}
-#if TVM_LLVM_VERSION >= 110
info.alignment = static_cast<unsigned>(alloca->getAlign().value());
-#else
- info.alignment = alloca->getAlignment();
-#endif
buf = alloca;
@@ -2224,7 +2093,6 @@ void CodeGenLLVM::VisitStmt_(const EvaluateNode* op) {
}
void CodeGenLLVM::EmitDebugLocation(const ffi::Optional<Span>& span) {
-#if TVM_LLVM_VERSION >= 50
if (di_subprogram_ == nullptr) {
// debug info is not always generated outside of CPU codegen
return;
@@ -2241,7 +2109,6 @@ void CodeGenLLVM::EmitDebugLocation(const
ffi::Optional<Span>& span) {
auto loc = llvm::DebugLoc(llvm::DILocation::get(*ctx, line, column,
di_subprogram_));
builder_->SetCurrentDebugLocation(loc);
-#endif
}
void CodeGenLLVM::EmitDebugLocation() {
builder_->SetCurrentDebugLocation(nullptr); }
@@ -2250,7 +2117,6 @@ void CodeGenLLVM::EmitDebugLocation(const StmtNode* op) {
EmitDebugLocation(op->
// Following Glow |DebugInfo::generateFunctionDebugInfo|, https://git.io/fjadv
void CodeGenLLVM::AddDebugInformation(llvm::Function* f_llvm,
const ffi::Array<Type>& tvm_param_types)
{
-#if TVM_LLVM_VERSION >= 50
TVM_FFI_ICHECK(di_subprogram_);
f_llvm->setSubprogram(di_subprogram_);
TVM_FFI_ICHECK_EQ(f_llvm->getSubprogram(), di_subprogram_);
@@ -2300,14 +2166,12 @@ void CodeGenLLVM::AddDebugInformation(llvm::Function*
f_llvm,
I.setDebugLoc(llvm::DebugLoc(di_loc));
}
}
-#endif
}
void CodeGenLLVM::AddDebugInformation(llvm::Value* llvm_value, const Var&
tir_var,
llvm::Instruction* insert_before) {
llvm_value->setName(tir_var->name_hint.c_str());
-#if TVM_LLVM_VERSION >= 50
if (!di_subprogram_) return;
auto dbg_dtype = GetDebugType(GetType(tir_var));
@@ -2318,7 +2182,6 @@ void CodeGenLLVM::AddDebugInformation(llvm::Value*
llvm_value, const Var& tir_va
auto* di_loc = llvm::DILocation::get(*llvm_target_->GetContext(), 0, 0,
di_subprogram_);
-#if TVM_LLVM_VERSION >= 150
// LLVM 15+ requires dbg_declare to reference pointer or integer types only.
// For non-pointer types (floats, vectors), use dbg_value instead to track
// the SSA value directly rather than a memory location.
@@ -2342,7 +2205,6 @@ void CodeGenLLVM::AddDebugInformation(llvm::Value*
llvm_value, const Var& tir_va
}
return;
}
-#endif
if (insert_before) {
#if TVM_LLVM_VERSION >= 200
@@ -2359,7 +2221,6 @@ void CodeGenLLVM::AddDebugInformation(llvm::Value*
llvm_value, const Var& tir_va
dbg_info_->di_builder_->createExpression(),
llvm::DebugLoc(di_loc),
builder_->GetInsertBlock());
}
-#endif
}
llvm::DIType* CodeGenLLVM::GetDebugType(const Type& ty_tir) {
diff --git a/src/target/llvm/codegen_llvm.h b/src/target/llvm/codegen_llvm.h
index e682581702..a14342db37 100644
--- a/src/target/llvm/codegen_llvm.h
+++ b/src/target/llvm/codegen_llvm.h
@@ -31,24 +31,15 @@
#include <llvm/IR/BasicBlock.h>
#include <llvm/IR/ConstantFolder.h>
#include <llvm/IR/Constants.h>
+#include <llvm/IR/DebugInfoMetadata.h>
#include <llvm/IR/DerivedTypes.h>
-#if TVM_LLVM_VERSION >= 150
#include <llvm/IR/FMF.h>
-#else
-#include <llvm/IR/Operator.h>
-#endif
-#include <llvm/IR/DebugInfoMetadata.h>
#include <llvm/IR/GlobalValue.h>
#include <llvm/IR/IRBuilder.h>
#include <llvm/IR/Instructions.h>
#include <llvm/IR/Intrinsics.h>
-#include <llvm/Support/Casting.h>
-#if TVM_LLVM_VERSION >= 140
#include <llvm/MC/TargetRegistry.h>
-#else
-#include <llvm/Support/TargetRegistry.h>
-#endif
-
+#include <llvm/Support/Casting.h>
#include <tvm/arith/analyzer.h>
#include <tvm/ir/module.h>
#include <tvm/target/codegen.h>
@@ -509,13 +500,7 @@ class CodeGenLLVM : public ExprFunctor<llvm::Value*(const
PrimExpr&)>,
* \return The retrieved argument.
*/
llvm::Argument* GetArg(const llvm::Function* function, int i) const {
-#if TVM_LLVM_VERSION >= 100
return function->getArg(i);
-#elif TVM_LLVM_VERSION >= 50
- return const_cast<llvm::Argument*>(&function->arg_begin()[i]);
-#else
- return const_cast<llvm::Argument*>(&*std::next(function->arg_begin(), i));
-#endif
}
// The IRBuilder.
@@ -627,11 +612,7 @@ class CodeGenLLVM : public ExprFunctor<llvm::Value*(const
PrimExpr&)>,
};
inline int CodeGenLLVM::GetVectorNumElements(llvm::Value* vec) {
-#if TVM_LLVM_VERSION >= 120
return llvm::cast<llvm::FixedVectorType>(vec->getType())->getNumElements();
-#else
- return llvm::cast<llvm::VectorType>(vec->getType())->getNumElements();
-#endif
}
template <typename IterType, typename ConvType>
diff --git a/src/target/llvm/codegen_nvptx.cc b/src/target/llvm/codegen_nvptx.cc
index 4069f20d74..1b38ce1b75 100644
--- a/src/target/llvm/codegen_nvptx.cc
+++ b/src/target/llvm/codegen_nvptx.cc
@@ -30,22 +30,18 @@
#include <llvm/IR/InlineAsm.h>
#include <llvm/IR/Instructions.h>
#include <llvm/IR/Intrinsics.h>
-#include <tvm/ffi/reflection/registry.h>
-#if TVM_LLVM_VERSION >= 100
#include <llvm/IR/IntrinsicsNVPTX.h>
-#endif
#include <llvm/IR/LegacyPassManager.h>
#include <llvm/IR/Metadata.h>
#include <llvm/IR/Module.h>
#include <llvm/IR/Type.h>
#include <llvm/IRReader/IRReader.h>
-#if TVM_LLVM_VERSION >= 100
#include <llvm/Support/Alignment.h>
-#endif
#include <llvm/Support/CodeGen.h>
#include <llvm/Support/SourceMgr.h>
#include <llvm/Support/raw_ostream.h>
#include <llvm/Target/TargetMachine.h>
+#include <tvm/ffi/reflection/registry.h>
#if TVM_LLVM_VERSION < 170
#include <llvm/Transforms/IPO/PassManagerBuilder.h>
#endif
@@ -110,17 +106,9 @@ class CodeGenNVPTX : public CodeGenLLVM {
llvm::AllocaInst* alloca = WithFunctionEntry([&]() {
return builder_->CreateAlloca(DTypeToLLVMType(op->dtype),
ConstInt32(constant_size));
});
-#if TVM_LLVM_VERSION >= 110
auto alignment = static_cast<unsigned>(alloca->getAlign().value());
-#else
- unsigned alignment = alloca->getAlignment();
-#endif
if (alignment < static_cast<unsigned>(info.alignment)) {
-#if TVM_LLVM_VERSION >= 100
alloca->setAlignment(llvm::Align(info.alignment));
-#else
- alloca->setAlignment(info.alignment);
-#endif
}
buf = alloca;
} else {
@@ -293,25 +281,11 @@ llvm::Value* CodeGenNVPTX::CreateIntrinsic(const
CallNode* op) {
llvm::Value* v0 = MakeValue(op->args[0]);
llvm::Value* v1 = MakeValue(op->args[1]);
if (op->args[1]->dtype.is_float()) {
-#if TVM_LLVM_VERSION >= 90
-#if TVM_LLVM_VERSION >= 130
return builder_->CreateAtomicRMW(llvm::AtomicRMWInst::FAdd, v0, v1,
llvm::MaybeAlign(),
llvm::AtomicOrdering::Monotonic);
-#else
- return builder_->CreateAtomicRMW(llvm::AtomicRMWInst::FAdd, v0, v1,
- llvm::AtomicOrdering::Monotonic);
-#endif
-#else
- TVM_FFI_THROW(InternalError) << "Floating point atomic requires LLVM 9
or newer";
-#endif
}
-#if TVM_LLVM_VERSION >= 130
return builder_->CreateAtomicRMW(llvm::AtomicRMWInst::Add, v0, v1,
llvm::MaybeAlign(),
llvm::AtomicOrdering::Monotonic);
-#else
- return builder_->CreateAtomicRMW(llvm::AtomicRMWInst::Add, v0, v1,
- llvm::AtomicOrdering::Monotonic);
-#endif
}
return CodeGenLLVM::CreateIntrinsic(op);
}
@@ -359,15 +333,7 @@ ffi::Module BuildNVPTX(IRModule mod, Target target) {
std::string ll(data_ll.begin(), data_ll.end());
// emit ptx
llvm::legacy::PassManager pass;
-#if TVM_LLVM_VERSION <= 60
- TVM_FFI_ICHECK(tm->addPassesToEmitFile(pass, dest_ptx,
llvm::TargetMachine::CGFT_AssemblyFile) ==
- 0)
- << "Cannot emit target CGFT_ObjectFile";
-#elif TVM_LLVM_VERSION <= 90
- TVM_FFI_ICHECK(
- tm->addPassesToEmitFile(pass, dest_ptx, nullptr,
llvm::TargetMachine::CGFT_AssemblyFile) == 0)
- << "Cannot emit target CGFT_ObjectFile";
-#elif TVM_LLVM_VERSION <= 170
+#if TVM_LLVM_VERSION <= 170
TVM_FFI_ICHECK(tm->addPassesToEmitFile(pass, dest_ptx, nullptr,
llvm::CGFT_AssemblyFile) == 0)
<< "Cannot emit target CGFT_ObjectFile";
#else
diff --git a/src/target/llvm/codegen_x86_64.cc
b/src/target/llvm/codegen_x86_64.cc
index cd280d2ddc..dd54c511fb 100644
--- a/src/target/llvm/codegen_x86_64.cc
+++ b/src/target/llvm/codegen_x86_64.cc
@@ -26,12 +26,10 @@
#include <llvm/IR/DerivedTypes.h>
#include <llvm/IR/Function.h>
#include <llvm/IR/Intrinsics.h>
-#include <tvm/ffi/reflection/registry.h>
-#if TVM_LLVM_VERSION >= 100
#include <llvm/IR/IntrinsicsX86.h>
-#endif
#include <llvm/Support/Casting.h>
#include <tvm/ffi/function.h>
+#include <tvm/ffi/reflection/registry.h>
#include <string>
#include <vector>
@@ -74,18 +72,6 @@ llvm::Value* CodeGenX86_64::VisitExpr_(const CastNode* op) {
/*rounding-mode=*/MakeValue(IntImm(DataType::Int(32), 4)),
});
}
-
-#if TVM_LLVM_VERSION <= 100
- // The intrinsic x86_vcvtph2ps_256 was removed in LLVM 11.
- const auto has_f16c = llvm_target_->TargetHasCPUFeature("f16c");
-
- if (from.lanes() >= 8 && has_f16c) {
- return CallVectorIntrin(llvm::Intrinsic::x86_vcvtph2ps_256, 8,
- DTypeToLLVMType(DataType::Float(32,
from.lanes())),
- {MakeValue(tir::Call(DataType::Int(16,
from.lanes()),
-
tir::builtin::reinterpret(), {op->value}))});
- }
-#endif
}
return CodeGenCPU::VisitExpr_(op);
@@ -100,11 +86,7 @@ llvm::Value*
CodeGenX86_64::CallVectorIntrin(llvm::Intrinsic::ID id, size_t intr
#else
llvm::Function* f = llvm::Intrinsic::getDeclaration(module_.get(), id);
#endif
-#if TVM_LLVM_VERSION >= 120
size_t num_elems =
llvm::cast<llvm::FixedVectorType>(result_ty)->getNumElements();
-#else
- size_t num_elems = llvm::cast<llvm::VectorType>(result_ty)->getNumElements();
-#endif
if (intrin_lanes == num_elems) {
return builder_->CreateCall(f, args);
}
@@ -123,11 +105,7 @@ llvm::Value*
CodeGenX86_64::CallVectorIntrin(llvm::Intrinsic::ID id, size_t intr
split_args.push_back(v);
}
}
-#if TVM_LLVM_VERSION >= 110
llvm::Type* type = llvm::FixedVectorType::get(result_ty->getScalarType(),
intrin_lanes);
-#else
- llvm::Type* type = llvm::VectorType::get(result_ty->getScalarType(),
intrin_lanes);
-#endif
split_results.push_back(CallVectorIntrin(id, intrin_lanes, type,
split_args));
}
return CreateVecSlice(CreateVecConcat(split_results), 0, num_elems);
diff --git a/src/target/llvm/llvm_instance.cc b/src/target/llvm/llvm_instance.cc
index 12edafd6f0..48fa1de406 100644
--- a/src/target/llvm/llvm_instance.cc
+++ b/src/target/llvm/llvm_instance.cc
@@ -23,21 +23,13 @@
#include <llvm/ADT/ArrayRef.h>
#include <llvm/ADT/StringRef.h>
-#if TVM_LLVM_VERSION >= 150
#include <llvm/IR/FMF.h>
-#else
-#include <llvm/IR/Operator.h>
-#endif
#include <llvm/IR/LLVMContext.h>
#include <llvm/IR/Metadata.h>
#include <llvm/IR/Module.h>
#include <llvm/IRReader/IRReader.h>
#include <llvm/MC/MCSubtargetInfo.h>
-#if TVM_LLVM_VERSION >= 140
#include <llvm/MC/TargetRegistry.h>
-#else
-#include <llvm/Support/TargetRegistry.h>
-#endif
#include <llvm/Support/CodeGen.h>
#include <llvm/Support/CommandLine.h>
#include <llvm/Support/ErrorOr.h>
@@ -293,7 +285,6 @@ LLVMTargetInfo::LLVMTargetInfo(LLVMInstance& instance,
if (arch == llvm::Triple::riscv32 || arch == llvm::Triple::riscv64) {
// code model
code_model_ = llvm::CodeModel::Medium;
-#if TVM_LLVM_VERSION >= 140
// get VLEN from the LLVM backend (zvlXXXb)
ffi::Map<ffi::String, ffi::String> features = GetAllLLVMCpuFeatures();
// check vector ISA
@@ -312,13 +303,9 @@ LLVMTargetInfo::LLVMTargetInfo(LLVMInstance& instance,
}
}
}
-#endif
}
// Target options
-#if TVM_LLVM_VERSION < 50
- target_options_.LessPreciseFPMADOption = true;
-#endif
// In clang, these are fed from LangOpts which describe language specific
features
// TODO(AndrewZhaoLuo): figure out how these relate to fast math flags
target_options_.AllowFPOpFusion = llvm::FPOpFusion::Fast;
@@ -379,18 +366,11 @@ LLVMTargetInfo::LLVMTargetInfo(LLVMInstance& instance,
}
};
if (GetBoolFlag("fast-math")) {
-#if TVM_LLVM_VERSION >= 60
fast_math_flags_.setFast();
-#else
- fast_math_flags_.setUnsafeAlgebra();
-#endif
} else {
-#if TVM_LLVM_VERSION >= 50
// This option was added in 5.x, and has a boolean argument,
// unlike the rest of options at the time.
fast_math_flags_.setAllowContract(GetBoolFlag("fast-math-contract"));
-#endif
-#if TVM_LLVM_VERSION >= 70
fast_math_flags_.setNoNaNs(GetBoolFlag("fast-math-nnan"));
fast_math_flags_.setNoInfs(GetBoolFlag("fast-math-ninf"));
fast_math_flags_.setNoSignedZeros(GetBoolFlag("fast-math-nsz"));
@@ -398,17 +378,6 @@ LLVMTargetInfo::LLVMTargetInfo(LLVMInstance& instance,
fast_math_flags_.setAllowContract(GetBoolFlag("fast-math-contract"));
fast_math_flags_.setAllowReassoc(GetBoolFlag("fast-math-reassoc"));
fast_math_flags_.setApproxFunc(GetBoolFlag("fast-math-afn"));
-#else
- // LLVM 4.x, 5.x, and 6.x
- if (GetBoolFlag("fast-math-nnan")) fast_math_flags_.setNoNaNs();
- if (GetBoolFlag("fast-math-ninf")) fast_math_flags_.setNoInfs();
- if (GetBoolFlag("fast-math-nsz")) fast_math_flags_.setNoSignedZeros();
- if (GetBoolFlag("fast-math-arcp")) fast_math_flags_.setAllowReciprocal();
-#if TVM_LLVM_VERSION >= 60
- if (GetBoolFlag("fast-math-reassoc")) fast_math_flags_.setAllowReassoc();
- if (GetBoolFlag("fast-math-afn")) fast_math_flags_.setApproxFunc();
-#endif
-#endif
}
}
@@ -511,30 +480,19 @@ std::string LLVMTargetInfo::str() const {
}
bool do_individual = true;
-#if TVM_LLVM_VERSION >= 60
if (fast_math_flags_.isFast()) {
obj.Set(ffi::String("fast-math"), true);
do_individual = false;
}
-#else
- if (fast_math_flags_.unsafeAlgebra()) {
- obj.Set(ffi::String("fast-math"), true);
- do_individual = false;
- }
-#endif
if (do_individual) {
if (fast_math_flags_.noNaNs()) obj.Set(ffi::String("fast-math-nnan"),
true);
if (fast_math_flags_.noInfs()) obj.Set(ffi::String("fast-math-ninf"),
true);
if (fast_math_flags_.noSignedZeros())
obj.Set(ffi::String("fast-math-nsz"), true);
if (fast_math_flags_.allowReciprocal())
obj.Set(ffi::String("fast-math-arcp"), true);
-#if TVM_LLVM_VERSION >= 50
if (fast_math_flags_.allowContract())
obj.Set(ffi::String("fast-math-contract"), true);
-#endif
-#if TVM_LLVM_VERSION >= 60
if (fast_math_flags_.allowReassoc())
obj.Set(ffi::String("fast-math-reassoc"), true);
if (fast_math_flags_.approxFunc()) obj.Set(ffi::String("fast-math-afn"),
true);
-#endif
}
#if TVM_LLVM_VERSION <= 170
diff --git a/src/target/llvm/llvm_instance.h b/src/target/llvm/llvm_instance.h
index 7185475116..9fec366712 100644
--- a/src/target/llvm/llvm_instance.h
+++ b/src/target/llvm/llvm_instance.h
@@ -25,11 +25,7 @@
#ifdef TVM_LLVM_VERSION
#include <llvm/ADT/ArrayRef.h>
-#if TVM_LLVM_VERSION >= 150
#include <llvm/IR/FMF.h>
-#else
-#include <llvm/IR/Operator.h>
-#endif
#include <llvm/Support/CodeGen.h>
#include <llvm/Target/TargetOptions.h>
#include <tvm/ffi/container/array.h>
@@ -51,20 +47,8 @@
#define llvmGetPointerTo(arg, offset) (arg->getPointerTo(offset))
#endif
-#if TVM_LLVM_VERSION >= 130
#define llvmGetIntrinName(id) \
std::string(llvm::Intrinsic::getBaseName(static_cast<llvm::Intrinsic::ID>(id)))
-#elif TVM_LLVM_VERSION >= 40
-// This is the version of Intrinsic::getName that works for overloaded
-// intrinsics. Helpfully, if we provide no types to this function, it
-// will give us the overloaded name without the types appended. This
-// should be enough information for most uses.
-#define llvmGetIntrinName(id) \
- std::string(llvm::Intrinsic::getName(static_cast<llvm::Intrinsic::ID>(id),
{}))
-#else
-// Nothing to do, just return the intrinsic id number
-#define llvmGetIntrinName(id) std::to_string(id)
-#endif
namespace llvm {
class LLVMContext;
diff --git a/src/target/llvm/llvm_module.cc b/src/target/llvm/llvm_module.cc
index 4294c77c7e..ef10daff69 100644
--- a/src/target/llvm/llvm_module.cc
+++ b/src/target/llvm/llvm_module.cc
@@ -201,22 +201,11 @@ ffi::Optional<ffi::Function>
LLVMModuleNode::GetFunction(const ffi::String& name
}
namespace {
-#if TVM_LLVM_VERSION <= 70
-constexpr auto llvm_open_output_flag = llvm::sys::fs::F_None;
-#else
constexpr auto llvm_open_output_flag = llvm::sys::fs::OF_None;
-#endif
-#if TVM_LLVM_VERSION <= 60
-std::unique_ptr<llvm::Module> CloneLLVMModule(llvm::Module* mod) { return
llvm::CloneModule(mod); }
-#else
std::unique_ptr<llvm::Module> CloneLLVMModule(llvm::Module* mod) { return
llvm::CloneModule(*mod); }
-#endif
-#if TVM_LLVM_VERSION <= 90
-constexpr auto llvm_object_file_target = llvm::TargetMachine::CGFT_ObjectFile;
-constexpr auto llvm_assembly_file_target =
llvm::TargetMachine::CGFT_AssemblyFile;
-#elif TVM_LLVM_VERSION <= 170
+#if TVM_LLVM_VERSION <= 170
constexpr auto llvm_object_file_target = llvm::CGFT_ObjectFile;
constexpr auto llvm_assembly_file_target = llvm::CGFT_AssemblyFile;
#else
@@ -227,11 +216,7 @@ constexpr auto llvm_assembly_file_target =
llvm::CodeGenFileType::AssemblyFile;
bool LLVMAddPassesToEmitFile(llvm::TargetMachine* tm,
llvm::legacy::PassManager* pm,
llvm::raw_fd_ostream* dest,
decltype(llvm_object_file_target)
llvm_file_target) {
-#if TVM_LLVM_VERSION <= 60
- return tm->addPassesToEmitFile(*pm, *dest, llvm_file_target);
-#else
return tm->addPassesToEmitFile(*pm, *dest, nullptr, llvm_file_target);
-#endif
}
} // namespace
@@ -261,11 +246,7 @@ void LLVMModuleNode::WriteToFile(const ffi::String&
file_name_str,
} else if (fmt == "ll") {
module_->print(dest, nullptr);
} else if (fmt == "bc") {
-#if TVM_LLVM_VERSION <= 60
- llvm::WriteBitcodeToFile(module_, dest);
-#else
llvm::WriteBitcodeToFile(*module_, dest);
-#endif
} else {
TVM_FFI_THROW(InternalError) << "Do not know how to save file " <<
file_name
<< " with format=\'" << format << "\'";
@@ -285,21 +266,10 @@ ffi::String LLVMModuleNode::InspectSource(const
ffi::String& format) const {
if (fmt == "s" || fmt == "asm") {
With<LLVMTarget> llvm_target(*llvm_instance_,
LLVMTarget::GetTargetMetadata(*module_));
-#if TVM_LLVM_VERSION <= 60
- std::unique_ptr<llvm::Module> m = llvm::CloneModule(module_);
-#else
std::unique_ptr<llvm::Module> m = llvm::CloneModule(*module_);
-#endif
llvm::legacy::PassManager pass;
llvm::TargetMachine* tm = llvm_target->GetOrCreateTargetMachine();
-#if TVM_LLVM_VERSION <= 60
- TVM_FFI_ICHECK(tm->addPassesToEmitFile(pass, rso,
llvm::TargetMachine::CGFT_AssemblyFile) == 0)
- << "Cannot emit target CGFT_AssemblyFile";
-#elif TVM_LLVM_VERSION <= 90
- TVM_FFI_ICHECK(
- tm->addPassesToEmitFile(pass, rso, nullptr,
llvm::TargetMachine::CGFT_AssemblyFile) == 0)
- << "Cannot emit target CGFT_AssemblyFile";
-#elif TVM_LLVM_VERSION <= 170
+#if TVM_LLVM_VERSION <= 170
TVM_FFI_ICHECK(tm->addPassesToEmitFile(pass, rso, nullptr,
llvm::CGFT_AssemblyFile) == 0)
<< "Cannot emit target CGFT_AssemblyFile";
#else
@@ -512,7 +482,6 @@ void LLVMModuleNode::InitORCJIT() {
return std::make_unique<llvm::orc::TMOwningSimpleCompiler>(std::move(tm));
};
-#if TVM_LLVM_VERSION >= 130
// linker
const auto linkerBuilder =
#if TVM_LLVM_VERSION >= 210
@@ -549,17 +518,12 @@ void LLVMModuleNode::InitORCJIT() {
return ObjLinkingLayer;
#endif
}; // NOLINT(readability/braces)
-#endif
// create LLJIT
orcjit_ee_ = llvm::cantFail(llvm::orc::LLJITBuilder()
-#if TVM_LLVM_VERSION >= 110
.setDataLayout(layout)
-#endif
.setCompileFunctionCreator(compilerBuilder)
-#if TVM_LLVM_VERSION >= 130
.setObjectLinkingLayerCreator(linkerBuilder)
-#endif
.create());
TVM_FFI_ICHECK(orcjit_ee_ != nullptr) << "Failed to initialize LLVM ORCJIT
engine for "
@@ -626,11 +590,7 @@ void* LLVMModuleNode::GetGlobalAddr(const std::string&
name, const LLVMTarget& l
if (jit_engine_ == "mcjit") {
return reinterpret_cast<void*>(mcjit_ee_->getGlobalValueAddress(name));
} else if (jit_engine_ == "orcjit") {
-#if TVM_LLVM_VERSION >= 150
auto addr = llvm::cantFail(orcjit_ee_->lookup(name)).getValue();
-#else
- auto addr = llvm::cantFail(orcjit_ee_->lookup(name)).getAddress();
-#endif
return reinterpret_cast<void*>(addr);
} else {
TVM_FFI_THROW(InternalError) << "Either `mcjit` or `orcjit` are not
initialized.";
@@ -646,11 +606,7 @@ void* LLVMModuleNode::GetFunctionAddr(const std::string&
name,
if (jit_engine_ == "mcjit") {
return reinterpret_cast<void*>(mcjit_ee_->getFunctionAddress(name));
} else if (jit_engine_ == "orcjit") {
-#if TVM_LLVM_VERSION >= 150
auto addr = llvm::cantFail(orcjit_ee_->lookup(name)).getValue();
-#else
- auto addr = llvm::cantFail(orcjit_ee_->lookup(name)).getAddress();
-#endif
return reinterpret_cast<void*>(addr);
} else {
TVM_FFI_THROW(InternalError) << "Either `mcjit` or `orcjit` are not
initialized.";
@@ -698,7 +654,6 @@ static void LLVMReflectionRegister() {
[](int64_t id) -> ffi::String { return llvmGetIntrinName(id); })
.def("target.llvm_get_system_x86_vendor",
[]() -> ffi::String {
-#if TVM_LLVM_VERSION >= 120
#if defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) ||
defined(_M_X64)
using namespace llvm::sys::detail::x86;
const auto x86_sign = getVendorSignature();
@@ -708,7 +663,6 @@ static void LLVMReflectionRegister() {
return "amd";
else if (x86_sign == VendorSignatures::UNKNOWN)
return "unknown";
-#endif
#endif
return "unimplemented";
})
diff --git a/tests/cpp/target/canonicalizer/arm_aprofile_test.cc
b/tests/cpp/target/canonicalizer/arm_aprofile_test.cc
index 73c0e6c291..89dd0f7a3b 100644
--- a/tests/cpp/target/canonicalizer/arm_aprofile_test.cc
+++ b/tests/cpp/target/canonicalizer/arm_aprofile_test.cc
@@ -42,7 +42,6 @@ static float optionalDotProd[] = {8.2, 8.3};
static float optionalSME[] = {9.2, 9.3};
static bool CheckArchitectureAvailability() {
-#if TVM_LLVM_VERSION > 120
auto llvm_instance = std::make_unique<codegen::LLVMInstance>();
codegen::LLVMTargetInfo llvm_backend(*llvm_instance, "llvm");
ffi::Array<ffi::String> targets = llvm_backend.GetAllLLVMTargets();
@@ -55,7 +54,6 @@ static bool CheckArchitectureAvailability() {
if (expected_target_count >= 2) {
return true;
}
-#endif
return false;
}
static bool has_aarch64_and_arm_targets = CheckArchitectureAvailability();
diff --git a/tests/cpp/tir_scalable_datatype.cc
b/tests/cpp/tir_scalable_datatype.cc
index f8f453bdbc..19e94e2677 100644
--- a/tests/cpp/tir_scalable_datatype.cc
+++ b/tests/cpp/tir_scalable_datatype.cc
@@ -184,7 +184,6 @@ TEST(ScalableDataType, TestScalableUInt) {
// -----------
// Integration
// -----------
-#if TVM_LLVM_VERSION >= 130
TEST(ScalableDataType, TestScalableIntrinCall) {
tvm::DataType scalable_type = tvm::DataType(kDLInt, 32, 4, true);
tvm::tir::Call call =
@@ -203,7 +202,6 @@ TEST(ScalableDataType, TestScalableIntrinCall) {
"T.call_llvm_intrin(\"int32xvscalex4\",
\"llvm.experimental.stepvector\")");
#endif
}
-#endif
TEST(ScalableDataType, TestTIRScriptScalableDtype2Str) {
tvm::DataType scalable_type = tvm::DataType(kDLInt, 32, 4, true);
