Return to host.c CVS log

Up to [Isaki's NoNo m68k/m88k emulator] / nono / fpe

Annotation of nono/fpe/host.c, revision 1.1

1.1     ! root        1: //
        !             2: // XM6i
        !             3: // Copyright (C) 2013 [email protected]
        !             4: //
        !             5: // for host FPU mode
        !             6: //
        !             7: 
        !             8: #include <float.h>
        !             9: #include <stdio.h>
        !            10: #include <string.h>
        !            11: 
        !            12: #include "cmake_config.h"
        !            13: #include "fpu_emulate.h"
        !            14: 
        !            15: /*
        !            16:  * M68881/2 の浮動小数点表現(IEEE754)をホストの浮動小数点表現に変換する。
        !            17:  */
        !            18: 
        !            19: /* ホスト演算用のダミー fpemu */
        !            20: static struct fpemu dummyfe;
        !            21: 
        !            22: float
        !            23: fpu_to_host_float(const uint32_t *src)
        !            24: {
        !            25:        return *(const float *)src;
        !            26: }
        !            27: 
        !            28: double
        !            29: fpu_to_host_double(const uint32_t *src)
        !            30: {
        !            31:        double dst = 0; /* shut up gcc */
        !            32:        uint32_t *d = (uint32_t *)&dst;
        !            33: 
        !            34:        d[1] = src[0];
        !            35:        d[0] = src[1];
        !            36:        return dst;
        !            37: }
        !            38: 
        !            39: #if defined(HAVE_LONG_DOUBLE)
        !            40: long double
        !            41: fpu_to_host_ldouble(const uint32_t *src)
        !            42: {
        !            43:        long double dst = 0;    /* shut up gcc */
        !            44:        uint32_t *d = (uint32_t *)&dst;
        !            45: 
        !            46: #if LONG_DOUBLE == 16
        !            47:        /* amd64 だと16バイト境界にしたいのでパディングがあるだけ */
        !            48:        d[3] = 0;
        !            49: #endif
        !            50:        /* intel フォーマットは16bitパディングの位置が 68881 とは逆 */
        !            51:        d[2] = src[0] >> 16;
        !            52:        d[1] = src[1];
        !            53:        d[0] = src[2];
        !            54: 
        !            55:        return dst;
        !            56: }
        !            57: #endif /* HAVE_LONG_DOUBLE */
        !            58: 
        !            59: void
        !            60: host_float_to_fpu(uint32_t *dst, float src)
        !            61: {
        !            62:        // stub
        !            63: }
        !            64: 
        !            65: void
        !            66: host_double_to_fpu(uint32_t *dst, double src)
        !            67: {
        !            68:        uint32_t *s = (uint32_t *)&src;
        !            69: 
        !            70:        dst[1] = s[0];
        !            71:        dst[0] = s[1];
        !            72: }
        !            73: 
        !            74: void
        !            75: host_ldouble_to_fpu(uint32_t *dst, long double src)
        !            76: {
        !            77:        // stub
        !            78: }
        !            79: 
        !            80: /*
        !            81:  * fpn 表現とホスト浮動小数点の変換
        !            82:  */
        !            83: 
        !            84: /*
        !            85:  * +-INF を作成して返す。
        !            86:  * 符号部は fp の符号を使うが、指数部/仮数部はこちらで用意する。
        !            87:  * 特に ISINF(fp) で判定した場合 fp の仮数部は不定なので流用してはいけない。
        !            88:  */
        !            89: static inline double
        !            90: fp2dbl_inf(const struct fpn *fp)
        !            91: {
        !            92:        uint64_t v;
        !            93: 
        !            94:        if (fp->fp_sign) {
        !            95:                // -INF
        !            96:                v = 0xfff0000000000000ULL;
        !            97:        } else {
        !            98:                // +INF
        !            99:                v = 0x7ff0000000000000ULL;
        !           100:        }
        !           101:        return *(double*)&v;
        !           102: }
        !           103: 
        !           104: double
        !           105: fp2dbl(const struct fpn *fp)
        !           106: {
        !           107:        int exp;
        !           108:        uint64_t v;
        !           109: 
        !           110:        if (ISNAN(fp)) {
        !           111:                exp = DBL_EXP_INFNAN;
        !           112:        } else if (ISINF(fp)) {
        !           113:                return fp2dbl_inf(fp);
        !           114:        } else {
        !           115:                exp = fp->fp_exp + DBL_EXP_BIAS;
        !           116:                // exp <= 0 は X 精度を D 精度にするとアンダーフローするケース。
        !           117:                if (ISZERO(fp) || exp <= 0) {
        !           118:                        if (fp->fp_sign) {
        !           119:                                return -0.0;
        !           120:                        } else {
        !           121:                                return 0.0;
        !           122:                        }
        !           123:                } else if (exp >= DBL_EXP_INFNAN) {
        !           124:                        return fp2dbl_inf(fp);
        !           125:                }
        !           126:        }
        !           127: 
        !           128:        v = (fp->fp_sign);
        !           129:        v <<= 11;
        !           130:        v |= exp;
        !           131:        v <<= FP_LG;
        !           132:        // mant の有効な上位の 52 ビットを取り出す
        !           133:        v |= fp->fp_mant[0] & (FP_1 - 1);
        !           134:        v <<= 32;
        !           135:        v |= fp->fp_mant[1];
        !           136:        v <<= 2;
        !           137:        v |= (fp->fp_mant[2] >> (32-2)) & 0x03;
        !           138: 
        !           139:        return *(double*)&v;
        !           140: }
        !           141: 
        !           142: long double
        !           143: fp2ldbl(const struct fpn *f)
        !           144: {
        !           145:        struct fpn fp;
        !           146:        uint32_t a[3];
        !           147: 
        !           148:        CPYFPN(&fp, f);
        !           149:        fpu_implode(&dummyfe, &fp, FTYPE_EXT, a);
        !           150:        return fpu_to_host_ldouble(a);
        !           151: }
        !           152: 
        !           153: void
        !           154: dbl2fp(struct fpn *fp, double src)
        !           155: {
        !           156:        uint32_t a[2];
        !           157: 
        !           158:        host_double_to_fpu(a, src);
        !           159:        fpu_explode(&dummyfe, fp, FTYPE_DBL, a);
        !           160:        return;
        !           161: }
        !           162: 
        !           163: void
        !           164: ldbl2fp(struct fpn *fp, long double src)
        !           165: {
        !           166:        // stub
        !           167: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.