Fixes for llvm trunk (#8590)

* Disable SVE patterns changed with LLVM trunk

* Track changes in llvm's use of llvm::Triple vs strings

---------

Co-authored-by: Volodymyr Kysenko <[email protected]>

Author: abadams

src/CodeGen_Internal.cpp

@@ -670,13 +670,18 @@ std::unique_ptr<llvm::TargetMachine> make_target_machine(const llvm::Module &mod
     std::string mattrs =
         get_md_string(module.getModuleFlag("halide_mattrs")).value_or(std::string{});
 
-    auto *tm = llvm_target->createTargetMachine(module.getTargetTriple(),
-                                                mcpu_target,
-                                                mattrs,
-                                                options,
-                                                use_pic ? llvm::Reloc::PIC_ : llvm::Reloc::Static,
-                                                use_large_code_model ? llvm::CodeModel::Large : llvm::CodeModel::Small,
-                                                CodeGenOptLevel::Aggressive);
+    auto *tm = llvm_target->createTargetMachine(
+#if LLVM_VERSION >= 210
+        module.getTargetTriple().str(),
+#else
+        module.getTargetTriple(),
+#endif
+        mcpu_target,
+        mattrs,
+        options,
+        use_pic ? llvm::Reloc::PIC_ : llvm::Reloc::Static,
+        use_large_code_model ? llvm::CodeModel::Large : llvm::CodeModel::Small,
+        CodeGenOptLevel::Aggressive);
     return std::unique_ptr<llvm::TargetMachine>(tm);
 }
 

src/CodeGen_LLVM.cpp

@@ -403,7 +403,11 @@ void CodeGen_LLVM::init_codegen(const std::string &name, bool any_strict_float)
 
     internal_assert(module && context);
 
+#if LLVM_VERSION >= 210
+    debug(1) << "Target triple of initial module: " << module->getTargetTriple().str() << "\n";
+#else
     debug(1) << "Target triple of initial module: " << module->getTargetTriple() << "\n";
+#endif
 
     module->setModuleIdentifier(name);
 

src/JITModule.cpp

@@ -274,7 +274,11 @@ void JITModule::compile_module(std::unique_ptr<llvm::Module> m, const string &fu
 
     // Make the execution engine
     debug(2) << "Creating new execution engine\n";
+#if LLVM_VERSION >= 210
+    debug(2) << "Target triple: " << m->getTargetTriple().str() << "\n";
+#else
     debug(2) << "Target triple: " << m->getTargetTriple() << "\n";
+#endif
     string error_string;
 
     llvm::for_each(*m, set_function_attributes_from_halide_target_options);
@@ -313,18 +317,32 @@ void JITModule::compile_module(std::unique_ptr<llvm::Module> m, const string &fu
     llvm::orc::LLJITBuilderState::ObjectLinkingLayerCreator linkerBuilder;
     if ((target.arch == Target::Arch::X86 && target.bits == 32) ||
         (target.arch == Target::Arch::ARM && target.bits == 32)) {
-        // Fallback to RTDyld-based linking to workaround errors:
-        // i386: "JIT session error: Unsupported i386 relocation:4" (R_386_PLT32)
-        // ARM 32bit: Unsupported target machine architecture in ELF object shared runtime-jitted-objectbuffer
+// Fallback to RTDyld-based linking to workaround errors:
+// i386: "JIT session error: Unsupported i386 relocation:4" (R_386_PLT32)
+// ARM 32bit: Unsupported target machine architecture in ELF object shared runtime-jitted-objectbuffer
+#if LLVM_VERSION >= 210
+        linkerBuilder = [&](llvm::orc::ExecutionSession &session) {
+            return std::make_unique<llvm::orc::RTDyldObjectLinkingLayer>(session, [&]() {
+                return std::make_unique<HalideJITMemoryManager>(dependencies);
+            });
+        };
+#else
         linkerBuilder = [&](llvm::orc::ExecutionSession &session, const llvm::Triple &) {
             return std::make_unique<llvm::orc::RTDyldObjectLinkingLayer>(session, [&]() {
                 return std::make_unique<HalideJITMemoryManager>(dependencies);
             });
         };
+#endif
     } else {
+#if LLVM_VERSION >= 210
+        linkerBuilder = [](llvm::orc::ExecutionSession &session) {
+            return std::make_unique<llvm::orc::ObjectLinkingLayer>(session);
+        };
+#else
         linkerBuilder = [](llvm::orc::ExecutionSession &session, const llvm::Triple &) {
             return std::make_unique<llvm::orc::ObjectLinkingLayer>(session);
         };
+#endif
     }
 
     auto JIT = llvm::cantFail(llvm::orc::LLJITBuilder()

src/LLVM_Output.cpp

@@ -352,7 +352,11 @@ std::unique_ptr<llvm::Module> clone_module(const llvm::Module &module_in) {
 void emit_file(const llvm::Module &module_in, Internal::LLVMOStream &out,
                llvm::CodeGenFileType file_type) {
     Internal::debug(1) << "emit_file.Compiling to native code...\n";
+#if LLVM_VERSION >= 210
+    Internal::debug(2) << "Target triple: " << module_in.getTargetTriple().str() << "\n";
+#else
     Internal::debug(2) << "Target triple: " << module_in.getTargetTriple() << "\n";
+#endif
 
     auto time_start = std::chrono::high_resolution_clock::now();
 

src/LLVM_Runtime_Linker.cpp

@@ -624,7 +624,11 @@ void link_modules(std::vector<std::unique_ptr<llvm::Module>> &modules, Target t,
             }
         }
         module->setDataLayout(data_layout);
+#if LLVM_VERSION >= 210
+        module->setTargetTriple(triple);
+#else
         module->setTargetTriple(triple.str());
+#endif
     }
 
     // Link them all together
@@ -1380,7 +1384,11 @@ std::unique_ptr<llvm::Module> get_initial_module_for_ptx_device(Target target, l
     }
 
     llvm::Triple triple("nvptx64--");
+#if LLVM_VERSION >= 210
+    modules[0]->setTargetTriple(triple);
+#else
     modules[0]->setTargetTriple(triple.str());
+#endif
 
     llvm::DataLayout dl("e-i64:64-v16:16-v32:32-n16:32:64");
     modules[0]->setDataLayout(dl);

test/correctness/simd_op_check_sve2.cpp

@@ -699,10 +699,14 @@ class SimdOpCheckArmSve : public SimdOpCheckTest {
                 Expr load_store_1 = in_im(x) * 3;
 
                 if (has_sve()) {
-                    // in native width, ld1b/st1b is used regardless of data type
-                    const bool allow_byte_ls = (width == target.vector_bits);
-                    add({get_sve_ls_instr("ld1", bits, bits, "", allow_byte_ls ? "b" : "")}, total_lanes, load_store_1);
-                    add({get_sve_ls_instr("st1", bits, bits, "", allow_byte_ls ? "b" : "")}, total_lanes, load_store_1);
+                    // This pattern has changed with LLVM 21, see https://github.com/halide/Halide/issues/8584 for more
+                    // details.
+                    if (Halide::Internal::get_llvm_version() <= 200) {
+                        // in native width, ld1b/st1b is used regardless of data type
+                        const bool allow_byte_ls = (width == target.vector_bits);
+                        add({get_sve_ls_instr("ld1", bits, bits, "", allow_byte_ls ? "b" : "")}, total_lanes, load_store_1);
+                        add({get_sve_ls_instr("st1", bits, bits, "", allow_byte_ls ? "b" : "")}, total_lanes, load_store_1);
+                    }
                 } else {
                     // vector register is not used for simple load/store
                     string reg_prefix = (width <= 64) ? "d" : "q";