Generate DXIL Shader hash

[beanz]

Summary

DXIL shader bitcode is hashed and the hash is placed into the final
output object file in its own data part.

This change modifies the DXContainerGlobals pass to compute the shader
hash (just an MD5 of the bitcode) and put the shader hash data into a
global for the HASH part.

This also sets the hash flag as appropriate for if the hashed shader
contained debug information. There is additional handling required to
get debug information in shaders working correctly with our tooling,
but that will be addressed in subsequent patches.

[beanz]

Need to byte-swap the hash structure on big endian hosts so that it is encoded as little-endian.

llvm/lib/Target/DirectX/DXContainerGlobals.cpp

 //===- DXContainerGlobals.cpp - DXContainer global generator pass ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // DXContainerGlobalsPass implementation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DXILShaderFlags.h"
 #include "DirectX.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/DXContainer.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
+#include "llvm/Support/MD5.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 
 using namespace llvm;
 using namespace llvm::dxil;
 
 namespace {
 class DXContainerGlobals : public llvm::ModulePass {
 
+  GlobalVariable *getShaderFlags(Module &M);
+  GlobalVariable *computeShaderHash(Module &M);
+
 public:
   static char ID; // Pass identification, replacement for typeid
   DXContainerGlobals() : ModulePass(ID) {
     initializeDXContainerGlobalsPass(*PassRegistry::getPassRegistry());
   }
 
   StringRef getPassName() const override {
     return "DXContainer Global Emitter";
   }
 
   bool runOnModule(Module &M) override;
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
     AU.addRequired<ShaderFlagsAnalysisWrapper>();
   }
 };
 
 } // namespace
 
 bool DXContainerGlobals::runOnModule(Module &M) {
+  llvm::SmallVector<GlobalValue *> Globals;
+  Globals.push_back(getShaderFlags(M));
+  Globals.push_back(computeShaderHash(M));
+
+  appendToCompilerUsed(M, Globals);
+  return true;
+}
+
+GlobalVariable *DXContainerGlobals::getShaderFlags(Module &M) {
   const uint64_t Flags =
       (uint64_t)(getAnalysis<ShaderFlagsAnalysisWrapper>().getShaderFlags());
 
   Constant *FlagsConstant = ConstantInt::get(M.getContext(), APInt(64, Flags));
   auto *GV = new llvm::GlobalVariable(M, FlagsConstant->getType(), true,
                                       GlobalValue::PrivateLinkage,
                                       FlagsConstant, "dx.sfi0");
   GV->setSection("SFI0");
   GV->setAlignment(Align(4));
-  appendToCompilerUsed(M, {GV});
-  return true;
+  return GV;
+}
+
+GlobalVariable *DXContainerGlobals::computeShaderHash(Module &M) {
+  auto *DXILConstant =
+      cast<ConstantDataArray>(M.getNamedGlobal("dx.dxil")->getInitializer());
+  MD5 Digest;
+  Digest.update(DXILConstant->getRawDataValues());
+  MD5::MD5Result Result = Digest.final();
+
+  dxbc::ShaderHash HashData = {0, {0}};
+  // The Hash's IncludesSource flag gets set whenever the hashed shader includes
+  // debug information.
+  if (M.debug_compile_units_begin() != M.debug_compile_units_end())
+    HashData.Flags = static_cast<uint32_t>(dxbc::HashFlags::IncludesSource);
+
+  memcpy(reinterpret_cast<void *>(&HashData.Digest), Result.data(), 16);
+  if (sys::IsBigEndianHost)
+    HashData.swapBytes();
+  StringRef Data(reinterpret_cast<char *>(&HashData), sizeof(dxbc::ShaderHash));
+
+  Constant *ModuleConstant =
+      ConstantDataArray::get(M.getContext(), arrayRefFromStringRef(Data));
+  auto *GV = new llvm::GlobalVariable(M, ModuleConstant->getType(), true,
+                                      GlobalValue::PrivateLinkage,
+                                      ModuleConstant, "dx.hash");
+  GV->setSection("HASH");
+  GV->setAlignment(Align(4));
+  return GV;
 }
 
 char DXContainerGlobals::ID = 0;
 INITIALIZE_PASS_BEGIN(DXContainerGlobals, "dxil-globals",
                       "DXContainer Global Emitter", false, true)
 INITIALIZE_PASS_DEPENDENCY(ShaderFlagsAnalysisWrapper)
 INITIALIZE_PASS_END(DXContainerGlobals, "dxil-globals",
                     "DXContainer Global Emitter", false, true)
 
 ModulePass *llvm::createDXContainerGlobalsPass() {
   return new DXContainerGlobals();
 }

llvm/test/CodeGen/DirectX/ContainerData/DebugShaderHash.ll

+; RUN: llc %s --filetype=asm -o - | FileCheck %s
+; RUN: llc %s --filetype=obj -o - | obj2yaml | FileCheck %s --check-prefix=DXC
+target triple = "dxil-unknown-shadermodel6.5-library"
+
+; CHECK: @dx.hash = private constant [20 x i8] c"\01\00\00\00{{.*}}", section "HASH", align 4
+
+define i32 @add(i32 %a, i32 %b) {
+  %sum = add i32 %a, %b
+  ret i32 %sum
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "Some Compiler", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "hlsl.hlsl", directory: "/some-path")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 2}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+
+; DXC: - Name:            HASH
+; DXC:   Size:            28
+; DXC:   Hash:
+; DXC:     IncludesSource:  true
+; DXC:     Digest:          [ 

llvm/test/CodeGen/DirectX/ContainerData/ShaderHash.ll

+; RUN: llc %s --filetype=asm -o - | FileCheck %s
+; RUN: llc %s --filetype=obj -o - | obj2yaml | FileCheck %s --check-prefix=DXC
+target triple = "dxil-unknown-shadermodel6.5-library"
+
+; CHECK: @dx.hash = private constant [20 x i8] c"\00\00\00\00{{.*}}", section "HASH", align 4
+
+define i32 @add(i32 %a, i32 %b) {
+  %sum = add i32 %a, %b
+  ret i32 %sum
+}
+
+; DXC: - Name:            HASH
+; DXC:   Size:            28
+; DXC:   Hash:
+; DXC:     IncludesSource:  false
+; DXC:     Digest:          [