← Home

FMOV (general)

Floating-point move to or from general-purpose register without conversion

This instruction transfers the contents of a SIMD&FP register to a general-purpose register, or the contents of a general-purpose register to a SIMD&FP register.

Depending on the settings in the CPACR_EL1, CPTR_EL2, and CPTR_EL3 registers, and the current Security state and Exception level, an attempt to execute the instruction might be trapped.

313029282726252423222120191817161514131211109876543210
sf0011110ftype10x11x000000RnRd
Srmodeopcode

Half-precision to 32-bit encoding

(FEAT_FP16)

(sf == 0 && ftype == 11 && rmode == 00 && opcode == 110)

FMOV <Wd>, <Hn>

Half-precision to 64-bit encoding

(FEAT_FP16)

(sf == 1 && ftype == 11 && rmode == 00 && opcode == 110)

FMOV <Xd>, <Hn>

32-bit to half-precision encoding

(FEAT_FP16)

(sf == 0 && ftype == 11 && rmode == 00 && opcode == 111)

FMOV <Hd>, <Wn>

32-bit to single-precision encoding

(FEAT_FP)

(sf == 0 && ftype == 00 && rmode == 00 && opcode == 111)

FMOV <Sd>, <Wn>

Single-precision to 32-bit encoding

(FEAT_FP)

(sf == 0 && ftype == 00 && rmode == 00 && opcode == 110)

FMOV <Wd>, <Sn>

64-bit to half-precision encoding

(FEAT_FP16)

(sf == 1 && ftype == 11 && rmode == 00 && opcode == 111)

FMOV <Hd>, <Xn>

64-bit to double-precision encoding

(FEAT_FP)

(sf == 1 && ftype == 01 && rmode == 00 && opcode == 111)

FMOV <Dd>, <Xn>

64-bit to top half of 128-bit encoding

(FEAT_FP)

(sf == 1 && ftype == 10 && rmode == 01 && opcode == 111)

FMOV <Vd>.D[1], <Xn>

Double-precision to 64-bit encoding

(FEAT_FP)

(sf == 1 && ftype == 01 && rmode == 00 && opcode == 110)

FMOV <Xd>, <Dn>

Top half of 128-bit to 64-bit encoding

(FEAT_FP)

(sf == 1 && ftype == 10 && rmode == 01 && opcode == 110)

FMOV <Xd>, <Vn>.D[1]

Decode (all encodings)

if !IsFeatureImplemented(FEAT_FP) then EndOfDecode(Decode_UNDEF); if ftype == '10' && opcode<2:1>:rmode != '11 01' then EndOfDecode(Decode_UNDEF); if ftype == '11' && !IsFeatureImplemented(FEAT_FP16) then EndOfDecode(Decode_UNDEF); constant integer d = UInt(Rd); constant integer n = UInt(Rn); constant integer intsize = 32 << UInt(sf); constant integer fltsize = if ftype == '10' then 64 else (8 << UInt(ftype EOR '10')); constant integer part = UInt(rmode<0>); FPConvOp op; case opcode<2:1>:rmode of when '11 00' // FMOV if fltsize != 16 && fltsize != intsize then EndOfDecode(Decode_UNDEF); op = if opcode<0> == '1' then FPConvOp_MOV_ItoF else FPConvOp_MOV_FtoI; when '11 01' // FMOV D[1] if intsize != 64 || ftype != '10' then EndOfDecode(Decode_UNDEF); op = if opcode<0> == '1' then FPConvOp_MOV_ItoF else FPConvOp_MOV_FtoI; otherwise Unreachable();

Assembler Symbols

<Wd>

Is the 32-bit name of the general-purpose destination register, encoded in the "Rd" field.

<Hn>

Is the 16-bit name of the SIMD&FP source register, encoded in the "Rn" field.

<Xd>

Is the 64-bit name of the general-purpose destination register, encoded in the "Rd" field.

<Hd>

Is the 16-bit name of the SIMD&FP destination register, encoded in the "Rd" field.

<Wn>

Is the 32-bit name of the general-purpose source register, encoded in the "Rn" field.

<Sd>

Is the 32-bit name of the SIMD&FP destination register, encoded in the "Rd" field.

<Sn>

Is the 32-bit name of the SIMD&FP source register, encoded in the "Rn" field.

<Xn>

Is the 64-bit name of the general-purpose source register, encoded in the "Rn" field.

<Dd>

Is the 64-bit name of the SIMD&FP destination register, encoded in the "Rd" field.

<Vd>

Is the name of the SIMD&FP destination register, encoded in the "Rd" field.

<Dn>

Is the 64-bit name of the SIMD&FP source register, encoded in the "Rn" field.

<Vn>

Is the name of the SIMD&FP source register, encoded in the "Rn" field.

Operation

AArch64.CheckFPEnabled(); bits(fltsize) fltval; bits(intsize) intval; case op of when FPConvOp_MOV_FtoI fltval = Vpart[n, part, fltsize]; X[d, intsize] = ZeroExtend(fltval, intsize); when FPConvOp_MOV_ItoF intval = X[n, intsize]; Vpart[d, part, fltsize] = intval<fltsize-1:0>; otherwise Unreachable();

Operational information

If FEAT_SME is implemented and the PE is in Streaming SVE mode, then any subsequent instruction which is dependent on the general-purpose register written by this instruction might be significantly delayed.


Version 2025.09 — Copyright © 2010-2025 Arm Limited or its affiliates.

This site is provided as a community resource and is NOT affiliated with nor endorsed by Arm Limited.