QEMU 的 softfloat 源码位于 fpu/ 和 include/fpu/ 路径中，代码最初源自 Berkeley SoftFloat IEC/IEEE 浮点运算包的 2a 版本（SoftFloat-2a），后续经过 QEMU 项目贡献者修改。
目前我已经为 softfloat 添加了 tfloat32 和 float8e4m3 和 float8e5m2 的支持，可以从下面的仓库获取：
1git clone -b neural-network-softfloat https://gitee.com/gevico/qemu.git
源文件结构如下：
1include/fpu
2|-- softfloat-helpers.h # standalone helpers，用于初始化，比如设置舍入模式、异常模式等
3|-- softfloat-macros.h # QEMU 浮点支持宏
4|-- softfloat-types.h # 定义浮点精度和格式
5`-- softfloat.h # 对外使用的浮点接口，比如浮点运算，浮点精度转换
6
7fpu/
8|-- meson.build # 构建脚本
9|-- softfloat-parts-addsub.c.inc
10|-- softfloat-parts.c.inc
11|-- softfloat-specialize.c.inc # 浮点运算的一些特殊实现
12`-- softfloat.c # 浮点功能的核心源码
为 softfloat 添加一个新的浮点精度，分下面几步完成：
- 在 softfloat-types.h 中增加新的浮点精度定义
- 在 softfloat.c 中实现关键浮点运算函数
- 在 softfloat-specialize.c.inc 中实现特殊的浮点运算函数
- 在 softfloat.h 中添加浮点精度的接口声明
下面我们以添加 tfloat32（Tensor float32， TF32） 浮点精度为例，进行讲解。
一、在 softfloat-types.h 中增加新的浮点精度定义
tfloat32 的浮点格式如下：
tfloat32 内部计算时仍然按照 float32 进行运算，只不过输出的浮点值，仅保留 float32 小数位的前 10 位。
我们来添加 tfloat32 的定义。
1// path: include/fpu/softfoloat-types.h
2
3/*
4 * Software neural-network floating-point types.
5 */
6typedef uint16_t bfloat16;
7typedef uint32_t tfloat32; /* 添加 TF32 的定义 */
8
9/* 一些操作宏，参考其他精度定义 */
10#define tfloat32_val(x) (x)
11#define make_tfloat32(x) (x)
二、在 softfloat.c 中实现关键浮点运算函数
为了提高可移植性和代码复用，softfloat 采用 packet 和 unpacket 的形式，对浮点格式进行解包和打包，具体运算是将 浮点值解包以后，对浮点位、指数位、小数位进行分别计算。
因此我们需要先添加 tfloat32 的 float format 的定义，代码如下：
1// path: fpu/softfloat.c
2
3/* Expand fields based on the size of exponent and fraction */
4#define FLOAT_PARAMS_(E) \
5 .exp_size = E, \
6 .exp_bias = ((1 << E) - 1) >> 1, \
7 .exp_re_bias = (1 << (E - 1)) + (1 << (E - 2)), \
8 .exp_max = (1 << E) - 1
9
10#define FLOAT_PARAMS(E, F) \
11 FLOAT_PARAMS_(E), \
12 .frac_size = F, \
13 .frac_shift = (-F - 1) & 63, \
14 .round_mask = (1ull << ((-F - 1) & 63)) - 1
15
16/* 定义 tfloat32 的 floatfmt */
17static const FloatFmt tfloat32_params = {
18 FLOAT_PARAMS(8, 23)
19};
20
21/* Unpack a float to parts, but do not canonicalize. */
22static void unpack_raw64(FloatParts64 *r, const FloatFmt *fmt, uint64_t raw)
23{
24 const int f_size = fmt->frac_size;
25 const int e_size = fmt->exp_size;
26
27 *r = (FloatParts64) {
28 .cls = float_class_unclassified,
29 .sign = extract64(raw, f_size + e_size, 1),
30 .exp = extract64(raw, f_size, e_size),
31 .frac = extract64(raw, 0, f_size)
32 };
33}
34
35/* Pack a float from parts, but do not canonicalize. */
36static uint64_t pack_raw64(const FloatParts64 *p, const FloatFmt *fmt)
37{
38 const int f_size = fmt->frac_size;
39 const int e_size = fmt->exp_size;
40 uint64_t ret;
41
42 ret = (uint64_t)p->sign << (f_size + e_size);
43 ret = deposit64(ret, f_size, e_size, p->exp);
44 ret = deposit64(ret, 0, f_size, p->frac);
45 return ret;
46}
47
48/* 定义解包函数 */
49static void QEMU_FLATTEN tfloat32_unpack_raw(FloatParts64 *p, tfloat32 f)
50{
51 unpack_raw64(p, &tfloat32_params, f);
52}
53
54static void tfloat32_unpack_canonical(FloatParts64 *p, tfloat32 f,
55 float_status *s)
56{
57 tfloat32_unpack_raw(p, f);
58 parts_canonicalize(p, s, &tfloat32_params);
59}
60
61/* 定义组包函数，组包时只保留小数位前10位 */
62static tfloat32 QEMU_FLATTEN tfloat32_pack_raw(const FloatParts64 *p)
63{
64 /* The fraction is kept to only its first 10 bits. */
65 return pack_raw64(p, &tfloat32_params) & 0xFFFC0000;
66}
67
68/* 增加组包的舍入方式的封装 */
69static tfloat32 tfloat32_round_pack_canonical(FloatParts64 *p,
70 float_status *s)
71{
72 parts_uncanon(p, s, &tfloat32_params);
73 return tfloat32_pack_raw(p);
74}
然后我们添加具体的计算函数，数量比较多，我们以 addsub 和精度转换为例：
1static tfloat32 QEMU_FLATTEN
2tfloat32_addsub(tfloat32 a, tfloat32 b, float_status *status, bool subtract)
3{
4 FloatParts64 pa, pb, *pr;
5
6 tfloat32_unpack_canonical(&pa, a, status);
7 tfloat32_unpack_canonical(&pb, b, status);
8 pr = parts_addsub(&pa, &pb, status, subtract);
9
10 return tfloat32_round_pack_canonical(pr, status);
11}
12
13tfloat32 tfloat32_add(tfloat32 a, tfloat32 b, float_status *status)
14{
15 return tfloat32_addsub(a, b, status, false);
16}
17
18tfloat32 tfloat32_sub(tfloat32 a, tfloat32 b, float_status *status)
19{
20 return tfloat32_addsub(a, b, status, true);
21}
22
23/* 以 tfloat32 和 float32 的精度相互转换为例 */
24
25float32 tfloat32_to_float32(tfloat32 a, float_status *s)
26{
27 FloatParts64 p;
28
29 tfloat32_unpack_canonical(&p, a, s);
30 parts_float_to_float(&p, s);
31 return float32_round_pack_canonical(&p, s);
32}
33
34tfloat32 float32_to_tfloat32(float32 a, float_status *s)
35{
36 FloatParts64 p;
37
38 float32_unpack_canonical(&p, a, s);
39 parts_float_to_float(&p, s);
40 return tfloat32_round_pack_canonical(&p, s);
41}
三、在 softfloat-specialize.c.inc 中实现特殊的浮点运算函数
需要实现的函数只有两个，tfloat32_is_quiet_nan() 和 tfloat32_is_signaling_nan()。
1/*----------------------------------------------------------------------------
2| Returns 1 if the tfloat32 value `a' is a quiet
3| NaN; otherwise returns 0.
4*----------------------------------------------------------------------------*/
5
6bool tfloat32_is_quiet_nan(tfloat32 a_, float_status *status)
7{
8 if (no_signaling_nans(status)) {
9 return tfloat32_is_any_nan(a_);
10 } else {
11 uint32_t a = tfloat32_val(a_);
12 if (snan_bit_is_one(status)) {
13 return (((a >> 22) & 0x1FF) == 0x1FE) && (a & 0x003FFFFF);
14 } else {
15 return ((uint32_t)(a << 1) >= 0xFF800000);
16 }
17 }
18}
19
20/*----------------------------------------------------------------------------
21| Returns 1 if the tfloat32 value `a' is a signaling
22| NaN; otherwise returns 0.
23*----------------------------------------------------------------------------*/
24
25bool tfloat32_is_signaling_nan(tfloat32 a_, float_status *status)
26{
27 if (no_signaling_nans(status)) {
28 return 0;
29 } else {
30 uint32_t a = tfloat32_val(a_);
31 if (snan_bit_is_one(status)) {
32 return ((uint32_t)(a << 1) >= 0xFF800000);
33 } else {
34 return (((a >> 22) & 0x1FF) == 0x1FE) && (a & 0x003FFFFF);
35 }
36 }
37}
四、在 softfloat.h 中添加浮点精度的接口声明
除了要声明在 softfloat.c 和 softfloat-specialize.c.inc 中定义的 tfloat32 相关的函数，在 softfloat.h 头文件里还需要添加一些常用的内联函数。
代码实现如下, 摘要重要部分：
1static inline tfloat32 tfloat32_abs(tfloat32 a)
2{
3 /* Note that abs does *not* handle NaN specially, nor does
4 * it flush denormal inputs to zero.
5 */
6 return make_tfloat32(tfloat32_val(a) & 0x7fffffff);
7}
8
9static inline tfloat32 tfloat32_chs(tfloat32 a)
10{
11 /* Note that chs does *not* handle NaN specially, nor does
12 * it flush denormal inputs to zero.
13 */
14 return make_tfloat32(tfloat32_val(a) ^ 0x80000000);
15}
16
17static inline bool tfloat32_is_infinity(tfloat32 a)
18{
19 return (tfloat32_val(a) & 0x7fffffff) == 0x7f800000;
20}
21
22static inline bool tfloat32_is_neg(tfloat32 a)
23{
24 return tfloat32_val(a) >> 31;
25}
26
27static inline bool tfloat32_is_zero(tfloat32 a)
28{
29 return (tfloat32_val(a) & 0x7fffffff) == 0;
30}
31
32static inline bool tfloat32_is_any_nan(tfloat32 a)
33{
34 return ((tfloat32_val(a) & ~(1 << 31)) > 0x7f800000UL);
35}
36
37static inline bool tfloat32_is_zero_or_denormal(tfloat32 a)
38{
39 return (tfloat32_val(a) & 0x7f800000) == 0;
40}
41
42static inline bool tfloat32_is_normal(tfloat32 a)
43{
44 return (((tfloat32_val(a) >> 23) + 1) & 0xff) >= 2;
45}
46
47static inline bool tfloat32_is_denormal(tfloat32 a)
48{
49 return tfloat32_is_zero_or_denormal(a) && !tfloat32_is_zero(a);
50}
51
52static inline bool tfloat32_is_zero_or_normal(tfloat32 a)
53{
54 return tfloat32_is_normal(a) || tfloat32_is_zero(a);
55}
56
57static inline tfloat32 tfloat32_set_sign(tfloat32 a, int sign)
58{
59 return make_tfloat32((tfloat32_val(a) & 0x7fffffff) | (sign << 31));
60}
61
62static inline bool tfloat32_eq(tfloat32 a, tfloat32 b, float_status *s)
63{
64 return tfloat32_compare(a, b, s) == float_relation_equal;
65}
66
67static inline bool tfloat32_le(tfloat32 a, tfloat32 b, float_status *s)
68{
69 return tfloat32_compare(a, b, s) <= float_relation_equal;
70}
71
72static inline bool tfloat32_lt(tfloat32 a, tfloat32 b, float_status *s)
73{
74 return tfloat32_compare(a, b, s) < float_relation_equal;
75}
76
77static inline bool tfloat32_unordered(tfloat32 a, tfloat32 b, float_status *s)
78{
79 return tfloat32_compare(a, b, s) == float_relation_unordered;
80}
81
82static inline bool tfloat32_eq_quiet(tfloat32 a, tfloat32 b, float_status *s)
83{
84 return tfloat32_compare_quiet(a, b, s) == float_relation_equal;
85}
86
87static inline bool tfloat32_le_quiet(tfloat32 a, tfloat32 b, float_status *s)
88{
89 return tfloat32_compare_quiet(a, b, s) <= float_relation_equal;
90}
91
92static inline bool tfloat32_lt_quiet(tfloat32 a, tfloat32 b, float_status *s)
93{
94 return tfloat32_compare_quiet(a, b, s) < float_relation_equal;
95}
96
97static inline bool tfloat32_unordered_quiet(tfloat32 a, tfloat32 b,
98 float_status *s)
99{
100 return tfloat32_compare_quiet(a, b, s) == float_relation_unordered;
101}
102
103#define tfloat32_zero 0
104#define tfloat32_half 0x3f000000
105#define tfloat32_one 0x3f800000
106#define tfloat32_one_point_five 0x3fc00000
107#define tfloat32_two 0x40000000
108#define tfloat32_three 0x40400000
109#define tfloat32_infinity 0x7f800000
后续文章，我们将讲解如何基于 qemu 的 fpu 测试框架，验证我们新增浮点精度的正确性。