src/arch/mips/faults.hh

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