Update Halide main branch to v16 (halide#7093)

* Update Halide main branch to v16

* Drop support for LLVM13 in main

Now that release/15.x has branched, main is now Halide 16 and no longer needs to support LLVM13. Update the docs, prune the requirements, eliminate old special cases we don't need anymore.

* Revert mistaken changes

* Update LLVM_Headers.h

Author: steven-johnson

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.22...3.23)
 project(Halide
-        VERSION 15.0.0
+        VERSION 16.0.0
         DESCRIPTION "Halide compiler and libraries"
         HOMEPAGE_URL "https://halide-lang.org")
 

Makefile

@@ -1097,25 +1097,9 @@ $(BUILD_DIR)/initmod.%_32_debug.ll: $(SRC_DIR)/runtime/%.cpp $(BUILD_DIR)/clang_
 	@mkdir -p $(@D)
 	$(CLANG) $(CXX_WARNING_FLAGS) -g -DDEBUG_RUNTIME -O3 $(RUNTIME_CXX_FLAGS) -fpic -m32 -target $(RUNTIME_TRIPLE_32) -DCOMPILING_HALIDE_RUNTIME -DBITS_32 -emit-llvm -S $(SRC_DIR)/runtime/$*.cpp -o $@ -MMD -MP -MF $(BUILD_DIR)/initmod.$*_32_debug.d
 
-ifneq (,$(findstring $(LLVM_VERSION_TIMES_10), 130))
-# For LLVM14+, we must add elementtype() annotations to some of our LLVM IR;
-# earlier versions either don't understand that keyword at all, or don't support
-# the uses we have for it. Rather than forking these sources, for now we'll just
-# edit the files at build time to remove the offending uses. Note that while we could use `sed`
-# here, that isn't an option for CMake builds (since they must support Windows environments without
-# such tooling); to ensure consistent transformations in all builds, we'll use the tool here, too.
-#
-# (This may well need attention in the future, depending on how the LLVM opaque-pointers work proceeeds;
-# see https://llvm.org/docs/OpaquePointers.html)
-$(BUILD_DIR)/initmod.%_ll.ll: $(SRC_DIR)/runtime/%.ll $(BIN_DIR)/regexp_replace
-	@mkdir -p $(@D)
-	$(BIN_DIR)/regexp_replace 'elementtype\(i[0-9]+\)' '' < $(SRC_DIR)/runtime/$*.ll > $(BUILD_DIR)/initmod.$*_ll.ll
-else
 $(BUILD_DIR)/initmod.%_ll.ll: $(SRC_DIR)/runtime/%.ll
 	@mkdir -p $(@D)
 	cp $(SRC_DIR)/runtime/$*.ll $(BUILD_DIR)/initmod.$*_ll.ll
-endif
-
 
 $(BUILD_DIR)/initmod.%.bc: $(BUILD_DIR)/initmod.%.ll $(BUILD_DIR)/llvm_ok
 	$(LLVM_AS) $(BUILD_DIR)/initmod.$*.ll -o $(BUILD_DIR)/initmod.$*.bc
@@ -2222,7 +2206,7 @@ $(BUILD_DIR)/clang_ok:
 	@exit 1
 endif
 
-ifneq (,$(findstring $(LLVM_VERSION_TIMES_10), 130 140 150 160))
+ifneq (,$(findstring $(LLVM_VERSION_TIMES_10), 140 150 160))
 LLVM_OK=yes
 endif
 

README.md

@@ -116,7 +116,7 @@ the repository (where this README is).
 
 At any point in time, building Halide requires either the latest stable version
 of LLVM, the previous stable version of LLVM, and trunk. At the time of writing,
-this means versions 15, 14 and 13 are supported, but 12 is not. The commands
+this means versions 16, 15, and 14 are supported, but 13 is not. The commands
 `llvm-config` and `clang` must be somewhere in the path.
 
 If your OS does not have packages for LLVM, you can find binaries for it at

dependencies/llvm/CMakeLists.txt

@@ -20,8 +20,8 @@ message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
 message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
 message(STATUS "Using ClangConfig.cmake in: ${Clang_DIR}")
 
-if (LLVM_PACKAGE_VERSION VERSION_LESS 13.0)
-    message(FATAL_ERROR "LLVM version must be 13.0 or newer")
+if (LLVM_PACKAGE_VERSION VERSION_LESS 14.0)
+    message(FATAL_ERROR "LLVM version must be 14.0 or newer")
 endif ()
 
 if (LLVM_PACKAGE_VERSION VERSION_GREATER 16.0)

src/CodeGen_LLVM.cpp

@@ -1128,13 +1128,6 @@ void CodeGen_LLVM::optimize_module() {
     llvm::CGSCCAnalysisManager cgam;
     llvm::ModuleAnalysisManager mam;
 
-#if LLVM_VERSION < 140
-    // If building against LLVM older than 14, explicitly specify AA pipeline.
-    // Not needed with LLVM14 or later, already the default.
-    llvm::AAManager aa = pb.buildDefaultAAPipeline();
-    fam.registerPass([&] { return std::move(aa); });
-#endif
-
     // Register all the basic analyses with the managers.
     pb.registerModuleAnalyses(mam);
     pb.registerCGSCCAnalyses(cgam);
@@ -1143,12 +1136,7 @@ void CodeGen_LLVM::optimize_module() {
     pb.crossRegisterProxies(lam, fam, cgam, mam);
     ModulePassManager mpm;
 
-#if LLVM_VERSION >= 140
     using OptimizationLevel = llvm::OptimizationLevel;
-#else
-    using OptimizationLevel = PassBuilder::OptimizationLevel;
-#endif
-
     OptimizationLevel level = OptimizationLevel::O3;
 
     if (get_target().has_feature(Target::SanitizerCoverage)) {
@@ -1183,7 +1171,6 @@ void CodeGen_LLVM::optimize_module() {
         });
 #endif
         pb.registerPipelineStartEPCallback([](ModulePassManager &mpm, OptimizationLevel) {
-#if LLVM_VERSION >= 140
             AddressSanitizerOptions asan_options;  // default values are good...
             asan_options.UseAfterScope = true;     // ...except this one
             constexpr bool use_global_gc = false;
@@ -1195,14 +1182,6 @@ void CodeGen_LLVM::optimize_module() {
 #else
             mpm.addPass(ModuleAddressSanitizerPass(
                 asan_options, use_global_gc, use_odr_indicator, destructor_kind));
-#endif
-#else
-            constexpr bool compile_kernel = false;
-            constexpr bool recover = false;
-            constexpr bool module_use_global_gc = false;
-            constexpr bool use_odr_indicator = true;
-            mpm.addPass(ModuleAddressSanitizerPass(
-                compile_kernel, recover, module_use_global_gc, use_odr_indicator));
 #endif
         });
     }

src/CodeGen_PTX_Dev.cpp

@@ -700,12 +700,7 @@ vector<char> CodeGen_PTX_Dev::compile_to_src() {
     pb.crossRegisterProxies(lam, fam, cgam, mam);
     ModulePassManager mpm;
 
-#if LLVM_VERSION >= 140
     using OptimizationLevel = llvm::OptimizationLevel;
-#else
-    using OptimizationLevel = PassBuilder::OptimizationLevel;
-#endif
-
     OptimizationLevel level = OptimizationLevel::O3;
 
     target_machine->registerPassBuilderCallbacks(pb);

src/CodeGen_WebAssembly.cpp

@@ -71,10 +71,6 @@ const WasmIntrinsic intrinsic_defs[] = {
     {"llvm.wasm.avgr.unsigned.v16i8", UInt(8, 16), "rounding_halving_add", {UInt(8, 16), UInt(8, 16)}, Target::WasmSimd128},
     {"llvm.wasm.avgr.unsigned.v8i16", UInt(16, 8), "rounding_halving_add", {UInt(16, 8), UInt(16, 8)}, Target::WasmSimd128},
 
-#if LLVM_VERSION == 130
-    {"float_to_double", Float(64, 4), "float_to_double", {Float(32, 4)}, Target::WasmSimd128},
-#endif
-
     // With some work, some of these could possibly be adapted to work under earlier versions of LLVM.
     {"widening_mul_i8x16", Int(16, 16), "widening_mul", {Int(8, 16), Int(8, 16)}, Target::WasmSimd128},
     {"widening_mul_i16x8", Int(32, 8), "widening_mul", {Int(16, 8), Int(16, 8)}, Target::WasmSimd128},
@@ -155,9 +151,6 @@ void CodeGen_WebAssembly::visit(const Cast *op) {
     static const Pattern patterns[] = {
         {"int_to_double", f64(wild_i32x_), Target::WasmSimd128},
         {"int_to_double", f64(wild_u32x_), Target::WasmSimd128},
-#if LLVM_VERSION == 130
-        {"float_to_double", f64(wild_f32x_), Target::WasmSimd128},
-#endif
         {"widen_integer", i16(wild_i8x_), Target::WasmSimd128},
         {"widen_integer", u16(wild_u8x_), Target::WasmSimd128},
         {"widen_integer", i32(wild_i16x_), Target::WasmSimd128},

src/LLVM_Headers.h

@@ -1,10 +1,10 @@
 #ifndef HALIDE_LLVM_HEADERS_H
 #define HALIDE_LLVM_HEADERS_H
 
-#if LLVM_VERSION >= 130
+#if LLVM_VERSION >= 140
 // We're good to go
 #else
-#error "Compiling Halide requires LLVM 13.0 or newer"
+#error "Compiling Halide requires LLVM 14.0 or newer"
 #endif
 
 // No msvc warnings from llvm headers please
@@ -62,6 +62,7 @@
 #include <llvm/IR/Verifier.h>
 #include <llvm/Linker/Linker.h>
 #include <llvm/MC/MCTargetOptions.h>
+#include <llvm/MC/TargetRegistry.h>
 #include <llvm/Object/ArchiveWriter.h>
 #include <llvm/Object/ObjectFile.h>
 #include <llvm/Passes/PassBuilder.h>
@@ -73,11 +74,6 @@
 #include <llvm/Support/ErrorHandling.h>
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/FormattedStream.h>
-#if LLVM_VERSION >= 140
-#include <llvm/MC/TargetRegistry.h>
-#else
-#include <llvm/Support/TargetRegistry.h>
-#endif
 #include <llvm/Support/TargetSelect.h>
 #include <llvm/Support/TypeSize.h>
 #include <llvm/Support/raw_os_ostream.h>

src/LLVM_Runtime_Linker.cpp

@@ -294,20 +294,12 @@ llvm::DataLayout get_data_layout_for_target(Target target) {
             } else if (target.os == Target::IOS) {
                 return llvm::DataLayout("e-m:o-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:128-n8:16:32-S128");
             } else if (target.os == Target::Windows) {
-#if LLVM_VERSION >= 140
                 // For 32-bit MSVC targets, alignment of f80 values is 16 bytes (see https://reviews.llvm.org/D115942)
                 if (!target.has_feature(Target::JIT)) {
                     return llvm::DataLayout("e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32-a:0:32-S32");
                 } else {
                     return llvm::DataLayout("e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32-a:0:32-S32");
                 }
-#else
-                if (!target.has_feature(Target::JIT)) {
-                    return llvm::DataLayout("e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:32-n8:16:32-a:0:32-S32");
-                } else {
-                    return llvm::DataLayout("e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:32-n8:16:32-a:0:32-S32");
-                }
-#endif
             } else {
                 // Linux/Android
                 return llvm::DataLayout("e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128");
@@ -360,19 +352,11 @@ llvm::DataLayout get_data_layout_for_target(Target target) {
             "e-m:e-p:32:32:32-a:0-n16:32-i64:64:64-i32:32:32-i16:16:16-i1:8:8"
             "-f32:32:32-f64:64:64-v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048");
     } else if (target.arch == Target::WebAssembly) {
-#if LLVM_VERSION >= 140
         if (target.bits == 32) {
             return llvm::DataLayout("e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20");
         } else {
             return llvm::DataLayout("e-m:e-p:64:64-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20");
         }
-#else
-        if (target.bits == 32) {
-            return llvm::DataLayout("e-m:e-p:32:32-i64:64-n32:64-S128");
-        } else {
-            return llvm::DataLayout("e-m:e-p:64:64-i64:64-n32:64-S128");
-        }
-#endif
     } else if (target.arch == Target::RISCV) {
         // TODO: Valdidate this data layout is correct for RISCV. Assumption is it is like MIPS.
         if (target.bits == 32) {

src/WasmExecutor.cpp

@@ -360,17 +360,10 @@ std::vector<char> compile_to_wasm(const Module &module, const std::string &fn_na
     // Note that we must restore it before using internal_error (and also on the non-error path).
     auto old_abort_handler = std::signal(SIGABRT, SIG_DFL);
 
-#if LLVM_VERSION >= 140
     if (!lld::wasm::link(lld_args, llvm::outs(), llvm::errs(), /*canExitEarly*/ false, /*disableOutput*/ false)) {
         std::signal(SIGABRT, old_abort_handler);
         internal_error << "lld::wasm::link failed\n";
     }
-#else
-    if (!lld::wasm::link(lld_args, /*CanExitEarly*/ false, llvm::outs(), llvm::errs())) {
-        std::signal(SIGABRT, old_abort_handler);
-        internal_error << "lld::wasm::link failed\n";
-    }
-#endif
 
     std::signal(SIGABRT, old_abort_handler);
 

src/runtime/CMakeLists.txt

@@ -270,28 +270,11 @@ foreach (i IN LISTS RUNTIME_LL)
     set(BC "initmod.${i}.bc")
     set(INITMOD "_initmod_${i}.cpp")
 
-    # For LLVM14+, we must add elementtype() annotations to some of our LLVM IR;
-    # earlier versions either don't understand that keyword at all, or don't support
-    # the uses we have for it. Rather than forking these sources, for now we'll just
-    # edit the files at build time to remove the offending uses. Note that `sed` and friends aren't
-    # an option for CMake builds (since they must support Windows environments without
-    # such tooling).
-    #
-    # (This may well need attention in the future, depending on how the LLVM opaque-pointers work proceeeds;
-    # see https://llvm.org/docs/OpaquePointers.html)
-
     set(LL_TRANSFORMED "${LL}.transformed.ll")
-    if (LLVM_PACKAGE_VERSION VERSION_LESS 14.0.0)
-        add_custom_command(OUTPUT "${LL_TRANSFORMED}"
-                           COMMAND regexp_replace "elementtype\\(i[0-9]+\\)" "" < "$<SHELL_PATH:${CMAKE_CURRENT_SOURCE_DIR}/${LL}>" > "${LL_TRANSFORMED}"
-                           DEPENDS "${LL}" regexp_replace
-                           VERBATIM)
-    else ()
-        add_custom_command(OUTPUT "${LL_TRANSFORMED}"
-                           COMMAND ${CMAKE_COMMAND} -E copy "$<SHELL_PATH:${CMAKE_CURRENT_SOURCE_DIR}/${LL}>" "${LL_TRANSFORMED}"
-                           DEPENDS "${LL}"
-                           VERBATIM)
-    endif ()
+    add_custom_command(OUTPUT "${LL_TRANSFORMED}"
+                       COMMAND ${CMAKE_COMMAND} -E copy "$<SHELL_PATH:${CMAKE_CURRENT_SOURCE_DIR}/${LL}>" "${LL_TRANSFORMED}"
+                       DEPENDS "${LL}"
+                       VERBATIM)
 
     add_custom_command(OUTPUT "${BC}"
                        COMMAND llvm-as "${LL_TRANSFORMED}" -o "${BC}"

src/runtime/wasm_math.ll

@@ -234,12 +234,6 @@ define weak_odr <8 x i16> @saturating_narrow_i32x8_to_u16x8(<8 x i32> %x) nounwi
   ret <8 x i16> %3
 }
 
-; single to double-precision floating point (only needed for LLVM_VERSION == 13)
-define weak_odr <4 x double> @float_to_double(<4 x float> %x) nounwind alwaysinline {
-  %1 = fpext <4 x float> %x to <4 x double>
-  ret <4 x double> %1
-}
-
 ; Integer to integer extension
 
 ; i8 -> i16

test/correctness/simd_op_check.cpp

@@ -996,7 +996,7 @@ class SimdOpCheck : public SimdOpCheckTest {
             check(arm32 ? "vmovl.u32" : "ushll", 2 * w, i64(u32_1));
 
             // VMOVN    I       -       Move and Narrow
-            if (Halide::Internal::get_llvm_version() >= 140 && w > 1) {
+            if (w > 1) {
                 check(arm32 ? "vmovn.i16" : "uzp1", 8 * w, i8(i16_1));
                 check(arm32 ? "vmovn.i16" : "uzp1", 8 * w, u8(u16_1));
                 check(arm32 ? "vmovn.i32" : "uzp1", 4 * w, i16(i32_1));
@@ -1389,23 +1389,14 @@ class SimdOpCheck : public SimdOpCheckTest {
             check(arm32 ? "vrshr.u32" : "urshr", 4 * w, u32((u64(u32_1) + 32) >> 6));
 
             // VRSHRN   I       -       Rounding Shift Right Narrow
-            if (Halide::Internal::get_llvm_version() >= 140) {
-                // LLVM14 converts RSHRN/RSHRN2 to RADDHN/RADDHN2 when the shift amount is half the width of the vector element
-                // See https://reviews.llvm.org/D116166
-                check(arm32 ? "vrshrn.i16" : "raddhn", 8 * w, i8((i32(i16_1) + 128) >> 8));
-                check(arm32 ? "vrshrn.i32" : "rshrn", 4 * w, i16((i32_1 + 256) >> 9));
-                check(arm32 ? "vrshrn.i64" : "rshrn", 2 * w, i32((i64_1 + 8) >> 4));
-                check(arm32 ? "vrshrn.i16" : "raddhn", 8 * w, u8((u32(u16_1) + 128) >> 8));
-                check(arm32 ? "vrshrn.i32" : "rshrn", 4 * w, u16((u64(u32_1) + 1024) >> 11));
-                // check(arm32 ? "vrshrn.i64" : "raddhn", 2 * w, u32((u64_1 + 64) >> 7));
-            } else {
-                check(arm32 ? "vrshrn.i16" : "rshrn", 8 * w, i8((i32(i16_1) + 128) >> 8));
-                check(arm32 ? "vrshrn.i32" : "rshrn", 4 * w, i16((i32_1 + 256) >> 9));
-                check(arm32 ? "vrshrn.i64" : "rshrn", 2 * w, i32((i64_1 + 8) >> 4));
-                check(arm32 ? "vrshrn.i16" : "rshrn", 8 * w, u8((u32(u16_1) + 128) >> 8));
-                check(arm32 ? "vrshrn.i32" : "rshrn", 4 * w, u16((u64(u32_1) + 1024) >> 11));
-                // check(arm32 ? "vrshrn.i64" : "rshrn", 2 * w, u32((u64_1 + 64) >> 7));
-            }
+            // LLVM14 converts RSHRN/RSHRN2 to RADDHN/RADDHN2 when the shift amount is half the width of the vector element
+            // See https://reviews.llvm.org/D116166
+            check(arm32 ? "vrshrn.i16" : "raddhn", 8 * w, i8((i32(i16_1) + 128) >> 8));
+            check(arm32 ? "vrshrn.i32" : "rshrn", 4 * w, i16((i32_1 + 256) >> 9));
+            check(arm32 ? "vrshrn.i64" : "rshrn", 2 * w, i32((i64_1 + 8) >> 4));
+            check(arm32 ? "vrshrn.i16" : "raddhn", 8 * w, u8((u32(u16_1) + 128) >> 8));
+            check(arm32 ? "vrshrn.i32" : "rshrn", 4 * w, u16((u64(u32_1) + 1024) >> 11));
+            // check(arm32 ? "vrshrn.i64" : "raddhn", 2 * w, u32((u64_1 + 64) >> 7));
 
             // VRSQRTE  I, F    -       Reciprocal Square Root Estimate
             check(arm32 ? "vrsqrte.f32" : "frsqrte", 4 * w, fast_inverse_sqrt(f32_1));
@@ -2223,10 +2214,8 @@ class SimdOpCheck : public SimdOpCheckTest {
                 check("f32x4.convert_i32x4_u", 8 * w, cast<float>(u32_1));
 
                 // Integer to double-precision floating point
-                if (Halide::Internal::get_llvm_version() >= 140) {
-                    check("f64x2.convert_low_i32x4_s", 2 * w, cast<double>(i32_1));
-                    check("f64x2.convert_low_i32x4_u", 2 * w, cast<double>(u32_1));
-                }
+                check("f64x2.convert_low_i32x4_s", 2 * w, cast<double>(i32_1));
+                check("f64x2.convert_low_i32x4_u", 2 * w, cast<double>(u32_1));
 
                 // Single-precision floating point to integer with saturation
                 check("i32x4.trunc_sat_f32x4_s", 4 * w, cast<int32_t>(f32_1));
@@ -2242,12 +2231,8 @@ class SimdOpCheck : public SimdOpCheckTest {
                 // check("f32x4.demote_f64x2_zero", 4 * w, ???);
 
                 // Single-precision floating point to double-precision
-                if (Halide::Internal::get_llvm_version() >= 140) {
-                    // TODO(https://github.com/halide/Halide/issues/5130): broken for > 128bit vector widths
-                    if (w < 2) {
-                        check("f64x2.promote_low_f32x4", 2 * w, cast<double>(f32_1));
-                    }
-                } else {
+                // TODO(https://github.com/halide/Halide/issues/5130): broken for > 128bit vector widths
+                if (w < 2) {
                     check("f64x2.promote_low_f32x4", 2 * w, cast<double>(f32_1));
                 }