tests/fp/wrap.c.inc

67 static extFloat80_t qemu_to_soft80(floatx80 a)
71     ret.signif = a.low;
72     ret.signExp = a.high;
76 static floatx80 soft_to_qemu80(extFloat80_t a)
80     ret.low = a.signif;
81     ret.high = a.signExp;
85 static float128_t qemu_to_soft128(float128 a)
90     to->v0 = a.low;
91     to->v64 = a.high;
95 static float128 soft_to_qemu128(float128_t a)
97     struct uint128 *from = (struct uint128 *)&a;
107     static b_type##_t name(a_type##_t a)                \
109         a_type *ap = (a_type *)&a;                      \
124     static b_type##_t name(a_type##_t a)                \
126         a_type *ap = (a_type *)&a;                      \
138     static void name(type##_t a, extFloat80_t *res)     \
141         type *ap = (type *)&a;                          \
152     static void name(type##_t a, float128_t *res)       \
155         type *ap = (type *)&a;                          \
167     static fast_type name(type##_t a, uint_fast8_t round, bool exact)   \
169         type *ap = (type *)&a;                                          \
196     static fast_type name(type##_t a, bool exact)               \
198         type *ap = (type *)&a;                                  \
237         floatx80 a;                                     \
240         a = soft_to_qemu80(*ap);                        \
241         ret = func(a, &qsf);                            \
252         float128 a;                             \
255         a = soft_to_qemu128(*ap);               \
256         ret = func(a, &qsf);                    \
285     static type##_t name(int_type a)                    \
289         ret = func(a, &qsf);                            \
311     static void name(int_type a, extFloat80_t *res)     \
315         ret = func(a, &qsf);                            \
328         floatx80 a;                                                     \
330         a = soft_to_qemu80(*ap);                                        \
332         return func(a, &qsf);                                           \
343         floatx80 a;                                             \
345         a = soft_to_qemu80(*ap);                                \
346         return func(a, &qsf);                                   \
360         float128 a;                                                     \
362         a = soft_to_qemu128(*ap);                                       \
364         return func(a, &qsf);                                           \
378         float128 a;                                             \
380         a = soft_to_qemu128(*ap);                               \
381         return func(a, &qsf);                                   \
396     static void name(int_type a, float128_t *res)       \
400         ret = func(a, &qsf);                            \
412     static type##_t name(type##_t a, uint_fast8_t round, bool exact)    \
414         type *ap = (type *)&a;                                          \
430     floatx80 a;
433     a = soft_to_qemu80(*ap);
435     ret = floatx80_round_to_int(a, &qsf);
442     float128 a;
445     a = soft_to_qemu128(*ap);
447     ret = float128_round_to_int(a, &qsf);
453     static type##_t name(type##_t a)            \
455         type *ap = (type *)&a;                  \
463     static type##_t name(type##_t a, type##_t b)        \
465         type *ap = (type *)&a;                          \
493         floatx80 a;                                             \
496         a = soft_to_qemu80(*ap);                                \
497         ret = func(a, &qsf);                                    \
507         float128 a;                                             \
510         a = soft_to_qemu128(*ap);                               \
511         ret = func(a, &qsf);                                    \
522         floatx80 a;                                                     \
526         a = soft_to_qemu80(*ap);                                        \
528         ret = func(a, b, &qsf);                                         \
543         float128 a;                                                     \
547         a = soft_to_qemu128(*ap);                                       \
549         ret = func(a, b, &qsf);                                         \
561     static type##_t name(type##_t a, type##_t b, type##_t c)    \
563         type *ap = (type *)&a;                                  \
580     float128 a, b, c, ret;
582     a = soft_to_qemu128(*ap);
585     ret = float128_muladd(a, b, c, 0, &qsf);
590     static bool name(float16_t a, float16_t b)  \
592         float16 *ap = (float16 *)&a;            \
609     static bool name(type##_t a, type##_t b)    \
611         type *ap = (type *)&a;                  \
633         floatx80 a;                                                     \
636         a = soft_to_qemu80(*ap);                                        \
638         return !!func(a, b, &qsf);                                      \
652         float128 a;                                                     \
655         a = soft_to_qemu128(*ap);                                       \
657         return !!func(a, b, &qsf);                                      \