Subversion Repositories openrisc_me

/*  This file is part of the program psim.

    Copyright 1994, 1997, 2003 Andrew Cagney

    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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

    */

#ifndef _REGISTERS_H_

#define _REGISTERS_H_

/*

 * The PowerPC registers

 *

 */

/* FIXME:

   For the moment use macro's to determine if the E500 or Altivec

   registers should be included.  IGEN should instead of a :register:

   field to facilitate the specification and generation of per ISA

   registers.  */

#ifdef WITH_E500

#include "e500_registers.h"

#endif

#if WITH_ALTIVEC

#include "altivec_registers.h"

#endif

/**

 ** General Purpose Registers

 **/

typedef signed_word gpreg;

/**

 ** Floating Point Registers

 **/

typedef unsigned64 fpreg;

/**

 ** The condition register

 **

 **/

typedef unsigned32 creg;

/* The following sub bits are defined for the condition register */

enum {

  cr_i_negative = BIT4(0),

  cr_i_positive = BIT4(1),

  cr_i_zero = BIT4(2),

  cr_i_summary_overflow = BIT4(3),

#if 0

  /* cr0 - integer status */

  cr0_i_summary_overflow_bit = 3,

  cr0_i_negative = BIT32(0),

  cr0_i_positive = BIT32(1),

  cr0_i_zero = BIT32(2),

  cr0_i_summary_overflow = BIT32(3),

  cr0_i_mask = MASK32(0,3),

#endif

  /* cr1 - floating-point status */

  cr1_i_floating_point_exception_summary_bit = 4,

  cr1_i_floating_point_enabled_exception_summary_bit = 5,

  cr1_i_floating_point_invalid_operation_exception_summary_bit = 6,

  cr1_i_floating_point_overflow_exception_bit = 7,

  cr1_i_floating_point_exception_summary = BIT32(4),

  cr1_i_floating_point_enabled_exception_summary = BIT32(5),

  cr1_i_floating_point_invalid_operation_exception_summary = BIT32(6),

  cr1_i_floating_point_overflow_exception = BIT32(7),

  cr1_i_mask = MASK32(4,7),

};

/* Condition register 1 contains the result of floating point arithmetic */

enum {

  cr_fp_exception = BIT4(0),

  cr_fp_enabled_exception = BIT4(1),

  cr_fp_invalid_exception = BIT4(2),

  cr_fp_overflow_exception = BIT4(3),

};

/**

 ** Floating-Point Status and Control Register

 **/

typedef unsigned32 fpscreg;

enum {

  fpscr_fx_bit = 0,

  fpscr_fx = BIT32(0),

  fpscr_fex_bit = 1,

  fpscr_fex = BIT32(1),

  fpscr_vx_bit = 2,

  fpscr_vx = BIT32(2),

  fpscr_ox_bit = 3,

  fpscr_ox = BIT32(3),

  fpscr_ux = BIT32(4),

  fpscr_zx = BIT32(5),

  fpscr_xx = BIT32(6),

  fpscr_vxsnan = BIT32(7), /* SNAN */

  fpscr_vxisi = BIT32(8), /* INF - INF */

  fpscr_vxidi = BIT32(9), /* INF / INF */

  fpscr_vxzdz = BIT32(10), /* 0 / 0 */

  fpscr_vximz = BIT32(11), /* INF * 0 */

  fpscr_vxvc = BIT32(12),

  fpscr_fr = BIT32(13),

  fpscr_fi = BIT32(14),

  fpscr_fprf = MASK32(15, 19),

  fpscr_c = BIT32(15),

  fpscr_fpcc_bit = 16, /* well sort of */

  fpscr_fpcc = MASK32(16, 19),

  fpscr_fl = BIT32(16),

  fpscr_fg = BIT32(17),

  fpscr_fe = BIT32(18),

  fpscr_fu = BIT32(19),

  fpscr_rf_quiet_nan = fpscr_c | fpscr_fu,

  fpscr_rf_neg_infinity = fpscr_fl | fpscr_fu,

  fpscr_rf_neg_normal_number = fpscr_fl,

  fpscr_rf_neg_denormalized_number = fpscr_c | fpscr_fl,

  fpscr_rf_neg_zero = fpscr_c | fpscr_fe,

  fpscr_rf_pos_zero = fpscr_fe,

  fpscr_rf_pos_denormalized_number = fpscr_c | fpscr_fg,

  fpscr_rf_pos_normal_number = fpscr_fg,

  fpscr_rf_pos_infinity = fpscr_fg | fpscr_fu,

  fpscr_reserved_20 = BIT32(20),

  fpscr_vxsoft = BIT32(21),

  fpscr_vxsqrt = BIT32(22),

  fpscr_vxcvi = BIT32(23),

  fpscr_ve = BIT32(24),

  fpscr_oe = BIT32(25),

  fpscr_ue = BIT32(26),

  fpscr_ze = BIT32(27),

  fpscr_xe = BIT32(28),

  fpscr_ni = BIT32(29),

  fpscr_rn = MASK32(30, 31),

  fpscr_rn_round_to_nearest = 0,

  fpscr_rn_round_towards_zero = MASK32(31,31),

  fpscr_rn_round_towards_pos_infinity = MASK32(30,30),

  fpscr_rn_round_towards_neg_infinity = MASK32(30,31),

  fpscr_vx_bits = (fpscr_vxsnan | fpscr_vxisi | fpscr_vxidi

                   | fpscr_vxzdz | fpscr_vximz | fpscr_vxvc

                   | fpscr_vxsoft | fpscr_vxsqrt | fpscr_vxcvi),

};

/**

 ** XER Register

 **/

typedef unsigned32 xereg;

enum {

  xer_summary_overflow = BIT32(0), xer_summary_overflow_bit = 0,

  xer_carry = BIT32(2), xer_carry_bit = 2,

  xer_overflow = BIT32(1),

  xer_reserved_3_24 = MASK32(3,24),

  xer_byte_count_mask = MASK32(25,31)

};

/**

 ** SPR's

 **/

#include "spreg.h"

/**

 ** Segment Registers

 **/

typedef unsigned32 sreg;

enum {

  nr_of_srs = 16

};

/**

 ** Machine state register

 **/

typedef unsigned_word msreg; /* 32 or 64 bits */

enum {

#if (WITH_TARGET_WORD_BITSIZE == 64)

  msr_64bit_mode = BIT(0),

#endif

#if (WITH_TARGET_WORD_BITSIZE == 32)

  msr_64bit_mode = 0,

#endif

  msr_power_management_enable = BIT(45),

  msr_tempoary_gpr_remapping = BIT(46), /* 603 specific */

  msr_interrupt_little_endian_mode = BIT(47),

  msr_external_interrupt_enable = BIT(48),

  msr_problem_state = BIT(49),

  msr_floating_point_available = BIT(50),

  msr_machine_check_enable = BIT(51),

  msr_floating_point_exception_mode_0 = BIT(52),

  msr_single_step_trace_enable = BIT(53),

  msr_branch_trace_enable = BIT(54),

  msr_floating_point_exception_mode_1 = BIT(55),

  msr_interrupt_prefix = BIT(57),

  msr_instruction_relocate = BIT(58),

  msr_data_relocate = BIT(59),

  msr_recoverable_interrupt = BIT(62),

  msr_little_endian_mode = BIT(63)

};

enum {

  srr1_hash_table_or_ibat_miss = BIT(33),

  srr1_direct_store_error_exception = BIT(35),

  srr1_protection_violation = BIT(36),

  srr1_segment_table_miss = BIT(42),

  srr1_floating_point_enabled = BIT(43),

  srr1_illegal_instruction = BIT(44),

  srr1_priviliged_instruction = BIT(45),

  srr1_trap = BIT(46),

  srr1_subsequent_instruction = BIT(47)

};

/**

 ** storage interrupt registers

 **/

typedef enum {

  dsisr_direct_store_error_exception = BIT32(0),

  dsisr_hash_table_or_dbat_miss = BIT32(1),

  dsisr_protection_violation = BIT32(4),

  dsisr_earwax_violation = BIT32(5),

  dsisr_store_operation = BIT32(6),

  dsisr_segment_table_miss = BIT32(10),

  dsisr_earwax_disabled = BIT32(11)

} dsisr_status;

/**

 ** And the registers proper

 **/

typedef struct _registers {

  gpreg gpr[32];

  fpreg fpr[32];

  creg cr;

  fpscreg fpscr;

  /* Machine state register */

  msreg msr;

  /* Spr's */

  spreg spr[nr_of_sprs];

  /* Segment Registers */

  sreg sr[nr_of_srs];

#if WITH_ALTIVEC

  struct altivec_regs altivec;

#endif

#if WITH_E500

  struct e500_regs e500;

#endif

} registers;

/* dump out all the registers */

INLINE_REGISTERS\

(void) registers_dump

(registers *regs);

/* return information on a register based on name */

typedef enum {

  reg_invalid,

  reg_gpr, reg_fpr, reg_spr, reg_msr,

  reg_cr, reg_fpscr, reg_pc, reg_sr,

  reg_insns, reg_stalls, reg_cycles,

#ifdef WITH_ALTIVEC

  reg_vr, reg_vscr,

#endif

#ifdef WITH_E500

  reg_acc, reg_gprh, reg_evr,

#endif

  nr_register_types

} register_types;

typedef struct {

  register_types type;

  int index;

  int size;

} register_descriptions;

INLINE_REGISTERS\

(register_descriptions) register_description

(const char reg[]);

/* Special purpose registers by their more common names */

#define SPREG(N)        cpu_registers(processor)->spr[N]

#define XER             SPREG(spr_xer)

#define LR              SPREG(spr_lr)

#define CTR             SPREG(spr_ctr)

#define SRR0            SPREG(spr_srr0)

#define SRR1            SPREG(spr_srr1)

#define DAR             SPREG(spr_dar)

#define DSISR           SPREG(spr_dsisr)

/* general purpose registers - indexed access */

#define GPR(N)          cpu_registers(processor)->gpr[N]

/* segment registers */

#define SEGREG(N)       cpu_registers(processor)->sr[N]

/* condition register */

#define CR              cpu_registers(processor)->cr

/* machine status register */

#define MSR             cpu_registers(processor)->msr

/* floating-point status condition register */

#define FPSCR           cpu_registers(processor)->fpscr

#endif /* _REGISTERS_H_ */