src/arch/sparc/miscregfile.cc

   1 /*
   2  * Copyright (c) 2003-2005 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * Authors: Gabe Black
  29  *          Ali Saidi
  30  */
  31
  32 #include "arch/sparc/asi.hh"
  33 #include "arch/sparc/miscregfile.hh"
  34 #include "base/bitfield.hh"
  35 #include "base/trace.hh"
  36 #include "config/full_system.hh"
  37 #include "cpu/base.hh"
  38 #include "cpu/thread_context.hh"
  39
  40 using namespace SparcISA;
  41 using namespace std;
  42
  43 class Checkpoint;
  44
  45 //These functions map register indices to names
  46 string SparcISA::getMiscRegName(RegIndex index)
  47 {
  48     static::string miscRegName[NumMiscRegs] =
  49         {/*"y", "ccr",*/ "asi", "tick", "fprs", "pcr", "pic",
  50          "gsr", "softint_set", "softint_clr", "softint", "tick_cmpr",
  51          "stick", "stick_cmpr",
  52          "tpc", "tnpc", "tstate", "tt", "privtick", "tba", "pstate", "tl",
  53          "pil", "cwp", /*"cansave", "canrestore", "cleanwin", "otherwin",
  54          "wstate",*/ "gl",
  55          "hpstate", "htstate", "hintp", "htba", "hver", "strand_sts_reg",
  56          "hstick_cmpr",
  57          "fsr", "prictx", "secctx", "partId", "lsuCtrlReg",
  58          "scratch0", "scratch1", "scratch2", "scratch3", "scratch4",
  59          "scratch5", "scratch6", "scratch7", "cpuMondoHead", "cpuMondoTail",
  60          "devMondoHead", "devMondoTail", "resErrorHead", "resErrorTail",
  61          "nresErrorHead", "nresErrorTail", "TlbData" };
  62
  63     return miscRegName[index];
  64 }
  65
  66 enum RegMask
  67 {
  68         PSTATE_MASK = (((1 << 4) - 1) << 1) | (((1 << 4) - 1) << 6) | (1 << 12)
  69 };
  70
  71 void MiscRegFile::clear()
  72 {
  73     //y = 0;
  74     //ccr = 0;
  75     asi = 0;
  76     tick = ULL(1) << 63;
  77     fprs = 0;
  78     gsr = 0;
  79     softint = 0;
  80     tick_cmpr = 0;
  81     stick = 0;
  82     stick_cmpr = 0;
  83     memset(tpc, 0, sizeof(tpc));
  84     memset(tnpc, 0, sizeof(tnpc));
  85     memset(tstate, 0, sizeof(tstate));
  86     memset(tt, 0, sizeof(tt));
  87     pstate = 0;
  88     tl = 0;
  89     pil = 0;
  90     cwp = 0;
  91     //cansave = 0;
  92     //canrestore = 0;
  93     //cleanwin = 0;
  94     //otherwin = 0;
  95     //wstate = 0;
  96     gl = 0;
  97     //In a T1, bit 11 is apparently always 1
  98     hpstate = (1 << 11);
  99     memset(htstate, 0, sizeof(htstate));
 100     hintp = 0;
 101     htba = 0;
 102     hstick_cmpr = 0;
 103     //This is set this way in Legion for some reason
 104     strandStatusReg = 0x50000;
 105     fsr = 0;
 106
 107     priContext = 0;
 108     secContext = 0;
 109     partId = 0;
 110     lsuCtrlReg = 0;
 111
 112     memset(scratchPad, 0, sizeof(scratchPad));
 113 #if FULL_SYSTEM
 114     tickCompare = NULL;
 115     sTickCompare = NULL;
 116     hSTickCompare = NULL;
 117 #endif
 118 }
 119
 120 MiscReg MiscRegFile::readRegNoEffect(int miscReg)
 121 {
 122
 123   // The three miscRegs are moved up from the switch statement
 124   // due to more frequent calls.
 125
 126   if (miscReg == MISCREG_GL)
 127     return gl;
 128   if (miscReg == MISCREG_CWP)
 129     return cwp;
 130   if (miscReg == MISCREG_TLB_DATA) {
 131     /* Package up all the data for the tlb:
 132      * 6666555555555544444444443333333333222222222211111111110000000000
 133      * 3210987654321098765432109876543210987654321098765432109876543210
 134      *   secContext   | priContext    |             |tl|partid|  |||||^hpriv
 135      *                                                           ||||^red
 136      *                                                           |||^priv
 137      *                                                           ||^am
 138      *                                                           |^lsuim
 139      *                                                           ^lsudm
 140      */
 141     return bits((uint64_t)hpstate,2,2) |
 142            bits((uint64_t)hpstate,5,5) << 1 |
 143            bits((uint64_t)pstate,3,2) << 2 |
 144            bits((uint64_t)lsuCtrlReg,3,2) << 4 |
 145            bits((uint64_t)partId,7,0) << 8 |
 146            bits((uint64_t)tl,2,0) << 16 |
 147                 (uint64_t)priContext << 32 |
 148                 (uint64_t)secContext << 48;
 149   }
 150
 151     switch (miscReg) {
 152       //case MISCREG_TLB_DATA:
 153       //  [original contents see above]
 154       //case MISCREG_Y:
 155       //  return y;
 156       //case MISCREG_CCR:
 157       //  return ccr;
 158       case MISCREG_ASI:
 159         return asi;
 160       case MISCREG_FPRS:
 161         return fprs;
 162       case MISCREG_TICK:
 163         return tick;
 164       case MISCREG_PCR:
 165         panic("PCR not implemented\n");
 166       case MISCREG_PIC:
 167         panic("PIC not implemented\n");
 168       case MISCREG_GSR:
 169         return gsr;
 170       case MISCREG_SOFTINT:
 171         return softint;
 172       case MISCREG_TICK_CMPR:
 173         return tick_cmpr;
 174       case MISCREG_STICK:
 175         return stick;
 176       case MISCREG_STICK_CMPR:
 177         return stick_cmpr;
 178
 179         /** Privilged Registers */
 180       case MISCREG_TPC:
 181         return tpc[tl-1];
 182       case MISCREG_TNPC:
 183         return tnpc[tl-1];
 184       case MISCREG_TSTATE:
 185         return tstate[tl-1];
 186       case MISCREG_TT:
 187         return tt[tl-1];
 188       case MISCREG_PRIVTICK:
 189         panic("Priviliged access to tick registers not implemented\n");
 190       case MISCREG_TBA:
 191         return tba;
 192       case MISCREG_PSTATE:
 193         return pstate;
 194       case MISCREG_TL:
 195         return tl;
 196       case MISCREG_PIL:
 197         return pil;
 198       //CWP, GL moved
 199       //case MISCREG_CWP:
 200       //  return cwp;
 201       //case MISCREG_CANSAVE:
 202       //  return cansave;
 203       //case MISCREG_CANRESTORE:
 204       //  return canrestore;
 205       //case MISCREG_CLEANWIN:
 206       //  return cleanwin;
 207       //case MISCREG_OTHERWIN:
 208       //  return otherwin;
 209       //case MISCREG_WSTATE:
 210       //  return wstate;
 211       //case MISCREG_GL:
 212       //  return gl;
 213
 214         /** Hyper privileged registers */
 215       case MISCREG_HPSTATE:
 216         return hpstate;
 217       case MISCREG_HTSTATE:
 218         return htstate[tl-1];
 219       case MISCREG_HINTP:
 220         return hintp;
 221       case MISCREG_HTBA:
 222         return htba;
 223       case MISCREG_STRAND_STS_REG:
 224         return strandStatusReg;
 225       case MISCREG_HSTICK_CMPR:
 226         return hstick_cmpr;
 227
 228         /** Floating Point Status Register */
 229       case MISCREG_FSR:
 230         DPRINTF(Sparc, "FSR read as: %#x\n", fsr);
 231         return fsr;
 232
 233       case MISCREG_MMU_P_CONTEXT:
 234         return priContext;
 235       case MISCREG_MMU_S_CONTEXT:
 236         return secContext;
 237       case MISCREG_MMU_PART_ID:
 238         return partId;
 239       case MISCREG_MMU_LSU_CTRL:
 240         return lsuCtrlReg;
 241
 242       case MISCREG_SCRATCHPAD_R0:
 243         return scratchPad[0];
 244       case MISCREG_SCRATCHPAD_R1:
 245         return scratchPad[1];
 246       case MISCREG_SCRATCHPAD_R2:
 247         return scratchPad[2];
 248       case MISCREG_SCRATCHPAD_R3:
 249         return scratchPad[3];
 250       case MISCREG_SCRATCHPAD_R4:
 251         return scratchPad[4];
 252       case MISCREG_SCRATCHPAD_R5:
 253         return scratchPad[5];
 254       case MISCREG_SCRATCHPAD_R6:
 255         return scratchPad[6];
 256       case MISCREG_SCRATCHPAD_R7:
 257         return scratchPad[7];
 258       case MISCREG_QUEUE_CPU_MONDO_HEAD:
 259         return cpu_mondo_head;
 260       case MISCREG_QUEUE_CPU_MONDO_TAIL:
 261         return cpu_mondo_tail;
 262       case MISCREG_QUEUE_DEV_MONDO_HEAD:
 263         return dev_mondo_head;
 264       case MISCREG_QUEUE_DEV_MONDO_TAIL:
 265         return dev_mondo_tail;
 266       case MISCREG_QUEUE_RES_ERROR_HEAD:
 267         return res_error_head;
 268       case MISCREG_QUEUE_RES_ERROR_TAIL:
 269         return res_error_tail;
 270       case MISCREG_QUEUE_NRES_ERROR_HEAD:
 271         return nres_error_head;
 272       case MISCREG_QUEUE_NRES_ERROR_TAIL:
 273         return nres_error_tail;
 274       default:
 275         panic("Miscellaneous register %d not implemented\n", miscReg);
 276     }
 277 }
 278
 279 MiscReg MiscRegFile::readReg(int miscReg, ThreadContext * tc)
 280 {
 281     switch (miscReg) {
 282         // tick and stick are aliased to each other in niagra
 283         // well store the tick data in stick and the interrupt bit in tick
 284       case MISCREG_STICK:
 285       case MISCREG_TICK:
 286       case MISCREG_PRIVTICK:
 287         // I'm not sure why legion ignores the lowest two bits, but we'll go
 288         // with it
 289         // change from curCycle() to instCount() until we're done with legion
 290         DPRINTF(Timer, "Instruction Count when TICK read: %#X stick=%#X\n",
 291                 tc->getCpuPtr()->instCount(), stick);
 292         return mbits(tc->getCpuPtr()->instCount() + (int64_t)stick,62,2) |
 293                mbits(tick,63,63);
 294       case MISCREG_FPRS:
 295         // in legion if fp is enabled du and dl are set
 296         return fprs | 0x3;
 297       case MISCREG_PCR:
 298       case MISCREG_PIC:
 299         panic("Performance Instrumentation not impl\n");
 300       case MISCREG_SOFTINT_CLR:
 301       case MISCREG_SOFTINT_SET:
 302         panic("Can read from softint clr/set\n");
 303       case MISCREG_SOFTINT:
 304       case MISCREG_TICK_CMPR:
 305       case MISCREG_STICK_CMPR:
 306       case MISCREG_HINTP:
 307       case MISCREG_HTSTATE:
 308       case MISCREG_HTBA:
 309       case MISCREG_HVER:
 310       case MISCREG_STRAND_STS_REG:
 311       case MISCREG_HSTICK_CMPR:
 312       case MISCREG_QUEUE_CPU_MONDO_HEAD:
 313       case MISCREG_QUEUE_CPU_MONDO_TAIL:
 314       case MISCREG_QUEUE_DEV_MONDO_HEAD:
 315       case MISCREG_QUEUE_DEV_MONDO_TAIL:
 316       case MISCREG_QUEUE_RES_ERROR_HEAD:
 317       case MISCREG_QUEUE_RES_ERROR_TAIL:
 318       case MISCREG_QUEUE_NRES_ERROR_HEAD:
 319       case MISCREG_QUEUE_NRES_ERROR_TAIL:
 320 #if FULL_SYSTEM
 321       case MISCREG_HPSTATE:
 322         return readFSReg(miscReg, tc);
 323 #else
 324       case MISCREG_HPSTATE:
 325         //HPSTATE is special because because sometimes in privilege checks for instructions
 326         //it will read HPSTATE to make sure the priv. level is ok
 327         //So, we'll just have to tell it it isn't, instead of panicing.
 328         return 0;
 329
 330       panic("Accessing Fullsystem register %s in SE mode\n",getMiscRegName(miscReg));
 331 #endif
 332
 333     }
 334     return readRegNoEffect(miscReg);
 335 }
 336
 337 void MiscRegFile::setRegNoEffect(int miscReg, const MiscReg &val)
 338 {
 339     switch (miscReg) {
 340 //      case MISCREG_Y:
 341 //        y = val;
 342 //        break;
 343 //      case MISCREG_CCR:
 344 //        ccr = val;
 345 //        break;
 346       case MISCREG_ASI:
 347         asi = val;
 348         break;
 349       case MISCREG_FPRS:
 350         fprs = val;
 351         break;
 352       case MISCREG_TICK:
 353         tick = val;
 354         break;
 355       case MISCREG_PCR:
 356         panic("PCR not implemented\n");
 357       case MISCREG_PIC:
 358         panic("PIC not implemented\n");
 359       case MISCREG_GSR:
 360         gsr = val;
 361         break;
 362       case MISCREG_SOFTINT:
 363         softint = val;
 364         break;
 365       case MISCREG_TICK_CMPR:
 366         tick_cmpr = val;
 367         break;
 368       case MISCREG_STICK:
 369         stick = val;
 370         break;
 371       case MISCREG_STICK_CMPR:
 372         stick_cmpr = val;
 373         break;
 374
 375         /** Privilged Registers */
 376       case MISCREG_TPC:
 377         tpc[tl-1] = val;
 378         break;
 379       case MISCREG_TNPC:
 380         tnpc[tl-1] = val;
 381         break;
 382       case MISCREG_TSTATE:
 383         tstate[tl-1] = val;
 384         break;
 385       case MISCREG_TT:
 386         tt[tl-1] = val;
 387         break;
 388       case MISCREG_PRIVTICK:
 389         panic("Priviliged access to tick regesiters not implemented\n");
 390       case MISCREG_TBA:
 391         // clear lower 7 bits on writes.
 392         tba = val & ULL(~0x7FFF);
 393         break;
 394       case MISCREG_PSTATE:
 395         pstate = (val & PSTATE_MASK);
 396         break;
 397       case MISCREG_TL:
 398         tl = val;
 399         break;
 400       case MISCREG_PIL:
 401         pil = val;
 402         break;
 403       case MISCREG_CWP:
 404         cwp = val;
 405         break;
 406 //      case MISCREG_CANSAVE:
 407 //        cansave = val;
 408 //        break;
 409 //      case MISCREG_CANRESTORE:
 410 //        canrestore = val;
 411 //        break;
 412 //      case MISCREG_CLEANWIN:
 413 //        cleanwin = val;
 414 //        break;
 415 //      case MISCREG_OTHERWIN:
 416 //        otherwin = val;
 417 //        break;
 418 //      case MISCREG_WSTATE:
 419 //        wstate = val;
 420 //        break;
 421       case MISCREG_GL:
 422         gl = val;
 423         break;
 424
 425         /** Hyper privileged registers */
 426       case MISCREG_HPSTATE:
 427         hpstate = val;
 428         break;
 429       case MISCREG_HTSTATE:
 430         htstate[tl-1] = val;
 431         break;
 432       case MISCREG_HINTP:
 433         hintp = val;
 434       case MISCREG_HTBA:
 435         htba = val;
 436         break;
 437       case MISCREG_STRAND_STS_REG:
 438         strandStatusReg = val;
 439         break;
 440       case MISCREG_HSTICK_CMPR:
 441         hstick_cmpr = val;
 442         break;
 443
 444         /** Floating Point Status Register */
 445       case MISCREG_FSR:
 446         fsr = val;
 447         DPRINTF(Sparc, "FSR written with: %#x\n", fsr);
 448         break;
 449
 450       case MISCREG_MMU_P_CONTEXT:
 451         priContext = val;
 452         break;
 453       case MISCREG_MMU_S_CONTEXT:
 454         secContext = val;
 455         break;
 456       case MISCREG_MMU_PART_ID:
 457         partId = val;
 458         break;
 459       case MISCREG_MMU_LSU_CTRL:
 460         lsuCtrlReg = val;
 461         break;
 462
 463       case MISCREG_SCRATCHPAD_R0:
 464         scratchPad[0] = val;
 465         break;
 466       case MISCREG_SCRATCHPAD_R1:
 467         scratchPad[1] = val;
 468         break;
 469       case MISCREG_SCRATCHPAD_R2:
 470         scratchPad[2] = val;
 471         break;
 472       case MISCREG_SCRATCHPAD_R3:
 473         scratchPad[3] = val;
 474         break;
 475       case MISCREG_SCRATCHPAD_R4:
 476         scratchPad[4] = val;
 477         break;
 478       case MISCREG_SCRATCHPAD_R5:
 479         scratchPad[5] = val;
 480         break;
 481       case MISCREG_SCRATCHPAD_R6:
 482         scratchPad[6] = val;
 483         break;
 484       case MISCREG_SCRATCHPAD_R7:
 485         scratchPad[7] = val;
 486         break;
 487       case MISCREG_QUEUE_CPU_MONDO_HEAD:
 488         cpu_mondo_head = val;
 489         break;
 490       case MISCREG_QUEUE_CPU_MONDO_TAIL:
 491         cpu_mondo_tail = val;
 492         break;
 493       case MISCREG_QUEUE_DEV_MONDO_HEAD:
 494         dev_mondo_head = val;
 495         break;
 496       case MISCREG_QUEUE_DEV_MONDO_TAIL:
 497         dev_mondo_tail = val;
 498         break;
 499       case MISCREG_QUEUE_RES_ERROR_HEAD:
 500         res_error_head = val;
 501         break;
 502       case MISCREG_QUEUE_RES_ERROR_TAIL:
 503         res_error_tail = val;
 504         break;
 505       case MISCREG_QUEUE_NRES_ERROR_HEAD:
 506         nres_error_head = val;
 507         break;
 508       case MISCREG_QUEUE_NRES_ERROR_TAIL:
 509         nres_error_tail = val;
 510         break;
 511       default:
 512         panic("Miscellaneous register %d not implemented\n", miscReg);
 513     }
 514 }
 515
 516 void MiscRegFile::setReg(int miscReg,
 517         const MiscReg &val, ThreadContext * tc)
 518 {
 519     MiscReg new_val = val;
 520
 521     switch (miscReg) {
 522       case MISCREG_STICK:
 523       case MISCREG_TICK:
 524         // stick and tick are same thing on niagra
 525         // use stick for offset and tick for holding intrrupt bit
 526         stick = mbits(val,62,0) - tc->getCpuPtr()->instCount();
 527         tick = mbits(val,63,63);
 528         DPRINTF(Timer, "Writing TICK=%#X\n", val);
 529         break;
 530       case MISCREG_FPRS:
 531         //Configure the fpu based on the fprs
 532         break;
 533       case MISCREG_PCR:
 534         //Set up performance counting based on pcr value
 535         break;
 536       case MISCREG_PSTATE:
 537         pstate = val & PSTATE_MASK;
 538         return;
 539       case MISCREG_TL:
 540         tl = val;
 541 #if FULL_SYSTEM
 542         if (hpstate & HPSTATE::tlz && tl == 0 && !(hpstate & HPSTATE::hpriv))
 543             tc->getCpuPtr()->post_interrupt(IT_TRAP_LEVEL_ZERO,0);
 544         else
 545             tc->getCpuPtr()->clear_interrupt(IT_TRAP_LEVEL_ZERO,0);
 546 #endif
 547         return;
 548       case MISCREG_CWP:
 549         new_val = val >= NWindows ? NWindows - 1 : val;
 550         if (val >= NWindows)
 551             new_val = NWindows - 1;
 552
 553         tc->changeRegFileContext(CONTEXT_CWP, new_val);
 554         break;
 555       case MISCREG_GL:
 556         tc->changeRegFileContext(CONTEXT_GLOBALS, val);
 557         break;
 558       case MISCREG_PIL:
 559       case MISCREG_SOFTINT:
 560       case MISCREG_SOFTINT_SET:
 561       case MISCREG_SOFTINT_CLR:
 562       case MISCREG_TICK_CMPR:
 563       case MISCREG_STICK_CMPR:
 564       case MISCREG_HINTP:
 565       case MISCREG_HTSTATE:
 566       case MISCREG_HTBA:
 567       case MISCREG_HVER:
 568       case MISCREG_STRAND_STS_REG:
 569       case MISCREG_HSTICK_CMPR:
 570       case MISCREG_QUEUE_CPU_MONDO_HEAD:
 571       case MISCREG_QUEUE_CPU_MONDO_TAIL:
 572       case MISCREG_QUEUE_DEV_MONDO_HEAD:
 573       case MISCREG_QUEUE_DEV_MONDO_TAIL:
 574       case MISCREG_QUEUE_RES_ERROR_HEAD:
 575       case MISCREG_QUEUE_RES_ERROR_TAIL:
 576       case MISCREG_QUEUE_NRES_ERROR_HEAD:
 577       case MISCREG_QUEUE_NRES_ERROR_TAIL:
 578 #if FULL_SYSTEM
 579       case MISCREG_HPSTATE:
 580         setFSReg(miscReg, val, tc);
 581         return;
 582 #else
 583       case MISCREG_HPSTATE:
 584         //HPSTATE is special because normal trap processing saves HPSTATE when
 585         //it goes into a trap, and restores it when it returns.
 586         return;
 587       panic("Accessing Fullsystem register %s to %#x in SE mode\n", getMiscRegName(miscReg), val);
 588 #endif
 589     }
 590     setRegNoEffect(miscReg, new_val);
 591 }
 592
 593 void MiscRegFile::serialize(std::ostream & os)
 594 {
 595     SERIALIZE_SCALAR(asi);
 596     SERIALIZE_SCALAR(tick);
 597     SERIALIZE_SCALAR(fprs);
 598     SERIALIZE_SCALAR(gsr);
 599     SERIALIZE_SCALAR(softint);
 600     SERIALIZE_SCALAR(tick_cmpr);
 601     SERIALIZE_SCALAR(stick);
 602     SERIALIZE_SCALAR(stick_cmpr);
 603     SERIALIZE_ARRAY(tpc,MaxTL);
 604     SERIALIZE_ARRAY(tnpc,MaxTL);
 605     SERIALIZE_ARRAY(tstate,MaxTL);
 606     SERIALIZE_ARRAY(tt,MaxTL);
 607     SERIALIZE_SCALAR(tba);
 608     SERIALIZE_SCALAR(pstate);
 609     SERIALIZE_SCALAR(tl);
 610     SERIALIZE_SCALAR(pil);
 611     SERIALIZE_SCALAR(cwp);
 612     SERIALIZE_SCALAR(gl);
 613     SERIALIZE_SCALAR(hpstate);
 614     SERIALIZE_ARRAY(htstate,MaxTL);
 615     SERIALIZE_SCALAR(hintp);
 616     SERIALIZE_SCALAR(htba);
 617     SERIALIZE_SCALAR(hstick_cmpr);
 618     SERIALIZE_SCALAR(strandStatusReg);
 619     SERIALIZE_SCALAR(fsr);
 620     SERIALIZE_SCALAR(priContext);
 621     SERIALIZE_SCALAR(secContext);
 622     SERIALIZE_SCALAR(partId);
 623     SERIALIZE_SCALAR(lsuCtrlReg);
 624     SERIALIZE_ARRAY(scratchPad,8);
 625     SERIALIZE_SCALAR(cpu_mondo_head);
 626     SERIALIZE_SCALAR(cpu_mondo_tail);
 627     SERIALIZE_SCALAR(dev_mondo_head);
 628     SERIALIZE_SCALAR(dev_mondo_tail);
 629     SERIALIZE_SCALAR(res_error_head);
 630     SERIALIZE_SCALAR(res_error_tail);
 631     SERIALIZE_SCALAR(nres_error_head);
 632     SERIALIZE_SCALAR(nres_error_tail);
 633 #if FULL_SYSTEM
 634     Tick tick_cmp = 0, stick_cmp = 0, hstick_cmp = 0;
 635     ThreadContext *tc = NULL;
 636     BaseCPU *cpu = NULL;
 637     int tc_num = 0;
 638     bool tick_intr_sched = true;
 639
 640     if (tickCompare)
 641         tc = tickCompare->getTC();
 642     else if (sTickCompare)
 643         tc = sTickCompare->getTC();
 644     else if (hSTickCompare)
 645         tc = hSTickCompare->getTC();
 646     else
 647         tick_intr_sched = false;
 648
 649     SERIALIZE_SCALAR(tick_intr_sched);
 650
 651     if (tc) {
 652         cpu = tc->getCpuPtr();
 653         tc_num = cpu->findContext(tc);
 654         if (tickCompare && tickCompare->scheduled())
 655             tick_cmp = tickCompare->when();
 656         if (sTickCompare && sTickCompare->scheduled())
 657             stick_cmp = sTickCompare->when();
 658         if (hSTickCompare && hSTickCompare->scheduled())
 659             hstick_cmp = hSTickCompare->when();
 660
 661         SERIALIZE_OBJPTR(cpu);
 662         SERIALIZE_SCALAR(tc_num);
 663         SERIALIZE_SCALAR(tick_cmp);
 664         SERIALIZE_SCALAR(stick_cmp);
 665         SERIALIZE_SCALAR(hstick_cmp);
 666     }
 667 #endif
 668 }
 669
 670 void MiscRegFile::unserialize(Checkpoint * cp, const std::string & section)
 671 {
 672     UNSERIALIZE_SCALAR(asi);
 673     UNSERIALIZE_SCALAR(tick);
 674     UNSERIALIZE_SCALAR(fprs);
 675     UNSERIALIZE_SCALAR(gsr);
 676     UNSERIALIZE_SCALAR(softint);
 677     UNSERIALIZE_SCALAR(tick_cmpr);
 678     UNSERIALIZE_SCALAR(stick);
 679     UNSERIALIZE_SCALAR(stick_cmpr);
 680     UNSERIALIZE_ARRAY(tpc,MaxTL);
 681     UNSERIALIZE_ARRAY(tnpc,MaxTL);
 682     UNSERIALIZE_ARRAY(tstate,MaxTL);
 683     UNSERIALIZE_ARRAY(tt,MaxTL);
 684     UNSERIALIZE_SCALAR(tba);
 685     UNSERIALIZE_SCALAR(pstate);
 686     UNSERIALIZE_SCALAR(tl);
 687     UNSERIALIZE_SCALAR(pil);
 688     UNSERIALIZE_SCALAR(cwp);
 689     UNSERIALIZE_SCALAR(gl);
 690     UNSERIALIZE_SCALAR(hpstate);
 691     UNSERIALIZE_ARRAY(htstate,MaxTL);
 692     UNSERIALIZE_SCALAR(hintp);
 693     UNSERIALIZE_SCALAR(htba);
 694     UNSERIALIZE_SCALAR(hstick_cmpr);
 695     UNSERIALIZE_SCALAR(strandStatusReg);
 696     UNSERIALIZE_SCALAR(fsr);
 697     UNSERIALIZE_SCALAR(priContext);
 698     UNSERIALIZE_SCALAR(secContext);
 699     UNSERIALIZE_SCALAR(partId);
 700     UNSERIALIZE_SCALAR(lsuCtrlReg);
 701     UNSERIALIZE_ARRAY(scratchPad,8);
 702     UNSERIALIZE_SCALAR(cpu_mondo_head);
 703     UNSERIALIZE_SCALAR(cpu_mondo_tail);
 704     UNSERIALIZE_SCALAR(dev_mondo_head);
 705     UNSERIALIZE_SCALAR(dev_mondo_tail);
 706     UNSERIALIZE_SCALAR(res_error_head);
 707     UNSERIALIZE_SCALAR(res_error_tail);
 708     UNSERIALIZE_SCALAR(nres_error_head);
 709     UNSERIALIZE_SCALAR(nres_error_tail);
 710
 711 #if FULL_SYSTEM
 712     Tick tick_cmp = 0, stick_cmp = 0, hstick_cmp = 0;
 713     ThreadContext *tc = NULL;
 714     BaseCPU *cpu = NULL;
 715     int tc_num;
 716     bool tick_intr_sched;
 717     UNSERIALIZE_SCALAR(tick_intr_sched);
 718     if (tick_intr_sched) {
 719         UNSERIALIZE_OBJPTR(cpu);
 720         if (cpu) {
 721             UNSERIALIZE_SCALAR(tc_num);
 722             UNSERIALIZE_SCALAR(tick_cmp);
 723             UNSERIALIZE_SCALAR(stick_cmp);
 724             UNSERIALIZE_SCALAR(hstick_cmp);
 725             tc = cpu->getContext(tc_num);
 726
 727             if (tick_cmp) {
 728                 tickCompare = new TickCompareEvent(this, tc);
 729                 tickCompare->schedule(tick_cmp);
 730             }
 731             if (stick_cmp)  {
 732                 sTickCompare = new STickCompareEvent(this, tc);
 733                 sTickCompare->schedule(stick_cmp);
 734             }
 735             if (hstick_cmp)  {
 736                 hSTickCompare = new HSTickCompareEvent(this, tc);
 737                 hSTickCompare->schedule(hstick_cmp);
 738             }
 739         }
 740     }
 741
 742  #endif
 743 }