[GVN] add GVN parameters parsing to new pass manager

[fedor.sergeev]

Summary

Introduce parsing, add a few instances of parameter use into GVN-PRE tests.

[skatkov]

llvm/lib/Passes/PassRegistry.def

195–196

Do you need this one now?

[fedor.sergeev]

removed old pass entry

llvm/lib/Passes/PassBuilder.cpp

if (ParamName == "split-footer-bb") {
           formatv("invalid MergedLoadStoreMotion pass parameter '{0}' ",
                   ParamName)
               .str(),
           inconvertibleErrorCode());
     }
   }
   return Result;
 }
+
+Expected<GVNOptions> parseGVNOptions(StringRef Params) {
+  GVNOptions Result;
+  while (!Params.empty()) {
+    StringRef ParamName;
+    std::tie(ParamName, Params) = Params.split(';');
+
+    bool Enable = !ParamName.consume_front("no-");
+    if (ParamName == "pre") {
+      Result.setPRE(Enable);
+    } else if (ParamName == "load-pre") {
+      Result.setLoadPRE(Enable);
+    } else if (ParamName == "memdep") {
+      Result.setMemDep(Enable);
+    } else {
+      return make_error<StringError>(
+          formatv("invalid GVN pass parameter '{0}' ", ParamName).str(),
+          inconvertibleErrorCode());
+    }
+  }
+  return Result;
+}
+
 } // namespace
 
 /// Tests whether a pass name starts with a valid prefix for a default pipeline
 /// alias.
 static bool startsWithDefaultPipelineAliasPrefix(StringRef Name) {
   return Name.startswith("default") || Name.startswith("thinlto") ||
          Name.startswith("lto");
 }

llvm/lib/Passes/PassRegistry.def

 FUNCTION_PASS("libcalls-shrinkwrap", LibCallsShrinkWrapPass())
 FUNCTION_PASS("inject-tli-mappings", InjectTLIMappings())
 FUNCTION_PASS("loweratomic", LowerAtomicPass())
 FUNCTION_PASS("lower-expect", LowerExpectIntrinsicPass())
 FUNCTION_PASS("lower-guard-intrinsic", LowerGuardIntrinsicPass())
 FUNCTION_PASS("lower-constant-intrinsics", LowerConstantIntrinsicsPass())
 FUNCTION_PASS("lower-matrix-intrinsics", LowerMatrixIntrinsicsPass())
 FUNCTION_PASS("lower-widenable-condition", LowerWidenableConditionPass())
 FUNCTION_PASS("guard-widening", GuardWideningPass())
-FUNCTION_PASS("gvn", GVN())
 FUNCTION_PASS("load-store-vectorizer", LoadStoreVectorizerPass())
 FUNCTION_PASS("loop-simplify", LoopSimplifyPass())
 FUNCTION_PASS("loop-sink", LoopSinkPass())
 FUNCTION_PASS("lowerinvoke", LowerInvokePass())
 FUNCTION_PASS("mem2reg", PromotePass())
 FUNCTION_PASS("memcpyopt", MemCpyOptPass())
 FUNCTION_PASS("mergeicmps", MergeICmpsPass())
 FUNCTION_PASS("nary-reassociate", NaryReassociatePass())
 FUNCTION_PASS("newgvn", NewGVNPass())
FUNCTION_PASS_WITH_PARAMS("loop-vectorize",
                              return LoopVectorizePass(Opts);
                            },
                            parseLoopVectorizeOptions)
 FUNCTION_PASS_WITH_PARAMS("mldst-motion",
                            [](MergedLoadStoreMotionOptions Opts) {
                              return MergedLoadStoreMotionPass(Opts);
                            },
                            parseMergedLoadStoreMotionOptions)
+FUNCTION_PASS_WITH_PARAMS("gvn",
+                           [](GVNOptions Opts) {
+                             return GVN(Opts);
+                           },
+                           parseGVNOptions)
 #undef FUNCTION_PASS_WITH_PARAMS
 
 #ifndef LOOP_ANALYSIS
 #define LOOP_ANALYSIS(NAME, CREATE_PASS)
 #endif
 LOOP_ANALYSIS("no-op-loop", NoOpLoopAnalysis())
 LOOP_ANALYSIS("access-info", LoopAccessAnalysis())
 LOOP_ANALYSIS("ddg", DDGAnalysis())

llvm/test/Transforms/GVN/PRE/load-pre-align.ll

 ; RUN: opt < %s -gvn -S | FileCheck %s
+; RUN: opt < %s -passes="gvn<load-pre>" -S | FileCheck %s
 
 target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:64:64-v128:128:128-a0:0:32-n32"
 
 @p = external global i32
 
 define i32 @test(i32 %n) nounwind {
 ; CHECK-LABEL: @test(
 entry:

llvm/test/Transforms/GVN/PRE/local-pre.ll

 ; RUN: opt < %s -gvn -enable-pre -S | FileCheck %s
+; RUN: opt < %s -passes="gvn<pre>" -enable-pre=false -S | FileCheck %s
 
 declare void @may_exit() nounwind
 
 declare void @may_exit_1(i32) nounwind
 
 define i32 @main(i32 %p, i32 %q) {
 
 ; CHECK-LABEL: @main(

llvm/test/Transforms/GVN/PRE/pre-basic-add.ll

 ; RUN: opt < %s -gvn -enable-pre -S | FileCheck %s
+; RUN: opt < %s -passes="gvn<pre>" -enable-pre=false -S | FileCheck %s
 
 @H = common global i32 0    ; <i32*> [#uses=2]
 @G = common global i32 0    ; <i32*> [#uses=1]
 
 define i32 @test() nounwind {
 entry:
   %0 = load i32, i32* @H, align 4    ; <i32> [#uses=2]
   %1 = call i32 (...) @foo() nounwind    ; <i32> [#uses=1]

llvm/test/Transforms/GVN/PRE/pre-gep-load.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -basicaa -gvn -enable-load-pre -S | FileCheck %s
 ; RUN: opt < %s -aa-pipeline=basic-aa -passes=gvn -enable-load-pre -S | FileCheck %s
+; RUN: opt < %s -aa-pipeline=basic-aa -passes="gvn<load-pre>" -enable-load-pre=false -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64--linux-gnu"
 
 define double @foo(i32 %stat, i32 %i, double** %p) {
 ; CHECK-LABEL: @foo(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    switch i32 [[STAT:%.*]], label [[SW_DEFAULT:%.*]] [

llvm/test/Transforms/GVN/PRE/pre-load.ll

 ; RUN: opt < %s -basicaa -gvn -enable-load-pre -S | FileCheck %s
+; RUN: opt < %s -aa-pipeline=basic-aa -passes="gvn<load-pre>" -enable-load-pre=false -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 
 define i32 @test1(i32* %p, i1 %C) {
 ; CHECK-LABEL: @test1(
 block1:
   br i1 %C, label %block2, label %block3
 
 block2:

llvm/test/Transforms/GVN/PRE/pre-single-pred.ll

 ; RUN: opt < %s -gvn -enable-load-pre -S | FileCheck %s
+; RUN: opt < %s -passes="gvn<load-pre>" -enable-load-pre=false -S | FileCheck %s
 ; This testcase assumed we'll PRE the load into %for.cond, but we don't actually
 ; verify that doing so is safe.  If there didn't _happen_ to be a load in
 ; %for.end, we would actually be lengthening the execution on some paths, and
 ; we were never actually checking that case.  Now we actually do perform some
 ; conservative checking to make sure we don't make paths longer, but we don't
 ; currently get this case, which we got lucky on previously.
 ;
 ; Now that that faulty assumption is corrected, test that we DON'T incorrectly