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
| 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
| 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__
|