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