parent c7393ad author Steven Johnson <srj@google.com> 1594836928 -070…

…0 committer Steven Johnson <srj@google.com> 1594925723 -0700

Drop support for LLVM9

Since LLVM trunk just got bumped to v12, we can consider dropping LLVM9 support. This PR revises the checks for minimum versions to require v10, and removes all conditional code that is no longer required.

.github/workflows/llvm_builder.yml

@@ -34,10 +34,8 @@ jobs:
         target_arch: [x86, arm]
         target_bits: [32, 64]
         target_os: [windows, linux, osx]
-        llvm_version: [9, 10, 11, 12]
+        llvm_version: [10, 11, 12]
         include:
-          - llvm_version: 9
-            llvm_branch: release/9.x
           - llvm_version: 10
             llvm_branch: release/10.x
           - llvm_version: 11

.github/workflows/test.yml

@@ -58,15 +58,13 @@ jobs:
         target_os: [linux, osx, windows]
         llvm_version: [12]
         build_tool: [cmake_shared]
-        # llvm_version: [9, 10, 11, 12]  # TODO
+        # llvm_version: [10, 11, 12]  # TODO
         # build_tool: [cmake_shared, make]  # TODO
 
         # This section basically allows us to define additional values for
         # each matrix entry, e.g. to map an llvm version number to the specific
         # git branch that is needed.
         include:
-          # - llvm_version: 9
-          #   llvm_branch: release/9.x
           # - llvm_version: 10
           #   llvm_branch: release/10.x
           # - llvm_version: 11

Makefile

@@ -2164,7 +2164,7 @@ $(BUILD_DIR)/clang_ok:
 	@exit 1
 endif
 
-ifneq (,$(findstring $(LLVM_VERSION_TIMES_10), 90 100 110 120))
+ifneq (,$(findstring $(LLVM_VERSION_TIMES_10), 100 110 120))
 LLVM_OK=yes
 endif
 

dependencies/llvm/CMakeLists.txt

@@ -6,8 +6,8 @@ find_package(LLVM ${HALIDE_REQUIRE_LLVM_VERSION} REQUIRED)
 message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
 message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
 
-if ("${LLVM_PACKAGE_VERSION}" VERSION_LESS 9.0)
-    message(FATAL_ERROR "LLVM version must be 9.0 or newer")
+if ("${LLVM_PACKAGE_VERSION}" VERSION_LESS 10.0)
+    message(FATAL_ERROR "LLVM version must be 10.0 or newer")
 endif ()
 
 if ("${LLVM_PACKAGE_VERSION}" VERSION_GREATER 12.0)

src/CodeGen_ARM.cpp

@@ -114,23 +114,13 @@ CodeGen_ARM::CodeGen_ARM(Target target)
         casts.push_back(p);
 
         // Saturating add
-#if LLVM_VERSION >= 100
         if (t.is_int()) {
             p.intrin32 = "llvm.sadd.sat" + t_str;
             p.intrin64 = "llvm.sadd.sat" + t_str;
         } else {
             p.intrin32 = "llvm.uadd.sat" + t_str;
             p.intrin64 = "llvm.uadd.sat" + t_str;
         }
-#else
-        if (t.is_int()) {
-            p.intrin32 = "llvm.arm.neon.vqadds" + t_str;
-            p.intrin64 = "llvm.aarch64.neon.sqadd" + t_str;
-        } else {
-            p.intrin32 = "llvm.arm.neon.vqaddu" + t_str;
-            p.intrin64 = "llvm.aarch64.neon.uqadd" + t_str;
-        }
-#endif
         p.pattern = cast(t, clamp(w_vector + w_vector, tmin, tmax));
         casts.push_back(p);
 
@@ -142,23 +132,13 @@ CodeGen_ARM::CodeGen_ARM(Target target)
 
         // Saturating subtract
         // N.B. Saturating subtracts always widen to a signed type
-#if LLVM_VERSION >= 100
         if (t.is_int()) {
             p.intrin32 = "llvm.ssub.sat" + t_str;
             p.intrin64 = "llvm.ssub.sat" + t_str;
         } else {
             p.intrin32 = "llvm.usub.sat" + t_str;
             p.intrin64 = "llvm.usub.sat" + t_str;
         }
-#else
-        if (t.is_int()) {
-            p.intrin32 = "llvm.arm.neon.vqsubs" + t_str;
-            p.intrin64 = "llvm.aarch64.neon.sqsub" + t_str;
-        } else {
-            p.intrin32 = "llvm.arm.neon.vqsubu" + t_str;
-            p.intrin64 = "llvm.aarch64.neon.uqsub" + t_str;
-        }
-#endif
         p.pattern = cast(t, clamp(ws_vector - ws_vector, tsmin, tsmax));
         casts.push_back(p);
 
@@ -947,10 +927,8 @@ void CodeGen_ARM::visit(const Load *op) {
             LoadInst *loadI = cast<LoadInst>(builder->CreateLoad(bitcastI));
 #if LLVM_VERSION >= 110
             loadI->setAlignment(Align(alignment));
-#elif LLVM_VERSION >= 100
-            loadI->setAlignment(MaybeAlign(alignment));
 #else
-            loadI->setAlignment(alignment);
+            loadI->setAlignment(MaybeAlign(alignment));
 #endif
             add_tbaa_metadata(loadI, op->name, slice_ramp);
             Value *shuffleInstr = builder->CreateShuffleVector(loadI, undef, constantsV);
@@ -1025,7 +1003,6 @@ void CodeGen_ARM::visit(const Call *op) {
 }
 
 void CodeGen_ARM::visit(const LT *op) {
-#if LLVM_VERSION >= 100
     if (op->a.type().is_float() && op->type.is_vector()) {
         // Fast-math flags confuse LLVM's aarch64 backend, so
         // temporarily clear them for this instruction.
@@ -1035,13 +1012,11 @@ void CodeGen_ARM::visit(const LT *op) {
         CodeGen_Posix::visit(op);
         return;
     }
-#endif
 
     CodeGen_Posix::visit(op);
 }
 
 void CodeGen_ARM::visit(const LE *op) {
-#if LLVM_VERSION >= 100
     if (op->a.type().is_float() && op->type.is_vector()) {
         // Fast-math flags confuse LLVM's aarch64 backend, so
         // temporarily clear them for this instruction.
@@ -1051,7 +1026,6 @@ void CodeGen_ARM::visit(const LE *op) {
         CodeGen_Posix::visit(op);
         return;
     }
-#endif
 
     CodeGen_Posix::visit(op);
 }
@@ -1060,10 +1034,7 @@ void CodeGen_ARM::codegen_vector_reduce(const VectorReduce *op, const Expr &init
     if (neon_intrinsics_disabled() ||
         op->op == VectorReduce::Or ||
         op->op == VectorReduce::And ||
-        op->op == VectorReduce::Mul ||
-        // LLVM 9 has bugs in the arm backend for vector reduce
-        // ops. See https://github.com/halide/Halide/issues/5081
-        !(LLVM_VERSION >= 100)) {
+        op->op == VectorReduce::Mul) {
         CodeGen_Posix::codegen_vector_reduce(op, init);
         return;
     }

src/CodeGen_LLVM.cpp

@@ -170,15 +170,9 @@ llvm::GlobalValue::LinkageTypes llvm_linkage(LinkageType t) {
 // A local helper to make an llvm value type representing
 // alignment. Can't be declared in a header without introducing a
 // dependence on the LLVM headers.
-#if LLVM_VERSION >= 100
 llvm::Align make_alignment(int a) {
     return llvm::Align(a);
 }
-#else
-int make_alignment(int a) {
-    return a;
-}
-#endif
 
 }  // namespace
 
@@ -4347,9 +4341,7 @@ void CodeGen_LLVM::codegen_vector_reduce(const VectorReduce *op, const Expr &ini
         return;
     }
 
-#if LLVM_VERSION >= 90
-    if (output_lanes == 1 &&
-        (target.arch != Target::ARM || LLVM_VERSION >= 100)) {
+    if (output_lanes == 1) {
         const int input_lanes = val.type().lanes();
         const int input_bytes = input_lanes * val.type().bytes();
         const bool llvm_has_intrinsic =
@@ -4449,7 +4441,6 @@ void CodeGen_LLVM::codegen_vector_reduce(const VectorReduce *op, const Expr &ini
             return;
         }
     }
-#endif
 
     if (output_lanes == 1 &&
         factor > native_lanes &&

src/CodeGen_PTX_Dev.cpp

@@ -277,39 +277,6 @@ void CodeGen_PTX_Dev::visit(const Store *op) {
     if (emit_atomic_stores) {
         user_assert(is_one(op->predicate)) << "Atomic update does not support predicated store.\n";
         user_assert(op->value.type().bits() >= 32) << "CUDA: 8-bit or 16-bit atomics are not supported.\n";
-#if LLVM_VERSION < 90
-        user_assert(op->value.type().is_scalar())
-            << "CUDA atomic update does not support vectorization with LLVM version < 9.\n";
-        // Generate nvvm intrinsics for the atomics if this is a float atomicAdd.
-        // Otherwise defer to the llvm codegen. For llvm version >= 90, atomicrmw support floats so we
-        // can also refer to llvm.
-        // Half atomics are supported by compute capability 7.x or higher.
-        if (op->value.type().is_float() &&
-            (op->value.type().bits() == 32 ||
-             (op->value.type().bits() == 64 &&
-              target.has_feature(Target::CUDACapability61)))) {
-            Expr val_expr = op->value;
-            Expr equiv_load = Load::make(op->value.type(), op->name, op->index, Buffer<>(), op->param, op->predicate, op->alignment);
-            Expr delta = simplify(common_subexpression_elimination(op->value - equiv_load));
-            // For atomicAdd, we check if op->value - store[index] is independent of store.
-            bool is_atomic_add = !expr_uses_var(delta, op->name);
-            if (is_atomic_add) {
-                Value *ptr = codegen_buffer_pointer(op->name, op->value.type(), op->index);
-                Value *val = codegen(delta);
-                llvm::Function *intrin = nullptr;
-                if (op->value.type().bits() == 32) {
-                    intrin = module->getFunction("llvm.nvvm.atomic.load.add.f32.p0f32");
-                    internal_assert(intrin) << "Could not find atomic intrinsics llvm.nvvm.atomic.load.add.f32.p0f32\n";
-                } else {
-                    internal_assert(op->value.type().bits() == 64);
-                    intrin = module->getFunction("llvm.nvvm.atomic.load.add.f64.p0f64");
-                    internal_assert(intrin) << "Could not find atomic intrinsics llvm.nvvm.atomic.load.add.f64.p0f64\n";
-                }
-                value = builder->CreateCall(intrin, {ptr, val});
-                return;
-            }
-        }
-#endif
     }
 
     // Do aligned 4-wide 32-bit stores as a single i128 store.
@@ -640,11 +607,7 @@ vector<char> CodeGen_PTX_Dev::compile_to_src() {
 
     // Ask the target to add backend passes as necessary.
     bool fail = target_machine->addPassesToEmitFile(module_pass_manager, ostream, nullptr,
-#if LLVM_VERSION >= 100
                                                     ::llvm::CGFT_AssemblyFile,
-#else
-                                                    TargetMachine::CGFT_AssemblyFile,
-#endif
                                                     true);
     if (fail) {
         internal_error << "Failed to set up passes to emit PTX source\n";

src/Introspection.cpp

@@ -49,11 +49,7 @@ inline T load_misaligned(const T *p) {
     return result;
 }
 
-#if LLVM_VERSION >= 100
 typedef uint64_t llvm_offset_t;
-#else
-typedef uint32_t llvm_offset_t;
-#endif
 
 }  // namespace
 
@@ -959,14 +955,9 @@ class DebugSections {
 
         for (llvm::object::section_iterator iter = obj->section_begin();
              iter != obj->section_end(); ++iter) {
-#if LLVM_VERSION >= 100
             auto expected_name = iter->getName();
             internal_assert(expected_name);
             llvm::StringRef name = expected_name.get();
-#else
-            llvm::StringRef name;
-            iter->getName(name);
-#endif
             debug(2) << "Section: " << name.str() << "\n";
             // ignore errors, just leave strings empty
             auto e = iter->getContents();

src/LLVM_Headers.h

@@ -1,10 +1,10 @@
 #ifndef HALIDE_LLVM_HEADERS_H
 #define HALIDE_LLVM_HEADERS_H
 
-#if LLVM_VERSION >= 90
+#if LLVM_VERSION >= 100
 // We're good to go
 #else
-#error "Compiling Halide requires LLVM 9.0 or newer"
+#error "Compiling Halide requires LLVM 10.0 or newer"
 #endif
 
 // This seems to be required by some LLVM header, which is likely an LLVM bug.
@@ -29,25 +29,23 @@
 #include <llvm/ExecutionEngine/MCJIT.h>
 #include <llvm/ExecutionEngine/SectionMemoryManager.h>
 
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorHandling.h"
+#include <llvm/ADT/StringMap.h>
 #include <llvm/Analysis/TargetLibraryInfo.h>
 #include <llvm/Bitcode/BitcodeReader.h>
 #include <llvm/Bitcode/BitcodeWriter.h>
 #include <llvm/ExecutionEngine/ExecutionEngine.h>
 #include <llvm/IR/LegacyPassManager.h>
+#include <llvm/IR/PassTimingInfo.h>
 #include <llvm/IR/Verifier.h>
 #include <llvm/Linker/Linker.h>
-#include <llvm/Passes/PassBuilder.h>
-#if LLVM_VERSION >= 100
-#include <llvm/Support/CodeGen.h>
-#endif
-#include "llvm/ADT/APFloat.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include <llvm/ADT/StringMap.h>
-#include <llvm/IR/PassTimingInfo.h>
 #include <llvm/Object/ArchiveWriter.h>
 #include <llvm/Object/ObjectFile.h>
+#include <llvm/Passes/PassBuilder.h>
+#include <llvm/Support/CodeGen.h>
 #include <llvm/Support/DataExtractor.h>
 #include <llvm/Support/DynamicLibrary.h>
 #include <llvm/Support/FileSystem.h>
@@ -75,11 +73,9 @@
 #include <llvm/IR/Function.h>
 #include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/Intrinsics.h>
-#if LLVM_VERSION >= 100
 #ifdef WITH_HEXAGON
 #include <llvm/IR/IntrinsicsHexagon.h>
 #endif
-#endif
 #include <llvm/IR/MDBuilder.h>
 #include <llvm/IR/Module.h>
 #include <llvm/IR/Value.h>

src/LLVM_Output.cpp

@@ -337,12 +337,7 @@ std::unique_ptr<llvm::Module> clone_module(const llvm::Module &module_in) {
 }  // namespace
 
 void emit_file(const llvm::Module &module_in, Internal::LLVMOStream &out,
-#if LLVM_VERSION >= 100
-               llvm::CodeGenFileType file_type
-#else
-               llvm::TargetMachine::CodeGenFileType file_type
-#endif
-) {
+               llvm::CodeGenFileType file_type) {
     Internal::debug(1) << "emit_file.Compiling to native code...\n";
     Internal::debug(2) << "Target triple: " << module_in.getTargetTriple() << "\n";
 
@@ -403,19 +398,11 @@ std::unique_ptr<llvm::Module> compile_module_to_llvm_module(const Module &module
 }
 
 void compile_llvm_module_to_object(llvm::Module &module, Internal::LLVMOStream &out) {
-#if LLVM_VERSION >= 100
     emit_file(module, out, llvm::CGFT_ObjectFile);
-#else
-    emit_file(module, out, llvm::TargetMachine::CGFT_ObjectFile);
-#endif
 }
 
 void compile_llvm_module_to_assembly(llvm::Module &module, Internal::LLVMOStream &out) {
-#if LLVM_VERSION >= 100
     emit_file(module, out, llvm::CGFT_AssemblyFile);
-#else
-    emit_file(module, out, llvm::TargetMachine::CGFT_AssemblyFile);
-#endif
 }
 
 void compile_llvm_module_to_llvm_bitcode(llvm::Module &module, Internal::LLVMOStream &out) {