faults.hh (8563:58cf8f4a7c33) | faults.hh (8566:812d279f7b51) |
---|---|
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 --- 27 unchanged lines hidden (view full) --- 36 37#include "sim/faults.hh" 38 39namespace MipsISA 40{ 41 42typedef const Addr FaultVect; 43 | 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 --- 27 unchanged lines hidden (view full) --- 36 37#include "sim/faults.hh" 38 39namespace MipsISA 40{ 41 42typedef const Addr FaultVect; 43 |
44class MipsFault : public FaultBase | 44class MipsFaultBase : public FaultBase |
45{ 46 protected: 47 virtual bool skipFaultingInstruction() {return false;} 48 virtual bool setRestartAddress() {return true;} 49 public: | 45{ 46 protected: 47 virtual bool skipFaultingInstruction() {return false;} 48 virtual bool setRestartAddress() {return true;} 49 public: |
50 struct FaultVals 51 { 52 const FaultName name; 53 const FaultVect vect; 54 FaultStat count; 55 }; 56 |
|
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 | 57 Addr badVAddr; 58 Addr entryHiAsid; 59 Addr entryHiVPN2; 60 Addr entryHiVPN2X; 61 Addr contextBadVPN2; 62#if FULL_SYSTEM 63 void invoke(ThreadContext * tc, 64 StaticInst::StaticInstPtr inst = StaticInst::nullStaticInstPtr) 65 {} 66 void setExceptionState(ThreadContext *, uint8_t); 67 void setHandlerPC(Addr, ThreadContext *); 68#endif |
62 virtual FaultVect vect() = 0; 63 virtual FaultStat & countStat() = 0; | |
64}; 65 | 69}; 70 |
66class MachineCheckFault : public MipsFault | 71template <typename T> 72class MipsFault : public MipsFaultBase |
67{ | 73{ |
68 private: 69 static FaultName _name; 70 static FaultVect _vect; 71 static FaultStat _count; | 74 protected: 75 static FaultVals vals; |
72 public: | 76 public: |
73 FaultName name() const {return _name;} 74 FaultVect vect() {return _vect;} 75 FaultStat & countStat() {return _count;} | 77 FaultName name() const { return vals.name; } 78 FaultVect vect() const { return vals.vect; } 79 FaultStat & countStat() { return vals.count; } 80}; 81 82class MachineCheckFault : public MipsFault<MachineCheckFault> 83{ 84 public: |
76 bool isMachineCheckFault() {return true;} 77}; 78 | 85 bool isMachineCheckFault() {return true;} 86}; 87 |
79class NonMaskableInterrupt : public MipsFault | 88class NonMaskableInterrupt : public MipsFault<NonMaskableInterrupt> |
80{ | 89{ |
81 private: 82 static FaultName _name; 83 static FaultVect _vect; 84 static FaultStat _count; | |
85 public: | 90 public: |
86 FaultName name() const {return _name;} 87 FaultVect vect() {return _vect;} 88 FaultStat & countStat() {return _count;} | |
89 bool isNonMaskableInterrupt() {return true;} 90}; 91 | 91 bool isNonMaskableInterrupt() {return true;} 92}; 93 |
92class AlignmentFault : public MipsFault | 94class AlignmentFault : public MipsFault<AlignmentFault> |
93{ | 95{ |
94 private: 95 static FaultName _name; 96 static FaultVect _vect; 97 static FaultStat _count; | |
98 public: | 96 public: |
99 FaultName name() const {return _name;} 100 FaultVect vect() {return _vect;} 101 FaultStat & countStat() {return _count;} | |
102 bool isAlignmentFault() {return true;} 103}; 104 | 97 bool isAlignmentFault() {return true;} 98}; 99 |
105class AddressErrorFault : public MipsFault | 100class AddressErrorFault : public MipsFault<AddressErrorFault> |
106{ | 101{ |
107 private: 108 static FaultName _name; 109 static FaultVect _vect; 110 static FaultStat _count; | |
111 public: | 102 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 | 103#if FULL_SYSTEM 104 void invoke(ThreadContext * tc, 105 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 106#endif 107 108}; 109 |
122class StoreAddressErrorFault : public MipsFault | 110class StoreAddressErrorFault : public MipsFault<StoreAddressErrorFault> |
123{ | 111{ |
124 private: 125 static FaultName _name; 126 static FaultVect _vect; 127 static FaultStat _count; | |
128 public: | 112 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 | 113#if FULL_SYSTEM 114 void invoke(ThreadContext * tc, 115 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 116#endif 117}; 118 |
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}; | 119class UnimplementedOpcodeFault : public MipsFault<UnimplementedOpcodeFault> {}; |
149 | 120 |
150 151class TLBRefillIFetchFault : public MipsFault | 121class TLBRefillIFetchFault : public MipsFault<TLBRefillIFetchFault> |
152{ | 122{ |
153 private: 154 Addr vaddr; 155 static FaultName _name; 156 static FaultVect _vect; 157 static FaultStat _count; | |
158 public: | 123 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 | 124 void invoke(ThreadContext * tc, 125 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 126}; 127 |
166class TLBInvalidIFetchFault : public MipsFault | 128class TLBInvalidIFetchFault : public MipsFault<TLBInvalidIFetchFault> |
167{ | 129{ |
168 private: 169 Addr vaddr; 170 static FaultName _name; 171 static FaultVect _vect; 172 static FaultStat _count; | |
173 public: | 130 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 | 131 void invoke(ThreadContext * tc, 132 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 133}; 134 |
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}; | 135class NDtbMissFault : public MipsFault<NDtbMissFault> {}; 136class PDtbMissFault : public MipsFault<PDtbMissFault> {}; 137class DtbPageFault : public MipsFault<DtbPageFault> {}; 138class DtbAcvFault : public MipsFault<DtbAcvFault> {}; |
192 | 139 |
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 | 140static inline Fault genMachineCheckFault() 141{ 142 return new MachineCheckFault; 143} 144 145static inline Fault genAlignmentFault() 146{ 147 return new AlignmentFault; 148} 149 |
240class ResetFault : public MipsFault | 150class ResetFault : public MipsFault<ResetFault> |
241{ | 151{ |
242 private: 243 static FaultName _name; 244 static FaultVect _vect; 245 static FaultStat _count; | |
246 public: | 152 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 | 153 void invoke(ThreadContext * tc, 154 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 155 156}; 157 |
255class SystemCallFault : public MipsFault | 158class SystemCallFault : public MipsFault<SystemCallFault> |
256{ | 159{ |
257 private: 258 static FaultName _name; 259 static FaultVect _vect; 260 static FaultStat _count; | |
261 public: | 160 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 | 161#if FULL_SYSTEM 162 void invoke(ThreadContext * tc, 163 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 164#endif 165}; 166 |
271class SoftResetFault : public MipsFault | 167class SoftResetFault : public MipsFault<SoftResetFault> |
272{ | 168{ |
273 private: 274 static FaultName _name; 275 static FaultVect _vect; 276 static FaultStat _count; | |
277 public: | 169 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 | 170 void invoke(ThreadContext * tc, 171 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 172}; 173 |
285class DebugSingleStep : public MipsFault | 174class DebugSingleStep : public MipsFault<DebugSingleStep> |
286{ | 175{ |
287 private: 288 static FaultName _name; 289 static FaultVect _vect; 290 static FaultStat _count; | |
291 public: | 176 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 | 177 void invoke(ThreadContext * tc, 178 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 179}; 180 |
299class DebugInterrupt : public MipsFault | 181class DebugInterrupt : public MipsFault<DebugInterrupt> |
300{ | 182{ |
301 private: 302 static FaultName _name; 303 static FaultVect _vect; 304 static FaultStat _count; | |
305 public: | 183 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 | 184 void invoke(ThreadContext * tc, 185 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 186}; 187 |
313class CoprocessorUnusableFault : public MipsFault | 188class CoprocessorUnusableFault : public MipsFault<CoprocessorUnusableFault> |
314{ | 189{ |
315 private: 316 static FaultName _name; 317 static FaultVect _vect; 318 static FaultStat _count; | 190 protected: |
319 int coProcID; 320 public: | 191 int coProcID; 192 public: |
321 FaultName name() const {return _name;} 322 FaultVect vect() {return _vect;} 323 FaultStat & countStat() {return _count;} | 193 CoprocessorUnusableFault(int _procid) : coProcID(_procid) 194 {} 195 |
324 void invoke(ThreadContext * tc, 325 StaticInstPtr inst = StaticInst::nullStaticInstPtr); | 196 void invoke(ThreadContext * tc, 197 StaticInstPtr inst = StaticInst::nullStaticInstPtr); |
326 CoprocessorUnusableFault(int _procid){ coProcID = _procid;} | |
327}; 328 | 198}; 199 |
329class ReservedInstructionFault : public MipsFault | 200class ReservedInstructionFault : public MipsFault<ReservedInstructionFault> |
330{ | 201{ |
331 private: 332 static FaultName _name; 333 static FaultVect _vect; 334 static FaultStat _count; | |
335 public: | 202 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 | 203 void invoke(ThreadContext * tc, 204 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 205}; 206 |
343class ThreadFault : public MipsFault | 207class ThreadFault : public MipsFault<ThreadFault> |
344{ | 208{ |
345 private: 346 static FaultName _name; 347 static FaultVect _vect; 348 static FaultStat _count; | |
349 public: | 209 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 | 210 void invoke(ThreadContext * tc, 211 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 212}; 213 |
357class ArithmeticFault : public MipsFault | 214class ArithmeticFault : public MipsFault<ArithmeticFault> |
358{ 359 protected: 360 bool skipFaultingInstruction() {return true;} | 215{ 216 protected: 217 bool skipFaultingInstruction() {return true;} |
361 private: 362 static FaultName _name; 363 static FaultVect _vect; 364 static FaultStat _count; | |
365 public: | 218 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 | 219#if FULL_SYSTEM 220 void invoke(ThreadContext * tc, 221 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 222#endif 223}; 224 |
375class InterruptFault : public MipsFault | 225class InterruptFault : public MipsFault<InterruptFault> |
376{ 377 protected: 378 bool setRestartAddress() {return false;} | 226{ 227 protected: 228 bool setRestartAddress() {return false;} |
379 private: 380 static FaultName _name; 381 static FaultVect _vect; 382 static FaultStat _count; | |
383 public: | 229 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 | 230#if FULL_SYSTEM 231 void invoke(ThreadContext * tc, 232 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 233#endif 234}; 235 |
394class TrapFault : public MipsFault | 236class TrapFault : public MipsFault<TrapFault> |
395{ | 237{ |
396 private: 397 static FaultName _name; 398 static FaultVect _vect; 399 static FaultStat _count; | |
400 public: | 238 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 | 239#if FULL_SYSTEM 240 void invoke(ThreadContext * tc, 241 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 242#endif 243}; 244 |
410class BreakpointFault : public MipsFault | 245class BreakpointFault : public MipsFault<BreakpointFault> |
411{ | 246{ |
412 private: 413 static FaultName _name; 414 static FaultVect _vect; 415 static FaultStat _count; | |
416 public: | 247 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 | 248#if FULL_SYSTEM 249 void invoke(ThreadContext * tc, 250 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 251#endif 252}; 253 |
426class ItbRefillFault : public MipsFault | 254class ItbRefillFault : public MipsFault<ItbRefillFault> |
427{ | 255{ |
428 private: 429 static FaultName _name; 430 static FaultVect _vect; 431 static FaultStat _count; | |
432 public: | 256 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 | 257#if FULL_SYSTEM 258 void invoke(ThreadContext * tc, 259 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 260#endif 261}; 262 |
442class DtbRefillFault : public MipsFault | 263class DtbRefillFault : public MipsFault<DtbRefillFault> |
443{ | 264{ |
444 private: 445 static FaultName _name; 446 static FaultVect _vect; 447 static FaultStat _count; | |
448 public: | 265 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 | 266#if FULL_SYSTEM 267 void invoke(ThreadContext * tc, 268 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 269#endif 270}; 271 |
458class ItbPageFault : public MipsFault | 272class ItbPageFault : public MipsFault<ItbPageFault> |
459{ | 273{ |
460 private: 461 static FaultName _name; 462 static FaultVect _vect; 463 static FaultStat _count; | |
464 public: | 274 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 | 275#if FULL_SYSTEM 276 void invoke(ThreadContext * tc, 277 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 278#endif 279}; 280 |
474class ItbInvalidFault : public MipsFault | 281class ItbInvalidFault : public MipsFault<ItbInvalidFault> |
475{ | 282{ |
476 private: 477 static FaultName _name; 478 static FaultVect _vect; 479 static FaultStat _count; | |
480 public: | 283 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 | 284#if FULL_SYSTEM 285 void invoke(ThreadContext * tc, 286 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 287#endif 288}; 289 |
490class TLBModifiedFault : public MipsFault | 290class TLBModifiedFault : public MipsFault<TLBModifiedFault> |
491{ | 291{ |
492 private: 493 static FaultName _name; 494 static FaultVect _vect; 495 static FaultStat _count; | |
496 public: | 292 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 | 293#if FULL_SYSTEM 294 void invoke(ThreadContext * tc, 295 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 296#endif 297}; 298 |
506class DtbInvalidFault : public MipsFault | 299class DtbInvalidFault : public MipsFault<DtbInvalidFault> |
507{ | 300{ |
508 private: 509 static FaultName _name; 510 static FaultVect _vect; 511 static FaultStat _count; | |
512 public: | 301 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 | 302#if FULL_SYSTEM 303 void invoke(ThreadContext * tc, 304 StaticInst::StaticInstPtr inst = nullStaticInstPtr); 305#endif 306}; 307 |
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}; | 308class FloatEnableFault : public MipsFault<FloatEnableFault> {}; 309class ItbMissFault : public MipsFault<ItbMissFault> {}; 310class ItbAcvFault : public MipsFault<ItbAcvFault> {}; 311class IntegerOverflowFault : public MipsFault<IntegerOverflowFault> {}; |
533 | 312 |
534class ItbMissFault : public MipsFault | 313class DspStateDisabledFault : public MipsFault<DspStateDisabledFault> |
535{ | 314{ |
536 private: 537 static FaultName _name; 538 static FaultVect _vect; 539 static FaultStat _count; | |
540 public: | 315 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__ | 316 void invoke(ThreadContext * tc, 317 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 318}; 319 320} // namespace MipsISA 321 322#endif // __MIPS_FAULTS_HH__ |