Is rd a floating-point register for FLTQ.D?
No. rd is an integer register holding the Boolean result 0 or 1.
FLTQ.D
RISC-V FLTQ.D Instruction Details
Instruction ManualR-typeDouble-precision floating-point quiet less-than comparison; writes x[rd]=1 when true, otherwise 0.
Instruction Syntax
fltq.d rd, rs1, rs2
Operand Breakdown
rd: destination integer register receiving a 0 or 1 comparison result.
rs1/rs2: source floating-point registers; compare instructions do not use an rm rounding mode.
ZfaDFloating-Point Compare
Instruction Behavior
FLTQ.D compares the double-precision floating-point values in f[rs1] and f[rs2] and writes the Boolean result to integer register rd. It is a quiet comparison: quiet NaNs do not set NV, signaling NaNs set NV, and any NaN operand makes the result 0. The result is not a floating-point value and is not rounded by rm.
FLTQ.D Decode And Execute Animation
Shows the Zfa + D-extension double-precision OP-FP flow: decode fields, read FP operands, perform FLTQ semantics, then write rd.
rd
rs1
rs2
fltq.d
,
,
Execution Context
FLEN>=64 / fmt=D (01)
funct3: quiet less-than compare
fflags: initial 0
31..27
26..25
24..20
19..15
14..12
11..7
6..0
10100
FLTQ
01
fmt=D
01100
rs2
01011
rs1
101
funct3=101
01010
rd
1010011
OP-FP
Execution Data Path
instruction
0xA2C5D553
opcode
1010011 -> OP-FP
funct5/fmt
10100 + D(01) -> FLTQ.D
funct3
101 -> quiet less-than compare
rd/rs
a0(x10) / fa1(f11) / fa2(f12)
read
Source registers not read yet
FP op
Awaiting Execute
write
Not written yet; initial fflags=0
Current Step
Fetch: show the 32-bit OP-FP encoding
The word is split as an R-type OP-FP instruction; double-precision OP-FP instructions use opcode 1010011.
encoding: 0xA2C5D553
syntax : fltq.d a0(x10), fa1(f11), fa2(f12)
result : Not written yet; initial fflags=0
The comparison result is written to integer register x[rd] and is only 0 or 1; compare instructions do not use rm.
Double-precision Calculation
rs1
fa1(f11) = 1.5
rs2
fa2(f12) = 2.25
result
Awaiting Execute
The comparison result is written to integer register x[rd] and is only 0 or 1; compare instructions do not use rm.
Assumes required extensions and FS enabled, valid NaN-boxing, and initial fflags=0. Finite inputs use the exact whitelist; signed zeros, infinities, qNaN, and sNaN are supported. Other inputs stop execution. One source register must have one initial value; rd=x0 discards only the integer write while NV still accrues. Steps are teaching views.
This animation shows only Zfa + D-extension ISA-visible OP-FP encoding, example numeric results, and fflags relationship; it does not model FPU pipelines, latency, every IEEE 754 corner case, or microarchitecture.
Quick Understanding & Search Notes
FLTQ.D writes the floating-point comparison result to integer register x[rd]. It has quiet-comparison semantics, useful when quiet NaNs should not raise NV.
It writes 1 when rs1 < rs2 is true, otherwise 0; any NaN operand writes 0.
Bits [14:12] are the funct3=101 comparison selector, not an rm rounding mode; rd is an integer register.
It requires Zfa+D (D depends on F); when FLEN exceeds 64, D operands are NaN-boxed and malformed boxes are treated as canonical NaNs.
Execute with the required extensions available and floating-point state enabled; rd=x0 discards the result, but a signaling NaN still accrues NV.
Common Usage Scenarios
Comparison & Detection
Understand this scenario with real code like «fltq.d x10, f11, f12 # x10 = (f11 < f12) ? 1 : 0; any NaN yields 0».
Floating-Point Conditions
Understand this scenario with real code like «fltq.d x10, f11, f12 # x10 = (f11 < f12) ? 1 : 0; any NaN yields 0».
Pre-Use Checklist
Syntax Check
- rd: destination integer register receiving a 0 or 1 comparison result.
- rs1/rs2: source floating-point registers; compare instructions do not use an rm rounding mode.
Semantic Check
- Confirm the result is written to an integer register and is only 0 or 1.
- Confirm quiet/signaling comparison behavior for NaNs and NV matches the need.
Pitfalls / Common Confusions
Quiet comparisons set NV only for signaling NaNs; a quiet NaN only makes the result 0.
rd is an integer register and receives 0 or 1, not a floating-point value.
The comparison does not use the rm rounding mode.
FAQ
What happens on NaN operands?
Any NaN operand makes the result 0; only signaling NaNs set NV.