Add option to limit Debugify to locations (omitting variables)

[dsanders]

Summary

It can be helpful to test behaviour w.r.t locations without having DEBUG_VALUE
around. In particular, because DEBUG_VALUE has the potential to change CodeGen
behaviour (e.g. hasOneUse() vs hasOneNonDbgUse()) while locations generally
don't.

[probinson]

I know it's a debugging/testing option, but it would be good to have a test that shows the two different levels do what you want.

[vsk]

In D77438#1964013, @probinson wrote:

I know it's a debugging/testing option, but it would be good to have a test that shows the two different levels do what you want.

Agreed. The patch looks good to me otherwise.

[dsanders]

+ test case

[vsk]

Thanks!

llvm/lib/Transforms/Utils/Debugify.cpp

 
 using namespace llvm;
 
 namespace {
 
 cl::opt<bool> Quiet("debugify-quiet",
                     cl::desc("Suppress verbose debugify output"));
 
+enum class Level {
+  Locations,
+  LocationsAndVariables
+};
+cl::opt<Level> DebugifyLevel(
+    "debugify-level", cl::desc("Kind of debug info to add"),
+    cl::values(clEnumValN(Level::Locations, "locations", "Locations only"),
+               clEnumValN(Level::LocationsAndVariables, "location+variables",
+                          "Locations and Variables")),
+    cl::init(Level::LocationsAndVariables));
+
 raw_ostream &dbg() { return Quiet ? nulls() : errs(); }
 
 uint64_t getAllocSizeInBits(Module &M, Type *Ty) {
   return Ty->isSized() ? M.getDataLayout().getTypeAllocSizeInBits(Ty) : 0;
 }
 
 bool isFunctionSkipped(Function &F) {
   return F.isDeclaration() || !F.hasExactDefinition();
for (Function &F : Functions) {
     auto SP = DIB.createFunction(CU, F.getName(), F.getName(), File, NextLine,
                                  SPType, NextLine, DINode::FlagZero, SPFlags);
     F.setSubprogram(SP);
     for (BasicBlock &BB : F) {
       // Attach debug locations.
       for (Instruction &I : BB)
         I.setDebugLoc(DILocation::get(Ctx, NextLine++, 1, SP));
 
+      if (DebugifyLevel < Level::LocationsAndVariables)
+        continue;
+
       // Inserting debug values into EH pads can break IR invariants.
       if (BB.isEHPad())
         continue;
 
       // Find the terminating instruction, after which no debug values are
       // attached.
       Instruction *LastInst = findTerminatingInstruction(BB);
       assert(LastInst && "Expected basic block with a terminator");

llvm/test/Transforms/Util/Debugify/loc-only.ll

+; RUN: opt -debugify -S < %s | FileCheck --check-prefixes=ALL,VALUE %s
+; RUN: opt -debugify -debugify-level=locations -S < %s | FileCheck --check-prefixes=ALL --implicit-check-not=dbg.value %s
+
+; ALL-LABEL: @test
+define void @test() {
+  %add = add i32 1, 2
+; ALL-NEXT:  %add = add i32 1, 2, !dbg [[L1:![0-9]+]]
+; VALUE-NEXT: call void @llvm.dbg.value(metadata i32 %add, metadata [[add:![0-9]+]], metadata !DIExpression()), !dbg [[L1]]
+  %sub = sub i32 %add, 1
+; ALL-NEXT: %sub = sub i32 %add, 1, !dbg [[L2:![0-9]+]]
+; VALUE-NEXT: call void @llvm.dbg.value(metadata i32 %sub, metadata [[sub:![0-9]+]], metadata !DIExpression()), !dbg [[L2]]
+; ALL-NEXT: ret void, !dbg [[L3:![0-9]+]]
+  ret void
+}
+
+; VALUE: [[add]] = !DILocalVariable
+; VALUE: [[sub]] = !DILocalVariable
+
+; ALL: [[L1]] = !DILocation(line: 1, column: 1, scope:
+; ALL: [[L2]] = !DILocation(line: 2, column: 1, scope:
+; ALL: [[L3]] = !DILocation(line: 3, column: 1, scope: