target-alpha/cpu.h

   1 /*
   2  *  Alpha emulation cpu definitions for qemu.
   3  *
   4  *  Copyright (c) 2007 Jocelyn Mayer
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #if !defined (__CPU_ALPHA_H__)
  22 #define __CPU_ALPHA_H__
  23
  24 #include "config.h"
  25
  26 #define TARGET_LONG_BITS 64
  27
  28 #include "cpu-defs.h"
  29
  30 #include <setjmp.h>
  31
  32 #include "softfloat.h"
  33
  34 #define TARGET_HAS_ICE 1
  35
  36 #define ELF_MACHINE     EM_ALPHA
  37
  38 #define ICACHE_LINE_SIZE 32
  39 #define DCACHE_LINE_SIZE 32
  40
  41 #define TARGET_PAGE_BITS 12
  42
  43 #define VA_BITS 43
  44
  45 /* Alpha major type */
  46 enum {
  47     ALPHA_EV3  = 1,
  48     ALPHA_EV4  = 2,
  49     ALPHA_SIM  = 3,
  50     ALPHA_LCA  = 4,
  51     ALPHA_EV5  = 5, /* 21164 */
  52     ALPHA_EV45 = 6, /* 21064A */
  53     ALPHA_EV56 = 7, /* 21164A */
  54 };
  55
  56 /* EV4 minor type */
  57 enum {
  58     ALPHA_EV4_2 = 0,
  59     ALPHA_EV4_3 = 1,
  60 };
  61
  62 /* LCA minor type */
  63 enum {
  64     ALPHA_LCA_1 = 1, /* 21066 */
  65     ALPHA_LCA_2 = 2, /* 20166 */
  66     ALPHA_LCA_3 = 3, /* 21068 */
  67     ALPHA_LCA_4 = 4, /* 21068 */
  68     ALPHA_LCA_5 = 5, /* 21066A */
  69     ALPHA_LCA_6 = 6, /* 21068A */
  70 };
  71
  72 /* EV5 minor type */
  73 enum {
  74     ALPHA_EV5_1 = 1, /* Rev BA, CA */
  75     ALPHA_EV5_2 = 2, /* Rev DA, EA */
  76     ALPHA_EV5_3 = 3, /* Pass 3 */
  77     ALPHA_EV5_4 = 4, /* Pass 3.2 */
  78     ALPHA_EV5_5 = 5, /* Pass 4 */
  79 };
  80
  81 /* EV45 minor type */
  82 enum {
  83     ALPHA_EV45_1 = 1, /* Pass 1 */
  84     ALPHA_EV45_2 = 2, /* Pass 1.1 */
  85     ALPHA_EV45_3 = 3, /* Pass 2 */
  86 };
  87
  88 /* EV56 minor type */
  89 enum {
  90     ALPHA_EV56_1 = 1, /* Pass 1 */
  91     ALPHA_EV56_2 = 2, /* Pass 2 */
  92 };
  93
  94 enum {
  95     IMPLVER_2106x = 0, /* EV4, EV45 & LCA45 */
  96     IMPLVER_21164 = 1, /* EV5, EV56 & PCA45 */
  97     IMPLVER_21264 = 2, /* EV6, EV67 & EV68x */
  98     IMPLVER_21364 = 3, /* EV7 & EV79 */
  99 };
 100
 101 enum {
 102     AMASK_BWX      = 0x00000001,
 103     AMASK_FIX      = 0x00000002,
 104     AMASK_CIX      = 0x00000004,
 105     AMASK_MVI      = 0x00000100,
 106     AMASK_TRAP     = 0x00000200,
 107     AMASK_PREFETCH = 0x00001000,
 108 };
 109
 110 enum {
 111     VAX_ROUND_NORMAL = 0,
 112     VAX_ROUND_CHOPPED,
 113 };
 114
 115 enum {
 116     IEEE_ROUND_NORMAL = 0,
 117     IEEE_ROUND_DYNAMIC,
 118     IEEE_ROUND_PLUS,
 119     IEEE_ROUND_MINUS,
 120     IEEE_ROUND_CHOPPED,
 121 };
 122
 123 /* IEEE floating-point operations encoding */
 124 /* Trap mode */
 125 enum {
 126     FP_TRAP_I   = 0x0,
 127     FP_TRAP_U   = 0x1,
 128     FP_TRAP_S  = 0x4,
 129     FP_TRAP_SU  = 0x5,
 130     FP_TRAP_SUI = 0x7,
 131 };
 132
 133 /* Rounding mode */
 134 enum {
 135     FP_ROUND_CHOPPED = 0x0,
 136     FP_ROUND_MINUS   = 0x1,
 137     FP_ROUND_NORMAL  = 0x2,
 138     FP_ROUND_DYNAMIC = 0x3,
 139 };
 140
 141 /* Internal processor registers */
 142 /* XXX: TOFIX: most of those registers are implementation dependant */
 143 enum {
 144     /* Ebox IPRs */
 145     IPR_CC           = 0xC0,
 146     IPR_CC_CTL       = 0xC1,
 147     IPR_VA           = 0xC2,
 148     IPR_VA_CTL       = 0xC4,
 149     IPR_VA_FORM      = 0xC3,
 150     /* Ibox IPRs */
 151     IPR_ITB_TAG      = 0x00,
 152     IPR_ITB_PTE      = 0x01,
 153     IPT_ITB_IAP      = 0x02,
 154     IPT_ITB_IA       = 0x03,
 155     IPT_ITB_IS       = 0x04,
 156     IPR_PMPC         = 0x05,
 157     IPR_EXC_ADDR     = 0x06,
 158     IPR_IVA_FORM     = 0x07,
 159     IPR_CM           = 0x09,
 160     IPR_IER          = 0x0A,
 161     IPR_SIRR         = 0x0C,
 162     IPR_ISUM         = 0x0D,
 163     IPR_HW_INT_CLR   = 0x0E,
 164     IPR_EXC_SUM      = 0x0F,
 165     IPR_PAL_BASE     = 0x10,
 166     IPR_I_CTL        = 0x11,
 167     IPR_I_STAT       = 0x16,
 168     IPR_IC_FLUSH     = 0x13,
 169     IPR_IC_FLUSH_ASM = 0x12,
 170     IPR_CLR_MAP      = 0x15,
 171     IPR_SLEEP        = 0x17,
 172     IPR_PCTX         = 0x40,
 173     IPR_PCTR_CTL     = 0x14,
 174     /* Mbox IPRs */
 175     IPR_DTB_TAG0     = 0x20,
 176     IPR_DTB_TAG1     = 0xA0,
 177     IPR_DTB_PTE0     = 0x21,
 178     IPR_DTB_PTE1     = 0xA1,
 179     IPR_DTB_ALTMODE  = 0xA6,
 180     IPR_DTB_IAP      = 0xA2,
 181     IPR_DTB_IA       = 0xA3,
 182     IPR_DTB_IS0      = 0x24,
 183     IPR_DTB_IS1      = 0xA4,
 184     IPR_DTB_ASN0     = 0x25,
 185     IPR_DTB_ASN1     = 0xA5,
 186     IPR_MM_STAT      = 0x27,
 187     IPR_M_CTL        = 0x28,
 188     IPR_DC_CTL       = 0x29,
 189     IPR_DC_STAT      = 0x2A,
 190     /* Cbox IPRs */
 191     IPR_C_DATA       = 0x2B,
 192     IPR_C_SHIFT      = 0x2C,
 193
 194     IPR_ASN,
 195     IPR_ASTEN,
 196     IPR_ASTSR,
 197     IPR_DATFX,
 198     IPR_ESP,
 199     IPR_FEN,
 200     IPR_IPIR,
 201     IPR_IPL,
 202     IPR_KSP,
 203     IPR_MCES,
 204     IPR_PERFMON,
 205     IPR_PCBB,
 206     IPR_PRBR,
 207     IPR_PTBR,
 208     IPR_SCBB,
 209     IPR_SISR,
 210     IPR_SSP,
 211     IPR_SYSPTBR,
 212     IPR_TBCHK,
 213     IPR_TBIA,
 214     IPR_TBIAP,
 215     IPR_TBIS,
 216     IPR_TBISD,
 217     IPR_TBISI,
 218     IPR_USP,
 219     IPR_VIRBND,
 220     IPR_VPTB,
 221     IPR_WHAMI,
 222     IPR_ALT_MODE,
 223     IPR_LAST,
 224 };
 225
 226 typedef struct CPUAlphaState CPUAlphaState;
 227
 228 typedef struct pal_handler_t pal_handler_t;
 229 struct pal_handler_t {
 230     /* Reset */
 231     void (*reset)(CPUAlphaState *env);
 232     /* Uncorrectable hardware error */
 233     void (*machine_check)(CPUAlphaState *env);
 234     /* Arithmetic exception */
 235     void (*arithmetic)(CPUAlphaState *env);
 236     /* Interrupt / correctable hardware error */
 237     void (*interrupt)(CPUAlphaState *env);
 238     /* Data fault */
 239     void (*dfault)(CPUAlphaState *env);
 240     /* DTB miss pal */
 241     void (*dtb_miss_pal)(CPUAlphaState *env);
 242     /* DTB miss native */
 243     void (*dtb_miss_native)(CPUAlphaState *env);
 244     /* Unaligned access */
 245     void (*unalign)(CPUAlphaState *env);
 246     /* ITB miss */
 247     void (*itb_miss)(CPUAlphaState *env);
 248     /* Instruction stream access violation */
 249     void (*itb_acv)(CPUAlphaState *env);
 250     /* Reserved or privileged opcode */
 251     void (*opcdec)(CPUAlphaState *env);
 252     /* Floating point exception */
 253     void (*fen)(CPUAlphaState *env);
 254     /* Call pal instruction */
 255     void (*call_pal)(CPUAlphaState *env, uint32_t palcode);
 256 };
 257
 258 #define NB_MMU_MODES 4
 259
 260 struct CPUAlphaState {
 261     uint64_t ir[31];
 262     float64  fir[31];
 263     float_status fp_status;
 264     uint64_t fpcr;
 265     uint64_t pc;
 266     uint64_t lock;
 267     uint32_t pcc[2];
 268     uint64_t ipr[IPR_LAST];
 269     uint64_t ps;
 270     uint64_t unique;
 271     int saved_mode; /* Used for HW_LD / HW_ST */
 272     int intr_flag; /* For RC and RS */
 273
 274 #if TARGET_LONG_BITS > HOST_LONG_BITS
 275     /* temporary fixed-point registers
 276      * used to emulate 64 bits target on 32 bits hosts
 277      */
 278     target_ulong t0, t1;
 279 #endif
 280     /* */
 281     double ft0, ft1, ft2;
 282
 283     /* Those resources are used only in Qemu core */
 284     CPU_COMMON
 285
 286     uint32_t hflags;
 287
 288     int error_code;
 289
 290     uint32_t features;
 291     uint32_t amask;
 292     int implver;
 293     pal_handler_t *pal_handler;
 294 };
 295
 296 #define CPUState CPUAlphaState
 297 #define cpu_init cpu_alpha_init
 298 #define cpu_exec cpu_alpha_exec
 299 #define cpu_gen_code cpu_alpha_gen_code
 300 #define cpu_signal_handler cpu_alpha_signal_handler
 301
 302 /* MMU modes definitions */
 303 #define MMU_MODE0_SUFFIX _kernel
 304 #define MMU_MODE1_SUFFIX _executive
 305 #define MMU_MODE2_SUFFIX _supervisor
 306 #define MMU_MODE3_SUFFIX _user
 307 #define MMU_USER_IDX 3
 308 static inline int cpu_mmu_index (CPUState *env)
 309 {
 310     return (env->ps >> 3) & 3;
 311 }
 312
 313 #if defined(CONFIG_USER_ONLY)
 314 static inline void cpu_clone_regs(CPUState *env, target_ulong newsp)
 315 {
 316     if (newsp)
 317         env->ir[30] = newsp;
 318     /* FIXME: Zero syscall return value.  */
 319 }
 320 #endif
 321
 322 #include "cpu-all.h"
 323
 324 enum {
 325     FEATURE_ASN    = 0x00000001,
 326     FEATURE_SPS    = 0x00000002,
 327     FEATURE_VIRBND = 0x00000004,
 328     FEATURE_TBCHK  = 0x00000008,
 329 };
 330
 331 enum {
 332     EXCP_RESET            = 0x0000,
 333     EXCP_MCHK             = 0x0020,
 334     EXCP_ARITH            = 0x0060,
 335     EXCP_HW_INTERRUPT     = 0x00E0,
 336     EXCP_DFAULT           = 0x01E0,
 337     EXCP_DTB_MISS_PAL     = 0x09E0,
 338     EXCP_ITB_MISS         = 0x03E0,
 339     EXCP_ITB_ACV          = 0x07E0,
 340     EXCP_DTB_MISS_NATIVE  = 0x08E0,
 341     EXCP_UNALIGN          = 0x11E0,
 342     EXCP_OPCDEC           = 0x13E0,
 343     EXCP_FEN              = 0x17E0,
 344     EXCP_CALL_PAL         = 0x2000,
 345     EXCP_CALL_PALP        = 0x3000,
 346     EXCP_CALL_PALE        = 0x4000,
 347     /* Pseudo exception for console */
 348     EXCP_CONSOLE_DISPATCH = 0x4001,
 349     EXCP_CONSOLE_FIXUP    = 0x4002,
 350 };
 351
 352 /* Arithmetic exception */
 353 enum {
 354     EXCP_ARITH_OVERFLOW,
 355 };
 356
 357 enum {
 358     PALCODE_CALL = 0x00000000,
 359     PALCODE_LD   = 0x01000000,
 360     PALCODE_ST   = 0x02000000,
 361     PALCODE_MFPR = 0x03000000,
 362     PALCODE_MTPR = 0x04000000,
 363     PALCODE_REI  = 0x05000000,
 364     PALCODE_INIT = 0xF0000000,
 365 };
 366
 367 enum {
 368     IR_V0   = 0,
 369     IR_T0   = 1,
 370     IR_T1   = 2,
 371     IR_T2   = 3,
 372     IR_T3   = 4,
 373     IR_T4   = 5,
 374     IR_T5   = 6,
 375     IR_T6   = 7,
 376     IR_T7   = 8,
 377     IR_S0   = 9,
 378     IR_S1   = 10,
 379     IR_S2   = 11,
 380     IR_S3   = 12,
 381     IR_S4   = 13,
 382     IR_S5   = 14,
 383     IR_S6   = 15,
 384 #define IR_FP IR_S6
 385     IR_A0   = 16,
 386     IR_A1   = 17,
 387     IR_A2   = 18,
 388     IR_A3   = 19,
 389     IR_A4   = 20,
 390     IR_A5   = 21,
 391     IR_T8   = 22,
 392     IR_T9   = 23,
 393     IR_T10  = 24,
 394     IR_T11  = 25,
 395     IR_RA   = 26,
 396     IR_T12  = 27,
 397 #define IR_PV IR_T12
 398     IR_AT   = 28,
 399     IR_GP   = 29,
 400     IR_SP   = 30,
 401     IR_ZERO = 31,
 402 };
 403
 404 CPUAlphaState * cpu_alpha_init (const char *cpu_model);
 405 int cpu_alpha_exec(CPUAlphaState *s);
 406 /* you can call this signal handler from your SIGBUS and SIGSEGV
 407    signal handlers to inform the virtual CPU of exceptions. non zero
 408    is returned if the signal was handled by the virtual CPU.  */
 409 int cpu_alpha_signal_handler(int host_signum, void *pinfo,
 410                              void *puc);
 411 int cpu_alpha_mfpr (CPUState *env, int iprn, uint64_t *valp);
 412 int cpu_alpha_mtpr (CPUState *env, int iprn, uint64_t val, uint64_t *oldvalp);
 413 void cpu_loop_exit (void);
 414 void pal_init (CPUState *env);
 415 #if !defined (CONFIG_USER_ONLY)
 416 void call_pal (CPUState *env);
 417 #else
 418 void call_pal (CPUState *env, int palcode);
 419 #endif
 420
 421 #define CPU_PC_FROM_TB(env, tb) env->pc = tb->pc
 422
 423 #endif /* !defined (__CPU_ALPHA_H__) */