diff --git a/doc/src/devdocs/build/build.md b/doc/src/devdocs/build/build.md
index 553f7c2e815cf..966ef3d102d1c 100644
--- a/doc/src/devdocs/build/build.md
+++ b/doc/src/devdocs/build/build.md
@@ -249,7 +249,7 @@ The most complicated dependency is LLVM, for which we require additional patches
 For packaging Julia with LLVM, we recommend either:
  - bundling a Julia-only LLVM library inside the Julia package, or
  - adding the patches to the LLVM package of the distribution.
-   * A complete list of patches is available in on [Github](https://github.com/JuliaLang/llvm-project) see the `julia-release/15.x` branch.
+   * A complete list of patches is available in on [Github](https://github.com/JuliaLang/llvm-project) see the `julia-release/18.x` branch.
    * The only Julia-specific patch is the lib renaming (`llvm7-symver-jlprefix.patch`), which should _not_ be applied to a system LLVM.
    * The remaining patches are all upstream bug fixes, and have been contributed into upstream LLVM.
 
diff --git a/src/APInt-C.cpp b/src/APInt-C.cpp
index e73399c2ecde4..86b0bdb27638b 100644
--- a/src/APInt-C.cpp
+++ b/src/APInt-C.cpp
@@ -475,7 +475,6 @@ void LLVMTrunc(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *otys, integerP
     memcpy(pr, pa, onumbytes);
 }
 
-#if JL_LLVM_VERSION >= 170000
 extern "C" JL_DLLEXPORT
 unsigned countr_zero_8(uint8_t Val) {
     return countr_zero(Val);
@@ -495,27 +494,6 @@ extern "C" JL_DLLEXPORT
 unsigned countr_zero_64(uint64_t Val) {
     return countr_zero(Val);
 }
-#else
-extern "C" JL_DLLEXPORT
-unsigned countTrailingZeros_8(uint8_t Val) {
-    return countTrailingZeros(Val);
-}
-
-extern "C" JL_DLLEXPORT
-unsigned countTrailingZeros_16(uint16_t Val) {
-    return countTrailingZeros(Val);
-}
-
-extern "C" JL_DLLEXPORT
-unsigned countTrailingZeros_32(uint32_t Val) {
-    return countTrailingZeros(Val);
-}
-
-extern "C" JL_DLLEXPORT
-unsigned countTrailingZeros_64(uint64_t Val) {
-    return countTrailingZeros(Val);
-}
-#endif
 
 extern "C" JL_DLLEXPORT
 void jl_LLVMSMod(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
@@ -545,7 +523,6 @@ void jl_LLVMFlipSign(unsigned numbits, integerPart *pa, integerPart *pb, integer
         memcpy(pr, pa, numbytes);
 }
 
-#if JL_LLVM_VERSION >= 170000
 extern "C" JL_DLLEXPORT
 unsigned LLVMPopcount(unsigned numbits, integerPart *pa) {
     CREATE(a)
@@ -575,34 +552,3 @@ unsigned LLVMCountl_zero(unsigned numbits, integerPart *pa) {
     CREATE(a)
     return a.countl_zero();
 }
-#else
-extern "C" JL_DLLEXPORT
-unsigned LLVMCountPopulation(unsigned numbits, integerPart *pa) {
-    CREATE(a)
-    return a.countPopulation();
-}
-
-extern "C" JL_DLLEXPORT
-unsigned LLVMCountTrailingOnes(unsigned numbits, integerPart *pa) {
-    CREATE(a)
-    return a.countTrailingOnes();
-}
-
-extern "C" JL_DLLEXPORT
-unsigned LLVMCountTrailingZeros(unsigned numbits, integerPart *pa) {
-    CREATE(a)
-    return a.countTrailingZeros();
-}
-
-extern "C" JL_DLLEXPORT
-unsigned LLVMCountLeadingOnes(unsigned numbits, integerPart *pa) {
-    CREATE(a)
-    return a.countLeadingOnes();
-}
-
-extern "C" JL_DLLEXPORT
-unsigned LLVMCountLeadingZeros(unsigned numbits, integerPart *pa) {
-    CREATE(a)
-    return a.countLeadingZeros();
-}
-#endif
diff --git a/src/APInt-C.h b/src/APInt-C.h
index a44d922a40d24..59ce3c765eeec 100644
--- a/src/APInt-C.h
+++ b/src/APInt-C.h
@@ -54,19 +54,11 @@ JL_DLLEXPORT int LLVMDiv_uov(unsigned numbits, integerPart *pa, integerPart *pb,
 JL_DLLEXPORT int LLVMRem_sov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
 JL_DLLEXPORT int LLVMRem_uov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
 
-#if JL_LLVM_VERSION >= 170000
 JL_DLLEXPORT unsigned LLVMPopcount(unsigned numbits, integerPart *pa);
 JL_DLLEXPORT unsigned LLVMCountr_one(unsigned numbits, integerPart *pa);
 JL_DLLEXPORT unsigned LLVMCountr_zero(unsigned numbits, integerPart *pa);
 JL_DLLEXPORT unsigned LLVMCountl_one(unsigned numbits, integerPart *pa);
 JL_DLLEXPORT unsigned LLVMCountl_zero(unsigned numbits, integerPart *pa);
-#else
-JL_DLLEXPORT unsigned LLVMCountPopulation(unsigned numbits, integerPart *pa);
-JL_DLLEXPORT unsigned LLVMCountTrailingOnes(unsigned numbits, integerPart *pa);
-JL_DLLEXPORT unsigned LLVMCountTrailingZeros(unsigned numbits, integerPart *pa);
-JL_DLLEXPORT unsigned LLVMCountLeadingOnes(unsigned numbits, integerPart *pa);
-JL_DLLEXPORT unsigned LLVMCountLeadingZeros(unsigned numbits, integerPart *pa);
-#endif
 
 JL_DLLEXPORT void LLVMFPtoSI(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr);
 JL_DLLEXPORT void LLVMFPtoUI(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr);
@@ -82,17 +74,10 @@ JL_DLLEXPORT int LLVMFPtoUI_exact(jl_datatype_t *ty, integerPart *pa, jl_datatyp
 JL_DLLEXPORT void jl_LLVMSMod(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
 JL_DLLEXPORT void jl_LLVMFlipSign(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
 
-#if JL_LLVM_VERSION >= 170000
 JL_DLLEXPORT unsigned countr_zero_8(uint8_t Val);
 JL_DLLEXPORT unsigned countr_zero_16(uint16_t Val);
 JL_DLLEXPORT unsigned countr_zero_32(uint32_t Val);
 JL_DLLEXPORT unsigned countr_zero_64(uint64_t Val);
-#else
-JL_DLLEXPORT unsigned countTrailingZeros_8(uint8_t Val);
-JL_DLLEXPORT unsigned countTrailingZeros_16(uint16_t Val);
-JL_DLLEXPORT unsigned countTrailingZeros_32(uint32_t Val);
-JL_DLLEXPORT unsigned countTrailingZeros_64(uint64_t Val);
-#endif
 
 //uint8_t getSwappedBytes_8(uint8_t Value); // no-op
 //uint16_t getSwappedBytes_16(uint16_t Value);
diff --git a/src/Makefile b/src/Makefile
index 3458f51fa5548..9355ca2c4c675 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -77,11 +77,7 @@ else
 # JULIACODEGEN != LLVM
 endif
 
-RT_LLVM_LIBS := support
-
-ifeq ($(shell test $(LLVM_VER_MAJ) -ge 16 && echo true),true)
-RT_LLVM_LIBS += targetparser
-endif
+RT_LLVM_LIBS := support targetparser
 
 ifeq ($(OS),WINNT)
 SRCS += win32_ucontext
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index 1d1e48efc8c6c..ba9a3c05e41ff 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -4,11 +4,7 @@
 #include "platform.h"
 
 // target support
-#if JL_LLVM_VERSION >= 170000
 #include <llvm/TargetParser/Triple.h>
-#else
-#include <llvm/ADT/Triple.h>
-#endif
 #include "llvm/Support/CodeGen.h"
 #include <llvm/ADT/Statistic.h>
 #include <llvm/Analysis/TargetLibraryInfo.h>
@@ -963,11 +959,7 @@ static FunctionInfo getFunctionWeight(const Function &F)
         auto val = F.getFnAttribute("julia.mv.clones").getValueAsString();
         // base16, so must be at most 4 * length bits long
         // popcount gives number of clones
-        #if JL_LLVM_VERSION >= 170000
         info.clones = APInt(val.size() * 4, val, 16).popcount() + 1;
-        #else
-        info.clones = APInt(val.size() * 4, val, 16).countPopulation() + 1;
-        #endif
     }
     info.weight += info.insts;
     // more basic blocks = more complex than just sum of insts,
@@ -1372,7 +1364,7 @@ static AOTOutputs add_output_impl(Module &M, TargetMachine &SourceTM, ShardTimer
             // So for now we inject a definition of these functions that calls our runtime
             // functions. We do so after optimization to avoid cloning these functions.
             // Float16 conversion routines
-#if defined(_CPU_X86_64_) && defined(_OS_DARWIN_) && JL_LLVM_VERSION >= 160000
+#if defined(_CPU_X86_64_) && defined(_OS_DARWIN_)
             // LLVM 16 reverted to soft-float ABI for passing half on x86_64 Darwin
             // https://github.com/llvm/llvm-project/commit/2bcf51c7f82ca7752d1bba390a2e0cb5fdd05ca9
             injectCRTAlias(M, "__gnu_h2f_ieee", "julia_half_to_float",
@@ -1721,9 +1713,6 @@ static SmallVector<AOTOutputs, 16> add_output(Module &M, TargetMachine &TM, Stri
             std::function<void()> func = [&, i]() {
                 LLVMContext ctx;
                 ctx.setDiscardValueNames(true);
-                #if JL_LLVM_VERSION < 170000
-                SetOpaquePointer(ctx);
-                #endif
                 // Lazily deserialize the entire module
                 timers[i].deserialize.startTimer();
                 auto EM = getLazyBitcodeModule(MemoryBufferRef(StringRef(serialized.data(), serialized.size()), "Optimized"), ctx);
@@ -1888,7 +1877,7 @@ void jl_dump_native_impl(void *native_code,
             Str += "10.14.0";
         TheTriple.setOSName(Str);
     }
-    Optional<Reloc::Model> RelocModel;
+    std::optional<Reloc::Model> RelocModel;
     if (TheTriple.isOSLinux() || TheTriple.isOSFreeBSD() || TheTriple.isOSOpenBSD()) {
         RelocModel = Reloc::PIC_;
     }
@@ -1933,9 +1922,6 @@ void jl_dump_native_impl(void *native_code,
         JL_TIMING(NATIVE_AOT, NATIVE_Sysimg);
         LLVMContext Context;
         Context.setDiscardValueNames(true);
-        #if JL_LLVM_VERSION < 170000
-        SetOpaquePointer(Context);
-        #endif
         Module sysimgM("sysimg", Context);
         sysimgM.setTargetTriple(TheTriple.str());
         sysimgM.setDataLayout(DL);
@@ -2081,9 +2067,6 @@ void jl_dump_native_impl(void *native_code,
         JL_TIMING(NATIVE_AOT, NATIVE_Metadata);
         LLVMContext Context;
         Context.setDiscardValueNames(true);
-        #if JL_LLVM_VERSION < 170000
-        SetOpaquePointer(Context);
-        #endif
         Module metadataM("metadata", Context);
         metadataM.setTargetTriple(TheTriple.str());
         metadataM.setDataLayout(DL);
@@ -2299,16 +2282,7 @@ void jl_get_llvmf_defn_impl(jl_llvmf_dump_t* dump, jl_method_instance_t *mi, jl_
                 }
                 else {
                     auto p = literal_static_pointer_val(global.first, global.second->getValueType());
-                    #if JL_LLVM_VERSION >= 170000
                     Type *elty = PointerType::get(output.getContext(), 0);
-                    #else
-                    Type *elty;
-                    if (p->getType()->isOpaquePointerTy()) {
-                        elty = PointerType::get(output.getContext(), 0);
-                    } else {
-                        elty = p->getType()->getNonOpaquePointerElementType();
-                    }
-                    #endif
                     // For pretty printing, when LLVM inlines the global initializer into its loads
                     auto alias = GlobalAlias::create(elty, 0, GlobalValue::PrivateLinkage, global.second->getName() + ".jit", p, global.second->getParent());
                     global.second->setInitializer(ConstantExpr::getBitCast(alias, global.second->getValueType()));
diff --git a/src/ccall.cpp b/src/ccall.cpp
index 52f8f807132e5..9aa1c56e2e78f 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -264,9 +264,6 @@ static GlobalVariable *emit_plt_thunk(
     SmallVector<Value*, 16> args;
     for (auto &arg : plt->args())
         args.push_back(&arg);
-    #if JL_LLVM_VERSION < 170000
-    assert(cast<PointerType>(ptr->getType())->isOpaqueOrPointeeTypeMatches(functype));
-    #endif
     CallInst *ret = irbuilder.CreateCall(
         functype,
         ptr, ArrayRef<Value*>(args));
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 7d4bd917eff30..9e170555e6149 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -60,11 +60,7 @@ static Value *decay_derived(jl_codectx_t &ctx, Value *V)
     if (T->getPointerAddressSpace() == AddressSpace::Derived)
         return V;
     // Once llvm deletes pointer element types, we won't need it here any more either.
-    #if JL_LLVM_VERSION >= 170000
     Type *NewT = PointerType::get(T, AddressSpace::Derived);
-    #else
-    Type *NewT = PointerType::getWithSamePointeeType(cast<PointerType>(T), AddressSpace::Derived);
-    #endif
     return ctx.builder.CreateAddrSpaceCast(V, NewT);
 }
 
@@ -74,11 +70,7 @@ static Value *maybe_decay_tracked(jl_codectx_t &ctx, Value *V)
     Type *T = V->getType();
     if (T->getPointerAddressSpace() != AddressSpace::Tracked)
         return V;
-    #if JL_LLVM_VERSION >= 170000
     Type *NewT = PointerType::get(T, AddressSpace::Derived);
-    #else
-    Type *NewT = PointerType::getWithSamePointeeType(cast<PointerType>(T), AddressSpace::Derived);
-    #endif
     return ctx.builder.CreateAddrSpaceCast(V, NewT);
 }
 
@@ -1010,54 +1002,6 @@ static void emit_memcpy_llvm(jl_codectx_t &ctx, Value *dst, jl_aliasinfo_t const
 {
     if (sz == 0)
         return;
-    #if JL_LLVM_VERSION < 170000
-    // If the types are small and simple, use load and store directly.
-    // Going through memcpy can cause LLVM (e.g. SROA) to create bitcasts between float and int
-    // that interferes with other optimizations.
-    // TODO: Restore this for opaque pointers? Needs extra type information from the caller.
-    if (ctx.builder.getContext().supportsTypedPointers() && sz <= 64) {
-        // The size limit is arbitrary but since we mainly care about floating points and
-        // machine size vectors this should be enough.
-        const DataLayout &DL = jl_Module->getDataLayout();
-        auto srcty = cast<PointerType>(src->getType());
-        //TODO unsafe nonopaque pointer
-        auto srcel = srcty->getNonOpaquePointerElementType();
-        auto dstty = cast<PointerType>(dst->getType());
-        //TODO unsafe nonopaque pointer
-        auto dstel = dstty->getNonOpaquePointerElementType();
-        while (srcel->isArrayTy() && srcel->getArrayNumElements() == 1) {
-            src = ctx.builder.CreateConstInBoundsGEP2_32(srcel, src, 0, 0);
-            srcel = srcel->getArrayElementType();
-            srcty = srcel->getPointerTo();
-        }
-        while (dstel->isArrayTy() && dstel->getArrayNumElements() == 1) {
-            dst = ctx.builder.CreateConstInBoundsGEP2_32(dstel, dst, 0, 0);
-            dstel = dstel->getArrayElementType();
-            dstty = dstel->getPointerTo();
-        }
-
-        llvm::Type *directel = nullptr;
-        if (srcel->isSized() && srcel->isSingleValueType() && DL.getTypeStoreSize(srcel) == sz) {
-            directel = srcel;
-            dst = emit_bitcast(ctx, dst, srcty);
-        }
-        else if (dstel->isSized() && dstel->isSingleValueType() &&
-                DL.getTypeStoreSize(dstel) == sz) {
-            directel = dstel;
-            src = emit_bitcast(ctx, src, dstty);
-        }
-        if (directel) {
-            if (isa<Instruction>(src) && !src->hasName())
-                setName(ctx.emission_context, src, "memcpy_refined_src");
-            if (isa<Instruction>(dst) && !dst->hasName())
-                setName(ctx.emission_context, dst, "memcpy_refined_dst");
-            auto val = src_ai.decorateInst(ctx.builder.CreateAlignedLoad(directel, src, MaybeAlign(align_src), is_volatile));
-            dst_ai.decorateInst(ctx.builder.CreateAlignedStore(val, dst, align_dst, is_volatile));
-            ++SkippedMemcpys;
-            return;
-        }
-    }
-    #endif
     ++EmittedMemcpys;
 
     // the memcpy intrinsic does not allow to specify different alias tags
@@ -1940,7 +1884,7 @@ static std::pair<Value*, bool> emit_isa(jl_codectx_t &ctx, const jl_cgval_t &x,
     // actual `isa` calls, this optimization should already have been performed upstream
     // anyway, but having this optimization in codegen might still be beneficial for
     // `typeassert`s if we can make it correct.
-    Optional<bool> known_isa;
+    std::optional<bool> known_isa;
     jl_value_t *intersected_type = type;
     if (x.constant)
         known_isa = jl_isa(x.constant, type);
@@ -3786,11 +3730,7 @@ static void recursively_adjust_ptr_type(llvm::Value *Val, unsigned FromAS, unsig
     for (auto *User : Val->users()) {
         if (isa<GetElementPtrInst>(User)) {
             GetElementPtrInst *Inst = cast<GetElementPtrInst>(User);
-            #if JL_LLVM_VERSION >= 170000
             Inst->mutateType(PointerType::get(Inst->getType(), ToAS));
-            #else
-            Inst->mutateType(PointerType::getWithSamePointeeType(cast<PointerType>(Inst->getType()), ToAS));
-            #endif
             recursively_adjust_ptr_type(Inst, FromAS, ToAS);
         }
         else if (isa<IntrinsicInst>(User)) {
@@ -3799,11 +3739,7 @@ static void recursively_adjust_ptr_type(llvm::Value *Val, unsigned FromAS, unsig
         }
         else if (isa<BitCastInst>(User)) {
             BitCastInst *Inst = cast<BitCastInst>(User);
-            #if JL_LLVM_VERSION >= 170000
             Inst->mutateType(PointerType::get(Inst->getType(), ToAS));
-            #else
-            Inst->mutateType(PointerType::getWithSamePointeeType(cast<PointerType>(Inst->getType()), ToAS));
-            #endif
             recursively_adjust_ptr_type(Inst, FromAS, ToAS);
         }
     }
diff --git a/src/codegen.cpp b/src/codegen.cpp
index b8bed0793730b..b9d42b9b5af16 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -23,11 +23,7 @@
 #include <llvm/CodeGen/TargetSubtargetInfo.h>
 #include <llvm/MC/TargetRegistry.h>
 #include <llvm/Target/TargetOptions.h>
-#if JL_LLVM_VERSION >= 170000
 #include <llvm/TargetParser/Host.h>
-#else
-#include <llvm/ADT/Host.h>
-#endif
 #include <llvm/Support/TargetSelect.h>
 #include <llvm/Object/SymbolSize.h>
 
@@ -637,11 +633,7 @@ static AttributeList get_func_attrs(LLVMContext &C)
 static AttributeList get_donotdelete_func_attrs(LLVMContext &C)
 {
     AttrBuilder FnAttrs(C);
-#if JL_LLVM_VERSION >= 160000
     FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleMemOnly());
-#else
-    FnAttrs.addAttribute(Attribute::InaccessibleMemOnly);
-#endif
     FnAttrs.addAttribute(Attribute::WillReturn);
     FnAttrs.addAttribute(Attribute::NoUnwind);
     return AttributeList::get(C,
@@ -671,11 +663,7 @@ static AttributeList get_attrs_box_float(LLVMContext &C, unsigned nbytes)
     auto FnAttrs = AttrBuilder(C);
     FnAttrs.addAttribute(Attribute::WillReturn);
     FnAttrs.addAttribute(Attribute::NoUnwind);
-#if JL_LLVM_VERSION >= 160000
     FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleMemOnly());
-#else
-    FnAttrs.addAttribute(Attribute::InaccessibleMemOnly);
-#endif
     auto RetAttrs = AttrBuilder(C);
     RetAttrs.addAttribute(Attribute::NonNull);
     RetAttrs.addDereferenceableAttr(nbytes);
@@ -691,11 +679,7 @@ static AttributeList get_attrs_box_sext(LLVMContext &C, unsigned nbytes)
     auto FnAttrs = AttrBuilder(C);
     FnAttrs.addAttribute(Attribute::WillReturn);
     FnAttrs.addAttribute(Attribute::NoUnwind);
-#if JL_LLVM_VERSION >= 160000
     FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleMemOnly());
-#else
-    FnAttrs.addAttribute(Attribute::InaccessibleMemOnly);
-#endif
     auto RetAttrs = AttrBuilder(C);
     RetAttrs.addAttribute(Attribute::NonNull);
     RetAttrs.addAttribute(Attribute::getWithDereferenceableBytes(C, nbytes));
@@ -712,11 +696,7 @@ static AttributeList get_attrs_box_zext(LLVMContext &C, unsigned nbytes)
     auto FnAttrs = AttrBuilder(C);
     FnAttrs.addAttribute(Attribute::WillReturn);
     FnAttrs.addAttribute(Attribute::NoUnwind);
-#if JL_LLVM_VERSION >= 160000
     FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleMemOnly());
-#else
-    FnAttrs.addAttribute(Attribute::InaccessibleMemOnly);
-#endif
     auto RetAttrs = AttrBuilder(C);
     RetAttrs.addAttribute(Attribute::NonNull);
     RetAttrs.addDereferenceableAttr(nbytes);
@@ -1141,12 +1121,7 @@ static const auto jlegalx_func = new JuliaFunction<TypeFnContextAndSizeT>{
         return FunctionType::get(getInt32Ty(C), {T, T, T_size}, false); },
     [](LLVMContext &C) {
         AttrBuilder FnAttrs(C);
-#if JL_LLVM_VERSION >= 160000
         FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleOrArgMemOnly());
-#else
-        FnAttrs.addAttribute(Attribute::ReadOnly);
-        FnAttrs.addAttribute(Attribute::ArgMemOnly);
-#endif
         FnAttrs.addAttribute(Attribute::NoUnwind);
         return AttributeList::get(C,
                 AttributeSet::get(C, FnAttrs),
@@ -1166,9 +1141,7 @@ static const auto jl_alloc_obj_func = new JuliaFunction<TypeFnContextAndSizeT>{
         auto FnAttrs = AttrBuilder(C);
         FnAttrs.addAllocSizeAttr(1, None); // returns %1 bytes
         FnAttrs.addAllocKindAttr(AllocFnKind::Alloc);
-#if JL_LLVM_VERSION >= 160000
         FnAttrs.addMemoryAttr(MemoryEffects::argMemOnly(ModRefInfo::Ref) | MemoryEffects::inaccessibleMemOnly(ModRefInfo::ModRef));
-#endif
         FnAttrs.addAttribute(Attribute::WillReturn);
         FnAttrs.addAttribute(Attribute::NoUnwind);
         auto RetAttrs = AttrBuilder(C);
@@ -1204,11 +1177,7 @@ static const auto jl_typeof_func = new JuliaFunction<>{
     },
     [](LLVMContext &C) {
         AttrBuilder FnAttrs(C);
-#if JL_LLVM_VERSION >= 160000
         FnAttrs.addMemoryAttr(MemoryEffects::none());
-#else
-        FnAttrs.addAttribute(Attribute::ReadNone);
-#endif
         FnAttrs.addAttribute(Attribute::NoUnwind);
         FnAttrs.addAttribute(Attribute::NoRecurse);
         return AttributeList::get(C,
@@ -1223,11 +1192,7 @@ static const auto jl_write_barrier_func = new JuliaFunction<>{
             {JuliaType::get_prjlvalue_ty(C)}, true); },
     [](LLVMContext &C) {
         AttrBuilder FnAttrs(C);
-#if JL_LLVM_VERSION >= 160000
         FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleMemOnly());
-#else
-        FnAttrs.addAttribute(Attribute::InaccessibleMemOnly);
-#endif
         FnAttrs.addAttribute(Attribute::NoUnwind);
         FnAttrs.addAttribute(Attribute::NoRecurse);
         return AttributeList::get(C,
@@ -1300,12 +1265,7 @@ static const auto memcmp_func = new JuliaFunction<TypeFnContextAndSizeT>{
             {getPointerTy(C), getPointerTy(C), T_size}, false); },
     [](LLVMContext &C) {
         AttrBuilder FnAttrs(C);
-#if JL_LLVM_VERSION >= 160000
         FnAttrs.addMemoryAttr(MemoryEffects::argMemOnly(ModRefInfo::Ref));
-#else
-        FnAttrs.addAttribute(Attribute::ArgMemOnly);
-        FnAttrs.addAttribute(Attribute::ReadOnly);
-#endif
         FnAttrs.addAttribute(Attribute::NoUnwind);
         return AttributeList::get(C,
             AttributeSet::get(C, FnAttrs),
@@ -1355,11 +1315,7 @@ static const auto jlfieldindex_func = new JuliaFunction<>{
     },
     [](LLVMContext &C) {
         AttrBuilder FnAttrs(C);
-#if JL_LLVM_VERSION >= 160000
         FnAttrs.addMemoryAttr(MemoryEffects::readOnly());
-#else
-        FnAttrs.addAttribute(Attribute::ReadOnly);
-#endif
         FnAttrs.addAttribute(Attribute::NoUnwind);
         FnAttrs.addAttribute(Attribute::WillReturn);
         return AttributeList::get(C,
@@ -1425,9 +1381,7 @@ static const auto jl_allocgenericmemory = new JuliaFunction<TypeFnContextAndSize
         [](LLVMContext &C) {
             AttrBuilder FnAttrs(C);
             AttrBuilder RetAttrs(C);
-#if JL_LLVM_VERSION >= 160000
             FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleMemOnly(ModRefInfo::ModRef) | MemoryEffects::argMemOnly(ModRefInfo::Ref));
-#endif
             FnAttrs.addAttribute(Attribute::WillReturn);
             RetAttrs.addAlignmentAttr(Align(16));
             RetAttrs.addAttribute(Attribute::NonNull);
@@ -1505,11 +1459,7 @@ static const auto pointer_from_objref_func = new JuliaFunction<>{
             {PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::Derived)}, false); },
     [](LLVMContext &C) {
         AttrBuilder FnAttrs(C);
-#if JL_LLVM_VERSION >= 160000
         FnAttrs.addMemoryAttr(MemoryEffects::none());
-#else
-        FnAttrs.addAttribute(Attribute::ReadNone);
-#endif
         FnAttrs.addAttribute(Attribute::NoUnwind);
         return AttributeList::get(C,
             AttributeSet::get(C, FnAttrs),
@@ -1532,11 +1482,7 @@ static const auto gc_loaded_func = new JuliaFunction<>{
         FnAttrs.addAttribute(Attribute::Speculatable);
         FnAttrs.addAttribute(Attribute::WillReturn);
         FnAttrs.addAttribute(Attribute::NoRecurse);
-#if JL_LLVM_VERSION >= 160000
         FnAttrs.addMemoryAttr(MemoryEffects::none());
-#else
-        FnAttrs.addAttribute(Attribute::ReadNone);
-#endif
         AttrBuilder RetAttrs(C);
         RetAttrs.addAttribute(Attribute::NonNull);
         RetAttrs.addAttribute(Attribute::NoUndef);
@@ -2440,11 +2386,7 @@ static Value *emit_inttoptr(jl_codectx_t &ctx, Value *v, Type *ty)
         auto ptr = I->getOperand(0);
         if (ty->getPointerAddressSpace() == ptr->getType()->getPointerAddressSpace())
             return ptr;
-        #if JL_LLVM_VERSION >= 170000
         else
-        #else
-        else if (cast<PointerType>(ty)->hasSameElementTypeAs(cast<PointerType>(ptr->getType())))
-        #endif
             return ctx.builder.CreateAddrSpaceCast(ptr, ty);
     }
     ++EmittedIntToPtrs;
@@ -10343,10 +10285,6 @@ char jl_using_perf_jitevents = 0;
 
 int jl_is_timing_passes = 0;
 
-#if JL_LLVM_VERSION < 170000
-int jl_opaque_ptrs_set = 0;
-#endif
-
 extern "C" void jl_init_llvm(void)
 {
     jl_page_size = jl_getpagesize();
@@ -10365,12 +10303,8 @@ extern "C" void jl_init_llvm(void)
     initializeAnalysis(Registry);
     initializeTransformUtils(Registry);
     initializeInstCombine(Registry);
-#if JL_LLVM_VERSION >= 160000
-    // TODO
-#else
-    initializeAggressiveInstCombine(Registry);
-    initializeInstrumentation(Registry);
-#endif
+    // TODO: initializeAggressiveInstCombine(Registry);
+    // TODO: initializeInstrumentation(Registry);
     initializeTarget(Registry);
 #ifdef USE_POLLY
     polly::initializePollyPasses(Registry);
@@ -10396,17 +10330,6 @@ extern "C" void jl_init_llvm(void)
     if (clopt && clopt->getNumOccurrences() == 0)
         cl::ProvidePositionalOption(clopt, "4", 1);
 
-    #if JL_LLVM_VERSION < 170000
-    // we want the opaque-pointers to be opt-in, per LLVMContext, for this release
-    // so change the default value back to pre-14.x, without changing the NumOccurrences flag for it
-    clopt = llvmopts.lookup("opaque-pointers");
-    if (clopt && clopt->getNumOccurrences() == 0) {
-        clopt->addOccurrence(1, clopt->ArgStr, "false", true);
-    } else {
-        jl_opaque_ptrs_set = 1;
-    }
-    #endif
-
     clopt = llvmopts.lookup("time-passes");
     if (clopt && clopt->getNumOccurrences() > 0)
         jl_is_timing_passes = 1;
diff --git a/src/disasm.cpp b/src/disasm.cpp
index b944e48430c29..6a7985bd7ec1b 100644
--- a/src/disasm.cpp
+++ b/src/disasm.cpp
@@ -58,11 +58,7 @@
 #include "llvm-version.h"
 
 // for outputting disassembly
-#if JL_LLVM_VERSION >= 170000
 #include <llvm/TargetParser/Triple.h>
-#else
-#include <llvm/ADT/Triple.h>
-#endif
 #include <llvm/AsmParser/Parser.h>
 #include <llvm/Analysis/TargetTransformInfo.h>
 #include <llvm/BinaryFormat/COFF.h>
@@ -505,7 +501,7 @@ jl_value_t *jl_dump_function_ir_impl(jl_llvmf_dump_t *dump, char strip_ir_metada
         auto TSM = std::unique_ptr<orc::ThreadSafeModule>(unwrap(dump->TSM));
         //If TSM is not passed in, then the context MUST be locked externally.
         //RAII will release the lock
-        Optional<orc::ThreadSafeContext::Lock> lock;
+        std::optional<orc::ThreadSafeContext::Lock> lock;
         if (TSM) {
             lock.emplace(TSM->getContext().getLock());
         }
@@ -1107,11 +1103,7 @@ static void jl_dump_asm_internal(
                             const MCOperand &OpI = Inst.getOperand(Op);
                             if (OpI.isImm()) {
                                 int64_t imm = OpI.getImm();
-                                #if JL_LLVM_VERSION >= 170000
                                 if (opinfo.operands()[Op].OperandType == MCOI::OPERAND_PCREL)
-                                #else
-                                if (opinfo.OpInfo[Op].OperandType == MCOI::OPERAND_PCREL)
-                                #endif
                                     imm += Fptr + Index;
                                 const char *name = DisInfo.lookupSymbolName(imm);
                                 if (name)
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index 42ddfb688af39..80867daade267 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -37,11 +37,7 @@
 #include <llvm/CodeGen/TargetSubtargetInfo.h>
 #include <llvm/MC/TargetRegistry.h>
 #include <llvm/Target/TargetOptions.h>
-#if JL_LLVM_VERSION >= 170000
 #include <llvm/TargetParser/Host.h>
-#else
-#include <llvm/Support/Host.h>
-#endif
 #include <llvm/Support/TargetSelect.h>
 #include <llvm/Object/SymbolSize.h>
 
@@ -1103,22 +1099,13 @@ class JLDebuginfoPlugin : public ObjectLinkingLayer::Plugin {
         return Error::success();
     }
 
-#if JL_LLVM_VERSION >= 160000
     Error notifyRemovingResources(JITDylib &JD, orc::ResourceKey K) override
-#else
-    Error notifyRemovingResources(orc::ResourceKey K) override
-#endif
     {
         return Error::success();
     }
 
-#if JL_LLVM_VERSION >= 160000
     void notifyTransferringResources(JITDylib &JD, orc::ResourceKey DstKey,
                                      orc::ResourceKey SrcKey) override {}
-#else
-    void notifyTransferringResources(orc::ResourceKey DstKey,
-                                     orc::ResourceKey SrcKey) override {}
-#endif
 
     void modifyPassConfig(MaterializationResponsibility &MR, jitlink::LinkGraph &,
                           jitlink::PassConfiguration &PassConfig) override
@@ -1168,21 +1155,12 @@ class JLMemoryUsagePlugin : public ObjectLinkingLayer::Plugin {
     Error notifyFailed(orc::MaterializationResponsibility &MR) override {
         return Error::success();
     }
-#if JL_LLVM_VERSION >= 160000
     Error notifyRemovingResources(JITDylib &JD, orc::ResourceKey K) override
-#else
-    Error notifyRemovingResources(orc::ResourceKey K) override
-#endif
     {
         return Error::success();
     }
-#if JL_LLVM_VERSION >= 160000
     void notifyTransferringResources(JITDylib &JD, orc::ResourceKey DstKey,
                                      orc::ResourceKey SrcKey) override {}
-#else
-    void notifyTransferringResources(orc::ResourceKey DstKey,
-                                     orc::ResourceKey SrcKey) override {}
-#endif
 
     void modifyPassConfig(orc::MaterializationResponsibility &,
                           jitlink::LinkGraph &,
@@ -1199,11 +1177,7 @@ class JLMemoryUsagePlugin : public ObjectLinkingLayer::Plugin {
                 for (auto block : section.blocks()) {
                     secsize += block->getSize();
                 }
-#if JL_LLVM_VERSION >= 160000
                 if ((section.getMemProt() & orc::MemProt::Exec) == orc::MemProt::None) {
-#else
-                if ((section.getMemProt() & jitlink::MemProt::Exec) == jitlink::MemProt::None) {
-#endif
                     data_size += secsize;
                 } else {
                     code_size += secsize;
@@ -1235,11 +1209,7 @@ class JLMemoryUsagePlugin : public ObjectLinkingLayer::Plugin {
 // TODO: Port our memory management optimisations to JITLink instead of using the
 // default InProcessMemoryManager.
 std::unique_ptr<jitlink::JITLinkMemoryManager> createJITLinkMemoryManager() JL_NOTSAFEPOINT {
-#if JL_LLVM_VERSION < 160000
-    return cantFail(orc::MapperJITLinkMemoryManager::CreateWithMapper<orc::InProcessMemoryMapper>());
-#else
     return cantFail(orc::MapperJITLinkMemoryManager::CreateWithMapper<orc::InProcessMemoryMapper>(/*Reservation Granularity*/ 16 * 1024 * 1024));
-#endif
 }
 
 #ifdef _COMPILER_CLANG_
@@ -1288,21 +1258,11 @@ class ForwardingMemoryManager : public RuntimeDyld::MemoryManager {
                                      bool IsReadOnly) override {
         return MemMgr->allocateDataSection(Size, Alignment, SectionID, SectionName, IsReadOnly);
     }
-#if JL_LLVM_VERSION >= 160000
     virtual void reserveAllocationSpace(uintptr_t CodeSize, Align CodeAlign,
                                         uintptr_t RODataSize, Align RODataAlign,
                                         uintptr_t RWDataSize, Align RWDataAlign) override {
         return MemMgr->reserveAllocationSpace(CodeSize, CodeAlign, RODataSize, RODataAlign, RWDataSize, RWDataAlign);
     }
-#else
-    virtual void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
-                                        uintptr_t RODataSize,
-                                        uint32_t RODataAlign,
-                                        uintptr_t RWDataSize,
-                                        uint32_t RWDataAlign) override {
-        return MemMgr->reserveAllocationSpace(CodeSize, CodeAlign, RODataSize, RODataAlign, RWDataSize, RWDataAlign);
-    }
-#endif
     virtual bool needsToReserveAllocationSpace() override {
         return MemMgr->needsToReserveAllocationSpace();
     }
@@ -1415,7 +1375,7 @@ namespace {
             FeaturesStr = Features.getString();
         }
         // Allocate a target...
-        Optional<CodeModel::Model> codemodel =
+        std::optional<CodeModel::Model> codemodel =
 #ifdef _P64
             // Make sure we are using the large code model on 64bit
             // Let LLVM pick a default suitable for jitting on 32bit
@@ -1830,11 +1790,6 @@ struct JuliaOJIT::DLSymOptimizer {
                     if (named) {
                         auto T = GV.getValueType();
                         assert(T->isPointerTy());
-                        #if JL_LLVM_VERSION < 170000
-                        if (!T->isOpaquePointerTy()) {
-                            T = T->getNonOpaquePointerElementType();
-                        }
-                        #endif
                         init = GlobalAlias::create(T, 0, GlobalValue::PrivateLinkage, GV.getName() + ".jit", init, &M);
                     }
                     GV.setInitializer(init);
@@ -1885,11 +1840,6 @@ struct JuliaOJIT::DLSymOptimizer {
                         if (named) {
                             auto T = CI->getType();
                             assert(T->isPointerTy());
-                            #if JL_LLVM_VERSION < 170000
-                            if (!T->isOpaquePointerTy()) {
-                                T = T->getNonOpaquePointerElementType();
-                            }
-                            #endif
                             init = GlobalAlias::create(T, 0, GlobalValue::PrivateLinkage, CI->getName() + ".jit", init, &M);
                         }
                         // DCE and SimplifyCFG will kill the branching structure around
@@ -1933,19 +1883,6 @@ void fixupTM(TargetMachine &TM) {
     }
 }
 
-#if JL_LLVM_VERSION < 170000
-extern int jl_opaque_ptrs_set;
-void SetOpaquePointer(LLVMContext &ctx) {
-    if (jl_opaque_ptrs_set)
-        return;
-#ifndef JL_LLVM_OPAQUE_POINTERS
-    ctx.setOpaquePointers(false);
-#else
-    ctx.setOpaquePointers(true);
-#endif
-}
-#endif
-
 llvm::DataLayout jl_create_datalayout(TargetMachine &TM) {
     // Mark our address spaces as non-integral
     auto jl_data_layout = TM.createDataLayout();
@@ -2053,7 +1990,7 @@ JuliaOJIT::JuliaOJIT()
 
     orc::SymbolAliasMap jl_crt = {
         // Float16 conversion routines
-#if defined(_CPU_X86_64_) && defined(_OS_DARWIN_) && JL_LLVM_VERSION >= 160000
+#if defined(_CPU_X86_64_) && defined(_OS_DARWIN_)
         // LLVM 16 reverted to soft-float ABI for passing half on x86_64 Darwin
         // https://github.com/llvm/llvm-project/commit/2bcf51c7f82ca7752d1bba390a2e0cb5fdd05ca9
         { mangle("__gnu_h2f_ieee"), { mangle("julia_half_to_float"),  JITSymbolFlags::Exported } },
@@ -2087,7 +2024,6 @@ JuliaOJIT::JuliaOJIT()
 
 #ifdef MSAN_EMUTLS_WORKAROUND
     orc::SymbolMap msan_crt;
-    #if JL_LLVM_VERSION >= 170000
     msan_crt[mangle("__emutls_get_address")] = {ExecutorAddr::fromPtr(msan_workaround::getTLSAddress), JITSymbolFlags::Exported};
     msan_crt[mangle("__emutls_v.__msan_param_tls")] = {ExecutorAddr::fromPtr(
         reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::param))), JITSymbolFlags::Exported};
@@ -2105,25 +2041,6 @@ JuliaOJIT::JuliaOJIT()
         reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::va_arg_overflow_size))), JITSymbolFlags::Exported};
     msan_crt[mangle("__emutls_v.__msan_origin_tls")] = {ExecutorAddr::fromPtr(
         reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::origin))), JITSymbolFlags::Exported};
-    #else
-    msan_crt[mangle("__emutls_get_address")] = JITEvaluatedSymbol::fromPointer(msan_workaround::getTLSAddress, JITSymbolFlags::Exported);
-    msan_crt[mangle("__emutls_v.__msan_param_tls")] = JITEvaluatedSymbol::fromPointer(
-        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::param)), JITSymbolFlags::Exported);
-    msan_crt[mangle("__emutls_v.__msan_param_origin_tls")] = JITEvaluatedSymbol::fromPointer(
-        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::param_origin)), JITSymbolFlags::Exported);
-    msan_crt[mangle("__emutls_v.__msan_retval_tls")] = JITEvaluatedSymbol::fromPointer(
-        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::retval)), JITSymbolFlags::Exported);
-    msan_crt[mangle("__emutls_v.__msan_retval_origin_tls")] = JITEvaluatedSymbol::fromPointer(
-        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::retval_origin)), JITSymbolFlags::Exported);
-    msan_crt[mangle("__emutls_v.__msan_va_arg_tls")] = JITEvaluatedSymbol::fromPointer(
-        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::va_arg)), JITSymbolFlags::Exported);
-    msan_crt[mangle("__emutls_v.__msan_va_arg_origin_tls")] = JITEvaluatedSymbol::fromPointer(
-        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::va_arg_origin)), JITSymbolFlags::Exported);
-    msan_crt[mangle("__emutls_v.__msan_va_arg_overflow_size_tls")] = JITEvaluatedSymbol::fromPointer(
-        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::va_arg_overflow_size)), JITSymbolFlags::Exported);
-    msan_crt[mangle("__emutls_v.__msan_origin_tls")] = JITEvaluatedSymbol::fromPointer(
-        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::origin)), JITSymbolFlags::Exported);
-    #endif
     cantFail(GlobalJD.define(orc::absoluteSymbols(msan_crt)));
 #endif
 #if JL_LLVM_VERSION < 190000
@@ -2133,11 +2050,7 @@ JuliaOJIT::JuliaOJIT()
     // hopefully fixed upstream by e7698a13e319a9919af04d3d693a6f6ea7168a44
     static int64_t jl___asan_globals_registered;
     orc::SymbolMap asan_crt;
-    #if JL_LLVM_VERSION >= 170000
     asan_crt[mangle("___asan_globals_registered")] = {ExecutorAddr::fromPtr(&jl___asan_globals_registered), JITSymbolFlags::Common | JITSymbolFlags::Exported};
-    #else
-    asan_crt[mangle("___asan_globals_registered")] = JITEvaluatedSymbol::fromPointer(&jl___asan_globals_registered, JITSymbolFlags::Common | JITSymbolFlags::Exported);
-    #endif
     cantFail(JD.define(orc::absoluteSymbols(asan_crt)));
 #endif
 #endif
@@ -2148,9 +2061,6 @@ JuliaOJIT::~JuliaOJIT() = default;
 ThreadSafeContext JuliaOJIT::makeContext()
 {
     auto ctx = std::make_unique<LLVMContext>();
-    #if JL_LLVM_VERSION < 170000
-    SetOpaquePointer(*ctx);
-    #endif
     return orc::ThreadSafeContext(std::move(ctx));
 }
 
@@ -2162,11 +2072,7 @@ orc::SymbolStringPtr JuliaOJIT::mangle(StringRef Name)
 
 void JuliaOJIT::addGlobalMapping(StringRef Name, uint64_t Addr)
 {
-    #if JL_LLVM_VERSION >= 170000
     cantFail(JD.define(orc::absoluteSymbols({{mangle(Name), {ExecutorAddr::fromPtr((void*)Addr), JITSymbolFlags::Exported}}})));
-    #else
-    cantFail(JD.define(orc::absoluteSymbols({{mangle(Name), JITEvaluatedSymbol::fromPointer((void*)Addr)}})));
-    #endif
 }
 
 void JuliaOJIT::addModule(orc::ThreadSafeModule TSM)
@@ -2245,7 +2151,6 @@ SmallVector<uint64_t> JuliaOJIT::findSymbols(ArrayRef<StringRef> Names)
     return Addrs;
 }
 
-#if JL_LLVM_VERSION >= 170000
 Expected<ExecutorSymbolDef> JuliaOJIT::findSymbol(StringRef Name, bool ExportedSymbolsOnly)
 {
     orc::JITDylib* SearchOrders[3] = {&JD, &GlobalJD, &ExternalJD};
@@ -2286,50 +2191,6 @@ uint64_t JuliaOJIT::getFunctionAddress(StringRef Name)
     }
     return addr->getAddress().getValue();
 }
-#else
-JL_JITSymbol JuliaOJIT::findSymbol(StringRef Name, bool ExportedSymbolsOnly)
-{
-    orc::JITDylib* SearchOrders[3] = {&JD, &GlobalJD, &ExternalJD};
-    ArrayRef<orc::JITDylib*> SearchOrder = ArrayRef<orc::JITDylib*>(&SearchOrders[0], ExportedSymbolsOnly ? 3 : 1);
-    auto Sym = ES.lookup(SearchOrder, Name);
-    if (Sym)
-        return *Sym;
-    return Sym.takeError();
-}
-
-JL_JITSymbol JuliaOJIT::findUnmangledSymbol(StringRef Name)
-{
-    return findSymbol(getMangledName(Name), true);
-}
-
-Expected<JL_JITSymbol> JuliaOJIT::findExternalJDSymbol(StringRef Name, bool ExternalJDOnly)
-{
-    orc::JITDylib* SearchOrders[3] = {&ExternalJD, &GlobalJD, &JD};
-    ArrayRef<orc::JITDylib*> SearchOrder = ArrayRef<orc::JITDylib*>(&SearchOrders[0], ExternalJDOnly ? 1 : 3);
-    auto Sym = ES.lookup(SearchOrder, getMangledName(Name));
-    return Sym;
-}
-
-uint64_t JuliaOJIT::getGlobalValueAddress(StringRef Name)
-{
-    auto addr = findSymbol(getMangledName(Name), false);
-    if (!addr) {
-        consumeError(addr.takeError());
-        return 0;
-    }
-    return cantFail(addr).getAddress();
-}
-
-uint64_t JuliaOJIT::getFunctionAddress(StringRef Name)
-{
-    auto addr = findSymbol(getMangledName(Name), false);
-    if (!addr) {
-        consumeError(addr.takeError());
-        return 0;
-    }
-    return cantFail(addr).getAddress();
-}
-#endif
 
 StringRef JuliaOJIT::getFunctionAtAddress(uint64_t Addr, jl_callptr_t invoke, jl_code_instance_t *codeinst)
 {
@@ -2361,13 +2222,8 @@ StringRef JuliaOJIT::getFunctionAtAddress(uint64_t Addr, jl_callptr_t invoke, jl
 }
 
 #ifdef JL_USE_JITLINK
-#if JL_LLVM_VERSION >= 170000
 #define addAbsoluteToMap(map,name) \
     (map[mangle(#name)] = {ExecutorAddr::fromPtr(&name), JITSymbolFlags::Exported | JITSymbolFlags::Callable}, orc::ExecutorAddr::fromPtr(&name))
-#else
-#define addAbsoluteToMap(map,name) \
-    (map[mangle(#name)] = JITEvaluatedSymbol::fromPointer(&name, JITSymbolFlags::Exported | JITSymbolFlags::Callable), orc::ExecutorAddr::fromPtr(&name))
-#endif
 
 void JuliaOJIT::enableJITDebuggingSupport()
 {
@@ -2552,11 +2408,7 @@ void jl_merge_module(orc::ThreadSafeModule &destTSM, orc::ThreadSafeModule srcTS
                 }
                 // Reparent the global variable:
                 SG.removeFromParent();
-                #if JL_LLVM_VERSION >= 170000
                 dest.insertGlobalVariable(&SG);
-                #else
-                dest.getGlobalList().push_back(&SG);
-                #endif
                 // Comdat is owned by the Module
                 SG.setComdat(nullptr);
             }
@@ -2603,11 +2455,7 @@ void jl_merge_module(orc::ThreadSafeModule &destTSM, orc::ThreadSafeModule srcTS
                     }
                 }
                 SG.removeFromParent();
-                #if JL_LLVM_VERSION >= 170000
                 dest.insertAlias(&SG);
-                #else
-                dest.getAliasList().push_back(&SG);
-                #endif
             }
 
             // metadata nodes need to be explicitly merged not just copied
diff --git a/src/jitlayers.h b/src/jitlayers.h
index baba5412226e3..6665be6a33faa 100644
--- a/src/jitlayers.h
+++ b/src/jitlayers.h
@@ -363,14 +363,6 @@ class MaxAlignedAllocImpl
 };
 using MaxAlignedAlloc = MaxAlignedAllocImpl<>;
 
-#if JL_LLVM_VERSION < 170000
-typedef JITSymbol JL_JITSymbol;
-// The type that is similar to SymbolInfo on LLVM 4.0 is actually
-// `JITEvaluatedSymbol`. However, we only use this type when a JITSymbol
-// is expected.
-typedef JITSymbol JL_SymbolInfo;
-#endif
-
 using CompilerResultT = Expected<std::unique_ptr<llvm::MemoryBuffer>>;
 using OptimizerResultT = Expected<orc::ThreadSafeModule>;
 using SharedBytesT = StringSet<MaxAlignedAllocImpl<sizeof(StringSet<>::MapEntryTy)>>;
@@ -472,7 +464,7 @@ class JuliaOJIT {
             }
             private:
             ResourcePool &pool;
-            Optional<ResourceT> resource;
+            std::optional<ResourceT> resource;
         };
 
         OwningResource operator*() JL_NOTSAFEPOINT {
@@ -558,16 +550,10 @@ class JuliaOJIT {
     orc::ExecutionSession &getExecutionSession() JL_NOTSAFEPOINT { return ES; }
     orc::JITDylib &getExternalJITDylib() JL_NOTSAFEPOINT { return ExternalJD; }
 
-    #if JL_LLVM_VERSION >= 170000
     Expected<llvm::orc::ExecutorSymbolDef> findSymbol(StringRef Name, bool ExportedSymbolsOnly) JL_NOTSAFEPOINT;
     Expected<llvm::orc::ExecutorSymbolDef> findUnmangledSymbol(StringRef Name) JL_NOTSAFEPOINT;
     Expected<llvm::orc::ExecutorSymbolDef> findExternalJDSymbol(StringRef Name, bool ExternalJDOnly) JL_NOTSAFEPOINT;
     SmallVector<uint64_t> findSymbols(ArrayRef<StringRef> Names) JL_NOTSAFEPOINT;
-    #else
-    JITEvaluatedSymbol findSymbol(StringRef Name, bool ExportedSymbolsOnly) JL_NOTSAFEPOINT;
-    JITEvaluatedSymbol findUnmangledSymbol(StringRef Name) JL_NOTSAFEPOINT;
-    Expected<JITEvaluatedSymbol> findExternalJDSymbol(StringRef Name, bool ExternalJDOnly) JL_NOTSAFEPOINT;
-    #endif
     uint64_t getGlobalValueAddress(StringRef Name) JL_NOTSAFEPOINT;
     uint64_t getFunctionAddress(StringRef Name) JL_NOTSAFEPOINT;
     StringRef getFunctionAtAddress(uint64_t Addr, jl_callptr_t invoke, jl_code_instance_t *codeinst) JL_NOTSAFEPOINT;
@@ -660,10 +646,6 @@ Module &jl_codegen_params_t::shared_module() JL_NOTSAFEPOINT {
 }
 void fixupTM(TargetMachine &TM) JL_NOTSAFEPOINT;
 
-#if JL_LLVM_VERSION < 170000
-void SetOpaquePointer(LLVMContext &ctx) JL_NOTSAFEPOINT;
-#endif
-
 void optimizeDLSyms(Module &M);
 
 // NewPM
diff --git a/src/llvm-codegen-shared.h b/src/llvm-codegen-shared.h
index a99e18f3e3762..d9551e0552f9c 100644
--- a/src/llvm-codegen-shared.h
+++ b/src/llvm-codegen-shared.h
@@ -1,5 +1,6 @@
 // This file is a part of Julia. License is MIT: https://julialang.org/license
 
+#include <optional>
 #include <utility>
 #include <llvm/ADT/ArrayRef.h>
 #include <llvm/ADT/SmallVector.h>
@@ -8,30 +9,15 @@
 #include <llvm/IR/DebugLoc.h>
 #include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/MDBuilder.h>
-
-#if JL_LLVM_VERSION >= 160000
 #include <llvm/Support/ModRef.h>
-#endif
 
 #include "julia.h"
 
 #define STR(csym)           #csym
 #define XSTR(csym)          STR(csym)
 
-#if JL_LLVM_VERSION >= 160000
-
-#include <optional>
-
-template<typename T>
-using Optional = std::optional<T>;
 static constexpr std::nullopt_t None = std::nullopt;
 
-#else
-
-#include <llvm/ADT/Optional.h>
-
-#endif
-
 enum AddressSpace {
     Generic = 0,
     Tracked = 10,
@@ -180,7 +166,7 @@ static inline llvm::Instruction *tbaa_decorate(llvm::MDNode *md, llvm::Instructi
     using namespace llvm;
     inst->setMetadata(llvm::LLVMContext::MD_tbaa, md);
     if (llvm::isa<llvm::LoadInst>(inst) && md && md == get_tbaa_const(md->getContext())) {
-        inst->setMetadata(llvm::LLVMContext::MD_invariant_load, llvm::MDNode::get(md->getContext(), None));
+        inst->setMetadata(llvm::LLVMContext::MD_invariant_load, llvm::MDNode::get(md->getContext(), std::nullopt));
     }
     return inst;
 }
@@ -245,11 +231,7 @@ static inline void emit_gc_safepoint(llvm::IRBuilder<> &builder, llvm::Type *T_s
         if (!F) {
             FunctionType *FT = FunctionType::get(Type::getVoidTy(C), {T_size->getPointerTo()}, false);
             F = Function::Create(FT, Function::ExternalLinkage, "julia.safepoint", M);
-#if JL_LLVM_VERSION >= 160000
             F->setMemoryEffects(MemoryEffects::inaccessibleOrArgMemOnly());
-#else
-            F->addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
-#endif
         }
         builder.CreateCall(F, {signal_page});
     }
diff --git a/src/llvm-cpufeatures.cpp b/src/llvm-cpufeatures.cpp
index 05d62adc57926..a6e963664b0f3 100644
--- a/src/llvm-cpufeatures.cpp
+++ b/src/llvm-cpufeatures.cpp
@@ -37,7 +37,7 @@ STATISTIC(LoweredWithoutFMA, "Number of have_fma's that were lowered to false");
 extern JuliaOJIT *jl_ExecutionEngine;
 
 // whether this platform unconditionally (i.e. without needing multiversioning) supports FMA
-Optional<bool> always_have_fma(Function &intr, const Triple &TT) JL_NOTSAFEPOINT {
+std::optional<bool> always_have_fma(Function &intr, const Triple &TT) JL_NOTSAFEPOINT {
     if (TT.isAArch64()) {
         auto intr_name = intr.getName();
         auto typ = intr_name.substr(strlen("julia.cpu.have_fma."));
diff --git a/src/llvm-julia-licm.cpp b/src/llvm-julia-licm.cpp
index 8d80f7fd54877..baf844dffa89c 100644
--- a/src/llvm-julia-licm.cpp
+++ b/src/llvm-julia-licm.cpp
@@ -342,11 +342,7 @@ struct JuliaLICM : public JuliaPassContext {
             }
         }
         if (changed && SE) {
-#if JL_LLVM_VERSION >= 160000
             SE->forgetLoopDispositions();
-#else
-            SE->forgetLoopDispositions(L);
-#endif
         }
 #ifdef JL_VERIFY_PASSES
         assert(!verifyLLVMIR(*L));
diff --git a/src/llvm-late-gc-lowering.cpp b/src/llvm-late-gc-lowering.cpp
index d95cc9c49b698..ff2cac6e49406 100644
--- a/src/llvm-late-gc-lowering.cpp
+++ b/src/llvm-late-gc-lowering.cpp
@@ -1163,9 +1163,6 @@ State LateLowerGCFrame::LocalScan(Function &F) {
                 }
                 if (CI->hasStructRetAttr()) {
                     Type *ElT = getAttributeAtIndex(CI->getAttributes(), 1, Attribute::StructRet).getValueAsType();
-                    #if JL_LLVM_VERSION < 170000
-                    assert(cast<PointerType>(CI->getArgOperand(0)->getType())->isOpaqueOrPointeeTypeMatches(getAttributeAtIndex(CI->getAttributes(), 1, Attribute::StructRet).getValueAsType()));
-                    #endif
                     auto tracked = CountTrackedPointers(ElT, true);
                     if (tracked.count) {
                         AllocaInst *SRet = dyn_cast<AllocaInst>((CI->arg_begin()[0])->stripInBoundsOffsets());
@@ -1252,38 +1249,20 @@ State LateLowerGCFrame::LocalScan(Function &F) {
                         callee->getName() == "memcmp") {
                         continue;
                     }
-#if JL_LLVM_VERSION >= 160000
                     if (callee->getMemoryEffects().onlyReadsMemory() ||
                         callee->getMemoryEffects().onlyAccessesArgPointees()) {
                         continue;
                     }
-#else
-                    if (callee->hasFnAttribute(Attribute::ReadNone) ||
-                        callee->hasFnAttribute(Attribute::ReadOnly) ||
-                        callee->hasFnAttribute(Attribute::ArgMemOnly)) {
-                        continue;
-                    }
-#endif
                     if (MemTransferInst *MI = dyn_cast<MemTransferInst>(CI)) {
                         MaybeTrackDst(S, MI);
                     }
                 }
-#if JL_LLVM_VERSION >= 160000
                 if (isa<IntrinsicInst>(CI) ||
                     CI->getMemoryEffects().onlyAccessesArgPointees() ||
                     CI->getMemoryEffects().onlyReadsMemory()) {
                     // Intrinsics are never safepoints.
                     continue;
                 }
-#else
-                if (isa<IntrinsicInst>(CI) ||
-                    CI->hasFnAttr(Attribute::ArgMemOnly) ||
-                    CI->hasFnAttr(Attribute::ReadNone)   ||
-                    CI->hasFnAttr(Attribute::ReadOnly)) {
-                    // Intrinsics are never safepoints.
-                    continue;
-                }
-#endif
                 SmallVector<int, 0> CalleeRoots;
                 for (Use &U : CI->args()) {
                     // Find all callee rooted arguments.
diff --git a/src/llvm-lower-handlers.cpp b/src/llvm-lower-handlers.cpp
index e09ea892ee488..c359bf6c117ce 100644
--- a/src/llvm-lower-handlers.cpp
+++ b/src/llvm-lower-handlers.cpp
@@ -8,11 +8,7 @@
 
 #include <llvm/ADT/DepthFirstIterator.h>
 #include <llvm/ADT/Statistic.h>
-#if JL_LLVM_VERSION >= 170000
 #include <llvm/TargetParser/Triple.h>
-#else
-#include <llvm/ADT/Triple.h>
-#endif
 #include <llvm/Analysis/CFG.h>
 #include <llvm/IR/BasicBlock.h>
 #include <llvm/IR/Constants.h>
diff --git a/src/llvm-multiversioning.cpp b/src/llvm-multiversioning.cpp
index 22ef973decfe9..a76d076ebd6f3 100644
--- a/src/llvm-multiversioning.cpp
+++ b/src/llvm-multiversioning.cpp
@@ -15,11 +15,7 @@
 #include <llvm/ADT/SmallString.h>
 #include <llvm/ADT/BitVector.h>
 #include <llvm/ADT/Statistic.h>
-#if JL_LLVM_VERSION >= 170000
 #include <llvm/TargetParser/Triple.h>
-#else
-#include <llvm/ADT/Triple.h>
-#endif
 #include <llvm/IR/Module.h>
 #include <llvm/IR/Function.h>
 #include <llvm/IR/Instructions.h>
@@ -51,7 +47,7 @@
 
 using namespace llvm;
 
-extern Optional<bool> always_have_fma(Function&, const Triple &TT);
+extern std::optional<bool> always_have_fma(Function&, const Triple &TT);
 
 namespace {
 constexpr uint32_t clone_mask =
@@ -185,7 +181,7 @@ struct TargetSpec {
     }
 };
 
-static Optional<SmallVector<TargetSpec, 0>> get_target_specs(Module &M) {
+static std::optional<SmallVector<TargetSpec, 0>> get_target_specs(Module &M) {
     auto md = M.getModuleFlag("julia.mv.specs");
     if (!md)
         return None;
diff --git a/src/llvm-pass-helpers.cpp b/src/llvm-pass-helpers.cpp
index 4e9e4826b4f75..ca25251040fb2 100644
--- a/src/llvm-pass-helpers.cpp
+++ b/src/llvm-pass-helpers.cpp
@@ -129,9 +129,7 @@ namespace jl_intrinsics {
     static Function *addGCAllocAttributes(Function *target)
     {
         auto FnAttrs = AttrBuilder(target->getContext());
-#if JL_LLVM_VERSION >= 160000
         FnAttrs.addMemoryAttr(MemoryEffects::argMemOnly(ModRefInfo::Ref) | MemoryEffects::inaccessibleMemOnly(ModRefInfo::ModRef));
-#endif
         FnAttrs.addAllocKindAttr(AllocFnKind::Alloc);
         FnAttrs.addAttribute(Attribute::WillReturn);
         FnAttrs.addAttribute(Attribute::NoUnwind);
@@ -228,11 +226,7 @@ namespace jl_intrinsics {
                     false),
                 Function::ExternalLinkage,
                 QUEUE_GC_ROOT_NAME);
-#if JL_LLVM_VERSION >= 160000
             intrinsic->setMemoryEffects(MemoryEffects::inaccessibleOrArgMemOnly());
-#else
-            intrinsic->addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
-#endif
             return intrinsic;
         });
 
@@ -248,11 +242,7 @@ namespace jl_intrinsics {
                     false),
                 Function::ExternalLinkage,
                 SAFEPOINT_NAME);
-#if JL_LLVM_VERSION >= 160000
             intrinsic->setMemoryEffects(MemoryEffects::inaccessibleOrArgMemOnly());
-#else
-            intrinsic->addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
-#endif
             return intrinsic;
         });
 }
@@ -309,11 +299,7 @@ namespace jl_well_known {
                     false),
                 Function::ExternalLinkage,
                 GC_QUEUE_ROOT_NAME);
-#if JL_LLVM_VERSION >= 160000
             func->setMemoryEffects(MemoryEffects::inaccessibleOrArgMemOnly());
-#else
-            func->addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
-#endif
             return func;
         });
 
diff --git a/src/llvm-propagate-addrspaces.cpp b/src/llvm-propagate-addrspaces.cpp
index 4e5a2ee5e0d54..06a52ad3dcb43 100644
--- a/src/llvm-propagate-addrspaces.cpp
+++ b/src/llvm-propagate-addrspaces.cpp
@@ -163,22 +163,14 @@ Value *PropagateJuliaAddrspacesVisitor::LiftPointer(Module *M, Value *V, Instruc
             Instruction *InstV = cast<Instruction>(V);
             Instruction *NewV = InstV->clone();
             ToInsert.push_back(std::make_pair(NewV, InstV));
-            #if JL_LLVM_VERSION >= 170000
             Type *NewRetTy = PointerType::get(InstV->getType(), allocaAddressSpace);
-            #else
-            Type *NewRetTy = PointerType::getWithSamePointeeType(cast<PointerType>(InstV->getType()), allocaAddressSpace);
-            #endif
             NewV->mutateType(NewRetTy);
             LiftingMap[InstV] = NewV;
             ToRevisit.push_back(NewV);
         }
     }
     auto CollapseCastsAndLift = [&](Value *CurrentV, Instruction *InsertPt) -> Value * {
-        #if JL_LLVM_VERSION >= 170000
         PointerType *TargetType = PointerType::get(CurrentV->getType(), allocaAddressSpace);
-        #else
-        PointerType *TargetType = PointerType::getWithSamePointeeType(cast<PointerType>(CurrentV->getType()), allocaAddressSpace);
-        #endif
         while (!LiftingMap.count(CurrentV)) {
             if (isa<BitCastInst>(CurrentV))
                 CurrentV = cast<BitCastInst>(CurrentV)->getOperand(0);
@@ -192,17 +184,7 @@ Value *PropagateJuliaAddrspacesVisitor::LiftPointer(Module *M, Value *V, Instruc
         }
         if (LiftingMap.count(CurrentV))
             CurrentV = LiftingMap[CurrentV];
-        #if JL_LLVM_VERSION >= 170000
         assert(CurrentV->getType() == TargetType);
-        #else
-        if (CurrentV->getType() != TargetType) {
-            // Shouldn't get here when using opaque pointers, so the new BitCastInst is fine
-            assert(CurrentV->getContext().supportsTypedPointers());
-            auto *BCI = new BitCastInst(CurrentV, TargetType);
-            ToInsert.push_back(std::make_pair(BCI, InsertPt));
-            CurrentV = BCI;
-        }
-        #endif
         return CurrentV;
     };
 
diff --git a/src/llvm-ptls.cpp b/src/llvm-ptls.cpp
index 614ed15f840e6..e36136859517a 100644
--- a/src/llvm-ptls.cpp
+++ b/src/llvm-ptls.cpp
@@ -9,11 +9,7 @@
 #include <llvm-c/Types.h>
 
 #include <llvm/Pass.h>
-#if JL_LLVM_VERSION >= 170000
 #include <llvm/TargetParser/Triple.h>
-#else
-#include <llvm/ADT/Triple.h>
-#endif
 #include <llvm/IR/Module.h>
 #include <llvm/IR/Function.h>
 #include <llvm/IR/Instructions.h>
@@ -67,11 +63,7 @@ struct LowerPTLS {
 
 void LowerPTLS::set_pgcstack_attrs(CallInst *pgcstack) const
 {
-#if JL_LLVM_VERSION >= 160000
     pgcstack->addFnAttr(Attribute::getWithMemoryEffects(pgcstack->getContext(), MemoryEffects::none()));
-#else
-    addFnAttr(pgcstack, Attribute::ReadNone);
-#endif
     addFnAttr(pgcstack, Attribute::NoUnwind);
 }
 
diff --git a/src/llvm-remove-addrspaces.cpp b/src/llvm-remove-addrspaces.cpp
index 89ae1d292d108..bb492f467e74c 100644
--- a/src/llvm-remove-addrspaces.cpp
+++ b/src/llvm-remove-addrspaces.cpp
@@ -44,19 +44,7 @@ class AddrspaceRemoveTypeRemapper : public ValueMapTypeRemapper {
 
         DstTy = SrcTy;
         if (auto Ty = dyn_cast<PointerType>(SrcTy)) {
-            #if JL_LLVM_VERSION >= 170000
             DstTy = PointerType::get(Ty->getContext(), ASRemapper(Ty->getAddressSpace()));
-            #else
-            if (Ty->isOpaque()) {
-                DstTy = PointerType::get(Ty->getContext(), ASRemapper(Ty->getAddressSpace()));
-            }
-            else {
-                //Remove once opaque pointer transition is complete
-                DstTy = PointerType::get(
-                        remapType(Ty->getNonOpaquePointerElementType()),
-                        ASRemapper(Ty->getAddressSpace()));
-            }
-            #endif
         }
         else if (auto Ty = dyn_cast<FunctionType>(SrcTy)) {
             SmallVector<Type *, 4> Params;
@@ -157,24 +145,8 @@ class AddrspaceRemoveValueMaterializer : public ValueMaterializer {
                     Ops.push_back(NewOp ? cast<Constant>(NewOp) : Op);
                 }
 
-                #if JL_LLVM_VERSION >= 170000
                 if (CE->getOpcode() != Instruction::GetElementPtr)
                     DstV = CE->getWithOperands(Ops, Ty);
-                #else
-                if (CE->getOpcode() == Instruction::GetElementPtr) {
-                    // GEP const exprs need to know the type of the source.
-                    // asserts remapType(typeof arg0) == typeof mapValue(arg0).
-                    Constant *Src = CE->getOperand(0);
-                    auto ptrty = cast<PointerType>(Src->getType()->getScalarType());
-                    //Remove once opaque pointer transition is complete
-                    if (!ptrty->isOpaque()) {
-                        Type *SrcTy = remapType(ptrty->getNonOpaquePointerElementType());
-                        DstV = CE->getWithOperands(Ops, Ty, false, SrcTy);
-                    }
-                }
-                else
-                    DstV = CE->getWithOperands(Ops, Ty);
-                #endif
             }
         }
 
diff --git a/src/llvm-simdloop.cpp b/src/llvm-simdloop.cpp
index e12b30e3db466..3faa9d9728e67 100644
--- a/src/llvm-simdloop.cpp
+++ b/src/llvm-simdloop.cpp
@@ -297,11 +297,7 @@ static bool processLoop(Loop &L, OptimizationRemarkEmitter &ORE, ScalarEvolution
         }
 
         if (SE)
-#if JL_LLVM_VERSION >= 160000
             SE->forgetLoopDispositions();
-#else
-            SE->forgetLoopDispositions(&L);
-#endif
     }
 
 #ifdef JL_VERIFY_PASSES
diff --git a/src/llvm-version.h b/src/llvm-version.h
index 984e918d480cc..061d80deb02f9 100644
--- a/src/llvm-version.h
+++ b/src/llvm-version.h
@@ -10,12 +10,8 @@
 #define JL_LLVM_VERSION (LLVM_VERSION_MAJOR * 10000 + LLVM_VERSION_MINOR * 100 \
                         + LLVM_VERSION_PATCH)
 
-#if JL_LLVM_VERSION < 150000
-    #error Only LLVM versions >= 15.0.0 are supported by Julia
-#endif
-
-#if JL_LLVM_VERSION >= 160000
-    #define JL_LLVM_OPAQUE_POINTERS 1
+#if JL_LLVM_VERSION < 170000
+    #error Only LLVM versions >= 17.0.0 are supported by Julia
 #endif
 
 #if JL_LLVM_VERSION < 19000 && defined(_CPU_RISCV64_)
diff --git a/src/pipeline.cpp b/src/pipeline.cpp
index f8976099ee53c..8c9054c0d65ff 100644
--- a/src/pipeline.cpp
+++ b/src/pipeline.cpp
@@ -150,15 +150,9 @@ namespace {
             // Opts.UseAfterReturn = CodeGenOpts.getSanitizeAddressUseAfterReturn();
             // MPM.addPass(RequireAnalysisPass<ASanGlobalsMetadataAnalysis, Module>());
             //Let's assume the defaults are actually fine for our purposes
-    #if JL_LLVM_VERSION < 160000
-            // MPM.addPass(ModuleAddressSanitizerPass(
-            //     Opts, UseGlobalGC, UseOdrIndicator, DestructorKind));
-            MPM.addPass(ModuleAddressSanitizerPass(AddressSanitizerOptions()));
-    #else // LLVM 16+
             // MPM.addPass(AddressSanitizerPass(
             //     Opts, UseGlobalGC, UseOdrIndicator, DestructorKind));
             MPM.addPass(AddressSanitizerPass(AddressSanitizerOptions(), true, false));
-    #endif
         //   }
         };
         ASanPass(/*SanitizerKind::Address, */false);
@@ -347,12 +341,8 @@ static void buildEarlySimplificationPipeline(ModulePassManager &MPM, PassBuilder
           FPM.addPass(DCEPass());
           FPM.addPass(SimplifyCFGPass(basicSimplifyCFGOptions()));
           if (O.getSpeedupLevel() >= 1) {
-#if JL_LLVM_VERSION >= 160000
               // TODO check the LLVM 15 default.
               FPM.addPass(SROAPass(SROAOptions::PreserveCFG));
-#else
-              FPM.addPass(SROAPass());
-#endif
           }
           MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
       }
@@ -389,12 +379,8 @@ static void buildEarlyOptimizerPipeline(ModulePassManager &MPM, PassBuilder *PB,
       if (O.getSpeedupLevel() >= 1) {
           FunctionPassManager FPM;
           if (O.getSpeedupLevel() >= 2) {
-#if JL_LLVM_VERSION >= 160000
               // TODO check the LLVM 15 default.
               FPM.addPass(SROAPass(SROAOptions::PreserveCFG));
-#else
-              FPM.addPass(SROAPass());
-#endif
               // SROA can duplicate PHI nodes which can block LowerSIMD
               FPM.addPass(InstCombinePass());
               FPM.addPass(JumpThreadingPass());
@@ -468,12 +454,8 @@ static void buildScalarOptimizerPipeline(FunctionPassManager &FPM, PassBuilder *
     if (options.enable_scalar_optimizations) {
         if (O.getSpeedupLevel() >= 2) {
             JULIA_PASS(FPM.addPass(AllocOptPass()));
-    #if JL_LLVM_VERSION >= 160000
             // TODO check the LLVM 15 default.
             FPM.addPass(SROAPass(SROAOptions::PreserveCFG));
-    #else
-            FPM.addPass(SROAPass());
-    #endif
             FPM.addPass(InstSimplifyPass());
             FPM.addPass(GVNPass());
             FPM.addPass(MemCpyOptPass());
@@ -737,12 +719,7 @@ void NewPM::run(Module &M) {
     //We must recreate the analysis managers every time
     //so that analyses from previous runs of the pass manager
     //do not hang around for the next run
-#if JL_LLVM_VERSION >= 160000
     StandardInstrumentations SI(M.getContext(),false);
-#else
-    StandardInstrumentations SI(false);
-#endif
-#if JL_LLVM_VERSION >= 170000
     PassInstrumentationCallbacks PIC;
     adjustPIC(PIC);
     TimePasses.registerCallbacks(PIC);
@@ -752,17 +729,6 @@ void NewPM::run(Module &M) {
     ModuleAnalysisManager MAM;
     SI.registerCallbacks(PIC, &MAM);
     SI.getTimePasses().setOutStream(nulls()); //TODO: figure out a better way of doing this
-#else
-    FunctionAnalysisManager FAM(createFAM(O, *TM.get()));
-    PassInstrumentationCallbacks PIC;
-    adjustPIC(PIC);
-    TimePasses.registerCallbacks(PIC);
-    SI.registerCallbacks(PIC, &FAM);
-    SI.getTimePasses().setOutStream(nulls()); //TODO: figure out a better way of doing this
-    LoopAnalysisManager LAM;
-    CGSCCAnalysisManager CGAM;
-    ModuleAnalysisManager MAM;
-#endif
     PassBuilder PB(TM.get(), PipelineTuningOptions(), None, &PIC);
     PB.registerLoopAnalyses(LAM);
     PB.registerFunctionAnalyses(FAM);
@@ -794,7 +760,7 @@ OptimizationLevel getOptLevel(int optlevel) {
 }
 
 //This part is also basically stolen from LLVM's PassBuilder.cpp file
-static Optional<std::pair<OptimizationLevel, OptimizationOptions>> parseJuliaPipelineOptions(StringRef name) {
+static std::optional<std::pair<OptimizationLevel, OptimizationOptions>> parseJuliaPipelineOptions(StringRef name) {
     if (name.consume_front("julia")) {
         auto O = OptimizationLevel::O2;
         auto options = OptimizationOptions::defaults();
diff --git a/src/processor.cpp b/src/processor.cpp
index bc12f5b54be19..3edebcc2f3ae6 100644
--- a/src/processor.cpp
+++ b/src/processor.cpp
@@ -7,11 +7,7 @@
 #include <llvm/ADT/ArrayRef.h>
 #include <llvm/ADT/SmallVector.h>
 #include <llvm/ADT/StringMap.h>
-#if JL_LLVM_VERSION >= 170000
 #include <llvm/TargetParser/Host.h>
-#else
-#include <llvm/Support/Host.h>
-#endif
 #include <llvm/Support/MathExtras.h>
 #include <llvm/Support/raw_ostream.h>
 
@@ -162,11 +158,7 @@ struct FeatureList {
     {
         int cnt = 0;
         for (size_t i = 0; i < n; i++)
-            #if JL_LLVM_VERSION >= 170000
             cnt += llvm::popcount(eles[i]);
-            #else
-            cnt += llvm::countPopulation(eles[i]);
-            #endif
         return cnt;
     }
     inline bool empty() const
diff --git a/src/runtime_ccall.cpp b/src/runtime_ccall.cpp
index 56f8487d8fb73..2a6cb00961594 100644
--- a/src/runtime_ccall.cpp
+++ b/src/runtime_ccall.cpp
@@ -4,11 +4,7 @@
 #include <map>
 #include <string>
 #include <llvm/ADT/StringMap.h>
-#if JL_LLVM_VERSION >= 170000
 #include <llvm/TargetParser/Host.h>
-#else
-#include <llvm/Support/Host.h>
-#endif
 #include <llvm/Support/raw_ostream.h>
 
 #include "julia.h"
diff --git a/src/runtime_intrinsics.c b/src/runtime_intrinsics.c
index 450096eef5b01..80281b733bf44 100644
--- a/src/runtime_intrinsics.c
+++ b/src/runtime_intrinsics.c
@@ -1574,7 +1574,6 @@ bi_iintrinsic_cnvtb_fast(LLVMAShr, ashr_op, ashr_int, , 1)
 //un_iintrinsic_fast(LLVMByteSwap, bswap_op, bswap_int, u)
 un_iintrinsic_slow(LLVMByteSwap, bswap_int, u)
 //#define ctpop_op(a) __builtin_ctpop(a)
-#if JL_LLVM_VERSION >= 170000
 //uu_iintrinsic_fast(LLVMPopcount, ctpop_op, ctpop_int, u)
 uu_iintrinsic_slow(LLVMPopcount, ctpop_int, u)
 //#define ctlz_op(a) __builtin_ctlz(a)
@@ -1583,16 +1582,6 @@ uu_iintrinsic_slow(LLVMCountl_zero, ctlz_int, u)
 //#define cttz_op(a) __builtin_cttz(a)
 //uu_iintrinsic_fast(LLVMCountr_zero, cttz_op, cttz_int, u)
 uu_iintrinsic_slow(LLVMCountr_zero, cttz_int, u)
-#else
-//uu_iintrinsic_fast(LLVMCountPopulation, ctpop_op, ctpop_int, u)
-uu_iintrinsic_slow(LLVMCountPopulation, ctpop_int, u)
-//#define ctlz_op(a) __builtin_ctlz(a)
-//uu_iintrinsic_fast(LLVMCountLeadingZeros, ctlz_op, ctlz_int, u)
-uu_iintrinsic_slow(LLVMCountLeadingZeros, ctlz_int, u)
-//#define cttz_op(a) __builtin_cttz(a)
-//uu_iintrinsic_fast(LLVMCountTrailingZeros, cttz_op, cttz_int, u)
-uu_iintrinsic_slow(LLVMCountTrailingZeros, cttz_int, u)
-#endif
 #define not_op(a) ~a
 un_iintrinsic_fast(LLVMFlipAllBits, not_op, not_int, u)
 
diff --git a/src/support/win32-clang-ABI-bug/optional b/src/support/win32-clang-ABI-bug/optional
index a2ecdad1e33ce..fd2f7646e1766 100644
--- a/src/support/win32-clang-ABI-bug/optional
+++ b/src/support/win32-clang-ABI-bug/optional
@@ -57,7 +57,6 @@ namespace optional_detail {
 //
 // The move constructible / assignable conditions emulate the remaining behavior
 // of std::is_trivially_copyable.
-#if JL_LLVM_VERSION >= 170000
 template <typename T,
           bool = (std::is_trivially_copy_constructible<T>::value &&
                   std::is_trivially_copy_assignable<T>::value &&
@@ -65,15 +64,6 @@ template <typename T,
                    !std::is_move_constructible<T>::value) &&
                   (std::is_trivially_move_assignable<T>::value ||
                    !std::is_move_assignable<T>::value))>
-#else
-template <typename T,
-          bool = (llvm::is_trivially_copy_constructible<T>::value &&
-                  std::is_trivially_copy_assignable<T>::value &&
-                  (llvm::is_trivially_move_constructible<T>::value ||
-                   !std::is_move_constructible<T>::value) &&
-                  (std::is_trivially_move_assignable<T>::value ||
-                   !std::is_move_assignable<T>::value))>
-#endif
 class OptionalStorage {
   union {
     char empty;