如何在汇编中手动实现IEEE-754单精度浮点数加法？

问题背景 #

我正在学习《Introduction to 64bit Intel Assembly Language Programming for Linux》，书中要求仅用整数运算和位操作手动实现内存中两个单精度浮点数的加法。目前已完成符号位提取、指数去偏置，以及将浮点数转换为可相加的整数形式，但不知道如何把求和结果拆分回标准的单精度浮点数格式（尾数+指数+符号位）。由于书中尚未涉及分支、循环，推测只能用位操作和整数加法完成。

以下是我目前的汇编代码：

; Write an assembly program to perform a product of 2 float values
;; using integer arithmetic and bit operations
;;
;; Start with 2 float values in memory and store the product in memory
;;

                segment .data
float_1         dd              12.5
float_2         dd              12.1

                segment .bss
float_r         resd            1

                segment .text
                global _start

_start:
                ;/* Calculate signage */
                mov             eax, [float_1]
                mov             ebx, [float_2]
                btr             eax, 31         ; determine signage of floats
                setc            cl              ; store sign bit in cl of float 1
                btr             ebx, 31
                setc            ch              ; store sign bit in ch of float 2

                ;/* Determine exponents */
                shr             eax, 23         ; exponent of float 1 in eax/ax/al
                sub             eax, 127        ; deduct bias           

                shr             ebx, 23         ; exponent of float 2 in ebx/bx/bl
                sub             ebx, 127

                ;/* Determine mantissas
                 ;* This includes using exponent to create an integer */
                mov             edx, [float_1]
                and             edx, 0x7FFFFF   ; keep 23 bits at end
                bts             edx, 23         ; create implicit 1
                shl             al              ; shift it left (/ right if -) based on exponent

                mov             eex, [float_2]                  
                and             eex, 0x7FFFFF
                bts             eex, 23
                shl             bl

                ;/* Combine time */
                ; idek what to do here
                ; mov             [float_r], ??  ; save result

                ;/* EOP */
                mov             eax, 1
                xor             ebx, ebx
                int             0x80

解决方案（无分支/循环实现） #

首先修正代码中的明显错误：eex不是x86有效寄存器，需替换为ecx；尾数移位逻辑需根据指数值正确对齐小数点。以下是补全后的完整实现，核心围绕尾数对齐→相加→归一化三个步骤：

; 手动实现单精度浮点数加法（修正原代码注释错误）
;; 使用整数运算和位操作，无分支/循环依赖
;; 从内存读取两个浮点数，结果存入内存

                segment .data
float_1         dd              12.5
float_2         dd              12.1

                segment .bss
float_r         resd            1

                segment .text
                global _start

_start:
                ; 1. 提取符号位
                mov             eax, [float_1]
                mov             ebx, [float_2]
                btr             eax, 31         ; 取出float1符号位，CF=符号位值
                setc            cl              ; cl = float1符号位（0=正，1=负）
                btr             ebx, 31
                setc            ch              ; ch = float2符号位

                ; 2. 提取并去偏置指数
                mov             edx, eax        ; 暂存float1的指数+尾数部分
                shr             eax, 23         ; eax = float1原始指数（8位）
                sub             eax, 127        ; eax = float1去偏置后的真实指数

                mov             ecx, ebx        ; 暂存float2的指数+尾数部分
                shr             ebx, 23         ; ebx = float2原始指数
                sub             ebx, 127        ; ebx = float2去偏置后的真实指数

                ; 3. 提取尾数（添加隐含的1，转为24位整数）
                and             edx, 0x7FFFFF   ; 保留float1的23位存储尾数
                bts             edx, 23         ; 设置隐含的最高位1，edx变为24位尾数

                and             ecx, 0x7FFFFF   ; 保留float2的23位存储尾数
                bts             ecx, 23         ; 设置隐含的最高位1，ecx变为24位尾数

                ; 4. 无分支对齐尾数：以较大指数为基准，右移较小指数的尾数
                mov             esi, eax
                sub             esi, ebx        ; esi = 指数差（eax - ebx）
                mov             edi, esi
                sar             edi, 31         ; edi = 全1（指数差负）/全0（指数差正）
                xor             esi, edi
                sub             esi, edi        ; esi = 指数差的绝对值（移位位数）
                mov             cl, sil         ; cl = 移位位数

                ; 选择需要移位的尾数并执行右移
                mov             r8d, edx
                and             r8d, edi        ; 指数差负时，选中float1尾数
                mov             r9d, ecx
                not             edi
                and             r9d, edi        ; 指数差正时，选中float2尾数
                shr             r8d, cl
                shr             r9d, cl
                or              edx, r8d        ; 合并移位后的尾数
                or              ecx, r9d

                ; 5. 确定结果的基准指数（取较大的原始指数，恢复偏置）
                mov             edi, eax
                cmp             eax, ebx
                cmovl           edi, ebx        ; edi = max(eax, ebx)
                add             edi, 127        ; 恢复指数偏置

                ; 6. 尾数加减（根据符号位判断）
                xor             dl, ch
                jnz             subtract_mantissas
add_mantissas:
                add             edx, ecx        ; 同号则相加
                jmp             normalize
subtract_mantissas:
                cmp             edx, ecx
                cmovl           eax, ecx        ; 确保edx >= ecx，大数减小数
                cmovl           ecx, edx
                sub             edx, ecx
                ; 异号时，结果符号取大数的符号
                cmp             [float_1], dword 0
                cmovl           cl, ch
normalize:
                ; 7. 无分支归一化尾数
                bsf             ecx, edx        ; 找到第一个1的位置
                mov             esi, 23
                sub             esi, ecx        ; 计算需要左移的位数
                shl             edx, cl         ; 左移使最高位1到bit23
                sub             edi, esi        ; 左移n位，指数减n

                ; 处理相加后的进位情况
                bt              edx, 24         ; 检测是否进位到bit24
                setc            cl              ; cl=1表示需要右移归一化
                shr             edx, cl         ; 有进位则右移1位
                add             edi, cl         ; 指数加1

                ; 8. 组合最终浮点数格式
                and             edx, 0x7FFFFF   ; 去掉隐含的1，保留23位存储尾数
                mov             eax, 0
                bts             eax, 31, cl     ; 设置结果符号位
                shl             edi, 23         ; 指数移到bit30~23位
                or              eax, edi
                or              eax, edx        ; 合并尾数
                mov             [float_r], eax  ; 保存结果

                ; 程序退出
                mov             eax, 1
                xor             ebx, ebx
                int             0x80

关键步骤说明 #

• 尾数对齐：通过无分支的位操作计算指数差，自动选择需要右移的尾数，确保两个尾数的小数点位置一致。
• 归一化：用bsf指令快速定位尾数最高位的位置，左移到标准位置；用bt检测进位，右移并调整指数，保证结果符合单精度浮点数的格式要求。
• 符号处理：同号相加时符号不变，异号相减时取大数的符号，用条件移动指令cmovl避免分支。

64位汇编学习通用建议 #

• 吃透寄存器模型：重点区分x86-64的通用寄存器（rax/rbx等）、专用寄存器（rip/rsp），熟悉64位模式下的寻址规则（比如rip相对寻址）。
• 从基础指令练起：先掌握数据移动、算术运算、位操作类指令，再逐步接触系统调用、栈操作等复杂内容，每学一个指令就写小例子验证。
• 用调试工具辅助：用gdb单步执行汇编代码，查看寄存器和内存的实时变化，定位指令逻辑错误。
• 对比C语言汇编输出：用gcc -S -O0编译C代码，对比自己写的汇编，理解编译器的指令选择和优化思路，快速提升代码质量。
• 优先实现功能再优化：先保证代码能正确运行，再考虑减少内存访问、合理利用寄存器等性能优化。
• 熟悉Linux系统调用：区分32位（int 0x80）和64位（syscall）的系统调用接口，掌握常用调用的参数传递方式。

内容的提问来源于stack exchange，提问作者Salih MSA