diff --git a/dependencies/llvm/CMakeLists.txt b/dependencies/llvm/CMakeLists.txt
index 296dde998..001fcf08f 100644
--- a/dependencies/llvm/CMakeLists.txt
+++ b/dependencies/llvm/CMakeLists.txt
@@ -20,9 +20,9 @@ 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")
-endif ()
+# if (LLVM_PACKAGE_VERSION VERSION_LESS 13.0)
+#     message(FATAL_ERROR "LLVM version must be 13.0 or newer")
+# endif ()
 
 if (LLVM_PACKAGE_VERSION VERSION_GREATER 15.0)
     message(WARNING "Halide is not tested on LLVM versions beyond 15.0")
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index fd714980d..ae46a40c0 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -527,7 +527,7 @@ endif ()
 
 if (BUILD_SHARED_LIBS)
     message(STATUS "Building autoschedulers enabled")
-    add_subdirectory(autoschedulers)
+    # add_subdirectory(autoschedulers)
 else ()
     message(STATUS "Building autoschedulers disabled (static Halide)")
 endif ()
diff --git a/src/CodeGen_Internal.cpp b/src/CodeGen_Internal.cpp
index 797f3a878..52e41ac53 100644
--- a/src/CodeGen_Internal.cpp
+++ b/src/CodeGen_Internal.cpp
@@ -70,7 +70,7 @@ llvm::Type *get_vector_element_type(llvm::Type *t) {
 }
 
 llvm::ElementCount element_count(int e) {
-    return llvm::ElementCount::getFixed(e);
+    return llvm::ElementCount(e, /*scalable*/ false);
 }
 
 llvm::Type *get_vector_type(llvm::Type *t, int n, bool scalable) {
@@ -714,7 +714,11 @@ void set_function_attributes_from_halide_target_options(llvm::Function &fn) {
 void embed_bitcode(llvm::Module *M, const string &halide_command) {
     // Save llvm.compiler.used and remote it.
     SmallVector<Constant *, 2> used_array;
+#if LLVM_VERSION >= 130
     SmallVector<GlobalValue *, 4> used_globals;
+#else
+    SmallPtrSet<GlobalValue *, 4> used_globals;
+#endif
     llvm::Type *used_element_type = llvm::Type::getInt8Ty(M->getContext())->getPointerTo(0);
     GlobalVariable *used = collectUsedGlobalVariables(*M, used_globals, true);
     for (auto *GV : used_globals) {
diff --git a/src/CodeGen_LLVM.cpp b/src/CodeGen_LLVM.cpp
index a1b92de54..8b9390fa0 100644
--- a/src/CodeGen_LLVM.cpp
+++ b/src/CodeGen_LLVM.cpp
@@ -1167,29 +1167,29 @@ void CodeGen_LLVM::optimize_module() {
             });
     }
 
-    if (get_target().has_feature(Target::ASAN)) {
-        pb.registerPipelineStartEPCallback([&](ModulePassManager &mpm, OptimizationLevel) {
-            mpm.addPass(RequireAnalysisPass<ASanGlobalsMetadataAnalysis, llvm::Module>());
-        });
-        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;
-            constexpr bool use_odr_indicator = true;
-            constexpr auto destructor_kind = AsanDtorKind::Global;
-            mpm.addPass(ModuleAddressSanitizerPass(
-                asan_options, use_global_gc, use_odr_indicator, destructor_kind));
-#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
-        });
-    }
+//     if (get_target().has_feature(Target::ASAN)) {
+//         pb.registerPipelineStartEPCallback([&](ModulePassManager &mpm, OptimizationLevel) {
+//             mpm.addPass(RequireAnalysisPass<ASanGlobalsMetadataAnalysis, llvm::Module>());
+//         });
+//         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;
+//             constexpr bool use_odr_indicator = true;
+//             constexpr auto destructor_kind = AsanDtorKind::Global;
+//             mpm.addPass(ModuleAddressSanitizerPass(
+//                 asan_options, use_global_gc, use_odr_indicator, destructor_kind));
+// #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
+//         });
+//     }
 
     // Target::MSAN handling is sprinkled throughout the codebase,
     // there is no need to run MemorySanitizerPass here.
@@ -1225,9 +1225,9 @@ void CodeGen_LLVM::optimize_module() {
         }
     }
 
-    if (tm) {
-        tm->registerPassBuilderCallbacks(pb);
-    }
+    // if (tm) {
+    //     tm->registerPassBuilderCallbacks(pb);
+    // }
 
     mpm = pb.buildPerModuleDefaultPipeline(level, debug_pass_manager);
     mpm.run(*module, mam);
@@ -2352,7 +2352,11 @@ llvm::Value *CodeGen_LLVM::codegen_dense_vector_load(const Type &type, const std
         Instruction *load_inst;
         if (vpred != nullptr) {
             Value *slice_mask = slice_vector(vpred, i, slice_lanes);
+#if LLVM_VERSION >= 130
             load_inst = builder->CreateMaskedLoad(slice_type, vec_ptr, llvm::Align(align_bytes), slice_mask);
+#else
+            load_inst = builder->CreateMaskedLoad(vec_ptr, llvm::Align(align_bytes), slice_mask);
+#endif
         } else {
             load_inst = builder->CreateAlignedLoad(slice_type, vec_ptr, llvm::Align(align_bytes));
         }
@@ -2439,11 +2443,20 @@ void CodeGen_LLVM::codegen_atomic_rmw(const Store *op) {
             Value *ptr = codegen_buffer_pointer(op->name,
                                                 op->value.type(),
                                                 op->index);
+#if LLVM_VERSION >= 130
             if (value_type.is_float()) {
                 builder->CreateAtomicRMW(AtomicRMWInst::FAdd, ptr, val, llvm::MaybeAlign(), AtomicOrdering::Monotonic);
             } else {
                 builder->CreateAtomicRMW(AtomicRMWInst::Add, ptr, val, llvm::MaybeAlign(), AtomicOrdering::Monotonic);
             }
+#else
+            // llvm 9 has FAdd which can be used for atomic floats.
+            if (value_type.is_float()) {
+                builder->CreateAtomicRMW(AtomicRMWInst::FAdd, ptr, val, AtomicOrdering::Monotonic);
+            } else {
+                builder->CreateAtomicRMW(AtomicRMWInst::Add, ptr, val, AtomicOrdering::Monotonic);
+            }
+#endif
         } else {
             Value *index = codegen(op->index);
             // Scalarize vector store.
@@ -2452,11 +2465,19 @@ void CodeGen_LLVM::codegen_atomic_rmw(const Store *op) {
                 Value *idx = builder->CreateExtractElement(index, lane);
                 Value *v = builder->CreateExtractElement(val, lane);
                 Value *ptr = codegen_buffer_pointer(op->name, value_type.element_of(), idx);
+#if LLVM_VERSION >= 130
                 if (value_type.is_float()) {
                     builder->CreateAtomicRMW(AtomicRMWInst::FAdd, ptr, v, llvm::MaybeAlign(), AtomicOrdering::Monotonic);
                 } else {
                     builder->CreateAtomicRMW(AtomicRMWInst::Add, ptr, v, llvm::MaybeAlign(), AtomicOrdering::Monotonic);
                 }
+#else
+                if (value_type.is_float()) {
+                    builder->CreateAtomicRMW(AtomicRMWInst::FAdd, ptr, v, AtomicOrdering::Monotonic);
+                } else {
+                    builder->CreateAtomicRMW(AtomicRMWInst::Add, ptr, v, AtomicOrdering::Monotonic);
+                }
+#endif
             }
         }
     } else {
@@ -2519,8 +2540,13 @@ void CodeGen_LLVM::codegen_atomic_rmw(const Store *op) {
                 val = builder->CreateBitCast(val, int_type);
                 cmp_val = builder->CreateBitCast(cmp_val, int_type);
             }
+#if LLVM_VERSION >= 130
             Value *cmpxchg_pair = builder->CreateAtomicCmpXchg(
                 ptr, cmp_val, val, llvm::MaybeAlign(), AtomicOrdering::Monotonic, AtomicOrdering::Monotonic);
+#else
+            Value *cmpxchg_pair = builder->CreateAtomicCmpXchg(
+                ptr, cmp_val, val, AtomicOrdering::Monotonic, AtomicOrdering::Monotonic);
+#endif
             Value *val_loaded = builder->CreateExtractValue(cmpxchg_pair, 0, "val_loaded");
             Value *success = builder->CreateExtractValue(cmpxchg_pair, 1, "success");
             if (need_bit_cast) {
@@ -4824,7 +4850,9 @@ llvm::Value *CodeGen_LLVM::fixed_to_scalable_vector_type(llvm::Value *fixed_arg)
     std::string bits_designator = std::to_string(fixed->getScalarSizeInBits());
     intrin += bits_designator;
     intrin += ".v" + std::to_string(lanes) + type_designator + bits_designator;
-    Constant *poison = PoisonValue::get(scalable->getElementType());
+    printf("poison\n");
+    // Constant *poison = PoisonValue::get(scalable->getElementType());
+    Constant *poison;
     llvm::Value *result_vec = ConstantVector::getSplat(scalable->getElementCount(), poison);
 
     std::vector<llvm::Value *> args;
diff --git a/src/CodeGen_RISCV.cpp b/src/CodeGen_RISCV.cpp
index 434105724..82005ce25 100644
--- a/src/CodeGen_RISCV.cpp
+++ b/src/CodeGen_RISCV.cpp
@@ -52,6 +52,7 @@ string CodeGen_RISCV::mattrs() const {
     if (target.has_feature(Target::RVV)) {
         arch_flags += ",+experimental-v";
     }
+    arch_flags += ",+xtheadc";
     return arch_flags;
 }
 
diff --git a/src/LLVM_Headers.h b/src/LLVM_Headers.h
index 42f44e042..984f681fa 100644
--- a/src/LLVM_Headers.h
+++ b/src/LLVM_Headers.h
@@ -1,11 +1,11 @@
 #ifndef HALIDE_LLVM_HEADERS_H
 #define HALIDE_LLVM_HEADERS_H
 
-#if LLVM_VERSION >= 130
-// We're good to go
-#else
-#error "Compiling Halide requires LLVM 13.0 or newer"
-#endif
+// #if LLVM_VERSION >= 130
+// // We're good to go
+// #else
+// #error "Compiling Halide requires LLVM 13.0 or newer"
+// #endif
 
 // No msvc warnings from llvm headers please
 #ifdef _MSC_VER
@@ -127,7 +127,7 @@ inline std::string get_llvm_function_name(const llvm::Function &f) {
 }
 
 inline llvm::StructType *get_llvm_struct_type_by_name(llvm::Module *module, const char *name) {
-    return llvm::StructType::getTypeByName(module->getContext(), name);
+    return module->getTypeByName(name);
 }
 
 }  // namespace Internal
diff --git a/src/runtime/CMakeLists.txt b/src/runtime/CMakeLists.txt
index e7f8fca7b..4e7682791 100644
--- a/src/runtime/CMakeLists.txt
+++ b/src/runtime/CMakeLists.txt
@@ -108,7 +108,7 @@ set(RUNTIME_LL
     wasm_math
     win32_math
     x86
-    x86_amx
+    # x86_amx
     x86_avx
     x86_avx2
     x86_avx512