Add support for SHA256 source file checksums in debug info

[arlosi]

Summary

LLVM currently supports CSK_MD5 and CSK_SHA1 source file checksums in debug info. This change adds support for CSK_SHA256 checksums.

The SHA256 checksums are supported by the CodeView debug format.

[aprantl]

Sounds reasonable. One inline question about the test.

llvm/test/Bitcode/upgrade-dbg-checksum.ll

13 ↗

(On Diff #248857)

I would expect a round-trip (as | dis | as |dis) test rather than an upgrade test when adding an extra enumerator. What am I missing?

[arlosi]

Change the test from editing an upgrade test to a new round trip test.

[aprantl]

llvm/test/Bitcode/round-trip-dbg-checksum.ll

1 ↗

(On Diff #248871)

Please move this to the /Assembler directory, rename it to dbg-checksum.ll, and make the RUN line:
RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis FileCheck %s

[arlosi]

Renamed test to appropriate location; modified test to test to disassemble and reassemble again.

[arlosi]

I do not have commit access. Could someone land this for me?

[arlosi]

The previous update contained only the requested changes commit, losing the rest of the change.
Hopefully I've correctly used arc to create the diff this time.

[arlosi]

Fix clang-tidy errors.

[rnk]

In D75785#1913551, @arlosi wrote:

I do not have commit access. Could someone land this for me?

Sure, thanks for the patch!

llvm/docs/LangRef.rst

 .. code-block:: none
 
     !0 = !DIFile(filename: "path/to/file", directory: "/path/to/dir",
                  checksumkind: CSK_MD5,
                  checksum: "000102030405060708090a0b0c0d0e0f")
 
 Files are sometimes used in ``scope:`` fields, and are the only valid target
 for ``file:`` fields.
-Valid values for ``checksumkind:`` field are: {CSK_None, CSK_MD5, CSK_SHA1}
+Valid values for ``checksumkind:`` field are: {CSK_None, CSK_MD5, CSK_SHA1, CSK_SHA256}
 
 .. _DIBasicType:
 
 DIBasicType
 """""""""""
 
 ``DIBasicType`` nodes represent primitive types, such as ``int``, ``bool`` and
 ``float``. ``tag:`` defaults to ``DW_TAG_base_type``.

llvm/include/llvm/IR/DebugInfoMetadata.h

public:
   /// value 0 is reserved to indicate the absence of a checksum in Bitcode.
   enum ChecksumKind {
     // The first variant was originally CSK_None, encoded as 0. The new
     // internal representation removes the need for this by wrapping the
     // ChecksumInfo in an Optional, but to preserve Bitcode compatibility the 0
     // encoding is reserved.
     CSK_MD5 = 1,
     CSK_SHA1 = 2,
-    CSK_Last = CSK_SHA1 // Should be last enumeration.
+    CSK_SHA256 = 3,
+    CSK_Last = CSK_SHA256 // Should be last enumeration.
   };
 
   /// A single checksum, represented by a \a Kind and a \a Value (a string).
   template <typename T>
   struct ChecksumInfo {
     /// The kind of checksum which \a Value encodes.
     ChecksumKind Kind;
     /// The string value of the checksum.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

if (Insertion.second) {
     FileChecksumKind CSKind = FileChecksumKind::None;
     if (F->getChecksum()) {
       std::string Checksum = fromHex(F->getChecksum()->Value);
       void *CKMem = OS.getContext().allocate(Checksum.size(), 1);
       memcpy(CKMem, Checksum.data(), Checksum.size());
       ChecksumAsBytes = ArrayRef<uint8_t>(
           reinterpret_cast<const uint8_t *>(CKMem), Checksum.size());
       switch (F->getChecksum()->Kind) {
-      case DIFile::CSK_MD5:  CSKind = FileChecksumKind::MD5; break;
-      case DIFile::CSK_SHA1: CSKind = FileChecksumKind::SHA1; break;
+      case DIFile::CSK_MD5:
+        CSKind = FileChecksumKind::MD5;
+        break;
+      case DIFile::CSK_SHA1:
+        CSKind = FileChecksumKind::SHA1;
+        break;
+      case DIFile::CSK_SHA256:
+        CSKind = FileChecksumKind::SHA256;
+        break;
       }
     }
     bool Success = OS.EmitCVFileDirective(NextId, FullPath, ChecksumAsBytes,
                                           static_cast<unsigned>(CSKind));
     (void)Success;
     assert(Success && ".cv_file directive failed");
   }
   return Insertion.first->second;

llvm/lib/IR/DebugInfoMetadata.cpp

DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context, DIFlags Flags,
   DEFINE_GETIMPL_LOOKUP(DISubroutineType, (Flags, CC, TypeArray));
   Metadata *Ops[] = {nullptr, nullptr, nullptr, TypeArray};
   DEFINE_GETIMPL_STORE(DISubroutineType, (Flags, CC), Ops);
 }
 
 // FIXME: Implement this string-enum correspondence with a .def file and macros,
 // so that the association is explicit rather than implied.
 static const char *ChecksumKindName[DIFile::CSK_Last] = {
     "CSK_MD5",
-  "CSK_SHA1"
+    "CSK_SHA1",
+    "CSK_SHA256",
 };
 
 StringRef DIFile::getChecksumKindAsString(ChecksumKind CSKind) {
   assert(CSKind <= DIFile::CSK_Last && "Invalid checksum kind");
   // The first space was originally the CSK_None variant, which is now
   // obsolete, but the space is still reserved in ChecksumKind, so we account
   // for it here.
   return ChecksumKindName[CSKind - 1];
 }
 
 Optional<DIFile::ChecksumKind> DIFile::getChecksumKind(StringRef CSKindStr) {
   return StringSwitch<Optional<DIFile::ChecksumKind>>(CSKindStr)
       .Case("CSK_MD5", DIFile::CSK_MD5)
       .Case("CSK_SHA1", DIFile::CSK_SHA1)
+      .Case("CSK_SHA256", DIFile::CSK_SHA256)
       .Default(None);
 }
 
 DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename,
                         MDString *Directory,
                         Optional<DIFile::ChecksumInfo<MDString *>> CS,
                         Optional<MDString *> Source, StorageType Storage,
                         bool ShouldCreate) {

llvm/lib/IR/Verifier.cpp

if (Checksum) {
     size_t Size;
     switch (Checksum->Kind) {
     case DIFile::CSK_MD5:
       Size = 32;
       break;
     case DIFile::CSK_SHA1:
       Size = 40;
       break;
+    case DIFile::CSK_SHA256:
+      Size = 64;
+      break;
     }
     AssertDI(Checksum->Value.size() == Size, "invalid checksum length", &N);
     AssertDI(Checksum->Value.find_if_not(llvm::isHexDigit) == StringRef::npos,
              "invalid checksum", &N);
   }
 }
 
 void Verifier::visitDICompileUnit(const DICompileUnit &N) {

llvm/test/Assembler/dbg-checksum.ll

+; Test that DIFile(checksumkind, checksum) can round-trip through bitcode.
+;
+; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
+
+!llvm.dbg.cu = !{!1, !2, !3, !4}
+!llvm.module.flags = !{!9}
+
+!1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !5, isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !6, isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)
+!3 = distinct !DICompileUnit(language: DW_LANG_C99, file: !7, isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)
+!4 = distinct !DICompileUnit(language: DW_LANG_C99, file: !8, isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)
+; CHECK: !DIFile(filename: "a.h", directory: "/test")
+!5 = !DIFile(filename: "a.h", directory: "/test")
+; CHECK: !DIFile(filename: "b.h", directory: "/test", checksumkind: CSK_MD5, checksum: "595f44fec1e92a71d3e9e77456ba80d1")
+!6 = !DIFile(filename: "b.h", directory: "/test", checksumkind: CSK_MD5, checksum: "595f44fec1e92a71d3e9e77456ba80d1")
+; CHECK: !DIFile(filename: "c.h", directory: "/test", checksumkind: CSK_SHA1, checksum: "d5db29cd03a2ed055086cef9c31c252b4587d6d0")
+!7 = !DIFile(filename: "c.h", directory: "/test", checksumkind: CSK_SHA1, checksum: "d5db29cd03a2ed055086cef9c31c252b4587d6d0")
+; CHECK: !DIFile(filename: "d.h", directory: "/test", checksumkind: CSK_SHA256, checksum: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
+!8 = !DIFile(filename: "d.h", directory: "/test", checksumkind: CSK_SHA256, checksum: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
+!9 = !{i32 2, !"Debug Info Version", i32 3}