1/*
| 1/*
|
2 * Copyright N) 2007 MIPS Technologies, Inc. All Rights Reserved
| 2 * Copyright (c) 2007 MIPS Technologies, Inc.
3 * All rights reserved.
|
3 *
| 4 *
|
4 * This software is part of the M5 simulator.
| 5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
|
5 *
| 15 *
|
6 * THIS IS A LEGAL AGREEMENT. BY DOWNLOADING, USING, COPYING, CREATING
7 * DERIVATIVE WORKS, AND/OR DISTRIBUTING THIS SOFTWARE YOU ARE AGREEING
8 * TO THESE TERMS AND CONDITIONS.
| 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
9 *
| 27 *
|
10 * Permission is granted to use, copy, create derivative works and
11 * distribute this software and such derivative works for any purpose,
12 * so long as (1) the copyright notice above, this grant of permission,
13 * and the disclaimer below appear in all copies and derivative works
14 * made, (2) the copyright notice above is augmented as appropriate to
15 * reflect the addition of any new copyrightable work in a derivative
16 * work (e.g., Copyright N) <Publication Year> Copyright Owner), and (3)
17 * the name of MIPS Technologies, Inc. ($(B!H(BMIPS$(B!I(B) is not used in any
18 * advertising or publicity pertaining to the use or distribution of
19 * this software without specific, written prior authorization.
20 *
21 * THIS SOFTWARE IS PROVIDED $(B!H(BAS IS.$(B!I(B MIPS MAKES NO WARRANTIES AND
22 * DISCLAIMS ALL WARRANTIES, WHETHER EXPRESS, STATUTORY, IMPLIED OR
23 * OTHERWISE, INCLUDING BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
24 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
25 * NON-INFRINGEMENT OF THIRD PARTY RIGHTS, REGARDING THIS SOFTWARE.
26 * IN NO EVENT SHALL MIPS BE LIABLE FOR ANY DAMAGES, INCLUDING DIRECT,
27 * INDIRECT, INCIDENTAL, CONSEQUENTIAL, SPECIAL, OR PUNITIVE DAMAGES OF
28 * ANY KIND OR NATURE, ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT,
29 * THIS SOFTWARE AND/OR THE USE OF THIS SOFTWARE, WHETHER SUCH LIABILITY
30 * IS ASSERTED ON THE BASIS OF CONTRACT, TORT (INCLUDING NEGLIGENCE OR
31 * STRICT LIABILITY), OR OTHERWISE, EVEN IF MIPS HAS BEEN WARNED OF THE
32 * POSSIBILITY OF ANY SUCH LOSS OR DAMAGE IN ADVANCE.
33 *
34 * Authors: Gabe M. Black
35 * Korey L. Sewell
| 28 * Authors: Gabe Black
29 * Korey Sewell
|
36 * Jaidev Patwardhan
37 */
38
39#ifndef __MIPS_FAULTS_HH__
40#define __MIPS_FAULTS_HH__
41
42#include "sim/faults.hh"
43
44// The design of the "name" and "vect" functions is in sim/faults.hh
45
46namespace MipsISA
47{
48typedef const Addr FaultVect;
49
50class MipsFault : public FaultBase
51{
52 protected:
53 virtual bool skipFaultingInstruction() {return false;}
54 virtual bool setRestartAddress() {return true;}
55 public:
56 Addr BadVAddr;
57 Addr EntryHi_Asid;
58 Addr EntryHi_VPN2;
59 Addr EntryHi_VPN2X;
60 Addr Context_BadVPN2;
61#if FULL_SYSTEM
62 void invoke(ThreadContext * tc) {};
63 void setExceptionState(ThreadContext *,uint8_t);
64 void setHandlerPC(Addr,ThreadContext *);
65#endif
66 virtual FaultVect vect() = 0;
67 virtual FaultStat & countStat() = 0;
68};
69
70class MachineCheckFault : public MipsFault
71{
72 private:
73 static FaultName _name;
74 static FaultVect _vect;
75 static FaultStat _count;
76 public:
77 FaultName name() const {return _name;}
78 FaultVect vect() {return _vect;}
79 FaultStat & countStat() {return _count;}
80 bool isMachineCheckFault() {return true;}
81};
82
83class NonMaskableInterrupt : public MipsFault
84{
85 private:
86 static FaultName _name;
87 static FaultVect _vect;
88 static FaultStat _count;
89 public:
90 FaultName name() const {return _name;}
91 FaultVect vect() {return _vect;}
92 FaultStat & countStat() {return _count;}
93 bool isNonMaskableInterrupt() {return true;}
94};
95
96class AlignmentFault : public MipsFault
97{
98 private:
99 static FaultName _name;
100 static FaultVect _vect;
101 static FaultStat _count;
102 public:
103 FaultName name() const {return _name;}
104 FaultVect vect() {return _vect;}
105 FaultStat & countStat() {return _count;}
106 bool isAlignmentFault() {return true;}
107};
108
109class AddressErrorFault : public MipsFault
110{
111 private:
112 static FaultName _name;
113 static FaultVect _vect;
114 static FaultStat _count;
115 public:
116 FaultName name() const {return _name;}
117 FaultVect vect() {return _vect;}
118 FaultStat & countStat() {return _count;}
119#if FULL_SYSTEM
120 void invoke(ThreadContext * tc);
121#endif
122
123};
124class StoreAddressErrorFault : public MipsFault
125{
126 private:
127 static FaultName _name;
128 static FaultVect _vect;
129 static FaultStat _count;
130 public:
131 FaultName name() const {return _name;}
132 FaultVect vect() {return _vect;}
133 FaultStat & countStat() {return _count;}
134#if FULL_SYSTEM
135 void invoke(ThreadContext * tc);
136#endif
137
138};
139class UnimplementedOpcodeFault : public MipsFault
140{
141 private:
142 static FaultName _name;
143 static FaultVect _vect;
144 static FaultStat _count;
145 public:
146 FaultName name() const {return _name;}
147 FaultVect vect() {return _vect;}
148 FaultStat & countStat() {return _count;}
149};
150
151
152class TLBRefillIFetchFault : public MipsFault
153{
154 private:
155 Addr vaddr;
156 static FaultName _name;
157 static FaultVect _vect;
158 static FaultStat _count;
159 public:
160 FaultName name() const {return _name;}
161 FaultVect vect() {return _vect;}
162 FaultStat & countStat() {return _count;}
163 void invoke(ThreadContext * tc);
164};
165class TLBInvalidIFetchFault : public MipsFault
166{
167 private:
168 Addr vaddr;
169 static FaultName _name;
170 static FaultVect _vect;
171 static FaultStat _count;
172 public:
173 FaultName name() const {return _name;}
174 FaultVect vect() {return _vect;}
175 FaultStat & countStat() {return _count;}
176 void invoke(ThreadContext * tc);
177};
178
179class NDtbMissFault : public MipsFault
180{
181 private:
182 static FaultName _name;
183 static FaultVect _vect;
184 static FaultStat _count;
185 public:
186 FaultName name() const {return _name;}
187 FaultVect vect() {return _vect;}
188 FaultStat & countStat() {return _count;}
189};
190
191class PDtbMissFault : public MipsFault
192{
193 private:
194 static FaultName _name;
195 static FaultVect _vect;
196 static FaultStat _count;
197 public:
198 FaultName name() const {return _name;}
199 FaultVect vect() {return _vect;}
200 FaultStat & countStat() {return _count;}
201};
202
203class DtbPageFault : public MipsFault
204{
205 private:
206 static FaultName _name;
207 static FaultVect _vect;
208 static FaultStat _count;
209 public:
210 FaultName name() const {return _name;}
211 FaultVect vect() {return _vect;}
212 FaultStat & countStat() {return _count;}
213};
214
215class DtbAcvFault : public MipsFault
216{
217 private:
218 static FaultName _name;
219 static FaultVect _vect;
220 static FaultStat _count;
221 public:
222 FaultName name() const {return _name;}
223 FaultVect vect() {return _vect;}
224 FaultStat & countStat() {return _count;}
225};
226
227class CacheErrorFault : public MipsFault
228{
229 private:
230 Addr vaddr;
231 static FaultName _name;
232 static FaultVect _vect;
233 static FaultStat _count;
234 public:
235 FaultName name() const {return _name;}
236 FaultVect vect() {return _vect;}
237 FaultStat & countStat() {return _count;}
238 void invoke(ThreadContext * tc);
239};
240
241
242
243
244static inline Fault genMachineCheckFault()
245{
246 return new MachineCheckFault;
247}
248
249static inline Fault genAlignmentFault()
250{
251 return new AlignmentFault;
252}
253
254class ResetFault : public MipsFault
255{
256 private:
257 static FaultName _name;
258 static FaultVect _vect;
259 static FaultStat _count;
260 public:
261 FaultName name() const {return _name;}
262 FaultVect vect() {return _vect;}
263 FaultStat & countStat() {return _count;}
264 void invoke(ThreadContext * tc);
265
266};
267class SystemCallFault : public MipsFault
268{
269 private:
270 static FaultName _name;
271 static FaultVect _vect;
272 static FaultStat _count;
273 public:
274 FaultName name() const {return _name;}
275 FaultVect vect() {return _vect;}
276 FaultStat & countStat() {return _count;}
277 void invoke(ThreadContext * tc);
278};
279
280class SoftResetFault : public MipsFault
281{
282 private:
283 static FaultName _name;
284 static FaultVect _vect;
285 static FaultStat _count;
286 public:
287 FaultName name() const {return _name;}
288 FaultVect vect() {return _vect;}
289 FaultStat & countStat() {return _count;}
290 void invoke(ThreadContext * tc);
291};
292class DebugSingleStep : public MipsFault
293{
294 private:
295 static FaultName _name;
296 static FaultVect _vect;
297 static FaultStat _count;
298 public:
299 FaultName name() const {return _name;}
300 FaultVect vect() {return _vect;}
301 FaultStat & countStat() {return _count;}
302 void invoke(ThreadContext * tc);
303};
304class DebugInterrupt : public MipsFault
305{
306 private:
307 static FaultName _name;
308 static FaultVect _vect;
309 static FaultStat _count;
310 public:
311 FaultName name() const {return _name;}
312 FaultVect vect() {return _vect;}
313 FaultStat & countStat() {return _count;}
314 void invoke(ThreadContext * tc);
315};
316
317class CoprocessorUnusableFault : public MipsFault
318{
319 private:
320 static FaultName _name;
321 static FaultVect _vect;
322 static FaultStat _count;
323 int coProcID;
324 public:
325 FaultName name() const {return _name;}
326 FaultVect vect() {return _vect;}
327 FaultStat & countStat() {return _count;}
328 void invoke(ThreadContext * tc);
329 CoprocessorUnusableFault(int _procid){ coProcID = _procid;}
330};
331
332class ReservedInstructionFault : public MipsFault
333{
334 private:
335 static FaultName _name;
336 static FaultVect _vect;
337 static FaultStat _count;
338 public:
339 FaultName name() const {return _name;}
340 FaultVect vect() {return _vect;}
341 FaultStat & countStat() {return _count;}
342 void invoke(ThreadContext * tc);
343};
344
345class ThreadFault : public MipsFault
346{
347 private:
348 static FaultName _name;
349 static FaultVect _vect;
350 static FaultStat _count;
351 public:
352 FaultName name() const {return _name;}
353 FaultVect vect() {return _vect;}
354 FaultStat & countStat() {return _count;}
355 void invoke(ThreadContext * tc);
356};
357
358
359class ArithmeticFault : public MipsFault
360{
361 protected:
362 bool skipFaultingInstruction() {return true;}
363 private:
364 static FaultName _name;
365 static FaultVect _vect;
366 static FaultStat _count;
367 public:
368 FaultName name() const {return _name;}
369 FaultVect vect() {return _vect;}
370 FaultStat & countStat() {return _count;}
371#if FULL_SYSTEM
372 void invoke(ThreadContext * tc);
373#endif
374};
375
376class InterruptFault : public MipsFault
377{
378 protected:
379 bool setRestartAddress() {return false;}
380 private:
381 static FaultName _name;
382 static FaultVect _vect;
383 static FaultStat _count;
384 public:
385 FaultName name() const {return _name;}
386 FaultVect vect() {return _vect;}
387 FaultStat & countStat() {return _count;}
388
389#if FULL_SYSTEM
390 void invoke(ThreadContext * tc);
391#endif
392
393 //void invoke(ThreadContext * tc);
394};
395
396class TrapFault : public MipsFault
397{
398 private:
399 static FaultName _name;
400 static FaultVect _vect;
401 static FaultStat _count;
402 public:
403 FaultName name() const {return _name;}
404 FaultVect vect() {return _vect;}
405 FaultStat & countStat() {return _count;}
406#if FULL_SYSTEM
407 void invoke(ThreadContext * tc);
408#endif
409};
410
411class BreakpointFault : public MipsFault
412{
413 private:
414 static FaultName _name;
415 static FaultVect _vect;
416 static FaultStat _count;
417 public:
418 FaultName name() const {return _name;}
419 FaultVect vect() {return _vect;}
420 FaultStat & countStat() {return _count;}
421#if FULL_SYSTEM
422 void invoke(ThreadContext * tc);
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#endif
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#endif
453};
454
455class ItbPageFault : public MipsFault
456{
457 private:
458 static FaultName _name;
459 static FaultVect _vect;
460 static FaultStat _count;
461 public:
462 FaultName name() const {return _name;}
463 FaultVect vect() {return _vect;}
464 FaultStat & countStat() {return _count;}
465#if FULL_SYSTEM
466 void invoke(ThreadContext * tc);
467#endif
468};
469
470class ItbInvalidFault : public MipsFault
471{
472 private:
473 static FaultName _name;
474 static FaultVect _vect;
475 static FaultStat _count;
476 public:
477 FaultName name() const {return _name;}
478 FaultVect vect() {return _vect;}
479 FaultStat & countStat() {return _count;}
480#if FULL_SYSTEM
481 void invoke(ThreadContext * tc);
482#endif
483
484};
485class TLBModifiedFault : public MipsFault
486{
487 private:
488 static FaultName _name;
489 static FaultVect _vect;
490 static FaultStat _count;
491 public:
492 FaultName name() const {return _name;}
493 FaultVect vect() {return _vect;}
494 FaultStat & countStat() {return _count;}
495#if FULL_SYSTEM
496 void invoke(ThreadContext * tc);
497#endif
498
499};
500
501class DtbInvalidFault : public MipsFault
502{
503 private:
504 static FaultName _name;
505 static FaultVect _vect;
506 static FaultStat _count;
507 public:
508 FaultName name() const {return _name;}
509 FaultVect vect() {return _vect;}
510 FaultStat & countStat() {return _count;}
511#if FULL_SYSTEM
512 void invoke(ThreadContext * tc);
513#endif
514
515};
516
517class FloatEnableFault : public MipsFault
518{
519 private:
520 static FaultName _name;
521 static FaultVect _vect;
522 static FaultStat _count;
523 public:
524 FaultName name() const {return _name;}
525 FaultVect vect() {return _vect;}
526 FaultStat & countStat() {return _count;}
527};
528
529class ItbMissFault : public MipsFault
530{
531 private:
532 static FaultName _name;
533 static FaultVect _vect;
534 static FaultStat _count;
535 public:
536 FaultName name() const {return _name;}
537 FaultVect vect() {return _vect;}
538 FaultStat & countStat() {return _count;}
539};
540
541class ItbAcvFault : public MipsFault
542{
543 private:
544 static FaultName _name;
545 static FaultVect _vect;
546 static FaultStat _count;
547 public:
548 FaultName name() const {return _name;}
549 FaultVect vect() {return _vect;}
550 FaultStat & countStat() {return _count;}
551};
552
553class IntegerOverflowFault : public MipsFault
554{
555 private:
556 static FaultName _name;
557 static FaultVect _vect;
558 static FaultStat _count;
559 public:
560 FaultName name() const {return _name;}
561 FaultVect vect() {return _vect;}
562 FaultStat & countStat() {return _count;}
563};
564
565class DspStateDisabledFault : public MipsFault
566{
567 private:
568 static FaultName _name;
569 static FaultVect _vect;
570 static FaultStat _count;
571 public:
572 FaultName name() const {return _name;}
573 FaultVect vect() {return _vect;}
574 FaultStat & countStat() {return _count;}
575 void invoke(ThreadContext * tc);
576};
577
578} // MipsISA namespace
579
580#endif // __MIPS_FAULTS_HH__
| 30 * Jaidev Patwardhan
31 */
32
33#ifndef __MIPS_FAULTS_HH__
34#define __MIPS_FAULTS_HH__
35
36#include "sim/faults.hh"
37
38// The design of the "name" and "vect" functions is in sim/faults.hh
39
40namespace MipsISA
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 EntryHi_Asid;
52 Addr EntryHi_VPN2;
53 Addr EntryHi_VPN2X;
54 Addr Context_BadVPN2;
55#if FULL_SYSTEM
56 void invoke(ThreadContext * tc) {};
57 void setExceptionState(ThreadContext *,uint8_t);
58 void setHandlerPC(Addr,ThreadContext *);
59#endif
60 virtual FaultVect vect() = 0;
61 virtual FaultStat & countStat() = 0;
62};
63
64class MachineCheckFault : public MipsFault
65{
66 private:
67 static FaultName _name;
68 static FaultVect _vect;
69 static FaultStat _count;
70 public:
71 FaultName name() const {return _name;}
72 FaultVect vect() {return _vect;}
73 FaultStat & countStat() {return _count;}
74 bool isMachineCheckFault() {return true;}
75};
76
77class NonMaskableInterrupt : public MipsFault
78{
79 private:
80 static FaultName _name;
81 static FaultVect _vect;
82 static FaultStat _count;
83 public:
84 FaultName name() const {return _name;}
85 FaultVect vect() {return _vect;}
86 FaultStat & countStat() {return _count;}
87 bool isNonMaskableInterrupt() {return true;}
88};
89
90class AlignmentFault : public MipsFault
91{
92 private:
93 static FaultName _name;
94 static FaultVect _vect;
95 static FaultStat _count;
96 public:
97 FaultName name() const {return _name;}
98 FaultVect vect() {return _vect;}
99 FaultStat & countStat() {return _count;}
100 bool isAlignmentFault() {return true;}
101};
102
103class AddressErrorFault : public MipsFault
104{
105 private:
106 static FaultName _name;
107 static FaultVect _vect;
108 static FaultStat _count;
109 public:
110 FaultName name() const {return _name;}
111 FaultVect vect() {return _vect;}
112 FaultStat & countStat() {return _count;}
113#if FULL_SYSTEM
114 void invoke(ThreadContext * tc);
115#endif
116
117};
118class StoreAddressErrorFault : public MipsFault
119{
120 private:
121 static FaultName _name;
122 static FaultVect _vect;
123 static FaultStat _count;
124 public:
125 FaultName name() const {return _name;}
126 FaultVect vect() {return _vect;}
127 FaultStat & countStat() {return _count;}
128#if FULL_SYSTEM
129 void invoke(ThreadContext * tc);
130#endif
131
132};
133class UnimplementedOpcodeFault : public MipsFault
134{
135 private:
136 static FaultName _name;
137 static FaultVect _vect;
138 static FaultStat _count;
139 public:
140 FaultName name() const {return _name;}
141 FaultVect vect() {return _vect;}
142 FaultStat & countStat() {return _count;}
143};
144
145
146class TLBRefillIFetchFault : public MipsFault
147{
148 private:
149 Addr vaddr;
150 static FaultName _name;
151 static FaultVect _vect;
152 static FaultStat _count;
153 public:
154 FaultName name() const {return _name;}
155 FaultVect vect() {return _vect;}
156 FaultStat & countStat() {return _count;}
157 void invoke(ThreadContext * tc);
158};
159class TLBInvalidIFetchFault : public MipsFault
160{
161 private:
162 Addr vaddr;
163 static FaultName _name;
164 static FaultVect _vect;
165 static FaultStat _count;
166 public:
167 FaultName name() const {return _name;}
168 FaultVect vect() {return _vect;}
169 FaultStat & countStat() {return _count;}
170 void invoke(ThreadContext * tc);
171};
172
173class NDtbMissFault : public MipsFault
174{
175 private:
176 static FaultName _name;
177 static FaultVect _vect;
178 static FaultStat _count;
179 public:
180 FaultName name() const {return _name;}
181 FaultVect vect() {return _vect;}
182 FaultStat & countStat() {return _count;}
183};
184
185class PDtbMissFault : public MipsFault
186{
187 private:
188 static FaultName _name;
189 static FaultVect _vect;
190 static FaultStat _count;
191 public:
192 FaultName name() const {return _name;}
193 FaultVect vect() {return _vect;}
194 FaultStat & countStat() {return _count;}
195};
196
197class DtbPageFault : public MipsFault
198{
199 private:
200 static FaultName _name;
201 static FaultVect _vect;
202 static FaultStat _count;
203 public:
204 FaultName name() const {return _name;}
205 FaultVect vect() {return _vect;}
206 FaultStat & countStat() {return _count;}
207};
208
209class DtbAcvFault : public MipsFault
210{
211 private:
212 static FaultName _name;
213 static FaultVect _vect;
214 static FaultStat _count;
215 public:
216 FaultName name() const {return _name;}
217 FaultVect vect() {return _vect;}
218 FaultStat & countStat() {return _count;}
219};
220
221class CacheErrorFault : public MipsFault
222{
223 private:
224 Addr vaddr;
225 static FaultName _name;
226 static FaultVect _vect;
227 static FaultStat _count;
228 public:
229 FaultName name() const {return _name;}
230 FaultVect vect() {return _vect;}
231 FaultStat & countStat() {return _count;}
232 void invoke(ThreadContext * tc);
233};
234
235
236
237
238static inline Fault genMachineCheckFault()
239{
240 return new MachineCheckFault;
241}
242
243static inline Fault genAlignmentFault()
244{
245 return new AlignmentFault;
246}
247
248class ResetFault : public MipsFault
249{
250 private:
251 static FaultName _name;
252 static FaultVect _vect;
253 static FaultStat _count;
254 public:
255 FaultName name() const {return _name;}
256 FaultVect vect() {return _vect;}
257 FaultStat & countStat() {return _count;}
258 void invoke(ThreadContext * tc);
259
260};
261class SystemCallFault : public MipsFault
262{
263 private:
264 static FaultName _name;
265 static FaultVect _vect;
266 static FaultStat _count;
267 public:
268 FaultName name() const {return _name;}
269 FaultVect vect() {return _vect;}
270 FaultStat & countStat() {return _count;}
271 void invoke(ThreadContext * tc);
272};
273
274class SoftResetFault : public MipsFault
275{
276 private:
277 static FaultName _name;
278 static FaultVect _vect;
279 static FaultStat _count;
280 public:
281 FaultName name() const {return _name;}
282 FaultVect vect() {return _vect;}
283 FaultStat & countStat() {return _count;}
284 void invoke(ThreadContext * tc);
285};
286class DebugSingleStep : public MipsFault
287{
288 private:
289 static FaultName _name;
290 static FaultVect _vect;
291 static FaultStat _count;
292 public:
293 FaultName name() const {return _name;}
294 FaultVect vect() {return _vect;}
295 FaultStat & countStat() {return _count;}
296 void invoke(ThreadContext * tc);
297};
298class DebugInterrupt : public MipsFault
299{
300 private:
301 static FaultName _name;
302 static FaultVect _vect;
303 static FaultStat _count;
304 public:
305 FaultName name() const {return _name;}
306 FaultVect vect() {return _vect;}
307 FaultStat & countStat() {return _count;}
308 void invoke(ThreadContext * tc);
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 CoprocessorUnusableFault(int _procid){ coProcID = _procid;}
324};
325
326class ReservedInstructionFault : public MipsFault
327{
328 private:
329 static FaultName _name;
330 static FaultVect _vect;
331 static FaultStat _count;
332 public:
333 FaultName name() const {return _name;}
334 FaultVect vect() {return _vect;}
335 FaultStat & countStat() {return _count;}
336 void invoke(ThreadContext * tc);
337};
338
339class ThreadFault : public MipsFault
340{
341 private:
342 static FaultName _name;
343 static FaultVect _vect;
344 static FaultStat _count;
345 public:
346 FaultName name() const {return _name;}
347 FaultVect vect() {return _vect;}
348 FaultStat & countStat() {return _count;}
349 void invoke(ThreadContext * tc);
350};
351
352
353class ArithmeticFault : public MipsFault
354{
355 protected:
356 bool skipFaultingInstruction() {return true;}
357 private:
358 static FaultName _name;
359 static FaultVect _vect;
360 static FaultStat _count;
361 public:
362 FaultName name() const {return _name;}
363 FaultVect vect() {return _vect;}
364 FaultStat & countStat() {return _count;}
365#if FULL_SYSTEM
366 void invoke(ThreadContext * tc);
367#endif
368};
369
370class InterruptFault : public MipsFault
371{
372 protected:
373 bool setRestartAddress() {return false;}
374 private:
375 static FaultName _name;
376 static FaultVect _vect;
377 static FaultStat _count;
378 public:
379 FaultName name() const {return _name;}
380 FaultVect vect() {return _vect;}
381 FaultStat & countStat() {return _count;}
382
383#if FULL_SYSTEM
384 void invoke(ThreadContext * tc);
385#endif
386
387 //void invoke(ThreadContext * tc);
388};
389
390class TrapFault : public MipsFault
391{
392 private:
393 static FaultName _name;
394 static FaultVect _vect;
395 static FaultStat _count;
396 public:
397 FaultName name() const {return _name;}
398 FaultVect vect() {return _vect;}
399 FaultStat & countStat() {return _count;}
400#if FULL_SYSTEM
401 void invoke(ThreadContext * tc);
402#endif
403};
404
405class BreakpointFault : public MipsFault
406{
407 private:
408 static FaultName _name;
409 static FaultVect _vect;
410 static FaultStat _count;
411 public:
412 FaultName name() const {return _name;}
413 FaultVect vect() {return _vect;}
414 FaultStat & countStat() {return _count;}
415#if FULL_SYSTEM
416 void invoke(ThreadContext * tc);
417#endif
418};
419
420class ItbRefillFault : public MipsFault
421{
422 private:
423 static FaultName _name;
424 static FaultVect _vect;
425 static FaultStat _count;
426 public:
427 FaultName name() const {return _name;}
428 FaultVect vect() {return _vect;}
429 FaultStat & countStat() {return _count;}
430#if FULL_SYSTEM
431 void invoke(ThreadContext * tc);
432#endif
433};
434class DtbRefillFault : public MipsFault
435{
436 private:
437 static FaultName _name;
438 static FaultVect _vect;
439 static FaultStat _count;
440 public:
441 FaultName name() const {return _name;}
442 FaultVect vect() {return _vect;}
443 FaultStat & countStat() {return _count;}
444#if FULL_SYSTEM
445 void invoke(ThreadContext * tc);
446#endif
447};
448
449class ItbPageFault : public MipsFault
450{
451 private:
452 static FaultName _name;
453 static FaultVect _vect;
454 static FaultStat _count;
455 public:
456 FaultName name() const {return _name;}
457 FaultVect vect() {return _vect;}
458 FaultStat & countStat() {return _count;}
459#if FULL_SYSTEM
460 void invoke(ThreadContext * tc);
461#endif
462};
463
464class ItbInvalidFault : public MipsFault
465{
466 private:
467 static FaultName _name;
468 static FaultVect _vect;
469 static FaultStat _count;
470 public:
471 FaultName name() const {return _name;}
472 FaultVect vect() {return _vect;}
473 FaultStat & countStat() {return _count;}
474#if FULL_SYSTEM
475 void invoke(ThreadContext * tc);
476#endif
477
478};
479class TLBModifiedFault : public MipsFault
480{
481 private:
482 static FaultName _name;
483 static FaultVect _vect;
484 static FaultStat _count;
485 public:
486 FaultName name() const {return _name;}
487 FaultVect vect() {return _vect;}
488 FaultStat & countStat() {return _count;}
489#if FULL_SYSTEM
490 void invoke(ThreadContext * tc);
491#endif
492
493};
494
495class DtbInvalidFault : public MipsFault
496{
497 private:
498 static FaultName _name;
499 static FaultVect _vect;
500 static FaultStat _count;
501 public:
502 FaultName name() const {return _name;}
503 FaultVect vect() {return _vect;}
504 FaultStat & countStat() {return _count;}
505#if FULL_SYSTEM
506 void invoke(ThreadContext * tc);
507#endif
508
509};
510
511class FloatEnableFault : public MipsFault
512{
513 private:
514 static FaultName _name;
515 static FaultVect _vect;
516 static FaultStat _count;
517 public:
518 FaultName name() const {return _name;}
519 FaultVect vect() {return _vect;}
520 FaultStat & countStat() {return _count;}
521};
522
523class ItbMissFault : public MipsFault
524{
525 private:
526 static FaultName _name;
527 static FaultVect _vect;
528 static FaultStat _count;
529 public:
530 FaultName name() const {return _name;}
531 FaultVect vect() {return _vect;}
532 FaultStat & countStat() {return _count;}
533};
534
535class ItbAcvFault : public MipsFault
536{
537 private:
538 static FaultName _name;
539 static FaultVect _vect;
540 static FaultStat _count;
541 public:
542 FaultName name() const {return _name;}
543 FaultVect vect() {return _vect;}
544 FaultStat & countStat() {return _count;}
545};
546
547class IntegerOverflowFault : public MipsFault
548{
549 private:
550 static FaultName _name;
551 static FaultVect _vect;
552 static FaultStat _count;
553 public:
554 FaultName name() const {return _name;}
555 FaultVect vect() {return _vect;}
556 FaultStat & countStat() {return _count;}
557};
558
559class DspStateDisabledFault : public MipsFault
560{
561 private:
562 static FaultName _name;
563 static FaultVect _vect;
564 static FaultStat _count;
565 public:
566 FaultName name() const {return _name;}
567 FaultVect vect() {return _vect;}
568 FaultStat & countStat() {return _count;}
569 void invoke(ThreadContext * tc);
570};
571
572} // MipsISA namespace
573
574#endif // __MIPS_FAULTS_HH__
|