tcl_init.c

一个用在mips体系结构中的操作系统

   return TCL_OK;
}

static int
ExitUserProcCmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[])
{
   int cpuNum;

   if (argc != 2) {
      Tcl_AppendResult(interp, "Bad arg, should be: exitUserProc cpuNum\n",
                       NULL);
      return TCL_ERROR;  
   }
   cpuNum = atoi(argv[1]);
   ASSERT(CPUVec.ProcMakeProcExit);
   CPUVec.ProcMakeProcExit(cpuNum);
   return TCL_OK;
}

void 
MiscInit(Tcl_Interp *interp)
{
   Tcl_CreateCommand(interp, "handler", HandlerCmd,
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

#ifdef OPTION_AS_HASHTABLE
   Tcl_SetVar2(interp, "OPTION", "need_to_set_so_I_can_trace", "",
               TCL_GLOBAL_ONLY);

   Tcl_TraceVar(interp, "OPTION",
                TCL_TRACE_READS | TCL_TRACE_WRITES | TCL_GLOBAL_ONLY,
                OptionAccess, (ClientData) NULL);
#else
   TCLOptionInit(interp);
#endif /* OPTION_AS_HASHTABLE */


   Tcl_CreateCommand(interp, "random", RandomCmd,
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

   Tcl_CreateCommand(interp, "source", SourceCmd,
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

   Tcl_CreateCommand(interp, "log", LogCmd,
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

   Tcl_CreateCommand(interp, "console", ConsoleCmd,
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

   Tcl_CreateCommand(interp, "debug", DebugCmd,
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

   Tcl_CreateCommand(interp, "assert", AssertCmd,
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

   Tcl_CreateCommand(interp, "cpuEnter", CPUEnterCmd,
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

   Tcl_CreateCommand(interp, "simosExit", SimosExitCmd,
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

   Tcl_CreateCommand(interp, "profile", ProfileCmd, 
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

   Tcl_CreateCommand(interp, "doCheckpoint", DoCheckpointCmd, 
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

   Tcl_CreateCommand(interp, "do_checkpoint", DoCheckpointCmd, 
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

   Tcl_CreateCommand(interp, "disableCPU", DisableCPUCmd, 
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

   Tcl_CreateCommand(interp, "exitUserProc", ExitUserProcCmd,
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

   Tcl_CreateCommand(interp, "machine", MachineSelectCmd,
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

   Tcl_CreateCommand(interp, "machine_val", MachineValueCmd,
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);

#if defined(SIM_MIPS32) || defined(SIM_MIPS64)
   Tcl_CreateCommand(interp, "hive", HiveCmd,
                     (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);
#endif
}

#ifdef USE_FLASHLITE
extern void FlashliteConfigDefaults(void);
static void
FlashliteTclInit(Tcl_Interp *interp)
{
   FlashliteConfigDefaults();
}
#endif


/*
 *   Debug stub for access to machine state
 */

Tcl_HashTable regTable;

#define NUM_REGS    ((sizeof reg_names)/sizeof(char*))

char* reg_names[] = REGISTER_NAMES;


#define FIRST_FP_REG                   32
#define IS_FPREG(_regnum)              (((_regnum) >= FIRST_FP_REG) && ((_regnum) < 64))

#define FIRST_DFP_REG                  (84)
#define IS_DFPREG(_regnum)             ((_regnum) >= FIRST_DFP_REG)
#define DFPREGNUM_TO_FPREGNUM(_regnum) (((_regnum) - FIRST_DFP_REG)*2 + FIRST_FP_REG)

static char *RegisterAccess(ClientData clientData, Tcl_Interp *interp,
                            char *name1, char *name2, int flags)
{
   Tcl_HashEntry *entryPtr;
   int regnum = 0;
   char buf[32];
   char *valstr;
   Reg regValue = 0;
   int cpunum;
   int argc;
   char **argv;
   
   union {
      double  fpr;
      struct {
         Reg  fgr1;
         Reg  fgr0;
      } fgr;
   } fpreg;
   
   if ((!CPUVec.GetRegister) || (!CPUVec.CurrentCpuNum)) {
      CPUWarning("TCL: WARNING - Too early to read registers. Returning 0.\n");
      Tcl_SetVar2(interp, name1, name2, "0", 0);
      return NULL;
   }

   cpunum = CPUVec.CurrentCpuNum();

   if (!strcmp(name1,"REGISTER")) {
      if (Tcl_SplitList(interp, name2, &argc, &argv) != TCL_OK) {
         return "cannot parse register number";
      }

      if ((argc != 1) && (argc != 2)) {
         free(argv);
         return "bad register list";
      }
      
      entryPtr = Tcl_FindHashEntry(&regTable, argv[0]);
      if (entryPtr == NULL) {
         free(argv);
         return "bad register name";
      }
      
      regnum = (int)PTR_TO_UINT64(Tcl_GetHashValue(entryPtr));

      if (argc == 2) {
         if (Tcl_GetInt(interp, argv[1], &cpunum) != TCL_OK) {
            free(argv);
            return "bad cpu number";
         }
      }
      free(argv);
      
   } else {
      entryPtr = Tcl_FindHashEntry(&regTable, name1);
      if (entryPtr == NULL) {
         return "bad register name";
      }
      
      regnum = (int)PTR_TO_UINT64(Tcl_GetHashValue(entryPtr));
   }
   
   
   if (flags & TCL_TRACE_READS) {
      if (IS_DFPREG(regnum)) {
         regnum = DFPREGNUM_TO_FPREGNUM(regnum);
         CPUVec.GetRegister(cpunum, regnum, &fpreg.fgr.fgr0);
         CPUVec.GetRegister(cpunum, regnum+1, &fpreg.fgr.fgr1);
         sprintf(buf, "%23.20f", fpreg.fpr);
         
      } else {
         CPUVec.GetRegister(cpunum, regnum, &regValue);
         if (IS_FPREG(regnum)) {
            sprintf(buf, "%23.20f", (float)regValue);
         } else if (sizeof(Reg) == sizeof(int)) {
            sprintf(buf, "0x%x", (int)regValue);
         } else { 
            PrintLLX(buf,regValue);
         }
      }
      
      Tcl_SetVar2(interp, name1, name2, buf, 0);

   } else if (flags & TCL_TRACE_WRITES) {
      if ((valstr = Tcl_GetVar2(interp, name1, name2, 0)) == NULL) {
         return "bad reg";
      }
      if (IS_DFPREG(regnum)) {
         regnum = DFPREGNUM_TO_FPREGNUM(regnum);
         if (Tcl_GetDouble(interp, valstr, &(fpreg.fpr)) != TCL_OK) {
            return "bad value";
         }
         CPUVec.PutRegister(cpunum, regnum, fpreg.fgr.fgr0);
         CPUVec.PutRegister(cpunum, regnum+1, fpreg.fgr.fgr1);
         
      } else if (IS_FPREG(regnum)) {
         if (Tcl_GetDouble(interp, valstr, &(fpreg.fpr)) != TCL_OK) {
            return "bad value";
         }
         CPUVec.PutRegister(cpunum, regnum, fpreg.fgr.fgr0);
         
      } else {
	 Reg value=0;
	 if (String2Reg(interp,valstr,&value)!=TCL_OK) 
	    return "bad value";
	 
         CPUVec.PutRegister(cpunum, regnum, value);
      }
   }
   
   return NULL;
}

static char *MemoryAccess(ClientData clientData, Tcl_Interp *interp,
                          char *name1, char *name2, int flags)
{
   Reg addr = 0;
   char buf[32];
   char *valstr;
   int value = 0;
   int cpunum;

   if ((!CPUVec.PutMemory) || (!CPUVec.GetMemory) || (!CPUVec.CurrentCpuNum)) {
      CPUWarning("TCL: WARNING - Too early to read MEMORY. Returning 0.\n");
      Tcl_SetVar2(interp, name1, name2, "0", 0);
      return NULL;
   }

   cpunum = CPUVec.CurrentCpuNum();
   
   /* find addr (should take symbols) */
   if ((name2 == NULL)
       || (String2Reg(interp, name2, &addr) != TCL_OK)) {
      return "bad addr";
   }
   
   if (flags & TCL_TRACE_READS) {
      if (CPUVec.GetMemory(cpunum, addr, 4, (char *)&value) != SUCCESS) {
         return "not mapped";
      }
      value = MO2HO_4(value);
      sprintf(buf, "0x%x", value);
      Tcl_SetVar2(interp, name1, name2, buf, 0);
      
   } else if (flags & TCL_TRACE_WRITES) {
      if ((valstr = Tcl_GetVar2(interp, name1, name2, 0)) == NULL) {
         return "bad addr";
      }
      if (Tcl_GetInt(interp, valstr, &value) != TCL_OK) {
         return "bad addr";
      }
      if (CPUVec.PutMemory(cpunum, addr, 4, (char *)&value) != SUCCESS) {
         return "not mapped";
      }
   }
   
   return NULL;
}


static char *PhysicalAccess(ClientData clientData, Tcl_Interp *interp,
                          char *name1, char *name2, int flags)
{
   Reg addr = 0;
   char buf[32];
   PA value = 0;
   int cpunum;

   if ((!CPUVec.TranslateVirtualNoSE) || (!CPUVec.CurrentCpuNum)) {
      return "Too early to read PHYSICAL.";
   }

   cpunum = CPUVec.CurrentCpuNum();
   
   /* find addr (should take symbols) */
   if ((name2 == NULL)
       || (String2Reg(interp, name2, &addr) != TCL_OK)) {
      return "bad addr";
   }
   
   if (flags & TCL_TRACE_READS) {
      if (CPUVec.TranslateVirtualNoSE(cpunum, addr, &value) != SUCCESS) {
         return "not mapped";
      }
#ifdef __alpha
      sprintf(buf, "0x%lx", (uint64)value);
#else
      sprintf(buf,"0x%llx", (uint64)value);
#endif
      Tcl_SetVar2(interp, name1, name2, buf, 0);
      
   } else if (flags & TCL_TRACE_WRITES) {
      return "can't write PHYSICAL";
   }
   
   return NULL;
}


static char *CPUAccess(ClientData clientData, Tcl_Interp *interp,
                       char *name1, char *name2, int flags)
{
   char buf[32];

   if (!CPUVec.CurrentCpuNum) {
      Tcl_SetVar(interp, name1, "0", 0);
      return NULL;
   }
   
   if (flags & TCL_TRACE_READS) {
      /* set its value */
      sprintf(buf, "%d", (CPUVec.CurrentCpuNum) ? CPUVec.CurrentCpuNum() : 0);
      Tcl_SetVar(interp, name1, buf, 0);

   } else if (flags & TCL_TRACE_WRITES) {
      return "Writes to CPU ignored";
   }
   
   return NULL;
}

static char *CellAccess(ClientData clientData, Tcl_Interp *interp,
                        char *name1, char *name2, int flags)
{
   char buf[32];

   if (!CPUVec.CurrentCpuNum) {
      Tcl_SetVar(interp, name1, "0", 0);
      return NULL;
   }
   
   if (flags & TCL_TRACE_READS) {
      int cpu = CPUVec.CurrentCpuNum();
      /* set its value */
      sprintf(buf, "%d", cpu / CPUS_PER_CELL(M_FROM_CPU(cpu)));
      Tcl_SetVar(interp, name1, buf, 0);

   } else if (flags & TCL_TRACE_WRITES) {
      return "Writes to CELL ignored";
   }
   
   return NULL;
}

static char *CycleAccess(ClientData clientData, Tcl_Interp *interp,
                         char *name1, char *name2, int flags) 
{
   int cpunum;
   char buf[32];

   if ((!CPUVec.CycleCount) || (!CPUVec.CurrentCpuNum)) {
      CPUWarning("TCL: WARNING - Too early to read CYCLES. Returning 0.\n");
      Tcl_SetVar(interp, name1, "0", 0);
      return NULL;
   }
   if (flags & TCL_TRACE_READS) {
      cpunum = CPUVec.CurrentCpuNum();
      PrintLLD(buf,CPUVec.CycleCount(cpunum));
      Tcl_SetVar(interp, name1, buf, 0);
   } else if (flags & TCL_TRACE_WRITES) {
      return "Writes to CYCLES ignored";
   }
   return NULL;
}

static char *InstsAccess(ClientData clientData, Tcl_Interp *interp,
                         char *name1, char *name2, int flags) 
{
   int cpunum;
   char buf[32];

   if ((!CPUVec.InstrCount) || (!CPUVec.CurrentCpuNum)) {
      CPUWarning("TCL: WARNING - Too early to read INSTS. Returning 0.\n");
      Tcl_SetVar(interp, name1, "0", 0);
      return NULL;
   }

   ASSERT(CPUVec.CurrentCpuNum);
   ASSERT(CPUVec.InstrCount);

   cpunum = CPUVec.CurrentCpuNum();

   if (flags & TCL_TRACE_READS) {
      PrintLLD(buf, CPUVec.InstrCount(cpunum));
      Tcl_SetVar(interp, name1, buf, 0);
   } else if (flags & TCL_TRACE_WRITES) {
      return "Writes to INSTS ignored";
   }
   return NULL;
}

static int ReadStringCmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[])
{
   Tcl_DString dstr;
   char *addrStr;
   VA addr=0;
   char c[2];
   int code;
   int cpunum;
   
   if ((!CPUVec.PutMemory) || (!CPUVec.GetMemory) || (!CPUVec.CurrentCpuNum)) {
      Tcl_AppendResult(interp, "too early to read memory", 0);
      return TCL_ERROR;
   }

   cpunum = CPUVec.CurrentCpuNum();

   if (argc != 2) {
      Tcl_AppendResult(interp, "wrong # args: should be \"",
                       argv[0], " addr\"", NULL);
      return TCL_ERROR;
   }

   addrStr = argv[1];
   if (String2Reg(interp,addrStr,&addr) != TCL_OK) {
      return TCL_ERROR;
    }

   Tcl_DStringInit(&dstr);

   c[1] = 0;
   while (1) {
      if (CPUVec.GetMemory(cpunum, addr, 1, c) != SUCCESS) {
         break;
      }
      if (!c[0]) {
         break;
      }
      Tcl_DStringAppend(&dstr, c, 1);
      addr++;
   }

   Tcl_AppendResult(interp, Tcl_DStringValue(&dstr), NULL);
   Tcl_DStringFree(&dstr);

   return TCL_OK;
}

static int WriteStringCmd(ClientData clientData, Tcl_Interp *interp,
			  int argc, char *argv[])
{
  char *addrStr;
  char *strStr;
  VA addr=0;
  char c;
  int code;
  int cpunum;
   
  if ((!CPUVec.PutMemory) || (!CPUVec.GetMemory) || (!CPUVec.CurrentCpuNum)) {
    Tcl_AppendResult(interp, "too early to read memory", 0);
    return TCL_ERROR;
  }

  cpunum = CPUVec.CurrentCpuNum();

  if (argc != 3) {
    Tcl_AppendResult(interp, "wrong # args: should be \"",
		     argv[0], " addr\"", NULL);
    return TCL_ERROR;
  }

  addrStr = argv[1];
  strStr = argv[2];
  if (String2Reg(interp,addrStr,&addr) != TCL_OK) {
    return TCL_ERROR;
  }

#if 0
  fprintf(stderr, "WriteStringCmd: addrStr=%p strStr=%p\n", addrStr, strStr);
  fprintf(stderr, "                addrStr=%s strStr=%s\n", addrStr, strStr);
#endif
  do {
    c = *strStr++;
    if (CPUVec.PutMemory(cpunum, addr, 1, &c) != SUCCESS) {
      break;
    }
    addr++;
  } while (c);

  return TCL_OK;
}

static int ReadWideStringCmd(ClientData clientData, Tcl_Interp *interp,
                             int argc, char *argv[])
{
   Tcl_DString dstr;