/*
 * Copyright (C) 1998 by the Board of Trustees
 *    of Leland Stanford Junior University.
 * Copyright (C) 1998 Digital Equipment Corporation
 *
 * This file is part of the SimOS distribution.
 * See LICENSE file for terms of the license.
 *
 */



/* 
 * ipr_decode: debugging of priviledged instructions 
 */

#include <stdlib.h>

#include "simtypes.h"
#include "alpha.h"
#include "ev5_ipr.h"
#include "sim_error.h"
#include "tclsimos.h"


static char *reg_name[32];
static char *fp_reg_name[32];
static char *ipr_name[MAX_IPR];


static void DefineReg(char *name,int reg)
{
   ASSERT( reg>=0);
   ASSERT( reg<32);
   ASSERT( !reg_name[reg]);
   reg_name[reg] = name;
}

char *GetRegName(int reg)
{
   ASSERT( reg >=0 && reg < 32);
   ASSERT( reg_name[reg]);
   return reg_name[reg];
}

static void DefineFPReg(char *name,int reg)
{
   ASSERT( reg>=0);
   ASSERT( reg<32);
   ASSERT( !fp_reg_name[reg]);
   fp_reg_name[reg] = name;
}

char *GetFPRegName(int reg)
{
   ASSERT( reg >=0 && reg < 32);
   ASSERT( fp_reg_name[reg]);
   return fp_reg_name[reg];
}

static void DefineIPR(int ipr, char *name)
{
   ASSERT(ipr>=0);
   ASSERT(ipr<MAX_IPR);
   if (ipr_name[ipr]) { 
      CPUWarning("DefineIPR redefine %x old=%20s new=%20s\n",
                 ipr, ipr_name[ipr],name);
   }

   ipr_name[ipr] = name;
}

char * GetIPRName(int ipr)
{
   static char buf[128];
   if (ipr<0 || ipr >= MAX_IPR) {
      sprintf(buf,"BOGUS(0x%x)",ipr);
      return buf;
   }
   if (!ipr_name[ipr]) {
      sprintf(buf,"UNDEF(0x%x)",ipr);
      return buf;
   } else {
      return ipr_name[ipr];
   }
}

#define DEFINE_IPR(x) DefineIPR(x, #x)

void InitIPRNames(void)
{

   DefineReg("v0",0);
   DefineReg("t0",1);
   DefineReg("t1",2);
   DefineReg("t2",3);
   DefineReg("t3",4);
   DefineReg("t4",5);
   DefineReg("t5",6);
   DefineReg("t6",7);
   DefineReg("t7",8);
   DefineReg("s0",9);
   DefineReg("s1",10);
   DefineReg("s2",11);
   DefineReg("s3",12);
   DefineReg("s4",13);
   DefineReg("s5",14);
   DefineReg("s6",15);
   /* DefineReg("fp",15); */
   DefineReg("a0",16);
   DefineReg("a1",17);
   DefineReg("a2",18);
   DefineReg("a3",19);
   DefineReg("a4",20);
   DefineReg("a5",21);
   DefineReg("t8",22);
   DefineReg("t9",23);
   DefineReg("t10",24);
   DefineReg("t11",25);
   DefineReg("ra",26);
   /* DefineReg("pv",27); */
   DefineReg("t12",27);
   DefineReg("AT",28);
   DefineReg("gp",29);
   DefineReg("sp",30);
   DefineReg("zero",31);

   DefineFPReg("$f0",0);
   DefineFPReg("$f1",1);
   DefineFPReg("$f2",2);
   DefineFPReg("$f3",3);
   DefineFPReg("$f4",4);
   DefineFPReg("$f5",5);
   DefineFPReg("$f6",6);
   DefineFPReg("$f7",7);
   DefineFPReg("$f8",8);
   DefineFPReg("$f9",9);
   DefineFPReg("$f10",10);
   DefineFPReg("$f11",11);
   DefineFPReg("$f12",12);
   DefineFPReg("$f13",13);
   DefineFPReg("$f14",14);
   DefineFPReg("$f15",15);
   DefineFPReg("$f16",16);
   DefineFPReg("$f17",17);
   DefineFPReg("$f18",18);
   DefineFPReg("$f19",19);
   DefineFPReg("$f20",20);
   DefineFPReg("$f21",21);
   DefineFPReg("$f22",22);
   DefineFPReg("$f23",23);
   DefineFPReg("$f24",24);
   DefineFPReg("$f25",25);
   DefineFPReg("$f26",26);
   DefineFPReg("$f27",27);
   DefineFPReg("$f28",28);
   DefineFPReg("$f29",29);
   DefineFPReg("$f30",30);
   DefineFPReg("$f31",31);
  
   DEFINE_IPR(IPR_PMCTR);
   DEFINE_IPR(IPR_ISR);
   DEFINE_IPR(IPR_INTID);
   DEFINE_IPR(IPR_ASTSR);
   DEFINE_IPR(IPR_ASTER);
   DEFINE_IPR(IPR_SIRR);
   DEFINE_IPR(IPR_HWINT_CLR);
   DEFINE_IPR(IPR_SL_XMIT);
   DEFINE_IPR(IPR_SL_RCV);
   DEFINE_IPR(IPR_ICERRSTAT);
   DEFINE_IPR(IPR_ICROWMAP);
   DEFINE_IPR(IPR_DCFILLERR);
   DEFINE_IPR(IPR_DCERRSTAT);
   DEFINE_IPR(IPR_DCTESTCTL);
   DEFINE_IPR(IPR_DCTESTTAG);
   DEFINE_IPR(IPR_DCTESTTAGT);
   DEFINE_IPR(IPR_DCMODE);
   DEFINE_IPR(IPR_MAFMODE);
   DEFINE_IPR(IPR_MCSR);
   DEFINE_IPR(IPR_IC_FLUSH);
   DEFINE_IPR(IPR_DC_FLUSH);
   DEFINE_IPR(IPR_CC);
   DEFINE_IPR(IPR_CC_CTL);
   DEFINE_IPR(IPR_IPL);
   DEFINE_IPR(IPR_PS);
   DEFINE_IPR(IPR_PAL_BASE);
   DEFINE_IPR(IPR_EXC_ADDR);
   DEFINE_IPR(IPR_EXC_SUM);
   DEFINE_IPR(IPR_EXC_MASK);
   DEFINE_IPR(IPR_MM_STAT);
   DEFINE_IPR(IPR_ITB_TAG);
   DEFINE_IPR(IPR_ITB_PTE);
   DEFINE_IPR(IPR_ITB_ASN);
   DEFINE_IPR(IPR_IPTE_TEMP);
   DEFINE_IPR(IPR_IVA);
   DEFINE_IPR(IPR_IVA_F);
   DEFINE_IPR(IPR_IVPTBR);
   DEFINE_IPR(IPR_ICSR);
   DEFINE_IPR(IPR_ALT_MODE);
   DEFINE_IPR(IPR_DTB_ASN);
   DEFINE_IPR(IPR_DTB_CM);
   DEFINE_IPR(IPR_DTB_TAG);
   DEFINE_IPR(IPR_DTB_PTE);
   DEFINE_IPR(IPR_DPTE_TEMP);
   DEFINE_IPR(IPR_VA);
   DEFINE_IPR(IPR_VA_F);
   DEFINE_IPR(IPR_MVPTBR);
   DEFINE_IPR(IPR_DTBIA);
   DEFINE_IPR(IPR_DTBIAP);
   DEFINE_IPR(IPR_DTBIS);
   DEFINE_IPR(IPR_ITBIA);
   DEFINE_IPR(IPR_ITBIAP);
   DEFINE_IPR(IPR_ITBIS);
   DEFINE_IPR(EVX$IPR_IBOX);
   DEFINE_IPR(EVX$IPR_ABOX);
   DEFINE_IPR(EVX$IPR_DTB_CTL);
   DEFINE_IPR(EVX$IPR_MM_CSR);
   DEFINE_IPR(EVX$IPR_BIU_ADDR);
   DEFINE_IPR(EVX$IPR_BIU_STAT);
   DEFINE_IPR(EVX$IPR_DC_ADDR);
   DEFINE_IPR(EVX$IPR_DC_STAT);
   DEFINE_IPR(EVX$IPR_FILL_ADDR);
   DEFINE_IPR(EVX$IPR_ABOX_CTL);
   DEFINE_IPR(EVX$IPR_BIU_CTL);
   DEFINE_IPR(EVX$IPR_FILL_SYNDROME);
   DEFINE_IPR(EVX$IPR_BC_TAG);
   DEFINE_IPR(EVX$IPR_INTR_FLAG);
   DEFINE_IPR(EVX$IPR_LOCK_FLAG);
   DEFINE_IPR(EVX$IPR_HIRR);
   DEFINE_IPR(EVX$IPR_ASTRR);
   DEFINE_IPR(EVX$IPR_HIER);
   DEFINE_IPR(EVX$IPR_SIER);
   DEFINE_IPR(EVX$IPR_SL_CLR);
   DEFINE_IPR(EVX$IPR_ISSUE_CHK);
   DEFINE_IPR(EVX$IPR_SINGLE_ISSUE);
   DEFINE_IPR(EVX$IPR_DUAL_ISSUE);
   /* DEFINE_IPR(IPR_PAL); */
   DEFINE_IPR(IPR_PAL_R0);
   DEFINE_IPR(IPR_PAL_R1);
   DEFINE_IPR(IPR_PAL_R2);
   /* DEFINE_IPR(IPR_PAL_R3); */
   DEFINE_IPR(IPR_PAL_IMPURE);
   DEFINE_IPR(IPR_PAL_R4);
   DEFINE_IPR(IPR_PAL_R5);
   DEFINE_IPR(IPR_PAL_R6);
   DEFINE_IPR(IPR_PAL_R7);
   DEFINE_IPR(IPR_PAL_R8);
   DEFINE_IPR(IPR_PAL_R9);
   DEFINE_IPR(IPR_PAL_R10);
   DEFINE_IPR(IPR_PAL_R11);
   DEFINE_IPR(IPR_PAL_R12);
   DEFINE_IPR(IPR_PAL_R13);
   DEFINE_IPR(IPR_PAL_R14);
   DEFINE_IPR(IPR_PAL_R15);
   /* DEFINE_IPR(IPR_PAL_R16); */
   DEFINE_IPR(IPR_PAL_WHAMI);
   DEFINE_IPR(IPR_PAL_R17);
   DEFINE_IPR(IPR_PAL_R18);
   DEFINE_IPR(IPR_PAL_R19);
   DEFINE_IPR(IPR_PAL_R20);
   DEFINE_IPR(IPR_PAL_R21);
   DEFINE_IPR(IPR_PAL_R22);
   DEFINE_IPR(IPR_PAL_R23);
   DEFINE_IPR(IPR_PAL_R24);
   DEFINE_IPR(IPR_PAL_R25);
   DEFINE_IPR(IPR_PAL_R26);
   DEFINE_IPR(IPR_PAL_R27);
   DEFINE_IPR(IPR_PAL_R28);
   DEFINE_IPR(IPR_PAL_R29);
   DEFINE_IPR(IPR_PAL_R30);
   DEFINE_IPR(IPR_PAL_R31);
   DEFINE_IPR(EVX$IPR_FP_CTL);
}


Reg EV5_GetIPR(int cpunum, int index)
{
   AlphaState *P = PE[cpunum];
   Reg value;
   switch (index) {
   case IPR_EXC_ADDR:
      value = P->trapState->atr[ATR_EXC_ADDR];
      break;
   case IPR_MM_STAT:
      value = P->trapState->atr[ATR_MM_STAT];
      break;
   case IPR_VA:
      value = P->trapState->atr[ATR_VA];
      break;
   case IPR_VA_FORM:
      value = P->trapState->atr[ATR_VA_FORM];
      break;
   case IPR_IVA:
      value = P->trapState->atr[ATR_IVA];
      break;
   case IPR_ITB_TAG:
      value = P->trapState->atr[ATR_ITB_TAG];
      break;
   case IPR_IVA_F:
      value = P->trapState->atr[ATR_IVA_F];
      break;
   case IPR_IPL:
      value = P->trapState->atr[ATR_IPL];
      break;
   case IPR_ISR:
      value = P->trapState->atr[ATR_ISR];
      break;
   case IPR_INTID:
      value = P->trapState->atr[ATR_INTID];
      break;
   default:
      value = P->ipr[index];
   }
   return value;
}

char *
IPRAccess(ClientData clientData, Tcl_Interp *interp,
          char *name1, char *name2, int flags)
{
   char buf[32];
   long index = strtoul(name2, (char**)NULL, 0);
   if (flags & TCL_TRACE_READS) {
      AlphaState *P = curPE;
      Reg value = EV5_GetIPR(P->myNum, index);    
      sprintf(buf, "0x%lx", value);
      Tcl_SetVar2(interp, name1, name2, buf, TCL_GLOBAL_ONLY);
   }
   return NULL;
}