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] = f32f64(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] = f64f32(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(s32f32(f[rs1]))
单精度浮点向字转换(Floating-point Convert to Word from Single). R-type, RV32F and RV64F.
把寄存器 f[rs1]中的单精度浮点数转化为 32 位二进制补码表示的整数,再写入 x[rd]中。

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

RV32FDQ/RV64RDQ指令集(2)_第1张图片

示例:

to do


fcvt.wu.s

fcvt.wu.s rd, rs1, rs2   //x[rd] = sext(u32f32(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] = s64f32(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] = u64f32(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]中有且仅有一位被置上,见下表

RV32FDQ/RV64RDQ指令集(2)_第2张图片

示例:

to do


fcvt.w.d

fcvt.w.d rd, rs1, rs2   //x[rd] = sext(s32f64(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(u32f64(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] = s64f64(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] = u64f64(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] = classifyd(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] = f32s32(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] = f32u32(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] = f32s64(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] = f32u64(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] = f64s32(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] = f64u32(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] = f64s64(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] = f64u64(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] = f64u64(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














你可能感兴趣的:(RV32FDQ/RV64RDQ指令集(2))