RDAT: Check flags and WaveSize for min SM; fix flag detection and merging

include/dxc/DXIL/DxilConstants.h

@@ -60,6 +60,22 @@ inline int CompareVersions(unsigned Major1, unsigned Minor1, unsigned Major2,
   return 0;
 }
 
+// Utility for updating major,minor to max of current and new.
+inline bool MaxOfShaderModels(unsigned &major, unsigned &minor,
+                              unsigned newMajor, unsigned newMinor) {
+  if (newMajor > major) {
+    major = newMajor;
+    minor = newMinor;
+    return true;
+  } else if (newMajor == major) {
+    if (newMinor > minor) {
+      minor = newMinor;
+      return true;
+    }
+  }
+  return false;
+}
+
 // Shader flags.
 const unsigned kDisableOptimizations =
     0x00000001; // D3D11_1_SB_GLOBAL_FLAG_SKIP_OPTIMIZATION

include/dxc/DXIL/DxilShaderFlags.h

@@ -15,6 +15,7 @@
 
 namespace hlsl {
 class DxilModule;
+struct DxilFunctionProps;
 }
 
 namespace llvm {
@@ -38,6 +39,21 @@ class ShaderFlags {
   void SetShaderFlagsRaw(uint64_t data);
   void CombineShaderFlags(const ShaderFlags &other);
 
+  // Adjust flags based on function properties; compute minimum shader model
+  // Library functions use flags to capture properties that may or may not be
+  // used in the final shader, depending on that final shader's shader model.
+  // These flags will be combined up a call graph until we hit an entry,
+  // function, at which point, we might have to remove flags that no longer
+  // apply, or adjust the minimum shader model.
+  // For instance: derivatives are allowed in CS/MS/AS in 6.6+, and for MS/AS,
+  // a feature bit is required.  Libary functions will capture any derivative
+  // use into this feature bit, which is used to calculate the final
+  // requirements once we reach an entry function.
+  ShaderFlags
+  AdjustMinimumShaderModelAndFlags(const hlsl::DxilFunctionProps *props,
+                                   unsigned &minMajor,
+                                   unsigned &minMinor) const;
+
   void SetDisableOptimizations(bool flag) { m_bDisableOptimizations = flag; }
   bool GetDisableOptimizations() const { return m_bDisableOptimizations; }
 

lib/DXIL/DxilShaderFlags.cpp

@@ -857,3 +857,69 @@ ShaderFlags ShaderFlags::CollectShaderFlags(const Function *F,
 void ShaderFlags::CombineShaderFlags(const ShaderFlags &other) {
   SetShaderFlagsRaw(GetShaderFlagsRaw() | other.GetShaderFlagsRaw());
 }
+
+ShaderFlags
+ShaderFlags::AdjustMinimumShaderModelAndFlags(const DxilFunctionProps *props,
+                                              unsigned &minMajor,
+                                              unsigned &minMinor) const {
+  // Start with the same flags, adjust as necessary.
+  ShaderFlags flags = *this;
+
+  // Adjust things based on known shader entry point once we have one.
+  // This must be done after combining flags from called functions.
+  if (props) {
+    // This flag doesn't impact min shader model until we know what kind of
+    // entry point we have. Then, we may need to clear the flag, when it doesn't
+    // apply.
+
+    if (GetUsesDerivatives()) {
+      if (props->IsCS()) {
+        // Always supported if SM 6.6+.
+        DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 6);
+      } else if (props->IsMS() || props->IsAS()) {
+        // Requires flag for support on SM 6.6+.
+        flags.SetDerivativesInMeshAndAmpShaders(true);
+        DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 6);
+      }
+    }
+
+    // If function has WaveSize, this also constrains the minimum shader model.
+    if (props->WaveSize.IsDefined()) {
+      if (props->WaveSize.IsRange())
+        DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 8);
+      else
+        DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 6);
+    }
+
+    // Adjust minimum shader model based on shader stage.
+    if (props->IsMS() || props->IsAS())
+      DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 5);
+    else if (props->IsRay())
+      DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 3);
+    else if (props->IsNode())
+      DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 8);
+  }
+
+  // Adjust minimum shader model based on flags.
+  if (GetWaveMMA())
+    DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 9);
+  else if (GetSampleCmpGradientOrBias() || GetExtendedCommandInfo())
+    DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 8);
+  else if (GetAdvancedTextureOps() || GetWriteableMSAATextures())
+    DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 7);
+  else if (GetAtomicInt64OnTypedResource() || GetAtomicInt64OnGroupShared() ||
+           GetAtomicInt64OnHeapResource() ||
+           GetResourceDescriptorHeapIndexing() ||
+           GetSamplerDescriptorHeapIndexing())
+    DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 6);
+  else if (GetRaytracingTier1_1() || GetSamplerFeedback())
+    DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 5);
+  else if (GetShadingRate())
+    DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 4);
+  else if (GetLowPrecisionPresent() && GetUseNativeLowPrecision())
+    DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 2);
+  else if (GetViewID() || GetBarycentrics())
+    DXIL::MaxOfShaderModels(minMajor, minMinor, 6, 1);
+
+  return flags;
+}