RV32FDQ/RV64RDQ指令集(2)

下面我们逐个看下每个指令的细节:

fadd.s

fadd.s rd, rs1, rs2     //f [rd] = f [rs1] + f [rs2]
单精度浮点加(Floating-point Add, Single-Precision). R-type, RV32F and RV64F.
把寄存器 f[rs1]和 f[rs2]中的单精度浮点数相加，并将舍入后的和写入 f[rd]。

示例：

to do

fsub.s

fsub.s rd, rs1, rs2    //f[rd] = f[rs1] - f[rs2]
单精度浮点减(Floating-point Subtract, Single-Precision). R-type, RV32F and RV64F.
把寄存器 f[rs1]和 f[rs2]中的单精度浮点数相减，并将舍入后的差写入 f[rd]。

示例：

to do

fmul.s

fmul.s rd, rs1, rs2    //f[rd] = f[rs1] × f[rs2]
单精度浮点乘(Floating-point Multiply, Single-Precision). R-type, RV32F and RV64F.
把寄存器 f[rs1]和 f[rs2]中的单精度浮点数相乘，将舍入后的单精度结果写入 f[rd]中。

示例：

to do

fdiv.s

fdiv.s rd, rs1, rs2   //f[rd] = f[rs1] ÷ f[rs2]
单精度浮点除法(Floating-point Divide, Single-Precision). R-type, RV32F and RV64F.
把寄存器 f[rs1]和 f[rs2]中的单精度浮点数相除，并将舍入后的商写入 f[rd]。

示例：

to do

fsgnj.s

fsgnj.s rd, rs1, rs2   //f[rd] = {f[rs2][31], f[rs1][30:0]}
单精度浮点符号注入(Floating-point Sign Inject, Single-Precision). R-type, RV32F and RV64F.
用 f[rs1]指数和有效数以及 f[rs2]的符号作为符号位，来构造一个新的单精度浮点数，并将其写入 f[rd]。

示例：

to do

fsgnjn.s

fsgnjn.s rd, rs1, rs2    //f[rd] = {~f[rs2][31], f[rs1][30:0]}
单精度浮点符号取反注入(Floating-point Sign Inject-Negate, Single-Precision). R-type, RV32F and RV64F.
用 f[rs1]指数和有效数以及 f[rs2]的符号作为符号位并取反，来构造一个新的单精度浮点数，并将其写入 f[rd]。

示例：

to do

fsgnjx.s

fsgnjx.s rd, rs1, rs2    //f[rd] = {f[rs1][31] ^ f[rs2][31], f[rs1][30:0]}
单精度浮点符号异或注入(Floating-point Sign Inject-XOR, Single-Precision). R-type, RV32F and RV64F.
用 f[rs1]指数和有效数以及 f[rs1]和 f[rs2]的符号的符号位异或，来构造一个新的单精度浮点数，并将其写入 f[rd]。

示例：

to do

fmin.s

fmin.s rd, rs1, rs2    //f[rd] = min(f[rs1], f[rs2])
单精度浮点最小值(Floating-point Minimum, Single-Precision). R-type, RV32F and RV64F.
把寄存器 f[rs1]和 f[rs2]中的单精度浮点数中的较小值写入 f[rd]中。

对于FMAX和FMIN指令，注意一下特殊情况：

1. 如果指令的两个操作数都是NaN，那么结果为Canonical-NaN。

2. 如果只有一个操作数位NaN，则结果为非NaN的另外一个操作数。

3. 如果任意一个操作数属于Signaling-NaN,则需要在fcsr寄存器中产生NV异常标志。

4. 由于浮点数可以表示两个0值，分别是-0.0和+0.0，对于FMAX和FMIN指令而言，-0.0被认为比+0.0小。

示例：

to do

fmax.s

fmax.s rd, rs1, rs2    //f[rd] = max(f[rs1], f[rs2])
单精度浮点最大值(Floating-point Maximum, Single-Precision). R-type, RV32F and RV64F.
把寄存器 f[rs1]和 f[rs2]中的单精度浮点数中的较大值写入 f[rd]中。

对于FMAX和FMIN指令，注意一下特殊情况：

1. 如果指令的两个操作数都是NaN，那么结果为Canonical-NaN。

2. 如果只有一个操作数位NaN，则结果为非NaN的另外一个操作数。

3. 如果任意一个操作数属于Signaling-NaN,则需要在fcsr寄存器中产生NV异常标志。

4. 由于浮点数可以表示两个0值，分别是-0.0和+0.0，对于FMAX和FMIN指令而言，-0.0被认为比+0.0小。

示例：

to do

fsqrt.s

fsqrt.s rd, rs1, rs2     //f[rd] =sqrt(f[rs1])
单精度浮点平方根(Floating-point Square Root, Single-Precision). R-type, RV32F and RV64F.
将 f[rs1]中的单精度浮点数的平方根舍入和写入 f[rd]。

示例：

to do

fadd.d

fadd.d rd, rs1, rs2    //f [rd] = f [rs1] + f [rs2]
双精度浮点加(Floating-point Add, Double-Precision). R-type, RV32D and RV64D.
把寄存器 f[rs1]和 f[rs2]中的双精度浮点数相加，并将舍入后的和写入 f[rd]。

示例：

to do

fsub.d

fsub.d rd, rs1, rs2   //f[rd] = f[rs1] - f[rs2]
双精度浮点减(Floating-point Subtract, Double-Precision). R-type, RV32D and RV64D.
把寄存器 f[rs1]和 f[rs2]中的双精度浮点数相减，并将舍入后的差写入 f[rd]。

示例：

to do

fmul.d

fmul.d rd, rs1, rs2    //f[rd] = f[rs1] × f[rs2]
双精度浮点乘(Floating-point Multiply, Double-Precision). R-type, RV32D and RV64D.
把寄存器 f[rs1]和 f[rs2]中的双精度浮点数相乘，将舍入后的双精度结果写入 f[rd]中。

示例：

to do

fdiv.d

fdiv.d rd, rs1, rs2    //f[rd] = f[rs1] ÷ f[rs2]
双精度浮点除法(Floating-point Divide, Double-Precision). R-type, RV32D and RV64D.
把寄存器 f[rs1]和 f[rs2]中的双精度浮点数相除，并将舍入后的商写入 f[rd]。

示例：

to do

fsgnj.d

fsgnj.d rd, rs1, rs2   //f[rd] = {f[rs2][63], f[rs1][62:0]}
双精度浮点符号注入(Floating-point Sign Inject, Double-Precision). R-type, RV32D and RV64D.
用 f[rs1]指数和有效数以及 f[rs2]的符号的符号位，来构造一个新的双精度浮点数，并将其写入 f[rd]。

示例：

to do

fsgnjn.d

fsgnjn.d rd, rs1, rs2    //f[rd] = {~f[rs2][63], f[rs1][62:0]}
双精度浮点符号取反注入(Floating-point Sign Inject-Negate, Double-Precision). R-type, RV32D and RV64D.
用 f[rs1]指数和有效数以及 f[rs2]的符号的符号位取反，来构造一个新的双精度浮点数，并将其写入 f[rd]。

示例：

to do

fsgnjx.d

fsgnjx.d rd, rs1, rs2    //f[rd] = {f[rs1][63] ^ f[rs2][63], f[rs1][62:0]}
双精度浮点符号异或注入(Floating-point Sign Inject-XOR, Double-Precision). R-type, RV32D and RV64D.
用 f[rs1]指数和有效数以及 f[rs1]和 f[rs2]的符号的符号位异或，来构造一个新的双精度浮点数，并将其写入 f[rd]。

示例：

to do

fmin.d

fmin.d rd, rs1, rs2    //f[rd] = min(f[rs1], f[rs2])
双精度浮点最小值(Floating-point Minimum, Double-Precision). R-type, RV32D and RV64D.
把寄存器 f[rs1]和 f[rs2]中的双精度浮点数中的较小值写入 f[rd]中。

对于FMAX和FMIN指令，注意一下特殊情况：

1. 如果指令的两个操作数都是NaN，那么结果为Canonical-NaN。

2. 如果只有一个操作数位NaN，则结果为非NaN的另外一个操作数。

3. 如果任意一个操作数属于Signaling-NaN,则需要在fcsr寄存器中产生NV异常标志。

4. 由于浮点数可以表示两个0值，分别是-0.0和+0.0，对于FMAX和FMIN指令而言，-0.0被认为比+0.0小。

示例：

to do

fmax.d

fmax.d rd, rs1, rs2    //f[rd] = max(f[rs1], f[rs2])
双精度浮点最大值(Floating-point Maximum, Double-Precision). R-type, RV32D and RV64D.
把寄存器 f[rs1]和 f[rs2]中的双精度浮点数中的较大值写入 f[rd]中。

对于FMAX和FMIN指令，注意一下特殊情况：

1. 如果指令的两个操作数都是NaN，那么结果为Canonical-NaN。

2. 如果只有一个操作数位NaN，则结果为非NaN的另外一个操作数。

3. 如果任意一个操作数属于Signaling-NaN,则需要在fcsr寄存器中产生NV异常标志。

4. 由于浮点数可以表示两个0值，分别是-0.0和+0.0，对于FMAX和FMIN指令而言，-0.0被认为比+0.0小。

示例：

to do

fcvt.s.d

fcvt.s.d rd, rs1, rs2    //f[rd] = f32_f64(f[rs1])
双精度向单精度浮点转换(Floating-point Convert to Single from Double). R-type, RV32D and RV64D.
把寄存器 f[rs1]中的双精度浮点数转化为单精度浮点数，再写入 f[rd]中。

示例：

to do

fcvt.d.s

fcvt.d.s rd, rs1, rs2    //f[rd] = f64_f32(f[rs1])
单精度向双精度浮点转换(Floating-point Convert to Double from Single). R-type, RV32D and RV64D.
把寄存器 f[rs1]中的单精度浮点数转化为双精度浮点数，再写入 f[rd]中。

示例：

to do

fsqrt.d

fsqrt.d rd, rs1, rs2   //f[rd] =sqrt(f[rs1])
双精度浮点平方根(Floating-point Square Root, Double-Precision). R-type, RV32D and RV64D.
将 f[rs1]中的双精度浮点数的平方根舍入和写入 f[rd]。

示例：

to do

fadd.q

示例：

to do

fsub.q

示例：

to do

fmul.q

示例：

to do

fdiv.q

示例：

to do

fsgnj.q

示例：

to do

fsgnjn.q

示例：

to do

fsgnjx.q

示例：

to do

fmin.q

示例：

to do

fmax.q

示例：

to do

fcvt.s.q

示例：

to do

fcvt.q.s

示例：

to do

fcvt.d.q

示例：

to do

fcvt.q.d

示例：

to do

fsqrt.q

示例：

to do

fle.s

fle.s rd, rs1, rs2    //x[rd] = f[rs1] ≤ f[rs2]
单精度浮点小于等于(Floating-point Less Than or Equal, Single-Precision). R-type, RV32F and RV64F.
若寄存器 f[rs1]中的单精度浮点数小于等于 f[rs2]中的单精度浮点数， 则在 x[rd]中写入 1，反之写 0。

• 对于FLT,FLE和FEQ指令，如果任何一个操作数位NaN，则结果为0。
• 对于FLT和FLE指令，如果任意一个操作数属于Nan，则需要在fscr寄存器中产生NV异常标志。
• 对于FEQ指令，如果任意一个操作数属于Signaling-NaN，则需要在fcsr寄存器中产生NV异常标志。

示例：

to do

flt.s

flt.s rd, rs1, rs2    //x[rd] = f[rs1] < f[rs2]
单精度浮点小于 (Floating-point Less Than, Single-Precision). R-type, RV32F and RV64F.
若寄存器 f[rs1]中的单精度浮点数小于 f[rs2]中的单精度浮点数， 则在 x[rd]中写入 1，反之写0。

• 对于FLT,FLE和FEQ指令，如果任何一个操作数位NaN，则结果为0。
• 对于FLT和FLE指令，如果任意一个操作数属于Nan，则需要在fscr寄存器中产生NV异常标志。
• 对于FEQ指令，如果任意一个操作数属于Signaling-NaN，则需要在fcsr寄存器中产生NV异常标志。

示例：

to do

fle.d

fle.d rd, rs1, rs2    //x[rd] = f[rs1] < f[rs2]
双精度浮点小于 (Floating-point Less Than, Double-Precision). R-type, RV32D and RV64D.
若寄存器 f[rs1]中的双精度浮点数小于 f[rs2]中的双精度浮点数， 则在 x[rd]中写入 1，反之写0。

• 对于FLT,FLE和FEQ指令，如果任何一个操作数位NaN，则结果为0。
• 对于FLT和FLE指令，如果任意一个操作数属于Nan，则需要在fscr寄存器中产生NV异常标志。
• 对于FEQ指令，如果任意一个操作数属于Signaling-NaN，则需要在fcsr寄存器中产生NV异常标志。

示例：

to do

flt.d

fle.d rd, rs1, rs2    //x[rd] = f[rs1] < f[rs2]
双精度浮点小于 (Floating-point Less Than, Double-Precision). R-type, RV32D and RV64D.
若寄存器 f[rs1]中的双精度浮点数小于 f[rs2]中的双精度浮点数， 则在 x[rd]中写入 1，反之写0。

• 对于FLT,FLE和FEQ指令，如果任何一个操作数位NaN，则结果为0。
• 对于FLT和FLE指令，如果任意一个操作数属于Nan，则需要在fscr寄存器中产生NV异常标志。
• 对于FEQ指令，如果任意一个操作数属于Signaling-NaN，则需要在fcsr寄存器中产生NV异常标志。

示例：

to do

fle.q

示例：

to do

flt.q

示例：

to do

feq.s

feq.s rd, rs1, rs2    //x[rd] = f[rs1] == f[rs2]
单精度浮点相等(Floating-point Equals, Single-Precision). R-type, RV32F and RV64F.
若寄存器 f[rs1]和 f[rs2]中的单精度浮点数相等， 则在 x[rd]中写入 1，反之写 0。

• 对于FLT,FLE和FEQ指令，如果任何一个操作数位NaN，则结果为0。
• 对于FLT和FLE指令，如果任意一个操作数属于Nan，则需要在fscr寄存器中产生NV异常标志。
• 对于FEQ指令，如果任意一个操作数属于Signaling-NaN，则需要在fcsr寄存器中产生NV异常标志。

示例：

to do

feq.d

feq.d rd, rs1, rs2  //x[rd] = f[rs1] == f[rs2]
双精度浮点相等(Floating-point Equals, Double-Precision). R-type, RV32D and RV64D.
若寄存器 f[rs1]和 f[rs2]中的双精度浮点数相等， 则在 x[rd]中写入 1，反之写 0。

• 对于FLT,FLE和FEQ指令，如果任何一个操作数位NaN，则结果为0。
• 对于FLT和FLE指令，如果任意一个操作数属于Nan，则需要在fscr寄存器中产生NV异常标志。
• 对于FEQ指令，如果任意一个操作数属于Signaling-NaN，则需要在fcsr寄存器中产生NV异常标志。

示例：

to do

feq.q

示例：

to do

fcvt.w.s

fcvt.w.s rd, rs1, rs2   //x[rd] = sext(s32_f32(f[rs1]))
单精度浮点向字转换(Floating-point Convert to Word from Single). R-type, RV32F and RV64F.
把寄存器 f[rs1]中的单精度浮点数转化为 32 位二进制补码表示的整数，再写入 x[rd]中。

由于浮点数表示范围远远大于整数，且浮点数存在一些特殊表示，比如无穷大和NaN等，下表是一些浮点转化整数时候的一些特殊情况。

示例：

to do

fcvt.wu.s

fcvt.wu.s rd, rs1, rs2   //x[rd] = sext(u32_f32(f[rs1]))
单精度浮点向无符号字转换(Floating-point Convert to Unsigned Word from Single). R-type,RV32F and RV64F.
把寄存器 f[rs1]中的单精度浮点数转化为 32 位无符号整数，再写入 x[rd]中。

示例：

to do

fcvt.l.s

fcvt.l.s rd, rs1, rs2   //x[rd] = s64_f32(f[rs1])
单精度浮点向长整型转换(Floating-point Convert to Long from Single). R-type, RV64F.
把寄存器 f[rs1]中的单精度浮点数转化为 64 位二进制补码表示的整数，再写入 x[rd]中。

示例：

to do

fcvt.lu.s

fcvt.lu.s rd, rs1, rs2   //x[rd] = u64_f32(f[rs1])
单精度浮点向无符号长整型转换(Floating-point Convert to Unsigned Long from Single). R-type,RV64F.
把寄存器 f[rs1]中的单精度浮点数转化为 64 位二进制补码表示的整数，再写入 x[rd]中。

示例：

to do

fmv.x.w

fmv.x.w rd, rs1, rs2    //x[rd] = sext(f[rs1][31:0])
单精度浮点移动(Floating-point Move Word to Integer). R-type, RV32F and RV64F.
把寄存器 f[rs1]中的低32位整数复制到 x[rd]中作为一个单精度浮点数表示。

示例：

to do

fclass.s

fclass.s rd, rs1, rs2    //x[rd] = classifys(f[rs1])
单精度浮点分类(Floating-point Classify, Single-Precision). R-type, RV32F and RV64F.
把一个表示寄存器 f[rs1]中单精度浮点数类别的掩码写入 x[rd]中。 x[rd]中有且仅有一位被置上，见下表

示例：

to do

fcvt.w.d

fcvt.w.d rd, rs1, rs2   //x[rd] = sext(s32_f64(f[rs1]))
双精度浮点向字转换(Floating-point Convert to Word from Double). R-type, RV32D and RV64D
把寄存器 f[rs1]中的双精度浮点数转化为 32 位二进制补码表示的整数，再写入 x[rd]中。

示例：

to do

fcvt.wu.d

fcvt.wu.d rd, rs1, rs2    //x[rd] = sext(u32_f64(f[rs1]))
双精度浮点向无符号字转换(Floating-point Convert to Unsigned Word from Double). R-type,RV32D and RV64D.
把寄存器 f[rs1]中的双精度浮点数转化为 32 位无符号整数，再写入 x[rd]中。

示例：

to do

fcvt.l.d

fcvt.l.d rd, rs1, rs2   //x[rd] = s64_f64(f[rs1])
双精度浮点向长整型转换(Floating-point Convert to Long from Double). R-type, RV64D.
把寄存器 f[rs1]中的双精度浮点数转化为 64 位二进制补码表示的整数，再写入 x[rd]中。

示例：

to do

fcvt.lu.d

fcvt.lu.d rd, rs1, rs2   //x[rd] = u64_f64(f[rs1])
双精度浮点向无符号长整型转换(Floating-point Convert to Unsigned Long from Double). Rtype, RV64D.
把寄存器 f[rs1]中的双精度浮点数转化为 64 位无符号整数，再写入 x[rd]中。

示例：

to do

fmv.x.d

fmv.x.d rd, rs1, rs2   //x[rd] = f[rs1][63:0]
双精度浮点移动(Floating-point Move Doubleword to Integer). R-type, RV64D.
把寄存器 f[rs1]中的双精度浮点数复制到 x[rd]中。

示例：

to do

fclass.d

fclass.d rd, rs1, rs2    //x[rd] = classify_d(f[rs1])
双精度浮点分类(Floating-point Classify, Double-Precision). R-type, RV32D and RV64D.
把一个表示寄存器 f[rs1]中双精度浮点数类别的掩码写入 x[rd]中。关于如何解释写入 x[rd]的值，请参阅指令 fclass.s 的介绍。

示例：

to do

fcvt.w.q

示例：

to do

fcvt.wu.q

示例：

to do

fcvt.l.q

示例：

to do

fcvt.lu.q

示例：

to do

fmv.x.q

示例：

to do

fclass.q

示例：

to do

fcvt.s.w

fcvt.s.w rd, rs1, rs2   //f[rd] = f32_s32(x[rs1])
字向单精度浮点转换(Floating-point Convert to Single from Word). R-type, RV32F and RV64F.
把寄存器 x[rs1]中的 32 位二进制补码表示的整数转化为单精度浮点数，再写入 f[rd]中。

示例：

to do

fcvt.s.wu

fcvt.s.wu rd, rs1, rs2   //f[rd] = f32_u32(x[rs1])
无符号字向单精度浮点转换(Floating-point Convert to Single from Unsigned Word). R-type,RV32F and RV64F.
把寄存器 x[rs1]中的 32 位无符号整数转化为单精度浮点数，再写入 f[rd]中。

示例：

to do

fcvt.s.l

fcvt.s.l rd, rs1, rs2  //f[rd] = f32_s64(x[rs1])
长整型向单精度浮点转换(Floating-point Convert to Single from Long). R-type, RV64F.
把寄存器 x[rs1]中的 64 位二进制补码表示的整数转化为单精度浮点数，再写入 f[rd]中。

示例：

to do

fcvt.s.lu

fcvt.s.lu rd, rs1, rs2   //f[rd] = f32_u64(x[rs1])
无符号长整型向单精度浮点转换(Floating-point Convert to Single from Unsigned Long). R-type,RV64F.
把寄存器 x[rs1]中的 64 位的无符号整数转化为单精度浮点数，再写入 f[rd]中。

示例：

to do

fmv.w.x

fmv.x.w rd, rs1, rs2    //x[rd] = sext(f[rs1][31:0])
单精度浮点移动(Floating-point Move Word to Integer). R-type, RV32F and RV64F.
把寄存器 f[rs1]中的补码表示的整数复制到 x[rd]中作为单精度浮点数，。

示例：

to do

fcvt.d.w

fcvt.d.w rd, rs1, rs2   //f[rd] = f64_s32(x[rs1])
字向双精度浮点转换(Floating-point Convert to Double from Word). R-type, RV32D and RV64D.
把寄存器 x[rs1]中的 32 位二进制补码表示的整数转化为双精度浮点数，再写入 f[rd]中。

示例：

to do

fcvt.d.wu

fcvt.d.wu rd, rs1, rs2   //f[rd] = f64_u32(x[rs1])
无符号字向双精度浮点转换(Floating-point Convert to Double from Unsigned Word). R-type,RV32D and RV64D.
把寄存器 x[rs1]中的 32 位无符号整数转化为双精度浮点数，再写入 f[rd]中。

示例：

to do

fcvt.d.l

fcvt.d.l rd, rs1, rs2   //f[rd] = f64_s64(x[rs1])
长整型向双精度浮点转换(Floating-point Convert to Double from Long). R-type, RV64D.
把寄存器 x[rs1]中的 64 位二进制补码表示的整数转化为双精度浮点数，再写入 f[rd]中。

示例：

to do

fcvt.d.lu

fcvt.d.lu rd, rs1, rs2  //f[rd] = f64_u64(x[rs1])
无符号长整型向双精度浮点转换(Floating-point Convert to Double from Unsigned Long). R-type, RV64D.
把寄存器 x[rs1]中的 64 位无符号整数转化为双精度浮点数，再写入 f[rd]中。

示例：

to do

fmv.d.x

fcvt.d.lu rd, rs1, rs2   //f[rd] = f64_u64(x[rs1])
无符号长整型向双精度浮点转换(Floating-point Convert to Double from Unsigned Long). R-type, RV64D.
把寄存器 x[rs1]中的 64 位无符号整数转化为双精度浮点数，再写入 f[rd]中。

示例：

to do

fcvt.q.w

示例：

to do

fcvt.q.wu

示例：

to do

fcvt.q.l

示例：

to do

fcvt.q.lu

示例：

to do

fmv.q.x

示例：

to do

flw

flw rd, offset(rs1)    //f[rd] = M[x[rs1] + sext(offset)][31:0]
浮点加载字(Floating-point Load Word). I-type, RV32F and RV64F.
从内存地址 x[rs1] + sign-extend(offset)中取单精度浮点数，并写入 f[rd]。
压缩形式： c.flwsp rd, offset; c.flw rd, offset(rs1)

示例：

to do

fld

fld rd, offset(rs1)   //f[rd] = M[x[rs1] + sext(offset)][63:0]
浮点加载双字(Floating-point Load Doubleword). I-type, RV32D and RV64D.
从内存地址 x[rs1] + sign-extend(offset)中取双精度浮点数，并写入 f[rd]。
压缩形式： c.fldsp rd, offset; c.fld rd, offset(rs1)

示例：

to do

flq

示例：

to do

fsw

fsw rs2, offset(rs1)   //M[x[rs1] + sext(offset)] = f[rs2][31:0]
单精度浮点存储(Floating-point Store Word). S-type, RV32F and RV64F.
将寄存器 f[rs2]中的单精度浮点数存入内存地址 x[rs1] + sign-extend(offset)中。
压缩形式： c.fswsp rs2, offset; c.fsw rs2, offset(rs1)

示例：

to do

fsd

fsd rs2, offset(rs1)   //M[x[rs1] + sext(offset)] = f[rs2][63:0]
双精度浮点存储(Floating-point Store Doubleword). S-type, RV32D and RV64D.
将寄存器 f[rs2]中的双精度浮点数存入内存地址 x[rs1] + sign-extend(offset)中。
压缩形式： c.fsdsp rs2, offset; c.fsd rs2, offset(rs1)

示例：

to do

fsq

示例：

to do

fmadd.s

fmadd.s rd, rs1, rs2, rs3    //f[rd] = f[rs1]× f[rs2]+f[rs3]
单精度浮点乘加(Floating-point Fused Multiply-Add, Single-Precision). R4-type, RV32F and RV64F.
把寄存器 f[rs1]和 f[rs2]中的单精度浮点数相乘，并将未舍入的积和寄存器 f[rs3]中的单精度
浮点数相加，将舍入后的单精度浮点数写入 f[rd]。

示例：

to do

fmsub.s

fmsub.s rd, rs1, rs2, rs3   //f[rd] = f[rs1]× f[rs2]-f[rs3]
单精度浮点乘减(Floating-point Fused Multiply-Subtarct, Single-Precision). R4-type, RV32F and RV64F.
把寄存器 f[rs1]和 f[rs2]中的单精度浮点数相乘，并将未舍入的积减去寄存器 f[rs3]中的单精
度浮点数，将舍入后的单精度浮点数写入 f[rd]。

示例：

to do

fnmsub.s

fnmsub.s rd, rs1, rs2, rs3   //f[rd] = -f[rs1]× f[rs2]+f[rs3]
单精度浮点乘取反减(Floating-point Fused Negative Multiply-Subtract, Single-Precision). R4-type, RV32F and RV64F.
把寄存器 f[rs1]和 f[rs2]中的单精度浮点数相乘，将结果取反，并将未舍入的积减去寄存器f[rs3]中的单精度浮点数，将舍入后的单精度浮点数写入 f[rd]。

示例：

to do

fnmadd.s

fnmadd.s rd, rs1, rs2, rs3   //f[rd] = -f[rs1]_f[rs2]-f[rs3]
单精度浮点乘取反加(Floating-point Fused Negative Multiply-Add, Single-Precision). R4-type,RV32F and RV64F.
把寄存器 f[rs1]和 f[rs2]中的单精度浮点数相乘，将结果取反，并将未舍入的积和寄存器 f[rs3]中的单精度浮点数相加，将舍入后的单精度浮点数写入 f[rd]。

示例：

to do

fmadd.d

fmadd.d rd, rs1, rs2, rs3   //f[rd] = f[rs1]× f[rs2]+f[rs3]
双精度浮点乘加(Floating-point Fused Multiply-Add, Double-Precision). R4-type, RV32D and RV64D.
把寄存器 f[rs1]和 f[rs2]中的双精度浮点数相乘，并将未舍入的积和寄存器 f[rs3]中的双精度
浮点数相加，将舍入后的双精度浮点数写入 f[rd]。

示例：

to do

fmsub.d

fmsub.d rd, rs1, rs2, rs3   //f[rd] = f[rs1]× f[rs2]-f[rs3]
双精度浮点乘减(Floating-point Fused Multiply-Subtract, Double-Precision). R4-type, RV32D and RV64D.
把寄存器 f[rs1]和 f[rs2]中的双精度浮点数相乘，并将未舍入的积减去寄存器 f[rs3]中的双精度浮点数，将舍入后的双精度浮点数写入 f[rd]。

示例：

to do

fnmsub.d

fnmsub.d rd, rs1, rs2, rs3   //f[rd] = -f[rs1]_f[rs2]+f[rs3]
双精度浮点乘取反减(Floating-point Fused Negative Multiply-Subtract, Double-Precision). R4-type, RV32D and RV64D.
把寄存器 f[rs1]和 f[rs2]中的双精度浮点数相乘，将结果取反，并将未舍入的积减去寄存器f[rs3]中的双精度浮点数，将舍入后的双精度浮点数写入 f[rd]。

示例：

to do

fnmadd.d

fnmadd.d rd, rs1, rs2, rs3   //f[rd] = f[rs1]× f[rs2]+f[rs3]
双精度浮点乘取反加(Floating-point Fused Negative Multiply-Add, Double-Precision). R4-type,RV32D and RV64D.
把寄存器 f[rs1]和 f[rs2]中的双精度浮点数相乘，将结果取反，并将未舍入的积和寄存器 f[rs3]中的双精度浮点数相加，将舍入后的双精度浮点数写入 f[rd]。

示例：

to do

fmadd.q

示例：

to do

fmsub.q

示例：

to do

fnmsub.q

示例：

to do

fnmadd.q

示例：

to do