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:
|
50 struct FaultVals 51 { 52 const FaultName name; 53 const FaultVect vect; 54 FaultStat count; 55 }; 56 |
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;
|
69}; 70
|
66class MachineCheckFault : public MipsFault
|
71template <typename T> 72class MipsFault : public MipsFaultBase |
73{
|
68 private:
69 static FaultName _name;
70 static FaultVect _vect;
71 static FaultStat _count;
|
74 protected: 75 static FaultVals vals; |
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: |
85 bool isMachineCheckFault() {return true;} 86}; 87
|
79class NonMaskableInterrupt : public MipsFault
|
88class NonMaskableInterrupt : public MipsFault<NonMaskableInterrupt> |
89{
|
81 private:
82 static FaultName _name;
83 static FaultVect _vect;
84 static FaultStat _count;
|
90 public:
|
86 FaultName name() const {return _name;}
87 FaultVect vect() {return _vect;}
88 FaultStat & countStat() {return _count;}
|
91 bool isNonMaskableInterrupt() {return true;} 92}; 93
|
92class AlignmentFault : public MipsFault
|
94class AlignmentFault : public MipsFault<AlignmentFault> |
95{
|
94 private:
95 static FaultName _name;
96 static FaultVect _vect;
97 static FaultStat _count;
|
96 public:
|
99 FaultName name() const {return _name;}
100 FaultVect vect() {return _vect;}
101 FaultStat & countStat() {return _count;}
|
97 bool isAlignmentFault() {return true;} 98}; 99
|
105class AddressErrorFault : public MipsFault
|
100class AddressErrorFault : public MipsFault<AddressErrorFault> |
101{
|
107 private:
108 static FaultName _name;
109 static FaultVect _vect;
110 static FaultStat _count;
|
102 public:
|
112 FaultName name() const {return _name;}
113 FaultVect vect() {return _vect;}
114 FaultStat & countStat() {return _count;}
|
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> |
111{
|
124 private:
125 static FaultName _name;
126 static FaultVect _vect;
127 static FaultStat _count;
|
112 public:
|
129 FaultName name() const {return _name;}
130 FaultVect vect() {return _vect;}
131 FaultStat & countStat() {return _count;}
|
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> {}; |
120
|
150
151class TLBRefillIFetchFault : public MipsFault
|
121class TLBRefillIFetchFault : public MipsFault<TLBRefillIFetchFault> |
122{
|
153 private:
154 Addr vaddr;
155 static FaultName _name;
156 static FaultVect _vect;
157 static FaultStat _count;
|
123 public:
|
159 FaultName name() const {return _name;}
160 FaultVect vect() {return _vect;}
161 FaultStat & countStat() {return _count;}
|
124 void invoke(ThreadContext * tc, 125 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 126}; 127
|
166class TLBInvalidIFetchFault : public MipsFault
|
128class TLBInvalidIFetchFault : public MipsFault<TLBInvalidIFetchFault> |
129{
|
168 private:
169 Addr vaddr;
170 static FaultName _name;
171 static FaultVect _vect;
172 static FaultStat _count;
|
130 public:
|
174 FaultName name() const {return _name;}
175 FaultVect vect() {return _vect;}
176 FaultStat & countStat() {return _count;}
|
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> {}; |
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
|
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> |
151{
|
242 private:
243 static FaultName _name;
244 static FaultVect _vect;
245 static FaultStat _count;
|
152 public:
|
247 FaultName name() const {return _name;}
248 FaultVect vect() {return _vect;}
249 FaultStat & countStat() {return _count;}
|
153 void invoke(ThreadContext * tc, 154 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 155 156}; 157
|
255class SystemCallFault : public MipsFault
|
158class SystemCallFault : public MipsFault<SystemCallFault> |
159{
|
257 private:
258 static FaultName _name;
259 static FaultVect _vect;
260 static FaultStat _count;
|
160 public:
|
262 FaultName name() const {return _name;}
263 FaultVect vect() {return _vect;}
264 FaultStat & countStat() {return _count;}
|
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> |
168{
|
273 private:
274 static FaultName _name;
275 static FaultVect _vect;
276 static FaultStat _count;
|
169 public:
|
278 FaultName name() const {return _name;}
279 FaultVect vect() {return _vect;}
280 FaultStat & countStat() {return _count;}
|
170 void invoke(ThreadContext * tc, 171 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 172}; 173
|
285class DebugSingleStep : public MipsFault
|
174class DebugSingleStep : public MipsFault<DebugSingleStep> |
175{
|
287 private:
288 static FaultName _name;
289 static FaultVect _vect;
290 static FaultStat _count;
|
176 public:
|
292 FaultName name() const {return _name;}
293 FaultVect vect() {return _vect;}
294 FaultStat & countStat() {return _count;}
|
177 void invoke(ThreadContext * tc, 178 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 179}; 180
|
299class DebugInterrupt : public MipsFault
|
181class DebugInterrupt : public MipsFault<DebugInterrupt> |
182{
|
301 private:
302 static FaultName _name;
303 static FaultVect _vect;
304 static FaultStat _count;
|
183 public:
|
306 FaultName name() const {return _name;}
307 FaultVect vect() {return _vect;}
308 FaultStat & countStat() {return _count;}
|
184 void invoke(ThreadContext * tc, 185 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 186}; 187
|
313class CoprocessorUnusableFault : public MipsFault
|
188class CoprocessorUnusableFault : public MipsFault<CoprocessorUnusableFault> |
189{
|
315 private:
316 static FaultName _name;
317 static FaultVect _vect;
318 static FaultStat _count;
|
190 protected: |
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 |
196 void invoke(ThreadContext * tc, 197 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
326 CoprocessorUnusableFault(int _procid){ coProcID = _procid;}
|
198}; 199
|
329class ReservedInstructionFault : public MipsFault
|
200class ReservedInstructionFault : public MipsFault<ReservedInstructionFault> |
201{
|
331 private:
332 static FaultName _name;
333 static FaultVect _vect;
334 static FaultStat _count;
|
202 public:
|
336 FaultName name() const {return _name;}
337 FaultVect vect() {return _vect;}
338 FaultStat & countStat() {return _count;}
|
203 void invoke(ThreadContext * tc, 204 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 205}; 206
|
343class ThreadFault : public MipsFault
|
207class ThreadFault : public MipsFault<ThreadFault> |
208{
|
345 private:
346 static FaultName _name;
347 static FaultVect _vect;
348 static FaultStat _count;
|
209 public:
|
350 FaultName name() const {return _name;}
351 FaultVect vect() {return _vect;}
352 FaultStat & countStat() {return _count;}
|
210 void invoke(ThreadContext * tc, 211 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 212}; 213
|
357class ArithmeticFault : public MipsFault
|
214class ArithmeticFault : public MipsFault<ArithmeticFault> |
215{ 216 protected: 217 bool skipFaultingInstruction() {return true;}
|
361 private:
362 static FaultName _name;
363 static FaultVect _vect;
364 static FaultStat _count;
|
218 public:
|
366 FaultName name() const {return _name;}
367 FaultVect vect() {return _vect;}
368 FaultStat & countStat() {return _count;}
|
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> |
226{ 227 protected: 228 bool setRestartAddress() {return false;}
|
379 private:
380 static FaultName _name;
381 static FaultVect _vect;
382 static FaultStat _count;
|
229 public:
|
384 FaultName name() const {return _name;}
385 FaultVect vect() {return _vect;}
386 FaultStat & countStat() {return _count;}
387
|
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> |
237{
|
396 private:
397 static FaultName _name;
398 static FaultVect _vect;
399 static FaultStat _count;
|
238 public:
|
401 FaultName name() const {return _name;}
402 FaultVect vect() {return _vect;}
403 FaultStat & countStat() {return _count;}
|
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> |
246{
|
412 private:
413 static FaultName _name;
414 static FaultVect _vect;
415 static FaultStat _count;
|
247 public:
|
417 FaultName name() const {return _name;}
418 FaultVect vect() {return _vect;}
419 FaultStat & countStat() {return _count;}
|
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> |
255{
|
428 private:
429 static FaultName _name;
430 static FaultVect _vect;
431 static FaultStat _count;
|
256 public:
|
433 FaultName name() const {return _name;}
434 FaultVect vect() {return _vect;}
435 FaultStat & countStat() {return _count;}
|
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> |
264{
|
444 private:
445 static FaultName _name;
446 static FaultVect _vect;
447 static FaultStat _count;
|
265 public:
|
449 FaultName name() const {return _name;}
450 FaultVect vect() {return _vect;}
451 FaultStat & countStat() {return _count;}
|
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> |
273{
|
460 private:
461 static FaultName _name;
462 static FaultVect _vect;
463 static FaultStat _count;
|
274 public:
|
465 FaultName name() const {return _name;}
466 FaultVect vect() {return _vect;}
467 FaultStat & countStat() {return _count;}
|
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> |
282{
|
476 private:
477 static FaultName _name;
478 static FaultVect _vect;
479 static FaultStat _count;
|
283 public:
|
481 FaultName name() const {return _name;}
482 FaultVect vect() {return _vect;}
483 FaultStat & countStat() {return _count;}
|
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> |
291{
|
492 private:
493 static FaultName _name;
494 static FaultVect _vect;
495 static FaultStat _count;
|
292 public:
|
497 FaultName name() const {return _name;}
498 FaultVect vect() {return _vect;}
499 FaultStat & countStat() {return _count;}
|
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> |
300{
|
508 private:
509 static FaultName _name;
510 static FaultVect _vect;
511 static FaultStat _count;
|
301 public:
|
513 FaultName name() const {return _name;}
514 FaultVect vect() {return _vect;}
515 FaultStat & countStat() {return _count;}
|
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> {}; |
312
|
534class ItbMissFault : public MipsFault
|
313class DspStateDisabledFault : public MipsFault<DspStateDisabledFault> |
314{
|
536 private:
537 static FaultName _name;
538 static FaultVect _vect;
539 static FaultStat _count;
|
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;}
|
316 void invoke(ThreadContext * tc, 317 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 318}; 319 320} // namespace MipsISA 321 322#endif // __MIPS_FAULTS_HH__
|