[mlir][dxsa] Refine dcl_global_flags instruction

Decouple MLIR enum values from the binary layout, drop the artificial 'none' case.

Example:
  dxsa.dcl_global_flags <refactoringAllowed|forceEarlyDepthStencil>

Signed-off-by: Vladimir Shiryaev <tagolog@users.noreply.github.com>

Author: tagolog

mlir/include/mlir/Dialect/DXSA/IR/DXSAOps.td

@@ -18,37 +18,26 @@ include "mlir/IR/EnumAttr.td"
 //===----------------------------------------------------------------------===//
 
 // Global shader flags for 'dcl_globalFlags' instruction.
-def DXSA_GlobalFlags_None               : I32BitEnumAttrCaseNone<"none">;
-// D3D10_SB_GLOBAL_FLAG_REFACTORING_ALLOWED
-def DXSA_GlobalFlags_RefactoringAllowed : I32BitEnumAttrCaseBit<"refactoringAllowed", 11>;
-// D3D11_SB_GLOBAL_FLAG_ENABLE_DOUBLE_PRECISION_FLOAT_OPS
-def DXSA_GlobalFlags_DoublePrecision    : I32BitEnumAttrCaseBit<"enableDoublePrecision", 12>;
-// D3D11_SB_GLOBAL_FLAG_FORCE_EARLY_DEPTH_STENCIL
-def DXSA_GlobalFlags_ForceEarlyDepth    : I32BitEnumAttrCaseBit<"forceEarlyDepth", 13>;
-// D3D11_SB_GLOBAL_FLAG_ENABLE_RAW_AND_STRUCTURED_BUFFERS
-def DXSA_GlobalFlags_RawStructured      : I32BitEnumAttrCaseBit<"enableRawStructured", 14>;
-// D3D11_1_SB_GLOBAL_FLAG_SKIP_OPTIMIZATION
-def DXSA_GlobalFlags_SkipOptimization   : I32BitEnumAttrCaseBit<"skipOptimization", 15>;
-// D3D11_1_SB_GLOBAL_FLAG_ENABLE_MINIMUM_PRECISION
-def DXSA_GlobalFlags_MinPrecision       : I32BitEnumAttrCaseBit<"enableMinPrecision", 16>;
-// D3D11_1_SB_GLOBAL_FLAG_ENABLE_DOUBLE_EXTENSIONS
-def DXSA_GlobalFlags_DoubleExtensions   : I32BitEnumAttrCaseBit<"enableDoubleExtensions", 17>;
-// D3D11_1_SB_GLOBAL_FLAG_ENABLE_SHADER_EXTENSIONS
-def DXSA_GlobalFlags_ShaderExtensions   : I32BitEnumAttrCaseBit<"enableShaderExtensions", 18>;
-// D3D12_SB_GLOBAL_FLAG_ALL_RESOURCES_BOUND
-def DXSA_GlobalFlags_AllResourcesBound  : I32BitEnumAttrCaseBit<"allResourcesBound", 19>;
+def DXSA_GlobalFlags_RefactoringAllowed            : I32BitEnumAttrCaseBit<"refactoringAllowed",            0>;
+def DXSA_GlobalFlags_EnableDoublePrecisionFloatOps : I32BitEnumAttrCaseBit<"enableDoublePrecisionFloatOps", 1>;
+def DXSA_GlobalFlags_ForceEarlyDepthStencil        : I32BitEnumAttrCaseBit<"forceEarlyDepthStencil",        2>;
+def DXSA_GlobalFlags_EnableRawAndStructuredBuffers : I32BitEnumAttrCaseBit<"enableRawAndStructuredBuffers", 3>;
+def DXSA_GlobalFlags_SkipOptimization              : I32BitEnumAttrCaseBit<"skipOptimization",              4>;
+def DXSA_GlobalFlags_EnableMinimumPrecision        : I32BitEnumAttrCaseBit<"enableMinimumPrecision",        5>;
+def DXSA_GlobalFlags_EnableDoubleExtensions        : I32BitEnumAttrCaseBit<"enableDoubleExtensions",        6>;
+def DXSA_GlobalFlags_EnableShaderExtensions        : I32BitEnumAttrCaseBit<"enableShaderExtensions",        7>;
+def DXSA_GlobalFlags_AllResourcesBound             : I32BitEnumAttrCaseBit<"allResourcesBound",             8>;
 
 def DXSA_GlobalFlags : I32BitEnumAttr<
     "GlobalFlags", "global shader flags", [
-      DXSA_GlobalFlags_None,
       DXSA_GlobalFlags_RefactoringAllowed,
-      DXSA_GlobalFlags_DoublePrecision,
-      DXSA_GlobalFlags_ForceEarlyDepth,
-      DXSA_GlobalFlags_RawStructured,
+      DXSA_GlobalFlags_EnableDoublePrecisionFloatOps,
+      DXSA_GlobalFlags_ForceEarlyDepthStencil,
+      DXSA_GlobalFlags_EnableRawAndStructuredBuffers,
       DXSA_GlobalFlags_SkipOptimization,
-      DXSA_GlobalFlags_MinPrecision,
-      DXSA_GlobalFlags_DoubleExtensions,
-      DXSA_GlobalFlags_ShaderExtensions,
+      DXSA_GlobalFlags_EnableMinimumPrecision,
+      DXSA_GlobalFlags_EnableDoubleExtensions,
+      DXSA_GlobalFlags_EnableShaderExtensions,
       DXSA_GlobalFlags_AllResourcesBound
     ]> {
   let separator = "|";
@@ -146,9 +135,18 @@ def DXSA_Instruction : DXSA_Op<"instruction"> {
 
 def DXSA_DclGlobalFlags : DXSA_Op<"dcl_global_flags"> {
   let summary = "declares global shader flags";
+  let description = [{
+    The `dxsa.dcl_global_flags` operation declares a set of flags that
+    affect the entire shader.
+
+    Example:
+
+    ```mlir
+    dxsa.dcl_global_flags <refactoringAllowed|forceEarlyDepthStencil>
+    ```
+  }];
   let arguments = (ins DXSA_GlobalFlagsAttr:$flags);
   let assemblyFormat = "$flags attr-dict";
-  let hasVerifier = 1;
 }
 
 def DXSA_DclTemps : DXSA_Op<"dcl_temps"> {

mlir/lib/Dialect/DXSA/IR/DXSA.cpp

@@ -34,16 +34,6 @@ void DXSADialect::initialize() {
       >();
 }
 
-//===----------------------------------------------------------------------===//
-// DclGlobalFlags
-//===----------------------------------------------------------------------===//
-
-LogicalResult DclGlobalFlags::verify() {
-  if (getFlags() == GlobalFlags::none)
-    return emitOpError("expected at least one global flag to be set");
-  return success();
-}
-
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//

mlir/lib/Target/DXSA/BinaryParser.cpp

@@ -509,9 +509,8 @@ class DXBuilder {
     return module;
   }
 
-  Instruction buildDclGlobalFlags(uint32_t flags, Location loc) {
-    auto flagsAttr = dxsa::GlobalFlagsAttr::get(
-        builder.getContext(), static_cast<dxsa::GlobalFlags>(flags));
+  Instruction buildDclGlobalFlags(dxsa::GlobalFlags flags, Location loc) {
+    auto flagsAttr = dxsa::GlobalFlagsAttr::get(builder.getContext(), flags);
     return dxsa::DclGlobalFlags::create(builder, loc, flagsAttr);
   }
 
@@ -824,8 +823,31 @@ class Parser {
 
   FailureOr<Instruction> parseDclGlobalFlags(uint32_t opcodeToken,
                                              Location loc) {
-    return builder.buildDclGlobalFlags(
-        DECODE_D3D10_SB_GLOBAL_FLAGS(opcodeToken), loc);
+    auto raw = DECODE_D3D10_SB_GLOBAL_FLAGS(opcodeToken);
+    if (raw == 0) {
+      emitError(loc, "expected at least one global flag to be set");
+      return failure();
+    }
+    auto flags = static_cast<dxsa::GlobalFlags>(0);
+    if (raw & D3D10_SB_GLOBAL_FLAG_REFACTORING_ALLOWED)
+      flags |= dxsa::GlobalFlags::refactoringAllowed;
+    if (raw & D3D11_SB_GLOBAL_FLAG_ENABLE_DOUBLE_PRECISION_FLOAT_OPS)
+      flags |= dxsa::GlobalFlags::enableDoublePrecisionFloatOps;
+    if (raw & D3D11_SB_GLOBAL_FLAG_FORCE_EARLY_DEPTH_STENCIL)
+      flags |= dxsa::GlobalFlags::forceEarlyDepthStencil;
+    if (raw & D3D11_SB_GLOBAL_FLAG_ENABLE_RAW_AND_STRUCTURED_BUFFERS)
+      flags |= dxsa::GlobalFlags::enableRawAndStructuredBuffers;
+    if (raw & D3D11_1_SB_GLOBAL_FLAG_SKIP_OPTIMIZATION)
+      flags |= dxsa::GlobalFlags::skipOptimization;
+    if (raw & D3D11_1_SB_GLOBAL_FLAG_ENABLE_MINIMUM_PRECISION)
+      flags |= dxsa::GlobalFlags::enableMinimumPrecision;
+    if (raw & D3D11_1_SB_GLOBAL_FLAG_ENABLE_DOUBLE_EXTENSIONS)
+      flags |= dxsa::GlobalFlags::enableDoubleExtensions;
+    if (raw & D3D11_1_SB_GLOBAL_FLAG_ENABLE_SHADER_EXTENSIONS)
+      flags |= dxsa::GlobalFlags::enableShaderExtensions;
+    if (raw & D3D12_SB_GLOBAL_FLAG_ALL_RESOURCES_BOUND)
+      flags |= dxsa::GlobalFlags::allResourcesBound;
+    return builder.buildDclGlobalFlags(flags, loc);
   }
 
   FailureOr<Instruction> parseDclTemps(Location loc) {

mlir/test/Target/DXSA/dcl_global_flags.mlir

@@ -4,14 +4,14 @@
 
 // CHECK:      module {
 // CHECK-NEXT:   dxsa.dcl_global_flags <refactoringAllowed>
-// CHECK-NEXT:   dxsa.dcl_global_flags <enableDoublePrecision>
-// CHECK-NEXT:   dxsa.dcl_global_flags <forceEarlyDepth>
-// CHECK-NEXT:   dxsa.dcl_global_flags <enableRawStructured>
+// CHECK-NEXT:   dxsa.dcl_global_flags <enableDoublePrecisionFloatOps>
+// CHECK-NEXT:   dxsa.dcl_global_flags <forceEarlyDepthStencil>
+// CHECK-NEXT:   dxsa.dcl_global_flags <enableRawAndStructuredBuffers>
 // CHECK-NEXT:   dxsa.dcl_global_flags <skipOptimization>
-// CHECK-NEXT:   dxsa.dcl_global_flags <enableMinPrecision>
+// CHECK-NEXT:   dxsa.dcl_global_flags <enableMinimumPrecision>
 // CHECK-NEXT:   dxsa.dcl_global_flags <enableDoubleExtensions>
 // CHECK-NEXT:   dxsa.dcl_global_flags <enableShaderExtensions>
 // CHECK-NEXT:   dxsa.dcl_global_flags <allResourcesBound>
 // CHECK-NEXT:   dxsa.dcl_global_flags <refactoringAllowed|skipOptimization|allResourcesBound>
-// CHECK-NEXT:   dxsa.dcl_global_flags <refactoringAllowed|enableDoublePrecision|forceEarlyDepth|enableRawStructured|skipOptimization|enableMinPrecision|enableDoubleExtensions|enableShaderExtensions|allResourcesBound>
+// CHECK-NEXT:   dxsa.dcl_global_flags <refactoringAllowed|enableDoublePrecisionFloatOps|forceEarlyDepthStencil|enableRawAndStructuredBuffers|skipOptimization|enableMinimumPrecision|enableDoubleExtensions|enableShaderExtensions|allResourcesBound>
 // CHECK-NEXT: }