[CPU] Move checking stack allocation cmd flag to Passes.cpp (#16062)

This removes an additional flag, and puts all the flags at the same
file. It makes all the cmd flags start with `iree-llvmcpu-*`.

compiler/src/iree/compiler/Codegen/LLVMCPU/LLVMCPUCheckIRBeforeLLVMConversion.cpp

@@ -16,16 +16,15 @@ static llvm::cl::opt<int> clMaxAllocationSizeInBytes(
     "iree-llvmcpu-stack-allocation-limit",
     llvm::cl::desc("maximum allowed stack allocation size in bytes"),
     llvm::cl::init(32768));
-static llvm::cl::opt<bool> clFailOnOutOfBoundsStackAllocation(
-    "iree-llvmcpu-fail-on-out-of-bounds-stack-allocation",
-    llvm::cl::desc("fail if the upper bound of dynamic stack allocation cannot "
-                   "be solved"),
-    llvm::cl::init(true));
 
 namespace {
 struct LLVMCPUCheckIRBeforeLLVMConversionPass
     : LLVMCPUCheckIRBeforeLLVMConversionBase<
           LLVMCPUCheckIRBeforeLLVMConversionPass> {
+  LLVMCPUCheckIRBeforeLLVMConversionPass(bool failOnOutOfBounds) {
+    this->failOnOutOfBounds = failOnOutOfBounds;
+  }
+
   void runOnOperation() override;
 };
 } // namespace
@@ -84,19 +83,22 @@ static LogicalResult checkStackAllocationSize(func::FuncOp funcOp) {
 }
 
 void LLVMCPUCheckIRBeforeLLVMConversionPass::runOnOperation() {
-  auto moduleOp = getOperation();
+  if (!failOnOutOfBounds) {
+    return;
+  }
 
+  auto moduleOp = getOperation();
   for (auto funcOp : moduleOp.getOps<func::FuncOp>()) {
-    if (clFailOnOutOfBoundsStackAllocation &&
-        failed(checkStackAllocationSize(funcOp))) {
+    if (failed(checkStackAllocationSize(funcOp))) {
       return signalPassFailure();
     }
   }
 }
 
 std::unique_ptr<OperationPass<ModuleOp>>
-createLLVMCPUCheckIRBeforeLLVMConversionPass() {
-  return std::make_unique<LLVMCPUCheckIRBeforeLLVMConversionPass>();
+createLLVMCPUCheckIRBeforeLLVMConversionPass(bool failOnOutOfBounds) {
+  return std::make_unique<LLVMCPUCheckIRBeforeLLVMConversionPass>(
+      failOnOutOfBounds);
 }
 
 } // namespace mlir::iree_compiler

compiler/src/iree/compiler/Codegen/LLVMCPU/Passes.cpp

@@ -31,10 +31,10 @@ namespace mlir::iree_compiler {
 
 /// Command line options used purely for development purposes. Not to be relied
 /// on in any way.
-static llvm::cl::opt<bool> clCheckIRBeforeLLVMConversion(
-    "iree-codegen-check-ir-before-llvm-conversion",
-    llvm::cl::desc("Runs the pass to check the IR generated from LLVMCPU "
-                   "before conversion to LLVM IR"),
+static llvm::cl::opt<bool> clFailOnOutOfBoundsStackAllocation(
+    "iree-llvmcpu-fail-on-out-of-bounds-stack-allocation",
+    llvm::cl::desc("fail if the upper bound of dynamic stack allocation cannot "
+                   "be solved"),
     llvm::cl::init(true));
 
 static llvm::cl::opt<bool> clCheckLinalgVectorization(
@@ -636,9 +636,8 @@ static void addLowerToLLVMPasses(OpPassManager &passManager,
   passManager.addNestedPass<func::FuncOp>(createCleanupBufferAllocViewPass());
 
   // Checking stack allocation before converting to CF dialect is easier.
-  if (clCheckIRBeforeLLVMConversion) {
-    passManager.addPass(createLLVMCPUCheckIRBeforeLLVMConversionPass());
-  }
+  passManager.addPass(createLLVMCPUCheckIRBeforeLLVMConversionPass(
+      clFailOnOutOfBoundsStackAllocation));
 
   // SCF -> CF
   passManager.addNestedPass<func::FuncOp>(createConvertSCFToCFPass());

compiler/src/iree/compiler/Codegen/LLVMCPU/Passes.h

@@ -25,7 +25,7 @@ createConvertToLLVMPass(bool reassociateFpReordering = false);
 
 /// Checks CPU backend specific IR constraints (like no stack allocations)
 std::unique_ptr<OperationPass<ModuleOp>>
-createLLVMCPUCheckIRBeforeLLVMConversionPass();
+createLLVMCPUCheckIRBeforeLLVMConversionPass(bool failOnOutOfBounds = true);
 
 std::unique_ptr<OperationPass<func::FuncOp>>
 createLLVMCPUEmitVectorizationRemarksPass();

compiler/src/iree/compiler/Codegen/LLVMCPU/Passes.td

@@ -49,6 +49,11 @@ def LLVMCPUCheckIRBeforeLLVMConversion :
     Pass<"iree-llvmcpu-check-ir-before-llvm-conversion", "ModuleOp"> {
   let summary = "Checks CPU backend specific IR constraints (like no allocas)";
   let constructor = "mlir::iree_compiler::createLLVMCPUCheckIRBeforeLLVMConversionPass()";
+  let options = [
+    Option<"failOnOutOfBounds", "fail-on-out-of-bounds", "bool", "true",
+           "Fails if the upper bound of dynamic stack allocation cannot be"
+           "resolved or is more than the limit.">
+  ];
 }
 
 def LLVMCPUEmitVectorizationRemarks :

compiler/src/iree/compiler/Codegen/LLVMCPU/test/check_ir_before_llvm_conversion_not_fail_unbound.mlir

@@ -1,4 +1,4 @@
-// RUN: iree-opt --iree-llvmcpu-check-ir-before-llvm-conversion --iree-llvmcpu-fail-on-out-of-bounds-stack-allocation=false %s --verify-diagnostics -split-input-file
+// RUN: iree-opt --iree-llvmcpu-check-ir-before-llvm-conversion=fail-on-out-of-bounds=false %s --verify-diagnostics -split-input-file
 
 module {
   func.func @dynamic_allocas(%arg0: index) {
@@ -28,4 +28,4 @@ module {
     return
   }
 }
-// CHECK-LABEL: func @mix_static_and_unbound_dynamic_allocas(
+// CHECK-LABEL: func @mix_static_and_unbound_dynamic_allocas(