349 lines
8.1 KiB
C
349 lines
8.1 KiB
C
/* 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_ */
|