/*

 *  PowerPC emulation cpu definitions for qemu.

 *

 *  Copyright (c) 2003-2007 Jocelyn Mayer

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#if !defined (__CPU_PPC_H__)

#define __CPU_PPC_H__

#include "config.h"

#include <inttypes.h>

//#define PPC_EMULATE_32BITS_HYPV

#if defined (TARGET_PPC64)

/* PowerPC 64 definitions */

#define TARGET_LONG_BITS 64

#define TARGET_PAGE_BITS 12

#else /* defined (TARGET_PPC64) */

/* PowerPC 32 definitions */

#define TARGET_LONG_BITS 32

#if defined(TARGET_PPCEMB)

/* Specific definitions for PowerPC embedded */

/* BookE have 36 bits physical address space */

#define TARGET_PHYS_ADDR_BITS 64

#if defined(CONFIG_USER_ONLY)

/* It looks like a lot of Linux programs assume page size

 * is 4kB long. This is evil, but we have to deal with it...

 */

#define TARGET_PAGE_BITS 12

#else /* defined(CONFIG_USER_ONLY) */

/* Pages can be 1 kB small */

#define TARGET_PAGE_BITS 10

#endif /* defined(CONFIG_USER_ONLY) */

#else /* defined(TARGET_PPCEMB) */

/* "standard" PowerPC 32 definitions */

#define TARGET_PAGE_BITS 12

#endif /* defined(TARGET_PPCEMB) */

#endif /* defined (TARGET_PPC64) */

#include "cpu-defs.h"

#define REGX "%016" PRIx64

#define ADDRX TARGET_FMT_lx

#define PADDRX TARGET_FMT_plx

#include <setjmp.h>

#include "softfloat.h"

#define TARGET_HAS_ICE 1

#if defined (TARGET_PPC64)

#define ELF_MACHINE     EM_PPC64

#else

#define ELF_MACHINE     EM_PPC

#endif

/*****************************************************************************/

/* MMU model                                                                 */

typedef enum powerpc_mmu_t powerpc_mmu_t;

enum powerpc_mmu_t {

    POWERPC_MMU_UNKNOWN    = 0x00000000,

    /* Standard 32 bits PowerPC MMU                            */

    POWERPC_MMU_32B        = 0x00000001,

    /* PowerPC 6xx MMU with software TLB                       */

    POWERPC_MMU_SOFT_6xx   = 0x00000002,

    /* PowerPC 74xx MMU with software TLB                      */

    POWERPC_MMU_SOFT_74xx  = 0x00000003,

    /* PowerPC 4xx MMU with software TLB                       */

    POWERPC_MMU_SOFT_4xx   = 0x00000004,

    /* PowerPC 4xx MMU with software TLB and zones protections */

    POWERPC_MMU_SOFT_4xx_Z = 0x00000005,

    /* PowerPC MMU in real mode only                           */

    POWERPC_MMU_REAL       = 0x00000006,

    /* Freescale MPC8xx MMU model                              */

    POWERPC_MMU_MPC8xx     = 0x00000007,

    /* BookE MMU model                                         */

    POWERPC_MMU_BOOKE      = 0x00000008,

    /* BookE FSL MMU model                                     */

    POWERPC_MMU_BOOKE_FSL  = 0x00000009,

    /* PowerPC 601 MMU model (specific BATs format)            */

    POWERPC_MMU_601        = 0x0000000A,

#if defined(TARGET_PPC64)

#define POWERPC_MMU_64       0x00010000

    /* 64 bits PowerPC MMU                                     */

    POWERPC_MMU_64B        = POWERPC_MMU_64 | 0x00000001,

    /* 620 variant (no segment exceptions)                     */

    POWERPC_MMU_620        = POWERPC_MMU_64 | 0x00000002,

#endif /* defined(TARGET_PPC64) */

};

/*****************************************************************************/

/* Exception model                                                           */

typedef enum powerpc_excp_t powerpc_excp_t;

enum powerpc_excp_t {

    POWERPC_EXCP_UNKNOWN   = 0,

    /* Standard PowerPC exception model */

    POWERPC_EXCP_STD,

    /* PowerPC 40x exception model      */

    POWERPC_EXCP_40x,

    /* PowerPC 601 exception model      */

    POWERPC_EXCP_601,

    /* PowerPC 602 exception model      */

    POWERPC_EXCP_602,

    /* PowerPC 603 exception model      */

    POWERPC_EXCP_603,

    /* PowerPC 603e exception model     */

    POWERPC_EXCP_603E,

    /* PowerPC G2 exception model       */

    POWERPC_EXCP_G2,

    /* PowerPC 604 exception model      */

    POWERPC_EXCP_604,

    /* PowerPC 7x0 exception model      */

    POWERPC_EXCP_7x0,

    /* PowerPC 7x5 exception model      */

    POWERPC_EXCP_7x5,

    /* PowerPC 74xx exception model     */

    POWERPC_EXCP_74xx,

    /* BookE exception model            */

    POWERPC_EXCP_BOOKE,

#if defined(TARGET_PPC64)

    /* PowerPC 970 exception model      */

    POWERPC_EXCP_970,

#endif /* defined(TARGET_PPC64) */

};

/*****************************************************************************/

/* Exception vectors definitions                                             */

enum {

    POWERPC_EXCP_NONE    = -1,

    /* The 64 first entries are used by the PowerPC embedded specification   */

    POWERPC_EXCP_CRITICAL = 0,  /* Critical input                            */

    POWERPC_EXCP_MCHECK   = 1,  /* Machine check exception                   */

    POWERPC_EXCP_DSI      = 2,  /* Data storage exception                    */

    POWERPC_EXCP_ISI      = 3,  /* Instruction storage exception             */

    POWERPC_EXCP_EXTERNAL = 4,  /* External input                            */

    POWERPC_EXCP_ALIGN    = 5,  /* Alignment exception                       */

    POWERPC_EXCP_PROGRAM  = 6,  /* Program exception                         */

    POWERPC_EXCP_FPU      = 7,  /* Floating-point unavailable exception      */

    POWERPC_EXCP_SYSCALL  = 8,  /* System call exception                     */

    POWERPC_EXCP_APU      = 9,  /* Auxiliary processor unavailable           */

    POWERPC_EXCP_DECR     = 10, /* Decrementer exception                     */

    POWERPC_EXCP_FIT      = 11, /* Fixed-interval timer interrupt            */

    POWERPC_EXCP_WDT      = 12, /* Watchdog timer interrupt                  */

    POWERPC_EXCP_DTLB     = 13, /* Data TLB miss                             */

    POWERPC_EXCP_ITLB     = 14, /* Instruction TLB miss                      */

    POWERPC_EXCP_DEBUG    = 15, /* Debug interrupt                           */

    /* Vectors 16 to 31 are reserved                                         */

    POWERPC_EXCP_SPEU     = 32, /* SPE/embedded floating-point unavailable   */

    POWERPC_EXCP_EFPDI    = 33, /* Embedded floating-point data interrupt    */

    POWERPC_EXCP_EFPRI    = 34, /* Embedded floating-point round interrupt   */

    POWERPC_EXCP_EPERFM   = 35, /* Embedded performance monitor interrupt    */

    POWERPC_EXCP_DOORI    = 36, /* Embedded doorbell interrupt               */

    POWERPC_EXCP_DOORCI   = 37, /* Embedded doorbell critical interrupt      */

    /* Vectors 38 to 63 are reserved                                         */

    /* Exceptions defined in the PowerPC server specification                */

    POWERPC_EXCP_RESET    = 64, /* System reset exception                    */

    POWERPC_EXCP_DSEG     = 65, /* Data segment exception                    */

    POWERPC_EXCP_ISEG     = 66, /* Instruction segment exception             */

    POWERPC_EXCP_HDECR    = 67, /* Hypervisor decrementer exception          */

    POWERPC_EXCP_TRACE    = 68, /* Trace exception                           */

    POWERPC_EXCP_HDSI     = 69, /* Hypervisor data storage exception         */

    POWERPC_EXCP_HISI     = 70, /* Hypervisor instruction storage exception  */

    POWERPC_EXCP_HDSEG    = 71, /* Hypervisor data segment exception         */

    POWERPC_EXCP_HISEG    = 72, /* Hypervisor instruction segment exception  */

    POWERPC_EXCP_VPU      = 73, /* Vector unavailable exception              */

    /* 40x specific exceptions                                               */

    POWERPC_EXCP_PIT      = 74, /* Programmable interval timer interrupt     */

    /* 601 specific exceptions                                               */

    POWERPC_EXCP_IO       = 75, /* IO error exception                        */

    POWERPC_EXCP_RUNM     = 76, /* Run mode exception                        */

    /* 602 specific exceptions                                               */

    POWERPC_EXCP_EMUL     = 77, /* Emulation trap exception                  */

    /* 602/603 specific exceptions                                           */

    POWERPC_EXCP_IFTLB    = 78, /* Instruction fetch TLB miss                */

    POWERPC_EXCP_DLTLB    = 79, /* Data load TLB miss                        */

    POWERPC_EXCP_DSTLB    = 80, /* Data store TLB miss                       */

    /* Exceptions available on most PowerPC                                  */

    POWERPC_EXCP_FPA      = 81, /* Floating-point assist exception           */

    POWERPC_EXCP_DABR     = 82, /* Data address breakpoint                   */

    POWERPC_EXCP_IABR     = 83, /* Instruction address breakpoint            */

    POWERPC_EXCP_SMI      = 84, /* System management interrupt               */

    POWERPC_EXCP_PERFM    = 85, /* Embedded performance monitor interrupt    */

    /* 7xx/74xx specific exceptions                                          */

    POWERPC_EXCP_THERM    = 86, /* Thermal interrupt                         */

    /* 74xx specific exceptions                                              */

    POWERPC_EXCP_VPUA     = 87, /* Vector assist exception                   */

    /* 970FX specific exceptions                                             */

    POWERPC_EXCP_SOFTP    = 88, /* Soft patch exception                      */

    POWERPC_EXCP_MAINT    = 89, /* Maintenance exception                     */

    /* Freescale embeded cores specific exceptions                           */

    POWERPC_EXCP_MEXTBR   = 90, /* Maskable external breakpoint              */

    POWERPC_EXCP_NMEXTBR  = 91, /* Non maskable external breakpoint          */

    POWERPC_EXCP_ITLBE    = 92, /* Instruction TLB error                     */

    POWERPC_EXCP_DTLBE    = 93, /* Data TLB error                            */

    /* EOL                                                                   */

    POWERPC_EXCP_NB       = 96,

    /* Qemu exceptions: used internally during code translation              */

    POWERPC_EXCP_STOP         = 0x200, /* stop translation                   */

    POWERPC_EXCP_BRANCH       = 0x201, /* branch instruction                 */

    /* Qemu exceptions: special cases we want to stop translation            */

    POWERPC_EXCP_SYNC         = 0x202, /* context synchronizing instruction  */

    POWERPC_EXCP_SYSCALL_USER = 0x203, /* System call in user mode only      */

};

/* Exceptions error codes                                                    */

enum {

    /* Exception subtypes for POWERPC_EXCP_ALIGN                             */

    POWERPC_EXCP_ALIGN_FP      = 0x01,  /* FP alignment exception            */

    POWERPC_EXCP_ALIGN_LST     = 0x02,  /* Unaligned mult/extern load/store  */

    POWERPC_EXCP_ALIGN_LE      = 0x03,  /* Multiple little-endian access     */

    POWERPC_EXCP_ALIGN_PROT    = 0x04,  /* Access cross protection boundary  */

    POWERPC_EXCP_ALIGN_BAT     = 0x05,  /* Access cross a BAT/seg boundary   */

    POWERPC_EXCP_ALIGN_CACHE   = 0x06,  /* Impossible dcbz access            */

    /* Exception subtypes for POWERPC_EXCP_PROGRAM                           */

    /* FP exceptions                                                         */

    POWERPC_EXCP_FP            = 0x10,

    POWERPC_EXCP_FP_OX         = 0x01,  /* FP overflow                       */

    POWERPC_EXCP_FP_UX         = 0x02,  /* FP underflow                      */

    POWERPC_EXCP_FP_ZX         = 0x03,  /* FP divide by zero                 */

    POWERPC_EXCP_FP_XX         = 0x04,  /* FP inexact                        */

    POWERPC_EXCP_FP_VXSNAN     = 0x05,  /* FP invalid SNaN op                */

    POWERPC_EXCP_FP_VXISI      = 0x06,  /* FP invalid infinite subtraction   */

    POWERPC_EXCP_FP_VXIDI      = 0x07,  /* FP invalid infinite divide        */

    POWERPC_EXCP_FP_VXZDZ      = 0x08,  /* FP invalid zero divide            */

    POWERPC_EXCP_FP_VXIMZ      = 0x09,  /* FP invalid infinite * zero        */

    POWERPC_EXCP_FP_VXVC       = 0x0A,  /* FP invalid compare                */

    POWERPC_EXCP_FP_VXSOFT     = 0x0B,  /* FP invalid operation              */

    POWERPC_EXCP_FP_VXSQRT     = 0x0C,  /* FP invalid square root            */

    POWERPC_EXCP_FP_VXCVI      = 0x0D,  /* FP invalid integer conversion     */

    /* Invalid instruction                                                   */

    POWERPC_EXCP_INVAL         = 0x20,

    POWERPC_EXCP_INVAL_INVAL   = 0x01,  /* Invalid instruction               */

    POWERPC_EXCP_INVAL_LSWX    = 0x02,  /* Invalid lswx instruction          */

    POWERPC_EXCP_INVAL_SPR     = 0x03,  /* Invalid SPR access                */

    POWERPC_EXCP_INVAL_FP      = 0x04,  /* Unimplemented mandatory fp instr  */

    /* Privileged instruction                                                */

    POWERPC_EXCP_PRIV          = 0x30,

    POWERPC_EXCP_PRIV_OPC      = 0x01,  /* Privileged operation exception    */

    POWERPC_EXCP_PRIV_REG      = 0x02,  /* Privileged register exception     */

    /* Trap                                                                  */

    POWERPC_EXCP_TRAP          = 0x40,

};

/*****************************************************************************/

/* Input pins model                                                          */

typedef enum powerpc_input_t powerpc_input_t;

enum powerpc_input_t {

    PPC_FLAGS_INPUT_UNKNOWN = 0,

    /* PowerPC 6xx bus                  */

    PPC_FLAGS_INPUT_6xx,

    /* BookE bus                        */

    PPC_FLAGS_INPUT_BookE,

    /* PowerPC 405 bus                  */

    PPC_FLAGS_INPUT_405,

    /* PowerPC 970 bus                  */

    PPC_FLAGS_INPUT_970,

    /* PowerPC 401 bus                  */

    PPC_FLAGS_INPUT_401,

    /* Freescale RCPU bus               */

    PPC_FLAGS_INPUT_RCPU,

};

#define PPC_INPUT(env) (env->bus_model)

/*****************************************************************************/

typedef struct ppc_def_t ppc_def_t;

typedef struct opc_handler_t opc_handler_t;

/*****************************************************************************/

/* Types used to describe some PowerPC registers */

typedef struct CPUPPCState CPUPPCState;

typedef struct ppc_tb_t ppc_tb_t;

typedef struct ppc_spr_t ppc_spr_t;

typedef struct ppc_dcr_t ppc_dcr_t;

typedef union ppc_avr_t ppc_avr_t;

typedef union ppc_tlb_t ppc_tlb_t;

/* SPR access micro-ops generations callbacks */

struct ppc_spr_t {

    void (*uea_read)(void *opaque, int gpr_num, int spr_num);

    void (*uea_write)(void *opaque, int spr_num, int gpr_num);

#if !defined(CONFIG_USER_ONLY)

    void (*oea_read)(void *opaque, int gpr_num, int spr_num);

    void (*oea_write)(void *opaque, int spr_num, int gpr_num);

    void (*hea_read)(void *opaque, int gpr_num, int spr_num);

    void (*hea_write)(void *opaque, int spr_num, int gpr_num);

#endif

    const char *name;

};

/* Altivec registers (128 bits) */

union ppc_avr_t {

    uint8_t u8[16];

    uint16_t u16[8];

    uint32_t u32[4];

    uint64_t u64[2];

    int8_t s8[16];

    int16_t s16[8];

    int32_t s32[4];

    float f[4];

};

/* Software TLB cache */

typedef struct ppc6xx_tlb_t ppc6xx_tlb_t;

struct ppc6xx_tlb_t {

    target_ulong pte0;

    target_ulong pte1;

    target_ulong EPN;

};

typedef struct ppcemb_tlb_t ppcemb_tlb_t;

struct ppcemb_tlb_t {

    target_phys_addr_t RPN;

    target_ulong EPN;

    target_ulong PID;

    target_ulong size;

    uint32_t prot;

    uint32_t attr; /* Storage attributes */

};

union ppc_tlb_t {

    ppc6xx_tlb_t tlb6;

    ppcemb_tlb_t tlbe;

};

/*****************************************************************************/

/* Machine state register bits definition                                    */

#define MSR_SF   63 /* Sixty-four-bit mode                            hflags */

#define MSR_TAG  62 /* Tag-active mode (POWERx ?)                            */

#define MSR_ISF  61 /* Sixty-four-bit interrupt mode on 630                  */

#define MSR_SHV  60 /* hypervisor state                               hflags */

#define MSR_CM   31 /* Computation mode for BookE                     hflags */

#define MSR_ICM  30 /* Interrupt computation mode for BookE                  */

#define MSR_THV  29 /* hypervisor state for 32 bits PowerPC           hflags */

#define MSR_UCLE 26 /* User-mode cache lock enable for BookE                 */

#define MSR_VR   25 /* altivec available                            x hflags */

#define MSR_SPE  25 /* SPE enable for BookE                         x hflags */

#define MSR_AP   23 /* Access privilege state on 602                  hflags */

#define MSR_SA   22 /* Supervisor access mode on 602                  hflags */

#define MSR_KEY  19 /* key bit on 603e                                       */

#define MSR_POW  18 /* Power management                                      */

#define MSR_TGPR 17 /* TGPR usage on 602/603                        x        */

#define MSR_CE   17 /* Critical interrupt enable on embedded PowerPC x       */

#define MSR_ILE  16 /* Interrupt little-endian mode                          */

#define MSR_EE   15 /* External interrupt enable                             */

#define MSR_PR   14 /* Problem state                                  hflags */

#define MSR_FP   13 /* Floating point available                       hflags */

#define MSR_ME   12 /* Machine check interrupt enable                        */

#define MSR_FE0  11 /* Floating point exception mode 0                hflags */

#define MSR_SE   10 /* Single-step trace enable                     x hflags */

#define MSR_DWE  10 /* Debug wait enable on 405                     x        */

#define MSR_UBLE 10 /* User BTB lock enable on e500                 x        */

#define MSR_BE   9  /* Branch trace enable                          x hflags */

#define MSR_DE   9  /* Debug interrupts enable on embedded PowerPC  x        */

#define MSR_FE1  8  /* Floating point exception mode 1                hflags */

#define MSR_AL   7  /* AL bit on POWER                                       */

#define MSR_EP   6  /* Exception prefix on 601                               */

#define MSR_IR   5  /* Instruction relocate                                  */

#define MSR_DR   4  /* Data relocate                                         */

#define MSR_PE   3  /* Protection enable on 403                              */

#define MSR_PX   2  /* Protection exclusive on 403                  x        */

#define MSR_PMM  2  /* Performance monitor mark on POWER            x        */

#define MSR_RI   1  /* Recoverable interrupt                        1        */

#define MSR_LE   0  /* Little-endian mode                           1 hflags */

#define msr_sf   ((env->msr >> MSR_SF)   & 1)

#define msr_isf  ((env->msr >> MSR_ISF)  & 1)

#define msr_shv  ((env->msr >> MSR_SHV)  & 1)

#define msr_cm   ((env->msr >> MSR_CM)   & 1)

#define msr_icm  ((env->msr >> MSR_ICM)  & 1)

#define msr_thv  ((env->msr >> MSR_THV)  & 1)

#define msr_ucle ((env->msr >> MSR_UCLE) & 1)

#define msr_vr   ((env->msr >> MSR_VR)   & 1)

#define msr_spe  ((env->msr >> MSR_SPE)  & 1)

#define msr_ap   ((env->msr >> MSR_AP)   & 1)

#define msr_sa   ((env->msr >> MSR_SA)   & 1)

#define msr_key  ((env->msr >> MSR_KEY)  & 1)

#define msr_pow  ((env->msr >> MSR_POW)  & 1)

#define msr_tgpr ((env->msr >> MSR_TGPR) & 1)

#define msr_ce   ((env->msr >> MSR_CE)   & 1)

#define msr_ile  ((env->msr >> MSR_ILE)  & 1)

#define msr_ee   ((env->msr >> MSR_EE)   & 1)

#define msr_pr   ((env->msr >> MSR_PR)   & 1)

#define msr_fp   ((env->msr >> MSR_FP)   & 1)

#define msr_me   ((env->msr >> MSR_ME)   & 1)

#define msr_fe0  ((env->msr >> MSR_FE0)  & 1)

#define msr_se   ((env->msr >> MSR_SE)   & 1)

#define msr_dwe  ((env->msr >> MSR_DWE)  & 1)

#define msr_uble ((env->msr >> MSR_UBLE) & 1)

#define msr_be   ((env->msr >> MSR_BE)   & 1)

#define msr_de   ((env->msr >> MSR_DE)   & 1)

#define msr_fe1  ((env->msr >> MSR_FE1)  & 1)

#define msr_al   ((env->msr >> MSR_AL)   & 1)

#define msr_ep   ((env->msr >> MSR_EP)   & 1)

#define msr_ir   ((env->msr >> MSR_IR)   & 1)

#define msr_dr   ((env->msr >> MSR_DR)   & 1)

#define msr_pe   ((env->msr >> MSR_PE)   & 1)

#define msr_px   ((env->msr >> MSR_PX)   & 1)

#define msr_pmm  ((env->msr >> MSR_PMM)  & 1)

#define msr_ri   ((env->msr >> MSR_RI)   & 1)

#define msr_le   ((env->msr >> MSR_LE)   & 1)

/* Hypervisor bit is more specific */

#if defined(TARGET_PPC64)

#define MSR_HVB (1ULL << MSR_SHV)

#define msr_hv  msr_shv

#else

#if defined(PPC_EMULATE_32BITS_HYPV)

#define MSR_HVB (1ULL << MSR_THV)

#define msr_hv  msr_thv

#else

#define MSR_HVB (0ULL)

#define msr_hv  (0)

#endif

#endif

enum {

    POWERPC_FLAG_NONE     = 0x00000000,

    /* Flag for MSR bit 25 signification (VRE/SPE)                           */

    POWERPC_FLAG_SPE      = 0x00000001,

    POWERPC_FLAG_VRE      = 0x00000002,

    /* Flag for MSR bit 17 signification (TGPR/CE)                           */

    POWERPC_FLAG_TGPR     = 0x00000004,

    POWERPC_FLAG_CE       = 0x00000008,

    /* Flag for MSR bit 10 signification (SE/DWE/UBLE)                       */

    POWERPC_FLAG_SE       = 0x00000010,

    POWERPC_FLAG_DWE      = 0x00000020,

    POWERPC_FLAG_UBLE     = 0x00000040,

    /* Flag for MSR bit 9 signification (BE/DE)                              */

    POWERPC_FLAG_BE       = 0x00000080,

    POWERPC_FLAG_DE       = 0x00000100,

    /* Flag for MSR bit 2 signification (PX/PMM)                             */

    POWERPC_FLAG_PX       = 0x00000200,

    POWERPC_FLAG_PMM      = 0x00000400,

    /* Flag for special features                                             */

    /* Decrementer clock: RTC clock (POWER, 601) or bus clock                */

    POWERPC_FLAG_RTC_CLK  = 0x00010000,

    POWERPC_FLAG_BUS_CLK  = 0x00020000,

};

/*****************************************************************************/

/* Floating point status and control register                                */

#define FPSCR_FX     31 /* Floating-point exception summary                  */

#define FPSCR_FEX    30 /* Floating-point enabled exception summary          */

#define FPSCR_VX     29 /* Floating-point invalid operation exception summ.  */

#define FPSCR_OX     28 /* Floating-point overflow exception                 */

#define FPSCR_UX     27 /* Floating-point underflow exception                */

#define FPSCR_ZX     26 /* Floating-point zero divide exception              */

#define FPSCR_XX     25 /* Floating-point inexact exception                  */

#define FPSCR_VXSNAN 24 /* Floating-point invalid operation exception (sNan) */

#define FPSCR_VXISI  23 /* Floating-point invalid operation exception (inf)  */

#define FPSCR_VXIDI  22 /* Floating-point invalid operation exception (inf)  */

#define FPSCR_VXZDZ  21 /* Floating-point invalid operation exception (zero) */

#define FPSCR_VXIMZ  20 /* Floating-point invalid operation exception (inf)  */

#define FPSCR_VXVC   19 /* Floating-point invalid operation exception (comp) */

#define FPSCR_FR     18 /* Floating-point fraction rounded                   */

#define FPSCR_FI     17 /* Floating-point fraction inexact                   */

#define FPSCR_C      16 /* Floating-point result class descriptor            */

#define FPSCR_FL     15 /* Floating-point less than or negative              */

#define FPSCR_FG     14 /* Floating-point greater than or negative           */

#define FPSCR_FE     13 /* Floating-point equal or zero                      */

#define FPSCR_FU     12 /* Floating-point unordered or NaN                   */

#define FPSCR_FPCC   12 /* Floating-point condition code                     */

#define FPSCR_FPRF   12 /* Floating-point result flags                       */

#define FPSCR_VXSOFT 10 /* Floating-point invalid operation exception (soft) */

#define FPSCR_VXSQRT 9  /* Floating-point invalid operation exception (sqrt) */

#define FPSCR_VXCVI  8  /* Floating-point invalid operation exception (int)  */

#define FPSCR_VE     7  /* Floating-point invalid operation exception enable */

#define FPSCR_OE     6  /* Floating-point overflow exception enable          */

#define FPSCR_UE     5  /* Floating-point undeflow exception enable          */

#define FPSCR_ZE     4  /* Floating-point zero divide exception enable       */

#define FPSCR_XE     3  /* Floating-point inexact exception enable           */

#define FPSCR_NI     2  /* Floating-point non-IEEE mode                      */

#define FPSCR_RN1    1

#define FPSCR_RN     0  /* Floating-point rounding control                   */

#define fpscr_fex    (((env->fpscr) >> FPSCR_FEX)    & 0x1)

#define fpscr_vx     (((env->fpscr) >> FPSCR_VX)     & 0x1)

#define fpscr_ox     (((env->fpscr) >> FPSCR_OX)     & 0x1)

#define fpscr_ux     (((env->fpscr) >> FPSCR_UX)     & 0x1)

#define fpscr_zx     (((env->fpscr) >> FPSCR_ZX)     & 0x1)

#define fpscr_xx     (((env->fpscr) >> FPSCR_XX)     & 0x1)

#define fpscr_vxsnan (((env->fpscr) >> FPSCR_VXSNAN) & 0x1)

#define fpscr_vxisi  (((env->fpscr) >> FPSCR_VXISI)  & 0x1)

#define fpscr_vxidi  (((env->fpscr) >> FPSCR_VXIDI)  & 0x1)

#define fpscr_vxzdz  (((env->fpscr) >> FPSCR_VXZDZ)  & 0x1)

#define fpscr_vximz  (((env->fpscr) >> FPSCR_VXIMZ)  & 0x1)

#define fpscr_vxvc   (((env->fpscr) >> FPSCR_VXVC)   & 0x1)

#define fpscr_fpcc   (((env->fpscr) >> FPSCR_FPCC)   & 0xF)

#define fpscr_vxsoft (((env->fpscr) >> FPSCR_VXSOFT) & 0x1)

#define fpscr_vxsqrt (((env->fpscr) >> FPSCR_VXSQRT) & 0x1)

#define fpscr_vxcvi  (((env->fpscr) >> FPSCR_VXCVI)  & 0x1)

#define fpscr_ve     (((env->fpscr) >> FPSCR_VE)     & 0x1)

#define fpscr_oe     (((env->fpscr) >> FPSCR_OE)     & 0x1)

#define fpscr_ue     (((env->fpscr) >> FPSCR_UE)     & 0x1)

#define fpscr_ze     (((env->fpscr) >> FPSCR_ZE)     & 0x1)

#define fpscr_xe     (((env->fpscr) >> FPSCR_XE)     & 0x1)

#define fpscr_ni     (((env->fpscr) >> FPSCR_NI)     & 0x1)

#define fpscr_rn     (((env->fpscr) >> FPSCR_RN)     & 0x3)

/* Invalid operation exception summary */

#define fpscr_ix ((env->fpscr) & ((1 << FPSCR_VXSNAN) | (1 << FPSCR_VXISI)  | \

                                  (1 << FPSCR_VXIDI)  | (1 << FPSCR_VXZDZ)  | \

                                  (1 << FPSCR_VXIMZ)  | (1 << FPSCR_VXVC)   | \

                                  (1 << FPSCR_VXSOFT) | (1 << FPSCR_VXSQRT) | \

                                  (1 << FPSCR_VXCVI)))

/* exception summary */

#define fpscr_ex  (((env->fpscr) >> FPSCR_XX) & 0x1F)

/* enabled exception summary */

#define fpscr_eex (((env->fpscr) >> FPSCR_XX) & ((env->fpscr) >> FPSCR_XE) &  \

                   0x1F)

/*****************************************************************************/

/* Vector status and control register */