[DWARFv5] Tolerate files not all having an MD5 checksum.

[probinson]

Summary

In some cases, for example when compiling a preprocessed file, the
front-end is not able to provide an MD5 checksum for all files. When
that happens, omit the MD5 checksums from the final DWARF, because
DWARF doesn't have a way to indicate that some but not all files have
a checksum.

When assembling a .s file, and some but not all .file directives
provide an MD5 checksum, issue a warning and don't emit MD5 into the
DWARF.

Fixes PR37623.

[aprantl]

llvm/include/llvm/MC/MCDwarf.h

258 ↗

(On Diff #151189)

I found that a little confusing to read at first:
what do you think about

Header.HasAnyMD5 |= CheckSum;
Header.HasAllMD5 &= CheckSum;

to underline the fact that these values are updated incrementally?

[probinson]

Simplify bool updates.

[probinson]

llvm/include/llvm/MC/MCDwarf.h

258 ↗

(On Diff #151189)

It would have to be spelled bool(CheckSum) or maybe you would prefer (CheckSum != nullptr)) but yes that does work.

[JDevlieghere]

llvm/include/llvm/MC/MCDwarf.h

255 ↗

(On Diff #151206)

How do you feel about a convenience method that takes the header and checksum pointer and updates both?

[probinson]

Privatize the flags for tracking MD5 usage.

[probinson]

llvm/include/llvm/MC/MCDwarf.h

255 ↗

(On Diff #151206)

What, because the same code is in 4 places and I already made mistakes updating all 4 consistently, I should factor them into a common method? You're right!
After which it really made sense to make them private fields and bury all of it behind an API for proper data hiding.

[JDevlieghere]

LGTM!

llvm/include/llvm/MC/MCDwarf.h

255 ↗

(On Diff #151206)

👍👍👍

llvm/trunk/include/llvm/MC/MCContext.h

public:
     /// These are "file 0" and "directory 0" in DWARF v5.
     void setMCLineTableRootFile(unsigned CUID, StringRef CompilationDir,
                                 StringRef Filename, MD5::MD5Result *Checksum,
                                 Optional<StringRef> Source) {
       getMCDwarfLineTable(CUID).setRootFile(CompilationDir, Filename, Checksum,
                                             Source);
     }
 
+    /// Reports whether MD5 checksum usage is consistent (all-or-none).
+    bool isDwarfMD5UsageConsistent(unsigned CUID) const {
+      return getMCDwarfLineTable(CUID).isMD5UsageConsistent();
+    }
+
     /// Saves the information from the currently parsed dwarf .loc directive
     /// and sets DwarfLocSeen.  When the next instruction is assembled an entry
     /// in the line number table with this information and the address of the
     /// instruction will be created.
     void setCurrentDwarfLoc(unsigned FileNum, unsigned Line, unsigned Column,
                             unsigned Flags, unsigned Isa,
                             unsigned Discriminator) {
       CurrentDwarfLoc.setFileNum(FileNum);

llvm/trunk/include/llvm/MC/MCDwarf.h

 
 struct MCDwarfLineTableHeader {
   MCSymbol *Label = nullptr;
   SmallVector<std::string, 3> MCDwarfDirs;
   SmallVector<MCDwarfFile, 3> MCDwarfFiles;
   StringMap<unsigned> SourceIdMap;
   StringRef CompilationDir;
   MCDwarfFile RootFile;
-  bool HasMD5 = false;
   bool HasSource = false;
+private:
+  bool HasAllMD5 = true;
+  bool HasAnyMD5 = false;
 
+public:
   MCDwarfLineTableHeader() = default;
 
   Expected<unsigned> tryGetFile(StringRef &Directory, StringRef &FileName,
                                 MD5::MD5Result *Checksum,
                                 Optional<StringRef> &Source,
                                 unsigned FileNumber = 0);
   std::pair<MCSymbol *, MCSymbol *>
   Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
        Optional<MCDwarfLineStr> &LineStr) const;
   std::pair<MCSymbol *, MCSymbol *>
   Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
        ArrayRef<char> SpecialOpcodeLengths,
        Optional<MCDwarfLineStr> &LineStr) const;
+  void resetMD5Usage() {
+    HasAllMD5 = true;
+    HasAnyMD5 = false;
+  }
+  void trackMD5Usage(bool MD5Used) {
+    HasAllMD5 &= MD5Used;
+    HasAnyMD5 |= MD5Used;
+  }
+  bool isMD5UsageConsistent() const {
+    return MCDwarfFiles.empty() || (HasAllMD5 == HasAnyMD5);
+  }
 
 private:
   void emitV2FileDirTables(MCStreamer *MCOS) const;
   void emitV5FileDirTables(MCStreamer *MCOS, Optional<MCDwarfLineStr> &LineStr,
                            StringRef CtxCompilationDir) const;
 };
 
 class MCDwarfDwoLineTable {
   MCDwarfLineTableHeader Header;
 
 public:
   void maybeSetRootFile(StringRef Directory, StringRef FileName,
                         MD5::MD5Result *Checksum, Optional<StringRef> Source) {
     if (!Header.RootFile.Name.empty())
       return;
     Header.CompilationDir = Directory;
     Header.RootFile.Name = FileName;
     Header.RootFile.DirIndex = 0;
     Header.RootFile.Checksum = Checksum;
     Header.RootFile.Source = Source;
-    Header.HasMD5 = (Checksum != nullptr);
+    Header.trackMD5Usage(Checksum);
     Header.HasSource = Source.hasValue();
   }
 
   unsigned getFile(StringRef Directory, StringRef FileName,
                    MD5::MD5Result *Checksum, Optional<StringRef> Source) {
     return cantFail(Header.tryGetFile(Directory, FileName, Checksum, Source));
   }
 
public:
 
   void setRootFile(StringRef Directory, StringRef FileName,
                    MD5::MD5Result *Checksum, Optional<StringRef> Source) {
     Header.CompilationDir = Directory;
     Header.RootFile.Name = FileName;
     Header.RootFile.DirIndex = 0;
     Header.RootFile.Checksum = Checksum;
     Header.RootFile.Source = Source;
-    Header.HasMD5 = (Checksum != nullptr);
+    Header.trackMD5Usage(Checksum);
     Header.HasSource = Source.hasValue();
   }
 
+  void resetRootFile() {
+    assert(Header.MCDwarfFiles.empty());
+    Header.resetMD5Usage();
+    Header.HasSource = false;
+  }
+
+  // Report whether MD5 usage has been consistent (all-or-none).
+  bool isMD5UsageConsistent() const { return Header.isMD5UsageConsistent(); }
+
   MCSymbol *getLabel() const {
     return Header.Label;
   }
 
   void setLabel(MCSymbol *Label) {
     Header.Label = Label;
   }
 

llvm/trunk/lib/MC/MCAsmStreamer.cpp

void MCAsmStreamer::emitDwarfFile0Directive(StringRef Directory,
                                             StringRef Filename,
                                             MD5::MD5Result *Checksum,
                                             Optional<StringRef> Source,
                                             unsigned CUID) {
   assert(CUID == 0);
   // .file 0 is new for DWARF v5.
   if (getContext().getDwarfVersion() < 5)
     return;
+  // Inform MCDwarf about the root file.
+  getContext().setMCLineTableRootFile(CUID, Directory, Filename, Checksum,
+                                      Source);
 
   SmallString<128> Str;
   raw_svector_ostream OS1(Str);
   printDwarfFileDirective(0, Directory, Filename, Checksum, Source,
                           UseDwarfDirectory, OS1);
 
   if (MCTargetStreamer *TS = getTargetStreamer())
     TS->emitDwarfFileDirective(OS1.str());

llvm/trunk/lib/MC/MCDwarf.cpp

for (unsigned i = 1; i < MCDwarfFiles.size(); i++) {
     MCOS->EmitULEB128IntValue(MCDwarfFiles[i].DirIndex); // Directory number.
     MCOS->EmitIntValue(0, 1); // Last modification timestamp (always 0).
     MCOS->EmitIntValue(0, 1); // File size (always 0).
   }
   MCOS->EmitIntValue(0, 1); // Terminate the file list.
 }
 
 static void emitOneV5FileEntry(MCStreamer *MCOS, const MCDwarfFile &DwarfFile,
-                               bool HasMD5, bool HasSource,
+                               bool EmitMD5, bool HasSource,
                                Optional<MCDwarfLineStr> &LineStr) {
   assert(!DwarfFile.Name.empty());
   if (LineStr)
     LineStr->emitRef(MCOS, DwarfFile.Name);
   else {
     MCOS->EmitBytes(DwarfFile.Name);     // FileName and...
     MCOS->EmitBytes(StringRef("\0", 1)); // its null terminator.
   }
   MCOS->EmitULEB128IntValue(DwarfFile.DirIndex); // Directory number.
-  if (HasMD5) {
+  if (EmitMD5) {
     MD5::MD5Result *Cksum = DwarfFile.Checksum;
     MCOS->EmitBinaryData(
         StringRef(reinterpret_cast<const char *>(Cksum->Bytes.data()),
                   Cksum->Bytes.size()));
   }
   if (HasSource) {
     if (LineStr)
       LineStr->emitRef(MCOS, DwarfFile.Source.getValueOr(StringRef()));
for (auto &Dir : MCDwarfDirs) {
       MCOS->EmitBytes(StringRef("\0", 1)); // its null terminator.
     }
   }
 
   // The file format, which is the inline null-terminated filename and a
   // directory index.  We don't track file size/timestamp so don't emit them
   // in the v5 table.  Emit MD5 checksums and source if we have them.
   uint64_t Entries = 2;
-  if (HasMD5)
+  if (HasAllMD5)
     Entries += 1;
   if (HasSource)
     Entries += 1;
   MCOS->EmitIntValue(Entries, 1);
   MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_path);
   MCOS->EmitULEB128IntValue(LineStr ? dwarf::DW_FORM_line_strp
                                     : dwarf::DW_FORM_string);
   MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_directory_index);
   MCOS->EmitULEB128IntValue(dwarf::DW_FORM_udata);
-  if (HasMD5) {
+  if (HasAllMD5) {
     MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_MD5);
     MCOS->EmitULEB128IntValue(dwarf::DW_FORM_data16);
   }
   if (HasSource) {
     MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_LLVM_source);
     MCOS->EmitULEB128IntValue(LineStr ? dwarf::DW_FORM_line_strp
                                       : dwarf::DW_FORM_string);
   }
   // Then the counted list of files. The root file is file #0, then emit the
   // files as provide by .file directives.  To accommodate assembler source
   // written for DWARF v4 but trying to emit v5, if we didn't see a root file
   // explicitly, replicate file #1.
   MCOS->EmitULEB128IntValue(MCDwarfFiles.size());
   emitOneV5FileEntry(MCOS, RootFile.Name.empty() ? MCDwarfFiles[1] : RootFile,
-                     HasMD5, HasSource, LineStr);
+                     HasAllMD5, HasSource, LineStr);
   for (unsigned i = 1; i < MCDwarfFiles.size(); ++i)
-    emitOneV5FileEntry(MCOS, MCDwarfFiles[i], HasMD5, HasSource, LineStr);
+    emitOneV5FileEntry(MCOS, MCDwarfFiles[i], HasAllMD5, HasSource, LineStr);
 }
 
 std::pair<MCSymbol *, MCSymbol *>
 MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
                              ArrayRef<char> StandardOpcodeLengths,
                              Optional<MCDwarfLineStr> &LineStr) const {
   MCContext &context = MCOS->getContext();
 
MCDwarfLineTableHeader::tryGetFile(StringRef &Directory,
                                    unsigned FileNumber) {
   if (Directory == CompilationDir)
     Directory = "";
   if (FileName.empty()) {
     FileName = "<stdin>";
     Directory = "";
   }
   assert(!FileName.empty());
-  // If any files have an MD5 checksum or embedded source, they all must.
+  // Keep track of whether any or all files have an MD5 checksum.
+  // If any files have embedded source, they all must.
   if (MCDwarfFiles.empty()) {
-    HasMD5 = (Checksum != nullptr);
+    trackMD5Usage(Checksum);
     HasSource = (Source != None);
   }
   if (FileNumber == 0) {
     // File numbers start with 1 and/or after any file numbers
     // allocated by inline-assembler .file directives.
     FileNumber = MCDwarfFiles.empty() ? 1 : MCDwarfFiles.size();
     SmallString<256> Buffer;
     auto IterBool = SourceIdMap.insert(
MCDwarfLineTableHeader::tryGetFile(StringRef &Directory,
   // Get the new MCDwarfFile slot for this FileNumber.
   MCDwarfFile &File = MCDwarfFiles[FileNumber];
 
   // It is an error to see the same number more than once.
   if (!File.Name.empty())
     return make_error<StringError>("file number already allocated",
                                    inconvertibleErrorCode());
 
-  // If any files have an MD5 checksum, they all must.
-  if (HasMD5 != (Checksum != nullptr))
-    return make_error<StringError>("inconsistent use of MD5 checksums",
-                                   inconvertibleErrorCode());
   // If any files have embedded source, they all must.
   if (HasSource != (Source != None))
     return make_error<StringError>("inconsistent use of embedded source",
                                    inconvertibleErrorCode());
 
   if (Directory.empty()) {
     // Separate the directory part from the basename of the FileName.
     StringRef tFileName = sys::path::filename(FileName);
if (Directory.empty()) {
     // directory names are stored at MCDwarfDirs[DirIndex-1] where FileNames
     // are stored at MCDwarfFiles[FileNumber].Name .
     DirIndex++;
   }
 
   File.Name = FileName;
   File.DirIndex = DirIndex;
   File.Checksum = Checksum;
-  if (Checksum)
-    HasMD5 = true;
+  trackMD5Usage(Checksum);
   File.Source = Source;
   if (Source)
     HasSource = true;
 
   // return the allocated FileNumber.
   return FileNumber;
 }
 

llvm/trunk/lib/MC/MCParser/AsmParser.cpp

private:
   unsigned AssemblerDialect = ~0U;
 
   /// is Darwin compatibility enabled?
   bool IsDarwin = false;
 
   /// Are we parsing ms-style inline assembly?
   bool ParsingInlineAsm = false;
 
+  /// Did we already inform the user about inconsistent MD5 usage?
+  bool ReportedInconsistentMD5 = false;
+
 public:
   AsmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
             const MCAsmInfo &MAI, unsigned CB);
   AsmParser(const AsmParser &) = delete;
   AsmParser &operator=(const AsmParser &) = delete;
   ~AsmParser() override;
 
   bool Run(bool NoInitialTextSection, bool NoFinalize = false) override;
if (Keyword == "md5") {
         return true;
     } else {
       return TokError("unexpected token in '.file' directive");
     }
   }
 
   // In case there is a -g option as well as debug info from directive .file,
   // we turn off the -g option, directly use the existing debug info instead.
-  getContext().setGenDwarfForAssembly(false);
+  // Also reset any implicit ".file 0" for the assembler source.
+  if (Ctx.getGenDwarfForAssembly()) {
+    Ctx.getMCDwarfLineTable(0).resetRootFile();
+    Ctx.setGenDwarfForAssembly(false);
+  }
 
   if (FileNumber == -1)
     getStreamer().EmitFileDirective(Filename);
   else {
     MD5::MD5Result *CKMem = nullptr;
     if (HasMD5) {
       CKMem = (MD5::MD5Result *)Ctx.allocate(sizeof(MD5::MD5Result), 1);
       for (unsigned i = 0; i != 8; ++i) {
if (FileNumber == 0)
       getStreamer().emitDwarfFile0Directive(Directory, Filename, CKMem, Source);
     else {
       Expected<unsigned> FileNumOrErr = getStreamer().tryEmitDwarfFileDirective(
           FileNumber, Directory, Filename, CKMem, Source);
       if (!FileNumOrErr)
         return Error(DirectiveLoc, toString(FileNumOrErr.takeError()));
       FileNumber = FileNumOrErr.get();
     }
+    // Alert the user if there are some .file directives with MD5 and some not.
+    // But only do that once.
+    if (!ReportedInconsistentMD5 && !Ctx.isDwarfMD5UsageConsistent(0)) {
+      ReportedInconsistentMD5 = true;
+      return Warning(DirectiveLoc, "inconsistent use of MD5 checksums");
+    }
   }
 
   return false;
 }
 
 /// parseDirectiveLine
 /// ::= .line [number]
 bool AsmParser::parseDirectiveLine() {

llvm/trunk/test/CodeGen/Generic/dwarf-md5.ll

 ; MD5 checksums provided by IR should be passed through to asm.
 ; They'll be emitted to an object file only for DWARF 5 or later.
 
 ; Darwin clamps the line table at DWARF v2 so XFAIL this test.
 ; XFAIL: darwin
 
 ; REQUIRES: object-emission
-; RUN: %llc_dwarf -dwarf-version 4 -filetype=asm -o - %s | FileCheck %s --check-prefixes=ASM,ASM-4
-; RUN: %llc_dwarf -dwarf-version 5 -filetype=asm -o - %s | FileCheck %s --check-prefixes=ASM,ASM-5
+; RUN: %llc_dwarf -dwarf-version 4 -filetype=asm -o - %s | FileCheck %s --check-prefix=ASM-4
+; RUN: %llc_dwarf -dwarf-version 5 -filetype=asm -o - %s | FileCheck %s --check-prefix=ASM-5
 ; RUN: %llc_dwarf -dwarf-version 4 -filetype=obj -o %t4.o %s
 ; RUN: llvm-dwarfdump -debug-line %t4.o | FileCheck %s --check-prefix=OBJ
 ; RUN: %llc_dwarf -dwarf-version 5 -filetype=obj -o %t5.o %s
 ; RUN: llvm-dwarfdump -debug-line %t5.o | FileCheck %s --check-prefixes=OBJ,OBJ-5
 
 ; ASM-4-NOT: .file 0
-; ASM-5: .file 0 "/scratch{{.*[/\\]}}t.c" md5 0x00000000000000000000000000000000
-; ASM: .file 1 "/scratch{{.*[/\\]}}t1.h"
+; ASM-4: .file 1 "/scratch{{.*[/\\]}}t1.h"
 ; ASM-4-NOT:  md5
-; ASM-5-SAME: md5 0x11111111111111111111111111111111
-; ASM: .file 2 "/scratch{{.*[/\\]}}t2.h"
+; ASM-4: .file 2 "/scratch{{.*[/\\]}}t2.h"
 ; ASM-4-NOT:  md5
-; ASM-5-SAME: md5 0x22222222222222222222222222222222
+; ASM-5: .file 0 "/scratch{{.*[/\\]}}t.c" md5 0x00000000000000000000000000000000
+; ASM-5: .file 1 "t1.h" md5 0x11111111111111111111111111111111
+; ASM-5: .file 2 "t2.h" md5 0x22222222222222222222222222222222
 
 ; OBJ-5: file_names[ 0]:
 ; OBJ-5-NEXT: name: "t.c"
 ; OBJ-5-NEXT: dir_index: 0
 ; OBJ-5-NEXT: md5_checksum: 00000000000000000000000000000000
 ; OBJ: file_names[ 1]:
 ; OBJ-NEXT: name: "t1.h"
 ; OBJ-NEXT: dir_index: 0

llvm/trunk/test/CodeGen/Generic/dwarf-source.ll

 ; Source text provided by IR should be passed through to asm.
 ; It is emitted to an object file only for DWARF 5 or later.
 
 ; Darwin clamps the line table at DWARF v2 so XFAIL this test.
 ; XFAIL: darwin
 
 ; REQUIRES: object-emission
-; RUN: %llc_dwarf -dwarf-version 4 -filetype=asm -o - %s | FileCheck %s --check-prefix=ASM
-; RUN: %llc_dwarf -dwarf-version 5 -filetype=asm -o - %s | FileCheck %s --check-prefixes=ASM,ASM-5
+; RUN: %llc_dwarf -dwarf-version 4 -filetype=asm -o - %s | FileCheck %s --check-prefix=ASM-4
+; RUN: %llc_dwarf -dwarf-version 5 -filetype=asm -o - %s | FileCheck %s --check-prefix=ASM-5
 ; RUN: %llc_dwarf -dwarf-version 4 -filetype=obj -o %t4.o %s
 ; RUN: llvm-dwarfdump -debug-line %t4.o | FileCheck %s --check-prefixes=OBJ,OBJ-4
 ; RUN: %llc_dwarf -dwarf-version 5 -filetype=obj -o %t5.o %s
 ; RUN: llvm-dwarfdump -debug-line %t5.o | FileCheck %s --check-prefixes=OBJ,OBJ-5
 
+; ASM-4: .file 1 "/test{{.*[/\\]}}t1.h" source "11111111111111111111111111111111"
+; ASM-4: .file 2 "/test{{.*[/\\]}}t2.h" source "22222222222222222222222222222222"
 ; ASM-5: .file 0 "/test{{.*[/\\]}}t.c" source "00000000000000000000000000000000"
-; ASM: .file 1 "/test{{.*[/\\]}}t1.h" source "11111111111111111111111111111111"
-; ASM: .file 2 "/test{{.*[/\\]}}t2.h" source "22222222222222222222222222222222"
+; ASM-5: .file 1 "t1.h" source "11111111111111111111111111111111"
+; ASM-5: .file 2 "t2.h" source "22222222222222222222222222222222"
 
 ; OBJ-5: file_names[ 0]:
 ; OBJ-5-NEXT: name: "t.c"
 ; OBJ-5-NEXT: dir_index: 0
 ; OBJ-5-NEXT: source: "00000000000000000000000000000000"
 ; OBJ: file_names[ 1]:
 ; OBJ-NEXT: name: "t1.h"
 ; OBJ-NEXT: dir_index: 0

llvm/trunk/test/MC/ELF/debug-md5-err.s

 # CHECK: [[@LINE+1]]:{{[0-9]+}}: error: unknown token in expression
         .file 4 "dir3" "foo" md5 ffeeddccbbaa99887766554433221100
 
 # Non-DWARF .file syntax with checksum.
 # CHECK: [[@LINE+1]]:{{[0-9]+}}: error: MD5 checksum specified, but no file number
         .file "baz" md5 0xffeeddccbbaa99887766554433221100
 
 # Inconsistent use of MD5 option. Note: .file 1 did not supply one.
-# CHECK: [[@LINE+1]]:{{[0-9]+}}: error: inconsistent use of MD5 checksums
+# CHECK: [[@LINE+1]]:{{[0-9]+}}: warning: inconsistent use of MD5 checksums
         .file 5 "bax" md5 0xffeeddccbbaa99887766554433221100

llvm/trunk/test/MC/ELF/debug-mixed-md5.ll

+; RUN: %llc_dwarf -filetype=asm -dwarf-version=5 %s -o - | FileCheck %s -check-prefix=ASM
+; RUN: %llc_dwarf -filetype=obj -dwarf-version=5 %s -o - | llvm-dwarfdump -debug-line - | FileCheck %s -check-prefix=OBJ
+; ASM: .file 0 "{{.+}}" md5
+; ASM: .file 1 "{{.+}}" md5
+; ASM: .file 2 "t1.cpp"
+; ASM-NOT: md5
+; OBJ: file_names[ 0]:
+; OBJ-NOT: md5
+;
+; Generated from this source (see PR37623):
+;
+; #define a(...) template __VA_ARGS__;
+; template <class> class b {};
+; a(class b<int>)
+; # 1 ""
+; int c;
+
+; ModuleID = 't1.cpp'
+source_filename = "t1.cpp"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@c = global i32 0, align 4, !dbg !0
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!12, !13, !14}
+!llvm.ident = !{!15}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "c", scope: !2, file: !3, line: 1, type: !10, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 7.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !5, globals: !11)
+!3 = !DIFile(filename: "<stdin>", directory: "/home/probinson/projects/scratch", checksumkind: CSK_MD5, checksum: "9252ff18ee25a08c2b4216b21b5d66d4")
+!4 = !{}
+!5 = !{!6}
+!6 = distinct !DICompositeType(tag: DW_TAG_class_type, name: "b<int>", file: !7, line: 3, size: 8, flags: DIFlagTypePassByValue, elements: !4, templateParams: !8, identifier: "_ZTS1bIiE")
+!7 = !DIFile(filename: "t1.cpp", directory: "/home/probinson/projects/scratch")
+!8 = !{!9}
+!9 = !DITemplateTypeParameter(type: !10)
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!0}
+!12 = !{i32 2, !"Dwarf Version", i32 5}
+!13 = !{i32 2, !"Debug Info Version", i32 3}
+!14 = !{i32 1, !"wchar_size", i32 4}
+!15 = !{!"clang version 7.0.0 "}