Return to fpa11_cpdo.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / linux-user / arm / nwfpe

Annotation of qemu/linux-user/arm/nwfpe/fpa11_cpdo.c, revision 1.1

1.1     ! root        1: /*
        !             2:     NetWinder Floating Point Emulator
        !             3:     (c) Rebel.COM, 1998,1999
        !             4: 
        !             5:     Direct questions, comments to Scott Bambrough <[email protected]>
        !             6: 
        !             7:     This program is free software; you can redistribute it and/or modify
        !             8:     it under the terms of the GNU General Public License as published by
        !             9:     the Free Software Foundation; either version 2 of the License, or
        !            10:     (at your option) any later version.
        !            11: 
        !            12:     This program is distributed in the hope that it will be useful,
        !            13:     but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            14:     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            15:     GNU General Public License for more details.
        !            16: 
        !            17:     You should have received a copy of the GNU General Public License
        !            18:     along with this program; if not, write to the Free Software
        !            19:     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
        !            20: */
        !            21: 
        !            22: #include "fpa11.h"
        !            23: #include "fpopcode.h"
        !            24: 
        !            25: unsigned int SingleCPDO(const unsigned int opcode);
        !            26: unsigned int DoubleCPDO(const unsigned int opcode);
        !            27: unsigned int ExtendedCPDO(const unsigned int opcode);
        !            28: 
        !            29: unsigned int EmulateCPDO(const unsigned int opcode)
        !            30: {
        !            31:    FPA11 *fpa11 = GET_FPA11();
        !            32:    unsigned int Fd, nType, nDest, nRc = 1;
        !            33: 
        !            34:    //printk("EmulateCPDO(0x%08x)\n",opcode);
        !            35: 
        !            36:    /* Get the destination size.  If not valid let Linux perform
        !            37:       an invalid instruction trap. */
        !            38:    nDest = getDestinationSize(opcode);
        !            39:    if (typeNone == nDest) return 0;
        !            40: 
        !            41:    SetRoundingMode(opcode);
        !            42: 
        !            43:    /* Compare the size of the operands in Fn and Fm.
        !            44:       Choose the largest size and perform operations in that size,
        !            45:       in order to make use of all the precision of the operands.
        !            46:       If Fm is a constant, we just grab a constant of a size
        !            47:       matching the size of the operand in Fn. */
        !            48:    if (MONADIC_INSTRUCTION(opcode))
        !            49:      nType = nDest;
        !            50:    else
        !            51:      nType = fpa11->fType[getFn(opcode)];
        !            52: 
        !            53:    if (!CONSTANT_FM(opcode))
        !            54:    {
        !            55:      register unsigned int Fm = getFm(opcode);
        !            56:      if (nType < fpa11->fType[Fm])
        !            57:      {
        !            58:         nType = fpa11->fType[Fm];
        !            59:      }
        !            60:    }
        !            61: 
        !            62:    switch (nType)
        !            63:    {
        !            64:       case typeSingle   : nRc = SingleCPDO(opcode);   break;
        !            65:       case typeDouble   : nRc = DoubleCPDO(opcode);   break;
        !            66:       case typeExtended : nRc = ExtendedCPDO(opcode); break;
        !            67:       default           : nRc = 0;
        !            68:    }
        !            69: 
        !            70:    /* If the operation succeeded, check to see if the result in the
        !            71:       destination register is the correct size.  If not force it
        !            72:       to be. */
        !            73:    Fd = getFd(opcode);
        !            74:    nType = fpa11->fType[Fd];
        !            75:    if ((0 != nRc) && (nDest != nType))
        !            76:    {
        !            77:      switch (nDest)
        !            78:      {
        !            79:        case typeSingle:
        !            80:        {
        !            81:          if (typeDouble == nType)
        !            82:            fpa11->fpreg[Fd].fSingle =
        !            83:               float64_to_float32(fpa11->fpreg[Fd].fDouble, &fpa11->fp_status);
        !            84:          else
        !            85:            fpa11->fpreg[Fd].fSingle =
        !            86:               floatx80_to_float32(fpa11->fpreg[Fd].fExtended, &fpa11->fp_status);
        !            87:        }
        !            88:        break;
        !            89: 
        !            90:        case typeDouble:
        !            91:        {
        !            92:          if (typeSingle == nType)
        !            93:            fpa11->fpreg[Fd].fDouble =
        !            94:               float32_to_float64(fpa11->fpreg[Fd].fSingle, &fpa11->fp_status);
        !            95:          else
        !            96:            fpa11->fpreg[Fd].fDouble =
        !            97:               floatx80_to_float64(fpa11->fpreg[Fd].fExtended, &fpa11->fp_status);
        !            98:        }
        !            99:        break;
        !           100: 
        !           101:        case typeExtended:
        !           102:        {
        !           103:          if (typeSingle == nType)
        !           104:            fpa11->fpreg[Fd].fExtended =
        !           105:               float32_to_floatx80(fpa11->fpreg[Fd].fSingle, &fpa11->fp_status);
        !           106:          else
        !           107:            fpa11->fpreg[Fd].fExtended =
        !           108:               float64_to_floatx80(fpa11->fpreg[Fd].fDouble, &fpa11->fp_status);
        !           109:        }
        !           110:        break;
        !           111:      }
        !           112: 
        !           113:      fpa11->fType[Fd] = nDest;
        !           114:    }
        !           115: 
        !           116:    return nRc;
        !           117: }

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