Subversion Repositories or1k

/*

    NetWinder Floating Point Emulator

    (c) Rebel.COM, 1998,1999

    (c) Philip Blundell, 2001

    Direct questions, comments to Scott Bambrough <scottb@netwinder.org>

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#include "fpa11.h"

#include "fpopcode.h"

#include "fpmodule.h"

#include "fpmodule.inl"

#include <asm/system.h>

/* forward declarations */

unsigned int EmulateCPDO(const unsigned int);

unsigned int EmulateCPDT(const unsigned int);

unsigned int EmulateCPRT(const unsigned int);

/* Reset the FPA11 chip.  Called to initialize and reset the emulator. */

void resetFPA11(void)

{

        int i;

        FPA11 *fpa11 = GET_FPA11();

        /* initialize the register type array */

        for (i = 0; i <= 7; i++) {

                fpa11->fType[i] = typeNone;

        }

        /* FPSR: set system id to FP_EMULATOR, set AC, clear all other bits */

        fpa11->fpsr = FP_EMULATOR | BIT_AC;

}

void SetRoundingMode(const unsigned int opcode)

{

        switch (opcode & MASK_ROUNDING_MODE) {

        default:

        case ROUND_TO_NEAREST:

                float_rounding_mode = float_round_nearest_even;

                break;

        case ROUND_TO_PLUS_INFINITY:

                float_rounding_mode = float_round_up;

                break;

        case ROUND_TO_MINUS_INFINITY:

                float_rounding_mode = float_round_down;

                break;

        case ROUND_TO_ZERO:

                float_rounding_mode = float_round_to_zero;

                break;

        }

}

void SetRoundingPrecision(const unsigned int opcode)

{

#ifdef CONFIG_FPE_NWFPE_XP

        switch (opcode & MASK_ROUNDING_PRECISION) {

        case ROUND_SINGLE:

                floatx80_rounding_precision = 32;

                break;

        case ROUND_DOUBLE:

                floatx80_rounding_precision = 64;

                break;

        case ROUND_EXTENDED:

                floatx80_rounding_precision = 80;

                break;

        default:

                floatx80_rounding_precision = 80;

        }

#endif

}

void nwfpe_init_fpa(void)

{

        FPA11 *fpa11 = GET_FPA11();

#ifdef NWFPE_DEBUG

        printk("NWFPE: setting up state.\n");

#endif

        resetFPA11();

        SetRoundingMode(ROUND_TO_NEAREST);

        SetRoundingPrecision(ROUND_EXTENDED);

        fpa11->initflag = 1;

}

/* Emulate the instruction in the opcode. */

unsigned int EmulateAll(const unsigned int opcode)

{

#ifdef NWFPE_DEBUG

        printk("NWFPE: emulating opcode %08x\n", opcode);

#endif

        if (TEST_OPCODE(opcode, MASK_CPRT)) {

                /* Emulate conversion opcodes. */

                /* Emulate register transfer opcodes. */

                /* Emulate comparison opcodes. */

                return EmulateCPRT(opcode);

        } else if (TEST_OPCODE(opcode, MASK_CPDO)) {

                /* Emulate monadic arithmetic opcodes. */

                /* Emulate dyadic arithmetic opcodes. */

                return EmulateCPDO(opcode);

        } else if (TEST_OPCODE(opcode, MASK_CPDT)) {

                /* Emulate load/store opcodes. */

                /* Emulate load/store multiple opcodes. */

                return EmulateCPDT(opcode);

        }

        /* Invalid instruction detected.  Return FALSE. */

        return 0;

}