faults.hh revision 8518 
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
45{
46  protected:
47    virtual bool skipFaultingInstruction() {return false;}
48    virtual bool setRestartAddress() {return true;}
49  public:
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
62    virtual FaultVect vect() = 0;
63    virtual FaultStat & countStat() = 0;
64};
65
66class MachineCheckFault : public MipsFault
67{
68  private:
69    static FaultName _name;
70    static FaultVect _vect;
71    static FaultStat _count;
72  public:
73    FaultName name() const {return _name;}
74    FaultVect vect() {return _vect;}
75    FaultStat & countStat() {return _count;}
76    bool isMachineCheckFault() {return true;}
77};
78
79class NonMaskableInterrupt : public MipsFault
80{
81  private:
82    static FaultName _name;
83    static FaultVect _vect;
84    static FaultStat _count;
85  public:
86    FaultName name() const {return _name;}
87    FaultVect vect() {return _vect;}
88    FaultStat & countStat() {return _count;}
89    bool isNonMaskableInterrupt() {return true;}
90};
91
92class AlignmentFault : public MipsFault
93{
94  private:
95    static FaultName _name;
96    static FaultVect _vect;
97    static FaultStat _count;
98  public:
99    FaultName name() const {return _name;}
100    FaultVect vect() {return _vect;}
101    FaultStat & countStat() {return _count;}
102    bool isAlignmentFault() {return true;}
103};
104
105class AddressErrorFault : public MipsFault
106{
107  private:
108    static FaultName _name;
109    static FaultVect _vect;
110    static FaultStat _count;
111  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
122class StoreAddressErrorFault : public MipsFault
123{
124  private:
125    static FaultName _name;
126    static FaultVect _vect;
127    static FaultStat _count;
128  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
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};
149
150
151class TLBRefillIFetchFault : public MipsFault
152{
153  private:
154    Addr vaddr;
155    static FaultName _name;
156    static FaultVect _vect;
157    static FaultStat _count;
158  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
166class TLBInvalidIFetchFault : public MipsFault
167{
168  private:
169    Addr vaddr;
170    static FaultName _name;
171    static FaultVect _vect;
172    static FaultStat _count;
173  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
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};
192
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
229class CacheErrorFault : public MipsFault
230{
231  private:
232    Addr vaddr;
233    static FaultName _name;
234    static FaultVect _vect;
235    static FaultStat _count;
236  public:
237    FaultName name() const {return _name;}
238    FaultVect vect() {return _vect;}
239    FaultStat & countStat() {return _count;}
240    void invoke(ThreadContext * tc,
241            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
242};
243
244
245
246
247static inline Fault genMachineCheckFault()
248{
249    return new MachineCheckFault;
250}
251
252static inline Fault genAlignmentFault()
253{
254    return new AlignmentFault;
255}
256
257class ResetFault : public MipsFault
258{
259  private:
260    static FaultName _name;
261    static FaultVect _vect;
262    static FaultStat _count;
263  public:
264    FaultName name() const {return _name;}
265    FaultVect vect() {return _vect;}
266    FaultStat & countStat() {return _count;}
267    void invoke(ThreadContext * tc,
268            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
269
270};
271
272class SystemCallFault : public MipsFault
273{
274  private:
275    static FaultName _name;
276    static FaultVect _vect;
277    static FaultStat _count;
278  public:
279    FaultName name() const {return _name;}
280    FaultVect vect() {return _vect;}
281    FaultStat & countStat() {return _count;}
282    void invoke(ThreadContext * tc,
283            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
284};
285
286class SoftResetFault : 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            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
298};
299
300class DebugSingleStep : public MipsFault
301{
302  private:
303    static FaultName _name;
304    static FaultVect _vect;
305    static FaultStat _count;
306  public:
307    FaultName name() const {return _name;}
308    FaultVect vect() {return _vect;}
309    FaultStat & countStat() {return _count;}
310    void invoke(ThreadContext * tc,
311            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
312};
313
314class DebugInterrupt : public MipsFault
315{
316  private:
317    static FaultName _name;
318    static FaultVect _vect;
319    static FaultStat _count;
320  public:
321    FaultName name() const {return _name;}
322    FaultVect vect() {return _vect;}
323    FaultStat & countStat() {return _count;}
324    void invoke(ThreadContext * tc,
325            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
326};
327
328class CoprocessorUnusableFault : public MipsFault
329{
330  private:
331    static FaultName _name;
332    static FaultVect _vect;
333    static FaultStat _count;
334    int coProcID;
335  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    CoprocessorUnusableFault(int _procid){ coProcID = _procid;}
342};
343
344class ReservedInstructionFault : public MipsFault
345{
346  private:
347    static FaultName _name;
348    static FaultVect _vect;
349    static FaultStat _count;
350  public:
351    FaultName name() const {return _name;}
352    FaultVect vect() {return _vect;}
353    FaultStat & countStat() {return _count;}
354    void invoke(ThreadContext * tc,
355            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
356};
357
358class ThreadFault : public MipsFault
359{
360  private:
361    static FaultName _name;
362    static FaultVect _vect;
363    static FaultStat _count;
364  public:
365    FaultName name() const {return _name;}
366    FaultVect vect() {return _vect;}
367    FaultStat & countStat() {return _count;}
368    void invoke(ThreadContext * tc,
369            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
370};
371
372class ArithmeticFault : public MipsFault
373{
374  protected:
375    bool skipFaultingInstruction() {return true;}
376  private:
377    static FaultName _name;
378    static FaultVect _vect;
379    static FaultStat _count;
380  public:
381    FaultName name() const {return _name;}
382    FaultVect vect() {return _vect;}
383    FaultStat & countStat() {return _count;}
384#if FULL_SYSTEM
385    void invoke(ThreadContext * tc,
386            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
387#endif
388};
389
390class InterruptFault : public MipsFault
391{
392  protected:
393    bool setRestartAddress() {return false;}
394  private:
395    static FaultName _name;
396    static FaultVect _vect;
397    static FaultStat _count;
398  public:
399    FaultName name() const {return _name;}
400    FaultVect vect() {return _vect;}
401    FaultStat & countStat() {return _count;}
402
403#if FULL_SYSTEM
404    void invoke(ThreadContext * tc,
405            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
406#endif
407};
408
409class TrapFault : public MipsFault
410{
411  private:
412    static FaultName _name;
413    static FaultVect _vect;
414    static FaultStat _count;
415  public:
416    FaultName name() const {return _name;}
417    FaultVect vect() {return _vect;}
418    FaultStat & countStat() {return _count;}
419#if FULL_SYSTEM
420    void invoke(ThreadContext * tc,
421            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
422#endif
423};
424
425class BreakpointFault : public MipsFault
426{
427  private:
428    static FaultName _name;
429    static FaultVect _vect;
430    static FaultStat _count;
431  public:
432    FaultName name() const {return _name;}
433    FaultVect vect() {return _vect;}
434    FaultStat & countStat() {return _count;}
435#if FULL_SYSTEM
436    void invoke(ThreadContext * tc,
437            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
438#endif
439};
440
441class ItbRefillFault : public MipsFault
442{
443  private:
444    static FaultName _name;
445    static FaultVect _vect;
446    static FaultStat _count;
447  public:
448    FaultName name() const {return _name;}
449    FaultVect vect() {return _vect;}
450    FaultStat & countStat() {return _count;}
451#if FULL_SYSTEM
452    void invoke(ThreadContext * tc,
453            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
454#endif
455};
456
457class DtbRefillFault : public MipsFault
458{
459  private:
460    static FaultName _name;
461    static FaultVect _vect;
462    static FaultStat _count;
463  public:
464    FaultName name() const {return _name;}
465    FaultVect vect() {return _vect;}
466    FaultStat & countStat() {return _count;}
467#if FULL_SYSTEM
468    void invoke(ThreadContext * tc,
469            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
470#endif
471};
472
473class ItbPageFault : public MipsFault
474{
475  private:
476    static FaultName _name;
477    static FaultVect _vect;
478    static FaultStat _count;
479  public:
480    FaultName name() const {return _name;}
481    FaultVect vect() {return _vect;}
482    FaultStat & countStat() {return _count;}
483#if FULL_SYSTEM
484    void invoke(ThreadContext * tc,
485            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
486#endif
487};
488
489class ItbInvalidFault : public MipsFault
490{
491  private:
492    static FaultName _name;
493    static FaultVect _vect;
494    static FaultStat _count;
495  public:
496    FaultName name() const {return _name;}
497    FaultVect vect() {return _vect;}
498    FaultStat & countStat() {return _count;}
499#if FULL_SYSTEM
500    void invoke(ThreadContext * tc,
501            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
502#endif
503};
504
505class TLBModifiedFault : public MipsFault
506{
507  private:
508    static FaultName _name;
509    static FaultVect _vect;
510    static FaultStat _count;
511  public:
512    FaultName name() const {return _name;}
513    FaultVect vect() {return _vect;}
514    FaultStat & countStat() {return _count;}
515#if FULL_SYSTEM
516    void invoke(ThreadContext * tc,
517            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
518#endif
519};
520
521class DtbInvalidFault : public MipsFault
522{
523  private:
524    static FaultName _name;
525    static FaultVect _vect;
526    static FaultStat _count;
527  public:
528    FaultName name() const {return _name;}
529    FaultVect vect() {return _vect;}
530    FaultStat & countStat() {return _count;}
531#if FULL_SYSTEM
532    void invoke(ThreadContext * tc,
533            StaticInst::StaticInstPtr inst = nullStaticInstPtr);
534#endif
535};
536
537class FloatEnableFault : public MipsFault
538{
539  private:
540    static FaultName _name;
541    static FaultVect _vect;
542    static FaultStat _count;
543  public:
544    FaultName name() const {return _name;}
545    FaultVect vect() {return _vect;}
546    FaultStat & countStat() {return _count;}
547};
548
549class ItbMissFault : public MipsFault
550{
551  private:
552    static FaultName _name;
553    static FaultVect _vect;
554    static FaultStat _count;
555  public:
556    FaultName name() const {return _name;}
557    FaultVect vect() {return _vect;}
558    FaultStat & countStat() {return _count;}
559};
560
561class ItbAcvFault : public MipsFault
562{
563  private:
564    static FaultName _name;
565    static FaultVect _vect;
566    static FaultStat _count;
567  public:
568    FaultName name() const {return _name;}
569    FaultVect vect() {return _vect;}
570    FaultStat & countStat() {return _count;}
571};
572
573class IntegerOverflowFault : public MipsFault
574{
575  private:
576    static FaultName _name;
577    static FaultVect _vect;
578    static FaultStat _count;
579  public:
580    FaultName name() const {return _name;}
581    FaultVect vect() {return _vect;}
582    FaultStat & countStat() {return _count;}
583};
584
585class DspStateDisabledFault : public MipsFault
586{
587  private:
588    static FaultName _name;
589    static FaultVect _vect;
590    static FaultStat _count;
591  public:
592    FaultName name() const {return _name;}
593    FaultVect vect() {return _vect;}
594    FaultStat & countStat() {return _count;}
595    void invoke(ThreadContext * tc,
596            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
597};
598
599} // namespace MipsISA
600
601#endif // __MIPS_FAULTS_HH__
602