src/arch/mips/faults.hh

   1 /*
   2  * Copyright (c) 2007 MIPS Technologies, Inc.
   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  *          Korey Sewell
  30  *          Jaidev Patwardhan
  31  */
  32
  33 #ifndef __MIPS_FAULTS_HH__
  34 #define __MIPS_FAULTS_HH__
  35
  36 #include "sim/faults.hh"
  37
  38 // The design of the "name" and "vect" functions is in sim/faults.hh
  39
  40 namespace MipsISA
  41 {
  42 typedef const Addr FaultVect;
  43
  44 class MipsFault : public FaultBase
  45 {
  46   protected:
  47     virtual bool skipFaultingInstruction() {return false;}
  48     virtual bool setRestartAddress() {return true;}
  49   public:
  50     Addr BadVAddr;
  51     Addr EntryHi_Asid;
  52     Addr EntryHi_VPN2;
  53     Addr EntryHi_VPN2X;
  54     Addr Context_BadVPN2;
  55 #if FULL_SYSTEM
  56   void invoke(ThreadContext * tc) {};
  57   void setExceptionState(ThreadContext *,uint8_t);
  58   void setHandlerPC(Addr,ThreadContext *);
  59 #endif
  60     virtual FaultVect vect() = 0;
  61     virtual FaultStat & countStat() = 0;
  62 };
  63
  64 class MachineCheckFault : public MipsFault
  65 {
  66   private:
  67     static FaultName _name;
  68     static FaultVect _vect;
  69     static FaultStat _count;
  70   public:
  71     FaultName name() const {return _name;}
  72     FaultVect vect() {return _vect;}
  73     FaultStat & countStat() {return _count;}
  74     bool isMachineCheckFault() {return true;}
  75 };
  76
  77 class NonMaskableInterrupt : public MipsFault
  78 {
  79   private:
  80     static FaultName _name;
  81     static FaultVect _vect;
  82     static FaultStat _count;
  83   public:
  84     FaultName name() const {return _name;}
  85     FaultVect vect() {return _vect;}
  86     FaultStat & countStat() {return _count;}
  87     bool isNonMaskableInterrupt() {return true;}
  88 };
  89
  90 class AlignmentFault : public MipsFault
  91 {
  92   private:
  93     static FaultName _name;
  94     static FaultVect _vect;
  95     static FaultStat _count;
  96   public:
  97     FaultName name() const {return _name;}
  98     FaultVect vect() {return _vect;}
  99     FaultStat & countStat() {return _count;}
 100     bool isAlignmentFault() {return true;}
 101 };
 102
 103 class AddressErrorFault : public MipsFault
 104 {
 105   private:
 106     static FaultName _name;
 107     static FaultVect _vect;
 108     static FaultStat _count;
 109   public:
 110     FaultName name() const {return _name;}
 111     FaultVect vect() {return _vect;}
 112     FaultStat & countStat() {return _count;}
 113 #if FULL_SYSTEM
 114     void invoke(ThreadContext * tc);
 115 #endif
 116
 117 };
 118 class StoreAddressErrorFault : public MipsFault
 119 {
 120   private:
 121     static FaultName _name;
 122     static FaultVect _vect;
 123     static FaultStat _count;
 124   public:
 125     FaultName name() const {return _name;}
 126     FaultVect vect() {return _vect;}
 127     FaultStat & countStat() {return _count;}
 128 #if FULL_SYSTEM
 129     void invoke(ThreadContext * tc);
 130 #endif
 131
 132 };
 133 class UnimplementedOpcodeFault : public MipsFault
 134 {
 135   private:
 136     static FaultName _name;
 137     static FaultVect _vect;
 138     static FaultStat _count;
 139   public:
 140     FaultName name() const {return _name;}
 141     FaultVect vect() {return _vect;}
 142     FaultStat & countStat() {return _count;}
 143 };
 144
 145
 146 class TLBRefillIFetchFault : public MipsFault
 147 {
 148   private:
 149     Addr vaddr;
 150     static FaultName _name;
 151     static FaultVect _vect;
 152     static FaultStat _count;
 153   public:
 154     FaultName name() const {return _name;}
 155     FaultVect vect() {return _vect;}
 156     FaultStat & countStat() {return _count;}
 157     void invoke(ThreadContext * tc);
 158 };
 159 class TLBInvalidIFetchFault : public MipsFault
 160 {
 161   private:
 162     Addr vaddr;
 163     static FaultName _name;
 164     static FaultVect _vect;
 165     static FaultStat _count;
 166   public:
 167     FaultName name() const {return _name;}
 168     FaultVect vect() {return _vect;}
 169     FaultStat & countStat() {return _count;}
 170     void invoke(ThreadContext * tc);
 171 };
 172
 173 class NDtbMissFault : public MipsFault
 174 {
 175   private:
 176     static FaultName _name;
 177     static FaultVect _vect;
 178     static FaultStat _count;
 179   public:
 180     FaultName name() const {return _name;}
 181     FaultVect vect() {return _vect;}
 182     FaultStat & countStat() {return _count;}
 183 };
 184
 185 class PDtbMissFault : public MipsFault
 186 {
 187   private:
 188     static FaultName _name;
 189     static FaultVect _vect;
 190     static FaultStat _count;
 191   public:
 192     FaultName name() const {return _name;}
 193     FaultVect vect() {return _vect;}
 194     FaultStat & countStat() {return _count;}
 195 };
 196
 197 class DtbPageFault : public MipsFault
 198 {
 199   private:
 200     static FaultName _name;
 201     static FaultVect _vect;
 202     static FaultStat _count;
 203   public:
 204     FaultName name() const {return _name;}
 205     FaultVect vect() {return _vect;}
 206     FaultStat & countStat() {return _count;}
 207 };
 208
 209 class DtbAcvFault : public MipsFault
 210 {
 211   private:
 212     static FaultName _name;
 213     static FaultVect _vect;
 214     static FaultStat _count;
 215   public:
 216     FaultName name() const {return _name;}
 217     FaultVect vect() {return _vect;}
 218     FaultStat & countStat() {return _count;}
 219 };
 220
 221 class CacheErrorFault : public MipsFault
 222 {
 223   private:
 224     Addr vaddr;
 225     static FaultName _name;
 226     static FaultVect _vect;
 227     static FaultStat _count;
 228   public:
 229     FaultName name() const {return _name;}
 230     FaultVect vect() {return _vect;}
 231     FaultStat & countStat() {return _count;}
 232     void invoke(ThreadContext * tc);
 233 };
 234
 235
 236
 237
 238 static inline Fault genMachineCheckFault()
 239 {
 240     return new MachineCheckFault;
 241 }
 242
 243 static inline Fault genAlignmentFault()
 244 {
 245     return new AlignmentFault;
 246 }
 247
 248 class ResetFault : public MipsFault
 249 {
 250   private:
 251     static FaultName _name;
 252     static FaultVect _vect;
 253     static FaultStat _count;
 254   public:
 255     FaultName name() const {return _name;}
 256     FaultVect vect() {return _vect;}
 257     FaultStat & countStat() {return _count;}
 258     void invoke(ThreadContext * tc);
 259
 260 };
 261 class SystemCallFault : public MipsFault
 262 {
 263   private:
 264     static FaultName _name;
 265     static FaultVect _vect;
 266     static FaultStat _count;
 267   public:
 268     FaultName name() const {return _name;}
 269     FaultVect vect() {return _vect;}
 270     FaultStat & countStat() {return _count;}
 271     void invoke(ThreadContext * tc);
 272 };
 273
 274 class SoftResetFault : public MipsFault
 275 {
 276   private:
 277     static FaultName _name;
 278     static FaultVect _vect;
 279     static FaultStat _count;
 280   public:
 281     FaultName name() const {return _name;}
 282     FaultVect vect() {return _vect;}
 283     FaultStat & countStat() {return _count;}
 284     void invoke(ThreadContext * tc);
 285 };
 286 class DebugSingleStep : public MipsFault
 287 {
 288   private:
 289     static FaultName _name;
 290     static FaultVect _vect;
 291     static FaultStat _count;
 292   public:
 293     FaultName name() const {return _name;}
 294     FaultVect vect() {return _vect;}
 295     FaultStat & countStat() {return _count;}
 296     void invoke(ThreadContext * tc);
 297 };
 298 class DebugInterrupt : public MipsFault
 299 {
 300   private:
 301     static FaultName _name;
 302     static FaultVect _vect;
 303     static FaultStat _count;
 304   public:
 305     FaultName name() const {return _name;}
 306     FaultVect vect() {return _vect;}
 307     FaultStat & countStat() {return _count;}
 308     void invoke(ThreadContext * tc);
 309 };
 310
 311 class CoprocessorUnusableFault : public MipsFault
 312 {
 313   private:
 314     static FaultName _name;
 315     static FaultVect _vect;
 316     static FaultStat _count;
 317     int coProcID;
 318   public:
 319     FaultName name() const {return _name;}
 320     FaultVect vect() {return _vect;}
 321     FaultStat & countStat() {return _count;}
 322     void invoke(ThreadContext * tc);
 323     CoprocessorUnusableFault(int _procid){ coProcID = _procid;}
 324 };
 325
 326 class ReservedInstructionFault : public MipsFault
 327 {
 328   private:
 329     static FaultName _name;
 330     static FaultVect _vect;
 331     static FaultStat _count;
 332   public:
 333     FaultName name() const {return _name;}
 334     FaultVect vect() {return _vect;}
 335     FaultStat & countStat() {return _count;}
 336     void invoke(ThreadContext * tc);
 337 };
 338
 339 class ThreadFault : public MipsFault
 340 {
 341   private:
 342     static FaultName _name;
 343     static FaultVect _vect;
 344     static FaultStat _count;
 345   public:
 346     FaultName name() const {return _name;}
 347     FaultVect vect() {return _vect;}
 348     FaultStat & countStat() {return _count;}
 349     void invoke(ThreadContext * tc);
 350 };
 351
 352
 353 class ArithmeticFault : public MipsFault
 354 {
 355   protected:
 356     bool skipFaultingInstruction() {return true;}
 357   private:
 358     static FaultName _name;
 359     static FaultVect _vect;
 360     static FaultStat _count;
 361   public:
 362     FaultName name() const {return _name;}
 363     FaultVect vect() {return _vect;}
 364     FaultStat & countStat() {return _count;}
 365 #if FULL_SYSTEM
 366     void invoke(ThreadContext * tc);
 367 #endif
 368 };
 369
 370 class InterruptFault : public MipsFault
 371 {
 372   protected:
 373     bool setRestartAddress() {return false;}
 374   private:
 375     static FaultName _name;
 376     static FaultVect _vect;
 377     static FaultStat _count;
 378   public:
 379     FaultName name() const {return _name;}
 380     FaultVect vect() {return _vect;}
 381     FaultStat & countStat() {return _count;}
 382
 383 #if FULL_SYSTEM
 384     void invoke(ThreadContext * tc);
 385 #endif
 386
 387     //void invoke(ThreadContext * tc);
 388 };
 389
 390 class TrapFault : public MipsFault
 391 {
 392   private:
 393     static FaultName _name;
 394     static FaultVect _vect;
 395     static FaultStat _count;
 396   public:
 397     FaultName name() const {return _name;}
 398     FaultVect vect() {return _vect;}
 399     FaultStat & countStat() {return _count;}
 400 #if FULL_SYSTEM
 401     void invoke(ThreadContext * tc);
 402 #endif
 403 };
 404
 405 class BreakpointFault : public MipsFault
 406 {
 407   private:
 408     static FaultName _name;
 409     static FaultVect _vect;
 410     static FaultStat _count;
 411   public:
 412     FaultName name() const {return _name;}
 413     FaultVect vect() {return _vect;}
 414     FaultStat & countStat() {return _count;}
 415 #if FULL_SYSTEM
 416     void invoke(ThreadContext * tc);
 417 #endif
 418 };
 419
 420 class ItbRefillFault : public MipsFault
 421 {
 422   private:
 423     static FaultName _name;
 424     static FaultVect _vect;
 425     static FaultStat _count;
 426   public:
 427     FaultName name() const {return _name;}
 428     FaultVect vect() {return _vect;}
 429     FaultStat & countStat() {return _count;}
 430 #if FULL_SYSTEM
 431     void invoke(ThreadContext * tc);
 432 #endif
 433 };
 434 class DtbRefillFault : public MipsFault
 435 {
 436   private:
 437     static FaultName _name;
 438     static FaultVect _vect;
 439     static FaultStat _count;
 440   public:
 441     FaultName name() const {return _name;}
 442     FaultVect vect() {return _vect;}
 443     FaultStat & countStat() {return _count;}
 444 #if FULL_SYSTEM
 445     void invoke(ThreadContext * tc);
 446 #endif
 447 };
 448
 449 class ItbPageFault : public MipsFault
 450 {
 451   private:
 452     static FaultName _name;
 453     static FaultVect _vect;
 454     static FaultStat _count;
 455   public:
 456     FaultName name() const {return _name;}
 457     FaultVect vect() {return _vect;}
 458     FaultStat & countStat() {return _count;}
 459 #if FULL_SYSTEM
 460     void invoke(ThreadContext * tc);
 461 #endif
 462 };
 463
 464 class ItbInvalidFault : public MipsFault
 465 {
 466   private:
 467     static FaultName _name;
 468     static FaultVect _vect;
 469     static FaultStat _count;
 470   public:
 471     FaultName name() const {return _name;}
 472     FaultVect vect() {return _vect;}
 473     FaultStat & countStat() {return _count;}
 474 #if FULL_SYSTEM
 475     void invoke(ThreadContext * tc);
 476 #endif
 477
 478 };
 479 class TLBModifiedFault : public MipsFault
 480 {
 481   private:
 482     static FaultName _name;
 483     static FaultVect _vect;
 484     static FaultStat _count;
 485   public:
 486     FaultName name() const {return _name;}
 487     FaultVect vect() {return _vect;}
 488     FaultStat & countStat() {return _count;}
 489 #if FULL_SYSTEM
 490     void invoke(ThreadContext * tc);
 491 #endif
 492
 493 };
 494
 495 class DtbInvalidFault : public MipsFault
 496 {
 497   private:
 498     static FaultName _name;
 499     static FaultVect _vect;
 500     static FaultStat _count;
 501   public:
 502     FaultName name() const {return _name;}
 503     FaultVect vect() {return _vect;}
 504     FaultStat & countStat() {return _count;}
 505 #if FULL_SYSTEM
 506     void invoke(ThreadContext * tc);
 507 #endif
 508
 509 };
 510
 511 class FloatEnableFault : public MipsFault
 512 {
 513   private:
 514     static FaultName _name;
 515     static FaultVect _vect;
 516     static FaultStat _count;
 517   public:
 518     FaultName name() const {return _name;}
 519     FaultVect vect() {return _vect;}
 520     FaultStat & countStat() {return _count;}
 521 };
 522
 523 class ItbMissFault : public MipsFault
 524 {
 525   private:
 526     static FaultName _name;
 527     static FaultVect _vect;
 528     static FaultStat _count;
 529   public:
 530     FaultName name() const {return _name;}
 531     FaultVect vect() {return _vect;}
 532     FaultStat & countStat() {return _count;}
 533 };
 534
 535 class ItbAcvFault : public MipsFault
 536 {
 537   private:
 538     static FaultName _name;
 539     static FaultVect _vect;
 540     static FaultStat _count;
 541   public:
 542     FaultName name() const {return _name;}
 543     FaultVect vect() {return _vect;}
 544     FaultStat & countStat() {return _count;}
 545 };
 546
 547 class IntegerOverflowFault : public MipsFault
 548 {
 549   private:
 550     static FaultName _name;
 551     static FaultVect _vect;
 552     static FaultStat _count;
 553   public:
 554     FaultName name() const {return _name;}
 555     FaultVect vect() {return _vect;}
 556     FaultStat & countStat() {return _count;}
 557 };
 558
 559 class DspStateDisabledFault : public MipsFault
 560 {
 561   private:
 562     static FaultName _name;
 563     static FaultVect _vect;
 564     static FaultStat _count;
 565   public:
 566     FaultName name() const {return _name;}
 567     FaultVect vect() {return _vect;}
 568     FaultStat & countStat() {return _count;}
 569     void invoke(ThreadContext * tc);
 570 };
 571
 572 } // MipsISA namespace
 573
 574 #endif // __MIPS_FAULTS_HH__