diff --git a/src/ccall.cpp b/src/ccall.cpp
index e19de5d1ff166c..a19d54c78d5620 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -166,17 +166,9 @@ static Value *runtime_sym_lookup(PointerType *funcptype, const char *f_lib,
     else {
         libname = literal_static_pointer_val(f_lib, T_pint8);
     }
-#if JL_LLVM_VERSION >= 30700
     Value *llvmf = builder.CreateCall(prepare_call(builder, jldlsym_func), { libname, stringConstPtr(builder, f_name), libptrgv });
-#else
-    Value *llvmf = builder.CreateCall3(prepare_call(builder, jldlsym_func), libname, stringConstPtr(builder, f_name), libptrgv);
-#endif
     auto store = builder.CreateAlignedStore(llvmf, llvmgv, sizeof(void*));
-#  if JL_LLVM_VERSION >= 30900
     store->setAtomic(AtomicOrdering::Release);
-#  else
-    store->setAtomic(Release);
-#  endif
     builder.CreateBr(ccall_bb);
 
     f->getBasicBlockList().push_back(ccall_bb);
@@ -254,11 +246,7 @@ static GlobalVariable *emit_plt_thunk(Module *M, FunctionType *functype,
     Value *ptr = runtime_sym_lookup(funcptype, f_lib, f_name, plt, libptrgv,
                                     llvmgv, runtime_lib);
     auto store = builder.CreateAlignedStore(builder.CreateBitCast(ptr, T_pvoidfunc), got, sizeof(void*));
-#if JL_LLVM_VERSION >= 30900
     store->setAtomic(AtomicOrdering::Release);
-#else
-    store->setAtomic(Release);
-#endif
     SmallVector<Value*, 16> args;
     for (Function::arg_iterator arg = plt->arg_begin(), arg_e = plt->arg_end(); arg != arg_e; ++arg)
         args.push_back(&*arg);
@@ -280,7 +268,7 @@ static GlobalVariable *emit_plt_thunk(Module *M, FunctionType *functype,
     else {
         // musttail support is very bad on ARM, PPC, PPC64 (as of LLVM 3.9)
         // Known failures includes vararg (not needed here) and sret.
-#if JL_LLVM_VERSION >= 30700 && (defined(_CPU_X86_) || defined(_CPU_X86_64_) || \
+#if (defined(_CPU_X86_) || defined(_CPU_X86_64_) || \
                         defined(_CPU_AARCH64_))
         ret->setTailCallKind(CallInst::TCK_MustTail);
 #endif
@@ -461,10 +449,8 @@ static Value *llvm_type_rewrite(
     Value *to;
 #if JL_LLVM_VERSION >= 40000
     const DataLayout &DL = jl_data_layout;
-#elif JL_LLVM_VERSION >= 30600
-    const DataLayout &DL = jl_ExecutionEngine->getDataLayout();
 #else
-    const DataLayout &DL = *jl_ExecutionEngine->getDataLayout();
+    const DataLayout &DL = jl_ExecutionEngine->getDataLayout();
 #endif
     if (DL.getTypeAllocSize(target_type) >= DL.getTypeAllocSize(from_type)) {
         to = emit_static_alloca(target_type, ctx);
@@ -487,7 +473,7 @@ static Value *runtime_apply_type(jl_value_t *ty, jl_unionall_t *unionall, jl_cod
     args[0] = literal_pointer_val(ty);
     args[1] = literal_pointer_val((jl_value_t*)ctx->linfo->def.method->sig);
     args[2] = builder.CreateInBoundsGEP(
-            LLVM37_param(T_prjlvalue)
+            T_prjlvalue,
             emit_bitcast(decay_derived(ctx->spvals_ptr), T_pprjlvalue),
             ConstantInt::get(T_size, sizeof(jl_svec_t) / sizeof(jl_value_t*)));
     return builder.CreateCall(prepare_call(jlapplytype_func), makeArrayRef(args));
@@ -519,11 +505,7 @@ static void typeassert_input(const jl_cgval_t &jvinfo, jl_value_t *jlto, jl_unio
                 Value *vx = boxed(jvinfo, ctx);
                 Value *istype = builder.
                     CreateICmpNE(
-#if JL_LLVM_VERSION >= 30700
                                  builder.CreateCall(prepare_call(jlisa_func), { vx, boxed(jlto_runtime, ctx) }),
-#else
-                                 builder.CreateCall2(prepare_call(jlisa_func), vx, boxed(jlto_runtime, ctx)),
-#endif
                                  ConstantInt::get(T_int32, 0));
                 BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext, "fail", ctx->f);
                 BasicBlock *passBB = BasicBlock::Create(jl_LLVMContext, "pass", ctx->f);
@@ -834,7 +816,6 @@ static jl_cgval_t emit_cglobal(jl_value_t **args, size_t nargs, jl_codectx_t *ct
     return mark_julia_type(res, false, rt, ctx);
 }
 
-#ifdef USE_MCJIT
 class FunctionMover final : public ValueMaterializer
 {
 public:
@@ -871,11 +852,6 @@ class FunctionMover final : public ValueMaterializer
             VMap[&*I] = &*(DestI++);        // Add mapping to VMap
         }
 
-#if JL_LLVM_VERSION >= 30600
-        // Clone debug info - Not yet public API
-        // llvm::CloneDebugInfoMetadata(NewF,F,VMap);
-#endif
-
         SmallVector<ReturnInst*, 8> Returns;
         llvm::CloneFunctionInto(NewF,F,VMap,true,Returns,"",NULL,NULL,this);
         NewF->setComdat(nullptr);
@@ -910,13 +886,7 @@ class FunctionMover final : public ValueMaterializer
         return NewF;
     }
 
-#if JL_LLVM_VERSION >= 30900
     Value *materialize(Value *V) override
-#elif JL_LLVM_VERSION >= 30800
-    Value *materializeDeclFor(Value *V) override
-#else
-    Value *materializeValueFor (Value *V) override
-#endif
     {
         Function *F = dyn_cast<Function>(V);
         if (F) {
@@ -984,7 +954,6 @@ class FunctionMover final : public ValueMaterializer
         return NULL;
     };
 };
-#endif
 
 // llvmcall(ir, (rettypes...), (argtypes...), args...)
 static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
@@ -1109,14 +1078,10 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
         << jl_string_data(ir) << "\n}";
         SMDiagnostic Err = SMDiagnostic();
         std::string ir_string = ir_stream.str();
-#if JL_LLVM_VERSION >= 30600
         Module *m = NULL;
         bool failed = parseAssemblyInto(llvm::MemoryBufferRef(ir_string,"llvmcall"),*jl_Module,Err);
         if (!failed)
             m = jl_Module;
-#else
-        Module *m = ParseAssemblyString(ir_string.c_str(),jl_Module,Err,jl_LLVMContext);
-#endif
         if (m == NULL) {
             std::string message = "Failed to parse LLVM Assembly: \n";
             llvm::raw_string_ostream stream(message);
@@ -1136,20 +1101,14 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
             it != argtypes.end(); ++it, ++i)
             assert(*it == f->getFunctionType()->getParamType(i));
 
-#ifdef USE_MCJIT
         if (f->getParent() != jl_Module) {
             FunctionMover mover(jl_Module, f->getParent());
             f = mover.CloneFunction(f);
         }
-#endif
 
         //f->dump();
-#if JL_LLVM_VERSION < 30500
-        if (verifyFunction(*f,PrintMessageAction)) {
-#else
         llvm::raw_fd_ostream out(1,false);
         if (verifyFunction(*f,&out)) {
-#endif
 #if JL_LLVM_VERSION >= 50000
             f->print(llvm::dbgs(), nullptr, false, true);
 #else
@@ -1212,10 +1171,8 @@ static jl_cgval_t mark_or_box_ccall_result(Value *result, bool isboxed, jl_value
         emit_leafcheck(runtime_dt, "ccall: return type must be a leaf DataType", ctx);
 #if JL_LLVM_VERSION >= 40000
         const DataLayout &DL = jl_data_layout;
-#elif JL_LLVM_VERSION >= 30600
-        const DataLayout &DL = jl_ExecutionEngine->getDataLayout();
 #else
-        const DataLayout &DL = *jl_ExecutionEngine->getDataLayout();
+        const DataLayout &DL = jl_ExecutionEngine->getDataLayout();
 #endif
         unsigned nb = DL.getTypeStoreSize(result->getType());
         MDNode *tbaa = jl_is_mutable(rt) ? tbaa_mutab : tbaa_immut;
@@ -1301,7 +1258,7 @@ std::string generate_func_sig()
         }
         else if (abi->use_sret((jl_datatype_t*)rt)) {
             AttrBuilder retattrs = AttrBuilder();
-#if !defined(_OS_WINDOWS_) || JL_LLVM_VERSION >= 30500 // llvm used to use the old mingw ABI, skipping this marking works around that difference
+#if !defined(_OS_WINDOWS_) // llvm used to use the old mingw ABI, skipping this marking works around that difference
             retattrs.addAttribute(Attribute::StructRet);
 #endif
             retattrs.addAttribute(Attribute::NoAlias);
@@ -1679,13 +1636,11 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
 #ifdef __MIC__
         // TODO
 #elif defined(_CPU_X86_64_) || defined(_CPU_X86_)  /* !__MIC__ */
-#if JL_LLVM_VERSION >= 30700
         static auto pauseinst = InlineAsm::get(FunctionType::get(T_void, false), "pause",
                                                "~{memory}", true);
         builder.CreateCall(pauseinst);
         JL_GC_POP();
         return ghostValue(jl_void_type);
-#endif
 #elif defined(_CPU_AARCH64_) || (defined(_CPU_ARM_) && __ARM_ARCH >= 7)
         static auto wfeinst = InlineAsm::get(FunctionType::get(T_void, false), "wfe",
                                              "~{memory}", true);
@@ -2051,11 +2006,7 @@ jl_cgval_t function_sig_t::emit_a_ccall(
         stacksave = CallInst::Create(Intrinsic::getDeclaration(jl_Module,
                                                                Intrinsic::stacksave));
         if (savespot) {
-#if JL_LLVM_VERSION >= 30800
             instList.insertAfter(savespot->getIterator(), stacksave);
-#else
-            instList.insertAfter(savespot, stacksave);
-#endif
         }
         else {
             instList.push_front(stacksave);
@@ -2197,10 +2148,8 @@ jl_cgval_t function_sig_t::emit_a_ccall(
 #ifndef JL_NDEBUG
 #if JL_LLVM_VERSION >= 40000
                 const DataLayout &DL = jl_data_layout;
-#elif JL_LLVM_VERSION >= 30600
-                const DataLayout &DL = jl_ExecutionEngine->getDataLayout();
 #else
-                const DataLayout &DL = *jl_ExecutionEngine->getDataLayout();
+                const DataLayout &DL = jl_ExecutionEngine->getDataLayout();
 #endif
                 // ARM and AArch64 can use a LLVM type larger than the julia
                 // type. However, the LLVM type size should be no larger than
diff --git a/src/cgmemmgr.cpp b/src/cgmemmgr.cpp
index 6b2f43ebffdcf2..b4f0ff0969b694 100644
--- a/src/cgmemmgr.cpp
+++ b/src/cgmemmgr.cpp
@@ -4,17 +4,11 @@
 #include "platform.h"
 #include "options.h"
 
-#ifdef USE_MCJIT
 #include <llvm/ExecutionEngine/SectionMemoryManager.h>
 #include "fix_llvm_assert.h"
 #include "julia.h"
 #include "julia_internal.h"
 
-#if JL_LLVM_VERSION >= 30700
-#if JL_LLVM_VERSION < 30800
-#  include <llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h>
-#  include "fix_llvm_assert.h"
-#endif
 #ifdef _OS_LINUX_
 #  include <sys/syscall.h>
 #  include <sys/utsname.h>
@@ -755,11 +749,9 @@ class RTDyldMemoryManagerJL : public SectionMemoryManager {
     uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
                                  unsigned SectionID, StringRef SectionName,
                                  bool isReadOnly) override;
-#if JL_LLVM_VERSION >= 30800
     using SectionMemoryManager::notifyObjectLoaded;
     void notifyObjectLoaded(RuntimeDyld &Dyld,
                             const object::ObjectFile &Obj) override;
-#endif
     bool finalizeMemory(std::string *ErrMsg = nullptr) override;
     template <typename DL, typename Alloc>
     void mapAddresses(DL &Dyld, Alloc &&allocator)
@@ -831,7 +823,6 @@ uint8_t *RTDyldMemoryManagerJL::allocateDataSection(uintptr_t Size,
                                                      SectionName, isReadOnly);
 }
 
-#if JL_LLVM_VERSION >= 30800
 void RTDyldMemoryManagerJL::notifyObjectLoaded(RuntimeDyld &Dyld,
                                                const object::ObjectFile &Obj)
 {
@@ -843,7 +834,6 @@ void RTDyldMemoryManagerJL::notifyObjectLoaded(RuntimeDyld &Dyld,
     assert(exe_alloc);
     mapAddresses(Dyld);
 }
-#endif
 
 bool RTDyldMemoryManagerJL::finalizeMemory(std::string *ErrMsg)
 {
@@ -886,14 +876,6 @@ void RTDyldMemoryManagerJL::deregisterEHFrames(uint8_t *Addr,
 
 }
 
-#if JL_LLVM_VERSION < 30800
-void notifyObjectLoaded(RTDyldMemoryManager *memmgr,
-                        llvm::orc::ObjectLinkingLayerBase::ObjSetHandleT H)
-{
-    ((RTDyldMemoryManagerJL*)memmgr)->mapAddresses(**H);
-}
-#endif
-
 #ifdef _OS_WINDOWS_
 void *lookupWriteAddressFor(RTDyldMemoryManager *memmgr, void *rt_addr)
 {
@@ -901,12 +883,7 @@ void *lookupWriteAddressFor(RTDyldMemoryManager *memmgr, void *rt_addr)
 }
 #endif
 
-#else // JL_LLVM_VERSION >= 30700
-typedef SectionMemoryManager RTDyldMemoryManagerJL;
-#endif // JL_LLVM_VERSION >= 30700
-
 RTDyldMemoryManager* createRTDyldMemoryManager()
 {
     return new RTDyldMemoryManagerJL();
 }
-#endif // USE_MCJIT
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index bb0013c1a3fc76..9ca01c96ddfe2e 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -1156,7 +1156,7 @@ static void emit_leafcheck(Value *typ, const std::string &msg, jl_codectx_t *ctx
     assert(typ->getType() == T_pjlvalue);
     emit_typecheck(mark_julia_type(typ, true, jl_any_type, ctx, false), (jl_value_t*)jl_datatype_type, msg, ctx);
     Value *isleaf;
-    isleaf = builder.CreateConstInBoundsGEP1_32(LLVM37_param(T_int8) emit_bitcast(decay_derived(typ), T_pint8), offsetof(jl_datatype_t, isleaftype));
+    isleaf = builder.CreateConstInBoundsGEP1_32(T_int8, emit_bitcast(decay_derived(typ), T_pint8), offsetof(jl_datatype_t, isleaftype));
     isleaf = builder.CreateLoad(isleaf, tbaa_const);
     isleaf = builder.CreateTrunc(isleaf, T_int1);
     error_unless(isleaf, msg, ctx);
@@ -1526,14 +1526,14 @@ static jl_cgval_t emit_getfield_knownidx(const jl_cgval_t &strct, unsigned idx,
                 lt = vlt->getElementType();
                 Value *ptr = data_pointer(strct, ctx, lt->getPointerTo());
                 Value *llvm_idx = ConstantInt::get(T_size, idx);
-                addr = builder.CreateGEP(LLVM37_param(lt) ptr, llvm_idx);
+                addr = builder.CreateGEP(lt, ptr, llvm_idx);
             }
             else if (lt->isSingleValueType()) {
                 addr = data_pointer(strct, ctx, lt->getPointerTo());
             }
             else {
                 Value *ptr = data_pointer(strct, ctx, lt->getPointerTo());
-                addr = builder.CreateStructGEP(LLVM37_param(lt) ptr, idx);
+                addr = builder.CreateStructGEP(lt, ptr, idx);
             }
         }
         if (jl_field_isptr(jt, idx)) {
@@ -2394,7 +2394,7 @@ static jl_cgval_t emit_new_struct(jl_value_t *ty, size_t nargs, jl_value_t **arg
                     if (!init_as_value) {
                         // avoid unboxing the argument explicitely
                         // and use memcpy instead
-                        dest = builder.CreateConstInBoundsGEP2_32(LLVM37_param(lt) strct, 0, i);
+                        dest = builder.CreateConstInBoundsGEP2_32(lt, strct, 0, i);
                     }
                     fval = emit_unbox(fty, fval_info, jtype, dest);
 
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 475cb70837ed34..8abe8ef92ec5c1 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -38,39 +38,23 @@
 // target machine computation
 #include <llvm/Target/TargetSubtargetInfo.h>
 #include <llvm/Support/TargetRegistry.h>
-#if JL_LLVM_VERSION < 30700
-#include <llvm/Target/TargetLibraryInfo.h>
-#endif
 #include <llvm/Target/TargetOptions.h>
 #include <llvm/Support/Host.h>
 #include <llvm/Support/TargetSelect.h>
-#if JL_LLVM_VERSION >= 30700
 #include <llvm/Analysis/TargetLibraryInfo.h>
-#endif
-
-#if JL_LLVM_VERSION >= 30700
 #include <llvm/Object/SymbolSize.h>
-#endif
 
 // IR building
 #include <llvm/IR/IntrinsicInst.h>
-#if JL_LLVM_VERSION >= 30500
 #include <llvm/Object/ObjectFile.h>
 #include <llvm/IR/DIBuilder.h>
 #include <llvm/AsmParser/Parser.h>
-#else
-#include <llvm/Assembly/Parser.h>
-#endif
 #include <llvm/DebugInfo/DIContext.h>
 #include <llvm/IR/DerivedTypes.h>
 #include <llvm/IR/Intrinsics.h>
 #include <llvm/IR/Attributes.h>
 #include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/MDBuilder.h>
-#if JL_LLVM_VERSION < 30500
-#include <llvm/DebugInfo.h>
-#include <llvm/DIBuilder.h>
-#endif
 
 // support
 #include <llvm/ADT/SmallBitVector.h>
@@ -79,26 +63,16 @@
 #include <llvm/Support/FormattedStream.h>
 #include <llvm/Support/SourceMgr.h> // for llvmcall
 #include <llvm/Transforms/Utils/Cloning.h> // for llvmcall inlining
-#if JL_LLVM_VERSION >= 30500
 #include <llvm/IR/Verifier.h> // for llvmcall validation
-#else
-#include <llvm/Analysis/Verifier.h>
-#endif
 
 // C API
-#if JL_LLVM_VERSION >= 30800
 #include <llvm-c/Types.h>
-#else
-#include <llvm-c/Core.h>
-#endif
 
 // for configuration options
 #include <llvm/Support/PrettyStackTrace.h>
 #include <llvm/Support/CommandLine.h>
 
-#if JL_LLVM_VERSION >= 30700
-#  include <llvm/IR/InlineAsm.h>
-#endif
+#include <llvm/IR/InlineAsm.h>
 #if defined(_CPU_ARM_) || defined(_CPU_AARCH64_)
 #  include <sys/utsname.h>
 #endif
@@ -123,13 +97,7 @@ namespace llvm {
 #include "codegen_internal.h"
 
 // LLVM version compatibility macros
-#if JL_LLVM_VERSION >= 30700
 legacy::PassManager *jl_globalPM;
-#define LLVM37_param(x) (x),
-#else
-#define LLVM37_param(x)
-PassManager *jl_globalPM;
-#endif
 
 #if JL_LLVM_VERSION >= 40000
 #define DIFlagZero (DINode::FlagZero)
@@ -137,10 +105,6 @@ PassManager *jl_globalPM;
 #define DIFlagZero (0)
 #endif
 
-#if JL_LLVM_VERSION < 30500
-#define AddrSpaceCastInst BitCastInst
-#endif
-
 extern "C" {
 
 #include "builtin_proto.h"
@@ -187,11 +151,7 @@ extern void _chkstk(void);
 #define DISABLE_FLOAT16
 
 // llvm state
-#if JL_LLVM_VERSION >= 30900
 JL_DLLEXPORT LLVMContext jl_LLVMContext;
-#else
-JL_DLLEXPORT LLVMContext &jl_LLVMContext = getGlobalContext();
-#endif
 static IRBuilder<> builder(jl_LLVMContext);
 static bool nested_compile = false;
 TargetMachine *jl_TargetMachine;
@@ -205,14 +165,7 @@ Module *shadow_output;
 #define jl_Module ctx->f->getParent()
 #define jl_builderModule builder.GetInsertBlock()->getParent()->getParent()
 
-#if JL_LLVM_VERSION >= 30700
 static DataLayout jl_data_layout("");
-// No DataLayout pass needed anymore.
-#elif JL_LLVM_VERSION >= 30500
-static DataLayoutPass *jl_data_layout;
-#else
-static DataLayout *jl_data_layout;
-#endif
 
 // types
 static Type *T_jlvalue;
@@ -279,25 +232,11 @@ static MDNode *tbaa_arrayflags;     // The flags in a jl_array_t
 static MDNode *tbaa_const;      // Memory that is immutable by the time LLVM can see it
 
 // Basic DITypes
-#if JL_LLVM_VERSION >= 30700
 static DICompositeType *jl_value_dillvmt;
 static DIDerivedType *jl_pvalue_dillvmt;
 static DIDerivedType *jl_ppvalue_dillvmt;
 static DISubroutineType *jl_di_func_sig;
 static DISubroutineType *jl_di_func_null_sig;
-#else
-static DICompositeType jl_value_dillvmt;
-static DIDerivedType jl_pvalue_dillvmt;
-static DIDerivedType jl_ppvalue_dillvmt;
-#if JL_LLVM_VERSION >= 30600
-DISubroutineType jl_di_func_sig;
-DISubroutineType jl_di_func_null_sig;
-#else
-DICompositeType jl_di_func_sig;
-DICompositeType jl_di_func_null_sig;
-#endif
-#endif
-
 
 extern "C"
 int32_t jl_jlcall_api(const void *function)
@@ -334,9 +273,6 @@ static GlobalVariable *jlRTLD_DEFAULT_var;
 #ifdef _OS_WINDOWS_
 static GlobalVariable *jlexe_var;
 static GlobalVariable *jldll_var;
-#if defined(_CPU_X86_64_) && !defined(USE_MCJIT)
-JITMemoryManager *createJITMemoryManagerWin();
-#endif
 #endif //_OS_WINDOWS_
 
 static Function *jltls_states_func;
@@ -541,11 +477,7 @@ struct jl_varinfo_t {
     Instruction *boxroot; // an address, if the var might be in a jl_value_t** stack slot (marked tbaa_const, if appropriate)
     jl_cgval_t value; // a stack slot or constant value
     Value *pTIndex; // i8* stack slot for the value.TIndex tag describing `value.V`
-#if JL_LLVM_VERSION >= 30700
     DILocalVariable *dinfo;
-#else
-    DIVariable dinfo;
-#endif
     // if the variable might be used undefined and is not boxed
     // this i1 flag is true when it is defined
     Value *defFlag;
@@ -559,11 +491,7 @@ struct jl_varinfo_t {
     jl_varinfo_t() : boxroot(NULL),
                      value(jl_cgval_t()),
                      pTIndex(NULL),
-#if JL_LLVM_VERSION >= 30700
                      dinfo(NULL),
-#else
-                     dinfo(DIVariable()),
-#endif
                      defFlag(NULL),
                      isSA(false),
                      isVolatile(false),
@@ -687,11 +615,7 @@ static GlobalVariable *get_pointer_to_constant(Constant *val, StringRef name, Mo
             GlobalVariable::PrivateLinkage,
             val,
             name);
-#if JL_LLVM_VERSION >= 30900
     gv->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
-#else
-    gv->setUnnamedAddr(true);
-#endif
     return gv;
 }
 
@@ -1289,12 +1213,7 @@ jl_llvm_functions_t jl_compile_linfo(jl_method_instance_t **pli, jl_code_info_t
             // so we can build a reverse mapping for debug-info.
             bool toplevel = !jl_is_method(li->def.method);
             if (!toplevel) {
-                const DataLayout &DL =
-#if JL_LLVM_VERSION >= 30500
-                    m->getDataLayout();
-#else
-                    *jl_data_layout;
-#endif
+                const DataLayout &DL = m->getDataLayout();
                 // but don't remember toplevel thunks because
                 // they may not be rooted in the gc for the life of the program,
                 // and the runtime doesn't notify us when the code becomes unreachable :(
@@ -1350,21 +1269,7 @@ jl_llvm_functions_t jl_compile_linfo(jl_method_instance_t **pli, jl_code_info_t
     return decls;
 }
 
-#if JL_LLVM_VERSION < 30700
-static Value *getModuleFlag(Module *m, StringRef Key)
-{
-    SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
-    m->getModuleFlagsMetadata(ModuleFlags);
-    SmallVector<Module::ModuleFlagEntry, 8>::iterator it = ModuleFlags.begin();
-    for (;it != ModuleFlags.end(); ++it) {
-        if (Key == it->Key->getString())
-            return it->Val;
-    }
-    return NULL;
-}
-#else
 #define getModuleFlag(m,str) m->getModuleFlag(str)
-#endif
 
 static void jl_setup_module(Module *m, const jl_cgparams_t *params = &jl_default_cgparams)
 {
@@ -1384,25 +1289,16 @@ static void jl_setup_module(Module *m, const jl_cgparams_t *params = &jl_default
 #endif
         m->addModuleFlag(llvm::Module::Warning, "Dwarf Version", dwarf_version);
     }
-#if JL_LLVM_VERSION >= 30400
     if (!getModuleFlag(m,"Debug Info Version"))
         m->addModuleFlag(llvm::Module::Error, "Debug Info Version",
             llvm::DEBUG_METADATA_VERSION);
-#endif
 #if JL_LLVM_VERSION >= 40000
     m->setDataLayout(jl_data_layout);
-#elif JL_LLVM_VERSION >= 30700
-#ifdef USE_ORCJIT
-    m->setDataLayout(jl_ExecutionEngine->getDataLayout());
-#elif JL_LLVM_VERSION >= 30800
-    m->setDataLayout(jl_ExecutionEngine->getDataLayout().getStringRepresentation());
 #else
-    m->setDataLayout(jl_ExecutionEngine->getDataLayout()->getStringRepresentation());
-#endif
-    m->setTargetTriple(jl_TargetMachine->getTargetTriple().str());
-#elif JL_LLVM_VERSION >= 30600
     m->setDataLayout(jl_ExecutionEngine->getDataLayout());
 #endif
+    m->setTargetTriple(jl_TargetMachine->getTargetTriple().str());
+
 }
 
 // this ensures that llvmf has been emitted to the execution engine,
@@ -1414,17 +1310,12 @@ static uint64_t getAddressForFunction(llvm::Function *llvmf)
 #ifdef JL_DEBUG_BUILD
     llvm::raw_fd_ostream out(1,false);
 #endif
-#ifdef USE_MCJIT
     jl_finalize_function(llvmf);
     uint64_t ret = jl_ExecutionEngine->getFunctionAddress(llvmf->getName());
     // delay executing trace callbacks until here to make sure there's no
     // recursive compilation.
     jl_callback_triggered_linfos();
     return ret;
-#else
-    return (uint64_t)jl_ExecutionEngine->getPointerToFunction(
-            cast<Function>(shadow_output->getNamedValue(llvmf->getName())));
-#endif
 }
 
 extern "C" JL_DLLEXPORT
@@ -1586,31 +1477,16 @@ void jl_extern_c(jl_function_t *f, jl_value_t *rt, jl_value_t *argt, char *name)
     // force eager emission of the function (llvm 3.3 gets confused otherwise and tries to do recursive compilation)
     uint64_t Addr = getAddressForFunction(llvmf);
 
-#if defined(USE_ORCJIT) || defined(USE_MCJIT)
     if (imaging_mode)
-         // in the old JIT, the shadow_module aliases the engine_module,
-         // otherwise, just point the alias to the declaration
-#endif
         llvmf = cast<Function>(shadow_output->getNamedValue(llvmf->getName()));
 
     // make the alias to the shadow_module
     GlobalAlias *GA =
-#if JL_LLVM_VERSION >= 30800
         GlobalAlias::create(llvmf->getType()->getElementType(), llvmf->getType()->getAddressSpace(),
                             GlobalValue::ExternalLinkage, name, llvmf, shadow_output);
-#elif JL_LLVM_VERSION >= 30700
-        GlobalAlias::create(cast<PointerType>(llvmf->getType()),
-                            GlobalValue::ExternalLinkage, name, llvmf, shadow_output);
-#else
-        new GlobalAlias(llvmf->getType(), GlobalValue::ExternalLinkage, name, llvmf, shadow_output);
-#endif
 
-#if defined(USE_ORCJIT) || defined(USE_MCJIT)
     // make sure the alias name is valid for the current session
     jl_ExecutionEngine->addGlobalMapping(GA, (void*)(uintptr_t)Addr);
-#else
-    (void)GA; (void)Addr;
-#endif
     JL_UNLOCK(&codegen_lock);
 }
 
@@ -1808,61 +1684,28 @@ static uint64_t compute_obj_symsize(const object::ObjectFile *obj, uint64_t offs
     uint64_t lo = 0;
     uint64_t hi = 0;
     bool setlo = false;
-#if JL_LLVM_VERSION >= 30700
     for (const object::SectionRef &Section : obj->sections()) {
-#else
-    llvm::error_code err;
-    for (object::section_iterator I = obj->begin_sections(), E = obj->end_sections();
-            !err && I != E; I.increment(err)) {
-        object::SectionRef Section = *I;
-#endif
         uint64_t SAddr, SSize;
-#if JL_LLVM_VERSION >= 30500
         if (!Section.isText()) continue;
-#else
-        bool isText;
-        if (Section.isText(isText) || !isText) continue;
-#endif
-#if JL_LLVM_VERSION >= 30600
         SAddr = Section.getAddress();
         SSize = Section.getSize();
-#else
-        Section.getAddress(SAddr);
-        Section.getSize(SSize);
-#endif
         if (offset < SAddr || offset >= SAddr + SSize) continue;
         assert(hi == 0);
 
         // test for lower and upper symbol bounds relative to other symbols
         hi = SAddr + SSize;
-#if JL_LLVM_VERSION >= 30700
         object::section_iterator ESection = obj->section_end();
         for (const object::SymbolRef &Sym : obj->symbols()) {
-#else
-        llvm::error_code err;
-        object::section_iterator ESection = obj->end_sections();
-        for (object::symbol_iterator I = obj->begin_symbols(), E = obj->end_symbols();
-                !err && I != E; I.increment(err)) {
-            object::SymbolRef Sym = *I;
-#endif
             uint64_t Addr;
             object::section_iterator Sect = ESection;
-#if JL_LLVM_VERSION >= 30800
             auto SectOrError = Sym.getSection();
             assert(SectOrError);
             Sect = SectOrError.get();
-#else
-            if (Sym.getSection(Sect)) continue;
-#endif
             if (Sect == ESection) continue;
             if (Sect != Section) continue;
-#if JL_LLVM_VERSION >= 30700
             auto AddrOrError = Sym.getAddress();
             assert(AddrOrError);
             Addr = AddrOrError.get();
-#else
-            if (Sym.getAddress(Addr)) continue;
-#endif
             if (Addr <= offset && Addr >= lo) {
                 // test for lower bound on symbol
                 lo = Addr;
@@ -1886,9 +1729,6 @@ const jl_value_t *jl_dump_function_asm(void *f, int raw_mc, const char* asm_vari
     jl_ptls_t ptls = jl_get_ptls_states();
     std::string code;
     llvm::raw_string_ostream stream(code);
-#if JL_LLVM_VERSION < 30700
-    llvm::formatted_raw_ostream fstream(stream);
-#endif
 
     Function *llvmf = dyn_cast<Function>((Function*)f);
     if (!llvmf)
@@ -1898,16 +1738,11 @@ const jl_value_t *jl_dump_function_asm(void *f, int raw_mc, const char* asm_vari
     uint64_t symsize = 0;
     int64_t slide = 0, section_slide = 0;
     uint64_t fptr = getAddressForFunction(llvmf);
-#ifdef USE_MCJIT
     // Look in the system image as well
     if (fptr == 0)
         fptr = (uintptr_t)jl_ExecutionEngine->getPointerToGlobalIfAvailable(llvmf);
     llvm::DIContext *context = NULL;
     llvm::DIContext *&objcontext = context;
-#else
-    std::vector<JITEvent_EmittedFunctionDetails::LineStart> context;
-    llvm::DIContext *objcontext = NULL;
-#endif
     const object::ObjectFile *object = NULL;
     assert(fptr != 0);
     if (!jl_DI_for_fptr(fptr, &symsize, &slide, &section_slide, &object, &context)) {
@@ -1930,21 +1765,11 @@ const jl_value_t *jl_dump_function_asm(void *f, int raw_mc, const char* asm_vari
 
     int8_t gc_state = jl_gc_safe_enter(ptls);
     jl_dump_asm_internal(fptr, symsize, slide,
-#ifndef USE_MCJIT
-            context,
-#endif
             object, objcontext,
-#if JL_LLVM_VERSION >= 30700
             stream,
-#else
-            fstream,
-#endif
             asm_variant
             );
 
-#if JL_LLVM_VERSION < 30700
-    fstream.flush();
-#endif
     jl_gc_safe_leave(ptls, gc_state);
 
     return jl_cstr_to_string(const_cast<char*>(stream.str().c_str()));
@@ -2001,11 +1826,7 @@ static void mallocVisitLine(StringRef filename, int line)
         return;
     }
     visitLine( mallocData[filename], line,
-               builder.CreateCall(prepare_call(diff_gc_total_bytes_func)
-#if JL_LLVM_VERSION >= 30700
-                                  , {}
-#endif
-                                  ),
+               builder.CreateCall(prepare_call(diff_gc_total_bytes_func), {}),
                         "bytecnt");
 }
 
@@ -2512,19 +2333,12 @@ static Value *emit_bits_compare(const jl_cgval_t &arg1, const jl_cgval_t &arg2,
         assert(arg1.ispointer() && arg2.ispointer());
         size_t sz = jl_datatype_size(arg1.typ);
         if (sz > 512 && !((jl_datatype_t*)arg1.typ)->layout->haspadding) {
-#if JL_LLVM_VERSION >= 30700
             Value *answer = builder.CreateCall(prepare_call(memcmp_func),
                             {
                             data_pointer(arg1, ctx, T_pint8),
                             data_pointer(arg2, ctx, T_pint8),
                             ConstantInt::get(T_size, sz)
                             });
-#else
-            Value *answer = builder.CreateCall3(prepare_call(memcmp_func),
-                    data_pointer(arg1, ctx, T_pint8),
-                    data_pointer(arg2, ctx, T_pint8),
-                    ConstantInt::get(T_size, sz));
-#endif
             return builder.CreateICmpEQ(answer, ConstantInt::get(T_int32, 0));
         }
         else {
@@ -2537,8 +2351,8 @@ static Value *emit_bits_compare(const jl_cgval_t &arg1, const jl_cgval_t &arg2,
             for(unsigned i=0; i < l; i++) {
                 jl_value_t *fldty = jl_svecref(types, i);
                 Value *subAns, *fld1, *fld2;
-                fld1 = builder.CreateConstGEP2_32(LLVM37_param(at) varg1, 0, i);
-                fld2 = builder.CreateConstGEP2_32(LLVM37_param(at) varg2, 0, i);
+                fld1 = builder.CreateConstGEP2_32(at, varg1, 0, i);
+                fld2 = builder.CreateConstGEP2_32(at, varg2, 0, i);
                 if (type_is_ghost(fld1->getType()->getPointerElementType()))
                     continue;
                 subAns = emit_bits_compare(
@@ -2627,11 +2441,7 @@ static Value *emit_f_is(const jl_cgval_t &arg1, const jl_cgval_t &arg2, jl_codec
     JL_FEAT_REQUIRE(ctx, runtime);
     Value *varg1 = mark_callee_rooted(boxed(arg1, ctx));
     Value *varg2 = mark_callee_rooted(boxed(arg2, ctx, false)); // potentially unrooted!
-#if JL_LLVM_VERSION >= 30700
     return builder.CreateTrunc(builder.CreateCall(prepare_call(jlegal_func), {varg1, varg2}), T_int1);
-#else
-    return builder.CreateTrunc(builder.CreateCall2(prepare_call(jlegal_func), varg1, varg2), T_int1);
-#endif
 }
 
 static bool emit_builtin_call(jl_cgval_t *ret, jl_value_t *f, jl_value_t **args, size_t nargs,
@@ -2692,11 +2502,7 @@ static bool emit_builtin_call(jl_cgval_t *ret, jl_value_t *f, jl_value_t **args,
             Value *rt_ty = boxed(emit_expr(args[2], ctx), ctx);
             Value *rt_val = boxed(*ret, ctx);
             JL_FEAT_REQUIRE(ctx, runtime);
-#if JL_LLVM_VERSION >= 30700
             builder.CreateCall(prepare_call(jltypeassert_func), {rt_val, rt_ty});
-#else
-            builder.CreateCall2(prepare_call(jltypeassert_func), rt_val, rt_ty);
-#endif
             JL_GC_POP();
             return true;
         }
@@ -2748,17 +2554,10 @@ static bool emit_builtin_call(jl_cgval_t *ret, jl_value_t *f, jl_value_t **args,
 #endif
         JL_FEAT_REQUIRE(ctx, runtime);
         Value *r =
-#if JL_LLVM_VERSION >= 30700
             builder.CreateCall(prepare_call(jlapply2va_func), {theF,
                                 builder.CreateGEP(ctx->argArray,
                                                   ConstantInt::get(T_size, ctx->nReqArgs)),
                                 nva});
-#else
-            builder.CreateCall3(prepare_call(jlapply2va_func), theF,
-                                builder.CreateGEP(ctx->argArray,
-                                                  ConstantInt::get(T_size, ctx->nReqArgs)),
-                                nva);
-#endif
         *ret = mark_julia_type(r, true, expr_type(expr, ctx), ctx);
         JL_GC_POP();
         return true;
@@ -2931,15 +2730,9 @@ static bool emit_builtin_call(jl_cgval_t *ret, jl_value_t *f, jl_value_t **args,
                                         T_pprjlvalue)));
                             }
                             else {
-#if JL_LLVM_VERSION >= 30700
                                 own_ptr = builder.CreateCall(
                                     prepare_call(jlarray_data_owner_func),
                                     {aryv});
-#else
-                                own_ptr = builder.CreateCall(
-                                    prepare_call(jlarray_data_owner_func),
-                                    aryv);
-#endif
                             }
                             builder.CreateBr(mergeBB);
                             builder.SetInsertPoint(mergeBB);
@@ -3529,15 +3322,9 @@ static Value *global_binding_pointer(jl_module_t *m, jl_sym_t *s,
             builder.CreateCondBr(builder.CreateICmpNE(cachedval, initnul), have_val, not_found);
             ctx->f->getBasicBlockList().push_back(not_found);
             builder.SetInsertPoint(not_found);
-#if JL_LLVM_VERSION >= 30700
             Value *bval = builder.CreateCall(prepare_call(jlgetbindingorerror_func),
                                               {maybe_decay_untracked(literal_pointer_val((jl_value_t*)m)),
                                               literal_pointer_val((jl_value_t*)s)});
-#else
-            Value *bval = builder.CreateCall2(prepare_call(jlgetbindingorerror_func),
-                                              maybe_decay_untracked(literal_pointer_val((jl_value_t*)m)),
-                                              literal_pointer_val((jl_value_t*)s));
-#endif
             builder.CreateStore(bval, bindinggv);
             builder.CreateBr(have_val);
             ctx->f->getBasicBlockList().push_back(have_val);
@@ -3572,7 +3359,7 @@ static jl_cgval_t emit_sparam(size_t i, jl_codectx_t *ctx)
         }
     }
     assert(ctx->spvals_ptr != NULL);
-    Value *bp = builder.CreateConstInBoundsGEP1_32(LLVM37_param(T_prjlvalue)
+    Value *bp = builder.CreateConstInBoundsGEP1_32(T_prjlvalue,
             emit_bitcast(decay_derived(ctx->spvals_ptr), T_pprjlvalue),
             i + sizeof(jl_svec_t) / sizeof(jl_value_t*));
     return mark_julia_type(tbaa_decorate(tbaa_const, builder.CreateLoad(bp)), true, jl_any_type, ctx, false);
@@ -3894,15 +3681,9 @@ static void emit_assignment(jl_value_t *l, jl_value_t *r, jl_codectx_t *ctx)
         JL_FEAT_REQUIRE(ctx, runtime);
         assert(bnd);
         Value *rval = mark_callee_rooted(boxed(emit_expr(r, ctx), ctx, false)); // no root needed since this is about to be assigned to a global
-#if JL_LLVM_VERSION >= 30700
         builder.CreateCall(prepare_call(jlcheckassign_func),
                            {literal_pointer_val(bnd),
                             rval});
-#else
-        builder.CreateCall2(prepare_call(jlcheckassign_func),
-                           literal_pointer_val(bnd),
-                            rval);
-#endif
         // Global variable. Does not need debug info because the debugger knows about
         // its memory location.
         return;
@@ -4450,9 +4231,7 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
             funcName.str(), M);
     jl_init_function(cw);
     cw->setAttributes(sig.attributes);
-#if JL_LLVM_VERSION >= 30700
     cw->addFnAttr("no-frame-pointer-elim", "true");
-#endif
     Function *cw_proto = function_proto(cw);
 
     BasicBlock *b0 = BasicBlock::Create(jl_LLVMContext, "top", cw);
@@ -4484,7 +4263,7 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
     if (lam) {
         Value *lam_max = builder.CreateLoad(
                 builder.CreateConstInBoundsGEP1_32(
-                    LLVM37_param(T_size)
+                    T_size,
                     emit_bitcast(decay_derived(literal_pointer_val((jl_value_t*)lam)), T_psize),
                     offsetof(jl_method_instance_t, max_world) / sizeof(size_t)));
         // XXX: age is always OK if we don't have a TLS. This is a hack required due to `@threadcall` abuse.
@@ -4628,7 +4407,7 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
         // figure out how to repack this type
         if (!specsig) {
             Value *arg = boxed(inputarg, &ctx, false); // don't want a gcroot, since it's about to be put into the jlcall frame anyways
-            GetElementPtrInst *slot = GetElementPtrInst::Create(LLVM37_param(NULL) myargs,
+            GetElementPtrInst *slot = GetElementPtrInst::Create(NULL, myargs,
                     ArrayRef<Value*>(ConstantInt::get(T_int32, FParamIndex)));
             slot->insertAfter(ctx.ptlsStates);
             builder.CreateStore(arg, slot);
@@ -4676,9 +4455,7 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
                                 funcName.str(), M);
                 jl_init_function(gf_thunk);
                 gf_thunk->setAttributes(theFptr->getAttributes());
-#if JL_LLVM_VERSION >= 30700
                 gf_thunk->addFnAttr("no-frame-pointer-elim", "true");
-#endif
                 call_v = builder.CreateSelect(age_ok, call_v, gf_thunk);
             }
             CallInst *call = builder.CreateCall(call_v, ArrayRef<Value*>(args));
@@ -4710,7 +4487,7 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
         // for jlcall, we need to pass the function object even if it is a ghost.
         // here we reconstruct the function instance from its type (first elt of argt)
         Value *theF = literal_pointer_val((jl_value_t*)ff);
-        GetElementPtrInst *slot = GetElementPtrInst::Create(LLVM37_param(NULL) myargs,
+        GetElementPtrInst *slot = GetElementPtrInst::Create(NULL, myargs,
                 ArrayRef<Value*>(ConstantInt::get(T_int32, 0)));
         slot->insertAfter(ctx.ptlsStates);
         builder.CreateStore(theF, slot);
@@ -4725,22 +4502,14 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
             builder.CreateCondBr(age_ok, b_jlcall, b_generic);
             builder.SetInsertPoint(b_jlcall);
             Value *nargs_v = ConstantInt::get(T_int32, nargs);
-            Value *myargs1 = builder.CreateConstInBoundsGEP1_32(LLVM37_param(NULL) myargs, 1);
-#if JL_LLVM_VERSION >= 30700
+            Value *myargs1 = builder.CreateConstInBoundsGEP1_32(NULL, myargs, 1);
             ret_jlcall = builder.CreateCall(prepare_call(theFptr), {theF, myargs1, nargs_v});
-#else
-            ret_jlcall = builder.CreateCall3(prepare_call(theFptr), theF, myargs1, nargs_v);
-#endif
             builder.CreateBr(b_after);
             builder.SetInsertPoint(b_generic);
         }
 
         Value *nargs_v = ConstantInt::get(T_int32, nargs + 1);
-#if JL_LLVM_VERSION >= 30700
         Value *ret = builder.CreateCall(prepare_call(jlapplygeneric_func), {myargs, nargs_v});
-#else
-        Value *ret = builder.CreateCall2(prepare_call(jlapplygeneric_func), myargs, nargs_v);
-#endif
         if (age_ok) {
             builder.CreateBr(b_after);
             builder.SetInsertPoint(b_after);
@@ -4842,16 +4611,12 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
                 }
                 (void)at;
             }
-            Value *argn = builder.CreateConstInBoundsGEP1_32(LLVM37_param(NULL) myargs, i);
+            Value *argn = builder.CreateConstInBoundsGEP1_32(NULL, myargs, i);
             builder.CreateStore(maybe_decay_untracked(arg_box), argn);
         }
         assert(AI == gf_thunk->arg_end());
         Value *nargs_v = ConstantInt::get(T_int32, nargs + 1);
-#if JL_LLVM_VERSION >= 30700
         Value *gf_ret = builder.CreateCall(prepare_call(jlapplygeneric_func), {myargs, nargs_v});
-#else
-        Value *gf_ret = builder.CreateCall2(prepare_call(jlapplygeneric_func), myargs, nargs_v);
-#endif
         jl_cgval_t gf_retbox = mark_julia_type(gf_ret, true, jl_any_type, &ctx, /*needsroot*/false);
         if (cc != jl_returninfo_t::Boxed) {
             emit_typecheck(gf_retbox, astrt, "cfunction", &ctx2);
@@ -5011,9 +4776,7 @@ static Function *gen_jlcall_wrapper(jl_method_instance_t *lam, const jl_returnin
     Function *w = Function::Create(jl_func_sig, GlobalVariable::ExternalLinkage,
                                    funcName, M);
     jl_init_function(w);
-#if JL_LLVM_VERSION >= 30700
     w->addFnAttr("no-frame-pointer-elim", "true");
-#endif
     Function::arg_iterator AI = w->arg_begin();
     Value *fArg = &*AI++;
     Value *argArray = &*AI++;
@@ -5180,9 +4943,7 @@ static jl_returninfo_t get_specsig_function(Module *M, const std::string &name,
             continue;
         if (ty->isAggregateType()) { // aggregate types are passed by pointer
             attributes = attributes.addAttribute(jl_LLVMContext, fsig.size() + 1, Attribute::NoCapture);
-#if JL_LLVM_VERSION >= 30500
             attributes = attributes.addAttribute(jl_LLVMContext, fsig.size() + 1, Attribute::ReadOnly);
-#endif
             ty = PointerType::get(ty, AddressSpace::Derived);
         }
         if (isboxed)
@@ -5196,26 +4957,10 @@ static jl_returninfo_t get_specsig_function(Module *M, const std::string &name,
     return props;
 }
 
-#if JL_LLVM_VERSION >= 30700
 static DISubroutineType *
-#elif JL_LLVM_VERSION >= 30600
-static DISubroutineType
-#else
-static DICompositeType
-#endif
-get_specsig_di(jl_value_t *sig,
-#if JL_LLVM_VERSION >= 30700
-    DIFile *topfile,
-#else
-    DIFile topfile,
-#endif
-    DIBuilder &dbuilder)
+get_specsig_di(jl_value_t *sig, DIFile *topfile, DIBuilder &dbuilder)
 {
-#if JL_LLVM_VERSION >= 30600
     std::vector<Metadata*> ditypes(0);
-#else
-    std::vector<Value*> ditypes(0);
-#endif
     for (size_t i = 0; i < jl_nparams(sig); i++) {
         jl_value_t *jt = jl_tparam(sig, i);
         Type *ty = julia_type_to_llvm(jt);
@@ -5223,13 +4968,7 @@ get_specsig_di(jl_value_t *sig,
             continue;
         ditypes.push_back(julia_type_to_di(jt, &dbuilder, false));
     }
-#if JL_LLVM_VERSION >= 30800
     return dbuilder.createSubroutineType(dbuilder.getOrCreateTypeArray(ditypes));
-#elif JL_LLVM_VERSION >= 30600
-    return dbuilder.createSubroutineType(topfile, dbuilder.getOrCreateTypeArray(ditypes));
-#else
-    return dbuilder.createSubroutineType(topfile, dbuilder.getOrCreateArray(ditypes));
-#endif
 }
 
 
@@ -5427,9 +5166,7 @@ static std::unique_ptr<Module> emit_function(
         declarations->specFunctionObject = NULL;
     }
 
-#if JL_LLVM_VERSION >= 30700
     f->addFnAttr("no-frame-pointer-elim", "true");
-#endif
     if (jlrettype == (jl_value_t*)jl_bottom_type)
         f->setDoesNotReturn();
 #if defined(_OS_WINDOWS_) && !defined(_CPU_X86_64_)
@@ -5449,7 +5186,7 @@ static std::unique_ptr<Module> emit_function(
             AttributeSet::FunctionIndex, *attr));
 #endif
 #endif
-#if defined(_OS_WINDOWS_) && defined(_CPU_X86_64_) && JL_LLVM_VERSION >= 30500
+#if defined(_OS_WINDOWS_) && defined(_CPU_X86_64_)
     f->setHasUWTable(); // force NeedsWinEH
 #endif
 
@@ -5466,36 +5203,19 @@ static std::unique_ptr<Module> emit_function(
 
     // Step 4b. determine debug info signature and other type info for locals
     DIBuilder dbuilder(*M);
-#if JL_LLVM_VERSION >= 30700
     DIFile *topfile = NULL;
     DISubprogram *SP = NULL;
-#else
-    DIFile topfile;
-    DISubprogram SP;
-#endif
     DebugLoc noDbg, topdebugloc;
     if (ctx.debug_enabled) {
         // TODO: Fix when moving to new LLVM version
         topfile = dbuilder.createFile(filename, ".");
-#if JL_LLVM_VERSION < 30400
-        dbuilder.createCompileUnit(0x01, filename, ".", "julia", true, "", 0);
-        DIDescriptor CU = DIDescriptor(dbuilder.getCU());
-#elif JL_LLVM_VERSION >= 40000
+#if JL_LLVM_VERSION >= 40000
         DICompileUnit *CU = dbuilder.createCompileUnit(0x01, topfile, "julia", true, "", 0);
-#elif JL_LLVM_VERSION >= 30700
-        DICompileUnit *CU = dbuilder.createCompileUnit(0x01, filename, ".", "julia", true, "", 0);
 #else
-        DICompileUnit CU = dbuilder.createCompileUnit(0x01, filename, ".", "julia", true, "", 0);
-        assert(CU.Verify());
+        DICompileUnit *CU = dbuilder.createCompileUnit(0x01, filename, ".", "julia", true, "", 0);
 #endif
 
-#if JL_LLVM_VERSION >= 30700
         DISubroutineType *subrty;
-#elif JL_LLVM_VERSION >= 30600
-        DISubroutineType subrty;
-#else
-        DICompositeType subrty;
-#endif
         if (jl_options.debug_level <= 1) {
             subrty = jl_di_func_null_sig;
         }
@@ -5516,19 +5236,9 @@ static std::unique_ptr<Module> emit_function(
                                      0,                // ScopeLine
                                      DIFlagZero,       // Flags
                                      true,             // isOptimized
-#if JL_LLVM_VERSION >= 30800
                                      nullptr);         // Template Parameters
-#else
-                                     f);               // Function
-#endif
         topdebugloc = DebugLoc::get(toplineno, 0, SP, NULL);
-#if JL_LLVM_VERSION >= 30800
         f->setSubprogram(SP);
-#endif
-#if JL_LLVM_VERSION < 30700
-        assert(SP.Verify() && SP.describes(f) && SP.getFunction() == f);
-#endif
-
         if (jl_options.debug_level >= 2) {
             const bool AlwaysPreserve = true;
             // Go over all arguments and local variables and initialize their debug information
@@ -5537,7 +5247,6 @@ static std::unique_ptr<Module> emit_function(
                 if (argname == unused_sym)
                     continue;
                 jl_varinfo_t &varinfo = ctx.slots[i];
-#if JL_LLVM_VERSION >= 30800
                 varinfo.dinfo = dbuilder.createParameterVariable(
                     SP,                                 // Scope (current function will be fill in later)
                     jl_symbol_name(argname),            // Variable name
@@ -5548,21 +5257,8 @@ static std::unique_ptr<Module> emit_function(
                     julia_type_to_di(varinfo.value.typ, &dbuilder, false),
                     AlwaysPreserve,                     // May be deleted if optimized out
                     DIFlagZero);                        // Flags (TODO: Do we need any)
-#else
-                varinfo.dinfo = dbuilder.createLocalVariable(
-                    llvm::dwarf::DW_TAG_arg_variable,    // Tag
-                    SP,                                 // Scope (current function will be fill in later)
-                    jl_symbol_name(argname),            // Variable name
-                    topfile,                            // File
-                    toplineno == -1 ? 0 : toplineno,             // Line (for now, use lineno of the function)
-                    julia_type_to_di(varinfo.value.typ, &dbuilder, false), // Variable type
-                    AlwaysPreserve,                     // May be deleted if optimized out
-                    0,                                  // Flags (TODO: Do we need any)
-                    ctx.has_sret + i + 1);              // Argument number (1-based)
-#endif
             }
             if (va && ctx.vaSlot != -1) {
-#if JL_LLVM_VERSION >= 30800
                 ctx.slots[ctx.vaSlot].dinfo = dbuilder.createParameterVariable(
                     SP,                                 // Scope (current function will be fill in later)
                     std::string(jl_symbol_name(slot_symbol(ctx.vaSlot, &ctx))) + "...",  // Variable name
@@ -5572,18 +5268,6 @@ static std::unique_ptr<Module> emit_function(
                     julia_type_to_di(ctx.slots[ctx.vaSlot].value.typ, &dbuilder, false),
                     AlwaysPreserve,                     // May be deleted if optimized out
                     DIFlagZero);                        // Flags (TODO: Do we need any)
-#else
-                ctx.slots[ctx.vaSlot].dinfo = dbuilder.createLocalVariable(
-                    llvm::dwarf::DW_TAG_arg_variable,   // Tag
-                    SP,                                 // Scope (current function will be fill in later)
-                    std::string(jl_symbol_name(slot_symbol(ctx.vaSlot, &ctx))) + "...",  // Variable name
-                    topfile,                            // File
-                    toplineno == -1 ? 0 : toplineno,    // Line (for now, use lineno of the function)
-                    julia_type_to_di(ctx.slots[ctx.vaSlot].value.typ, &dbuilder, false),      // Variable type
-                    AlwaysPreserve,                     // May be deleted if optimized out
-                    0,                                  // Flags (TODO: Do we need any)
-                    ctx.has_sret + nreq + 1);           // Argument number (1-based)
-#endif
             }
             for (i = 0; i < vinfoslen; i++) {
                 jl_sym_t *s = (jl_sym_t*)jl_array_ptr_ref(src->slotnames, i);
@@ -5591,12 +5275,7 @@ static std::unique_ptr<Module> emit_function(
                 if (varinfo.isArgument || s == compiler_temp_sym || s == unused_sym)
                     continue;
                 // LLVM 4.0: Assume the variable has default alignment
-#if JL_LLVM_VERSION >= 30800
                 varinfo.dinfo = dbuilder.createAutoVariable(
-#else
-                varinfo.dinfo = dbuilder.createLocalVariable(
-                    llvm::dwarf::DW_TAG_auto_variable,    // Tag
-#endif
                     SP,                     // Scope (current function will be fill in later)
                     jl_symbol_name(s),       // Variable name
                     topfile,                 // File
@@ -5604,9 +5283,6 @@ static std::unique_ptr<Module> emit_function(
                     julia_type_to_di(varinfo.value.typ, &dbuilder, false), // Variable type
                     AlwaysPreserve,          // May be deleted if optimized out
                     DIFlagZero               // Flags (TODO: Do we need any)
-#if JL_LLVM_VERSION < 30800
-                    ,0                       // Argument number (1-based)
-#endif
                     );
             }
         }
@@ -5712,16 +5388,12 @@ static std::unique_ptr<Module> emit_function(
             // slot is not immutable if there are multiple assignments
             varinfo.value.isimmutable &= varinfo.isSA;
             alloc_def_flag(varinfo, &ctx);
-#if JL_LLVM_VERSION >= 30600
             if (ctx.debug_enabled && varinfo.dinfo) {
                 assert((Metadata*)varinfo.dinfo->getType() != jl_pvalue_dillvmt);
                 dbuilder.insertDeclare(lv, varinfo.dinfo, dbuilder.createExpression(),
-#if JL_LLVM_VERSION >= 30700
                                        topdebugloc,
-#endif
                                        builder.GetInsertBlock());
             }
-#endif
             continue;
         }
         if (!varinfo.isArgument || // always need a slot if the variable is assigned
@@ -5739,7 +5411,6 @@ static std::unique_ptr<Module> emit_function(
                 false);
             SI->insertAfter(ctx.ptlsStates);
             varinfo.boxroot = av;
-#if JL_LLVM_VERSION >= 30600
             if (ctx.debug_enabled && varinfo.dinfo) {
                 DIExpression *expr;
                 if ((Metadata*)varinfo.dinfo->getType() == jl_pvalue_dillvmt) {
@@ -5751,12 +5422,9 @@ static std::unique_ptr<Module> emit_function(
                     expr = dbuilder.createExpression(addr);
                 }
                 dbuilder.insertDeclare(av, varinfo.dinfo, expr,
-#if JL_LLVM_VERSION >= 30700
                                             topdebugloc,
-#endif
                                 builder.GetInsertBlock());
             }
-#endif
         }
         maybe_alloc_arrayvar(i, &ctx);
     }
@@ -5808,7 +5476,6 @@ static std::unique_ptr<Module> emit_function(
                 else {
                     Value *argPtr = builder.CreateGEP(argArray, ConstantInt::get(T_size, i-1));
                     theArg = mark_julia_type(builder.CreateLoad(argPtr), true, vi.value.typ, &ctx, /*needsgcroot*/false);
-#if JL_LLVM_VERSION >= 30600
                     if (ctx.debug_enabled && vi.dinfo && !vi.boxroot && !vi.value.V) {
                         SmallVector<uint64_t, 8> addr;
                         addr.push_back(llvm::dwarf::DW_OP_deref);
@@ -5817,12 +5484,9 @@ static std::unique_ptr<Module> emit_function(
                         if ((Metadata*)vi.dinfo->getType() != jl_pvalue_dillvmt)
                             addr.push_back(llvm::dwarf::DW_OP_deref);
                         dbuilder.insertDeclare(pargArray, vi.dinfo, dbuilder.createExpression(addr),
-#if JL_LLVM_VERSION >= 30700
                                         topdebugloc,
-#endif
                                         builder.GetInsertBlock());
                     }
-#endif
                 }
             }
 
@@ -5830,7 +5494,6 @@ static std::unique_ptr<Module> emit_function(
                 assert(vi.value.V == NULL && "unexpected variable slot created for argument");
                 // keep track of original (possibly boxed) value to avoid re-boxing or moving
                 vi.value = theArg;
-#if JL_LLVM_VERSION >= 30600
                 if (specsig && theArg.V && ctx.debug_enabled && vi.dinfo) {
                     SmallVector<uint64_t, 8> addr;
                     if ((Metadata*)vi.dinfo->getType() != jl_pvalue_dillvmt && theArg.ispointer())
@@ -5841,12 +5504,9 @@ static std::unique_ptr<Module> emit_function(
                         builder.CreateStore(theArg.V, parg);
                     }
                     dbuilder.insertDeclare(parg, vi.dinfo, dbuilder.createExpression(addr),
-#if JL_LLVM_VERSION >= 30700
                                                 topdebugloc,
-#endif
                                                 builder.GetInsertBlock());
                 }
-#endif
             }
             else {
                 Value *argp = boxed(theArg, &ctx, false); // skip the temporary gcroot since it would be folded to argp anyways
@@ -5871,21 +5531,12 @@ static std::unique_ptr<Module> emit_function(
         else if (!vi.value.constant) {
             // restarg = jl_f_tuple(NULL, &args[nreq], nargs-nreq)
             if (vi.boxroot != NULL) {
-#if JL_LLVM_VERSION >= 30700
                 Value *restTuple =
                     builder.CreateCall(prepare_call(jltuple_func), {maybe_decay_untracked(V_null),
                                         builder.CreateGEP(argArray,
                                                           ConstantInt::get(T_size,nreq-1)),
                                         builder.CreateSub(argCount,
                                                           ConstantInt::get(T_int32,nreq-1))});
-#else
-                Value *restTuple =
-                    builder.CreateCall3(prepare_call(jltuple_func), maybe_decay_untracked(V_null),
-                                        builder.CreateGEP(argArray,
-                                                          ConstantInt::get(T_size,nreq-1)),
-                                        builder.CreateSub(argCount,
-                                                          ConstantInt::get(T_int32,nreq-1)));
-#endif
                 builder.CreateStore(restTuple, vi.boxroot);
                 emit_local_root(&ctx, &vi); // create a root for vi
             }
@@ -5909,11 +5560,7 @@ static std::unique_ptr<Module> emit_function(
     };
     struct DbgState {
         DebugLoc loc;
-#if JL_LLVM_VERSION >= 30700
         DISubprogram *sp;
-#else
-        DISubprogram sp;
-#endif
         StringRef file;
         ssize_t line;
         bool in_user_code;
@@ -5970,11 +5617,7 @@ static std::unique_ptr<Module> emit_function(
             }
             MDNode *inlinedAt = NULL;
             if (DI_stack.size() > 0) {
-#if JL_LLVM_VERSION >= 30700
                 inlinedAt = DI_stack.back().loc;
-#else
-                inlinedAt = DI_stack.back().loc.getAsMDNode(jl_LLVMContext);
-#endif
             }
             if (ctx.debug_enabled)
                 cur_prop.loc = DebugLoc::get(lno, 0, SP, inlinedAt);
@@ -5990,11 +5633,7 @@ static std::unique_ptr<Module> emit_function(
                 jl_sym_t *filesym = (jl_sym_t*)jl_exprarg(expr, 1);
                 if (filesym != empty_sym)
                     new_filename = jl_symbol_name(filesym);
-#if JL_LLVM_VERSION >= 30700
                 DIFile *new_file = nullptr;
-#else
-                DIFile new_file;
-#endif
                 if (ctx.debug_enabled)
                     new_file = dbuilder.createFile(new_filename, ".");
                 DI_stack.push_back(DbgState{cur_prop.loc, SP,
@@ -6034,11 +5673,7 @@ static std::unique_ptr<Module> emit_function(
                                                  true,
                                                  nullptr);
                     MDNode *inlinedAt = NULL;
-#if JL_LLVM_VERSION >= 30700
                     inlinedAt = cur_prop.loc;
-#else
-                    inlinedAt = cur_prop.loc.getAsMDNode(jl_LLVMContext);
-#endif
                     cur_prop.loc = DebugLoc::get(inlined_func_lineno,
                                                  0, SP, inlinedAt);
                 }
@@ -6337,11 +5972,7 @@ static std::unique_ptr<Module> emit_function(
                                      builder.CreateLoad(emit_exc_in_transit(&ctx), true)),
                                  resetstkoflw_blk, handlr);
             builder.SetInsertPoint(resetstkoflw_blk);
-            builder.CreateCall(prepare_call(resetstkoflw_func)
-#                          if JL_LLVM_VERSION >= 30700
-                               , {}
-#                          endif
-                );
+            builder.CreateCall(prepare_call(resetstkoflw_func), {});
             builder.CreateBr(handlr);
 #else
             builder.CreateCondBr(isz, tryblk, handlr);
@@ -6403,20 +6034,8 @@ std::pair<MDNode*,MDNode*> tbaa_make_child(const char *name, MDNode *parent=null
     static MDNode *tbaa_root = mbuilder->createTBAARoot("jtbaa");
     if (!parent)
         parent = tbaa_root;
-#if JL_LLVM_VERSION >= 30700
     MDNode *scalar = mbuilder->createTBAAScalarTypeNode(name, parent);
     MDNode *n = mbuilder->createTBAAStructTagNode(scalar, scalar, 0, isConstant);
-#else
-    MDNode *n = mbuilder->createTBAANode(name, parent, isConstant);
-    MDNode *scalar = n;
-#if JL_LLVM_VERSION < 30600
-#if JL_LLVM_VERSION >= 30500
-    n->setValueName(ValueName::Create(name));
-#else
-    n->setValueName(ValueName::Create(name, name + strlen(name)));
-#endif
-#endif
-#endif
     return std::make_pair(n, scalar);
 }
 
@@ -6468,10 +6087,6 @@ extern "C" void jl_fptr_to_llvm(jl_fptr_t fptr, jl_method_instance_t *lam, int s
         else if (lam->jlcall_api == 1)
             funcName << "jsys1_"; // it's a jlcall without a specsig
         const char* unadorned_name = jl_symbol_name(lam->def.method->name);
-#if (defined(_OS_LINUX_) && JL_LLVM_VERSION < 30400)
-        if (unadorned_name[0] == '@')
-            unadorned_name++;
-#endif
         funcName << unadorned_name << "_" << globalUnique++;
         if (specsig) { // assumes !va
             Function *f = get_specsig_function(shadow_output, funcName.str(), lam->specTypes, lam->rettype).decl;
@@ -6497,11 +6112,6 @@ extern "C" void jl_fptr_to_llvm(jl_fptr_t fptr, jl_method_instance_t *lam, int s
     }
 }
 
-#if LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR == 3 && defined(SYSTEM_LLVM)
-#define INSTCOMBINE_BUG
-#define V128_BUG
-#endif
-
 static void init_julia_llvm_meta(void)
 {
     tbaa_gcframe = tbaa_make_child("jtbaa_gcframe").first;
@@ -6564,42 +6174,25 @@ static void init_julia_llvm_env(Module *m)
 
     // add needed base debugging definitions to our LLVM environment
     DIBuilder dbuilder(*m);
-#if JL_LLVM_VERSION >= 30700
     DIFile *julia_h = dbuilder.createFile("julia.h","");
     jl_value_dillvmt = dbuilder.createStructType(nullptr,
-#else
-    DIFile julia_h = dbuilder.createFile("julia.h","");
-    jl_value_dillvmt = dbuilder.createStructType(DIDescriptor(),
-#endif
         "jl_value_t",
         julia_h,
         71, // At the time of this writing. Not sure if it's worth it to keep this in sync
         0 * 8, // sizeof(jl_value_t) * 8,
         __alignof__(void*) * 8, // __alignof__(jl_value_t) * 8,
         DIFlagZero, // Flags
-#if JL_LLVM_VERSION >= 30700
         nullptr,    // Derived from
         nullptr);  // Elements - will be corrected later
-#else
-        DIType(), // Derived from
-        DIArray()); // Elements - will be corrected later
-#endif
 
     jl_pvalue_dillvmt = dbuilder.createPointerType(jl_value_dillvmt, sizeof(jl_value_t*) * 8,
                                                    __alignof__(jl_value_t*) * 8);
 
-#if JL_LLVM_VERSION >= 30600
     SmallVector<llvm::Metadata *, 1> Elts;
     std::vector<Metadata*> diargs(0);
     Elts.push_back(jl_pvalue_dillvmt);
     dbuilder.replaceArrays(jl_value_dillvmt,
        dbuilder.getOrCreateArray(Elts));
-#else
-    SmallVector<llvm::Value *, 1> Elts;
-    std::vector<Value*> diargs(0);
-    Elts.push_back(jl_pvalue_dillvmt);
-    jl_value_dillvmt.setTypeArray(dbuilder.getOrCreateArray(Elts));
-#endif
 
     jl_ppvalue_dillvmt = dbuilder.createPointerType(jl_pvalue_dillvmt,sizeof(jl_value_t**)*8,
                                                     __alignof__(jl_value_t**)*8);
@@ -6610,22 +6203,10 @@ static void init_julia_llvm_env(Module *m)
     // Third argument (length(argv))
     diargs.push_back(julia_type_to_di((jl_value_t*)jl_int32_type,&dbuilder,false));
 
-#if JL_LLVM_VERSION >= 30800
     jl_di_func_sig = dbuilder.createSubroutineType(
         dbuilder.getOrCreateTypeArray(diargs));
     jl_di_func_null_sig = dbuilder.createSubroutineType(
         dbuilder.getOrCreateTypeArray(None));
-#elif JL_LLVM_VERSION >= 30600
-    jl_di_func_sig = dbuilder.createSubroutineType(julia_h,
-        dbuilder.getOrCreateTypeArray(diargs));
-    jl_di_func_null_sig = dbuilder.createSubroutineType(julia_h,
-        dbuilder.getOrCreateTypeArray(None));
-#else
-    jl_di_func_sig = dbuilder.createSubroutineType(julia_h,
-        dbuilder.getOrCreateArray(diargs));
-    jl_di_func_null_sig = dbuilder.createSubroutineType(julia_h,
-        dbuilder.getOrCreateArray(ArrayRef<Value*>()));
-#endif
 
     T_jlvalue = StructType::create(jl_LLVMContext, "jl_value_t");
     T_pjlvalue = PointerType::get(T_jlvalue, 0);
@@ -7200,30 +6781,8 @@ static void init_julia_llvm_env(Module *m)
                            NULL, "jl_world_counter");
     add_named_global(jlgetworld_global, &jl_world_counter);
 
-    // set up optimization passes
-#if JL_LLVM_VERSION >= 30700
-// No DataLayout pass needed anymore.
-#elif JL_LLVM_VERSION >= 30600
-    jl_data_layout = new llvm::DataLayoutPass();
-#elif JL_LLVM_VERSION >= 30500
-    jl_data_layout = new llvm::DataLayoutPass(*jl_ExecutionEngine->getDataLayout());
-#else
-    jl_data_layout = new DataLayout(*jl_ExecutionEngine->getDataLayout());
-#endif
-
-#if JL_LLVM_VERSION >= 30700
     jl_globalPM = new legacy::PassManager();
-#else
-    jl_globalPM = new PassManager();
-#endif
-#if JL_LLVM_VERSION < 30700
-    jl_globalPM->add(new TargetLibraryInfo(Triple(jl_TargetMachine->getTargetTriple())));
-#else
     jl_globalPM->add(new TargetLibraryInfoWrapperPass(Triple(jl_TargetMachine->getTargetTriple())));
-#endif
-#if JL_LLVM_VERSION < 30700
-    jl_globalPM->add(jl_data_layout);
-#endif
     addOptimizationPasses(jl_globalPM, jl_options.opt_level);
 }
 
@@ -7314,17 +6873,7 @@ static inline SmallVector<std::string,10> getTargetFeatures(std::string &cpu)
     }
 
     // Platform specific overides follow
-#if defined(_CPU_X86_64_) || defined(_CPU_X86_)
-#ifndef USE_MCJIT
-    // Temporarily disable Haswell BMI2 features due to LLVM bug.
-    HostFeatures["bmi2"] = false;
-    HostFeatures["avx2"] = false;
-#endif
-#ifdef V128_BUG
-    HostFeatures["avx"] = false;
-#endif
-#endif
-#if defined(_CPU_X86_64_) && JL_LLVM_VERSION >= 30600
+#if defined(_CPU_X86_64_)
     // Require cx16 (cmpxchg16b)
     // We need this for 128-bit atomic operations. We only need this
     // when threading is enabled; however, to test whether this
@@ -7436,11 +6985,6 @@ extern "C" void *jl_init_llvm(void)
     jl_init_debuginfo();
     jl_init_runtime_ccall();
 
-#if JL_LLVM_VERSION < 30400
-    // this option disables LLVM's signal handlers
-    llvm::DisablePrettyStackTrace = true;
-#endif
-
 #ifdef USE_POLLY
     PassRegistry &Registry = *PassRegistry::getPassRegistry();
     polly::initializePollyPasses(Registry);
@@ -7454,52 +6998,24 @@ extern "C" void *jl_init_llvm(void)
 
     Module *m, *engine_module;
     engine_module = new Module("julia", jl_LLVMContext);
-#ifdef USE_MCJIT
     m = new Module("julia", jl_LLVMContext);
-#else
-    m = engine_module;
-#endif
     shadow_output = m;
 
     TargetOptions options = TargetOptions();
     //options.PrintMachineCode = true; //Print machine code produced during JIT compiling
-#if defined(JL_DEBUG_BUILD) && JL_LLVM_VERSION < 30700
-    options.JITEmitDebugInfo = true;
-#endif
-#if JL_LLVM_VERSION < 30700
-    options.NoFramePointerElim = true;
-#endif
-#if JL_LLVM_VERSION < 30400
-    options.NoFramePointerElimNonLeaf = true;
-#endif
 #if defined(_OS_WINDOWS_) && !defined(_CPU_X86_64_)
     // tell Win32 to assume the stack is always 16-byte aligned,
     // and to ensure that it is 16-byte aligned for out-going calls,
     // to ensure compatibility with GCC codes
     options.StackAlignmentOverride = 16;
 #endif
-#if defined(__APPLE__) && JL_LLVM_VERSION < 30400
-    // turn on JIT support for libunwind to walk the stack
-    options.JITExceptionHandling = 1;
-#endif
-
-#if JL_LLVM_VERSION >= 30600
     EngineBuilder eb((std::unique_ptr<Module>(engine_module)));
-#else
-    EngineBuilder eb(engine_module);
-#endif
     std::string ErrorStr;
     eb  .setEngineKind(EngineKind::JIT)
-#if defined(_OS_WINDOWS_) && defined(_CPU_X86_64_) && !defined(USE_MCJIT)
-        .setJITMemoryManager(createJITMemoryManagerWin())
-#elif defined(USE_MCJIT)
         .setMCJITMemoryManager(std::unique_ptr<RTDyldMemoryManager>{createRTDyldMemoryManager()})
-#endif
         .setTargetOptions(options)
 #if (defined(_OS_LINUX_) && defined(_CPU_X86_64_))
         .setRelocationModel(Reloc::PIC_)
-#elif JL_LLVM_VERSION < 30900
-        .setRelocationModel(Reloc::Default)
 #endif
 #ifdef _P64
         .setCodeModel(CodeModel::Large)
@@ -7511,20 +7027,13 @@ extern "C" void *jl_init_llvm(void)
 #else
         .setOptLevel(jl_options.opt_level == 0 ? CodeGenOpt::None : CodeGenOpt::Aggressive)
 #endif
-#if defined(USE_MCJIT) && JL_LLVM_VERSION < 30600
-        .setUseMCJIT(true)
-#endif
 #ifdef USE_ORCMCJIT
         .setUseOrcMCJITReplacement(true)
 #endif
     ;
     Triple TheTriple(sys::getProcessTriple());
 #if defined(FORCE_ELF)
-#if JL_LLVM_VERSION >= 30500
     TheTriple.setObjectFormat(Triple::ELF);
-#else
-    TheTriple.setEnvironment(Triple::ELF);
-#endif
 #endif
     std::string TheCPU;
     SmallVector<std::string, 10> targetFeatures = getTargetFeatures(TheCPU);
@@ -7535,7 +7044,7 @@ extern "C" void *jl_init_llvm(void)
             targetFeatures);
     assert(jl_TargetMachine && "Failed to select target machine -"
                                " Is the LLVM backend for this CPU enabled?");
-    #if defined(USE_MCJIT) && (!defined(_CPU_ARM_) && !defined(_CPU_PPC64_))
+    #if (!defined(_CPU_ARM_) && !defined(_CPU_PPC64_))
     // FastISel seems to be buggy for ARM. Ref #13321
     if (jl_options.opt_level < 2)
         jl_TargetMachine->setFastISel(true);
@@ -7552,7 +7061,7 @@ extern "C" void *jl_init_llvm(void)
                   ErrorStr.c_str());
         exit(1);
     }
-#if JL_LLVM_VERSION >= 30500 && !defined(USE_ORCMCJIT)
+#if !defined(USE_ORCMCJIT)
     jl_ExecutionEngine->setProcessAllSections(true);
 #endif
     jl_ExecutionEngine->DisableLazyCompilation();
diff --git a/src/codegen_internal.h b/src/codegen_internal.h
index 1ee60e0611af44..49543b27199b5f 100644
--- a/src/codegen_internal.h
+++ b/src/codegen_internal.h
@@ -2,36 +2,19 @@
 
 #include "codegen_shared.h"
 
-#if defined(USE_ORCJIT) && JL_LLVM_VERSION <= 30800
-#  include <llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h>
-void notifyObjectLoaded(RTDyldMemoryManager *memmgr,
-                        llvm::orc::ObjectLinkingLayerBase::ObjSetHandleT H);
-#endif
-
 // Declarations for disasm.cpp
 extern "C"
 void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
-#ifndef USE_MCJIT
-                          std::vector<JITEvent_EmittedFunctionDetails::LineStart> lineinfo,
-#endif
                           const object::ObjectFile *object,
                           llvm::DIContext *context,
-#if JL_LLVM_VERSION >= 30700
                           raw_ostream &rstream,
-#else
-                          formatted_raw_ostream &stream,
-#endif
                           const char* asm_variant="att"
                           );
 
 // Declarations for debuginfo.cpp
 extern int jl_DI_for_fptr(uint64_t fptr, uint64_t *symsize, int64_t *slide, int64_t *section_slide,
                       const object::ObjectFile **object,
-#ifdef USE_MCJIT
                       llvm::DIContext **context
-#else
-                      std::vector<JITEvent_EmittedFunctionDetails::LineStart> *lines
-#endif
                       );
 
 extern bool jl_dylib_DI_for_fptr(size_t pointer, const object::ObjectFile **object, llvm::DIContext **context, int64_t *slide, int64_t *section_slide,
@@ -43,6 +26,4 @@ void *lookupWriteAddressFor(RTDyldMemoryManager *memmgr, void *rt_addr);
 #endif
 #endif
 
-#ifdef USE_MCJIT
 RTDyldMemoryManager* createRTDyldMemoryManager(void);
-#endif
diff --git a/src/debuginfo.cpp b/src/debuginfo.cpp
index 558bb83fcff71e..95106b098321ce 100644
--- a/src/debuginfo.cpp
+++ b/src/debuginfo.cpp
@@ -6,37 +6,22 @@
 #include <llvm/ExecutionEngine/ExecutionEngine.h>
 #include <llvm/ExecutionEngine/JITEventListener.h>
 #include <llvm/DebugInfo/DIContext.h>
-#if JL_LLVM_VERSION >= 30700
 #include <llvm/DebugInfo/DWARF/DWARFContext.h>
 #include <llvm/Object/SymbolSize.h>
-#endif
 #include <llvm/Support/MemoryBuffer.h>
 #include <llvm/IR/Function.h>
 #include <llvm/ADT/StringRef.h>
 #include <llvm/ADT/StringMap.h>
-#if JL_LLVM_VERSION >= 30500
 #include <llvm/IR/DebugInfo.h>
-#else
-#include <llvm/DebugInfo.h>
-#endif
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
 #include <llvm/IR/DataLayout.h>
 #include <llvm/IR/Mangler.h>
-#if JL_LLVM_VERSION < 30600
-#include <llvm/ExecutionEngine/ObjectImage.h>
-#endif
 #include <llvm/ExecutionEngine/RuntimeDyld.h>
-#else
-#include <llvm/ExecutionEngine/JITMemoryManager.h>
-#endif
 #if JL_LLVM_VERSION >= 50000
 #include <llvm/BinaryFormat/Magic.h>
 #endif
 #include <llvm/Object/MachO.h>
 #include <llvm/Object/COFF.h>
-#if JL_LLVM_VERSION >= 30700
-#  include <llvm/Object/ELFObjectFile.h>
-#endif
+#include <llvm/Object/ELFObjectFile.h>
 #include "fix_llvm_assert.h"
 
 using namespace llvm;
@@ -63,13 +48,7 @@ using llvm_file_magic = sys::fs::file_magic;
 #include <cstdio>
 #include <cassert>
 
-#if JL_LLVM_VERSION >= 30500 && JL_LLVM_VERSION < 30600
-extern ExecutionEngine *jl_ExecutionEngine;
-#endif
-
-#ifdef USE_MCJIT
 typedef object::SymbolRef SymRef;
-#endif
 
 // Any function that acquires this lock must be either a unmanaged thread
 // or in the GC safe region and must NOT allocate anything through the GC
@@ -85,26 +64,12 @@ extern "C" void jl_init_debuginfo()
 
 // --- storing and accessing source location metadata ---
 
-#ifndef USE_MCJIT
-struct FuncInfo {
-    const Function *func;
-    size_t lengthAdr;
-    std::vector<JITEvent_EmittedFunctionDetails::LineStart> lines;
-    jl_method_instance_t *linfo;
-};
-#else
 struct ObjectInfo {
     const object::ObjectFile *object;
     size_t SectionSize;
     ptrdiff_t slide;
-#if JL_LLVM_VERSION >= 30700
     DIContext *context;
-#endif
-#if defined(_OS_DARWIN_) && JL_LLVM_VERSION < 30700
-    const char *name;
-#endif
 };
-#endif
 
 // Maintain a mapping of unrealized function names -> linfo objects
 // so that when we see it get emitted, we can add a link back to the linfo
@@ -112,16 +77,12 @@ struct ObjectInfo {
 static StringMap<jl_method_instance_t*> linfo_in_flight;
 static std::string mangle(const std::string &Name, const DataLayout &DL)
 {
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
     std::string MangledName;
     {
         raw_string_ostream MangledNameStream(MangledName);
         Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
     }
     return MangledName;
-#else
-    return Name;
-#endif
 }
 void jl_add_linfo_in_flight(StringRef name, jl_method_instance_t *linfo, const DataLayout &DL)
 {
@@ -135,30 +96,7 @@ static void create_PRUNTIME_FUNCTION(uint8_t *Code, size_t Size, StringRef fnnam
     // GC safe
     DWORD mod_size = 0;
 #if defined(_CPU_X86_64_)
-#if !defined(USE_MCJIT)
-    uint8_t *catchjmp = Section+Allocated;
-    UnwindData = (uint8_t*)(((uintptr_t)catchjmp+12+3)&~(uintptr_t)3);
-    if (!catchjmp[0]) {
-        catchjmp[0] = 0x48;
-        catchjmp[1] = 0xb8; // mov RAX, QWORD PTR [...]
-        *(uint64_t*)(&catchjmp[2]) = (uint64_t)&__julia_personality;
-        catchjmp[10] = 0xff;
-        catchjmp[11] = 0xe0; // jmp RAX
-        UnwindData[0] = 0x09; // version info, UNW_FLAG_EHANDLER
-        UnwindData[1] = 4;    // size of prolog (bytes)
-        UnwindData[2] = 2;    // count of unwind codes (slots)
-        UnwindData[3] = 0x05; // frame register (rbp) = rsp
-        UnwindData[4] = 4;    // second instruction
-        UnwindData[5] = 0x03; // mov RBP, RSP
-        UnwindData[6] = 1;    // first instruction
-        UnwindData[7] = 0x50; // push RBP
-        *(DWORD*)&UnwindData[8] = (DWORD)(catchjmp - Section); // relative location of catchjmp
-        mod_size = (DWORD)Allocated+48;
-    }
-    PRUNTIME_FUNCTION tbl = (PRUNTIME_FUNCTION)(UnwindData+12);
-#else
     PRUNTIME_FUNCTION tbl = (PRUNTIME_FUNCTION)malloc(sizeof(RUNTIME_FUNCTION));
-#endif
     tbl->BeginAddress = (DWORD)(Code - Section);
     tbl->EndAddress = (DWORD)(Code - Section + Size);
     tbl->UnwindData = (DWORD)(UnwindData - Section);
@@ -170,9 +108,6 @@ static void create_PRUNTIME_FUNCTION(uint8_t *Code, size_t Size, StringRef fnnam
         assert(!jl_in_stackwalk);
         jl_in_stackwalk = 1;
         if (mod_size && !SymLoadModuleEx(GetCurrentProcess(), NULL, NULL, NULL, (DWORD64)Section, mod_size, NULL, SLMFLAG_VIRTUAL)) {
-#if defined(_CPU_X86_64_) && !defined(USE_MCJIT)
-            catchjmp[0] = 0;
-#endif
             static int warned = 0;
             if (!warned) {
                 jl_printf(JL_STDERR, "WARNING: failed to insert module info for backtrace: %lu\n", GetLastError());
@@ -210,14 +145,12 @@ struct revcomp {
     { return lhs>rhs; }
 };
 
-#if JL_LLVM_VERSION >= 30800
 struct strrefcomp {
     bool operator() (const StringRef& lhs, const StringRef& rhs) const
     {
         return lhs.compare(rhs) > 0;
     }
 };
-#endif
 
 extern "C" tracer_cb jl_linfo_tracer;
 static std::vector<jl_method_instance_t*> triggered_linfos;
@@ -234,61 +167,13 @@ void jl_callback_triggered_linfos(void)
 
 class JuliaJITEventListener: public JITEventListener
 {
-#ifndef USE_MCJIT
-    std::map<size_t, FuncInfo, revcomp> info;
-#else
     std::map<size_t, ObjectInfo, revcomp> objectmap;
     std::map<size_t, std::pair<size_t, jl_method_instance_t *>, revcomp> linfomap;
-#endif
 
 public:
     JuliaJITEventListener(){}
     virtual ~JuliaJITEventListener() {}
 
-#ifndef USE_MCJIT
-    virtual void NotifyFunctionEmitted(const Function &F, void *Code,
-                                       size_t Size, const EmittedFunctionDetails &Details)
-    {
-        jl_ptls_t ptls = jl_get_ptls_states();
-        // This function modify linfo->fptr in GC safe region.
-        // This should be fine since the GC won't scan this field.
-        int8_t gc_state = jl_gc_safe_enter(ptls);
-        uv_rwlock_wrlock(&threadsafe);
-        StringRef sName = F.getName();
-        StringMap<jl_method_instance_t*>::iterator linfo_it = linfo_in_flight.find(sName);
-        jl_method_instance_t *linfo = NULL;
-        if (linfo_it != linfo_in_flight.end()) {
-            linfo = linfo_it->second;
-            linfo_in_flight.erase(linfo_it);
-            if (!linfo->fptr && linfo->functionObjectsDecls.functionObject &&
-                    ((Function*)linfo->functionObjectsDecls.functionObject)->getName().equals(sName)) {
-                int jlcall_api = jl_jlcall_api(&F);
-                if (linfo->inferred || jlcall_api != 1) {
-                    linfo->jlcall_api = jlcall_api;
-                    linfo->fptr = (jl_fptr_t)(uintptr_t)Code;
-                }
-                else {
-                    linfo->unspecialized_ducttape = (jl_fptr_t)(uintptr_t)Code;
-                }
-            }
-        }
-#if defined(_OS_WINDOWS_)
-        create_PRUNTIME_FUNCTION((uint8_t*)Code, Size, F.getName(), (uint8_t*)Code, Size, NULL);
-#endif
-        FuncInfo tmp = {&F, Size, Details.LineStarts, linfo};
-        info[(size_t)(Code)] = tmp;
-        uv_rwlock_wrunlock(&threadsafe);
-        jl_gc_safe_leave(ptls, gc_state);
-    }
-
-    std::map<size_t, FuncInfo, revcomp>& getMap()
-    {
-        uv_rwlock_rdlock(&threadsafe);
-        return info;
-    }
-#endif // ifndef USE_MCJIT
-
-#ifdef USE_MCJIT
     jl_method_instance_t *lookupLinfo(size_t pointer)
     {
         auto linfo = linfomap.lower_bound(pointer);
@@ -297,7 +182,6 @@ class JuliaJITEventListener: public JITEventListener
         else
             return NULL;
     }
-#if JL_LLVM_VERSION >= 30600
 
     virtual void NotifyObjectEmitted(const object::ObjectFile &obj,
                                      const RuntimeDyld::LoadedObjectInfo &L)
@@ -309,24 +193,15 @@ class JuliaJITEventListener: public JITEventListener
                                       const object::ObjectFile &debugObj,
                                       const RuntimeDyld::LoadedObjectInfo &L,
                                       RTDyldMemoryManager *memmgr)
-#else
-    virtual void NotifyObjectEmitted(const ObjectImage &obj)
-#endif
     {
         jl_ptls_t ptls = jl_get_ptls_states();
         // This function modify linfo->fptr in GC safe region.
         // This should be fine since the GC won't scan this field.
         int8_t gc_state = jl_gc_safe_enter(ptls);
         uv_rwlock_wrlock(&threadsafe);
-#if JL_LLVM_VERSION >= 30600
         object::section_iterator Section = debugObj.section_begin();
         object::section_iterator EndSection = debugObj.section_end();
-#else
-        object::section_iterator Section = debugObj.begin_sections();
-        object::section_iterator EndSection = debugObj.end_sections();
-#endif
 
-#if JL_LLVM_VERSION >= 30800
         std::map<StringRef,object::SectionRef,strrefcomp> loadedSections;
         for (const object::SectionRef &lSection: obj.sections()) {
             StringRef sName;
@@ -340,7 +215,6 @@ class JuliaJITEventListener: public JITEventListener
                 return 0;
             return L.getSectionLoadAddress(search->second);
         };
-#endif
 
 #ifdef _CPU_ARM_
         // ARM does not have/use .eh_frame
@@ -361,11 +235,7 @@ class JuliaJITEventListener: public JITEventListener
                     continue;
                 }
             }
-#if JL_LLVM_VERSION >= 30800
             uint64_t loadaddr = L.getSectionLoadAddress(section);
-#else
-            uint64_t loadaddr = L.getSectionLoadAddress(sName);
-#endif
             size_t seclen = section.getSize();
             if (istext) {
                 arm_text_addr = loadaddr;
@@ -402,13 +272,9 @@ class JuliaJITEventListener: public JITEventListener
         uint8_t *catchjmp = NULL;
         for (const object::SymbolRef &sym_iter : debugObj.symbols()) {
             StringRef sName;
-#if JL_LLVM_VERSION >= 30700
             auto sNameOrError = sym_iter.getName();
             assert(sNameOrError);
             sName = sNameOrError.get();
-#else
-            sym_iter.getName(sName);
-#endif
             uint8_t **pAddr = NULL;
             if (sName.equals("__UnwindData")) {
                 pAddr = &UnwindData;
@@ -418,7 +284,6 @@ class JuliaJITEventListener: public JITEventListener
             }
             if (pAddr) {
                 uint64_t Addr, SectionAddr, SectionLoadAddr;
-#if JL_LLVM_VERSION >= 30800
                 auto AddrOrError = sym_iter.getAddress();
                 assert(AddrOrError);
                 Addr = AddrOrError.get();
@@ -429,42 +294,16 @@ class JuliaJITEventListener: public JITEventListener
                 SectionAddr = Section->getAddress();
                 Section->getName(sName);
                 SectionLoadAddr = getLoadAddress(sName);
-#elif JL_LLVM_VERSION >= 30700
-                auto AddrOrError = sym_iter.getAddress();
-                assert(AddrOrError);
-                Addr = AddrOrError.get();
-                sym_iter.getSection(Section);
-                assert(Section != EndSection && Section->isText());
-                Section->getName(sName);
-                SectionAddr = Section->getAddress();
-                SectionLoadAddr = L.getSectionLoadAddress(sName);
-#elif JL_LLVM_VERSION >= 30600
-                sym_iter.getAddress(Addr);
-                sym_iter.getSection(Section);
-                assert(Section != EndSection && Section->isText());
-                Section->getName(sName);
-                SectionAddr = Section->getAddress();
-                SectionLoadAddr = L.getSectionLoadAddress(sName);
-#else // JL_LLVM_VERSION >= 30500
-                sym_iter.getAddress(Addr);
-                sym_iter.getSection(Section);
-                assert(Section != EndSection);
-                assert(!Section->isText(isText) && isText);
-                Section->getAddress(SectionAddr);
-                Section->getAddress(SectionLoadAddr);
-#endif
                 Addr -= SectionAddr - SectionLoadAddr;
                 *pAddr = (uint8_t*)Addr;
                 if (SectionAddrCheck)
                     assert(SectionAddrCheck == SectionLoadAddr);
                 else
                     SectionAddrCheck = SectionLoadAddr;
-#ifdef USE_ORCJIT
                 if (memmgr)
                     SectionAddr =
                         (uintptr_t)lookupWriteAddressFor(memmgr,
                                                          (void*)SectionLoadAddr);
-#endif
                 if (SectionLoadOffset != 1)
                     assert(SectionLoadOffset == SectionAddr - SectionLoadAddr);
                 else
@@ -493,39 +332,26 @@ class JuliaJITEventListener: public JITEventListener
 #endif // defined(_OS_X86_64_)
 #endif // defined(_OS_WINDOWS_)
 
-#if JL_LLVM_VERSION >= 30700
         auto symbols = object::computeSymbolSizes(debugObj);
         bool first = true;
         for(const auto &sym_size : symbols) {
             const object::SymbolRef &sym_iter = sym_size.first;
-#if JL_LLVM_VERSION >= 30900
             auto SymbolTypeOrError = sym_iter.getType();
             assert(SymbolTypeOrError);
             object::SymbolRef::Type SymbolType = SymbolTypeOrError.get();
-#else
-            object::SymbolRef::Type SymbolType = sym_iter.getType();
-#endif
             if (SymbolType != object::SymbolRef::ST_Function) continue;
             auto AddrOrError = sym_iter.getAddress();
             assert(AddrOrError);
             uint64_t Addr = AddrOrError.get();
-#if JL_LLVM_VERSION >= 30800
             auto SectionOrError = sym_iter.getSection();
             assert(SectionOrError);
             Section = SectionOrError.get();
-#else
-            sym_iter.getSection(Section);
-#endif
             if (Section == EndSection) continue;
             if (!Section->isText()) continue;
             uint64_t SectionAddr = Section->getAddress();
             StringRef secName;
             Section->getName(secName);
-#if JL_LLVM_VERSION >= 30800
             uint64_t SectionLoadAddr = getLoadAddress(secName);
-#else
-            uint64_t SectionLoadAddr = L.getSectionLoadAddress(secName);
-#endif
             Addr -= SectionAddr - SectionLoadAddr;
             auto sNameOrError = sym_iter.getName();
             assert(sNameOrError);
@@ -572,109 +398,6 @@ class JuliaJITEventListener: public JITEventListener
                 first = false;
            }
         }
-
-#else // pre-LLVM 3.7
-        uint64_t Addr;
-        uint64_t Size;
-        object::SymbolRef::Type SymbolType;
-        StringRef sName;
-        uint64_t SectionLoadAddr = 0, SectionAddr = 0;
-#if JL_LLVM_VERSION < 30600
-        bool isText;
-#endif
-
-#if JL_LLVM_VERSION >= 30500
-        for (const object::SymbolRef &sym_iter : obj.symbols()) {
-            sym_iter.getType(SymbolType);
-            if (SymbolType != object::SymbolRef::ST_Function) continue;
-            sym_iter.getSize(Size);
-            sym_iter.getAddress(Addr);
-            sym_iter.getSection(Section);
-            if (Section == EndSection) continue;
-#if JL_LLVM_VERSION >= 30600
-            if (!Section->isText()) continue;
-            Section->getName(sName);
-            SectionAddr = Section->getAddress();
-            SectionLoadAddr = L.getSectionLoadAddress(sName);
-            Addr += SectionLoadAddr;
-#else
-            if (Section->isText(isText) || !isText) continue;
-            Section->getAddress(SectionAddr);
-            Section->getAddress(SectionLoadAddr);
-#endif
-            sym_iter.getName(sName);
-#ifdef _OS_DARWIN_
-#   if JL_LLVM_VERSION < 30600
-            Addr = ((MCJIT*)jl_ExecutionEngine)->getSymbolAddress(sName, true);
-            if (!Addr && sName[0] == '_') {
-                Addr = ((MCJIT*)jl_ExecutionEngine)->getSymbolAddress(sName.substr(1), true);
-            }
-            if (!Addr) continue;
-#   endif
-#elif defined(_OS_WINDOWS_)
-            uint64_t SectionSize = 0;
-#   if JL_LLVM_VERSION >= 30600
-            SectionSize = Section->getSize();
-#   else
-            Section->getSize(SectionSize);
-#   endif
-            if (SectionAddrCheck)
-                assert(SectionAddrCheck == SectionLoadAddr);
-            else
-                SectionAddrCheck = SectionLoadAddr;
-            create_PRUNTIME_FUNCTION(
-                   (uint8_t*)(uintptr_t)Addr, (size_t)Size, sName,
-                   (uint8_t*)(uintptr_t)SectionLoadAddr, (size_t)SectionSize, UnwindData);
-#endif
-            StringMap<jl_method_instance_t*>::iterator linfo_it = linfo_in_flight.find(sName);
-            jl_method_instance_t *linfo = NULL;
-            if (linfo_it != linfo_in_flight.end()) {
-                linfo = linfo_it->second;
-                linfo_in_flight.erase(linfo_it);
-                Function *F = (Function*)linfo->functionObjectsDecls.functionObject;
-                if (!linfo->fptr && F && F->getName().equals(sName)) {
-                    int jlcall_api = jl_jlcall_api(F);
-                    if (linfo->inferred || jlcall_api != 1) {
-                        linfo->jlcall_api = jlcall_api;
-                        linfo->fptr = (jl_fptr_t)(uintptr_t)Addr;
-                    }
-                    else {
-                        linfo->unspecialized_ducttape = (jl_fptr_t)(uintptr_t)Addr;
-                    }
-                }
-            }
-            if (linfo)
-                linfomap[Addr] = std::make_pair(Size, linfo);
-            const object::ObjectFile *objfile =
-#if JL_LLVM_VERSION >= 30600
-                &obj;
-#else
-                obj.getObjectFile();
-#endif
-            ObjectInfo tmp = {objfile, (size_t)Size,
-                (ptrdiff_t)(SectionAddr - SectionLoadAddr),
-#ifdef _OS_DARWIN_
-                strndup(sName.data(), sName.size()),
-#endif
-                linfo
-            };
-            objectmap[Addr] = tmp;
-        }
-#else //JL_LLVM_VERSION >= 30400
-        error_code itererr;
-        object::symbol_iterator sym_iter = obj.begin_symbols();
-        object::symbol_iterator sym_end = obj.end_symbols();
-        for (; sym_iter != sym_end; sym_iter.increment(itererr)) {
-            sym_iter->getType(SymbolType);
-            if (SymbolType != object::SymbolRef::ST_Function) continue;
-            sym_iter->getAddress(Addr);
-            sym_iter->getSize(Size);
-
-            ObjectInfo tmp = {obj.getObjectFile(), (size_t)Size};
-            objectmap[Addr] = tmp;
-        }
-#endif
-#endif
         uv_rwlock_wrunlock(&threadsafe);
         jl_gc_safe_leave(ptls, gc_state);
     }
@@ -688,7 +411,6 @@ class JuliaJITEventListener: public JITEventListener
         uv_rwlock_rdlock(&threadsafe);
         return objectmap;
     }
-#endif // USE_MCJIT
 };
 
 #ifdef USE_ORCJIT
@@ -769,14 +491,8 @@ static int lookup_pointer(DIContext *context, jl_frame_t **frames,
         return 1;
     }
     jl_mutex_lock_maybe_nogc(&codegen_lock);
-#if JL_LLVM_VERSION >= 30500
     DILineInfoSpecifier infoSpec(DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath,
                                  DILineInfoSpecifier::FunctionNameKind::ShortName);
-#else
-    int infoSpec = DILineInfoSpecifier::FileLineInfo |
-                   DILineInfoSpecifier::AbsoluteFilePath |
-                   DILineInfoSpecifier::FunctionName;
-#endif
 
     auto inlineInfo = context->getInliningInfoForAddress(pointer, infoSpec);
 
@@ -806,11 +522,7 @@ static int lookup_pointer(DIContext *context, jl_frame_t **frames,
         }
 
         jl_frame_t *frame = &(*frames)[i];
-#if JL_LLVM_VERSION < 30500
-        std::string func_name(info.getFunctionName());
-#else
         std::string func_name(info.FunctionName);
-#endif
 
         if (inlined_frame) {
             frame->inlined = 1;
@@ -831,13 +543,8 @@ static int lookup_pointer(DIContext *context, jl_frame_t **frames,
         if (!frame->func_name)
             frame->fromC = 1;
 
-#if JL_LLVM_VERSION < 30500
-        frame->line = info.getLine();
-        std::string file_name(info.getFileName());
-#else
         frame->line = info.Line;
         std::string file_name(info.FileName);
-#endif
 
         if (file_name == "<invalid>")
             frame->file_name = NULL;
@@ -867,41 +574,16 @@ static obfiletype objfilemap;
 
 static bool getObjUUID(llvm::object::MachOObjectFile *obj, uint8_t uuid[16])
 {
-# if JL_LLVM_VERSION >= 30700
     for (auto Load : obj->load_commands())
-# else
-#  if JL_LLVM_VERSION >= 30500
-    uint32_t LoadCommandCount = obj->getHeader().ncmds;
-#  else
-    uint32_t LoadCommandCount = obj->getHeader().NumLoadCommands;
-#  endif
-    llvm::object::MachOObjectFile::LoadCommandInfo Load = obj->getFirstLoadCommandInfo();
-    for (unsigned I = 0; ; ++I)
-# endif
     {
-        if (
-# if JL_LLVM_VERSION >= 30500
-            Load.C.cmd == LC_UUID
-# else
-            Load.C.Type == LC_UUID
-# endif
-            ) {
+        if (Load.C.cmd == LC_UUID) {
             memcpy(uuid, ((const MachO::uuid_command*)Load.Ptr)->uuid, 16);
             return true;
         }
-# if JL_LLVM_VERSION < 30700
-        else if (I == LoadCommandCount - 1) {
-            return false;
-        }
-        else {
-            Load = obj->getNextLoadCommandInfo(Load);
-        }
-# endif
     }
     return false;
 }
 
-#if JL_LLVM_VERSION >= 30600
 struct debug_link_info {
     StringRef filename;
     uint32_t crc32;
@@ -987,42 +669,26 @@ calc_gnu_debuglink_crc32(const void *buf, size_t size)
     return crc ^ ~0U;
 }
 
-#if JL_LLVM_VERSION >= 30900
 static Expected<object::OwningBinary<object::ObjectFile>>
-#else
-static ErrorOr<object::OwningBinary<object::ObjectFile>>
-#endif
 openDebugInfo(StringRef debuginfopath, const debug_link_info &info)
 {
     auto SplitFile = MemoryBuffer::getFile(debuginfopath);
     if (std::error_code EC = SplitFile.getError()) {
-#if JL_LLVM_VERSION >= 30900
         return errorCodeToError(EC);
-#else
-        return EC;
-#endif
     }
 
     uint32_t crc32 = calc_gnu_debuglink_crc32(
             SplitFile.get()->getBufferStart(),
             SplitFile.get()->getBufferSize());
     if (crc32 != info.crc32) {
-#if JL_LLVM_VERSION >= 30900
         return errorCodeToError(object::object_error::arch_not_found);
-#else
-        return object::object_error::arch_not_found;
-#endif
     }
 
     auto error_splitobj = object::ObjectFile::createObjectFile(
             SplitFile.get().get()->getMemBufferRef(),
             llvm_file_magic::unknown);
     if (!error_splitobj) {
-#if JL_LLVM_VERSION >= 30900
         return error_splitobj.takeError();
-#else
-        return error_splitobj.getError();
-#endif
     }
 
     // successfully validated and loaded split debug info file
@@ -1030,7 +696,6 @@ openDebugInfo(StringRef debuginfopath, const debug_link_info &info)
             std::move(error_splitobj.get()),
             std::move(SplitFile.get()));
 }
-#endif
 
 static uint64_t jl_sysimage_base;
 static void **sysimg_fvars;
@@ -1047,7 +712,7 @@ extern "C" void jl_register_fptrs(uint64_t sysimage_base, void **fptrs, jl_metho
 template<typename T>
 static inline void ignoreError(T &err)
 {
-#if JL_LLVM_VERSION >= 30900 && !defined(NDEBUG)
+#if !defined(NDEBUG)
     // Needed only with LLVM assertion build
     consumeError(err.takeError());
 #endif
@@ -1160,12 +825,6 @@ bool jl_dylib_DI_for_fptr(size_t pointer, const llvm::object::ObjectFile **obj,
 #endif
     (void)iswindows;
 
-#if JL_LLVM_VERSION < 30500
-    if (iswindows) {
-        return true;
-    }
-#endif
-
 // GOAL: Read debuginfo from file
     // TODO: need read/write lock here for objfilemap synchronization
     obfiletype::iterator it = objfilemap.find(fbase);
@@ -1184,23 +843,10 @@ bool jl_dylib_DI_for_fptr(size_t pointer, const llvm::object::ObjectFile **obj,
     uint8_t uuid[16], uuid2[16];
     if (isdarwin) {
         size_t msize = (size_t)(((uint64_t)-1) - fbase);
-#if JL_LLVM_VERSION >= 30600
         std::unique_ptr<MemoryBuffer> membuf = MemoryBuffer::getMemBuffer(
                 StringRef((const char *)fbase, msize), "", false);
         auto origerrorobj = llvm::object::ObjectFile::createObjectFile(
             membuf->getMemBufferRef(), llvm_file_magic::unknown);
-#elif JL_LLVM_VERSION >= 30500
-        MemoryBuffer *membuf = MemoryBuffer::getMemBuffer(
-            StringRef((const char *)fbase, msize), "", false);
-        std::unique_ptr<MemoryBuffer> buf(membuf);
-        auto origerrorobj = llvm::object::ObjectFile::createObjectFile(
-            buf, llvm_file_magic::unknown);
-#else
-        MemoryBuffer *membuf = MemoryBuffer::getMemBuffer(
-            StringRef((const char *)fbase, msize), "", false);
-        std::unique_ptr<llvm::object::ObjectFile> origerrorobj(llvm::object::ObjectFile::createObjectFile(
-            membuf));
-#endif
         if (!origerrorobj) {
             objfileentry_t entry = {};
             objfilemap[fbase] = entry;
@@ -1208,11 +854,7 @@ bool jl_dylib_DI_for_fptr(size_t pointer, const llvm::object::ObjectFile **obj,
         }
 
         llvm::object::MachOObjectFile *morigobj = (llvm::object::MachOObjectFile*)
-#if JL_LLVM_VERSION >= 30600
             origerrorobj.get().get();
-#else
-            origerrorobj.get();
-#endif
 
         // First find the uuid of the object file (we'll use this to make sure we find the
         // correct debug symbol file).
@@ -1237,22 +879,13 @@ bool jl_dylib_DI_for_fptr(size_t pointer, const llvm::object::ObjectFile **obj,
         // On Windows we need to mmap another copy since reading the in-memory copy seems to return object_error:unexpected_eof
         objpath = fname;
     }
-#if JL_LLVM_VERSION >= 30500
     auto errorobj = llvm::object::ObjectFile::createObjectFile(objpath);
-#else
-    std::unique_ptr<llvm::object::ObjectFile> errorobj(llvm::object::ObjectFile::createObjectFile(objpath));
-#endif
 
 // GOAL: Assign *obj, *context, *slide (if above succeeded)
     if (errorobj) {
-#if JL_LLVM_VERSION >= 30600
         auto *debugobj = errorobj->getBinary();
-#else
-        auto *debugobj = errorobj.get();
-#endif
 
         if (islinux) {
-#if JL_LLVM_VERSION >= 30600
             // if the file has a .gnu_debuglink section,
             // try to load its companion file instead
             // in the expected locations
@@ -1260,16 +893,11 @@ bool jl_dylib_DI_for_fptr(size_t pointer, const llvm::object::ObjectFile **obj,
             debug_link_info info = getDebuglink(*debugobj);
             if (!info.filename.empty()) {
                 size_t sep = fname.rfind('/');
-#if JL_LLVM_VERSION >= 30900
                 Expected<object::OwningBinary<object::ObjectFile>>
                     DebugInfo(errorCodeToError(std::make_error_code(std::errc::no_such_file_or_directory)));
                 // Can't find a way to construct an empty Expected object
                 // that can be ignored.
                 ignoreError(DebugInfo);
-#else
-                ErrorOr<object::OwningBinary<object::ObjectFile>>
-                    DebugInfo(std::errc::no_such_file_or_directory);
-#endif
                 if (fname.substr(sep + 1) != info.filename) {
                     debuginfopath = fname.substr(0, sep + 1);
                     debuginfopath += info.filename;
@@ -1299,7 +927,6 @@ bool jl_dylib_DI_for_fptr(size_t pointer, const llvm::object::ObjectFile **obj,
                     ignoreError(DebugInfo);
                 }
             }
-#endif
         }
 
         if (isdarwin) {
@@ -1314,50 +941,18 @@ bool jl_dylib_DI_for_fptr(size_t pointer, const llvm::object::ObjectFile **obj,
 
         if (auto *OF = dyn_cast<const object::COFFObjectFile>(debugobj)) {
             assert(iswindows);
-#if JL_LLVM_VERSION >= 30800
             *slide = OF->getImageBase() - fbase;
             *section_slide = 0; // Since LLVM 3.8+ addresses are adjusted correctly
-#elif JL_LLVM_VERSION >= 30500
-            const llvm::object::pe32plus_header *pe32plus;
-            OF->getPE32PlusHeader(pe32plus);
-            if (pe32plus != NULL) {
-                *slide = pe32plus->ImageBase - fbase;
-                *section_slide = -(int64_t)pe32plus->ImageBase;
-            }
-            else {
-                const llvm::object::pe32_header *pe32;
-                OF->getPE32Header(pe32);
-                if (pe32 == NULL) {
-                    objfileentry_t entry = {};
-                    objfilemap[fbase] = entry;
-                    return true;
-                }
-                else {
-                    *slide = pe32->ImageBase - fbase;
-                    *section_slide = -(int64_t)pe32->ImageBase;
-                }
-            }
-#endif
         }
         else {
             *slide = -(int64_t)fbase;
         }
 
-#if JL_LLVM_VERSION >= 30700
         *context = new DWARFContextInMemory(*debugobj);
-#elif JL_LLVM_VERSION >= 30600
-        *context = DIContext::getDWARFContext(*debugobj);
-#else
-        *context = DIContext::getDWARFContext(debugobj);
-#endif
         *obj = debugobj;
-#if JL_LLVM_VERSION >= 30600
         auto binary = errorobj->takeBinary();
         binary.first.release();
         binary.second.release();
-#else
-        errorobj.release();
-#endif
     }
     else {
         // TODO: report the error instead of silently consuming it?
@@ -1436,26 +1031,11 @@ static int jl_getDylibFunctionInfo(jl_frame_t **frames, size_t pointer, int skip
 
 int jl_DI_for_fptr(uint64_t fptr, uint64_t *symsize, int64_t *slide, int64_t *section_slide,
                       const object::ObjectFile **object,
-#ifdef USE_MCJIT
                       llvm::DIContext **context
-#else
-                      std::vector<JITEvent_EmittedFunctionDetails::LineStart> *lines
-#endif
                       )
 {
     int found = 0;
     *slide = 0;
-#ifndef USE_MCJIT
-    std::map<size_t, FuncInfo, revcomp> &fmap = jl_jit_events->getMap();
-    std::map<size_t, FuncInfo, revcomp>::iterator fit = fmap.lower_bound(fptr);
-
-    if (fit != fmap.end() && fptr < fit->first + fit->second.lengthAdr) {
-        if (symsize)
-            *symsize = fit->second.lengthAdr;
-        *lines = fit->second.lines;
-        found = 1;
-    }
-#else // MCJIT version
     std::map<size_t, ObjectInfo, revcomp> &objmap = jl_jit_events->getObjectMap();
     std::map<size_t, ObjectInfo, revcomp>::iterator fit = objmap.lower_bound(fptr);
 
@@ -1466,20 +1046,14 @@ int jl_DI_for_fptr(uint64_t fptr, uint64_t *symsize, int64_t *slide, int64_t *se
             *section_slide = fit->second.slide;
         *object = fit->second.object;
         if (context) {
-#if JL_LLVM_VERSION >= 30700
             *context = fit->second.context;
-#else
-            *context = DIContext::getDWARFContext(*fit->second.object);
-#endif
         }
         found = 1;
     }
-#endif
     uv_rwlock_rdunlock(&threadsafe);
     return found;
 }
 
-#ifdef USE_MCJIT
 extern "C"
 JL_DLLEXPORT jl_value_t *jl_get_dobj_data(uint64_t fptr)
 {
@@ -1528,8 +1102,6 @@ JL_DLLEXPORT uint64_t jl_get_section_start(uint64_t fptr)
     return ret;
 }
 
-#endif
-
 // Set *name and *filename to either NULL or malloc'd string
 int jl_getFunctionInfo(jl_frame_t **frames_out, size_t pointer, int skipC, int noInline)
 {
@@ -1540,7 +1112,6 @@ int jl_getFunctionInfo(jl_frame_t **frames_out, size_t pointer, int skipC, int n
     frames[0].line = -1;
     *frames_out = frames;
 
-#ifdef USE_MCJIT
     llvm::DIContext *context;
     const llvm::object::ObjectFile *object;
     uint64_t symsize;
@@ -1550,112 +1121,15 @@ int jl_getFunctionInfo(jl_frame_t **frames_out, size_t pointer, int skipC, int n
         int nf = lookup_pointer(context, frames_out, pointer+slide, 1, noInline);
         return nf;
     }
-#else // !USE_MCJIT
-// Without MCJIT we use the FuncInfo structure containing address maps
-    std::map<size_t, FuncInfo, revcomp> &info = jl_jit_events->getMap();
-    std::map<size_t, FuncInfo, revcomp>::iterator it = info.lower_bound(pointer);
-    if (it != info.end() && (uintptr_t)(*it).first + (*it).second.lengthAdr >= pointer) {
-        // We do this to hide the jlcall wrappers when getting julia backtraces,
-        // but it is still good to have them for regular lookup of C frames.
-        if (skipC && (*it).second.lines.empty()) {
-            // Technically not true, but we don't want them
-            // in julia backtraces, so close enough
-            frames[0].fromC = 1;
-            uv_rwlock_rdunlock(&threadsafe);
-            return 1;
-        }
-
-        jl_copy_str(&frames[0].func_name, (*it).second.func->getName().str().c_str());
-        jl_copy_str(&frames[0].file_name, "");
-
-        if ((*it).second.lines.empty()) {
-            frames[0].fromC = 1;
-            uv_rwlock_rdunlock(&threadsafe);
-            return 1;
-        }
-
-        frames[0].linfo = (*it).second.linfo;
-        std::vector<JITEvent_EmittedFunctionDetails::LineStart>::iterator vit =
-            (*it).second.lines.begin();
-        JITEvent_EmittedFunctionDetails::LineStart prev = *vit;
-        LLVMContext &Ctx = (*it).second.func->getContext();
-
-        DISubprogram debugscope(prev.Loc.getScope(Ctx));
-        jl_copy_str(&frames[0].file_name, debugscope.getFilename().str().c_str());
-        // The DISubprogram has the un-mangled name, so use that if
-        // available. However, the scope need not be the current subprogram.
-        if (debugscope.getName().data() != NULL) {
-            jl_copy_str(&frames[0].func_name, debugscope.getName().str().c_str());
-        }
-        else {
-            char *oldname = frames[0].func_name;
-            std::pair<char *, bool> demangled = jl_demangle(oldname);
-            frames[0].func_name = demangled.first;
-            frames[0].fromC = !demangled.second;
-            free(oldname);
-        }
-
-        // find nearest line info
-        ++vit;
-        while (vit != (*it).second.lines.end()) {
-            if (pointer <= (*vit).Address) {
-                break;
-            }
-            prev = *vit;
-            ++vit;
-        }
-
-        // read out inlining and line number information
-        int n_frames = 1;
-        if (!noInline) {
-            MDNode *inlinedAt = prev.Loc.getInlinedAt(Ctx);
-            while (inlinedAt != NULL) {
-                DebugLoc inlineloc = DebugLoc::getFromDILocation(inlinedAt);
-                inlinedAt = inlineloc.getInlinedAt(Ctx);
-                n_frames++;
-            }
-            if (n_frames > 1) {
-                frames = (jl_frame_t*)calloc(sizeof(jl_frame_t), n_frames);
-                memcpy(&frames[n_frames - 1], *frames_out, sizeof(jl_frame_t));
-                free(*frames_out);
-                *frames_out = frames;
-            }
-        }
-        DebugLoc inlineloc = prev.Loc;
-        for (int i = 0; i < n_frames; i++) {
-            frames[i].inlined = i != n_frames - 1;
-            frames[i].line = inlineloc.getLine();
-            DISubprogram locscope(inlineloc.getScope(Ctx));
-            jl_copy_str(&frames[i].file_name, locscope.getFilename().str().c_str());
-            jl_copy_str(&frames[i].func_name, locscope.getName().str().c_str());
-            MDNode *inlinedAt = inlineloc.getInlinedAt(Ctx);
-            inlineloc = DebugLoc::getFromDILocation(inlinedAt);
-        }
-
-        uv_rwlock_rdunlock(&threadsafe);
-        return n_frames;
-    }
-    uv_rwlock_rdunlock(&threadsafe);
-#endif // USE_MCJIT
     return jl_getDylibFunctionInfo(frames_out, pointer, skipC, noInline);
 }
 
 extern "C" jl_method_instance_t *jl_gdblookuplinfo(void *p)
 {
-#ifndef USE_MCJIT
-    std::map<size_t, FuncInfo, revcomp> &info = jl_jit_events->getMap();
-    std::map<size_t, FuncInfo, revcomp>::iterator it = info.lower_bound((size_t)p);
-    jl_method_instance_t *li = NULL;
-    if (it != info.end() && (uintptr_t)(*it).first + (*it).second.lengthAdr >= (uintptr_t)p)
-        li = (*it).second.linfo;
-    uv_rwlock_rdunlock(&threadsafe);
-    return li;
-#else
     return jl_jit_events->lookupLinfo((size_t)p);
-#endif
 }
 
-#if JL_LLVM_VERSION >= 30700 && (defined(_OS_LINUX_) || (defined(_OS_DARWIN_) && defined(LLVM_SHLIB)))
+#if (defined(_OS_LINUX_) || (defined(_OS_DARWIN_) && defined(LLVM_SHLIB)))
 extern "C" void __register_frame(void*);
 extern "C" void __deregister_frame(void*);
 
@@ -1682,7 +1156,7 @@ static void processFDEs(const char *EHFrameAddr, size_t EHFrameSize, callback f)
 }
 #endif
 
-#if defined(_OS_DARWIN_) && JL_LLVM_VERSION >= 30700 && defined(LLVM_SHLIB)
+#if defined(_OS_DARWIN_) && defined(LLVM_SHLIB)
 
 /*
  * We use a custom unwinder, so we need to make sure that when registering dynamic
@@ -1722,7 +1196,7 @@ void deregister_eh_frames(uint8_t *Addr, size_t Size)
     });
 }
 
-#elif defined(_OS_LINUX_) && JL_LLVM_VERSION >= 30700 && \
+#elif defined(_OS_LINUX_) && \
     defined(JL_UNW_HAS_FORMAT_IP) && !defined(_CPU_ARM_)
 #include <type_traits>
 
@@ -2064,7 +1538,6 @@ void deregister_eh_frames(uint8_t *Addr, size_t Size)
 
 #endif
 
-#ifdef USE_MCJIT
 extern "C"
 uint64_t jl_getUnwindInfo(uint64_t dwAddr)
 {
@@ -2078,109 +1551,3 @@ uint64_t jl_getUnwindInfo(uint64_t dwAddr)
     uv_rwlock_rdunlock(&threadsafe);
     return ipstart;
 }
-#else
-extern "C"
-uint64_t jl_getUnwindInfo(uint64_t dwAddr)
-{
-    // Might be called from unmanaged thread
-    std::map<size_t, FuncInfo, revcomp> &info = jl_jit_events->getMap();
-    std::map<size_t, FuncInfo, revcomp>::iterator it = info.lower_bound(dwAddr);
-    uint64_t ipstart = 0; // ip of the first instruction in the function (if found)
-    if (it != info.end() && (uintptr_t)(*it).first + (*it).second.lengthAdr > dwAddr) {
-        ipstart = (uint64_t)(uintptr_t)(*it).first;
-    }
-    uv_rwlock_rdunlock(&threadsafe);
-    return ipstart;
-}
-#endif
-
-
-#if defined(_OS_WINDOWS_) && !defined(USE_MCJIT) && defined(_CPU_X86_64_)
-// Custom memory manager for exception handling on Windows
-// we overallocate 48 bytes at the end of each function
-// for unwind information (see NotifyFunctionEmitted)
-class JITMemoryManagerWin : public JITMemoryManager {
-private:
-    JITMemoryManager *JMM;
-public:
-    JITMemoryManagerWin() : JITMemoryManager()
-    {
-        JMM = JITMemoryManager::CreateDefaultMemManager();
-    }
-    virtual void setMemoryWritable() { return JMM->setMemoryWritable(); }
-    virtual void setMemoryExecutable() { return JMM->setMemoryExecutable(); }
-    virtual void setPoisonMemory(bool poison) { return JMM->setPoisonMemory(poison); }
-    virtual void AllocateGOT() { JMM->AllocateGOT(); HasGOT = true; }
-    virtual uint8_t *getGOTBase() const { return JMM->getGOTBase(); }
-    virtual uint8_t *startFunctionBody(const Function *F, uintptr_t &ActualSize)
-    {
-        if (ActualSize == 0)
-            ActualSize += 64;
-        ActualSize += 48;
-        uint8_t *mem = JMM->startFunctionBody(F,ActualSize);
-        ActualSize -= 48;
-        return mem;
-    }
-    virtual uint8_t *allocateStub(const GlobalValue *F, unsigned StubSize, unsigned Alignment)
-    {
-        return JMM->allocateStub(F,StubSize,Alignment);
-    }
-    virtual void endFunctionBody(const Function *F, uint8_t *FunctionStart, uint8_t *FunctionEnd)
-    {
-        FunctionEnd[0] = 0;
-        JMM->endFunctionBody(F,FunctionStart,FunctionEnd+48);
-    }
-    virtual uint8_t *allocateSpace(intptr_t Size, unsigned Alignment) { return JMM->allocateSpace(Size,Alignment); }
-    virtual uint8_t *allocateGlobal(uintptr_t Size, unsigned Alignment) { return JMM->allocateGlobal(Size,Alignment); }
-    virtual void deallocateFunctionBody(void *Body) { return JMM->deallocateFunctionBody(Body); }
-    virtual uint8_t *startExceptionTable(const Function *F,
-                                         uintptr_t &ActualSize) { return JMM->startExceptionTable(F,ActualSize); }
-    virtual void endExceptionTable(const Function *F, uint8_t *TableStart,
-                                   uint8_t *TableEnd, uint8_t *FrameRegister) { return JMM->endExceptionTable(F,TableStart,TableEnd,FrameRegister); }
-    virtual void deallocateExceptionTable(void *ET) { return JMM->deallocateExceptionTable(ET); }
-    virtual bool CheckInvariants(std::string &str) { return JMM->CheckInvariants(str); }
-    virtual size_t GetDefaultCodeSlabSize() { return JMM->GetDefaultCodeSlabSize(); }
-    virtual size_t GetDefaultDataSlabSize() { return JMM->GetDefaultDataSlabSize(); }
-    virtual size_t GetDefaultStubSlabSize() { return JMM->GetDefaultStubSlabSize(); }
-    virtual unsigned GetNumCodeSlabs() { return JMM->GetNumCodeSlabs(); }
-    virtual unsigned GetNumDataSlabs() { return JMM->GetNumDataSlabs(); }
-    virtual unsigned GetNumStubSlabs() { return JMM->GetNumStubSlabs(); }
-
-#if JL_LLVM_VERSION >= 30500
-    virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
-                                         unsigned SectionID, llvm::StringRef SectionName)
-    {
-        uint8_t *mem = JMM->allocateCodeSection(Size+48, Alignment, SectionID, SectionName);
-        mem[Size] = 0;
-        return mem;
-    }
-    virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
-                                         unsigned SectionID, llvm::StringRef SectionName, bool IsReadOnly)
-    {
-        return JMM->allocateDataSection(Size,Alignment,SectionID,SectionName,IsReadOnly);
-    }
-#else
-    virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment, unsigned SectionID)
-    {
-        uint8_t *mem = JMM->allocateCodeSection(Size+48, Alignment, SectionID);
-        mem[Size] = 0;
-        return mem;
-    }
-    virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
-                                         unsigned SectionID, bool IsReadOnly)
-    {
-        return JMM->allocateDataSection(Size,Alignment,SectionID,IsReadOnly);
-    }
-#endif
-    virtual void *getPointerToNamedFunction(const std::string &Name, bool AbortOnFailure = true)
-    {
-        return JMM->getPointerToNamedFunction(Name,AbortOnFailure);
-    }
-    virtual bool applyPermissions(std::string *ErrMsg = 0) { return JMM->applyPermissions(ErrMsg); }
-    virtual void registerEHFrames(StringRef SectionData) { return JMM->registerEHFrames(SectionData); }
-};
-JITMemoryManager *createJITMemoryManagerWin()
-{
-    return new JITMemoryManagerWin();
-}
-#endif
diff --git a/src/disasm.cpp b/src/disasm.cpp
index 766f726303fcee..9e75e6ce316314 100644
--- a/src/disasm.cpp
+++ b/src/disasm.cpp
@@ -49,45 +49,22 @@
 #include <llvm/MC/MCExpr.h>
 #include <llvm/MC/MCInstrAnalysis.h>
 #include <llvm/MC/MCSymbol.h>
-#if JL_LLVM_VERSION >= 30500
-#  include <llvm/AsmParser/Parser.h>
-#  if JL_LLVM_VERSION >= 30900
-#    include <llvm/MC/MCDisassembler/MCDisassembler.h>
-#    include <llvm/MC/MCDisassembler/MCExternalSymbolizer.h>
-#  else
-#    include <llvm/MC/MCExternalSymbolizer.h>
-#    include <llvm/MC/MCDisassembler.h>
-#  endif
-#else
-#  include <llvm/Assembly/Parser.h>
-#  include <llvm/ADT/OwningPtr.h>
-#  include <llvm/MC/MCDisassembler.h>
-#endif
+#include <llvm/AsmParser/Parser.h>
+#include <llvm/MC/MCDisassembler/MCDisassembler.h>
+#include <llvm/MC/MCDisassembler/MCExternalSymbolizer.h>
 #include <llvm/ADT/Triple.h>
 #include <llvm/Support/MemoryBuffer.h>
-#if JL_LLVM_VERSION < 30600
-#include <llvm/Support/MemoryObject.h>
-#endif
 #include <llvm/Support/SourceMgr.h>
 #include <llvm/Support/TargetRegistry.h>
 #include <llvm/Support/Host.h>
 #include "llvm/Support/TargetSelect.h"
 #include <llvm/Support/raw_ostream.h>
 #include "llvm/Support/FormattedStream.h"
-#if JL_LLVM_VERSION < 30500
-#include <llvm/Support/system_error.h>
-#endif
 #include <llvm/ExecutionEngine/JITEventListener.h>
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/DebugInfo/DIContext.h>
-#if JL_LLVM_VERSION >= 30700
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
-#endif
-#if JL_LLVM_VERSION >= 30500
 #include <llvm/IR/DebugInfo.h>
-#else
-#include <llvm/DebugInfo.h>
-#endif
 #include "fix_llvm_assert.h"
 
 #include "julia.h"
@@ -98,31 +75,7 @@ using namespace llvm;
 extern JL_DLLEXPORT LLVMContext &jl_LLVMContext;
 
 namespace {
-#if JL_LLVM_VERSION >= 30600
 #define FuncMCView ArrayRef<uint8_t>
-#else
-class FuncMCView : public MemoryObject {
-private:
-    const char *Fptr;
-    const size_t Fsize;
-public:
-    FuncMCView(const void *fptr, size_t size) : Fptr((const char*)fptr), Fsize(size) {}
-    uint64_t getBase() const { return 0; }
-    uint64_t getExtent() const { return Fsize; }
-    int readByte(uint64_t Addr, uint8_t *Byte) const {
-        if (Addr >= getExtent())
-            return -1;
-        *Byte = Fptr[Addr];
-        return 0;
-    }
-
-    // ArrayRef-like accessors:
-    const char operator[] (const size_t idx) const { return Fptr[idx]; }
-    uint64_t size() const { return Fsize; }
-    const uint8_t *data() const { return (const uint8_t*)Fptr; }
-    FuncMCView slice(unsigned N) const { return FuncMCView(Fptr+N, Fsize-N); }
-};
-#endif
 
 // Look up a symbol, and return a const char* to its name when the
 // address matches. We currently just use "L<address>" as name for the
@@ -180,33 +133,16 @@ const char *SymbolTable::lookupLocalPC(size_t addr) {
 StringRef SymbolTable::getSymbolNameAt(uint64_t offset) const
 {
     if (object == NULL) return StringRef();
-#if JL_LLVM_VERSION >= 30700
     object::section_iterator ESection = object->section_end();
     for (const object::SymbolRef &Sym : object->symbols()) {
-#else
-    llvm::error_code err;
-    object::section_iterator ESection = object->end_sections();
-    for (object::symbol_iterator I = object->begin_symbols(), E = object->end_symbols();
-            !err && I != E; I.increment(err)) {
-        object::SymbolRef Sym = *I;
-#endif
         uint64_t Addr, SAddr;
         object::section_iterator Sect = ESection;
-#if JL_LLVM_VERSION >= 30800
         auto SectOrError = Sym.getSection();
         assert(SectOrError);
         Sect = SectOrError.get();
-#else
-        if (Sym.getSection(Sect)) continue;
-#endif
         if (Sect == ESection) continue;
-#if JL_LLVM_VERSION >= 30500
         SAddr = Sect->getAddress();
         if (SAddr == 0) continue;
-#else
-        if (Sym.getAddress(SAddr) || SAddr == 0) continue;
-#endif
-#if JL_LLVM_VERSION >= 30700
         auto AddrOrError = Sym.getAddress();
         assert(AddrOrError);
         Addr = AddrOrError.get();
@@ -215,14 +151,6 @@ StringRef SymbolTable::getSymbolNameAt(uint64_t offset) const
             if (sNameOrError)
                 return sNameOrError.get();
         }
-#else
-        if (Sym.getAddress(Addr)) continue;
-        if (Addr == offset) {
-            StringRef Name;
-            if (!Sym.getName(Name))
-                return Name;
-        }
-#endif
     }
     return StringRef();
 }
@@ -258,13 +186,8 @@ void SymbolTable::createSymbols()
             name << global;
         }
 
-#if JL_LLVM_VERSION >= 30700
         MCSymbol *symb = Ctx.getOrCreateSymbol(StringRef(name.str()));
         assert(symb->isUndefined());
-#else
-        MCSymbol *symb = Ctx.GetOrCreateSymbol(StringRef(name.str()));
-        symb->setVariableValue(MCConstantExpr::Create(rel, Ctx));
-#endif
         isymb->second = symb;
     }
 }
@@ -304,11 +227,7 @@ static const char *SymbolLookup(void *DisInfo, uint64_t ReferenceValue, uint64_t
         else if (*ReferenceType == LLVMDisassembler_ReferenceType_In_PCrel_Load) {
             const char *symbolName = SymTab->lookupSymbolName(addr, false);
             if (symbolName) {
-#if JL_LLVM_VERSION >= 30700
                 *ReferenceType = LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr;
-#else
-                *ReferenceType = LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr;
-#endif
                 *ReferenceName = symbolName;
                 return NULL;
             }
@@ -364,16 +283,9 @@ JL_DLLEXPORT size_t jl_LLVMDisasmInstruction(LLVMDisasmContextRef DC, uint8_t *B
 }
 
 void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
-#ifndef USE_MCJIT
-                          std::vector<JITEvent_EmittedFunctionDetails::LineStart> lineinfo,
-#endif
                           const object::ObjectFile *object,
                           DIContext *di_ctx,
-#if JL_LLVM_VERSION >= 30700
                           raw_ostream &rstream,
-#else
-                          formatted_raw_ostream &stream,
-#endif
                           const char* asm_variant="att"
                           )
 {
@@ -396,58 +308,24 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
     const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, err);
 
     // Set up required helpers and streamer
-#if JL_LLVM_VERSION >= 30500
     std::unique_ptr<MCStreamer> Streamer;
-#else
-    OwningPtr<MCStreamer> Streamer;
-#endif
     SourceMgr SrcMgr;
 
-#if JL_LLVM_VERSION >= 30500
     std::unique_ptr<MCAsmInfo> MAI(TheTarget->createMCAsmInfo(*TheTarget->createMCRegInfo(TripleName),TripleName));
-#elif JL_LLVM_VERSION >= 30400
-    llvm::OwningPtr<MCAsmInfo> MAI(TheTarget->createMCAsmInfo(*TheTarget->createMCRegInfo(TripleName),TripleName));
-#else
-    llvm::OwningPtr<MCAsmInfo> MAI(TheTarget->createMCAsmInfo(TripleName));
-#endif
     assert(MAI && "Unable to create target asm info!");
 
-#if JL_LLVM_VERSION >= 30500
     std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
-#else
-    llvm::OwningPtr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
-#endif
     assert(MRI && "Unable to create target register info!");
 
-#if JL_LLVM_VERSION >= 30500
     std::unique_ptr<MCObjectFileInfo> MOFI(new MCObjectFileInfo());
-#else
-    OwningPtr<MCObjectFileInfo> MOFI(new MCObjectFileInfo());
-#endif
-#if JL_LLVM_VERSION >= 30400
     MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr);
-#else
-    MCContext Ctx(*MAI, *MRI, MOFI.get(), &SrcMgr);
-#endif
-#if JL_LLVM_VERSION >= 30900
     MOFI->InitMCObjectFileInfo(TheTriple, /* PIC */ false,
                                CodeModel::Default, Ctx);
-#elif JL_LLVM_VERSION >= 30700
-    MOFI->InitMCObjectFileInfo(TheTriple, Reloc::Default, CodeModel::Default, Ctx);
-#else
-    MOFI->InitMCObjectFileInfo(TripleName, Reloc::Default, CodeModel::Default, Ctx);
-#endif
 
     // Set up Subtarget and Disassembler
-#if JL_LLVM_VERSION >= 30500
     std::unique_ptr<MCSubtargetInfo>
         STI(TheTarget->createMCSubtargetInfo(TripleName, MCPU, Features.getString()));
     std::unique_ptr<MCDisassembler> DisAsm(TheTarget->createMCDisassembler(*STI, Ctx));
-#else
-    OwningPtr<MCSubtargetInfo>
-        STI(TheTarget->createMCSubtargetInfo(TripleName, MCPU, Features.getString()));
-    OwningPtr<MCDisassembler> DisAsm(TheTarget->createMCDisassembler(*STI));
-#endif
     if (!DisAsm) {
         jl_printf(JL_STDERR, "ERROR: no disassembler for target %s\n",
                   TripleName.c_str());
@@ -460,75 +338,38 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
     }
     bool ShowEncoding = false;
 
-#if JL_LLVM_VERSION >= 30500
     std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
     std::unique_ptr<MCInstrAnalysis>
         MCIA(TheTarget->createMCInstrAnalysis(MCII.get()));
-#else
-    OwningPtr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
-    OwningPtr<MCInstrAnalysis>
-        MCIA(TheTarget->createMCInstrAnalysis(MCII.get()));
-#endif
-#if JL_LLVM_VERSION >= 30700
     MCInstPrinter *IP =
         TheTarget->createMCInstPrinter(TheTriple, OutputAsmVariant, *MAI, *MCII, *MRI);
-#else
-    MCInstPrinter *IP =
-        TheTarget->createMCInstPrinter(OutputAsmVariant, *MAI, *MCII, *MRI, *STI);
-#endif
     //IP->setPrintImmHex(true); // prefer hex or decimal immediates
     MCCodeEmitter *CE = 0;
     MCAsmBackend *MAB = 0;
     if (ShowEncoding) {
-#if JL_LLVM_VERSION >= 30700
         CE = TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx);
-#else
-        CE = TheTarget->createMCCodeEmitter(*MCII, *MRI, *STI, Ctx);
-#endif
 #if JL_LLVM_VERSION >= 40000
         MCTargetOptions Options;
         MAB = TheTarget->createMCAsmBackend(*MRI, TripleName, MCPU, Options);
-#elif JL_LLVM_VERSION >= 30400
-        MAB = TheTarget->createMCAsmBackend(*MRI, TripleName, MCPU);
 #else
-        MAB = TheTarget->createMCAsmBackend(TripleName, MCPU);
+        MAB = TheTarget->createMCAsmBackend(*MRI, TripleName, MCPU);
 #endif
     }
 
-#if JL_LLVM_VERSION >= 30700
     // createAsmStreamer expects a unique_ptr to a formatted stream, which means
     // it will destruct the stream when it is done. We cannot have this, so we
     // start out with a raw stream, and create formatted stream from it here.
     // LLVM will desctruct the formatted stream, and we keep the raw stream.
     auto ustream = llvm::make_unique<formatted_raw_ostream>(rstream);
     Streamer.reset(TheTarget->createAsmStreamer(Ctx, std::move(ustream), /*asmverbose*/true,
-#else
-    Streamer.reset(TheTarget->createAsmStreamer(Ctx, stream, /*asmverbose*/true,
-#endif
-#if JL_LLVM_VERSION < 30500
-                                                /*useLoc*/ true,
-                                                /*useCFI*/ true,
-#endif
                                                 /*useDwarfDirectory*/ true,
                                                 IP, CE, MAB, /*ShowInst*/ false));
-#if JL_LLVM_VERSION >= 30600
     Streamer->InitSections(true);
-#else
-    Streamer->InitSections();
-#endif
 
     // Make the MemoryObject wrapper
-#if JL_LLVM_VERSION >= 30600
     ArrayRef<uint8_t> memoryObject(const_cast<uint8_t*>((const uint8_t*)Fptr),Fsize);
-#else
-    FuncMCView memoryObject((const uint8_t*)Fptr, Fsize);
-#endif
     SymbolTable DisInfo(Ctx, object, slide, memoryObject);
 
-#ifndef USE_MCJIT
-    typedef std::vector<JITEvent_EmittedFunctionDetails::LineStart> LInfoVec;
-#endif
-
     DILineInfoTable di_lineinfo;
     if (di_ctx)
          di_lineinfo = di_ctx->getLineInfoForAddressRange(Fptr+slide, Fsize);
@@ -545,72 +386,29 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
             // MCIA->evaluateBranch. (It should be possible to rewrite
             // this routine to handle this case correctly as well.)
             // Could add OpInfoLookup here
-#if JL_LLVM_VERSION >= 30500
             DisAsm->setSymbolizer(std::unique_ptr<MCSymbolizer>(new MCExternalSymbolizer(
                         Ctx,
                         std::unique_ptr<MCRelocationInfo>(new MCRelocationInfo(Ctx)),
                         OpInfoLookup,
                         SymbolLookup,
                         &DisInfo)));
-#elif JL_LLVM_VERSION >= 30400
-            OwningPtr<MCRelocationInfo> relinfo(new MCRelocationInfo(Ctx));
-            DisAsm->setupForSymbolicDisassembly(OpInfoLookup, SymbolLookup, &DisInfo, &Ctx,
-                                                relinfo);
-#else
-            DisAsm->setupForSymbolicDisassembly(OpInfoLookup, SymbolLookup, &DisInfo, &Ctx);
-#endif
         }
 
         uint64_t nextLineAddr = -1;
         DILineInfoTable::iterator di_lineIter = di_lineinfo.begin();
         DILineInfoTable::iterator di_lineEnd = di_lineinfo.end();
-#ifndef USE_MCJIT
-        LInfoVec::iterator lineIter = lineinfo.begin();
-        LInfoVec::iterator lineEnd  = lineinfo.end();
-#endif
         if (pass != 0) {
             if (di_ctx) {
                 // Set up the line info
                 if (di_lineIter != di_lineEnd) {
-#if JL_LLVM_VERSION >= 30700
                     std::ostringstream buf;
                     buf << "Filename: " << di_lineIter->second.FileName << "\n";
                     Streamer->EmitRawText(buf.str());
-#elif JL_LLVM_VERSION >= 30500
-                    stream << "Filename: " << di_lineIter->second.FileName << "\n";
-#else
-                    stream << "Filename: " << di_lineIter->second.getFileName() << "\n";
-#endif
-#if JL_LLVM_VERSION >= 30500
                     if (di_lineIter->second.Line <= 0)
-#else
-                    if (di_lineIter->second.getLine() <= 0)
-#endif
                         ++di_lineIter;
                     nextLineAddr = di_lineIter->first;
                 }
             }
-#ifndef USE_MCJIT
-            else {
-            // Set up the line info
-                if (lineIter != lineEnd) {
-                    DebugLoc Loc = (*lineIter).Loc;
-                    MDNode *outer = Loc.getInlinedAt(jl_LLVMContext);
-                    while (outer) {
-                        Loc = DebugLoc::getFromDILocation(outer);
-                        outer = Loc.getInlinedAt(jl_LLVMContext);
-                    }
-                    StringRef FileName;
-                    DISubprogram debugscope = DISubprogram(Loc.getScope(jl_LLVMContext));
-                    stream << "Filename: " << debugscope.getFilename() << "\n";
-                    if (Loc.getLine() > 0)
-                        stream << "Source line: " << Loc.getLine() << "\n";
-#if JL_LLVM_VERSION >= 30500
-                    nextLineAddr = (*lineIter).Address;
-#endif
-                }
-            }
-#endif
         }
 
         uint64_t Index = 0;
@@ -621,45 +419,21 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
 
             if (nextLineAddr != (uint64_t)-1 && Index + Fptr + slide == nextLineAddr) {
                 if (di_ctx) {
-#if JL_LLVM_VERSION >= 30700
                     std::ostringstream buf;
                     buf << "Source line: " << di_lineIter->second.Line << "\n";
                     Streamer->EmitRawText(buf.str());
-#elif JL_LLVM_VERSION >= 30500
-                    stream << "Source line: " << di_lineIter->second.Line << "\n";
-#else
-                    stream << "Source line: " << di_lineIter->second.getLine() << "\n";
-#endif
                     nextLineAddr = (++di_lineIter)->first;
                 }
-#ifndef USE_MCJIT
-                else {
-                    DebugLoc Loc = (*lineIter).Loc;
-                    MDNode *outer = Loc.getInlinedAt(jl_LLVMContext);
-                    while (outer) {
-                        Loc = DebugLoc::getFromDILocation(outer);
-                        outer = Loc.getInlinedAt(jl_LLVMContext);
-                    }
-                    stream << "Source line: " << Loc.getLine() << "\n";
-                    nextLineAddr = (*++lineIter).Address;
-                }
-#endif
             }
 
             DisInfo.setIP(Fptr+Index);
             if (pass != 0) {
                 // Uncomment this to output addresses for all instructions
                 // stream << Index << ": ";
-#if JL_LLVM_VERSION >= 30700
                 MCSymbol *symbol = DisInfo.lookupSymbol(Fptr+Index);
                 if (symbol)
                     Streamer->EmitLabel(symbol);
                     // emitInstructionAnnot
-#else
-                const char *symbolName = DisInfo.lookupSymbolName(Fptr + Index, true);
-                if (symbolName)
-                    stream << symbolName << ":";
-#endif
             }
 
             MCInst Inst;
@@ -703,21 +477,13 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
                     // Pass 0: Record all branch targets
                     if (MCIA && (MCIA->isBranch(Inst) || MCIA->isCall(Inst))) {
                         uint64_t addr;
-#if JL_LLVM_VERSION >= 30400
                         if (MCIA->evaluateBranch(Inst, Fptr+Index, insSize, addr))
-#else
-                        if ((addr = MCIA->evaluateBranch(Inst, Fptr+Index, insSize)) != (uint64_t)-1)
-#endif
                             DisInfo.insertAddress(addr);
                     }
                 }
                 else {
                     // Pass 1: Output instruction
-#if JL_LLVM_VERSION >= 30500
                     Streamer->EmitInstruction(Inst, *STI);
-#else
-                    Streamer->EmitInstruction(Inst);
-#endif
                 }
                 break;
             }
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index 3b41b41438b2cb..26dfac6977fd84 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -8,19 +8,11 @@
 
 // analysis passes
 #include <llvm/Analysis/Passes.h>
-#if JL_LLVM_VERSION >= 30800
 #include <llvm/Analysis/BasicAliasAnalysis.h>
 #include <llvm/Analysis/TypeBasedAliasAnalysis.h>
-#endif
-#if JL_LLVM_VERSION >= 30700
 #include <llvm/Analysis/TargetTransformInfo.h>
 #include <llvm/Analysis/TargetLibraryInfo.h>
-#endif
-#if JL_LLVM_VERSION >= 30500
 #include <llvm/IR/Verifier.h>
-#else
-#include <llvm/Analysis/Verifier.h>
-#endif
 #if defined(USE_POLLY)
 #include <polly/RegisterPasses.h>
 #include <polly/LinkAllPasses.h>
@@ -35,9 +27,7 @@
 #include <llvm/Transforms/Utils/BasicBlockUtils.h>
 #include <llvm/Transforms/Instrumentation.h>
 #include <llvm/Transforms/Vectorize.h>
-#if JL_LLVM_VERSION >= 30900
 #include <llvm/Transforms/Scalar/GVN.h>
-#endif
 #if JL_LLVM_VERSION >= 40000
 #include <llvm/Transforms/IPO/AlwaysInliner.h>
 #endif
@@ -51,9 +41,7 @@ namespace llvm {
 #else
 #  include <llvm/Bitcode/ReaderWriter.h>
 #endif
-#if JL_LLVM_VERSION >= 30500
 #include <llvm/Bitcode/BitcodeWriterPass.h>
-#endif
 
 #include <llvm/IR/LegacyPassManagers.h>
 #include <llvm/IR/IRPrintingPasses.h>
@@ -63,9 +51,6 @@ namespace llvm {
 // target support
 #include <llvm/ADT/Triple.h>
 #include <llvm/Support/TargetRegistry.h>
-#if JL_LLVM_VERSION < 30700
-#include <llvm/Target/TargetLibraryInfo.h>
-#endif
 #include <llvm/IR/DataLayout.h>
 #include <llvm/Support/DynamicLibrary.h>
 
@@ -82,9 +67,7 @@ using namespace llvm;
 #include "julia.h"
 #include "julia_internal.h"
 #include "jitlayers.h"
-#ifdef USE_MCJIT
 RTDyldMemoryManager* createRTDyldMemoryManager(void);
-#endif
 
 static Type *T_void;
 static IntegerType *T_uint32;
@@ -110,11 +93,7 @@ void jl_init_jit(Type *T_pjlvalue_)
 // Except for parts of this file which were copied from LLVM, under the UIUC license (marked below).
 
 // this defines the set of optimization passes defined for Julia at various optimization levels
-#if JL_LLVM_VERSION >= 30700
 void addOptimizationPasses(legacy::PassManagerBase *PM, int opt_level)
-#else
-void addOptimizationPasses(PassManager *PM, int opt_level)
-#endif
 {
 #ifdef JL_DEBUG_BUILD
     PM->add(createGCInvariantVerifierPass(true));
@@ -122,10 +101,6 @@ void addOptimizationPasses(PassManager *PM, int opt_level)
 #endif
 
 #if defined(JL_ASAN_ENABLED)
-#   if JL_LLVM_VERSION >= 30700 && JL_LLVM_VERSION < 30800
-    // LLVM 3.7 BUG: ASAN pass doesn't properly initialize its dependencies
-    initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
-#   endif
     PM->add(createAddressSanitizerFunctionPass());
 #endif
 #if defined(JL_MSAN_ENABLED)
@@ -157,22 +132,10 @@ void addOptimizationPasses(PassManager *PM, int opt_level)
         return;
     }
     PM->add(createPropagateJuliaAddrspaces());
-#if JL_LLVM_VERSION >= 30700
     PM->add(createTargetTransformInfoWrapperPass(jl_TargetMachine->getTargetIRAnalysis()));
-#else
-    jl_TargetMachine->addAnalysisPasses(*PM);
-#endif
-#if JL_LLVM_VERSION >= 30800
     PM->add(createTypeBasedAAWrapperPass());
-#else
-    PM->add(createTypeBasedAliasAnalysisPass());
-#endif
     if (jl_options.opt_level >= 3) {
-#if JL_LLVM_VERSION >= 30800
         PM->add(createBasicAAWrapperPass());
-#else
-        PM->add(createBasicAliasAnalysisPass());
-#endif
     }
     // list of passes from vmkit
     PM->add(createCFGSimplificationPass()); // Clean up disgusting code
@@ -198,22 +161,16 @@ void addOptimizationPasses(PassManager *PM, int opt_level)
     PM->add(createAlwaysInlinerPass()); // Respect always_inline
 #endif
 
-#ifndef INSTCOMBINE_BUG
     PM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
-#endif
     // Let the InstCombine pass remove the unnecessary load of
     // safepoint address first
     PM->add(createSROAPass());                 // Break up aggregate allocas
-#ifndef INSTCOMBINE_BUG
     PM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
-#endif
     PM->add(createJumpThreadingPass());        // Thread jumps.
     // NOTE: CFG simp passes after this point seem to hurt native codegen.
     // See issue #6112. Should be re-evaluated when we switch to MCJIT.
     //PM->add(createCFGSimplificationPass());    // Merge & remove BBs
-#ifndef INSTCOMBINE_BUG
     PM->add(createInstructionCombiningPass()); // Combine silly seq's
-#endif
 
     //PM->add(createCFGSimplificationPass());    // Merge & remove BBs
     PM->add(createReassociatePass());          // Reassociate expressions
@@ -239,24 +196,13 @@ void addOptimizationPasses(PassManager *PM, int opt_level)
     PM->add(createLICMPass());                 // Hoist loop invariants
     PM->add(createLoopUnswitchPass());         // Unswitch loops.
     // Subsequent passes not stripping metadata from terminator
-#ifndef INSTCOMBINE_BUG
     PM->add(createInstructionCombiningPass());
-#endif
     PM->add(createIndVarSimplifyPass());       // Canonicalize indvars
     PM->add(createLoopDeletionPass());         // Delete dead loops
-#if JL_LLVM_VERSION >= 30500
     PM->add(createSimpleLoopUnrollPass());     // Unroll small loops
-#else
-    PM->add(createLoopUnrollPass());           // Unroll small loops
-#endif
-#if JL_LLVM_VERSION < 30500 && !defined(INSTCOMBINE_BUG)
-    PM->add(createLoopVectorizePass());        // Vectorize loops
-#endif
     //PM->add(createLoopStrengthReducePass());   // (jwb added)
 
-#ifndef INSTCOMBINE_BUG
     PM->add(createInstructionCombiningPass()); // Clean up after the unroller
-#endif
     PM->add(createGVNPass());                  // Remove redundancies
     PM->add(createMemCpyOptPass());            // Remove memcpy / form memset
     PM->add(createSCCPPass());                 // Constant prop with SCCP
@@ -265,9 +211,7 @@ void addOptimizationPasses(PassManager *PM, int opt_level)
     // opened up by them.
     PM->add(createSinkingPass()); ////////////// ****
     PM->add(createInstructionSimplifierPass());///////// ****
-#ifndef INSTCOMBINE_BUG
     PM->add(createInstructionCombiningPass());
-#endif
     PM->add(createJumpThreadingPass());         // Thread jumps
     PM->add(createDeadStoreEliminationPass());  // Delete dead stores
 
@@ -279,19 +223,15 @@ void addOptimizationPasses(PassManager *PM, int opt_level)
     PM->add(createLoopDeletionPass());          // Delete dead loops
     PM->add(createJumpThreadingPass());         // Thread jumps
 
-#if JL_LLVM_VERSION >= 30500
     if (jl_options.opt_level >= 3) {
         PM->add(createSLPVectorizerPass());     // Vectorize straight-line code
     }
-#endif
 
     PM->add(createAggressiveDCEPass());         // Delete dead instructions
-#if JL_LLVM_VERSION >= 30500
     if (jl_options.opt_level >= 3)
         PM->add(createInstructionCombiningPass());   // Clean up after SLP loop vectorizer
     PM->add(createLoopVectorizePass());         // Vectorize loops
     PM->add(createInstructionCombiningPass());  // Clean up after loop vectorizer
-#endif
     // LowerPTLS removes an indirect call. As a result, it is likely to trigger
     // LLVM's devirtualization heuristics, which would result in the entire
     // pass pipeline being re-exectuted. Prevent this by inserting a barrier.
@@ -304,13 +244,6 @@ void addOptimizationPasses(PassManager *PM, int opt_level)
 #endif
 }
 
-#ifdef USE_ORCJIT
-
-#if JL_LLVM_VERSION < 30800
-void notifyObjectLoaded(RTDyldMemoryManager *memmgr,
-                        llvm::orc::ObjectLinkingLayerBase::ObjSetHandleT H);
-#endif
-
 // ------------------------ TEMPORARILY COPIED FROM LLVM -----------------
 // This must be kept in sync with gdb/gdb/jit.h .
 extern "C" {
@@ -410,17 +343,10 @@ template <typename ObjSetT, typename LoadResult>
 void JuliaOJIT::DebugObjectRegistrar::operator()(RTDyldObjectLinkingLayerBase::ObjSetHandleT H,
                 const ObjSetT &Objects, const LoadResult &LOS)
 {
-#if JL_LLVM_VERSION < 30800
-    notifyObjectLoaded(JIT.MemMgr, H);
-#endif
     auto oit = Objects.begin();
     auto lit = LOS.begin();
     for (; oit != Objects.end(); ++oit, ++lit) {
-#if JL_LLVM_VERSION >= 30900
         const auto &Object = (*oit)->getBinary();
-#else
-        auto &Object = *oit;
-#endif
         auto &LO = *lit;
 
         OwningBinary<object::ObjectFile> SavedObject = LO->getObjectForDebug(*Object);
@@ -509,17 +435,12 @@ JuliaOJIT::JuliaOJIT(TargetMachine &TM)
 #else
                     M.dump();
 #endif
-#if JL_LLVM_VERSION >= 30900
                     std::string Buf;
                     raw_string_ostream OS(Buf);
                     logAllUnhandledErrors(Obj.takeError(), OS, "");
                     OS.flush();
                     llvm::report_fatal_error("FATAL: Unable to compile LLVM Module: '" + Buf + "'\n"
                         "The module's content was printed above. Please file a bug report");
-#else
-                    llvm::report_fatal_error("FATAL: Unable to compile LLVM Module.\n"
-                        "The module's content was printed above. Please file a bug report");
-#endif
                 }
 
                 return OwningObj(std::move(*Obj), std::move(ObjBuffer));
@@ -691,9 +612,6 @@ std::string JuliaOJIT::getMangledName(const GlobalValue *GV)
 }
 
 JuliaOJIT *jl_ExecutionEngine;
-#else
-ExecutionEngine *jl_ExecutionEngine;
-#endif
 
 // MSVC's link.exe requires each function declaration to have a Comdat section
 // So rather than litter the code with conditionals,
@@ -703,7 +621,7 @@ ExecutionEngine *jl_ExecutionEngine;
 template<class T> // for GlobalObject's
 static T *addComdat(T *G)
 {
-#if defined(_OS_WINDOWS_) && JL_LLVM_VERSION >= 30500
+#if defined(_OS_WINDOWS_)
     if (imaging_mode && !G->isDeclaration()) {
         // Add comdat information to make MSVC link.exe happy
         // it's valid to emit this for ld.exe too,
@@ -809,15 +727,9 @@ static void jl_merge_module(Module *dest, std::unique_ptr<Module> src)
     NamedMDNode *sNMD = src->getNamedMetadata("llvm.dbg.cu");
     if (sNMD) {
         NamedMDNode *dNMD = dest->getOrInsertNamedMetadata("llvm.dbg.cu");
-#if JL_LLVM_VERSION >= 30500
         for (NamedMDNode::op_iterator I = sNMD->op_begin(), E = sNMD->op_end(); I != E; ++I) {
             dNMD->addOperand(*I);
         }
-#else
-        for (unsigned i = 0, l = sNMD->getNumOperands(); i < l; i++) {
-            dNMD->addOperand(sNMD->getOperand(i));
-        }
-#endif
     }
 }
 
@@ -827,10 +739,9 @@ static void jl_merge_module(Module *dest, std::unique_ptr<Module> src)
 static StringMap<Module*> module_for_fname;
 static void jl_merge_recursive(Module *m, Module *collector);
 
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
 static void jl_add_to_ee(std::unique_ptr<Module> m)
 {
-#if defined(_CPU_X86_64_) && defined(_OS_WINDOWS_) && JL_LLVM_VERSION >= 30500
+#if defined(_CPU_X86_64_) && defined(_OS_WINDOWS_)
     // Add special values used by debuginfo to build the UnwindData table registration for Win64
     ArrayType *atype = ArrayType::get(T_uint32, 3); // want 4-byte alignment of 12-bytes of data
     (new GlobalVariable(*m, atype,
@@ -841,11 +752,7 @@ static void jl_add_to_ee(std::unique_ptr<Module> m)
         ConstantAggregateZero::get(atype), "__catchjmp"))->setSection(".text");
 #endif
     assert(jl_ExecutionEngine);
-#if JL_LLVM_VERSION >= 30600
     jl_ExecutionEngine->addModule(std::move(m));
-#else
-    jl_ExecutionEngine->addModule(m.release());
-#endif
 }
 
 void jl_finalize_function(Function *F)
@@ -856,21 +763,6 @@ void jl_finalize_function(Function *F)
         jl_add_to_ee(std::move(m));
     }
 }
-#else
-static bool jl_try_finalize(Module *m)
-{
-    for (Module::iterator I = m->begin(), E = m->end(); I != E; ++I) {
-        Function *F = &*I;
-        if (F->isDeclaration() && !isIntrinsicFunction(F)) {
-            if (!jl_can_finalize_function(F))
-                return false;
-        }
-    }
-    jl_merge_recursive(m, shadow_output);
-    jl_merge_module(shadow_output, std::unique_ptr<Module>(m));
-    return true;
-}
-#endif
 
 static void jl_finalize_function(const std::string &F, Module *collector)
 {
@@ -909,11 +801,7 @@ static bool jl_can_finalize_function(StringRef F, SmallSet<Module*, 16> &known)
     if (incomplete_fname.find(F) != incomplete_fname.end())
         return false;
     Module *M = module_for_fname.lookup(F);
-#if JL_LLVM_VERSION >= 30500
     if (M && known.insert(M).second)
-#else
-    if (M && known.insert(M))
-#endif
     {
         for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) {
             Function *F = &*I;
@@ -954,47 +842,22 @@ void jl_finalize_module(Module *m, bool shadow)
             module_for_fname[F->getName()] = m;
         }
     }
-#if defined(USE_ORCJIT) || defined(USE_MCJIT)
     // in the newer JITs, the shadow module is separate from the execution module
     if (shadow)
         jl_add_to_shadow(m);
-#else
-    bool changes = jl_try_finalize(m);
-    while (changes) {
-        // this definitely isn't the most efficient, but it's only for the old LLVM 3.3 JIT
-        changes = false;
-        for (StringMap<Module*>::iterator MI = module_for_fname.begin(), ME = module_for_fname.end(); MI != ME; ++MI) {
-            changes |= jl_try_finalize(MI->second);
-        }
-    }
-#endif
 }
 
 // helper function for adding a DLLImport (dlsym) address to the execution engine
 // (for values created locally or in the sysimage, jl_emit_and_add_to_shadow is generally preferable)
-#if JL_LLVM_VERSION >= 30500
 void add_named_global(GlobalObject *gv, void *addr, bool dllimport)
-#else
-void add_named_global(GlobalValue *gv, void *addr, bool dllimport)
-#endif
 {
 #ifdef _OS_WINDOWS_
     // setting JL_DLLEXPORT correctly only matters when building a binary
     // (global_proto will strip this from the JIT)
     if (dllimport && imaging_mode) {
         assert(gv->getLinkage() == GlobalValue::ExternalLinkage);
-#if JL_LLVM_VERSION >= 30500
         // add the __declspec(dllimport) attribute
         gv->setDLLStorageClass(GlobalValue::DLLImportStorageClass);
-#else
-        gv->setLinkage(GlobalValue::DLLImportLinkage);
-#if defined(_P64)
-        // __imp_ variables are indirection pointers, so use malloc to simulate that
-        void **imp_addr = (void**)malloc(sizeof(void*));
-        *imp_addr = addr;
-        addr = (void*)imp_addr;
-#endif
-#endif
     }
 #endif // _OS_WINDOWS_
 
@@ -1020,9 +883,7 @@ void* jl_emit_and_add_to_shadow(GlobalVariable *gv, void *gvarinit)
     PointerType *T = cast<PointerType>(gv->getType()->getElementType()); // pointer is the only supported type here
 
     GlobalVariable *shadowvar = NULL;
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
     if (imaging_mode)
-#endif
         shadowvar = global_proto(gv, shadow_output);
 
     if (shadowvar) {
@@ -1040,13 +901,9 @@ void* jl_emit_and_add_to_shadow(GlobalVariable *gv, void *gvarinit)
     }
 
     // make the pointer valid for this session
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
     void *slot = calloc(1, sizeof(void*));
     jl_ExecutionEngine->addGlobalMapping(gv, slot);
     return slot;
-#else
-    return jl_ExecutionEngine->getPointerToGlobal(shadowvar);
-#endif
 }
 
 // Emit a slot in the system image to be filled at sysimg init time.
@@ -1065,13 +922,8 @@ GlobalVariable *jl_emit_sysimg_slot(Module *m, Type *typ, const char *name,
                                             Constant::getNullValue(typ), name);
     addComdat(gv);
     // make the pointer valid for this session
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
     auto p = new uintptr_t(init);
     jl_ExecutionEngine->addGlobalMapping(gv, (void*)p);
-#else
-    uintptr_t *p = (uintptr_t*)jl_ExecutionEngine->getPointerToGlobal(gv);
-    *p = init;
-#endif
     jl_sysimg_gvars.push_back(ConstantExpr::getBitCast(gv, T_psize));
     idx = jl_sysimg_gvars.size();
     return gv;
@@ -1079,18 +931,12 @@ GlobalVariable *jl_emit_sysimg_slot(Module *m, Type *typ, const char *name,
 
 void* jl_get_globalvar(GlobalVariable *gv)
 {
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
     void *p = (void*)(intptr_t)jl_ExecutionEngine->getPointerToGlobalIfAvailable(gv);
-#else
-    void *p = jl_ExecutionEngine->getPointerToGlobal(
-            shadow_output->getNamedValue(gv->getName()));
-#endif
     assert(p);
     return p;
 }
 
 // clones the contents of the module `m` to the shadow_output collector
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
 void jl_add_to_shadow(Module *m)
 {
 #ifndef KEEP_BODIES
@@ -1108,7 +954,6 @@ void jl_add_to_shadow(Module *m)
     }
     jl_merge_module(shadow_output, std::move(clone));
 }
-#endif
 
 #ifdef HAVE_CPUID
 extern "C" {
@@ -1213,23 +1058,11 @@ void jl_dump_native(const char *bc_fname, const char *unopt_bc_fname, const char
     Triple TheTriple = Triple(jl_TargetMachine->getTargetTriple());
     // make sure to emit the native object format, even if FORCE_ELF was set in codegen
 #if defined(_OS_WINDOWS_)
-#if JL_LLVM_VERSION >= 30500
     TheTriple.setObjectFormat(Triple::COFF);
-#else
-    TheTriple.setEnvironment(Triple::UnknownEnvironment);
-#endif
 #elif defined(_OS_DARWIN_)
-#if JL_LLVM_VERSION >= 30500
     TheTriple.setObjectFormat(Triple::MachO);
-#else
-    TheTriple.setEnvironment(Triple::MachO);
-#endif
 #endif
-#if JL_LLVM_VERSION >= 30500
     std::unique_ptr<TargetMachine>
-#else
-    OwningPtr<TargetMachine>
-#endif
     TM(jl_TargetMachine->getTarget().createTargetMachine(
         TheTriple.getTriple(),
         jl_TargetMachine->getTargetCPU(),
@@ -1237,72 +1070,33 @@ void jl_dump_native(const char *bc_fname, const char *unopt_bc_fname, const char
         jl_TargetMachine->Options,
 #if defined(_OS_LINUX_) || defined(_OS_FREEBSD_)
         Reloc::PIC_,
-#elif JL_LLVM_VERSION >= 30900
-        Optional<Reloc::Model>(),
 #else
-        Reloc::Default,
+        Optional<Reloc::Model>(),
 #endif
         CodeModel::Default,
         CodeGenOpt::Aggressive // -O3 TODO: respect command -O0 flag?
         ));
 
-#if JL_LLVM_VERSION >= 30700
     legacy::PassManager PM;
-#else
-    PassManager PM;
-#endif
-#if JL_LLVM_VERSION < 30700
-    PM.add(new TargetLibraryInfo(Triple(TM->getTargetTriple())));
-#else
     PM.add(new TargetLibraryInfoWrapperPass(Triple(TM->getTargetTriple())));
-#endif
-
 
     // set up optimization passes
-#if JL_LLVM_VERSION >= 30700
-    // No DataLayout pass needed anymore.
-#elif JL_LLVM_VERSION >= 30600
-    PM.add(new DataLayoutPass());
-#elif JL_LLVM_VERSION >= 30500
-    PM.add(new DataLayoutPass(*jl_ExecutionEngine->getDataLayout()));
-#else
-    PM.add(new DataLayout(*jl_ExecutionEngine->getDataLayout()));
-#endif
-
     std::unique_ptr<raw_fd_ostream> unopt_bc_OS;
     std::unique_ptr<raw_fd_ostream> bc_OS;
     std::unique_ptr<raw_fd_ostream> obj_OS;
-#if JL_LLVM_VERSION >= 30700 // 3.7 simplified formatted output; just use the raw stream alone
-    std::unique_ptr<raw_fd_ostream> &unopt_bc_FOS = unopt_bc_OS;
-    std::unique_ptr<raw_fd_ostream> &bc_FOS = bc_OS;
-    std::unique_ptr<raw_fd_ostream> &obj_FOS = obj_OS;
-#else
-    std::unique_ptr<formatted_raw_ostream> unopt_bc_FOS;
-    std::unique_ptr<formatted_raw_ostream> bc_FOS;
-    std::unique_ptr<formatted_raw_ostream> obj_FOS;
-#endif
-
 
     if (unopt_bc_fname) {
-#if JL_LLVM_VERSION >= 30500
         // call output handler directly to avoid special case handling of `-` filename
         int FD;
         std::error_code EC = sys::fs::openFileForWrite(unopt_bc_fname, FD, sys::fs::F_None);
-        unopt_bc_FOS.reset(new raw_fd_ostream(FD, true));
+        unopt_bc_OS.reset(new raw_fd_ostream(FD, true));
         std::string err;
         if (EC)
             err = "ERROR: failed to open --output-unopt-bc file '" + std::string(unopt_bc_fname) + "': " + EC.message();
-#else
-        std::string err;
-        unopt_bc_OS.reset(new raw_fd_ostream(unopt_bc_fname, err, raw_fd_ostream::F_Binary));
-#endif
         if (!err.empty())
             jl_safe_printf("%s\n", err.c_str());
         else {
-#if JL_LLVM_VERSION < 30700
-            unopt_bc_FOS.reset(new formatted_raw_ostream(*unopt_bc_OS.get()));
-#endif
-            PM.add(createBitcodeWriterPass(*unopt_bc_FOS.get()));
+            PM.add(createBitcodeWriterPass(*unopt_bc_OS.get()));
         }
     }
 
@@ -1310,7 +1104,6 @@ void jl_dump_native(const char *bc_fname, const char *unopt_bc_fname, const char
         addOptimizationPasses(&PM, jl_options.opt_level);
 
     if (bc_fname) {
-#if JL_LLVM_VERSION >= 30500
         // call output handler directly to avoid special case handling of `-` filename
         int FD;
         std::error_code EC = sys::fs::openFileForWrite(bc_fname, FD, sys::fs::F_None);
@@ -1318,22 +1111,14 @@ void jl_dump_native(const char *bc_fname, const char *unopt_bc_fname, const char
         std::string err;
         if (EC)
             err = "ERROR: failed to open --output-bc file '" + std::string(bc_fname) + "': " + EC.message();
-#else
-        std::string err;
-        bc_OS.reset(new raw_fd_ostream(bc_fname, err, raw_fd_ostream::F_Binary));
-#endif
         if (!err.empty())
             jl_safe_printf("%s\n", err.c_str());
         else {
-#if JL_LLVM_VERSION < 30700
-            bc_FOS.reset(new formatted_raw_ostream(*bc_OS.get()));
-#endif
-            PM.add(createBitcodeWriterPass(*bc_FOS.get()));
+            PM.add(createBitcodeWriterPass(*bc_OS.get()));
         }
     }
 
     if (obj_fname) {
-#if JL_LLVM_VERSION >= 30500
         // call output handler directly to avoid special case handling of `-` filename
         int FD;
         std::error_code EC = sys::fs::openFileForWrite(obj_fname, FD, sys::fs::F_None);
@@ -1341,42 +1126,26 @@ void jl_dump_native(const char *bc_fname, const char *unopt_bc_fname, const char
         std::string err;
         if (EC)
             err = "ERROR: failed to open --output-o file '" + std::string(obj_fname) + "': " + EC.message();
-#else
-        std::string err;
-        obj_OS.reset(new raw_fd_ostream(obj_fname, err, raw_fd_ostream::F_Binary));
-#endif
         if (!err.empty())
             jl_safe_printf("%s\n", err.c_str());
         else {
-#if JL_LLVM_VERSION < 30700
-            obj_FOS.reset(new formatted_raw_ostream(*obj_OS.get()));
-#endif
-            if (TM->addPassesToEmitFile(PM, *obj_FOS.get(), TargetMachine::CGFT_ObjectFile, false)) {
+            if (TM->addPassesToEmitFile(PM, *obj_OS.get(), TargetMachine::CGFT_ObjectFile, false)) {
                 jl_safe_printf("ERROR: target does not support generation of object files\n");
             }
         }
     }
 
     ValueToValueMapTy VMap;
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
-    // now copy the module (if using the old JIT), since PM.run may modify it
     Module *clone = shadow_output;
-#else
-    Module *clone = CloneModule(shadow_output, VMap);
-#endif
 
-#if JL_LLVM_VERSION >= 30700
     // Reset the target triple to make sure it matches the new target machine
     clone->setTargetTriple(TM->getTargetTriple().str());
 #if JL_LLVM_VERSION >= 40000
     DataLayout DL = TM->createDataLayout();
     DL.reset(DL.getStringRepresentation() + "-ni:10:11:12");
     clone->setDataLayout(DL);
-#elif JL_LLVM_VERSION >= 30800
-    clone->setDataLayout(TM->createDataLayout());
 #else
-    clone->setDataLayout(TM->getDataLayout()->getStringRepresentation());
-#endif
+    clone->setDataLayout(TM->createDataLayout());
 #endif
 
     // add metadata information
@@ -1384,9 +1153,6 @@ void jl_dump_native(const char *bc_fname, const char *unopt_bc_fname, const char
 
     // do the actual work
     PM.run(*clone);
-#if !defined(USE_MCJIT) && !defined(USE_ORCJIT)
-    delete clone;
-#endif
     imaging_mode = false;
 }
 
diff --git a/src/jitlayers.h b/src/jitlayers.h
index 78f4147aff6a4b..407ca9021cd12a 100644
--- a/src/jitlayers.h
+++ b/src/jitlayers.h
@@ -17,29 +17,16 @@
 #  include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
 #endif
 #include "llvm/ExecutionEngine/ObjectMemoryBuffer.h"
-#elif defined(USE_MCJIT)
+#else
 #include <llvm/ExecutionEngine/MCJIT.h>
 #include <llvm/ADT/DenseMapInfo.h>
 #include <llvm/Object/ObjectFile.h>
-#else
-#include <llvm/ExecutionEngine/JIT.h>
-#include <llvm/ExecutionEngine/JITMemoryManager.h>
-#include <llvm/ExecutionEngine/Interpreter.h>
-#include <llvm/ExecutionEngine/ExecutionEngine.h>
-#include <llvm/ExecutionEngine/JITEventListener.h>
 #endif
 
-#if JL_LLVM_VERSION >= 30700
 #include "llvm/IR/LegacyPassManager.h"
 extern legacy::PassManager *jl_globalPM;
-#else
-#include <llvm/PassManager.h>
-extern PassManager *jl_globalPM;
-#endif
 
-#if JL_LLVM_VERSION >= 30500
 #include <llvm/Target/TargetMachine.h>
-#endif
 #include "fix_llvm_assert.h"
 
 extern "C" {
@@ -60,11 +47,7 @@ extern size_t jltls_offset_idx;
 
 typedef struct {Value *gv; int32_t index;} jl_value_llvm; // uses 1-based indexing
 
-#if JL_LLVM_VERSION >= 30700
 void addOptimizationPasses(legacy::PassManagerBase *PM, int opt_level);
-#else
-void addOptimizationPasses(PassManager *PM, int opt_level);
-#endif
 void* jl_emit_and_add_to_shadow(GlobalVariable *gv, void *gvarinit = NULL);
 GlobalVariable *jl_emit_sysimg_slot(Module *m, Type *typ, const char *name,
                                     uintptr_t init, size_t &idx);
@@ -84,11 +67,9 @@ static inline GlobalVariable *global_proto(GlobalVariable *G, Module *M = NULL)
             G->isConstant(), GlobalVariable::ExternalLinkage,
             NULL, G->getName(),  G->getThreadLocalMode());
     proto->copyAttributesFrom(G);
-#if JL_LLVM_VERSION >= 30500
     // DLLImport only needs to be set for the shadow module
     // it just gets annoying in the JIT
     proto->setDLLStorageClass(GlobalValue::DefaultStorageClass);
-#endif
     if (M)
         M->getGlobalList().push_back(proto);
     return proto;
@@ -106,28 +87,22 @@ static inline Function *function_proto(Function *F, Module *M = NULL)
     // routine from `F`, since copying it and then resetting is more expensive
     // as well as introducing an extra use from this unowned function, which
     // can cause crashes in the LLVMContext's global destructor.
-#if JL_LLVM_VERSION >= 30700
     llvm::Constant *OldPersonalityFn = nullptr;
     if (F->hasPersonalityFn()) {
         OldPersonalityFn = F->getPersonalityFn();
         F->setPersonalityFn(nullptr);
     }
-#endif
 
      // FunctionType does not include any attributes. Copy them over manually
      // as codegen may make decisions based on the presence of certain attributes
      NewF->copyAttributesFrom(F);
 
-#if JL_LLVM_VERSION >= 30700
     if (OldPersonalityFn)
         F->setPersonalityFn(OldPersonalityFn);
-#endif
 
-#if JL_LLVM_VERSION >= 30500
     // DLLImport only needs to be set for the shadow module
     // it just gets annoying in the JIT
     NewF->setDLLStorageClass(GlobalValue::DefaultStorageClass);
-#endif
 
     return NewF;
 }
@@ -143,15 +118,9 @@ static inline GlobalVariable *prepare_global(GlobalVariable *G, Module *M)
     return cast<GlobalVariable>(local);
 }
 
-#if JL_LLVM_VERSION >= 30500
 void add_named_global(GlobalObject *gv, void *addr, bool dllimport);
 template<typename T>
 static inline void add_named_global(GlobalObject *gv, T *addr, bool dllimport = true)
-#else
-void add_named_global(GlobalValue *gv, void *addr, bool dllimport);
-template<typename T>
-static inline void add_named_global(GlobalValue *gv, T *addr, bool dllimport = true)
-#endif
 {
     // cast through integer to avoid c++ pedantic warning about casting between
     // data and code pointers
@@ -240,11 +209,7 @@ extern JuliaOJIT *jl_ExecutionEngine;
 #else
 extern ExecutionEngine *jl_ExecutionEngine;
 #endif
-#if JL_LLVM_VERSION >= 30900
 JL_DLLEXPORT extern LLVMContext jl_LLVMContext;
-#else
-JL_DLLEXPORT extern LLVMContext &jl_LLVMContext;
-#endif
 
 Pass *createLowerPTLSPass(bool imaging_mode);
 Pass *createLateLowerGCFramePass();
diff --git a/src/llvm-ptls.cpp b/src/llvm-ptls.cpp
index b8b6584c09a0ed..8ac71da16abf40 100644
--- a/src/llvm-ptls.cpp
+++ b/src/llvm-ptls.cpp
@@ -15,14 +15,10 @@
 #include <llvm/IR/Instructions.h>
 #include <llvm/IR/Constants.h>
 #include <llvm/IR/LLVMContext.h>
-#if JL_LLVM_VERSION >= 30700
 #include <llvm/IR/LegacyPassManager.h>
-#else
-#include <llvm/PassManager.h>
-#endif
 #include <llvm/IR/MDBuilder.h>
 
-#if JL_LLVM_VERSION >= 30700 && defined(JULIA_ENABLE_THREADING)
+#if defined(JULIA_ENABLE_THREADING)
 #  include <llvm/IR/InlineAsm.h>
 #  include <llvm/Transforms/Utils/BasicBlockUtils.h>
 #endif
@@ -63,12 +59,8 @@ static void ensure_global(const char *name, Type *t, Module &M,
     // setting JL_DLLEXPORT correctly only matters when building a binary
     // (global_proto will strip this from the JIT)
     if (dllimport) {
-#if JL_LLVM_VERSION >= 30500
         // add the __declspec(dllimport) attribute
         proto->setDLLStorageClass(GlobalValue::DLLImportStorageClass);
-#else
-        proto->setLinkage(GlobalValue::DLLImportLinkage);
-#endif
     }
 #else // _OS_WINDOWS_
     (void)proto;
@@ -87,7 +79,6 @@ static void setCallPtlsAttrs(CallInst *ptlsStates)
 #endif
 }
 
-#if JL_LLVM_VERSION >= 30700
 static Instruction *emit_ptls_tp(LLVMContext &ctx, Value *offset, Type *T_ppjlvalue,
                                  Instruction *insertBefore)
 {
@@ -153,7 +144,6 @@ static Instruction *emit_ptls_tp(LLVMContext &ctx, Value *offset, Type *T_ppjlva
     return nullptr;
 #  endif
 }
-#endif
 
 #endif
 
@@ -182,7 +172,6 @@ void LowerPTLS::runOnFunction(LLVMContext &ctx, Module &M, Function *F,
     if (imaging_mode) {
         GlobalVariable *GV = cast<GlobalVariable>(
             M.getNamedValue("jl_get_ptls_states.ptr"));
-#if JL_LLVM_VERSION >= 30700
         if (jl_tls_elf_support) {
             GlobalVariable *OffsetGV = cast<GlobalVariable>(
                 M.getNamedValue("jl_tls_offset.val"));
@@ -215,18 +204,15 @@ void LowerPTLS::runOnFunction(LLVMContext &ctx, Module &M, Function *F,
 
             return;
         }
-#endif
         auto getter = new LoadInst(GV, "", ptlsStates);
         getter->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_const);
         ptlsStates->setCalledFunction(getter);
         setCallPtlsAttrs(ptlsStates);
     }
-#if JL_LLVM_VERSION >= 30700
     else if (jl_tls_offset != -1) {
         ptlsStates->replaceAllUsesWith(emit_ptls_tp(ctx, nullptr, T_ppjlvalue, ptlsStates));
         ptlsStates->eraseFromParent();
     }
-#endif
     else {
         setCallPtlsAttrs(ptlsStates);
     }
diff --git a/src/llvm-simdloop.cpp b/src/llvm-simdloop.cpp
index 58da4b57163a82..72dbe86ee6bebd 100644
--- a/src/llvm-simdloop.cpp
+++ b/src/llvm-simdloop.cpp
@@ -32,11 +32,7 @@ bool annotateSimdLoop(BasicBlock *incr)
     // Lazy initialization
     if (!simd_loop_mdkind) {
         simd_loop_mdkind = incr->getContext().getMDKindID("simd_loop");
-#if JL_LLVM_VERSION >= 30600
         simd_loop_md = MDNode::get(incr->getContext(), ArrayRef<Metadata*>());
-#else
-        simd_loop_md = MDNode::get(incr->getContext(), ArrayRef<Value*>());
-#endif
     }
     // Ideally, the decoration would go on the block itself, but LLVM 3.3 does not
     // support putting metadata on blocks.  So instead, put the decoration on the last
@@ -118,13 +114,8 @@ void LowerSIMDLoop::enableUnsafeAlgebraIfReduction(PHINode *Phi, Loop *L) const
     for (Instruction *I = Phi; ; I=J) {
         J = NULL;
         // Find the user of instruction I that is within loop L.
-#if JL_LLVM_VERSION >= 30500
         for (User *UI : I->users()) { /*}*/
             Instruction *U = cast<Instruction>(UI);
-#else
-        for (Value::use_iterator UI = I->use_begin(), UE = I->use_end(); UI != UE; ++UI) {
-            Instruction *U = cast<Instruction>(*UI);
-#endif
             if (L->contains(U)) {
                 if (J) {
                     DEBUG(dbgs() << "LSL: not a reduction var because op has two internal uses: " << *I << "\n");
@@ -168,11 +159,7 @@ bool LowerSIMDLoop::runOnLoop(Loop *L, LPPassManager &LPM)
 {
     if (!simd_loop_mdkind) {
         simd_loop_mdkind = L->getHeader()->getContext().getMDKindID("simd_loop");
-#if JL_LLVM_VERSION >= 30600
         simd_loop_md = MDNode::get(L->getHeader()->getContext(), ArrayRef<Metadata*>());
-#else
-        simd_loop_md = MDNode::get(L->getHeader()->getContext(), ArrayRef<Value*>());
-#endif
     }
 
     if (!hasSIMDLoopMetadata(L))
@@ -181,27 +168,14 @@ bool LowerSIMDLoop::runOnLoop(Loop *L, LPPassManager &LPM)
     DEBUG(dbgs() << "LSL: simd_loop found\n");
     BasicBlock *Lh = L->getHeader();
     DEBUG(dbgs() << "LSL: loop header: " << *Lh << "\n");
-#if JL_LLVM_VERSION >= 30400
     MDNode *n = L->getLoopID();
     if (!n) {
         // Loop does not have a LoopID yet, so give it one.
-#if JL_LLVM_VERSION >= 30600
         n = MDNode::get(Lh->getContext(), ArrayRef<Metadata*>(NULL));
-#else
-        n = MDNode::get(Lh->getContext(), ArrayRef<Value*>(NULL));
-#endif
         n->replaceOperandWith(0,n);
         L->setLoopID(n);
     }
-#else
-    MDNode *n = MDNode::get(Lh->getContext(), ArrayRef<Value*>());
-    L->getLoopLatch()->getTerminator()->setMetadata("llvm.loop.parallel", n);
-#endif
-#if JL_LLVM_VERSION >= 30600
     MDNode *m = MDNode::get(Lh->getContext(), ArrayRef<Metadata*>(n));
-#else
-    MDNode *m = MDNode::get(Lh->getContext(), ArrayRef<Value*>(n));
-#endif
 
     // Mark memory references so that Loop::isAnnotatedParallel will return true for this loop.
     for(Loop::block_iterator BBI = L->block_begin(), E=L->block_end(); BBI!=E; ++BBI)
diff --git a/src/llvm-version.h b/src/llvm-version.h
index 308aa42e14bddf..77879bb8b96e46 100644
--- a/src/llvm-version.h
+++ b/src/llvm-version.h
@@ -3,36 +3,14 @@
 #include <llvm/Config/llvm-config.h>
 #include "fix_llvm_assert.h"
 
-#ifndef LLVM_VERSION_PATCH // for LLVM 3.3
-#define LLVM_VERSION_PATCH 0
-#endif
-
 // The LLVM version used, JL_LLVM_VERSION, is represented as a 5-digit integer
 // of the form ABBCC, where A is the major version, B is minor, and C is patch.
 // So for example, LLVM 3.7.0 is 30700.
 #define JL_LLVM_VERSION (LLVM_VERSION_MAJOR * 10000 + LLVM_VERSION_MINOR * 100 \
                         + LLVM_VERSION_PATCH)
 
-#if JL_LLVM_VERSION != 30300 && JL_LLVM_VERSION < 30701
-    #error Only LLVM versions 3.3 and >= 3.7.1 are supported by Julia
+#if JL_LLVM_VERSION < 30901
+    #error Only LLVM versions >= 3.9.1 are supported by Julia
 #endif
 
-#if JL_LLVM_VERSION >= 30800
-    #define USE_ORCJIT
-// We enable ORCJIT only if we have our custom patches
-#elif JL_LLVM_VERSION >= 30700 && !defined(SYSTEM_LLVM)
-    #define USE_ORCJIT
-#endif
-
-#if JL_LLVM_VERSION >= 30400
-    #define USE_MCJIT
-#endif
-
-
-//temporary, since in some places USE_MCJIT may be used instead of the correct LLVM version test
-#ifdef USE_ORCJIT
-    #define USE_MCJIT
-#endif
-#ifdef USE_ORCMCJIT
-    #define USE_MCJIT
-#endif
+#define USE_ORCJIT