Return to fpu_fstore.c CVS log

Up to [local] / sys / arch / m68k / fpe

Annotation of sys/arch/m68k/fpe/fpu_fstore.c, Revision 1.1

1.1     ! nbrk        1: /*     $OpenBSD: fpu_fstore.c,v 1.6 2006/06/11 20:43:28 miod Exp $     */
        !             2: /*     $NetBSD: fpu_fstore.c,v 1.8 2003/07/15 02:43:10 lukem Exp $     */
        !             3:
        !             4: /*
        !             5:  * Copyright (c) 1995 Ken Nakata
        !             6:  * All rights reserved.
        !             7:  *
        !             8:  * Redistribution and use in source and binary forms, with or without
        !             9:  * modification, are permitted provided that the following conditions
        !            10:  * are met:
        !            11:  * 1. Redistributions of source code must retain the above copyright
        !            12:  *    notice, this list of conditions and the following disclaimer.
        !            13:  * 2. Redistributions in binary form must reproduce the above copyright
        !            14:  *    notice, this list of conditions and the following disclaimer in the
        !            15:  *    documentation and/or other materials provided with the distribution.
        !            16:  *
        !            17:  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
        !            18:  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
        !            19:  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
        !            20:  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
        !            21:  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
        !            22:  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
        !            23:  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
        !            24:  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
        !            25:  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
        !            26:  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
        !            27:  */
        !            28:
        !            29: #include <sys/types.h>
        !            30: #include <sys/signal.h>
        !            31: #include <sys/systm.h>
        !            32: #include <machine/frame.h>
        !            33:
        !            34: #include <m68k/fpe/fpu_emulate.h>
        !            35:
        !            36: /*
        !            37:  * type 0: fmove mem/fpr->fpr
        !            38:  * In this function, we know
        !            39:  *     (opcode & 0x01c0) == 0
        !            40:  *     (word1 & 0xe000) == 0x6000
        !            41:  */
        !            42: int
        !            43: fpu_emul_fstore(struct fpemu *fe, struct instruction *insn, int *typ)
        !            44: {
        !            45:     struct frame *frame = fe->fe_frame;
        !            46:     u_int *fpregs = fe->fe_fpframe->fpf_regs;
        !            47:     int word1, sig;
        !            48:     int regnum;
        !            49:     int format;
        !            50:     u_int buf[3];
        !            51:
        !            52: #if DEBUG_FPE
        !            53:     printf("  fpu_emul_fstore: frame at %p fpframe at %p\n",
        !            54:           frame, fe->fe_fpframe);
        !            55: #endif
        !            56:
        !            57:     word1 = insn->is_word1;
        !            58:     format = (word1 >> 10) & 7;
        !            59:     regnum = (word1 >> 7) & 7;
        !            60:
        !            61:     insn->is_advance = 4;
        !            62:
        !            63:     if (format == FTYPE_DBL) {
        !            64:        insn->is_datasize = 8;
        !            65:     } else if (format == FTYPE_SNG || format == FTYPE_LNG) {
        !            66:        insn->is_datasize = 4;
        !            67:     } else if (format == FTYPE_WRD) {
        !            68:        insn->is_datasize = 2;
        !            69:        format = FTYPE_LNG;
        !            70:     } else if (format == FTYPE_BYT) {
        !            71:        insn->is_datasize = 1;
        !            72:        format = FTYPE_LNG;
        !            73:     } else if (format == FTYPE_EXT) {
        !            74:        insn->is_datasize = 12;
        !            75:     } else {
        !            76:        /* invalid or unsupported operand format */
        !            77: #if DEBUG_FPE
        !            78:        printf("  fpu_emul_fstore: invalid format %d\n", format);
        !            79: #endif
        !            80:        *typ = ILL_ILLOPN;
        !            81:        sig = SIGILL;
        !            82:     }
        !            83: #if DEBUG_FPE
        !            84:     printf("  fpu_emul_fstore: format %d, size %d\n",
        !            85:           format, insn->is_datasize);
        !            86: #endif
        !            87:
        !            88:     fe->fe_fpsr &= ~FPSR_EXCP;
        !            89:
        !            90:     /* Get effective address. (modreg=opcode&077) */
        !            91:     sig = fpu_decode_ea(frame, insn, &insn->is_ea, insn->is_opcode, typ);
        !            92:     if (sig) {
        !            93: #if DEBUG_FPE
        !            94:        printf("  fpu_emul_fstore: failed in decode_ea sig=%d\n", sig);
        !            95: #endif
        !            96:        return sig;
        !            97:     }
        !            98:
        !            99:     if (insn->is_datasize > 4 && insn->is_ea.ea_flags == EA_DIRECT) {
        !           100:        /* trying to store dbl or ext into a data register */
        !           101: #ifdef DEBUG
        !           102:        printf("  fpu_fstore: attempted to store dbl/ext to reg\n");
        !           103: #endif
        !           104:        return SIGILL;
        !           105:     }
        !           106:
        !           107: #if DEBUG_FPE
        !           108:     printf("  fpu_emul_fstore: saving FP%d (%08x,%08x,%08x)\n",
        !           109:           regnum, fpregs[regnum * 3], fpregs[regnum * 3 + 1],
        !           110:           fpregs[regnum * 3 + 2]);
        !           111: #endif
        !           112:     fpu_explode(fe, &fe->fe_f3, FTYPE_EXT, &fpregs[regnum * 3]);
        !           113: #if DEBUG_FPE
        !           114:     {
        !           115:        static char *class_name[] = { "SNAN", "QNAN", "ZERO", "NUM", "INF" };
        !           116:        printf("  fpu_emul_fstore: fpn (%s,%c,%d,%08x,%08x,%08x)\n",
        !           117:               class_name[fe->fe_f3.fp_class + 2],
        !           118:               fe->fe_f3.fp_sign ? '-' : '+', fe->fe_f3.fp_exp,
        !           119:               fe->fe_f3.fp_mant[0], fe->fe_f3.fp_mant[1],
        !           120:               fe->fe_f3.fp_mant[2]);
        !           121:     }
        !           122: #endif
        !           123:     fpu_implode(fe, &fe->fe_f3, format, buf);
        !           124:
        !           125:     fpu_store_ea(frame, insn, &insn->is_ea, (char *)buf);
        !           126: #if DEBUG_FPE
        !           127:     printf("  fpu_emul_fstore: %08x,%08x,%08x size %d\n",
        !           128:           buf[0], buf[1], buf[2], insn->is_datasize);
        !           129: #endif
        !           130:
        !           131:     return 0;
        !           132: }