nak: Add F2F and implement fquantize16

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

src/nouveau/compiler/nak_encode_sm75.rs

@@ -664,6 +664,20 @@ impl SM75Instr {
         self.set_bit(80, op.dst_high);
     }
 
+    fn encode_f2f(&mut self, op: &OpF2F) {
+        self.encode_alu(
+            0x104,
+            Some(op.dst),
+            ALUSrc::None,
+            ALUSrc::from_src(&op.src.into()),
+            ALUSrc::None,
+        );
+        self.set_field(75..77, op.dst_type.bytes().ilog2());
+        self.set_rnd_mode(78..80, op.rnd_mode);
+        self.set_bit(80, op.ftz);
+        self.set_field(84..86, op.src_type.bytes().ilog2());
+    }
+
     fn encode_f2i(&mut self, op: &OpF2I) {
         self.encode_alu(
             0x105,
@@ -1230,6 +1244,7 @@ impl SM75Instr {
             Op::ISetP(op) => si.encode_isetp(&op),
             Op::Lop3(op) => si.encode_lop3(&op),
             Op::Shf(op) => si.encode_shf(&op),
+            Op::F2F(op) => si.encode_f2f(&op),
             Op::F2I(op) => si.encode_f2i(&op),
             Op::I2F(op) => si.encode_i2f(&op),
             Op::Mov(op) => si.encode_mov(&op),

src/nouveau/compiler/nak_from_nir.rs

@@ -287,6 +287,31 @@ impl<'a> ShaderFromNir<'a> {
                     saturate: false,
                 })));
             }
+            nir_op_fquantize2f16 => {
+                let tmp = self.alloc_ssa(RegFile::GPR);
+                self.instrs.push(
+                    OpF2F {
+                        dst: tmp.into(),
+                        src: srcs[0],
+                        src_type: FloatType::F32,
+                        dst_type: FloatType::F16,
+                        rnd_mode: FRndMode::NearestEven,
+                        ftz: true,
+                    }
+                    .into(),
+                );
+                self.instrs.push(
+                    OpF2F {
+                        dst: dst,
+                        src: tmp.into(),
+                        src_type: FloatType::F16,
+                        dst_type: FloatType::F32,
+                        rnd_mode: FRndMode::NearestEven,
+                        ftz: true,
+                    }
+                    .into(),
+                );
+            }
             nir_op_frcp => {
                 self.instrs.push(Instr::new_mufu(dst, MuFuOp::Rcp, srcs[0]));
             }

src/nouveau/compiler/nak_ir.rs

@@ -1649,6 +1649,31 @@ impl fmt::Display for OpShf {
     }
 }
 
+#[repr(C)]
+#[derive(SrcsAsSlice, DstsAsSlice)]
+pub struct OpF2F {
+    pub dst: Dst,
+    pub src: Src,
+    pub src_type: FloatType,
+    pub dst_type: FloatType,
+    pub rnd_mode: FRndMode,
+    pub ftz: bool,
+}
+
+impl fmt::Display for OpF2F {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "F2F")?;
+        if self.ftz {
+            write!(f, ".FTZ")?;
+        }
+        write!(
+            f,
+            ".{}.{}.{} {} {}",
+            self.dst_type, self.src_type, self.rnd_mode, self.dst, self.src,
+        )
+    }
+}
+
 #[repr(C)]
 #[derive(SrcsAsSlice, DstsAsSlice)]
 pub struct OpF2I {
@@ -2430,6 +2455,7 @@ pub enum Op {
     ISetP(OpISetP),
     Lop3(OpLop3),
     Shf(OpShf),
+    F2F(OpF2F),
     F2I(OpF2I),
     I2F(OpI2F),
     Mov(OpMov),
@@ -2923,7 +2949,7 @@ impl Instr {
             | Op::PLop3(_)
             | Op::ISetP(_)
             | Op::Shf(_) => Some(6),
-            Op::F2I(_) | Op::I2F(_) | Op::Mov(_) => Some(15),
+            Op::F2F(_) | Op::F2I(_) | Op::I2F(_) | Op::Mov(_) => Some(15),
             Op::MuFu(_) => None,
             Op::Sel(_) => Some(15),
             Op::S2R(_) => None,