nak: Implement fadd

Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/24998>

src/nouveau/compiler/nak_encode_sm75.rs

@@ -272,6 +272,32 @@ impl SM75Instr {
         self.set_field(122..126, deps.reuse_mask);
     }
 
+    fn set_rnd_mode(&mut self, range: Range<usize>, rnd_mode: FRndMode) {
+        assert!(range.len() == 2);
+        self.set_field(
+            range,
+            match rnd_mode {
+                FRndMode::NearestEven => 0_u8,
+                FRndMode::NegInf => 1_u8,
+                FRndMode::PosInf => 2_u8,
+                FRndMode::Zero => 3_u8,
+            },
+        );
+    }
+
+    fn encode_fadd(&mut self, op: &OpFAdd) {
+        self.encode_alu(
+            0x021,
+            Some(op.dst),
+            Some(op.mod_src(0)),
+            op.mod_src(1),
+            None,
+        );
+        self.set_bit(77, op.saturate);
+        self.set_rnd_mode(78..80, op.rnd_mode);
+        self.set_bit(80, false); /* TODO: Denorm mode */
+    }
+
     fn encode_iadd3(&mut self, op: &OpIAdd3) {
         self.encode_alu(
             0x010,
@@ -363,15 +389,7 @@ impl SM75Instr {
         self.set_field(60..62, 0_u8); /* TODO: subop */
         self.set_bit(74, op.src_type.is_signed());
         self.set_field(75..77, op.dst_type.bytes().trailing_zeros());
-        self.set_field(
-            78..80,
-            match op.rnd_mode {
-                FRndMode::NearestEven => 0_u8,
-                FRndMode::NegInf => 1_u8,
-                FRndMode::PosInf => 2_u8,
-                FRndMode::Zero => 3_u8,
-            },
-        );
+        self.set_rnd_mode(78..80, op.rnd_mode);
         self.set_field(84..86, op.src_type.bytes().trailing_zeros());
     }
 
@@ -529,6 +547,7 @@ impl SM75Instr {
         };
 
         match &instr.op {
+            Op::FAdd(op) => si.encode_fadd(&op),
             Op::IAdd3(op) => si.encode_iadd3(&op),
             Op::ISetP(op) => si.encode_isetp(&op),
             Op::Lop3(op) => si.encode_lop3(&op),

src/nouveau/compiler/nak_from_nir.rs

@@ -90,6 +90,13 @@ impl<'a> ShaderFromNir<'a> {
                 self.instrs
                     .push(Instr::new_sel(dst, srcs[0], srcs[1], srcs[2]));
             }
+            nir_op_fadd => {
+                self.instrs.push(Instr::new_fadd(
+                    dst,
+                    srcs[0].into(),
+                    srcs[1].into(),
+                ));
+            }
             nir_op_i2f32 => {
                 self.instrs.push(Instr::new_i2f(dst, srcs[0]));
             }

src/nouveau/compiler/nak_ir.rs

@@ -571,6 +571,7 @@ impl fmt::Display for FloatType {
     }
 }
 
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
 pub enum FRndMode {
     NearestEven,
     NegInf,
@@ -758,6 +759,35 @@ pub struct AttrAccess {
     pub flags: u8,
 }
 
+#[repr(C)]
+#[derive(SrcsAsSlice, DstsAsSlice, SrcModsAsSlice)]
+pub struct OpFAdd {
+    pub dst: Dst,
+    pub srcs: [Src; 2],
+    pub src_mods: [SrcMod; 2],
+    pub saturate: bool,
+    pub rnd_mode: FRndMode,
+}
+
+impl fmt::Display for OpFAdd {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "FADD")?;
+        if self.saturate {
+            write!(f, ".SAT")?;
+        }
+        if self.rnd_mode != FRndMode::NearestEven {
+            write!(f, ".{}", self.rnd_mode)?;
+        }
+        write!(
+            f,
+            " {} {{ {}, {} }}",
+            self.dst,
+            self.mod_src(0),
+            self.mod_src(1),
+        )
+    }
+}
+
 #[repr(C)]
 #[derive(SrcsAsSlice, DstsAsSlice, SrcModsAsSlice)]
 pub struct OpIAdd3 {
@@ -1115,6 +1145,7 @@ impl fmt::Display for OpFSOut {
 
 #[derive(Display, DstsAsSlice, SrcsAsSlice)]
 pub enum Op {
+    FAdd(OpFAdd),
     IAdd3(OpIAdd3),
     ISetP(OpISetP),
     Lop3(OpLop3),
@@ -1298,6 +1329,16 @@ impl Instr {
         }
     }
 
+    pub fn new_fadd(dst: Dst, x: ModSrc, y: ModSrc) -> Instr {
+        Instr::new(Op::FAdd(OpFAdd {
+            dst: dst,
+            srcs: [x.src, y.src],
+            src_mods: [x.src_mod, y.src_mod],
+            saturate: false,
+            rnd_mode: FRndMode::NearestEven,
+        }))
+    }
+
     pub fn new_iadd(dst: Dst, x: Src, y: Src) -> Instr {
         Instr::new(Op::IAdd3(OpIAdd3 {
             dst: dst,
@@ -1474,7 +1515,8 @@ impl Instr {
 
     pub fn get_latency(&self) -> Option<u32> {
         match self.op {
-            Op::IAdd3(_)
+            Op::FAdd(_)
+            | Op::IAdd3(_)
             | Op::Lop3(_)
             | Op::PLop3(_)
             | Op::ISetP(_)