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;}
| 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;}
|
267}; 268 269class SoftResetFault : public MipsFault 270{ 271 private: 272 static FaultName _name; 273 static FaultVect _vect; 274 static FaultStat _count; 275 public: 276 FaultName name() const {return _name;} 277 FaultVect vect() {return _vect;} 278 FaultStat & countStat() {return _count;} 279 void invoke(ThreadContext * tc, 280 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 281}; 282 283class DebugSingleStep : public MipsFault 284{ 285 private: 286 static FaultName _name; 287 static FaultVect _vect; 288 static FaultStat _count; 289 public: 290 FaultName name() const {return _name;} 291 FaultVect vect() {return _vect;} 292 FaultStat & countStat() {return _count;} 293 void invoke(ThreadContext * tc, 294 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 295}; 296 297class DebugInterrupt : public MipsFault 298{ 299 private: 300 static FaultName _name; 301 static FaultVect _vect; 302 static FaultStat _count; 303 public: 304 FaultName name() const {return _name;} 305 FaultVect vect() {return _vect;} 306 FaultStat & countStat() {return _count;} 307 void invoke(ThreadContext * tc, 308 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 309}; 310 311class 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 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 324 CoprocessorUnusableFault(int _procid){ coProcID = _procid;} 325}; 326 327class 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 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 339}; 340 341class ThreadFault : public MipsFault 342{ 343 private: 344 static FaultName _name; 345 static FaultVect _vect; 346 static FaultStat _count; 347 public: 348 FaultName name() const {return _name;} 349 FaultVect vect() {return _vect;} 350 FaultStat & countStat() {return _count;} 351 void invoke(ThreadContext * tc, 352 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 353}; 354 355class ArithmeticFault : public MipsFault 356{ 357 protected: 358 bool skipFaultingInstruction() {return true;} 359 private: 360 static FaultName _name; 361 static FaultVect _vect; 362 static FaultStat _count; 363 public: 364 FaultName name() const {return _name;} 365 FaultVect vect() {return _vect;} 366 FaultStat & countStat() {return _count;} 367#if FULL_SYSTEM 368 void invoke(ThreadContext * tc, 369 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 370#endif 371}; 372 373class InterruptFault : public MipsFault 374{ 375 protected: 376 bool setRestartAddress() {return false;} 377 private: 378 static FaultName _name; 379 static FaultVect _vect; 380 static FaultStat _count; 381 public: 382 FaultName name() const {return _name;} 383 FaultVect vect() {return _vect;} 384 FaultStat & countStat() {return _count;} 385 386#if FULL_SYSTEM 387 void invoke(ThreadContext * tc, 388 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 389#endif 390}; 391 392class 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 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 405#endif 406}; 407 408class BreakpointFault : public MipsFault 409{ 410 private: 411 static FaultName _name; 412 static FaultVect _vect; 413 static FaultStat _count; 414 public: 415 FaultName name() const {return _name;} 416 FaultVect vect() {return _vect;} 417 FaultStat & countStat() {return _count;} 418#if FULL_SYSTEM 419 void invoke(ThreadContext * tc, 420 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 421#endif 422}; 423 424class ItbRefillFault : public MipsFault 425{ 426 private: 427 static FaultName _name; 428 static FaultVect _vect; 429 static FaultStat _count; 430 public: 431 FaultName name() const {return _name;} 432 FaultVect vect() {return _vect;} 433 FaultStat & countStat() {return _count;} 434#if FULL_SYSTEM 435 void invoke(ThreadContext * tc, 436 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 437#endif 438}; 439 440class DtbRefillFault : public MipsFault 441{ 442 private: 443 static FaultName _name; 444 static FaultVect _vect; 445 static FaultStat _count; 446 public: 447 FaultName name() const {return _name;} 448 FaultVect vect() {return _vect;} 449 FaultStat & countStat() {return _count;} 450#if FULL_SYSTEM 451 void invoke(ThreadContext * tc, 452 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 453#endif 454}; 455 456class ItbPageFault : public MipsFault 457{ 458 private: 459 static FaultName _name; 460 static FaultVect _vect; 461 static FaultStat _count; 462 public: 463 FaultName name() const {return _name;} 464 FaultVect vect() {return _vect;} 465 FaultStat & countStat() {return _count;} 466#if FULL_SYSTEM 467 void invoke(ThreadContext * tc, 468 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 469#endif 470}; 471 472class ItbInvalidFault : public MipsFault 473{ 474 private: 475 static FaultName _name; 476 static FaultVect _vect; 477 static FaultStat _count; 478 public: 479 FaultName name() const {return _name;} 480 FaultVect vect() {return _vect;} 481 FaultStat & countStat() {return _count;} 482#if FULL_SYSTEM 483 void invoke(ThreadContext * tc, 484 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 485#endif 486}; 487 488class TLBModifiedFault : public MipsFault 489{ 490 private: 491 static FaultName _name; 492 static FaultVect _vect; 493 static FaultStat _count; 494 public: 495 FaultName name() const {return _name;} 496 FaultVect vect() {return _vect;} 497 FaultStat & countStat() {return _count;} 498#if FULL_SYSTEM 499 void invoke(ThreadContext * tc, 500 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 501#endif 502}; 503 504class DtbInvalidFault : public MipsFault 505{ 506 private: 507 static FaultName _name; 508 static FaultVect _vect; 509 static FaultStat _count; 510 public: 511 FaultName name() const {return _name;} 512 FaultVect vect() {return _vect;} 513 FaultStat & countStat() {return _count;} 514#if FULL_SYSTEM 515 void invoke(ThreadContext * tc, 516 StaticInst::StaticInstPtr inst = nullStaticInstPtr); 517#endif 518}; 519 520class FloatEnableFault : public MipsFault 521{ 522 private: 523 static FaultName _name; 524 static FaultVect _vect; 525 static FaultStat _count; 526 public: 527 FaultName name() const {return _name;} 528 FaultVect vect() {return _vect;} 529 FaultStat & countStat() {return _count;} 530}; 531 532class ItbMissFault : public MipsFault 533{ 534 private: 535 static FaultName _name; 536 static FaultVect _vect; 537 static FaultStat _count; 538 public: 539 FaultName name() const {return _name;} 540 FaultVect vect() {return _vect;} 541 FaultStat & countStat() {return _count;} 542}; 543 544class ItbAcvFault : public MipsFault 545{ 546 private: 547 static FaultName _name; 548 static FaultVect _vect; 549 static FaultStat _count; 550 public: 551 FaultName name() const {return _name;} 552 FaultVect vect() {return _vect;} 553 FaultStat & countStat() {return _count;} 554}; 555 556class IntegerOverflowFault : public MipsFault 557{ 558 private: 559 static FaultName _name; 560 static FaultVect _vect; 561 static FaultStat _count; 562 public: 563 FaultName name() const {return _name;} 564 FaultVect vect() {return _vect;} 565 FaultStat & countStat() {return _count;} 566}; 567 568class DspStateDisabledFault : public MipsFault 569{ 570 private: 571 static FaultName _name; 572 static FaultVect _vect; 573 static FaultStat _count; 574 public: 575 FaultName name() const {return _name;} 576 FaultVect vect() {return _vect;} 577 FaultStat & countStat() {return _count;} 578 void invoke(ThreadContext * tc, 579 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 580}; 581 582} // namespace MipsISA 583 584#endif // __MIPS_FAULTS_HH__
| 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__
|