[Debugify] Add a mode to opt to enable faster testing

[vsk]

Summary

Opt's "-enable-debugify" mode adds an instance of Debugify at the
beginning of the pass pipeline, and an instance of CheckDebugify at the
end.

You can enable this mode with lit using: -Dopt="opt -enable-debugify".
Note that running test suites in this mode will result in many failures
due to strict FileCheck commands, etc.

It can be more useful to look for assertion failures which arise only
when Debugify is enabled, e.g to prove that we have (or do not have)
test coverage for some code path with debug info present.

[davide]

LGTM

[MatzeB]

BTW: I usually do this instead of an env var to force some arguments to all invocations of a tool in lit:

llvm-lit -Dllc="llc -verify-machineinstrs"

[davide]

In D41793#969945, @MatzeB wrote:

BTW: I usually do this instead of an env var to force some arguments to all invocations of a tool in lit:

llvm-lit -Dllc="llc -verify-machineinstrs"

If we can go without an enviroment variable, it's even better.
BTW, I've never heard of this flag, is it documented somewhere? If not, we probably might want to.

[MatzeB]

In D41793#969946, @davide wrote:

In D41793#969945, @MatzeB wrote:

BTW: I usually do this instead of an env var to force some arguments to all invocations of a tool in lit:

llvm-lit -Dllc="llc -verify-machineinstrs"

If we can go without an enviroment variable, it's even better.
BTW, I've never heard of this flag, is it documented somewhere? If not, we probably might want to.

Probably not. I sneaked that into llvms lit.cfg a long time ago as it was only a 1-line thing but probably very few people know about it. Let me write a sentence or two for TestingGuide.rst

[MatzeB]

In D41793#969948, @MatzeB wrote:

In D41793#969946, @davide wrote:

In D41793#969945, @MatzeB wrote:

BTW: I usually do this instead of an env var to force some arguments to all invocations of a tool in lit:

llvm-lit -Dllc="llc -verify-machineinstrs"

If we can go without an enviroment variable, it's even better.
BTW, I've never heard of this flag, is it documented somewhere? If not, we probably might want to.

Probably not. I sneaked that into llvms lit.cfg a long time ago as it was only a 1-line thing but probably very few people know about it. Let me write a sentence or two for TestingGuide.rst

Turns I out I already documented it in r236462 :)

[jroelofs]

You can avoid the env var by adding a substitution for opt in the lit.cfg.py with the extra argument.

[davide]

In D41793#969952, @MatzeB wrote:

In D41793#969948, @MatzeB wrote:

In D41793#969946, @davide wrote:

In D41793#969945, @MatzeB wrote:

BTW: I usually do this instead of an env var to force some arguments to all invocations of a tool in lit:

llvm-lit -Dllc="llc -verify-machineinstrs"

If we can go without an enviroment variable, it's even better.
BTW, I've never heard of this flag, is it documented somewhere? If not, we probably might want to.

Probably not. I sneaked that into llvms lit.cfg a long time ago as it was only a 1-line thing but probably very few people know about it. Let me write a sentence or two for TestingGuide.rst

Turns I out I already documented it in r236462 :)

:) Thanks!

[vsk]

I think @MatzeB's suggestion works well without requiring any test changes. I'll update this patch soon.

test/DebugInfo/debugify.ll

 ; RUN: opt -debugify -S -o - < %s | FileCheck %s
 
 ; RUN: opt -debugify -debugify -S -o - < %s 2>&1 | \
 ; RUN:   FileCheck %s -check-prefix=CHECK-REPEAT
 
 ; RUN: opt -debugify -check-debugify -S -o - < %s | \
 ; RUN:   FileCheck %s -implicit-check-not="CheckDebugify: FAIL"
 
 ; RUN: opt -debugify -strip -check-debugify -S -o - < %s | \
 ; RUN:   FileCheck %s -check-prefix=CHECK-FAIL
 
+; RUN: opt -enable-debugify -strip -S -o - < %s | \
+; RUN:   FileCheck %s -check-prefix=CHECK-FAIL
+
 ; CHECK-LABEL: define void @foo
 define void @foo() {
 ; CHECK: ret void, !dbg ![[RET1:.*]]
   ret void
 }
 
 ; CHECK-LABEL: define i32 @bar
 define i32 @bar() {

tools/opt/Debugify.cpp

void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 
   static char ID; // Pass identification.
 };
 
 } // end anonymous namespace
 
+ModulePass *createDebugifyPass() { return new DebugifyPass(); }
+
+ModulePass *createCheckDebugifyPass() { return new CheckDebugifyPass(); }
+
 char DebugifyPass::ID = 0;
 static RegisterPass<DebugifyPass> X("debugify",
                                     "Attach debug info to everything");
 
 char CheckDebugifyPass::ID = 0;
 static RegisterPass<CheckDebugifyPass> Y("check-debugify",
                                          "Check debug info from -debugify");

tools/opt/opt.cpp

 Quiet("q", cl::desc("Obsolete option"), cl::Hidden);
 
 static cl::alias
 QuietA("quiet", cl::desc("Alias for -q"), cl::aliasopt(Quiet));
 
 static cl::opt<bool>
 AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization"));
 
+static cl::opt<bool> EnableDebugify(
+    "enable-debugify",
+    cl::desc(
+        "Start the pipeline with debugify and end it with check-debugify"));
+
 static cl::opt<bool>
 PrintBreakpoints("print-breakpoints-for-testing",
                  cl::desc("Print select breakpoints location for testing"));
 
 static cl::opt<std::string> ClDataLayout("data-layout",
                                          cl::desc("data layout string to use"),
                                          cl::value_desc("layout-string"),
                                          cl::init(""));
static cl::opt<unsigned> PassRemarksHotnessThreshold(
     cl::desc("Minimum profile count required for an optimization remark to be output"),
     cl::Hidden);
 
 static cl::opt<std::string>
     RemarksFilename("pass-remarks-output",
                     cl::desc("YAML output filename for pass remarks"),
                     cl::value_desc("filename"));
 
+extern ModulePass *createDebugifyPass();
+extern ModulePass *createCheckDebugifyPass();
+
 static inline void addPass(legacy::PassManagerBase &PM, Pass *P) {
   // Add the pass to the pass manager...
   PM.add(P);
 
   // If we are verifying all of the intermediate steps, add the verifier...
   if (VerifyEach)
     PM.add(createVerifierPass());
 }
#endif
   if (DisableSimplifyLibCalls)
     TLII.disableAllFunctions();
   Passes.add(new TargetLibraryInfoWrapperPass(TLII));
 
   // Add internal analysis passes from the target machine.
   Passes.add(createTargetTransformInfoWrapperPass(TM ? TM->getTargetIRAnalysis()
                                                      : TargetIRAnalysis()));
 
+  if (EnableDebugify)
+    Passes.add(createDebugifyPass());
+
   std::unique_ptr<legacy::FunctionPassManager> FPasses;
   if (OptLevelO0 || OptLevelO1 || OptLevelO2 || OptLevelOs || OptLevelOz ||
       OptLevelO3) {
     FPasses.reset(new legacy::FunctionPassManager(M.get()));
     FPasses->add(createTargetTransformInfoWrapperPass(
         TM ? TM->getTargetIRAnalysis() : TargetIRAnalysis()));
   }
 
for (Function &F : *M)
       FPasses->run(F);
     FPasses->doFinalization();
   }
 
   // Check that the module is well formed on completion of optimization
   if (!NoVerify && !VerifyEach)
     Passes.add(createVerifierPass());
 
+  if (EnableDebugify)
+    Passes.add(createCheckDebugifyPass());
+
   // In run twice mode, we want to make sure the output is bit-by-bit
   // equivalent if we run the pass manager again, so setup two buffers and
   // a stream to write to them. Note that llc does something similar and it
   // may be worth to abstract this out in the future.
   SmallVector<char, 0> Buffer;
   SmallVector<char, 0> CompileTwiceBuffer;
   std::unique_ptr<raw_svector_ostream> BOS;
   raw_ostream *OS = nullptr;