Add new debug kind LocTrackingOnly.

[dnovillo]

Summary

This new debug emission kind supports emitting line location
information in all instructions, but stops code generation
from emitting debug info to the final output.

This mode is useful when the backend wants to track source
locations during code generation, but it does not want to
produce debug info. This is currently used by optimization
remarks (-pass-remarks, -pass-remarks-missed and
-pass-remarks-analysis).

To prevent debug info emission, DIBuilder never inserts the
annotation 'llvm.dbg.cu' when LocTrackingOnly is enabled.

[dblaikie]

Probably worth wiring up the command line support in the same patch &
including test coverage.

I'd probably start with the LLVM change (using a local Clang change to
generate IR, or just hand-hacking the removal of the llvm.dbg.cu node
in an IR sample) to make sure this strategy is plausible and that just
dropping the llvm.dbg.cu node is all that's required from the
front-end.

Have you tested this through LLVM? How's it look?

[dnovillo]

Add missing test.

Instead of adding the new test I was working on, I opted to make a smaller
change and modify an existing one. We already had a test with debug info
in it. I changed it so it is missing llvm.dbg.cu.

The test now checks:

1- That a missing llvm.dbg.cu does not prevent line location tracking from

emitting proper locations with -pass-remarks.

2- That the final output contain no debug information in it.

[dblaikie]

As to the other comments about whether to add a value to the enum or use a flag in createCompileUnit - for now I think I'm going to err on the side of preferring a flag in createCompileUnit.

The Clang-side support for this should obviously look a fair bit like GMLT (indeed if you put the enum value for this mode before GMLT, it should get most/all the right behavior by default (though you might have to fix up some comparisons for == GMLT to <= GMLT)). At some point we can probably simplify this even further so all the scopes are just simple line/file info without having to create any compile units, functions, lexical scopes, etc.

test/Transforms/LoopVectorize/X86/vectorization-remarks.ll

7 ↗

(On Diff #10703)

My instinct would've been to -filetype=obj and run this through objdump -h and FileCheck that instead, but this seems OK too.

9 ↗

(On Diff #10703)

You don't need the {{.*}} on either side here, FileCheck looks for subline matches by default (which is why the .loc as you've written it is correct).

[dnovillo]

• Remove DebugEmissionKind::LocTrackingOnly. Instead, add a boolean flag to DIBuilder::createCompileUnit.

• Fix expected pattern in test.

[dblaikie]

include/llvm/IR/DIBuilder.h

112 ↗

(On Diff #10758)

I wonder if there's a less vague name we could use for this parameter, but I haven't thought of a better one yet. (I imagine inverted would make more sense - true for "use this weird thing where we make metadata nodes but don't add the CUs to the list" - but still don't know what we'd name it)

[dnovillo]

Closed by commit rL211609 (authored by @dnovillo).

llvm/trunk/include/llvm/IR/DIBuilder.h

class DIBuilder {
     ///                    is ON or not.
     /// @param Flags    This string lists command line options. This string is
     ///                 directly embedded in debug info output which may be used
     ///                 by a tool analyzing generated debugging information.
     /// @param RV       This indicates runtime version for languages like
     ///                 Objective-C.
     /// @param SplitName The name of the file that we'll split debug info out
     ///                  into.
+    /// @param Kind     The kind of debug information to generate.
+    /// @param EmitDebugInfo   A boolean flag which indicates whether debug
+    ///                        information should be written to the final
+    ///                        output or not. When this is false, debug
+    ///                        information annotations will be present in
+    ///                        the IL but they are not written to the final
+    ///                        assembly or object file. This supports tracking
+    ///                        source location information in the back end
+    ///                        without actually changing the output (e.g.,
+    ///                        when using optimization remarks).
     DICompileUnit createCompileUnit(unsigned Lang, StringRef File,
                                     StringRef Dir, StringRef Producer,
                                     bool isOptimized, StringRef Flags,
                                     unsigned RV,
                                     StringRef SplitName = StringRef(),
-                                    DebugEmissionKind Kind = FullDebug);
+                                    DebugEmissionKind Kind = FullDebug,
+                                    bool EmitDebugInfo = true);
 
     /// createFile - Create a file descriptor to hold debugging information
     /// for a file.
     DIFile createFile(StringRef Filename, StringRef Directory);
 
     /// createEnumerator - Create a single enumerator value.
     DIEnumerator createEnumerator(StringRef Name, int64_t Val);
 

llvm/trunk/lib/IR/DIBuilder.cpp

 
 /// createCompileUnit - A CompileUnit provides an anchor for all debugging
 /// information generated during this instance of compilation.
 DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
                                            StringRef Directory,
                                            StringRef Producer, bool isOptimized,
                                            StringRef Flags, unsigned RunTimeVer,
                                            StringRef SplitName,
-                                           DebugEmissionKind Kind) {
+                                           DebugEmissionKind Kind,
+                                           bool EmitDebugInfo) {
 
   assert(((Lang <= dwarf::DW_LANG_OCaml && Lang >= dwarf::DW_LANG_C89) ||
           (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
          "Invalid Language tag");
   assert(!Filename.empty() &&
          "Unable to create compile unit without filename");
   Value *TElts[] = { GetTagConstant(VMContext, DW_TAG_base_type) };
   TempEnumTypes = MDNode::getTemporary(VMContext, TElts);
Value *Elts[] = {
     TempImportedModules,
     MDString::get(VMContext, SplitName),
     ConstantInt::get(Type::getInt32Ty(VMContext), Kind)
   };
 
   MDNode *CUNode = MDNode::get(VMContext, Elts);
 
   // Create a named metadata so that it is easier to find cu in a module.
+  // Note that we only generate this when the caller wants to actually
+  // emit debug information. When we are only interested in tracking
+  // source line locations throughout the backend, we prevent codegen from
+  // emitting debug info in the final output by not generating llvm.dbg.cu.
+  if (EmitDebugInfo) {
     NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
     NMD->addOperand(CUNode);
+  }
 
   return DICompileUnit(CUNode);
 }
 
 static DIImportedEntity
 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope Context,
                      Value *NS, unsigned Line, StringRef Name,
                      SmallVectorImpl<TrackingVH<MDNode>> &AllImportedModules) {

llvm/trunk/test/Transforms/LoopVectorize/X86/vectorization-remarks.ll

 ; RUN: opt < %s -loop-vectorize -mtriple=x86_64-unknown-linux -S -pass-remarks='loop-vectorize' 2>&1 | FileCheck -check-prefix=VECTORIZED %s
 ; RUN: opt < %s -loop-vectorize -force-vector-width=1 -force-vector-unroll=4 -mtriple=x86_64-unknown-linux -S -pass-remarks='.*vectorize.*' 2>&1 | FileCheck -check-prefix=UNROLLED %s
 
+; This code has all the !dbg annotations needed to track source line information,
+; but is missing the llvm.dbg.cu annotation. This prevents code generation from
+; emitting debug info in the final output.
+; RUN: llc -mtriple x86_64-pc-linux-gnu %s -o - | FileCheck -check-prefix=DEBUG-OUTPUT %s
+; DEBUG-OUTPUT-NOT: .loc
+; DEBUG-OUTPUT-NOT: {{.*}}.debug_info
+
 ; VECTORIZED: remark: {{.*}}.c:17:8: vectorized loop (vectorization factor: 4, unrolling interleave factor: 1)
 ; UNROLLED: remark: {{.*}}.c:17:8: unrolled with interleaving factor 4 (vectorization not beneficial)
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define i32 @foo(i32 %n) #0 {
 entry:
   %diff = alloca i32, align 4

 for.end:                                          ; preds = %for.body
   store i32 %add, i32* %diff, align 4, !dbg !19, !tbaa !11
   call void @ibar(i32* %diff) #2, !dbg !22
   ret i32 0, !dbg !23
 }
 
 declare void @ibar(i32*) #1
 
-!llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!7, !8}
 !llvm.ident = !{!9}
 
-!0 = metadata !{i32 786449, metadata !1, i32 12, metadata !"clang version 3.5.0 ", i1 true, metadata !"", i32 0, metadata !2, metadata !2, metadata !3, metadata !2, metadata !2, metadata !"", i32 2} ; [ DW_TAG_compile_unit ] [./vectorization-remarks.c] [DW_LANG_C99]
 !1 = metadata !{metadata !"vectorization-remarks.c", metadata !"."}
 !2 = metadata !{}
 !3 = metadata !{metadata !4}
 !4 = metadata !{i32 786478, metadata !1, metadata !5, metadata !"foo", metadata !"foo", metadata !"", i32 5, metadata !6, i1 false, i1 true, i32 0, i32 0, null, i32 256, i1 true, i32 (i32)* @foo, null, null, metadata !2, i32 6} ; [ DW_TAG_subprogram ] [line 5] [def] [scope 6] [foo]
 !5 = metadata !{i32 786473, metadata !1}          ; [ DW_TAG_file_type ] [./vectorization-remarks.c]
 !6 = metadata !{i32 786453, i32 0, null, metadata !"", i32 0, i64 0, i64 0, i64 0, i32 0, null, metadata !2, i32 0, null, null, null} ; [ DW_TAG_subroutine_type ] [line 0, size 0, align 0, offset 0] [from ]
 !7 = metadata !{i32 2, metadata !"Dwarf Version", i32 4}
 !8 = metadata !{i32 1, metadata !"Debug Info Version", i32 1}