Does FROUND.H write an integer register?
No. The result is written to FP register f[rd] in the original precision; zero, infinity and NaN follow the special rules listed on this page.
FROUND.H
RISC-V FROUND.H Instruction Details
Instruction ManualR-typeRound a half-precision floating-point value to an integral value in the same FP format, without setting NX.
Instruction Syntax
fround.h rd, rs1[, rm]
Operand Breakdown
rd, rs1: FP registers f0–f31 or ABI names; f0 is writable and rd may overlap rs1.
rs1 is the only source; rs2=00100 is a fixed selector. Optional rm defaults to dyn; 111 uses frm. Static 101/110 and dynamic frm=101–111 have reserved behavior.
ZfaZfhFP Precision
Instruction Behavior
FROUND.H requires RV32/RV64 Zfa+Zfh and enabled FP state. It rounds the half-precision value in f[rs1] to an integral value according to rm and writes it in H format to f[rd]. Zero and infinity are copied unchanged. NaN results are canonical; signaling NaN accrues NV. It does not set NX. It sets no DZ, OF or UF and does not clear existing fflags.
FROUND.H Decode And Execute Animation
Shows the Zfa + Zfh-extension half-precision OP-FP flow: decode fields, read FP operands, perform FROUND semantics, then write rd.
rd
rs1
rm
fround.h
,
,
Leave rm empty to use the assembly default dyn encoding and fcsr.frm below.
Execution Context
FLEN>=32 / fmt=H (10)
rounding: RNE nearest-even
fflags: initial 0
31..27
26..25
24..20
19..15
14..12
11..7
6..0
01000
FROUND
10
fmt=H
00100
rs2=4 (roundToIntegral)
01011
rs1
000
rm
01010
rd
1010011
OP-FP
Execution Data Path
instruction
0x44458553
opcode
1010011 -> OP-FP
funct5/fmt
01000 + H(10) -> FROUND.H
rm
000 -> RNE nearest-even
rd/rs
fa0(f10) / fa1(f11) / rs2=00100 (fixed)
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; half-precision OP-FP instructions use opcode 1010011.
encoding: 0x44458553
syntax : fround.h fa0(f10), fa1(f11), rne
result : Not written yet; initial fflags=0
This bounded teaching model computes whitelisted finite examples plus zero, infinity, and NaN; FROUND.H writes the integral value in H format. Zero and infinity are copied. FROUND does not set NX and sets no exception flags other than NV.
Half-precision Calculation
rs1
fa1(f11) = 1.5
result
Awaiting Execute
This bounded teaching model computes whitelisted finite examples plus zero, infinity, and NaN; FROUND.H writes the integral value in H format. Zero and infinity are copied. FROUND does not set NX and sets no exception flags other than NV.
Assumes Zfa + Zfh, FS enabled, correctly NaN-boxed inputs, and initial fflags=0. Accepts the listed exact finite whitelist, signed zeros, infinity, qNaN, and sNaN. Rounding uses rm/frm; zero and infinity are copied, and sNaN sets NV. FROUND does not set NX. rd may overlap rs1, and f0 accepts writeback. Steps are teaching views.
This animation shows only Zfa + Zfh-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
FROUND.H rounds a half-precision value to an integral value in an FP register. It does not set NX. It does not convert to an integer register.
Requires Zfa 1.0 and Zfh; Zfa depends on F. rd and rs1 are FP registers f0–f31; f0 is writable and rd may overlap rs1.
32-bit OP-FP: funct5=01000, fmt=10 (H), rs2=00100, rs1, rm, rd, opcode=1010011. rs2 is a fixed selector, not a second source.
Optional rm defaults to dyn: 000/001/010/011/100 select rne/rtz/rdn/rup/rmm; 111 uses frm. Static 101/110 and dynamic frm=101–111 have reserved behavior.
Operands narrower than FLEN must be correctly NaN-boxed; otherwise they are treated as canonical NaNs in their format. Narrower results get their upper FLEN minus format-width bits set to ones.
Zero and infinity are copied unchanged; NaN results are canonical and signaling NaN accrues NV. It does not set NX. No DZ, OF or UF is set; existing fflags are not cleared and setting a flag does not itself cause an FP exception trap.
The animation assumes valid NaN-boxing and initial fflags=0. It accepts the listed exact finite whitelist plus signed zeros, infinity, qNaN and sNaN; arbitrary decimal inputs are not simulated.
The RISC-V Instruction Set Manual, Volume I: Unprivileged Architecture — Version 20260120, Zfa 1.0 §26.3; F 2.2 §§21.2–21.3The RISC-V Instruction Set Manual, Volume I: Unprivileged Architecture — Version 20260120, D §22.2; H/Q formats and conversionsThe RISC-V Instruction Set Manual, Volume II: Privileged Architecture — Version 20260120, §3.1.6.7RISC-V Assembly Programmer’s Manual — cover v0.0.0, 2025-02-05; release v0.0.1, Floating-point rounding modesRISC-V ABIs Specification — Version 1.0, §1.2 Table 2
Common Usage Scenarios
Floating-Point Rounding
Assume required extensions and FP state enabled, f11=1.5 in this format (validly NaN-boxed when narrower than FLEN), and initial fflags=0: the rne example writes f10=2.0 in an FP register; no exception flags are added, so fflags remains 0.
Numeric Format Handling
Assume required extensions and FP state enabled, f11=1.5 in this format (validly NaN-boxed when narrower than FLEN), and initial fflags=0: the rne example writes f10=2.0 in an FP register; no exception flags are added, so fflags remains 0.
Pre-Use Checklist
Syntax Check
- rd, rs1: FP registers f0–f31 or ABI names; f0 is writable and rd may overlap rs1.
- rs1 is the only source; rs2=00100 is a fixed selector. Optional rm defaults to dyn; 111 uses frm. Static 101/110 and dynamic frm=101–111 have reserved behavior.
Semantic Check
- Confirm Zfa, the matching precision extension, enabled FP state, and valid NaN-boxing for narrower sources.
- The result stays in the same FP format. Zero and infinity are copied; NaN results are canonical, and sNaN adds NV. No NX is added. No DZ, OF or UF is added; existing fflags are preserved.
Pitfalls / Common Confusions
FROUND does not set NX; use FROUNDNX to set NX when the input differs from the rounded result and is not NaN.
The result stays in an FP register; for an integer-register result use FCVT.W[U].H, or FCVT.L[U].H on RV64 only.
rm controls the direction for rounding to an integral value.
FAQ
How does FROUND.H differ from the other FROUND form?
FROUND does not set NX; FROUNDNX sets NX only when the input differs from the rounded result and is not NaN.