faults.hh revision 5222:bb733a878f85 
1/*
2 * Copyright N) 2007 MIPS Technologies, Inc.  All Rights Reserved
3 *
4 * This software is part of the M5 simulator.
5 *
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.
9 *
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
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__
581