Aarch64架构下如何处理80位浮点数的读取与格式化？

Aarch64架构的FPU（NEON/VFP）原生不支持x87风格的80位long double，没法像x64那样用汇编指令直接转换，得通过软件解析80位浮点数的结构，再转成double格式。以下是具体实现方案：

核心思路 #

80位x87浮点数的结构是：

• 1位符号位
• 15位指数（偏移量16383）
• 64位尾数（带隐藏的最高位1，非规格化数除外）

我们需要把这个结构映射到64位double的结构（1位符号、11位指数偏移1023、52位尾数），处理指数转换、尾数截断，以及特殊值（NaN、无穷大、零）的情况。

实现代码 #

#include <cstdint>
#include <cmath>
#include <limits>

// 从内存读取80位x87格式long double，转换为double
void convert_x87_ldbl_to_double(const uint8_t* x87_ldbl_buf, double* out_double) {
    // 解析80位数据的各个部分：字节0-7是尾数低64位，字节8是指数低8位，字节9是符号位+指数高7位
    uint64_t mantissa = 0;
    for (int i = 7; i >= 0; --i) {
        mantissa = (mantissa << 8) | x87_ldbl_buf[i];
    }
    uint16_t exp_sign = (static_cast<uint16_t>(x87_ldbl_buf[9]) << 8) | x87_ldbl_buf[8];
    bool is_negative = (exp_sign & 0x8000) != 0;
    int16_t x87_exp = static_cast<int16_t>(exp_sign & 0x7FFF) - 16383;

    // 处理特殊值：NaN、无穷大
    if (x87_exp == 16384) {
        if (mantissa != 0) {
            *out_double = std::numeric_limits<double>::quiet_NaN();
        } else {
            *out_double = is_negative ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity();
        }
        return;
    }

    // 处理零值
    if (x87_exp == -16383 && mantissa == 0) {
        *out_double = is_negative ? -0.0 : 0.0;
        return;
    }

    int double_exp = x87_exp + 1023;
    uint64_t double_mantissa = 0;

    if (x87_exp == -16383) {
        // x87非规格化数：无隐藏位，需要左移调整指数
        int leading_zeros = __builtin_clzll(mantissa);
        int shift = leading_zeros - (64 - 63); // 把尾数最高位移到第63位（对应double的隐藏位）
        double_exp = 1023 - shift;
        double_mantissa = (mantissa << shift) >> 12; // 截断到52位
    } else {
        // 规格化数：带上隐藏位后截断尾数到52位
        double_mantissa = mantissa >> 12;
        // 处理指数溢出/下溢
        if (double_exp > 2047) {
            *out_double = is_negative ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity();
            return;
        } else if (double_exp <= 0) {
            // 转为double的非规格化数
            int shift = 1 - double_exp;
            double_mantissa = ((mantissa | (1ULL << 63)) >> (12 + shift)) & 0xFFFFFFFFFFFFF;
            double_exp = 0;
        }
    }

    // 组装double的二进制表示
    uint64_t double_bits = (static_cast<uint64_t>(is_negative) << 63) | 
                           (static_cast<uint64_t>(double_exp & 0x7FF) << 52) | 
                           double_mantissa;
    *out_double = *reinterpret_cast<double*>(&double_bits);
}

使用方法 #

把内存中存储80位浮点数的缓冲区传入convert_x87_ldbl_to_double，得到double后直接打印即可，精度损失和你x64方案一致，可接受。

注意事项 #

• __builtin_clzll是VS、GCC、Clang都支持的内置函数，用于计算64位整数的前导零个数，Aarch64架构下可用。
• 代码已处理所有边界情况：零、非规格化数、无穷大、NaN，以及指数溢出/下溢。

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