Code formatting changes

Author: justinrosner

mlir/lib/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.cpp

@@ -685,23 +685,24 @@ static Value castScaleOperand(ConversionPatternRewriter &rewriter, Location loc,
 /// Maps f8 scale element types to WMMA scale format codes.
 static std::optional<uint32_t> getWmmaScaleFormat(Type elemType) {
   return TypeSwitch<Type, std::optional<uint32_t>>(elemType)
-      .Case<Float8E8M0FNUType>([](auto) { return 0; })
-      .Case<Float8E4M3FNType>([](auto) { return 2; })
-      .Default([](Type) { return std::nullopt; });
+      .Case([](Float8E8M0FNUType) { return 0; })
+      .Case([](Float8E4M3FNType) { return 2; })
+      .Default(std::nullopt);
 }
 
 /// Determines the ROCDL intrinsic name for scaled WMMA based on dimensions
 /// and scale vector length.
 static std::optional<StringRef>
 getScaledWmmaIntrinsicName(int64_t m, int64_t n, int64_t k, bool isScale16) {
-  if (m == 16 && n == 16 && k == 128) {
+  if (m == 16 && n == 16 && k == 128)
     return isScale16
                ? ROCDL::wmma_scale16_f32_16x16x128_f8f6f4::getOperationName()
                : ROCDL::wmma_scale_f32_16x16x128_f8f6f4::getOperationName();
-  } else if (m == 32 && n == 16 && k == 128) {
+
+  if (m == 32 && n == 16 && k == 128)
     return isScale16 ? ROCDL::wmma_scale16_f32_32x16x128_f4::getOperationName()
                      : ROCDL::wmma_scale_f32_32x16x128_f4::getOperationName();
-  }
+
   return std::nullopt;
 }
 
@@ -1457,31 +1458,24 @@ struct ScaledWMMAOpLowering : public ConvertOpToLLVMPattern<ScaledWMMAOp> {
     // The f4 variant does not have fmtA and fmtB attributes.
     bool is32x16 = (m == 32 && n == 16 && k == 128);
     if (!is32x16) {
-      attrs.emplace_back(
-          rewriter.getNamedAttr("fmtA", rewriter.getI32IntegerAttr(*aFmtCode)));
-      attrs.emplace_back(
-          rewriter.getNamedAttr("fmtB", rewriter.getI32IntegerAttr(*bFmtCode)));
+      attrs.emplace_back("fmtA", rewriter.getI32IntegerAttr(*aFmtCode));
+      attrs.emplace_back("fmtB", rewriter.getI32IntegerAttr(*bFmtCode));
     }
 
     // modC uses default value of 0.
-    attrs.emplace_back(
-        rewriter.getNamedAttr("modC", rewriter.getI16IntegerAttr(0)));
+    attrs.emplace_back("modC", rewriter.getI16IntegerAttr(0));
 
     // Scale attributes.
-    attrs.emplace_back(rewriter.getNamedAttr(
-        "scaleAType", rewriter.getI32IntegerAttr(op.getScaleAIdx())));
-    attrs.emplace_back(rewriter.getNamedAttr(
-        "fmtScaleA", rewriter.getI32IntegerAttr(*scaleAFmt)));
-    attrs.emplace_back(rewriter.getNamedAttr(
-        "scaleBType", rewriter.getI32IntegerAttr(op.getScaleBIdx())));
-    attrs.emplace_back(rewriter.getNamedAttr(
-        "fmtScaleB", rewriter.getI32IntegerAttr(*scaleBFmt)));
+    attrs.emplace_back("scaleAType",
+                       rewriter.getI32IntegerAttr(op.getScaleAIdx()));
+    attrs.emplace_back("fmtScaleA", rewriter.getI32IntegerAttr(*scaleAFmt));
+    attrs.emplace_back("scaleBType",
+                       rewriter.getI32IntegerAttr(op.getScaleBIdx()));
+    attrs.emplace_back("fmtScaleB", rewriter.getI32IntegerAttr(*scaleBFmt));
 
     // Reuse flags use default value of false.
-    attrs.emplace_back(
-        rewriter.getNamedAttr("reuseA", rewriter.getBoolAttr(false)));
-    attrs.emplace_back(
-        rewriter.getNamedAttr("reuseB", rewriter.getBoolAttr(false)));
+    attrs.emplace_back("reuseA", rewriter.getBoolAttr(false));
+    attrs.emplace_back("reuseB", rewriter.getBoolAttr(false));
 
     // Convert typed float vectors to packed format.
     Value sourceA =

mlir/lib/Dialect/AMDGPU/IR/AMDGPUDialect.cpp

@@ -448,17 +448,13 @@ LogicalResult WMMAOp::verify() {
 
 LogicalResult ScaledWMMAOp::verify() {
   // Helper functions for type classification.
-  auto isF8 = [](Type t) {
-    return isa<Float8E4M3FNType, Float8E5M2Type, Float8E8M0FNUType,
-               Float8E4M3FNUZType, Float8E5M2FNUZType>(t);
-  };
-  auto isF6 = [](Type t) { return isa<Float6E2M3FNType, Float6E3M2FNType>(t); };
-  auto isF4 = [](Type t) { return isa<Float4E2M1FNType>(t); };
+  auto isF8 = llvm::IsaPred<Float8E4M3FNType, Float8E5M2Type>;
+  auto isF6 = llvm::IsaPred<Float6E2M3FNType, Float6E3M2FNType>;
+  auto isF4 = llvm::IsaPred<Float4E2M1FNType>;
   auto isSmallFloat = [&](Type t) { return isF4(t) || isF6(t) || isF8(t); };
-  auto isE8M0 = [](Type t) { return isa<Float8E8M0FNUType>(t); };
-  auto isE4M3 = [](Type t) {
-    return isa<Float8E4M3FNType, Float8E4M3FNUZType>(t);
-  };
+  auto isScaleF8 = llvm::IsaPred<Float8E8M0FNUType, Float8E4M3FNType>;
+  auto isE8M0 = llvm::IsaPred<Float8E8M0FNUType>;
+  auto isE4M3 = llvm::IsaPred<Float8E4M3FNType>;
 
   auto sourceAType = cast<VectorType>(getSourceA().getType());
   auto sourceBType = cast<VectorType>(getSourceB().getType());
@@ -517,9 +513,10 @@ LogicalResult ScaledWMMAOp::verify() {
   Type scaleAElemType = scaleAType.getElementType();
   Type scaleBElemType = scaleBType.getElementType();
 
-  // Validate scale element types are valid f8 types.
-  if (!isF8(scaleAElemType) || !isF8(scaleBElemType))
-    return emitOpError("scale operands must have f8 element types");
+  // Validate scale element types are valid scale f8 types (E8M0FNU or E4M3FN).
+  if (!isScaleF8(scaleAElemType) || !isScaleF8(scaleBElemType))
+    return emitOpError(
+        "scale operands must have f8 element types (E8M0FNU or E4M3FN)");
 
   // Any matrices A/B (fp8|fp6|fp4) with E8M0 scales for matrix A/B are valid.
   if (isE8M0(scaleAElemType) && isE8M0(scaleBElemType))