diff options
-rw-r--r-- | .SRCINFO | 25 | ||||
-rw-r--r-- | 0002-OCaml-Remove-all-PassManager-related-functions.patch (renamed from 0001-OCaml-Remove-all-PassManager-related-functions.patch) | 0 | ||||
-rw-r--r-- | 0003-IPO-Remove-various-legacy-passes.patch (renamed from 0001-IPO-Remove-various-legacy-passes.patch) | 0 | ||||
-rw-r--r-- | 0004-llvm-c-Remove-bindings-for-creating-legacy-passes.patch (renamed from 0001-llvm-c-Remove-bindings-for-creating-legacy-passes.patch) | 0 | ||||
-rw-r--r-- | 0005-llvm-c-Remove-PassManagerBuilder-APIs.patch | 239 | ||||
-rw-r--r-- | 0006-llvm-c-Remove-pointee-support-from-LLVMGetElementTyp.patch | 56 | ||||
-rw-r--r-- | 0007-Passes-Remove-some-legacy-passes.patch | 1154 | ||||
-rw-r--r-- | PKGBUILD | 39 |
8 files changed, 1493 insertions, 20 deletions
@@ -1,5 +1,5 @@ pkgbase = llvm-minimal-git - pkgver = 17.0.0_r453589.44c6b905f852 + pkgver = 17.0.0_r454285.890e6c871d31 pkgrel = 1 url = https://llvm.org/ arch = x86_64 @@ -22,27 +22,36 @@ pkgbase = llvm-minimal-git source = local://llvm-config.h source = git+https://github.com/KhronosGroup/SPIRV-LLVM-Translator.git source = 0001-IPSCCP-Remove-legacy-pass.patch - source = 0001-OCaml-Remove-all-PassManager-related-functions.patch - source = 0001-llvm-c-Remove-bindings-for-creating-legacy-passes.patch - source = 0001-IPO-Remove-various-legacy-passes.patch + source = 0002-OCaml-Remove-all-PassManager-related-functions.patch + source = 0003-IPO-Remove-various-legacy-passes.patch + source = 0004-llvm-c-Remove-bindings-for-creating-legacy-passes.patch + source = 0005-llvm-c-Remove-PassManagerBuilder-APIs.patch + source = 0006-llvm-c-Remove-pointee-support-from-LLVMGetElementTyp.patch + source = 0007-Passes-Remove-some-legacy-passes.patch md5sums = SKIP md5sums = 295c343dcd457dc534662f011d7cff1a md5sums = SKIP md5sums = 245054bc67dec3eb30329bbdeed171b1 md5sums = 4c5ac9bca18c8a92280b1699f2f85a16 - md5sums = 286194131e1b5df0fe50ecd0f1b58eb2 md5sums = 179d535366bdb73c6b02850210aca69c + md5sums = 286194131e1b5df0fe50ecd0f1b58eb2 + md5sums = 9e7e1648b472f83b054bf8dcbfc74175 + md5sums = a4604d7858e1536af63f52dcbc47fbb8 + md5sums = a09eda7d75c717aeb882fdfa67b028c3 sha512sums = SKIP sha512sums = 75e743dea28b280943b3cc7f8bbb871b57d110a7f2b9da2e6845c1c36bf170dd883fca54e463f5f49e0c3effe07fbd0db0f8cf5a12a2469d3f792af21a73fcdd sha512sums = SKIP sha512sums = 4c1e8a455163ceb1e7d3f09f5e68f731e47f2346a2f62e1fe97b19f54c16781efc0b75d52304fe9d4aa62512fd6f32b7bd6e12b319cbe72e7831f1a056ffbfd0 sha512sums = 92f971db948e8acd4a55cb46ef28dc394c5df07f57844b63d82fc19436e2dfe7b184599ca17d84ef4fa63f6281628d8cc734d74dcc95bc0eee8a5e7c3778f49a - sha512sums = d3f5df839b49e4a853e88efaf2fb31c36efb15a91b4803f7e52414ab0e3121f4bfafc7d39edaad52a29106ca648428577f97f4fd12e7575cd3bbe009a1111901 sha512sums = ab46bd37d540e9c62d99cc9e137079e077f032d0ba6531b0685d2bb91a4d832787dd12e3680c76b58d26ada7e81b3a7d8d138c303a6ffb21b593dc549aecb140 + sha512sums = d3f5df839b49e4a853e88efaf2fb31c36efb15a91b4803f7e52414ab0e3121f4bfafc7d39edaad52a29106ca648428577f97f4fd12e7575cd3bbe009a1111901 + sha512sums = 034b8262c2cec48fcdf1eef8f74332fc7016ecbf1627ab755f95f525c653cab0dd4199cd60b85dd09a63dc0b76bc9db9f85043c91801940294e42bc1feb1ea60 + sha512sums = 2f227060ab56e04bf3e74fbb785c2edf9fc55121c936ba17ac62275cacdacfb9cb84bfda0e6637e11e744e26212bbfa861fa320084502afb4b7fd247d832993b + sha512sums = 6d77c23ad97c057898d97fd08af9714ff18c43026e082ad5e654b736caffb1ba814de0ebb9a7e169de9475d819df3cd0058805e4a0f020c55ce3b2272181802a pkgname = llvm-minimal-git pkgdesc = Collection of modular and reusable compiler and toolchain technologies - depends = llvm-libs-minimal-git=17.0.0_r453589.44c6b905f852-1 + depends = llvm-libs-minimal-git=17.0.0_r454285.890e6c871d31-1 depends = perl optdepends = python: for using lit (LLVM Integrated Tester) optdepends = python-setuptools: for using lit @@ -66,7 +75,7 @@ pkgname = llvm-libs-minimal-git pkgname = spirv-llvm-translator-minimal-git pkgdesc = Tool and a library for bi-directional translation between SPIR-V and LLVM IR, trunk version - depends = llvm-minimal-git=17.0.0_r453589.44c6b905f852-1 + depends = llvm-minimal-git=17.0.0_r454285.890e6c871d31-1 depends = spirv-tools-git provides = spirv-llvm-translator conflicts = spirv-llvm-translator diff --git a/0001-OCaml-Remove-all-PassManager-related-functions.patch b/0002-OCaml-Remove-all-PassManager-related-functions.patch index 49c5049c5f66..49c5049c5f66 100644 --- a/0001-OCaml-Remove-all-PassManager-related-functions.patch +++ b/0002-OCaml-Remove-all-PassManager-related-functions.patch diff --git a/0001-IPO-Remove-various-legacy-passes.patch b/0003-IPO-Remove-various-legacy-passes.patch index 76330ff53a95..76330ff53a95 100644 --- a/0001-IPO-Remove-various-legacy-passes.patch +++ b/0003-IPO-Remove-various-legacy-passes.patch diff --git a/0001-llvm-c-Remove-bindings-for-creating-legacy-passes.patch b/0004-llvm-c-Remove-bindings-for-creating-legacy-passes.patch index a9dfd87457cd..a9dfd87457cd 100644 --- a/0001-llvm-c-Remove-bindings-for-creating-legacy-passes.patch +++ b/0004-llvm-c-Remove-bindings-for-creating-legacy-passes.patch diff --git a/0005-llvm-c-Remove-PassManagerBuilder-APIs.patch b/0005-llvm-c-Remove-PassManagerBuilder-APIs.patch new file mode 100644 index 000000000000..599e3a420aae --- /dev/null +++ b/0005-llvm-c-Remove-PassManagerBuilder-APIs.patch @@ -0,0 +1,239 @@ +From 0aac9a2875bad4f065367e4a6553fad78605f895 Mon Sep 17 00:00:00 2001 +From: Nikita Popov <npopov@redhat.com> +Date: Mon, 6 Mar 2023 16:53:35 +0100 +Subject: [PATCH] [llvm-c] Remove PassManagerBuilder APIs + +The legacy PM is only supported for codegen, and PassManagerBuilder +is exclusively about the middle-end optimization pipeline. Drop it. + +Differential Revision: https://reviews.llvm.org/D145387 +--- + llvm/docs/ReleaseNotes.rst | 2 + + .../llvm-c/Transforms/PassManagerBuilder.h | 81 ------------------- + .../llvm/Transforms/IPO/PassManagerBuilder.h | 9 --- + .../lib/Transforms/IPO/PassManagerBuilder.cpp | 66 --------------- + llvm/tools/llvm-c-test/include-all.c | 1 - + 5 files changed, 2 insertions(+), 157 deletions(-) + delete mode 100644 llvm/include/llvm-c/Transforms/PassManagerBuilder.h + +diff --git a/llvm/docs/ReleaseNotes.rst b/llvm/docs/ReleaseNotes.rst +index c136eb7f8fe7..f6ac66df740a 100644 +--- a/llvm/docs/ReleaseNotes.rst ++++ b/llvm/docs/ReleaseNotes.rst +@@ -147,6 +147,8 @@ Changes to the C API + pointer, has been removed. + * Functions for adding legacy passes like ``LLVMAddInstructionCombiningPass`` + have been removed. ++* Removed ``LLVMPassManagerBuilderRef`` and functions interacting with it. ++ These belonged to the no longer supported legacy pass manager. + + Changes to the FastISel infrastructure + -------------------------------------- +diff --git a/llvm/include/llvm-c/Transforms/PassManagerBuilder.h b/llvm/include/llvm-c/Transforms/PassManagerBuilder.h +deleted file mode 100644 +index 3ba75440129a..000000000000 +--- a/llvm/include/llvm-c/Transforms/PassManagerBuilder.h ++++ /dev/null +@@ -1,81 +0,0 @@ +-/*===-- llvm-c/Transform/PassManagerBuilder.h - PMB C Interface ---*- C -*-===*\ +-|* *| +-|* Part of the LLVM Project, under the Apache License v2.0 with LLVM *| +-|* Exceptions. *| +-|* See https://llvm.org/LICENSE.txt for license information. *| +-|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception *| +-|* *| +-|*===----------------------------------------------------------------------===*| +-|* *| +-|* This header declares the C interface to the PassManagerBuilder class. *| +-|* *| +-\*===----------------------------------------------------------------------===*/ +- +-#ifndef LLVM_C_TRANSFORMS_PASSMANAGERBUILDER_H +-#define LLVM_C_TRANSFORMS_PASSMANAGERBUILDER_H +- +-#include "llvm-c/ExternC.h" +-#include "llvm-c/Types.h" +- +-typedef struct LLVMOpaquePassManagerBuilder *LLVMPassManagerBuilderRef; +- +-LLVM_C_EXTERN_C_BEGIN +- +-/** +- * @defgroup LLVMCTransformsPassManagerBuilder Pass manager builder +- * @ingroup LLVMCTransforms +- * +- * @{ +- */ +- +-/** See llvm::PassManagerBuilder. */ +-LLVMPassManagerBuilderRef LLVMPassManagerBuilderCreate(void); +-void LLVMPassManagerBuilderDispose(LLVMPassManagerBuilderRef PMB); +- +-/** See llvm::PassManagerBuilder::OptLevel. */ +-void +-LLVMPassManagerBuilderSetOptLevel(LLVMPassManagerBuilderRef PMB, +- unsigned OptLevel); +- +-/** See llvm::PassManagerBuilder::SizeLevel. */ +-void +-LLVMPassManagerBuilderSetSizeLevel(LLVMPassManagerBuilderRef PMB, +- unsigned SizeLevel); +- +-/** See llvm::PassManagerBuilder::DisableUnitAtATime. */ +-void +-LLVMPassManagerBuilderSetDisableUnitAtATime(LLVMPassManagerBuilderRef PMB, +- LLVMBool Value); +- +-/** See llvm::PassManagerBuilder::DisableUnrollLoops. */ +-void +-LLVMPassManagerBuilderSetDisableUnrollLoops(LLVMPassManagerBuilderRef PMB, +- LLVMBool Value); +- +-/** See llvm::PassManagerBuilder::DisableSimplifyLibCalls */ +-void +-LLVMPassManagerBuilderSetDisableSimplifyLibCalls(LLVMPassManagerBuilderRef PMB, +- LLVMBool Value); +- +-/** See llvm::PassManagerBuilder::Inliner. */ +-void +-LLVMPassManagerBuilderUseInlinerWithThreshold(LLVMPassManagerBuilderRef PMB, +- unsigned Threshold); +- +-/** See llvm::PassManagerBuilder::populateFunctionPassManager. */ +-void +-LLVMPassManagerBuilderPopulateFunctionPassManager(LLVMPassManagerBuilderRef PMB, +- LLVMPassManagerRef PM); +- +-/** See llvm::PassManagerBuilder::populateModulePassManager. */ +-void +-LLVMPassManagerBuilderPopulateModulePassManager(LLVMPassManagerBuilderRef PMB, +- LLVMPassManagerRef PM); +- +-/** +- * @} +- */ +- +-LLVM_C_EXTERN_C_END +- +-#endif +diff --git a/llvm/include/llvm/Transforms/IPO/PassManagerBuilder.h b/llvm/include/llvm/Transforms/IPO/PassManagerBuilder.h +index 3930cb8a0e05..a727ffed33cd 100644 +--- a/llvm/include/llvm/Transforms/IPO/PassManagerBuilder.h ++++ b/llvm/include/llvm/Transforms/IPO/PassManagerBuilder.h +@@ -14,7 +14,6 @@ + #ifndef LLVM_TRANSFORMS_IPO_PASSMANAGERBUILDER_H + #define LLVM_TRANSFORMS_IPO_PASSMANAGERBUILDER_H + +-#include "llvm-c/Transforms/PassManagerBuilder.h" + #include <functional> + #include <string> + #include <vector> +@@ -122,13 +121,5 @@ public: + void populateModulePassManager(legacy::PassManagerBase &MPM); + }; + +-inline PassManagerBuilder *unwrap(LLVMPassManagerBuilderRef P) { +- return reinterpret_cast<PassManagerBuilder*>(P); +-} +- +-inline LLVMPassManagerBuilderRef wrap(PassManagerBuilder *P) { +- return reinterpret_cast<LLVMPassManagerBuilderRef>(P); +-} +- + } // end namespace llvm + #endif +diff --git a/llvm/lib/Transforms/IPO/PassManagerBuilder.cpp b/llvm/lib/Transforms/IPO/PassManagerBuilder.cpp +index 5fec9dcbadb3..cd8523c215a0 100644 +--- a/llvm/lib/Transforms/IPO/PassManagerBuilder.cpp ++++ b/llvm/lib/Transforms/IPO/PassManagerBuilder.cpp +@@ -12,7 +12,6 @@ + //===----------------------------------------------------------------------===// + + #include "llvm/Transforms/IPO/PassManagerBuilder.h" +-#include "llvm-c/Transforms/PassManagerBuilder.h" + #include "llvm/ADT/STLExtras.h" + #include "llvm/ADT/SmallVector.h" + #include "llvm/Analysis/GlobalsModRef.h" +@@ -361,68 +360,3 @@ void PassManagerBuilder::populateModulePassManager( + MPM.add(createCFGSimplificationPass( + SimplifyCFGOptions().convertSwitchRangeToICmp(true))); + } +- +-LLVMPassManagerBuilderRef LLVMPassManagerBuilderCreate() { +- PassManagerBuilder *PMB = new PassManagerBuilder(); +- return wrap(PMB); +-} +- +-void LLVMPassManagerBuilderDispose(LLVMPassManagerBuilderRef PMB) { +- PassManagerBuilder *Builder = unwrap(PMB); +- delete Builder; +-} +- +-void +-LLVMPassManagerBuilderSetOptLevel(LLVMPassManagerBuilderRef PMB, +- unsigned OptLevel) { +- PassManagerBuilder *Builder = unwrap(PMB); +- Builder->OptLevel = OptLevel; +-} +- +-void +-LLVMPassManagerBuilderSetSizeLevel(LLVMPassManagerBuilderRef PMB, +- unsigned SizeLevel) { +- PassManagerBuilder *Builder = unwrap(PMB); +- Builder->SizeLevel = SizeLevel; +-} +- +-void +-LLVMPassManagerBuilderSetDisableUnitAtATime(LLVMPassManagerBuilderRef PMB, +- LLVMBool Value) { +- // NOTE: The DisableUnitAtATime switch has been removed. +-} +- +-void +-LLVMPassManagerBuilderSetDisableUnrollLoops(LLVMPassManagerBuilderRef PMB, +- LLVMBool Value) { +- PassManagerBuilder *Builder = unwrap(PMB); +- Builder->DisableUnrollLoops = Value; +-} +- +-void +-LLVMPassManagerBuilderSetDisableSimplifyLibCalls(LLVMPassManagerBuilderRef PMB, +- LLVMBool Value) { +- // NOTE: The simplify-libcalls pass has been removed. +-} +- +-void +-LLVMPassManagerBuilderUseInlinerWithThreshold(LLVMPassManagerBuilderRef PMB, +- unsigned Threshold) { +- // TODO: remove this +-} +- +-void +-LLVMPassManagerBuilderPopulateFunctionPassManager(LLVMPassManagerBuilderRef PMB, +- LLVMPassManagerRef PM) { +- PassManagerBuilder *Builder = unwrap(PMB); +- legacy::FunctionPassManager *FPM = unwrap<legacy::FunctionPassManager>(PM); +- Builder->populateFunctionPassManager(*FPM); +-} +- +-void +-LLVMPassManagerBuilderPopulateModulePassManager(LLVMPassManagerBuilderRef PMB, +- LLVMPassManagerRef PM) { +- PassManagerBuilder *Builder = unwrap(PMB); +- legacy::PassManagerBase *MPM = unwrap(PM); +- Builder->populateModulePassManager(*MPM); +-} +diff --git a/llvm/tools/llvm-c-test/include-all.c b/llvm/tools/llvm-c-test/include-all.c +index eada03caf5e0..d5d07ff0b891 100644 +--- a/llvm/tools/llvm-c-test/include-all.c ++++ b/llvm/tools/llvm-c-test/include-all.c +@@ -36,6 +36,5 @@ + #include "llvm-c/Target.h" + #include "llvm-c/TargetMachine.h" + #include "llvm-c/Transforms/PassBuilder.h" +-#include "llvm-c/Transforms/PassManagerBuilder.h" + #include "llvm-c/Types.h" + #include "llvm-c/lto.h" +-- +2.39.2 + diff --git a/0006-llvm-c-Remove-pointee-support-from-LLVMGetElementTyp.patch b/0006-llvm-c-Remove-pointee-support-from-LLVMGetElementTyp.patch new file mode 100644 index 000000000000..c63d58a93c97 --- /dev/null +++ b/0006-llvm-c-Remove-pointee-support-from-LLVMGetElementTyp.patch @@ -0,0 +1,56 @@ +From 9e0c2626f3d4282a135da112320139d9fba32fb5 Mon Sep 17 00:00:00 2001 +From: Arthur Eubanks <aeubanks@google.com> +Date: Thu, 9 Mar 2023 15:42:27 -0800 +Subject: [PATCH] [llvm-c] Remove pointee support from LLVMGetElementType + +Reviewed By: nikic + +Differential Revision: https://reviews.llvm.org/D145717 +--- + llvm/docs/ReleaseNotes.rst | 2 ++ + llvm/include/llvm-c/Core.h | 2 -- + llvm/lib/IR/Core.cpp | 2 -- + 3 files changed, 2 insertions(+), 4 deletions(-) + +diff --git a/llvm/docs/ReleaseNotes.rst b/llvm/docs/ReleaseNotes.rst +index f6ac66df740a..4cf01ad8e284 100644 +--- a/llvm/docs/ReleaseNotes.rst ++++ b/llvm/docs/ReleaseNotes.rst +@@ -149,6 +149,8 @@ Changes to the C API + have been removed. + * Removed ``LLVMPassManagerBuilderRef`` and functions interacting with it. + These belonged to the no longer supported legacy pass manager. ++* As part of the opaque pointer transition, ``LLVMGetElementType`` no longer ++ gives the pointee type of a pointer type. + + Changes to the FastISel infrastructure + -------------------------------------- +diff --git a/llvm/include/llvm-c/Core.h b/llvm/include/llvm-c/Core.h +index df9db59503c3..5454cc2d96c5 100644 +--- a/llvm/include/llvm-c/Core.h ++++ b/llvm/include/llvm-c/Core.h +@@ -1411,8 +1411,6 @@ LLVMBool LLVMIsLiteralStruct(LLVMTypeRef StructTy); + /** + * Obtain the element type of an array or vector type. + * +- * This currently also works for pointer types, but this usage is deprecated. +- * + * @see llvm::SequentialType::getElementType() + */ + LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty); +diff --git a/llvm/lib/IR/Core.cpp b/llvm/lib/IR/Core.cpp +index a0fade96daec..85b7d17ef56c 100644 +--- a/llvm/lib/IR/Core.cpp ++++ b/llvm/lib/IR/Core.cpp +@@ -811,8 +811,6 @@ LLVMTypeRef LLVMScalableVectorType(LLVMTypeRef ElementType, + + LLVMTypeRef LLVMGetElementType(LLVMTypeRef WrappedTy) { + auto *Ty = unwrap(WrappedTy); +- if (auto *PTy = dyn_cast<PointerType>(Ty)) +- return wrap(PTy->getNonOpaquePointerElementType()); + if (auto *ATy = dyn_cast<ArrayType>(Ty)) + return wrap(ATy->getElementType()); + return wrap(cast<VectorType>(Ty)->getElementType()); +-- +2.39.2 + diff --git a/0007-Passes-Remove-some-legacy-passes.patch b/0007-Passes-Remove-some-legacy-passes.patch new file mode 100644 index 000000000000..3b0c98f64570 --- /dev/null +++ b/0007-Passes-Remove-some-legacy-passes.patch @@ -0,0 +1,1154 @@ +From 7c3c981442b11153ac1a2be678db727ff715253b Mon Sep 17 00:00:00 2001 +From: Arthur Eubanks <aeubanks@google.com> +Date: Wed, 8 Mar 2023 15:07:17 -0800 +Subject: [PATCH] [Passes] Remove some legacy passes + +DFAJumpThreading +JumpThreading +LibCallsShrink +LoopVectorize +SLPVectorizer +DeadStoreElimination +AggressiveDCE +CorrelatedValuePropagation +IndVarSimplify + +These are part of the optimization pipeline, of which the legacy version is deprecated and being removed. +--- + .../LLJITWithOptimizingIRTransform.cpp | 1 - + llvm/include/llvm/InitializePasses.h | 4 - + llvm/include/llvm/LinkAllPasses.h | 9 -- + llvm/include/llvm/Transforms/Scalar.h | 51 ---------- + llvm/include/llvm/Transforms/Vectorize.h | 14 --- + .../lib/Transforms/IPO/PassManagerBuilder.cpp | 19 ---- + llvm/lib/Transforms/Scalar/ADCE.cpp | 47 --------- + .../Scalar/CorrelatedValuePropagation.cpp | 47 --------- + .../Transforms/Scalar/DFAJumpThreading.cpp | 43 -------- + .../Scalar/DeadStoreElimination.cpp | 76 -------------- + llvm/lib/Transforms/Scalar/IndVarSimplify.cpp | 51 ---------- + llvm/lib/Transforms/Scalar/JumpThreading.cpp | 87 ---------------- + llvm/lib/Transforms/Scalar/Scalar.cpp | 6 -- + .../Transforms/Utils/LibCallsShrinkWrap.cpp | 43 -------- + llvm/lib/Transforms/Utils/Utils.cpp | 1 - + .../Transforms/Vectorize/LoopVectorize.cpp | 98 ------------------- + .../Transforms/Vectorize/SLPVectorizer.cpp | 71 -------------- + llvm/lib/Transforms/Vectorize/Vectorize.cpp | 2 - + .../hexagon_vector_loop_carried_reuse.ll | 2 +- + ...n_vector_loop_carried_reuse_commutative.ll | 2 +- + ...agon_vector_loop_carried_reuse_constant.ll | 2 +- + .../scev-after-loopinstsimplify.ll | 2 +- + .../AArch64/sleef-calls-aarch64.ll | 2 +- + polly/lib/Transform/Canonicalization.cpp | 1 - + 24 files changed, 5 insertions(+), 676 deletions(-) + +diff --git a/llvm/examples/OrcV2Examples/LLJITWithOptimizingIRTransform/LLJITWithOptimizingIRTransform.cpp b/llvm/examples/OrcV2Examples/LLJITWithOptimizingIRTransform/LLJITWithOptimizingIRTransform.cpp +index a5fd384b65b5..069c8e8e8031 100644 +--- a/llvm/examples/OrcV2Examples/LLJITWithOptimizingIRTransform/LLJITWithOptimizingIRTransform.cpp ++++ b/llvm/examples/OrcV2Examples/LLJITWithOptimizingIRTransform/LLJITWithOptimizingIRTransform.cpp +@@ -74,7 +74,6 @@ class MyOptimizationTransform { + public: + MyOptimizationTransform() : PM(std::make_unique<legacy::PassManager>()) { + PM->add(createTailCallEliminationPass()); +- PM->add(createIndVarSimplifyPass()); + PM->add(createCFGSimplificationPass()); + } + +diff --git a/llvm/include/llvm/InitializePasses.h b/llvm/include/llvm/InitializePasses.h +index 818dd2e5c45e..64a9f7b47112 100644 +--- a/llvm/include/llvm/InitializePasses.h ++++ b/llvm/include/llvm/InitializePasses.h +@@ -99,7 +99,6 @@ void initializeCycleInfoWrapperPassPass(PassRegistry &); + void initializeDAEPass(PassRegistry&); + void initializeDAHPass(PassRegistry&); + void initializeDCELegacyPassPass(PassRegistry&); +-void initializeDFAJumpThreadingLegacyPassPass(PassRegistry &); + void initializeDSELegacyPassPass(PassRegistry&); + void initializeDeadMachineInstructionElimPass(PassRegistry&); + void initializeDebugifyMachineModulePass(PassRegistry &); +@@ -189,7 +188,6 @@ void initializeLegacyLoopSinkPassPass(PassRegistry&); + void initializeLegalizerPass(PassRegistry&); + void initializeGISelCSEAnalysisWrapperPassPass(PassRegistry &); + void initializeGISelKnownBitsAnalysisPass(PassRegistry &); +-void initializeLibCallsShrinkWrapLegacyPassPass(PassRegistry&); + void initializeLintLegacyPassPass(PassRegistry &); + void initializeLiveDebugValuesPass(PassRegistry&); + void initializeLiveDebugVariablesPass(PassRegistry&); +@@ -215,7 +213,6 @@ void initializeLoopSimplifyCFGLegacyPassPass(PassRegistry&); + void initializeLoopSimplifyPass(PassRegistry&); + void initializeLoopStrengthReducePass(PassRegistry&); + void initializeLoopUnrollPass(PassRegistry&); +-void initializeLoopVectorizePass(PassRegistry&); + void initializeLowerAtomicLegacyPassPass(PassRegistry&); + void initializeLowerConstantIntrinsicsPass(PassRegistry&); + void initializeLowerEmuTLSPass(PassRegistry&); +@@ -336,7 +333,6 @@ void initializeRewriteStatepointsForGCLegacyPassPass(PassRegistry &); + void initializeRewriteSymbolsLegacyPassPass(PassRegistry&); + void initializeSCCPLegacyPassPass(PassRegistry&); + void initializeSCEVAAWrapperPassPass(PassRegistry&); +-void initializeSLPVectorizerPass(PassRegistry&); + void initializeSROALegacyPassPass(PassRegistry&); + void initializeSafeStackLegacyPassPass(PassRegistry&); + void initializeSafepointIRVerifierPass(PassRegistry&); +diff --git a/llvm/include/llvm/LinkAllPasses.h b/llvm/include/llvm/LinkAllPasses.h +index 3f20916af2f3..9e16054bfb9f 100644 +--- a/llvm/include/llvm/LinkAllPasses.h ++++ b/llvm/include/llvm/LinkAllPasses.h +@@ -69,7 +69,6 @@ namespace { + return; + + (void) llvm::createAAEvalPass(); +- (void) llvm::createAggressiveDCEPass(); + (void)llvm::createBitTrackingDCEPass(); + (void) llvm::createAlignmentFromAssumptionsPass(); + (void) llvm::createBasicAAWrapperPass(); +@@ -81,11 +80,9 @@ namespace { + (void) llvm::createCallGraphViewerPass(); + (void) llvm::createCFGSimplificationPass(); + (void) llvm::createStructurizeCFGPass(); +- (void) llvm::createLibCallsShrinkWrapPass(); + (void) llvm::createCostModelAnalysisPass(); + (void) llvm::createDeadArgEliminationPass(); + (void) llvm::createDeadCodeEliminationPass(); +- (void) llvm::createDeadStoreEliminationPass(); + (void) llvm::createDependenceAnalysisWrapperPass(); + (void) llvm::createDomOnlyPrinterWrapperPassPass(); + (void) llvm::createDomPrinterWrapperPassPass(); +@@ -96,7 +93,6 @@ namespace { + (void) llvm::createGuardWideningPass(); + (void) llvm::createLoopGuardWideningPass(); + (void) llvm::createInductiveRangeCheckEliminationPass(); +- (void) llvm::createIndVarSimplifyPass(); + (void) llvm::createInstSimplifyLegacyPass(); + (void) llvm::createInstructionCombiningPass(); + (void) llvm::createJMCInstrumenterPass(); +@@ -137,8 +133,6 @@ namespace { + (void) llvm::createSingleLoopExtractorPass(); + (void) llvm::createTailCallEliminationPass(); + (void)llvm::createTLSVariableHoistPass(); +- (void) llvm::createJumpThreadingPass(); +- (void) llvm::createDFAJumpThreadingPass(); + (void) llvm::createUnifyFunctionExitNodesPass(); + (void) llvm::createInstCountPass(); + (void) llvm::createConstantHoistingPass(); +@@ -164,10 +158,7 @@ namespace { + (void) llvm::createLintLegacyPassPass(); + (void) llvm::createSinkingPass(); + (void) llvm::createLowerAtomicPass(); +- (void) llvm::createCorrelatedValuePropagationPass(); + (void) llvm::createMemDepPrinter(); +- (void) llvm::createLoopVectorizePass(); +- (void) llvm::createSLPVectorizerPass(); + (void) llvm::createLoadStoreVectorizerPass(); + (void) llvm::createPartiallyInlineLibCallsPass(); + (void) llvm::createScalarizerPass(); +diff --git a/llvm/include/llvm/Transforms/Scalar.h b/llvm/include/llvm/Transforms/Scalar.h +index ae91ddca7b81..e9b6dc40c913 100644 +--- a/llvm/include/llvm/Transforms/Scalar.h ++++ b/llvm/include/llvm/Transforms/Scalar.h +@@ -47,13 +47,6 @@ Pass *createRedundantDbgInstEliminationPass(); + // + FunctionPass *createDeadCodeEliminationPass(); + +-//===----------------------------------------------------------------------===// +-// +-// DeadStoreElimination - This pass deletes stores that are post-dominated by +-// must-aliased stores and are not loaded used between the stores. +-// +-FunctionPass *createDeadStoreEliminationPass(); +- + + //===----------------------------------------------------------------------===// + // +@@ -61,14 +54,6 @@ FunctionPass *createDeadStoreEliminationPass(); + // values. + FunctionPass *createCallSiteSplittingPass(); + +-//===----------------------------------------------------------------------===// +-// +-// AggressiveDCE - This pass uses the SSA based Aggressive DCE algorithm. This +-// algorithm assumes instructions are dead until proven otherwise, which makes +-// it more successful are removing non-obviously dead instructions. +-// +-FunctionPass *createAggressiveDCEPass(); +- + //===----------------------------------------------------------------------===// + // + // GuardWidening - An optimization over the @llvm.experimental.guard intrinsic +@@ -108,13 +93,6 @@ FunctionPass *createSROAPass(bool PreserveCFG = true); + // + Pass *createInductiveRangeCheckEliminationPass(); + +-//===----------------------------------------------------------------------===// +-// +-// InductionVariableSimplify - Transform induction variables in a program to all +-// use a single canonical induction variable per loop. +-// +-Pass *createIndVarSimplifyPass(); +- + //===----------------------------------------------------------------------===// + // + // LICM - This pass is a loop invariant code motion and memory promotion pass. +@@ -188,22 +166,6 @@ extern char &DemoteRegisterToMemoryID; + // + FunctionPass *createReassociatePass(); + +-//===----------------------------------------------------------------------===// +-// +-// JumpThreading - Thread control through mult-pred/multi-succ blocks where some +-// preds always go to some succ. Thresholds other than minus one +-// override the internal BB duplication default threshold. +-// +-FunctionPass *createJumpThreadingPass(int Threshold = -1); +- +-//===----------------------------------------------------------------------===// +-// +-// DFAJumpThreading - When a switch statement inside a loop is used to +-// implement a deterministic finite automata we can jump thread the switch +-// statement reducing number of conditional jumps. +-// +-FunctionPass *createDFAJumpThreadingPass(); +- + //===----------------------------------------------------------------------===// + // + // CFGSimplification - Merge basic blocks, eliminate unreachable blocks, +@@ -327,12 +289,6 @@ Pass *createLowerWidenableConditionPass(); + // + Pass *createMergeICmpsLegacyPass(); + +-//===----------------------------------------------------------------------===// +-// +-// ValuePropagation - Propagate CFG-derived value information +-// +-Pass *createCorrelatedValuePropagationPass(); +- + //===----------------------------------------------------------------------===// + // + // InferAddressSpaces - Modify users of addrspacecast instructions with values +@@ -428,13 +384,6 @@ FunctionPass *createNaryReassociatePass(); + // + FunctionPass *createLoopDataPrefetchPass(); + +-//===----------------------------------------------------------------------===// +-// +-// LibCallsShrinkWrap - Shrink-wraps a call to function if the result is not +-// used. +-// +-FunctionPass *createLibCallsShrinkWrapPass(); +- + //===----------------------------------------------------------------------===// + // + // LoopSimplifyCFG - This pass performs basic CFG simplification on loops, +diff --git a/llvm/include/llvm/Transforms/Vectorize.h b/llvm/include/llvm/Transforms/Vectorize.h +index bca78d073003..b77ebbc55e7d 100644 +--- a/llvm/include/llvm/Transforms/Vectorize.h ++++ b/llvm/include/llvm/Transforms/Vectorize.h +@@ -104,20 +104,6 @@ struct VectorizeConfig { + VectorizeConfig(); + }; + +-//===----------------------------------------------------------------------===// +-// +-// LoopVectorize - Create a loop vectorization pass. +-// +-Pass *createLoopVectorizePass(); +-Pass *createLoopVectorizePass(bool InterleaveOnlyWhenForced, +- bool VectorizeOnlyWhenForced); +- +-//===----------------------------------------------------------------------===// +-// +-// SLPVectorizer - Create a bottom-up SLP vectorizer pass. +-// +-Pass *createSLPVectorizerPass(); +- + //===----------------------------------------------------------------------===// + /// Vectorize the BasicBlock. + /// +diff --git a/llvm/lib/Transforms/IPO/PassManagerBuilder.cpp b/llvm/lib/Transforms/IPO/PassManagerBuilder.cpp +index cd8523c215a0..ba7a7f9b121d 100644 +--- a/llvm/lib/Transforms/IPO/PassManagerBuilder.cpp ++++ b/llvm/lib/Transforms/IPO/PassManagerBuilder.cpp +@@ -102,17 +102,12 @@ void PassManagerBuilder::addFunctionSimplificationPasses( + if (OptLevel > 1) { + // Speculative execution if the target has divergent branches; otherwise nop. + MPM.add(createSpeculativeExecutionIfHasBranchDivergencePass()); +- +- MPM.add(createJumpThreadingPass()); // Thread jumps. +- MPM.add(createCorrelatedValuePropagationPass()); // Propagate conditionals + } + MPM.add( + createCFGSimplificationPass(SimplifyCFGOptions().convertSwitchRangeToICmp( + true))); // Merge & remove BBs + // Combine silly seq's + MPM.add(createInstructionCombiningPass()); +- if (SizeLevel == 0) +- MPM.add(createLibCallsShrinkWrapPass()); + + // TODO: Investigate the cost/benefit of tail call elimination on debugging. + if (OptLevel > 1) +@@ -151,7 +146,6 @@ void PassManagerBuilder::addFunctionSimplificationPasses( + SimplifyCFGOptions().convertSwitchRangeToICmp(true))); + MPM.add(createInstructionCombiningPass()); + // We resume loop passes creating a second loop pipeline here. +- MPM.add(createIndVarSimplifyPass()); // Canonicalize indvars + + // Unroll small loops and perform peeling. + MPM.add(createSimpleLoopUnrollPass(OptLevel, DisableUnrollLoops, +@@ -174,16 +168,10 @@ void PassManagerBuilder::addFunctionSimplificationPasses( + // Run instcombine after redundancy elimination to exploit opportunities + // opened up by them. + MPM.add(createInstructionCombiningPass()); +- if (OptLevel > 1) { +- MPM.add(createJumpThreadingPass()); // Thread jumps +- MPM.add(createCorrelatedValuePropagationPass()); +- } +- MPM.add(createAggressiveDCEPass()); // Delete dead instructions + + MPM.add(createMemCpyOptPass()); // Remove memcpy / form memset + // TODO: Investigate if this is too expensive at O1. + if (OptLevel > 1) { +- MPM.add(createDeadStoreEliminationPass()); // Delete dead stores + MPM.add(createLICMPass(LicmMssaOptCap, LicmMssaNoAccForPromotionCap, + /*AllowSpeculation=*/true)); + } +@@ -198,8 +186,6 @@ void PassManagerBuilder::addFunctionSimplificationPasses( + /// FIXME: Should LTO cause any differences to this set of passes? + void PassManagerBuilder::addVectorPasses(legacy::PassManagerBase &PM, + bool IsFullLTO) { +- PM.add(createLoopVectorizePass(!LoopsInterleaved, !LoopVectorize)); +- + if (IsFullLTO) { + // The vectorizer may have significantly shortened a loop body; unroll + // again. Unroll small loops to hide loop backedge latency and saturate any +@@ -237,11 +223,6 @@ void PassManagerBuilder::addVectorPasses(legacy::PassManagerBase &PM, + PM.add(createBitTrackingDCEPass()); + } + +- // Optimize parallel scalar instruction chains into SIMD instructions. +- if (SLPVectorize) { +- PM.add(createSLPVectorizerPass()); +- } +- + if (!IsFullLTO) { + PM.add(createInstructionCombiningPass()); + +diff --git a/llvm/lib/Transforms/Scalar/ADCE.cpp b/llvm/lib/Transforms/Scalar/ADCE.cpp +index ec07c5341d18..b96feb905659 100644 +--- a/llvm/lib/Transforms/Scalar/ADCE.cpp ++++ b/llvm/lib/Transforms/Scalar/ADCE.cpp +@@ -733,50 +733,3 @@ PreservedAnalyses ADCEPass::run(Function &F, FunctionAnalysisManager &FAM) { + + return PA; + } +- +-namespace { +- +-struct ADCELegacyPass : public FunctionPass { +- static char ID; // Pass identification, replacement for typeid +- +- ADCELegacyPass() : FunctionPass(ID) { +- initializeADCELegacyPassPass(*PassRegistry::getPassRegistry()); +- } +- +- bool runOnFunction(Function &F) override { +- if (skipFunction(F)) +- return false; +- +- // ADCE does not need DominatorTree, but require DominatorTree here +- // to update analysis if it is already available. +- auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>(); +- auto *DT = DTWP ? &DTWP->getDomTree() : nullptr; +- auto &PDT = getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree(); +- ADCEChanged Changed = +- AggressiveDeadCodeElimination(F, DT, PDT).performDeadCodeElimination(); +- return Changed.ChangedAnything; +- } +- +- void getAnalysisUsage(AnalysisUsage &AU) const override { +- AU.addRequired<PostDominatorTreeWrapperPass>(); +- if (!RemoveControlFlowFlag) +- AU.setPreservesCFG(); +- else { +- AU.addPreserved<DominatorTreeWrapperPass>(); +- AU.addPreserved<PostDominatorTreeWrapperPass>(); +- } +- AU.addPreserved<GlobalsAAWrapperPass>(); +- } +-}; +- +-} // end anonymous namespace +- +-char ADCELegacyPass::ID = 0; +- +-INITIALIZE_PASS_BEGIN(ADCELegacyPass, "adce", +- "Aggressive Dead Code Elimination", false, false) +-INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass) +-INITIALIZE_PASS_END(ADCELegacyPass, "adce", "Aggressive Dead Code Elimination", +- false, false) +- +-FunctionPass *llvm::createAggressiveDCEPass() { return new ADCELegacyPass(); } +diff --git a/llvm/lib/Transforms/Scalar/CorrelatedValuePropagation.cpp b/llvm/lib/Transforms/Scalar/CorrelatedValuePropagation.cpp +index a6293ee67123..1323d724a97c 100644 +--- a/llvm/lib/Transforms/Scalar/CorrelatedValuePropagation.cpp ++++ b/llvm/lib/Transforms/Scalar/CorrelatedValuePropagation.cpp +@@ -97,43 +97,6 @@ STATISTIC(NumMinMax, "Number of llvm.[us]{min,max} intrinsics removed"); + STATISTIC(NumUDivURemsNarrowedExpanded, + "Number of bound udiv's/urem's expanded"); + +-namespace { +- +- class CorrelatedValuePropagation : public FunctionPass { +- public: +- static char ID; +- +- CorrelatedValuePropagation(): FunctionPass(ID) { +- initializeCorrelatedValuePropagationPass(*PassRegistry::getPassRegistry()); +- } +- +- bool runOnFunction(Function &F) override; +- +- void getAnalysisUsage(AnalysisUsage &AU) const override { +- AU.addRequired<DominatorTreeWrapperPass>(); +- AU.addRequired<LazyValueInfoWrapperPass>(); +- AU.addPreserved<GlobalsAAWrapperPass>(); +- AU.addPreserved<DominatorTreeWrapperPass>(); +- AU.addPreserved<LazyValueInfoWrapperPass>(); +- } +- }; +- +-} // end anonymous namespace +- +-char CorrelatedValuePropagation::ID = 0; +- +-INITIALIZE_PASS_BEGIN(CorrelatedValuePropagation, "correlated-propagation", +- "Value Propagation", false, false) +-INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(LazyValueInfoWrapperPass) +-INITIALIZE_PASS_END(CorrelatedValuePropagation, "correlated-propagation", +- "Value Propagation", false, false) +- +-// Public interface to the Value Propagation pass +-Pass *llvm::createCorrelatedValuePropagationPass() { +- return new CorrelatedValuePropagation(); +-} +- + static bool processSelect(SelectInst *S, LazyValueInfo *LVI) { + if (S->getType()->isVectorTy()) return false; + if (isa<Constant>(S->getCondition())) return false; +@@ -1221,16 +1184,6 @@ static bool runImpl(Function &F, LazyValueInfo *LVI, DominatorTree *DT, + return FnChanged; + } + +-bool CorrelatedValuePropagation::runOnFunction(Function &F) { +- if (skipFunction(F)) +- return false; +- +- LazyValueInfo *LVI = &getAnalysis<LazyValueInfoWrapperPass>().getLVI(); +- DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); +- +- return runImpl(F, LVI, DT, getBestSimplifyQuery(*this, F)); +-} +- + PreservedAnalyses + CorrelatedValuePropagationPass::run(Function &F, FunctionAnalysisManager &AM) { + LazyValueInfo *LVI = &AM.getResult<LazyValueAnalysis>(F); +diff --git a/llvm/lib/Transforms/Scalar/DFAJumpThreading.cpp b/llvm/lib/Transforms/Scalar/DFAJumpThreading.cpp +index 658d0fcb53fa..ede98fc69e64 100644 +--- a/llvm/lib/Transforms/Scalar/DFAJumpThreading.cpp ++++ b/llvm/lib/Transforms/Scalar/DFAJumpThreading.cpp +@@ -168,51 +168,8 @@ private: + OptimizationRemarkEmitter *ORE; + }; + +-class DFAJumpThreadingLegacyPass : public FunctionPass { +-public: +- static char ID; // Pass identification +- DFAJumpThreadingLegacyPass() : FunctionPass(ID) {} +- +- void getAnalysisUsage(AnalysisUsage &AU) const override { +- AU.addRequired<AssumptionCacheTracker>(); +- AU.addRequired<DominatorTreeWrapperPass>(); +- AU.addPreserved<DominatorTreeWrapperPass>(); +- AU.addRequired<TargetTransformInfoWrapperPass>(); +- AU.addRequired<OptimizationRemarkEmitterWrapperPass>(); +- } +- +- bool runOnFunction(Function &F) override { +- if (skipFunction(F)) +- return false; +- +- AssumptionCache *AC = +- &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); +- DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); +- TargetTransformInfo *TTI = +- &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F); +- OptimizationRemarkEmitter *ORE = +- &getAnalysis<OptimizationRemarkEmitterWrapperPass>().getORE(); +- +- return DFAJumpThreading(AC, DT, TTI, ORE).run(F); +- } +-}; + } // end anonymous namespace + +-char DFAJumpThreadingLegacyPass::ID = 0; +-INITIALIZE_PASS_BEGIN(DFAJumpThreadingLegacyPass, "dfa-jump-threading", +- "DFA Jump Threading", false, false) +-INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker) +-INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass) +-INITIALIZE_PASS_END(DFAJumpThreadingLegacyPass, "dfa-jump-threading", +- "DFA Jump Threading", false, false) +- +-// Public interface to the DFA Jump Threading pass +-FunctionPass *llvm::createDFAJumpThreadingPass() { +- return new DFAJumpThreadingLegacyPass(); +-} +- + namespace { + + /// Create a new basic block and sink \p SIToSink into it. +diff --git a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp +index d3757341ad20..9a7ad8d49222 100644 +--- a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp ++++ b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp +@@ -2240,79 +2240,3 @@ PreservedAnalyses DSEPass::run(Function &F, FunctionAnalysisManager &AM) { + PA.preserve<LoopAnalysis>(); + return PA; + } +- +-namespace { +- +-/// A legacy pass for the legacy pass manager that wraps \c DSEPass. +-class DSELegacyPass : public FunctionPass { +-public: +- static char ID; // Pass identification, replacement for typeid +- +- DSELegacyPass() : FunctionPass(ID) { +- initializeDSELegacyPassPass(*PassRegistry::getPassRegistry()); +- } +- +- bool runOnFunction(Function &F) override { +- if (skipFunction(F)) +- return false; +- +- AliasAnalysis &AA = getAnalysis<AAResultsWrapperPass>().getAAResults(); +- DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree(); +- const TargetLibraryInfo &TLI = +- getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F); +- MemorySSA &MSSA = getAnalysis<MemorySSAWrapperPass>().getMSSA(); +- PostDominatorTree &PDT = +- getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree(); +- AssumptionCache &AC = +- getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); +- LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); +- +- bool Changed = eliminateDeadStores(F, AA, MSSA, DT, PDT, AC, TLI, LI); +- +-#ifdef LLVM_ENABLE_STATS +- if (AreStatisticsEnabled()) +- for (auto &I : instructions(F)) +- NumRemainingStores += isa<StoreInst>(&I); +-#endif +- +- return Changed; +- } +- +- void getAnalysisUsage(AnalysisUsage &AU) const override { +- AU.setPreservesCFG(); +- AU.addRequired<AAResultsWrapperPass>(); +- AU.addRequired<TargetLibraryInfoWrapperPass>(); +- AU.addPreserved<GlobalsAAWrapperPass>(); +- AU.addRequired<DominatorTreeWrapperPass>(); +- AU.addPreserved<DominatorTreeWrapperPass>(); +- AU.addRequired<PostDominatorTreeWrapperPass>(); +- AU.addRequired<MemorySSAWrapperPass>(); +- AU.addPreserved<PostDominatorTreeWrapperPass>(); +- AU.addPreserved<MemorySSAWrapperPass>(); +- AU.addRequired<LoopInfoWrapperPass>(); +- AU.addPreserved<LoopInfoWrapperPass>(); +- AU.addRequired<AssumptionCacheTracker>(); +- } +-}; +- +-} // end anonymous namespace +- +-char DSELegacyPass::ID = 0; +- +-INITIALIZE_PASS_BEGIN(DSELegacyPass, "dse", "Dead Store Elimination", false, +- false) +-INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(GlobalsAAWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(MemorySSAWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(MemoryDependenceWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker) +-INITIALIZE_PASS_END(DSELegacyPass, "dse", "Dead Store Elimination", false, +- false) +- +-FunctionPass *llvm::createDeadStoreEliminationPass() { +- return new DSELegacyPass(); +-} +diff --git a/llvm/lib/Transforms/Scalar/IndVarSimplify.cpp b/llvm/lib/Transforms/Scalar/IndVarSimplify.cpp +index 0c21ae26297d..64f5dcb94312 100644 +--- a/llvm/lib/Transforms/Scalar/IndVarSimplify.cpp ++++ b/llvm/lib/Transforms/Scalar/IndVarSimplify.cpp +@@ -2223,54 +2223,3 @@ PreservedAnalyses IndVarSimplifyPass::run(Loop &L, LoopAnalysisManager &AM, + PA.preserve<MemorySSAAnalysis>(); + return PA; + } +- +-namespace { +- +-struct IndVarSimplifyLegacyPass : public LoopPass { +- static char ID; // Pass identification, replacement for typeid +- +- IndVarSimplifyLegacyPass() : LoopPass(ID) { +- initializeIndVarSimplifyLegacyPassPass(*PassRegistry::getPassRegistry()); +- } +- +- bool runOnLoop(Loop *L, LPPassManager &LPM) override { +- if (skipLoop(L)) +- return false; +- +- auto *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); +- auto *SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE(); +- auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); +- auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>(); +- auto *TLI = TLIP ? &TLIP->getTLI(*L->getHeader()->getParent()) : nullptr; +- auto *TTIP = getAnalysisIfAvailable<TargetTransformInfoWrapperPass>(); +- auto *TTI = TTIP ? &TTIP->getTTI(*L->getHeader()->getParent()) : nullptr; +- const DataLayout &DL = L->getHeader()->getModule()->getDataLayout(); +- auto *MSSAAnalysis = getAnalysisIfAvailable<MemorySSAWrapperPass>(); +- MemorySSA *MSSA = nullptr; +- if (MSSAAnalysis) +- MSSA = &MSSAAnalysis->getMSSA(); +- +- IndVarSimplify IVS(LI, SE, DT, DL, TLI, TTI, MSSA, AllowIVWidening); +- return IVS.run(L); +- } +- +- void getAnalysisUsage(AnalysisUsage &AU) const override { +- AU.setPreservesCFG(); +- AU.addPreserved<MemorySSAWrapperPass>(); +- getLoopAnalysisUsage(AU); +- } +-}; +- +-} // end anonymous namespace +- +-char IndVarSimplifyLegacyPass::ID = 0; +- +-INITIALIZE_PASS_BEGIN(IndVarSimplifyLegacyPass, "indvars", +- "Induction Variable Simplification", false, false) +-INITIALIZE_PASS_DEPENDENCY(LoopPass) +-INITIALIZE_PASS_END(IndVarSimplifyLegacyPass, "indvars", +- "Induction Variable Simplification", false, false) +- +-Pass *llvm::createIndVarSimplifyPass() { +- return new IndVarSimplifyLegacyPass(); +-} +diff --git a/llvm/lib/Transforms/Scalar/JumpThreading.cpp b/llvm/lib/Transforms/Scalar/JumpThreading.cpp +index eac41f05ca14..35daa8f3874d 100644 +--- a/llvm/lib/Transforms/Scalar/JumpThreading.cpp ++++ b/llvm/lib/Transforms/Scalar/JumpThreading.cpp +@@ -115,64 +115,6 @@ static cl::opt<bool> ThreadAcrossLoopHeaders( + cl::desc("Allow JumpThreading to thread across loop headers, for testing"), + cl::init(false), cl::Hidden); + +- +-namespace { +- +- /// This pass performs 'jump threading', which looks at blocks that have +- /// multiple predecessors and multiple successors. If one or more of the +- /// predecessors of the block can be proven to always jump to one of the +- /// successors, we forward the edge from the predecessor to the successor by +- /// duplicating the contents of this block. +- /// +- /// An example of when this can occur is code like this: +- /// +- /// if () { ... +- /// X = 4; +- /// } +- /// if (X < 3) { +- /// +- /// In this case, the unconditional branch at the end of the first if can be +- /// revectored to the false side of the second if. +- class JumpThreading : public FunctionPass { +- public: +- static char ID; // Pass identification +- +- JumpThreading(int T = -1) : FunctionPass(ID) { +- initializeJumpThreadingPass(*PassRegistry::getPassRegistry()); +- } +- +- bool runOnFunction(Function &F) override; +- +- void getAnalysisUsage(AnalysisUsage &AU) const override { +- AU.addRequired<DominatorTreeWrapperPass>(); +- AU.addPreserved<DominatorTreeWrapperPass>(); +- AU.addRequired<AAResultsWrapperPass>(); +- AU.addRequired<LazyValueInfoWrapperPass>(); +- AU.addPreserved<LazyValueInfoWrapperPass>(); +- AU.addPreserved<GlobalsAAWrapperPass>(); +- AU.addRequired<TargetLibraryInfoWrapperPass>(); +- AU.addRequired<TargetTransformInfoWrapperPass>(); +- } +- }; +- +-} // end anonymous namespace +- +-char JumpThreading::ID = 0; +- +-INITIALIZE_PASS_BEGIN(JumpThreading, "jump-threading", +- "Jump Threading", false, false) +-INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(LazyValueInfoWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass) +-INITIALIZE_PASS_END(JumpThreading, "jump-threading", +- "Jump Threading", false, false) +- +-// Public interface to the Jump Threading pass +-FunctionPass *llvm::createJumpThreadingPass(int Threshold) { +- return new JumpThreading(Threshold); +-} +- + JumpThreadingPass::JumpThreadingPass(int T) { + DefaultBBDupThreshold = (T == -1) ? BBDuplicateThreshold : unsigned(T); + } +@@ -303,35 +245,6 @@ static void updatePredecessorProfileMetadata(PHINode *PN, BasicBlock *BB) { + } + } + +-/// runOnFunction - Toplevel algorithm. +-bool JumpThreading::runOnFunction(Function &F) { +- if (skipFunction(F)) +- return false; +- auto TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F); +- // Jump Threading has no sense for the targets with divergent CF +- if (TTI->hasBranchDivergence()) +- return false; +- auto TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F); +- auto DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); +- auto LVI = &getAnalysis<LazyValueInfoWrapperPass>().getLVI(); +- auto AA = &getAnalysis<AAResultsWrapperPass>().getAAResults(); +- +- LoopInfo LI{*DT}; +- auto BPI = std::make_unique<BranchProbabilityInfo>(F, LI, TLI); +- auto BFI = std::make_unique<BlockFrequencyInfo>(F, *BPI, LI); +- +- JumpThreadingPass Impl; +- bool Changed = Impl.runImpl(F, nullptr, TLI, TTI, LVI, AA, +- std::make_unique<DomTreeUpdater>( +- DT, DomTreeUpdater::UpdateStrategy::Lazy), +- BFI.get(), BPI.get()); +- if (PrintLVIAfterJumpThreading) { +- dbgs() << "LVI for function '" << F.getName() << "':\n"; +- LVI->printLVI(F, Impl.getDomTreeUpdater()->getDomTree(), dbgs()); +- } +- return Changed; +-} +- + PreservedAnalyses JumpThreadingPass::run(Function &F, + FunctionAnalysisManager &AM) { + auto &TTI = AM.getResult<TargetIRAnalysis>(F); +diff --git a/llvm/lib/Transforms/Scalar/Scalar.cpp b/llvm/lib/Transforms/Scalar/Scalar.cpp +index 9a3d243859be..26a1e22f3317 100644 +--- a/llvm/lib/Transforms/Scalar/Scalar.cpp ++++ b/llvm/lib/Transforms/Scalar/Scalar.cpp +@@ -29,15 +29,12 @@ using namespace llvm; + /// initializeScalarOptsPasses - Initialize all passes linked into the + /// ScalarOpts library. + void llvm::initializeScalarOpts(PassRegistry &Registry) { +- initializeADCELegacyPassPass(Registry); + initializeBDCELegacyPassPass(Registry); + initializeAlignmentFromAssumptionsPass(Registry); + initializeCallSiteSplittingLegacyPassPass(Registry); + initializeConstantHoistingLegacyPassPass(Registry); +- initializeCorrelatedValuePropagationPass(Registry); + initializeDCELegacyPassPass(Registry); + initializeScalarizerLegacyPassPass(Registry); +- initializeDSELegacyPassPass(Registry); + initializeGuardWideningLegacyPassPass(Registry); + initializeLoopGuardWideningLegacyPassPass(Registry); + initializeGVNLegacyPassPass(Registry); +@@ -49,11 +46,8 @@ void llvm::initializeScalarOpts(PassRegistry &Registry) { + initializeGVNSinkLegacyPassPass(Registry); + initializeFlattenCFGLegacyPassPass(Registry); + initializeIRCELegacyPassPass(Registry); +- initializeIndVarSimplifyLegacyPassPass(Registry); + initializeInferAddressSpacesPass(Registry); + initializeInstSimplifyLegacyPassPass(Registry); +- initializeJumpThreadingPass(Registry); +- initializeDFAJumpThreadingLegacyPassPass(Registry); + initializeLegacyLICMPassPass(Registry); + initializeLegacyLoopSinkPassPass(Registry); + initializeLoopDataPrefetchLegacyPassPass(Registry); +diff --git a/llvm/lib/Transforms/Utils/LibCallsShrinkWrap.cpp b/llvm/lib/Transforms/Utils/LibCallsShrinkWrap.cpp +index 5dd469c7af4b..ff2d5a017590 100644 +--- a/llvm/lib/Transforms/Utils/LibCallsShrinkWrap.cpp ++++ b/llvm/lib/Transforms/Utils/LibCallsShrinkWrap.cpp +@@ -50,27 +50,6 @@ using namespace llvm; + STATISTIC(NumWrappedOneCond, "Number of One-Condition Wrappers Inserted"); + STATISTIC(NumWrappedTwoCond, "Number of Two-Condition Wrappers Inserted"); + +-namespace { +-class LibCallsShrinkWrapLegacyPass : public FunctionPass { +-public: +- static char ID; // Pass identification, replacement for typeid +- explicit LibCallsShrinkWrapLegacyPass() : FunctionPass(ID) { +- initializeLibCallsShrinkWrapLegacyPassPass( +- *PassRegistry::getPassRegistry()); +- } +- void getAnalysisUsage(AnalysisUsage &AU) const override; +- bool runOnFunction(Function &F) override; +-}; +-} +- +-char LibCallsShrinkWrapLegacyPass::ID = 0; +-INITIALIZE_PASS_BEGIN(LibCallsShrinkWrapLegacyPass, "libcalls-shrinkwrap", +- "Conditionally eliminate dead library calls", false, +- false) +-INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass) +-INITIALIZE_PASS_END(LibCallsShrinkWrapLegacyPass, "libcalls-shrinkwrap", +- "Conditionally eliminate dead library calls", false, false) +- + namespace { + class LibCallsShrinkWrap : public InstVisitor<LibCallsShrinkWrap> { + public: +@@ -515,12 +494,6 @@ bool LibCallsShrinkWrap::perform(CallInst *CI) { + return performCallErrors(CI, Func); + } + +-void LibCallsShrinkWrapLegacyPass::getAnalysisUsage(AnalysisUsage &AU) const { +- AU.addPreserved<DominatorTreeWrapperPass>(); +- AU.addPreserved<GlobalsAAWrapperPass>(); +- AU.addRequired<TargetLibraryInfoWrapperPass>(); +-} +- + static bool runImpl(Function &F, const TargetLibraryInfo &TLI, + DominatorTree *DT) { + if (F.hasFnAttribute(Attribute::OptimizeForSize)) +@@ -534,21 +507,6 @@ static bool runImpl(Function &F, const TargetLibraryInfo &TLI, + return Changed; + } + +-bool LibCallsShrinkWrapLegacyPass::runOnFunction(Function &F) { +- auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F); +- auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>(); +- auto *DT = DTWP ? &DTWP->getDomTree() : nullptr; +- return runImpl(F, TLI, DT); +-} +- +-namespace llvm { +-char &LibCallsShrinkWrapPassID = LibCallsShrinkWrapLegacyPass::ID; +- +-// Public interface to LibCallsShrinkWrap pass. +-FunctionPass *createLibCallsShrinkWrapPass() { +- return new LibCallsShrinkWrapLegacyPass(); +-} +- + PreservedAnalyses LibCallsShrinkWrapPass::run(Function &F, + FunctionAnalysisManager &FAM) { + auto &TLI = FAM.getResult<TargetLibraryAnalysis>(F); +@@ -559,4 +517,3 @@ PreservedAnalyses LibCallsShrinkWrapPass::run(Function &F, + PA.preserve<DominatorTreeAnalysis>(); + return PA; + } +-} +diff --git a/llvm/lib/Transforms/Utils/Utils.cpp b/llvm/lib/Transforms/Utils/Utils.cpp +index d86f20c7bb6f..59d1b8e42dc1 100644 +--- a/llvm/lib/Transforms/Utils/Utils.cpp ++++ b/llvm/lib/Transforms/Utils/Utils.cpp +@@ -30,7 +30,6 @@ void llvm::initializeTransformUtils(PassRegistry &Registry) { + initializeCanonicalizeFreezeInLoopsPass(Registry); + initializeInstNamerPass(Registry); + initializeLCSSAWrapperPassPass(Registry); +- initializeLibCallsShrinkWrapLegacyPassPass(Registry); + initializeLoopSimplifyPass(Registry); + initializeLowerGlobalDtorsLegacyPassPass(Registry); + initializeLowerInvokeLegacyPassPass(Registry); +diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp +index 9083b7b3c712..df6f3b33fac0 100644 +--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp ++++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp +@@ -2250,73 +2250,6 @@ static void collectSupportedLoops(Loop &L, LoopInfo *LI, + collectSupportedLoops(*InnerL, LI, ORE, V); + } + +-namespace { +- +-/// The LoopVectorize Pass. +-struct LoopVectorize : public FunctionPass { +- /// Pass identification, replacement for typeid +- static char ID; +- +- LoopVectorizePass Impl; +- +- explicit LoopVectorize(bool InterleaveOnlyWhenForced = false, +- bool VectorizeOnlyWhenForced = false) +- : FunctionPass(ID), +- Impl({InterleaveOnlyWhenForced, VectorizeOnlyWhenForced}) { +- initializeLoopVectorizePass(*PassRegistry::getPassRegistry()); +- } +- +- bool runOnFunction(Function &F) override { +- if (skipFunction(F)) +- return false; +- +- auto *SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE(); +- auto *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); +- auto *TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F); +- auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); +- auto *BFI = &getAnalysis<BlockFrequencyInfoWrapperPass>().getBFI(); +- auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>(); +- auto *TLI = TLIP ? &TLIP->getTLI(F) : nullptr; +- auto *AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); +- auto &LAIs = getAnalysis<LoopAccessLegacyAnalysis>().getLAIs(); +- auto *DB = &getAnalysis<DemandedBitsWrapperPass>().getDemandedBits(); +- auto *ORE = &getAnalysis<OptimizationRemarkEmitterWrapperPass>().getORE(); +- auto *PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI(); +- +- return Impl +- .runImpl(F, *SE, *LI, *TTI, *DT, BFI, TLI, *DB, *AC, LAIs, *ORE, PSI) +- .MadeAnyChange; +- } +- +- void getAnalysisUsage(AnalysisUsage &AU) const override { +- AU.addRequired<AssumptionCacheTracker>(); +- AU.addRequired<BlockFrequencyInfoWrapperPass>(); +- AU.addRequired<DominatorTreeWrapperPass>(); +- AU.addRequired<LoopInfoWrapperPass>(); +- AU.addRequired<ScalarEvolutionWrapperPass>(); +- AU.addRequired<TargetTransformInfoWrapperPass>(); +- AU.addRequired<LoopAccessLegacyAnalysis>(); +- AU.addRequired<DemandedBitsWrapperPass>(); +- AU.addRequired<OptimizationRemarkEmitterWrapperPass>(); +- AU.addRequired<InjectTLIMappingsLegacy>(); +- +- // We currently do not preserve loopinfo/dominator analyses with outer loop +- // vectorization. Until this is addressed, mark these analyses as preserved +- // only for non-VPlan-native path. +- // TODO: Preserve Loop and Dominator analyses for VPlan-native path. +- if (!EnableVPlanNativePath) { +- AU.addPreserved<LoopInfoWrapperPass>(); +- AU.addPreserved<DominatorTreeWrapperPass>(); +- } +- +- AU.addPreserved<BasicAAWrapperPass>(); +- AU.addPreserved<GlobalsAAWrapperPass>(); +- AU.addRequired<ProfileSummaryInfoWrapperPass>(); +- } +-}; +- +-} // end anonymous namespace +- + //===----------------------------------------------------------------------===// + // Implementation of LoopVectorizationLegality, InnerLoopVectorizer and + // LoopVectorizationCostModel and LoopVectorizationPlanner. +@@ -7463,37 +7396,6 @@ LoopVectorizationCostModel::getInstructionCost(Instruction *I, ElementCount VF, + } // end of switch. + } + +-char LoopVectorize::ID = 0; +- +-static const char lv_name[] = "Loop Vectorization"; +- +-INITIALIZE_PASS_BEGIN(LoopVectorize, LV_NAME, lv_name, false, false) +-INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(BasicAAWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(GlobalsAAWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker) +-INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(LoopAccessLegacyAnalysis) +-INITIALIZE_PASS_DEPENDENCY(DemandedBitsWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(ProfileSummaryInfoWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(InjectTLIMappingsLegacy) +-INITIALIZE_PASS_END(LoopVectorize, LV_NAME, lv_name, false, false) +- +-namespace llvm { +- +-Pass *createLoopVectorizePass() { return new LoopVectorize(); } +- +-Pass *createLoopVectorizePass(bool InterleaveOnlyWhenForced, +- bool VectorizeOnlyWhenForced) { +- return new LoopVectorize(InterleaveOnlyWhenForced, VectorizeOnlyWhenForced); +-} +- +-} // end namespace llvm +- + void LoopVectorizationCostModel::collectValuesToIgnore() { + // Ignore ephemeral values. + CodeMetrics::collectEphemeralValues(TheLoop, AC, ValuesToIgnore); +diff --git a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp +index bbaccb5cd282..91d99e5008cc 100644 +--- a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp ++++ b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp +@@ -11645,60 +11645,6 @@ void BoUpSLP::computeMinimumValueSizes() { + MinBWs[Scalar] = std::make_pair(MaxBitWidth, !IsKnownPositive); + } + +-namespace { +- +-/// The SLPVectorizer Pass. +-struct SLPVectorizer : public FunctionPass { +- SLPVectorizerPass Impl; +- +- /// Pass identification, replacement for typeid +- static char ID; +- +- explicit SLPVectorizer() : FunctionPass(ID) { +- initializeSLPVectorizerPass(*PassRegistry::getPassRegistry()); +- } +- +- bool doInitialization(Module &M) override { return false; } +- +- bool runOnFunction(Function &F) override { +- if (skipFunction(F)) +- return false; +- +- auto *SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE(); +- auto *TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F); +- auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>(); +- auto *TLI = TLIP ? &TLIP->getTLI(F) : nullptr; +- auto *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults(); +- auto *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); +- auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); +- auto *AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); +- auto *DB = &getAnalysis<DemandedBitsWrapperPass>().getDemandedBits(); +- auto *ORE = &getAnalysis<OptimizationRemarkEmitterWrapperPass>().getORE(); +- +- return Impl.runImpl(F, SE, TTI, TLI, AA, LI, DT, AC, DB, ORE); +- } +- +- void getAnalysisUsage(AnalysisUsage &AU) const override { +- FunctionPass::getAnalysisUsage(AU); +- AU.addRequired<AssumptionCacheTracker>(); +- AU.addRequired<ScalarEvolutionWrapperPass>(); +- AU.addRequired<AAResultsWrapperPass>(); +- AU.addRequired<TargetTransformInfoWrapperPass>(); +- AU.addRequired<LoopInfoWrapperPass>(); +- AU.addRequired<DominatorTreeWrapperPass>(); +- AU.addRequired<DemandedBitsWrapperPass>(); +- AU.addRequired<OptimizationRemarkEmitterWrapperPass>(); +- AU.addRequired<InjectTLIMappingsLegacy>(); +- AU.addPreserved<LoopInfoWrapperPass>(); +- AU.addPreserved<DominatorTreeWrapperPass>(); +- AU.addPreserved<AAResultsWrapperPass>(); +- AU.addPreserved<GlobalsAAWrapperPass>(); +- AU.setPreservesCFG(); +- } +-}; +- +-} // end anonymous namespace +- + PreservedAnalyses SLPVectorizerPass::run(Function &F, FunctionAnalysisManager &AM) { + auto *SE = &AM.getResult<ScalarEvolutionAnalysis>(F); + auto *TTI = &AM.getResult<TargetIRAnalysis>(F); +@@ -14600,20 +14546,3 @@ bool SLPVectorizerPass::vectorizeStoreChains(BoUpSLP &R) { + } + return Changed; + } +- +-char SLPVectorizer::ID = 0; +- +-static const char lv_name[] = "SLP Vectorizer"; +- +-INITIALIZE_PASS_BEGIN(SLPVectorizer, SV_NAME, lv_name, false, false) +-INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker) +-INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(LoopSimplify) +-INITIALIZE_PASS_DEPENDENCY(DemandedBitsWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass) +-INITIALIZE_PASS_DEPENDENCY(InjectTLIMappingsLegacy) +-INITIALIZE_PASS_END(SLPVectorizer, SV_NAME, lv_name, false, false) +- +-Pass *llvm::createSLPVectorizerPass() { return new SLPVectorizer(); } +diff --git a/llvm/lib/Transforms/Vectorize/Vectorize.cpp b/llvm/lib/Transforms/Vectorize/Vectorize.cpp +index 6a335e9120bb..cea47334d507 100644 +--- a/llvm/lib/Transforms/Vectorize/Vectorize.cpp ++++ b/llvm/lib/Transforms/Vectorize/Vectorize.cpp +@@ -22,8 +22,6 @@ using namespace llvm; + + /// Initialize all passes linked into the Vectorization library. + void llvm::initializeVectorization(PassRegistry &Registry) { +- initializeLoopVectorizePass(Registry); +- initializeSLPVectorizerPass(Registry); + initializeLoadStoreVectorizerLegacyPassPass(Registry); + } + +diff --git a/llvm/test/CodeGen/Hexagon/hexagon_vector_loop_carried_reuse.ll b/llvm/test/CodeGen/Hexagon/hexagon_vector_loop_carried_reuse.ll +index d7b18ae078ff..0771fda02cfb 100644 +--- a/llvm/test/CodeGen/Hexagon/hexagon_vector_loop_carried_reuse.ll ++++ b/llvm/test/CodeGen/Hexagon/hexagon_vector_loop_carried_reuse.ll +@@ -1,4 +1,4 @@ +-; RUN: opt < %s -hexagon-vlcr -adce -S | FileCheck %s ++; RUN: opt < %s -hexagon-vlcr | opt -passes=adce -S | FileCheck %s + + ; CHECK: %.hexagon.vlcr = tail call <32 x i32> @llvm.hexagon.V6.vmaxub.128B + ; ModuleID = 'hexagon_vector_loop_carried_reuse.c' +diff --git a/llvm/test/CodeGen/Hexagon/hexagon_vector_loop_carried_reuse_commutative.ll b/llvm/test/CodeGen/Hexagon/hexagon_vector_loop_carried_reuse_commutative.ll +index b280830d403a..25afb9f1a137 100644 +--- a/llvm/test/CodeGen/Hexagon/hexagon_vector_loop_carried_reuse_commutative.ll ++++ b/llvm/test/CodeGen/Hexagon/hexagon_vector_loop_carried_reuse_commutative.ll +@@ -1,4 +1,4 @@ +-; RUN: opt -march=hexagon < %s -hexagon-vlcr -adce -S | FileCheck %s ++; RUN: opt < %s -march=hexagon -hexagon-vlcr | opt -passes=adce -S | FileCheck %s + + ; CHECK: %v32.hexagon.vlcr = tail call <32 x i32> @llvm.hexagon.V6.vmaxub.128B + +diff --git a/llvm/test/CodeGen/Hexagon/hexagon_vector_loop_carried_reuse_constant.ll b/llvm/test/CodeGen/Hexagon/hexagon_vector_loop_carried_reuse_constant.ll +index c64404f97775..53973423732c 100644 +--- a/llvm/test/CodeGen/Hexagon/hexagon_vector_loop_carried_reuse_constant.ll ++++ b/llvm/test/CodeGen/Hexagon/hexagon_vector_loop_carried_reuse_constant.ll +@@ -1,4 +1,4 @@ +-; RUN: opt < %s -hexagon-vlcr -adce -S | FileCheck %s ++; RUN: opt < %s -hexagon-vlcr | opt -passes=adce -S | FileCheck %s + + ; CHECK-NOT: %.hexagon.vlcr + ; ModuleID = 'hexagon_vector_loop_carried_reuse.c' +diff --git a/llvm/test/Transforms/LoopStrengthReduce/scev-after-loopinstsimplify.ll b/llvm/test/Transforms/LoopStrengthReduce/scev-after-loopinstsimplify.ll +index 6c91f643e7a9..6e059b5d8fa5 100644 +--- a/llvm/test/Transforms/LoopStrengthReduce/scev-after-loopinstsimplify.ll ++++ b/llvm/test/Transforms/LoopStrengthReduce/scev-after-loopinstsimplify.ll +@@ -1,4 +1,4 @@ +-; RUN: opt %s -indvars -loop-instsimplify -loop-reduce ++; RUN: opt %s -passes=indvars,loop-instsimplify,loop-reduce + ; We are only checking that there is no crash! + + ; https://bugs.llvm.org/show_bug.cgi?id=37936 +diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/sleef-calls-aarch64.ll b/llvm/test/Transforms/LoopVectorize/AArch64/sleef-calls-aarch64.ll +index ed9e1b4b6fb2..be4309996fbb 100644 +--- a/llvm/test/Transforms/LoopVectorize/AArch64/sleef-calls-aarch64.ll ++++ b/llvm/test/Transforms/LoopVectorize/AArch64/sleef-calls-aarch64.ll +@@ -1,5 +1,5 @@ + ; Do NOT use -O3. It will lower exp2 to ldexp, and the test will fail. +-; RUN: opt -vector-library=sleefgnuabi -replace-with-veclib -loop-unroll -loop-vectorize -S < %s | FileCheck %s ++; RUN: opt -vector-library=sleefgnuabi -replace-with-veclib < %s | opt -vector-library=sleefgnuabi -passes=inject-tli-mappings,loop-unroll,loop-vectorize -S | FileCheck %s + + target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" + target triple = "aarch64-unknown-linux-gnu" +diff --git a/polly/lib/Transform/Canonicalization.cpp b/polly/lib/Transform/Canonicalization.cpp +index 8cb235f94601..901299d8f02c 100644 +--- a/polly/lib/Transform/Canonicalization.cpp ++++ b/polly/lib/Transform/Canonicalization.cpp +@@ -56,7 +56,6 @@ void polly::registerCanonicalicationPasses(llvm::legacy::PassManagerBase &PM) { + PM.add(createBarrierNoopPass()); + } + PM.add(llvm::createInstructionCombiningPass()); +- PM.add(llvm::createIndVarSimplifyPass()); + } + + /// Adapted from llvm::PassBuilder::buildInlinerPipeline +-- +2.39.2 + @@ -16,7 +16,7 @@ pkgbase=llvm-minimal-git pkgname=('llvm-minimal-git' 'llvm-libs-minimal-git' 'spirv-llvm-translator-minimal-git') -pkgver=17.0.0_r453589.44c6b905f852 +pkgver=17.0.0_r454285.890e6c871d31 pkgrel=1 arch=('x86_64') url="https://llvm.org/" @@ -27,9 +27,12 @@ source=("llvm-project::git+https://github.com/llvm/llvm-project.git" 'local://llvm-config.h' "git+https://github.com/KhronosGroup/SPIRV-LLVM-Translator.git" '0001-IPSCCP-Remove-legacy-pass.patch' - '0001-OCaml-Remove-all-PassManager-related-functions.patch' - '0001-llvm-c-Remove-bindings-for-creating-legacy-passes.patch' - '0001-IPO-Remove-various-legacy-passes.patch' + '0002-OCaml-Remove-all-PassManager-related-functions.patch' + '0003-IPO-Remove-various-legacy-passes.patch' + '0004-llvm-c-Remove-bindings-for-creating-legacy-passes.patch' + '0005-llvm-c-Remove-PassManagerBuilder-APIs.patch' + '0006-llvm-c-Remove-pointee-support-from-LLVMGetElementTyp.patch' + '0007-Passes-Remove-some-legacy-passes.patch' ) md5sums=('SKIP' @@ -37,15 +40,21 @@ md5sums=('SKIP' 'SKIP' '245054bc67dec3eb30329bbdeed171b1' '4c5ac9bca18c8a92280b1699f2f85a16' + '179d535366bdb73c6b02850210aca69c' '286194131e1b5df0fe50ecd0f1b58eb2' - '179d535366bdb73c6b02850210aca69c') + '9e7e1648b472f83b054bf8dcbfc74175' + 'a4604d7858e1536af63f52dcbc47fbb8' + 'a09eda7d75c717aeb882fdfa67b028c3') sha512sums=('SKIP' '75e743dea28b280943b3cc7f8bbb871b57d110a7f2b9da2e6845c1c36bf170dd883fca54e463f5f49e0c3effe07fbd0db0f8cf5a12a2469d3f792af21a73fcdd' 'SKIP' '4c1e8a455163ceb1e7d3f09f5e68f731e47f2346a2f62e1fe97b19f54c16781efc0b75d52304fe9d4aa62512fd6f32b7bd6e12b319cbe72e7831f1a056ffbfd0' '92f971db948e8acd4a55cb46ef28dc394c5df07f57844b63d82fc19436e2dfe7b184599ca17d84ef4fa63f6281628d8cc734d74dcc95bc0eee8a5e7c3778f49a' + 'ab46bd37d540e9c62d99cc9e137079e077f032d0ba6531b0685d2bb91a4d832787dd12e3680c76b58d26ada7e81b3a7d8d138c303a6ffb21b593dc549aecb140' 'd3f5df839b49e4a853e88efaf2fb31c36efb15a91b4803f7e52414ab0e3121f4bfafc7d39edaad52a29106ca648428577f97f4fd12e7575cd3bbe009a1111901' - 'ab46bd37d540e9c62d99cc9e137079e077f032d0ba6531b0685d2bb91a4d832787dd12e3680c76b58d26ada7e81b3a7d8d138c303a6ffb21b593dc549aecb140') + '034b8262c2cec48fcdf1eef8f74332fc7016ecbf1627ab755f95f525c653cab0dd4199cd60b85dd09a63dc0b76bc9db9f85043c91801940294e42bc1feb1ea60' + '2f227060ab56e04bf3e74fbb785c2edf9fc55121c936ba17ac62275cacdacfb9cb84bfda0e6637e11e744e26212bbfa861fa320084502afb4b7fd247d832993b' + '6d77c23ad97c057898d97fd08af9714ff18c43026e082ad5e654b736caffb1ba814de0ebb9a7e169de9475d819df3cd0058805e4a0f020c55ce3b2272181802a') options=('staticlibs' '!lto') # explicitly disable lto to reduce number of build hangs / test failures @@ -74,13 +83,19 @@ pkgver() { prepare() { - #more reverts to keep legacy passmanager working - patch --directory="llvm-project" --reverse --strip=1 --input="${srcdir}/0001-llvm-c-Remove-bindings-for-creating-legacy-passes.patch" - patch --directory="llvm-project" --reverse --strip=1 --input="${srcdir}/0001-IPO-Remove-various-legacy-passes.patch" - patch --directory="llvm-project" --reverse --strip=1 --input="${srcdir}/0001-OCaml-Remove-all-PassManager-related-functions.patch" + patch --directory="llvm-project" --reverse --strip=1 --input="${srcdir}"/0007-Passes-Remove-some-legacy-passes.patch + patch --directory="llvm-project" --reverse --strip=1 --input="${srcdir}"/0006-llvm-c-Remove-pointee-support-from-LLVMGetElementTyp.patch + patch --directory="llvm-project" --reverse --strip=1 --input="${srcdir}"/0005-llvm-c-Remove-PassManagerBuilder-APIs.patch + patch --directory="llvm-project" --reverse --strip=1 --input="${srcdir}"/0004-llvm-c-Remove-bindings-for-creating-legacy-passes.patch + patch --directory="llvm-project" --reverse --strip=1 --input="${srcdir}"/0003-IPO-Remove-various-legacy-passes.patch + patch --directory="llvm-project" --reverse --strip=1 --input="${srcdir}"/0002-OCaml-Remove-all-PassManager-related-functions.patch # reverting commit b677d0753c0a771c6203607f5dbb56189193a14c , see https://gitlab.freedesktop.org/mesa/mesa/-/issues/8297 - patch --directory="llvm-project" --reverse --strip=1 --input="${srcdir}/0001-IPSCCP-Remove-legacy-pass.patch" - + patch --directory="llvm-project" --reverse --strip=1 --input="${srcdir}"/0001-IPSCCP-Remove-legacy-pass.patch + + + + +# patch --directory="llvm-project" --reverse --strip=1 --input="${srcdir}"/0001-IPSCCP-Remove-legacy-pass.patch } build() { |