Skip to main content
Engineering LibreTexts

18.5: Floating-Point Arithmetic Instructions

  1. Last updated
  2. Save as PDF
  • Page ID
    19978

    • \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \) \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)\(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\) \(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\)\(\newcommand{\AA}{\unicode[.8,0]{x212B}}\)

    The floating-point arithmetic instructions perform arithmetic operations such as add, subtract, multiplication, and division on single or double precision floating-point values. The following sections present the basic arithmetic operations.

    Floating-Point Addition

    The general form of the floating-point addition instructions are as follows:

         addss    <RXdest>, <src>
     addsd    <RXdest>, <src>

    Where operation is as follows:

         <RXdest> = <RXdest> + <src>

    Specifically, the source and destination operands are added and the result is placed in the destination operand (over-writing the previous value). The destination operand must be a floating-point register. The source operand may not be an immediate value. The value of the source operand is unchanged. The destination and source operand must be of the same size (double-words or quadwords). If a memory to memory addition operation is required, two instructions must be used.

    For example, assuming the following data declarations:

        fSNum1    dd    43.75
    fSNum2    dd    15.5
    fSAns     dd    0.0

    fDNum3    dq    200.12
    fDNum4    dq    73.2134
    fDAns     dq    0.0

    To perform the basic operations of:

        fSAns = fSNum1 + fSNum2
    fDAns = fDNum3 + fDNum4

    The following instructions could be used:

        ; fSAns = fSNum1 + fSNum2
    movss    xmm0, dword [fSNum1]
    addss    xmm0, dword [fSNum2]
    movss    dword [fSAns], xmm0
    ; fDAns = fDNum3 + fDNum4
    movsd    xmm0, qword [fDNum3]
    addsd    xmm0, qword [fDNum4]
    movsd    qword [fDAns], xmm0

    For some instructions, including those above, the explicit type specification (e.g., dword, qword) can be omitted as the other operand or the instruction itself clearly defines the size. It is included for consistency and good programming practices.

    The floating-point addition instructions are summarized as follows:

    Instruction

    Explanation 

    addss   <RXdest>, <src>

    Add two 32-bit floating-point operands, (<RXdest> + <src>) and place the result in <RXdest> (over-writing previous value).
    Note 1, destination operands must be a floating-point register.
    Note 2, source operand cannot be an immediate.

    Examples:

    		 
    addss   xmm0, xmm3
addss   xmm5, dword [fSVar]

    addsd   <RXdest>, <src>

    Add two 64-bit floating-point operands, (<RXdest> + <src>) and place the result in <RXdest> (over-writing previous value).
    Note 1, destination operands must be a floating-point register.
    Note 2, source operand cannot be an immediate.

    Examples:

    		 
    addsd   xmm0, xmm3
addsd   xmm5, qword [fDVar]

    A more complete list of the instructions is located in Appendix B.

    Floating-Point Subtraction

    The general form of the floating-point subtraction instructions are as follows:

         subss    <RXdest>, <src>
     subsd    <RXdest>, <src>

    Where operation is as follows:

         <RXdest> = <RXdest> - <src>

    Specifically, the source and destination operands are subtracted and the result is placed in the destination operand (over-writing the previous value). The destination operand must be a floating-point register. The source operand may not be an immediate value. The value of the source operand is unchanged. The destination and source operand must be of the same size (double-words or quadwords). If a memory to memory addition operation is required, two instructions must be used.

    For example, assuming the following data declarations:

        fSNum1    dd    43.75
    fSNum2    dd    15.5
    fSAns     dd    0.0

    fDNum3    dq    200.12
    fDNum4    dq    73.2134
    fDAns     dq    0.0

    To perform the basic operations of:

        fSAns = fSNum1 - fSNum2
    fDAns = fDNum3 - fDNum4

    The following instructions could be used:

        ; fSAns = fSNum1 - fSNum2
    movss    xmm0, dword [fSNum1]
    subss    xmm0, dword [fSNum2]
    movss    dword [fSAns], xmm0
    
    ;fSAns = fSNum3 - fSNum4
    movsd    xmm0, qword [fSNum1]
    subsd    xmm0, qword [fSNum2]
    movsd    qword [fSAns], xmm0

    For some instructions, including those above, the explicit type specification (e.g., dword, qword) can be omitted as the other operand or the instruction itself clearly defines the size. It is included for consistency and good programming practices.

    The floating-point subtraction instructions are summarized as follows:

    Instruction

    Explanation 

    subss   <RXdest>, <src>

    Subtract two 32-bit floating-point operands, (<RXdest> - <src>) and place the result in <RXdest> (over-writing previous value).
    Note 1, destination operands must be a floating-point register.
    Note 2, source operand cannot be an immediate.

    Examples:

    		 
    subss   xmm0, xmm3
subss   xmm5, dword [fSVar]

    subsd   <RXdest>, <src>

    Subtract two 64-bit floating-point operands, (<RXdest> - <src>) and place the result in <RXdest> (over-writing previous value).
    Note 1, destination operands must be a floating-point register.
    Note 2, source operand cannot be an immediate.

    Examples:

    		 
    subsd   xmm0, xmm3
subsd   xmm5, qword [fDVar]

    A more complete list of the instructions is located in Appendix B.

    Floating-Point Multiplication

    The general form of the floating-point multiplication instructions are as follows:

         mulss    <RXdest>, <src>
     mulsd    <RXdest>, <src>

    Where operation is as follows:

         <RXdest> = <RXdest> * <src>

    Specifically, the source and destination operands are multiplied and the result is placed in the destination operand (over-writing the previous value). The destination operand must be a floating-point register. The source operand may not be an immediate value. The value of the source operand is unchanged. The destination and source operand must be of the same size (double-words or quadwords). If a memory to memory addition operation is required, two instructions must be used.

    For example, assuming the following data declarations:

        fSNum1    dd    43.75
    fSNum2    dd    15.5
    fSAns     dd    0.0

    fDNum3    dq    200.12
    fDNum4    dq    73.2134
    fDAns     dq    0.0

    To perform the basic operations of:

        fSAns = fSNum1 * fSNum2
    fDAns = fDNum3 * fDNum4

    The following instructions could be used:

        ; fSAns = fSNum1 * fSNum2
    movss    xmm0, dword [fSNum1]
    mulss    xmm0, dword [fSNum2]
    movss    dword [fSAns], xmm0
    
    ; fSAns = fSNum3 * fSNum4
    movsd    xmm0, dworq [fSNum3]
    mulsd    xmm0, dworq [fSNum4]
    movsd    qword [fSAns], xmm0

    For some instructions, including those above, the explicit type specification (e.g., dword, qword) can be omitted as the other operand or the instruction itself clearly defines the size. It is included for consistency and good programming practices.

    The floating-point multiplication instructions are summarized as follows:

    Instruction

    Explanation 

    mulss   <RXdest>, <src>

    Multiply two 32-bit floating-point operands, (<RXdest> * <src>) and place the result in <RXdest> (over-writing previous value).
    Note 1, destination operands must be a floating-point register.
    Note 2, source operand cannot be an immediate.

    Examples:

    		 
    mulss   xmm0, xmm3
mulss   xmm5, dword [fSVar]

    mulsd   <RXdest>, <src>

    Multiply two 64-bit floating-point operands, (<RXdest> * <src>) and place the result in <RXdest> (over-writing previous value).
    Note 1, destination operands must be a floating-point register.
    Note 2, source operand cannot be an immediate.

    Examples:

    		 
    mulsd   xmm0, xmm3
mulsd   xmm5, qword [fDVar]

    A more complete list of the instructions is located in Appendix B.

    Floating-Point Division

    The general form of the floating-point division instructions are as follows:

         divss    <RXdest>, <src>
     divsd    <RXdest>, <src>

    Where operation is as follows:

         <RXdest> = <RXdest> / <src>

    Specifically, the source and destination operands are divided and the result is placed in the destination operand (over-writing the previous value). The destination operand must be a floating-point register. The source operand may not be an immediate value. The value of the source operand is unchanged. The destination and source operand must be of the same size (double-words or quadwords). If a memory to memory addition operation is required, two instructions must be used.

    For example, assuming the following data declarations:

        fSNum1    dd    43.75
    fSNum2    dd    15.5
    fSAns     dd    0.0

    fDNum3    dq    200.12
    fDNum4    dq    73.2134
    fDAns     dq    0.0

    To perform the basic operations of:

        fSAns = fSNum1 / fSNum2
    fDAns = fDNum3 / fDNum4

    The following instructions could be used:

        ; fSAns = fSNum1 / fSNum2
    movss    xmm0, dword [fSNum1]
    divss    xmm0, dword [fSNum2]
    movss    dword [fSAns], xmm0
    
    ; fSAns = fSNum3 / fSNum4
    movsd    xmm0, qword [fSNum3]
    divsd    xmm0, qword [fSNum4]
    movsd    qword [fSAns], xmm0

    For some instructions, including those above, the explicit type specification (e.g., dword, qword) can be omitted as the other operand or the instruction itself clearly defines the size. It is included for consistency and good programming practices.

    The floating-point division instructions are summarized as follows:

    Instruction

    Explanation 

    divss   <RXdest>, <src>

    Divide two 32-bit floating-point operands, (<RXdest> / <src>) and place the result in <RXdest> (over-writing previous value).
    Note 1, destination operands must be a floating-point register.
    Note 2, source operand cannot be an immediate.

    Examples:

    		 
    divss   xmm0, xmm3
divss   xmm5, dword [fSVar]

    divsd   <RXdest>, <src>

    Divide two 64-bit floating-point operands, (<RXdest> / <src>) and place the result in <RXdest> (over-writing previous value).
    Note 1, destination operands must be a floating-point register.
    Note 2, source operand cannot be an immediate.

    Examples:

    		 
    divsd   xmm0, xmm3
divsd   xmm5, qword [fDVar]

    A more complete list of the instructions is located in Appendix B.

    Floating-Point Square Root

    The general form of the floating-point square root instructions are as follows:

         sqrtss    <RXdest>, <src>
     sqrtsd    <RXdest>, <src>

    Where operation is as follows:

        <dest> = √ <src>

    Specifically, the square root of the source operand is placed in the destination operand (over-writing the previous value). The destination operand must be a floating-point register. The source operand may not be an immediate value. The value of the source operand is unchanged. The destination and source operand must be of the same size (double-words or quadwords). If a memory to memory addition operation is required, two instructions must be used.

    For example, assuming the following data declarations:

        fSNum1     dd    1213.0
    fSAns      dd    0.0

    fDNum3     dq    172935.123
    fDAns      dq    0.0

    To perform the basic operations of:

        fSAns = √ fSNum1 
    fDAns = √ fSNum3

    The following instructions could be used:

        ; fSAns = sqrt (fSNum1)
    sqrtss     xmm0, dword [fSNum1] 
    movss      dword [fSAns], xmm0
    
    ; fDAns = sqrt(fDNum3)
    sqrtsd     xmm0, qword [fDNum3] 
    movsd      qword [fDAns], xmm0

    For some instructions, including those above, the explicit type specification (e.g., dword, qword) can be omitted as the other operand or the instruction itself clearly defines the size. It is included for consistency and good programming practices.

    The floating-point addition instructions are summarized as follows:

    Instruction

    Explanation 

    sqrtss   <RXdest>, <src>

    Take the square root of the 32-bit floating- point source operand and place the result in destination operand (over-writing previous value).

    Note 1, destination operands must be a floating-point register.
    Note 2, source operand cannot be an immediate.

    Examples:

    		 
    sqrtss   xmm0, xmm3
sqrtss   xmm7, dword [fSVar]

    sqrtsd   <RXdest>, <src>

    Take the square root of the 64-bit floating- point source operand and place the result in destination operand (over-writing previous value).

    Note 1, destination operands must be a floating-point register.
    Note 2, source operand cannot be an immediate.

    Examples:

    		 
    sqrtsd   xmm0, xmm3
sqrtsd   xmm7, qword [fDVar]

    A more complete list of the instructions is located in Appendix B.

    This page titled 18.5: Floating-Point Arithmetic Instructions is shared under a CC BY-NC-SA license and was authored, remixed, and/or curated by Ed Jorgensen.

    1. Back to top
    • Was this article helpful?

    Recommended articles

    1. Article type
      Section or Page
      Author
      Ed Jorgensen
      Autonumber Section Headings
      title with colon delimiters
      License
      CC BY-NC-SA
      Show TOC
      no
    2. Tags
      This page has no tags.