DebugInfo: Added support for Checksum debug info feature (Clang part)

[aaboud]

Summary

Resolve Bug 30978.

This patch contains changes in Clang to support Checksum debug info feature.

[rnk]

lib/Basic/SourceManager.cpp

1447

Let's move this whole thing to CGDebugInfo::getOrCreateFile. SourceManager isn't caching or managing MD5 checksums at all in this CL.

1450–1451

If this can fail, we should not pretend to have an MD5 checksum in the debug info.

1461

This can use SmallString and stringifyResult() to avoid heap allocations.

lib/CodeGen/CGDebugInfo.cpp

350

We should only do this if CGM.getCodeGenOpts().EmitCodeView, or we will regress compile time on other platforms without any added functionality.

[probinson]

lib/CodeGen/CGDebugInfo.cpp

350

Eventually we'll want it for DWARF 5 also, but for now conditioning on CodeView is fine.

[aaboud]

Moved getChecksum from SourceManager to CGDebugInfo.
Also, now checksum is emitted only for CodeView.

[rnk]

test/CodeGen/debug-info-file-checksum.c

2

Instead of %s.source, you can do %S/Inputs/debug-info-file-checksum.c.

test/CodeGen/debug-info-file-checksum.c.source

2

This can live in test/CodeGen/Inputs/debug-info-file-checksum.c

[majnemer]

lib/CodeGen/CGDebugInfo.cpp

408–409

Formatting looks wrong

[aaboud]

Addressed comments by Reid and David.

[rnk]

This side looks good.

lib/CodeGen/CGDebugInfo.cpp

324

This is uncached. Maybe call it computeChecksum to indicate that it is expensive?

include/clang/Basic/SourceManager.h

public:
 
   /// \brief Return the filename or buffer identifier of the buffer the
   /// location is in.
   ///
   /// Note that this name does not respect \#line directives.  Use
   /// getPresumedLoc for normal clients.
   StringRef getBufferName(SourceLocation Loc, bool *Invalid = nullptr) const;
 
+  /// Return the checksum of the given file in MD5 format.
+  void getChecksumMD5(FileID FID, std::string &Checksum) const;
+
   /// \brief Return the file characteristic of the specified source
   /// location, indicating whether this is a normal file, a system
   /// header, or an "implicit extern C" system header.
   ///
   /// This state can be modified with flags on GNU linemarker directives like:
   /// \code
   ///   # 4 "foo.h" 3
   /// \endcode

lib/Basic/SourceManager.cpp

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManagerInternals.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Capacity.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/MD5.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstring>
 
 using namespace clang;
 using namespace SrcMgr;

 /// for normal clients.
 StringRef SourceManager::getBufferName(SourceLocation Loc,
                                        bool *Invalid) const {
   if (isInvalid(Loc, Invalid)) return "<invalid loc>";
 
   return getBuffer(getFileID(Loc), Invalid)->getBufferIdentifier();
 }
 
+void SourceManager::getChecksumMD5(FileID FID, std::string &Checksum) const {
+  bool Invalid;
+
+  llvm::MemoryBuffer *MemBuffer = getBuffer(FID, &Invalid);
+  if (Invalid) return;
+
+  llvm::MD5 Hash;
+  llvm::MD5::MD5Result Result;
+
+  Hash.update(MemBuffer->getBuffer());
+  Hash.final(Result);
+
+  llvm::raw_string_ostream OS(Checksum);
+
+  for (unsigned i = 0; i < sizeof(Result); i++)
+    OS << llvm::format("%02x", Result[i]);
+}
+
 
 /// getPresumedLoc - This method returns the "presumed" location of a
 /// SourceLocation specifies.  A "presumed location" can be modified by \#line
 /// or GNU line marker directives.  This provides a view on the data that a
 /// user should see in diagnostics, for example.
 ///
 /// Note that a presumed location is always given as the expansion point of an
 /// expansion location, not at the spelling location.

lib/CodeGen/CGDebugInfo.cpp

if (CGM.getLangOpts().CPlusPlus) {
       }
     }
   }
 
   return StringRef();
 }
 
 llvm::DIFile *CGDebugInfo::getOrCreateFile(SourceLocation Loc) {
   if (!Loc.isValid())
     // If Location is not valid then use main input file.
     return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
-                               remapDIPath(TheCU->getDirectory()));
+                               remapDIPath(TheCU->getDirectory()),
+                               TheCU->getChecksum());
 
   SourceManager &SM = CGM.getContext().getSourceManager();
   PresumedLoc PLoc = SM.getPresumedLoc(Loc);
 
   if (PLoc.isInvalid() || StringRef(PLoc.getFilename()).empty())
     // If the location is not valid then use main input file.
     return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
-                               remapDIPath(TheCU->getDirectory()));
+                               remapDIPath(TheCU->getDirectory()),
+                               TheCU->getChecksum());
 
   // Cache the results.
   const char *fname = PLoc.getFilename();
   auto it = DIFileCache.find(fname);
 
   if (it != DIFileCache.end()) {
     // Verify that the information still exists.
     if (llvm::Metadata *V = it->second)
       return cast<llvm::DIFile>(V);
   }
 
+  std::string Checksum;
+  SM.getChecksumMD5(SM.getFileID(Loc), Checksum);
+
+  llvm::DIChecksum *C =
+      DBuilder.createChecksum(llvm::DIChecksum::MD5, Checksum);
+
   llvm::DIFile *F = DBuilder.createFile(remapDIPath(PLoc.getFilename()),
-                                        remapDIPath(getCurrentDirname()));
+                                        remapDIPath(getCurrentDirname()), C);
 
   DIFileCache[fname].reset(F);
   return F;
 }
 
 llvm::DIFile *CGDebugInfo::getOrCreateMainFile() {
   return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
-                             remapDIPath(TheCU->getDirectory()));
+                             remapDIPath(TheCU->getDirectory()),
+                             TheCU->getChecksum());
 }
 
 std::string CGDebugInfo::remapDIPath(StringRef Path) const {
   for (const auto &Entry : DebugPrefixMap)
     if (Path.startswith(Entry.first))
       return (Twine(Entry.second) + Path.substr(Entry.first.size())).str();
   return Path.str();
 }
StringRef CGDebugInfo::getCurrentDirname() {
   if (!CWDName.empty())
     return CWDName;
   SmallString<256> CWD;
   llvm::sys::fs::current_path(CWD);
   return CWDName = internString(CWD);
 }
 
 void CGDebugInfo::CreateCompileUnit() {
+  std::string Checksum;
 
   // Should we be asking the SourceManager for the main file name, instead of
   // accepting it as an argument? This just causes the main file name to
   // mismatch with source locations and create extra lexical scopes or
   // mismatched debug info (a CU with a DW_AT_file of "-", because that's what
   // the driver passed, but functions/other things have DW_AT_file of "<stdin>"
   // because that's what the SourceManager says)
 
   // Get absolute path name.
void CGDebugInfo::CreateCompileUnit() {
   std::string MainFileDir;
   if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
     MainFileDir = remapDIPath(MainFile->getDir()->getName());
     if (MainFileDir != ".") {
       llvm::SmallString<1024> MainFileDirSS(MainFileDir);
       llvm::sys::path::append(MainFileDirSS, MainFileName);
       MainFileName = MainFileDirSS.str();
     }
+    SM.getChecksumMD5(SM.getMainFileID(), Checksum);
   }
 
   llvm::dwarf::SourceLanguage LangTag;
   const LangOptions &LO = CGM.getLangOpts();
   if (LO.CPlusPlus) {
     if (LO.ObjC1)
       LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
     else
case codegenoptions::FullDebugInfo:
     EmissionKind = llvm::DICompileUnit::FullDebug;
     break;
   }
 
   // Create new compile unit.
   // FIXME - Eliminate TheCU.
   TheCU = DBuilder.createCompileUnit(
       LangTag, remapDIPath(MainFileName), remapDIPath(getCurrentDirname()),
-      Producer, LO.Optimize, CGM.getCodeGenOpts().DwarfDebugFlags, RuntimeVers,
+      llvm::DIChecksum::MD5, Checksum, Producer, LO.Optimize,
+      CGM.getCodeGenOpts().DwarfDebugFlags, RuntimeVers,
       CGM.getCodeGenOpts().SplitDwarfFile, EmissionKind, 0 /* DWOid */,
       CGM.getCodeGenOpts().SplitDwarfInlining);
 }
 
 llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
   llvm::dwarf::TypeKind Encoding;
   StringRef BTName;
   switch (BT->getKind()) {
CGDebugInfo::getOrCreateModuleRef(ExternalASTSource::ASTSourceDescriptor Mod,
 
   bool IsRootModule = M ? !M->Parent : true;
   if (CreateSkeletonCU && IsRootModule) {
     // PCH files don't have a signature field in the control block,
     // but LLVM detects skeleton CUs by looking for a non-zero DWO id.
     uint64_t Signature = Mod.getSignature() ? Mod.getSignature() : ~1ULL;
     llvm::DIBuilder DIB(CGM.getModule());
     DIB.createCompileUnit(TheCU->getSourceLanguage(), Mod.getModuleName(),
-                          Mod.getPath(), TheCU->getProducer(), true,
-                          StringRef(), 0, Mod.getASTFile(),
-                          llvm::DICompileUnit::FullDebug, Signature);
+                          Mod.getPath(), llvm::DIChecksum::None, "",
+                          TheCU->getProducer(), true, StringRef(), 0,
+                          Mod.getASTFile(), llvm::DICompileUnit::FullDebug,
+                          Signature);
     DIB.finalize();
   }
   llvm::DIModule *Parent =
       IsRootModule ? nullptr
                    : getOrCreateModuleRef(
                          ExternalASTSource::ASTSourceDescriptor(*M->Parent),
                          CreateSkeletonCU);
   llvm::DIModule *DIMod =

test/CodeGen/debug-info-atomic.c

 // RUN: %clang -g -c -std=c11 -S -emit-llvm -o - %s | FileCheck %s
 
-// CHECK: !DIGlobalVariable(name: "i"{{.*}}type: !5, isLocal: false, isDefinition: true)
-// CHECK: !5 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !6)
-// CHECK: !6 = !DIDerivedType(tag: DW_TAG_atomic_type, baseType: !7)
-// CHECK: !7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+// CHECK: !DIGlobalVariable(name: "i"{{.*}}type: [[CONST:![0-9]+]], isLocal: false, isDefinition: true)
+// CHECK: [[CONST]] = !DIDerivedType(tag: DW_TAG_const_type, baseType: [[ATOMIC:![0-9]+]])
+// CHECK: [[ATOMIC]] = !DIDerivedType(tag: DW_TAG_atomic_type, baseType: [[INT32:![0-9]+]])
+// CHECK: [[INT32]] = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 _Atomic const int i;

test/CodeGen/debug-info-file-checksum.c

+// RUN: %clang -emit-llvm -S -g -x c %s.source -o - | FileCheck %s
+
+// Check that "checksum" is created correctly for the compiled file.
+
+// CHECK: !DIFile(filename:{{.*}}, directory:{{.*}}, checksum: [[CHECKSUM:![0-9]+]])
+// CHECK: [[CHECKSUM]] = !DIChecksum(type: ChecksumType_MD5, data: "a3b7d27af071accdeccaa933fc603608")

test/CodeGen/debug-info-file-checksum.c.source

+int foo(int x) {
+  return x+1;
+}

test/CodeGen/debug-prefix-map.c

 // CHECK-EVIL: !DIFile(filename: "/var=empty{{[/\\]}}{{.*}}"
 // CHECK-EVIL: !DIFile(filename: "/var=empty{{[/\\]}}Inputs/stdio.h"
 // CHECK-EVIL-NOT: !DIFile(filename:
 
 // CHECK: !DIFile(filename: "/var/empty{{[/\\]}}{{.*}}"
 // CHECK: !DIFile(filename: "/var/empty{{[/\\]}}Inputs/stdio.h"
 // CHECK-NOT: !DIFile(filename:
 
-// CHECK-COMPILATION-DIR: !DIFile(filename: "/var/empty{{[/\\]}}{{.*}}", directory: "/var/empty")
-// CHECK-COMPILATION-DIR: !DIFile(filename: "/var/empty{{[/\\]}}Inputs/stdio.h", directory: "/var/empty")
+// CHECK-COMPILATION-DIR: !DIFile(filename: "/var/empty{{[/\\]}}{{.*}}", directory: "/var/empty"
+// CHECK-COMPILATION-DIR: !DIFile(filename: "/var/empty{{[/\\]}}Inputs/stdio.h", directory: "/var/empty"
 // CHECK-COMPILATION-DIR-NOT: !DIFile(filename:

test/PCH/debug-info-pch-path.c

 // RUN:     -triple %itanium_abi_triple                         \
 // RUN:     -include-pch prefix.pch %s -emit-llvm -o %t.nodir.ll %s
 // RUN: cat %t.nodir.ll | FileCheck %s --check-prefix=CHECK-REL-NODIR
 //
 //
 // CHECK-REL-NODIR: !DICompileUnit
 // CHECK-REL-NODIR-SAME:           file: ![[C:[0-9]+]]
 // CHECK-REL-NODIR-NOT: dwoId
-// CHECK-REL-NODIR: ![[C]] = !DIFile({{.*}}directory: "[[DIR:.*]]"
+// CHECK-REL-NODIR: ![[C]] = !DIFile({{.*}}directory: "[[DIR:.*]]",
 // CHECK-REL-NODIR: !DICompileUnit(
 // CHECK-REL-NODIR-SAME:           file: ![[PCH:[0-9]+]]
 // CHECK-REL-NODIR-SAME:           splitDebugFilename: "prefix.pch"
 // CHECK-REL-NODIR: ![[PCH]] = !DIFile({{.*}}directory: "[[DIR]]"
 
 // ---------------------------------------------------------------------
 // Relative PCH in a subdirectory.
 // ---------------------------------------------------------------------
 //
 // RUN: mkdir pchdir
 // RUN: %clang_cc1 -fmodule-format=obj -emit-pch                \
 // RUN:     -triple %itanium_abi_triple                         \
 // RUN:     -o pchdir/prefix.pch %S/debug-info-limited-struct.h
 //
 // RUN: %clang_cc1 -debug-info-kind=standalone                  \
 // RUN:     -dwarf-ext-refs -fmodule-format=obj                 \
 // RUN:     -triple %itanium_abi_triple                         \
 // RUN:     -include-pch pchdir/prefix.pch %s -emit-llvm -o %t.rel.ll %s
 // RUN: cat %t.rel.ll | FileCheck %s --check-prefix=CHECK-REL
 
 // CHECK-REL: !DICompileUnit
 // CHECK-REL-SAME:           file: ![[C:[0-9]+]]
 // CHECK-REL-NOT: dwoId
-// CHECK-REL: ![[C]] = !DIFile({{.*}}directory: "[[DIR:.*]]"
+// CHECK-REL: ![[C]] = !DIFile({{.*}}directory: "[[DIR:.*]]",
 // CHECK-REL: !DICompileUnit(
 // CHECK-REL-SAME:           file: ![[PCH:[0-9]+]]
 // CHECK-REL-SAME:           splitDebugFilename: "prefix.pch"
 // CHECK-REL: ![[PCH]] = !DIFile({{.*}}directory: "[[DIR]]{{.*}}pchdir"
 
 // ---------------------------------------------------------------------
 // Absolute PCH.
 // ---------------------------------------------------------------------
 //
 // RUN: %clang_cc1 -fmodule-format=obj -emit-pch                \
 // RUN:     -triple %itanium_abi_triple                         \
 // RUN:     -o %t/prefix.pch %S/debug-info-limited-struct.h
 //
 // RUN: %clang_cc1 -debug-info-kind=standalone                  \
 // RUN:     -dwarf-ext-refs -fmodule-format=obj                 \
 // RUN:     -triple %itanium_abi_triple                         \
 // RUN:     -include-pch %t/prefix.pch %s -emit-llvm -o %t.abs.ll %s
 // RUN: cat %t.abs.ll | FileCheck %s --check-prefix=CHECK-ABS
 
 // CHECK-ABS: !DICompileUnit
 // CHECK-ABS-SAME:           file: ![[C:[0-9]+]]
 // CHECK-ABS-NOT: dwoId
-// CHECK-ABS: ![[C]] = !DIFile({{.*}}directory: "[[DIR:.*]]"
+// CHECK-ABS: ![[C]] = !DIFile({{.*}}directory: "[[DIR:.*]]",
 // CHECK-ABS: !DICompileUnit(
 // CHECK-ABS-SAME:           file: ![[PCH:[0-9]+]]
 // CHECK-ABS-SAME:           splitDebugFilename: "prefix.pch"
 // CHECK-ABS: ![[PCH]] = !DIFile({{.*}}directory: "[[DIR]]"