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 namespace MipsISA
  40 {
  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 entryHiAsid;
  52     Addr entryHiVPN2;
  53     Addr entryHiVPN2X;
  54     Addr contextBadVPN2;
  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
 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
 161 class TLBInvalidIFetchFault : public MipsFault
 162 {
 163   private:
 164     Addr vaddr;
 165     static FaultName _name;
 166     static FaultVect _vect;
 167     static FaultStat _count;
 168   public:
 169     FaultName name() const {return _name;}
 170     FaultVect vect() {return _vect;}
 171     FaultStat & countStat() {return _count;}
 172     void invoke(ThreadContext * tc);
 173 };
 174
 175 class NDtbMissFault : public MipsFault
 176 {
 177   private:
 178     static FaultName _name;
 179     static FaultVect _vect;
 180     static FaultStat _count;
 181   public:
 182     FaultName name() const {return _name;}
 183     FaultVect vect() {return _vect;}
 184     FaultStat & countStat() {return _count;}
 185 };
 186
 187 class PDtbMissFault : public MipsFault
 188 {
 189   private:
 190     static FaultName _name;
 191     static FaultVect _vect;
 192     static FaultStat _count;
 193   public:
 194     FaultName name() const {return _name;}
 195     FaultVect vect() {return _vect;}
 196     FaultStat & countStat() {return _count;}
 197 };
 198
 199 class DtbPageFault : public MipsFault
 200 {
 201   private:
 202     static FaultName _name;
 203     static FaultVect _vect;
 204     static FaultStat _count;
 205   public:
 206     FaultName name() const {return _name;}
 207     FaultVect vect() {return _vect;}
 208     FaultStat & countStat() {return _count;}
 209 };
 210
 211 class DtbAcvFault : public MipsFault
 212 {
 213   private:
 214     static FaultName _name;
 215     static FaultVect _vect;
 216     static FaultStat _count;
 217   public:
 218     FaultName name() const {return _name;}
 219     FaultVect vect() {return _vect;}
 220     FaultStat & countStat() {return _count;}
 221 };
 222
 223 class CacheErrorFault : public MipsFault
 224 {
 225   private:
 226     Addr vaddr;
 227     static FaultName _name;
 228     static FaultVect _vect;
 229     static FaultStat _count;
 230   public:
 231     FaultName name() const {return _name;}
 232     FaultVect vect() {return _vect;}
 233     FaultStat & countStat() {return _count;}
 234     void invoke(ThreadContext * tc);
 235 };
 236
 237
 238
 239
 240 static inline Fault genMachineCheckFault()
 241 {
 242     return new MachineCheckFault;
 243 }
 244
 245 static inline Fault genAlignmentFault()
 246 {
 247     return new AlignmentFault;
 248 }
 249
 250 class ResetFault : public MipsFault
 251 {
 252   private:
 253     static FaultName _name;
 254     static FaultVect _vect;
 255     static FaultStat _count;
 256   public:
 257     FaultName name() const {return _name;}
 258     FaultVect vect() {return _vect;}
 259     FaultStat & countStat() {return _count;}
 260     void invoke(ThreadContext * tc);
 261
 262 };
 263
 264 class SystemCallFault : public MipsFault
 265 {
 266   private:
 267     static FaultName _name;
 268     static FaultVect _vect;
 269     static FaultStat _count;
 270   public:
 271     FaultName name() const {return _name;}
 272     FaultVect vect() {return _vect;}
 273     FaultStat & countStat() {return _count;}
 274     void invoke(ThreadContext * tc);
 275 };
 276
 277 class SoftResetFault : public MipsFault
 278 {
 279   private:
 280     static FaultName _name;
 281     static FaultVect _vect;
 282     static FaultStat _count;
 283   public:
 284     FaultName name() const {return _name;}
 285     FaultVect vect() {return _vect;}
 286     FaultStat & countStat() {return _count;}
 287     void invoke(ThreadContext * tc);
 288 };
 289
 290 class DebugSingleStep : public MipsFault
 291 {
 292   private:
 293     static FaultName _name;
 294     static FaultVect _vect;
 295     static FaultStat _count;
 296   public:
 297     FaultName name() const {return _name;}
 298     FaultVect vect() {return _vect;}
 299     FaultStat & countStat() {return _count;}
 300     void invoke(ThreadContext * tc);
 301 };
 302
 303 class DebugInterrupt : public MipsFault
 304 {
 305   private:
 306     static FaultName _name;
 307     static FaultVect _vect;
 308     static FaultStat _count;
 309   public:
 310     FaultName name() const {return _name;}
 311     FaultVect vect() {return _vect;}
 312     FaultStat & countStat() {return _count;}
 313     void invoke(ThreadContext * tc);
 314 };
 315
 316 class CoprocessorUnusableFault : public MipsFault
 317 {
 318   private:
 319     static FaultName _name;
 320     static FaultVect _vect;
 321     static FaultStat _count;
 322     int coProcID;
 323   public:
 324     FaultName name() const {return _name;}
 325     FaultVect vect() {return _vect;}
 326     FaultStat & countStat() {return _count;}
 327     void invoke(ThreadContext * tc);
 328     CoprocessorUnusableFault(int _procid){ coProcID = _procid;}
 329 };
 330
 331 class ReservedInstructionFault : public MipsFault
 332 {
 333   private:
 334     static FaultName _name;
 335     static FaultVect _vect;
 336     static FaultStat _count;
 337   public:
 338     FaultName name() const {return _name;}
 339     FaultVect vect() {return _vect;}
 340     FaultStat & countStat() {return _count;}
 341     void invoke(ThreadContext * tc);
 342 };
 343
 344 class ThreadFault : public MipsFault
 345 {
 346   private:
 347     static FaultName _name;
 348     static FaultVect _vect;
 349     static FaultStat _count;
 350   public:
 351     FaultName name() const {return _name;}
 352     FaultVect vect() {return _vect;}
 353     FaultStat & countStat() {return _count;}
 354     void invoke(ThreadContext * tc);
 355 };
 356
 357 class ArithmeticFault : public MipsFault
 358 {
 359   protected:
 360     bool skipFaultingInstruction() {return true;}
 361   private:
 362     static FaultName _name;
 363     static FaultVect _vect;
 364     static FaultStat _count;
 365   public:
 366     FaultName name() const {return _name;}
 367     FaultVect vect() {return _vect;}
 368     FaultStat & countStat() {return _count;}
 369 #if FULL_SYSTEM
 370     void invoke(ThreadContext * tc);
 371 #endif
 372 };
 373
 374 class InterruptFault : public MipsFault
 375 {
 376   protected:
 377     bool setRestartAddress() {return false;}
 378   private:
 379     static FaultName _name;
 380     static FaultVect _vect;
 381     static FaultStat _count;
 382   public:
 383     FaultName name() const {return _name;}
 384     FaultVect vect() {return _vect;}
 385     FaultStat & countStat() {return _count;}
 386
 387 #if FULL_SYSTEM
 388     void invoke(ThreadContext * tc);
 389 #endif
 390 };
 391
 392 class TrapFault : public MipsFault
 393 {
 394   private:
 395     static FaultName _name;
 396     static FaultVect _vect;
 397     static FaultStat _count;
 398   public:
 399     FaultName name() const {return _name;}
 400     FaultVect vect() {return _vect;}
 401     FaultStat & countStat() {return _count;}
 402 #if FULL_SYSTEM
 403     void invoke(ThreadContext * tc);
 404 #endif
 405 };
 406
 407 class BreakpointFault : public MipsFault
 408 {
 409   private:
 410     static FaultName _name;
 411     static FaultVect _vect;
 412     static FaultStat _count;
 413   public:
 414     FaultName name() const {return _name;}
 415     FaultVect vect() {return _vect;}
 416     FaultStat & countStat() {return _count;}
 417 #if FULL_SYSTEM
 418     void invoke(ThreadContext * tc);
 419 #endif
 420 };
 421
 422 class ItbRefillFault : public MipsFault
 423 {
 424   private:
 425     static FaultName _name;
 426     static FaultVect _vect;
 427     static FaultStat _count;
 428   public:
 429     FaultName name() const {return _name;}
 430     FaultVect vect() {return _vect;}
 431     FaultStat & countStat() {return _count;}
 432 #if FULL_SYSTEM
 433     void invoke(ThreadContext * tc);
 434 #endif
 435 };
 436
 437 class DtbRefillFault : public MipsFault
 438 {
 439   private:
 440     static FaultName _name;
 441     static FaultVect _vect;
 442     static FaultStat _count;
 443   public:
 444     FaultName name() const {return _name;}
 445     FaultVect vect() {return _vect;}
 446     FaultStat & countStat() {return _count;}
 447 #if FULL_SYSTEM
 448     void invoke(ThreadContext * tc);
 449 #endif
 450 };
 451
 452 class ItbPageFault : public MipsFault
 453 {
 454   private:
 455     static FaultName _name;
 456     static FaultVect _vect;
 457     static FaultStat _count;
 458   public:
 459     FaultName name() const {return _name;}
 460     FaultVect vect() {return _vect;}
 461     FaultStat & countStat() {return _count;}
 462 #if FULL_SYSTEM
 463     void invoke(ThreadContext * tc);
 464 #endif
 465 };
 466
 467 class ItbInvalidFault : public MipsFault
 468 {
 469   private:
 470     static FaultName _name;
 471     static FaultVect _vect;
 472     static FaultStat _count;
 473   public:
 474     FaultName name() const {return _name;}
 475     FaultVect vect() {return _vect;}
 476     FaultStat & countStat() {return _count;}
 477 #if FULL_SYSTEM
 478     void invoke(ThreadContext * tc);
 479 #endif
 480 };
 481
 482 class TLBModifiedFault : public MipsFault
 483 {
 484   private:
 485     static FaultName _name;
 486     static FaultVect _vect;
 487     static FaultStat _count;
 488   public:
 489     FaultName name() const {return _name;}
 490     FaultVect vect() {return _vect;}
 491     FaultStat & countStat() {return _count;}
 492 #if FULL_SYSTEM
 493     void invoke(ThreadContext * tc);
 494 #endif
 495 };
 496
 497 class DtbInvalidFault : public MipsFault
 498 {
 499   private:
 500     static FaultName _name;
 501     static FaultVect _vect;
 502     static FaultStat _count;
 503   public:
 504     FaultName name() const {return _name;}
 505     FaultVect vect() {return _vect;}
 506     FaultStat & countStat() {return _count;}
 507 #if FULL_SYSTEM
 508     void invoke(ThreadContext * tc);
 509 #endif
 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__