Implement ResMayNotAlias DXIL shader flag analysis

Author: Icohedron

clang/include/clang/Basic/CodeGenOptions.def

@@ -476,6 +476,9 @@ CODEGENOPT(ImportCallOptimization, 1, 0)
 /// (BlocksRuntime) on Windows.
 CODEGENOPT(StaticClosure, 1, 0)
 
+/// Assume that UAVs/SRVs may alias
+CODEGENOPT(ResMayAlias, 1, 0)
+
 /// FIXME: Make DebugOptions its own top-level .def file.
 #include "DebugOptions.def"
 

clang/include/clang/Driver/Options.td

@@ -9043,6 +9043,11 @@ def dxil_validator_version : Option<["/", "-"], "validator-version", KIND_SEPARA
   HelpText<"Override validator version for module. Format: <major.minor>;"
            "Default: DXIL.dll version or current internal version">,
   MarshallingInfoString<TargetOpts<"DxilValidatorVersion">, "\"1.8\"">;
+def res_may_alias : Option<["/", "-"], "res-may-alias", KIND_FLAG>,
+  Group<dxc_Group>, Flags<[HelpHidden]>,
+  Visibility<[DXCOption, ClangOption, CC1Option]>,
+  HelpText<"Assume that UAVs/SRVs may alias">,
+  MarshallingInfoFlag<CodeGenOpts<"ResMayAlias">>;
 def target_profile : DXCJoinedOrSeparate<"T">, MetaVarName<"<profile>">,
   HelpText<"Set target profile">,
   Values<"ps_6_0, ps_6_1, ps_6_2, ps_6_3, ps_6_4, ps_6_5, ps_6_6, ps_6_7,"

clang/lib/CodeGen/CGHLSLRuntime.cpp

@@ -283,10 +283,13 @@ void CGHLSLRuntime::addHLSLBufferLayoutType(const RecordType *StructType,
 
 void CGHLSLRuntime::finishCodeGen() {
   auto &TargetOpts = CGM.getTarget().getTargetOpts();
+  auto &CodeGenOpts = CGM.getCodeGenOpts();
   llvm::Module &M = CGM.getModule();
   Triple T(M.getTargetTriple());
   if (T.getArch() == Triple::ArchType::dxil)
     addDxilValVersion(TargetOpts.DxilValidatorVersion, M);
+  if (CodeGenOpts.ResMayAlias)
+    M.setModuleFlag(llvm::Module::ModFlagBehavior::Error, "dx.resmayalias", 1);
 
   generateGlobalCtorDtorCalls();
 }

clang/lib/Driver/ToolChains/Clang.cpp

@@ -3959,6 +3959,7 @@ static void RenderOpenCLOptions(const ArgList &Args, ArgStringList &CmdArgs,
 static void RenderHLSLOptions(const ArgList &Args, ArgStringList &CmdArgs,
                               types::ID InputType) {
   const unsigned ForwardedArguments[] = {options::OPT_dxil_validator_version,
+                                         options::OPT_res_may_alias,
                                          options::OPT_D,
                                          options::OPT_I,
                                          options::OPT_O,

clang/test/CodeGenHLSL/res-may-alias.hlsl

@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -res-may-alias -finclude-default-header -triple dxil-pc-shadermodel6.3-library -emit-llvm -disable-llvm-passes -o - %s | FileCheck %s --check-prefix=FLAG
+// RUN: %clang_cc1 -finclude-default-header -triple dxil-pc-shadermodel6.3-library -emit-llvm -disable-llvm-passes -o - %s | FileCheck %s --check-prefix=NOFLAG
+
+// FLAG-DAG: ![[RMA:.*]] = !{i32 1, !"dx.resmayalias", i32 1}
+// FLAG-DAG: !llvm.module.flags = !{{{.*}}![[RMA]]{{.*}}}
+
+// NOFLAG-NOT: dx.resmayalias

llvm/lib/Target/DirectX/DXILShaderFlags.cpp

@@ -74,7 +74,8 @@ static bool checkWaveOps(Intrinsic::ID IID) {
 /// \param I Instruction to check.
 void ModuleShaderFlags::updateFunctionFlags(ComputedShaderFlags &CSF,
                                             const Instruction &I,
-                                            DXILResourceTypeMap &DRTM) {
+                                            DXILResourceTypeMap &DRTM,
+                                            const ModuleMetadataInfo &MMDI) {
   if (!CSF.Doubles)
     CSF.Doubles = I.getType()->isDoubleTy();
 
@@ -116,8 +117,17 @@ void ModuleShaderFlags::updateFunctionFlags(ComputedShaderFlags &CSF,
     switch (II->getIntrinsicID()) {
     default:
       break;
-    case Intrinsic::dx_resource_handlefrombinding:
-      switch (DRTM[cast<TargetExtType>(II->getType())].getResourceKind()) {
+    case Intrinsic::dx_resource_handlefrombinding: {
+      dxil::ResourceTypeInfo &RTI = DRTM[cast<TargetExtType>(II->getType())];
+
+      // If -res-may-alias is NOT specified, and DXIL Ver > 1.7.
+      // Then set ResMayNotAlias if function uses UAVs.
+      if (!CSF.ResMayNotAlias && !ResMayAlias &&
+          MMDI.DXILVersion > VersionTuple(1, 7) && RTI.isUAV()) {
+        CSF.ResMayNotAlias = true;
+      }
+
+      switch (RTI.getResourceKind()) {
       case dxil::ResourceKind::StructuredBuffer:
       case dxil::ResourceKind::RawBuffer:
         CSF.EnableRawAndStructuredBuffers = true;
@@ -126,6 +136,7 @@ void ModuleShaderFlags::updateFunctionFlags(ComputedShaderFlags &CSF,
         break;
       }
       break;
+    }
     case Intrinsic::dx_resource_load_typedbuffer: {
       dxil::ResourceTypeInfo &RTI =
           DRTM[cast<TargetExtType>(II->getArgOperand(0)->getType())];
@@ -151,7 +162,17 @@ void ModuleShaderFlags::updateFunctionFlags(ComputedShaderFlags &CSF,
 
 /// Construct ModuleShaderFlags for module Module M
 void ModuleShaderFlags::initialize(Module &M, DXILResourceTypeMap &DRTM,
+                                   DXILBindingMap &DBM,
                                    const ModuleMetadataInfo &MMDI) {
+
+  // Check if -res-may-alias was provided on the command line.
+  // The command line option will set the dx.resmayalias module flag to 1.
+  if (auto *RMA = mdconst::extract_or_null<ConstantInt>(
+          M.getModuleFlag("dx.resmayalias"))) {
+    if (RMA->getValue() != 0)
+      ResMayAlias = true;
+  }
+
   CallGraph CG(M);
 
   // Compute Shader Flags Mask for all functions using post-order visit of SCC
@@ -176,10 +197,16 @@ void ModuleShaderFlags::initialize(Module &M, DXILResourceTypeMap &DRTM,
         continue;
       }
 
+      // If -res-may-alias is NOT specified, and DXIL Ver <= 1.7.
+      // Then set ResMayNotAlias to true if there are UAVs present globally.
+      if (!ResMayAlias && MMDI.DXILVersion <= VersionTuple(1, 7)) {
+        SCCSF.ResMayNotAlias = !DBM.uavs().empty();
+      }
+
       ComputedShaderFlags CSF;
       for (const auto &BB : *F)
         for (const auto &I : BB)
-          updateFunctionFlags(CSF, I, DRTM);
+          updateFunctionFlags(CSF, I, DRTM, MMDI);
       // Update combined shader flags mask for all functions in this SCC
       SCCSF.merge(CSF);
 
@@ -249,10 +276,11 @@ AnalysisKey ShaderFlagsAnalysis::Key;
 ModuleShaderFlags ShaderFlagsAnalysis::run(Module &M,
                                            ModuleAnalysisManager &AM) {
   DXILResourceTypeMap &DRTM = AM.getResult<DXILResourceTypeAnalysis>(M);
+  DXILBindingMap &DBM = AM.getResult<DXILResourceBindingAnalysis>(M);
   const ModuleMetadataInfo MMDI = AM.getResult<DXILMetadataAnalysis>(M);
 
   ModuleShaderFlags MSFI;
-  MSFI.initialize(M, DRTM, MMDI);
+  MSFI.initialize(M, DRTM, DBM, MMDI);
 
   return MSFI;
 }
@@ -282,16 +310,19 @@ PreservedAnalyses ShaderFlagsAnalysisPrinter::run(Module &M,
 bool ShaderFlagsAnalysisWrapper::runOnModule(Module &M) {
   DXILResourceTypeMap &DRTM =
       getAnalysis<DXILResourceTypeWrapperPass>().getResourceTypeMap();
+  DXILBindingMap &DBM =
+      getAnalysis<DXILResourceBindingWrapperPass>().getBindingMap();
   const ModuleMetadataInfo MMDI =
       getAnalysis<DXILMetadataAnalysisWrapperPass>().getModuleMetadata();
 
-  MSFI.initialize(M, DRTM, MMDI);
+  MSFI.initialize(M, DRTM, DBM, MMDI);
   return false;
 }
 
 void ShaderFlagsAnalysisWrapper::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequiredTransitive<DXILResourceTypeWrapperPass>();
+  AU.addRequiredTransitive<DXILResourceBindingWrapperPass>();
   AU.addRequired<DXILMetadataAnalysisWrapperPass>();
 }
 

llvm/lib/Target/DirectX/DXILShaderFlags.h

@@ -28,6 +28,7 @@ namespace llvm {
 class Module;
 class GlobalVariable;
 class DXILResourceTypeMap;
+class DXILBindingMap;
 
 namespace dxil {
 
@@ -85,19 +86,23 @@ struct ComputedShaderFlags {
 
 struct ModuleShaderFlags {
   void initialize(Module &, DXILResourceTypeMap &DRTM,
-                  const ModuleMetadataInfo &MMDI);
+                  DXILBindingMap &DBM, const ModuleMetadataInfo &MMDI);
   const ComputedShaderFlags &getFunctionFlags(const Function *) const;
   const ComputedShaderFlags &getCombinedFlags() const { return CombinedSFMask; }
 
 private:
+  // A bool to indicate if the -res-may-alias flag was passed to clang-dxc.
+  // A module flag "dx.resmayalias" is set to 1 if true.
+  // This bool is used in the logic for setting the flag ResMayNotAlias.
+  bool ResMayAlias = false;
   /// Map of Function-Shader Flag Mask pairs representing properties of each of
   /// the functions in the module. Shader Flags of each function represent both
   /// module-level and function-level flags
   DenseMap<const Function *, ComputedShaderFlags> FunctionFlags;
   /// Combined Shader Flag Mask of all functions of the module
   ComputedShaderFlags CombinedSFMask{};
   void updateFunctionFlags(ComputedShaderFlags &, const Instruction &,
-                           DXILResourceTypeMap &);
+                           DXILResourceTypeMap &, const ModuleMetadataInfo &);
 };
 
 class ShaderFlagsAnalysis : public AnalysisInfoMixin<ShaderFlagsAnalysis> {

llvm/test/CodeGen/DirectX/ShaderFlags/res-may-alias-0.ll

@@ -0,0 +1,39 @@
+; RUN: opt -S --passes="print-dx-shader-flags" 2>&1 %s | FileCheck %s
+
+target triple = "dxil-pc-shadermodel6.8-library"
+
+; CHECK:      Combined Shader Flags for Module
+; CHECK-NEXT: Shader Flags Value: 0x200000010
+
+; CHECK: Note: extra DXIL module flags:
+; CHECK:       Raw and Structured buffers
+; CHECK:       Any UAV may not alias any other UAV
+;
+
+; CHECK: Function loadUAV : 0x20000000
+define float @loadUAV() #0 {
+  %res = call target("dx.TypedBuffer", float, 1, 0, 0)
+      @llvm.dx.resource.handlefrombinding(i32 0, i32 0, i32 1, i32 0, i1 false)
+  %load = call {float, i1} @llvm.dx.resource.load.typedbuffer(
+      target("dx.TypedBuffer", float, 1, 0, 0) %res, i32 0)
+  %val = extractvalue {float, i1} %load, 0
+  ret float %val
+}
+
+; CHECK: Function loadSRV : 0x00000010
+define float @loadSRV() #0 {
+  %res = tail call target("dx.RawBuffer", float, 0, 0)
+      @llvm.dx.resource.handlefrombinding(i32 0, i32 0, i32 1, i32 0, i1 false)
+  %load = call {float, i1} @llvm.dx.resource.load.rawbuffer(
+      target("dx.RawBuffer", float, 0, 0) %res, i32 0, i32 0)
+  %val = extractvalue { float, i1 } %load, 0
+  ret float %val
+}
+
+!llvm.module.flags = !{!0}
+
+; dx.resmayalias should never appear with a value of 0.
+; But if it does, ensure that it has no effect.
+!0 = !{i32 1, !"dx.resmayalias", i32 0}
+
+attributes #0 = { convergent norecurse nounwind "hlsl.export"}

llvm/test/CodeGen/DirectX/ShaderFlags/res-may-alias-1.ll

@@ -0,0 +1,37 @@
+; RUN: opt -S --passes="print-dx-shader-flags" 2>&1 %s | FileCheck %s
+
+target triple = "dxil-pc-shadermodel6.8-library"
+
+; CHECK:      Combined Shader Flags for Module
+; CHECK-NEXT: Shader Flags Value: 0x00000010
+
+; CHECK: Note: extra DXIL module flags:
+; CHECK:       Raw and Structured buffers
+; CHECK-NOT:   Any UAV may not alias any other UAV
+;
+
+; CHECK: Function loadUAV : 0x00000000
+define float @loadUAV() #0 {
+  %res = call target("dx.TypedBuffer", float, 1, 0, 0)
+      @llvm.dx.resource.handlefrombinding(i32 0, i32 0, i32 1, i32 0, i1 false)
+  %load = call {float, i1} @llvm.dx.resource.load.typedbuffer(
+      target("dx.TypedBuffer", float, 1, 0, 0) %res, i32 0)
+  %val = extractvalue {float, i1} %load, 0
+  ret float %val
+}
+
+; CHECK: Function loadSRV : 0x00000010
+define float @loadSRV() #0 {
+  %res = tail call target("dx.RawBuffer", float, 0, 0)
+      @llvm.dx.resource.handlefrombinding(i32 0, i32 0, i32 1, i32 0, i1 false)
+  %load = call {float, i1} @llvm.dx.resource.load.rawbuffer(
+      target("dx.RawBuffer", float, 0, 0) %res, i32 0, i32 0)
+  %val = extractvalue { float, i1 } %load, 0
+  ret float %val
+}
+
+!llvm.module.flags = !{!0}
+
+!0 = !{i32 1, !"dx.resmayalias", i32 1}
+
+attributes #0 = { convergent norecurse nounwind "hlsl.export"}

llvm/test/CodeGen/DirectX/ShaderFlags/res-may-not-alias-shadermodel6.7.ll

@@ -0,0 +1,33 @@
+; RUN: opt -S --passes="print-dx-shader-flags" 2>&1 %s | FileCheck %s
+
+target triple = "dxil-pc-shadermodel6.7-library"
+
+; CHECK:      Combined Shader Flags for Module
+; CHECK-NEXT: Shader Flags Value: 0x200000010
+
+; CHECK: Note: extra DXIL module flags:
+; CHECK:       Raw and Structured buffers
+; CHECK:       Any UAV may not alias any other UAV
+;
+
+; CHECK: Function loadUAV : 0x200000000
+define float @loadUAV() #0 {
+  %res = call target("dx.TypedBuffer", float, 1, 0, 0)
+      @llvm.dx.resource.handlefrombinding(i32 0, i32 0, i32 1, i32 0, i1 false)
+  %load = call {float, i1} @llvm.dx.resource.load.typedbuffer(
+      target("dx.TypedBuffer", float, 1, 0, 0) %res, i32 0)
+  %val = extractvalue {float, i1} %load, 0
+  ret float %val
+}
+
+; CHECK: Function loadSRV : 0x200000010
+define float @loadSRV() #0 {
+  %res = tail call target("dx.RawBuffer", float, 0, 0)
+      @llvm.dx.resource.handlefrombinding(i32 0, i32 0, i32 1, i32 0, i1 false)
+  %load = call {float, i1} @llvm.dx.resource.load.rawbuffer(
+      target("dx.RawBuffer", float, 0, 0) %res, i32 0, i32 0)
+  %val = extractvalue { float, i1 } %load, 0
+  ret float %val
+}
+
+attributes #0 = { convergent norecurse nounwind "hlsl.export"}