[mlir][dxsa] Add bfi instruction

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

@@ -19,13 +19,9 @@ include "mlir/Dialect/DXSA/IR/DXSAOpBase.td"
 // DXSA shared base for atomic memory ops
 //===----------------------------------------------------------------------===//
 
-class DXSA_AtomicOp<string mnemonic> : DXSA_Op<mnemonic> {
-  let arguments = (ins
-      DXSA_DstOperandAttr:$dst,
-      DXSA_SrcOperandAttr:$dst_address,
-      DXSA_SrcOperandAttr:$src0);
-  let results = (outs);
-  let assemblyFormat = "$dst `,` $dst_address `,` $src0 attr-dict";
+class DXSA_AtomicOp<string mnemonic> : DXSA_BaseOp<mnemonic> {
+  let srcs = (ins DXSA_SrcOperandAttr:$dst_address, DXSA_SrcOperandAttr:$src0);
+  let asmFormat = "$dst `,` $dst_address `,` $src0";
 }
 
 //===----------------------------------------------------------------------===//
@@ -209,15 +205,10 @@ def DXSA_AtomicUMin : DXSA_AtomicOp<"atomic_umin"> {
 // DXSA shared base for immediate atomic ops returning the prior value
 //===----------------------------------------------------------------------===//
 
-class DXSA_ImmAtomicBinaryOp<string mnemonic> : DXSA_Op<mnemonic> {
-  let arguments = (ins
-      DXSA_DstOperandAttr:$dst0,
-      DXSA_DstOperandAttr:$dst1,
-      DXSA_SrcOperandAttr:$dst_address,
-      DXSA_SrcOperandAttr:$src0);
-  let results = (outs);
-  let assemblyFormat =
-      "$dst0 `,` $dst1 `,` $dst_address `,` $src0 attr-dict";
+class DXSA_ImmAtomicBinaryOp<string mnemonic> : DXSA_BaseOp<mnemonic> {
+  let dsts = (ins DXSA_DstOperandAttr:$dst0, DXSA_DstOperandAttr:$dst1);
+  let srcs = (ins DXSA_SrcOperandAttr:$dst_address, DXSA_SrcOperandAttr:$src0);
+  let asmFormat = "$dst0 `,` $dst1 `,` $dst_address `,` $src0";
 }
 
 //===----------------------------------------------------------------------===//
@@ -418,7 +409,7 @@ def DXSA_ImmAtomicUMin : DXSA_ImmAtomicBinaryOp<"imm_atomic_umin"> {
 // dxsa.atomic_cmp_store
 //===----------------------------------------------------------------------===//
 
-def DXSA_AtomicCmpStore : DXSA_Op<"atomic_cmp_store"> {
+def DXSA_AtomicCmpStore : DXSA_BaseOp<"atomic_cmp_store"> {
   let summary = "atomic compare and conditional write to memory";
   let description = [{
     The `dxsa.atomic_cmp_store` operation atomically compares `$src0` with the
@@ -437,14 +428,9 @@ def DXSA_AtomicCmpStore : DXSA_Op<"atomic_cmp_store"> {
     dxsa.atomic_cmp_store u<0>, r<1>, r<2>, r<3>
     ```
   }];
-  let arguments = (ins
-      DXSA_DstOperandAttr:$dst,
-      DXSA_SrcOperandAttr:$dst_address,
-      DXSA_SrcOperandAttr:$src0,
-      DXSA_SrcOperandAttr:$src1);
-  let results = (outs);
-  let assemblyFormat =
-      "$dst `,` $dst_address `,` $src0 `,` $src1 attr-dict";
+  let srcs = (ins DXSA_SrcOperandAttr:$dst_address,
+                  DXSA_SrcOperandAttr:$src0, DXSA_SrcOperandAttr:$src1);
+  let asmFormat = "$dst `,` $dst_address `,` $src0 `,` $src1";
 }
 
 //===----------------------------------------------------------------------===//
@@ -474,7 +460,7 @@ def DXSA_ImmAtomicExch : DXSA_ImmAtomicBinaryOp<"imm_atomic_exch"> {
 // dxsa.imm_atomic_cmp_exch
 //===----------------------------------------------------------------------===//
 
-def DXSA_ImmAtomicCmpExch : DXSA_Op<"imm_atomic_cmp_exch"> {
+def DXSA_ImmAtomicCmpExch : DXSA_BaseOp<"imm_atomic_cmp_exch"> {
   let summary =
       "atomic compare and exchange to memory, returning the prior value";
   let description = [{
@@ -494,27 +480,19 @@ def DXSA_ImmAtomicCmpExch : DXSA_Op<"imm_atomic_cmp_exch"> {
     dxsa.imm_atomic_cmp_exch r<0, <x>>, u<0>, r<1>, r<2>, r<3>
     ```
   }];
-  let arguments = (ins
-      DXSA_DstOperandAttr:$dst0,
-      DXSA_DstOperandAttr:$dst1,
-      DXSA_SrcOperandAttr:$dst_address,
-      DXSA_SrcOperandAttr:$src0,
-      DXSA_SrcOperandAttr:$src1);
-  let results = (outs);
-  let assemblyFormat =
-      "$dst0 `,` $dst1 `,` $dst_address `,` $src0 `,` $src1 attr-dict";
+  let dsts = (ins DXSA_DstOperandAttr:$dst0, DXSA_DstOperandAttr:$dst1);
+  let srcs = (ins DXSA_SrcOperandAttr:$dst_address,
+                  DXSA_SrcOperandAttr:$src0, DXSA_SrcOperandAttr:$src1);
+  let asmFormat = "$dst0 `,` $dst1 `,` $dst_address `,` $src0 `,` $src1";
 }
 
 //===----------------------------------------------------------------------===//
 // DXSA shared base for UnorderedAccessView (UAV) counter atomics
 //===----------------------------------------------------------------------===//
 
-class DXSA_ImmAtomicCounterOp<string mnemonic> : DXSA_Op<mnemonic> {
-  let arguments = (ins
-      DXSA_DstOperandAttr:$dst,
-      DXSA_SrcOperandAttr:$uav);
-  let results = (outs);
-  let assemblyFormat = "$dst `,` $uav attr-dict";
+class DXSA_ImmAtomicCounterOp<string mnemonic> : DXSA_BaseOp<mnemonic> {
+  let srcs = (ins DXSA_SrcOperandAttr:$uav);
+  let asmFormat = "$dst `,` $uav";
 }
 
 //===----------------------------------------------------------------------===//

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

@@ -34,6 +34,30 @@ def DXSA_And : DXSA_BinaryOp<"and"> {
   }];
 }
 
+//===----------------------------------------------------------------------===//
+// dxsa.bfi
+//===----------------------------------------------------------------------===//
+
+def DXSA_BFI : DXSA_BaseOp<"bfi"> {
+  let summary = "bit field insert";
+  let description = [{
+    The `dxsa.bfi` operation takes a bit range from the LSB of a number
+    and places that number of bits in another number at any offset.
+
+    `$src0` specifies the bitfield width to take from `$src2`. `$src1`
+    specifies the offset at which to insert the bitfield in `$src3`.
+
+    Example:
+
+    ```mlir
+    dxsa.bfi r<0, <y>>, l(0x1E), l(0x2), v<0, <x>>, l(0x1)
+    ```
+  }];
+  let srcs = (ins DXSA_SrcOperandAttr:$src0, DXSA_SrcOperandAttr:$src1,
+                  DXSA_SrcOperandAttr:$src2, DXSA_SrcOperandAttr:$src3);
+  let asmFormat = "$dst `,` $src0 `,` $src1 `,` $src2 `,` $src3";
+}
+
 //===----------------------------------------------------------------------===//
 // dxsa.bfrev
 //===----------------------------------------------------------------------===//

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

@@ -769,15 +769,10 @@ def DXSA_RsqSat : DXSA_UnaryOp<"rsq_sat"> {
 
 // Shared base for sine/cosine: sin of `$operand` into `$sin`, cosine into
 // `$cos`. Either destination may be `null` when that result is not needed.
-class DXSA_SincosOp<string mnemonic> : DXSA_Op<mnemonic> {
-  let arguments = (ins
-      DXSA_DstOperandAttr:$sin,
-      DXSA_DstOperandAttr:$cos,
-      DXSA_SrcOperandAttr:$operand,
-      OptionalAttr<DXSA_ComponentMaskAttr>:$precise);
-  let results = (outs);
-  let assemblyFormat =
-      "(`precise` $precise^)? $sin `,` $cos `,` $operand attr-dict";
+class DXSA_SincosOp<string mnemonic> : DXSA_BaseOp<mnemonic> {
+  let dsts = (ins DXSA_DstOperandAttr:$sin, DXSA_DstOperandAttr:$cos);
+  let srcs = (ins DXSA_SrcOperandAttr:$operand);
+  let asmFormat = "$sin `,` $cos `,` $operand";
 }
 
 def DXSA_Sincos : DXSA_SincosOp<"sincos"> {

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

@@ -160,7 +160,7 @@ def DXSA_Imad : DXSA_MultiplyAddOp<"imad"> {
 // dxsa.imul
 //===----------------------------------------------------------------------===//
 
-def DXSA_Imul : DXSA_Op<"imul"> {
+def DXSA_Imul : DXSA_BinaryOp<"imul"> {
   let summary = "component-wise integer multiply";
   let description = [{
     The `dxsa.imul` operation computes the component-wise product
@@ -176,15 +176,8 @@ def DXSA_Imul : DXSA_Op<"imul"> {
     dxsa.imul r<7, <x, y, z>>, r<3, <x, y, z>>, r<3, <x, y, z, x>>, r<4, <x, y, z, x>>
     ```
   }];
-  let arguments = (ins
-      DXSA_DstOperandAttr:$dstHi,
-      DXSA_DstOperandAttr:$dstLo,
-      DXSA_SrcOperandAttr:$lhs,
-      DXSA_SrcOperandAttr:$rhs,
-      OptionalAttr<DXSA_ComponentMaskAttr>:$precise);
-  let results = (outs);
-  let assemblyFormat =
-      "(`precise` $precise^)? $dstHi `,` $dstLo `,` $lhs `,` $rhs attr-dict";
+  let dsts = (ins DXSA_DstOperandAttr:$dstHi, DXSA_DstOperandAttr:$dstLo);
+  let asmFormat = "$dstHi `,` $dstLo `,` $lhs `,` $rhs";
 }
 
 //===----------------------------------------------------------------------===//

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

@@ -25,53 +25,44 @@ class DXSA_Op<string mnemonic, list<Trait> traits = []> :
     Op<DXSADialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
-// DXSA shared bases for ops with inline operands
+// DXSA shared base for ops with all operands specified inline
 //===----------------------------------------------------------------------===//
 
-class DXSA_UnaryOp<string mnemonic> : DXSA_Op<mnemonic> {
-  let arguments = (ins
-      DXSA_DstOperandAttr:$dst,
-      DXSA_SrcOperandAttr:$src,
-      OptionalAttr<DXSA_ComponentMaskAttr>:$precise);
+class DXSA_BaseOp<string mnemonic> : DXSA_Op<mnemonic> {
+  dag dsts;
+  dag srcs;
+  string asmFormat;
+  let dsts = (ins DXSA_DstOperandAttr:$dst);
+
+  let arguments = !con(dsts, srcs, (ins OptionalAttr<DXSA_ComponentMaskAttr>:$precise));
   let results = (outs);
-  let assemblyFormat =
-      "(`precise` $precise^)? $dst `,` $src attr-dict";
+  let assemblyFormat = !strconcat("(`precise` $precise^)? ", asmFormat, " attr-dict");
 }
 
-class DXSA_BinaryOp<string mnemonic> : DXSA_Op<mnemonic> {
-  let arguments = (ins
-      DXSA_DstOperandAttr:$dst,
-      DXSA_SrcOperandAttr:$lhs,
-      DXSA_SrcOperandAttr:$rhs,
-      OptionalAttr<DXSA_ComponentMaskAttr>:$precise);
-  let results = (outs);
-  let assemblyFormat =
-      "(`precise` $precise^)? $dst `,` $lhs `,` $rhs attr-dict";
+class DXSA_NullaryOp<string mnemonic> : DXSA_BaseOp<mnemonic> {
+  let srcs = (ins);
+  let asmFormat = "$dst";
 }
 
-class DXSA_TernaryOp<string mnemonic> : DXSA_Op<mnemonic> {
-  let arguments = (ins
-      DXSA_DstOperandAttr:$dst,
-      DXSA_SrcOperandAttr:$src0,
-      DXSA_SrcOperandAttr:$src1,
-      DXSA_SrcOperandAttr:$src2,
-      OptionalAttr<DXSA_ComponentMaskAttr>:$precise);
-  let results = (outs);
-  let assemblyFormat =
-      "(`precise` $precise^)? $dst `,` $src0 `,` $src1 `,` $src2 attr-dict";
+class DXSA_UnaryOp<string mnemonic> : DXSA_BaseOp<mnemonic> {
+  let srcs = (ins DXSA_SrcOperandAttr:$src);
+  let asmFormat = "$dst `,` $src";
+}
+
+class DXSA_BinaryOp<string mnemonic> : DXSA_BaseOp<mnemonic> {
+  let srcs = (ins DXSA_SrcOperandAttr:$lhs, DXSA_SrcOperandAttr:$rhs);
+  let asmFormat = "$dst `,` $lhs `,` $rhs";
+}
+
+class DXSA_TernaryOp<string mnemonic> : DXSA_BaseOp<mnemonic> {
+  let srcs = (ins DXSA_SrcOperandAttr:$src0, DXSA_SrcOperandAttr:$src1, DXSA_SrcOperandAttr:$src2);
+  let asmFormat = "$dst `,` $src0 `,` $src1 `,` $src2";
 }
 
 // Shared base for the multiply-add family: `$dst = $lhs * $rhs + $acc`.
-class DXSA_MultiplyAddOp<string mnemonic> : DXSA_Op<mnemonic> {
-  let arguments = (ins
-      DXSA_DstOperandAttr:$dst,
-      DXSA_SrcOperandAttr:$lhs,
-      DXSA_SrcOperandAttr:$rhs,
-      DXSA_SrcOperandAttr:$acc,
-      OptionalAttr<DXSA_ComponentMaskAttr>:$precise);
-  let results = (outs);
-  let assemblyFormat =
-      "(`precise` $precise^)? $dst `,` $lhs `,` $rhs `,` $acc attr-dict";
+class DXSA_MultiplyAddOp<string mnemonic> : DXSA_BaseOp<mnemonic> {
+  let srcs = (ins DXSA_SrcOperandAttr:$lhs, DXSA_SrcOperandAttr:$rhs, DXSA_SrcOperandAttr:$acc);
+  let asmFormat = "$dst `,` $lhs `,` $rhs `,` $acc";
 }
 
 #endif // MLIR_DIALECT_DXSA_IR_DXSAOPBASE