faults.hh revision 5268:5bfc53fe60e7 
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
39// The design of the "name" and "vect" functions is in sim/faults.hh
40
41namespace MipsISA
42{
43typedef const Addr FaultVect;
44
45class MipsFault : public FaultBase
46{
47  protected:
48    virtual bool skipFaultingInstruction() {return false;}
49    virtual bool setRestartAddress() {return true;}
50  public:
51    Addr BadVAddr;
52    Addr EntryHi_Asid;
53    Addr EntryHi_VPN2;
54    Addr EntryHi_VPN2X;
55    Addr Context_BadVPN2;
56#if FULL_SYSTEM
57  void invoke(ThreadContext * tc) {};
58  void setExceptionState(ThreadContext *,uint8_t);
59  void setHandlerPC(Addr,ThreadContext *);
60#endif
61    virtual FaultVect vect() = 0;
62    virtual FaultStat & countStat() = 0;
63};
64
65class MachineCheckFault : public MipsFault
66{
67  private:
68    static FaultName _name;
69    static FaultVect _vect;
70    static FaultStat _count;
71  public:
72    FaultName name() const {return _name;}
73    FaultVect vect() {return _vect;}
74    FaultStat & countStat() {return _count;}
75    bool isMachineCheckFault() {return true;}
76};
77
78class NonMaskableInterrupt : public MipsFault
79{
80  private:
81    static FaultName _name;
82    static FaultVect _vect;
83    static FaultStat _count;
84  public:
85    FaultName name() const {return _name;}
86    FaultVect vect() {return _vect;}
87    FaultStat & countStat() {return _count;}
88    bool isNonMaskableInterrupt() {return true;}
89};
90
91class AlignmentFault : public MipsFault
92{
93  private:
94    static FaultName _name;
95    static FaultVect _vect;
96    static FaultStat _count;
97  public:
98    FaultName name() const {return _name;}
99    FaultVect vect() {return _vect;}
100    FaultStat & countStat() {return _count;}
101    bool isAlignmentFault() {return true;}
102};
103
104class AddressErrorFault : public MipsFault
105{
106  private:
107    static FaultName _name;
108    static FaultVect _vect;
109    static FaultStat _count;
110  public:
111    FaultName name() const {return _name;}
112    FaultVect vect() {return _vect;}
113    FaultStat & countStat() {return _count;}
114#if FULL_SYSTEM
115    void invoke(ThreadContext * tc);
116#endif
117
118};
119class StoreAddressErrorFault : public MipsFault
120{
121  private:
122    static FaultName _name;
123    static FaultVect _vect;
124    static FaultStat _count;
125  public:
126    FaultName name() const {return _name;}
127    FaultVect vect() {return _vect;}
128    FaultStat & countStat() {return _count;}
129#if FULL_SYSTEM
130    void invoke(ThreadContext * tc);
131#endif
132
133};
134class UnimplementedOpcodeFault : public MipsFault
135{
136  private:
137    static FaultName _name;
138    static FaultVect _vect;
139    static FaultStat _count;
140  public:
141    FaultName name() const {return _name;}
142    FaultVect vect() {return _vect;}
143    FaultStat & countStat() {return _count;}
144};
145
146
147class TLBRefillIFetchFault : public MipsFault
148{
149  private:
150    Addr vaddr;
151    static FaultName _name;
152    static FaultVect _vect;
153    static FaultStat _count;
154  public:
155    FaultName name() const {return _name;}
156    FaultVect vect() {return _vect;}
157    FaultStat & countStat() {return _count;}
158    void invoke(ThreadContext * tc);
159};
160class TLBInvalidIFetchFault : public MipsFault
161{
162  private:
163    Addr vaddr;
164    static FaultName _name;
165    static FaultVect _vect;
166    static FaultStat _count;
167  public:
168    FaultName name() const {return _name;}
169    FaultVect vect() {return _vect;}
170    FaultStat & countStat() {return _count;}
171    void invoke(ThreadContext * tc);
172};
173
174class NDtbMissFault : public MipsFault
175{
176  private:
177    static FaultName _name;
178    static FaultVect _vect;
179    static FaultStat _count;
180  public:
181    FaultName name() const {return _name;}
182    FaultVect vect() {return _vect;}
183    FaultStat & countStat() {return _count;}
184};
185
186class PDtbMissFault : public MipsFault
187{
188  private:
189    static FaultName _name;
190    static FaultVect _vect;
191    static FaultStat _count;
192  public:
193    FaultName name() const {return _name;}
194    FaultVect vect() {return _vect;}
195    FaultStat & countStat() {return _count;}
196};
197
198class DtbPageFault : public MipsFault
199{
200  private:
201    static FaultName _name;
202    static FaultVect _vect;
203    static FaultStat _count;
204  public:
205    FaultName name() const {return _name;}
206    FaultVect vect() {return _vect;}
207    FaultStat & countStat() {return _count;}
208};
209
210class DtbAcvFault : public MipsFault
211{
212  private:
213    static FaultName _name;
214    static FaultVect _vect;
215    static FaultStat _count;
216  public:
217    FaultName name() const {return _name;}
218    FaultVect vect() {return _vect;}
219    FaultStat & countStat() {return _count;}
220};
221
222class CacheErrorFault : public MipsFault
223{
224  private:
225    Addr vaddr;
226    static FaultName _name;
227    static FaultVect _vect;
228    static FaultStat _count;
229  public:
230    FaultName name() const {return _name;}
231    FaultVect vect() {return _vect;}
232    FaultStat & countStat() {return _count;}
233    void invoke(ThreadContext * tc);
234};
235
236
237
238
239static inline Fault genMachineCheckFault()
240{
241    return new MachineCheckFault;
242}
243
244static inline Fault genAlignmentFault()
245{
246    return new AlignmentFault;
247}
248
249class ResetFault : public MipsFault
250{
251  private:
252    static FaultName _name;
253    static FaultVect _vect;
254    static FaultStat _count;
255  public:
256    FaultName name() const {return _name;}
257    FaultVect vect() {return _vect;}
258    FaultStat & countStat() {return _count;}
259    void invoke(ThreadContext * tc);
260
261};
262class SystemCallFault : public MipsFault
263{
264  private:
265    static FaultName _name;
266    static FaultVect _vect;
267    static FaultStat _count;
268  public:
269    FaultName name() const {return _name;}
270    FaultVect vect() {return _vect;}
271    FaultStat & countStat() {return _count;}
272    void invoke(ThreadContext * tc);
273};
274
275class SoftResetFault : public MipsFault
276{
277  private:
278    static FaultName _name;
279    static FaultVect _vect;
280    static FaultStat _count;
281  public:
282    FaultName name() const {return _name;}
283    FaultVect vect() {return _vect;}
284    FaultStat & countStat() {return _count;}
285    void invoke(ThreadContext * tc);
286};
287class DebugSingleStep : public MipsFault
288{
289  private:
290    static FaultName _name;
291    static FaultVect _vect;
292    static FaultStat _count;
293  public:
294    FaultName name() const {return _name;}
295    FaultVect vect() {return _vect;}
296    FaultStat & countStat() {return _count;}
297    void invoke(ThreadContext * tc);
298};
299class DebugInterrupt : public MipsFault
300{
301  private:
302    static FaultName _name;
303    static FaultVect _vect;
304    static FaultStat _count;
305  public:
306    FaultName name() const {return _name;}
307    FaultVect vect() {return _vect;}
308    FaultStat & countStat() {return _count;}
309    void invoke(ThreadContext * tc);
310};
311
312class CoprocessorUnusableFault : public MipsFault
313{
314  private:
315    static FaultName _name;
316    static FaultVect _vect;
317    static FaultStat _count;
318    int coProcID;
319  public:
320    FaultName name() const {return _name;}
321    FaultVect vect() {return _vect;}
322    FaultStat & countStat() {return _count;}
323    void invoke(ThreadContext * tc);
324    CoprocessorUnusableFault(int _procid){ coProcID = _procid;}
325};
326
327class ReservedInstructionFault : public MipsFault
328{
329  private:
330    static FaultName _name;
331    static FaultVect _vect;
332    static FaultStat _count;
333  public:
334    FaultName name() const {return _name;}
335    FaultVect vect() {return _vect;}
336    FaultStat & countStat() {return _count;}
337    void invoke(ThreadContext * tc);
338};
339
340class ThreadFault : public MipsFault
341{
342  private:
343    static FaultName _name;
344    static FaultVect _vect;
345    static FaultStat _count;
346  public:
347    FaultName name() const {return _name;}
348    FaultVect vect() {return _vect;}
349    FaultStat & countStat() {return _count;}
350    void invoke(ThreadContext * tc);
351};
352
353
354class ArithmeticFault : public MipsFault
355{
356  protected:
357    bool skipFaultingInstruction() {return true;}
358  private:
359    static FaultName _name;
360    static FaultVect _vect;
361    static FaultStat _count;
362  public:
363    FaultName name() const {return _name;}
364    FaultVect vect() {return _vect;}
365    FaultStat & countStat() {return _count;}
366#if FULL_SYSTEM
367    void invoke(ThreadContext * tc);
368#endif
369};
370
371class InterruptFault : public MipsFault
372{
373  protected:
374    bool setRestartAddress() {return false;}
375  private:
376    static FaultName _name;
377    static FaultVect _vect;
378    static FaultStat _count;
379  public:
380    FaultName name() const {return _name;}
381    FaultVect vect() {return _vect;}
382    FaultStat & countStat() {return _count;}
383
384#if FULL_SYSTEM
385    void invoke(ThreadContext * tc);
386#endif
387
388    //void invoke(ThreadContext * tc);
389};
390
391class TrapFault : public MipsFault
392{
393  private:
394    static FaultName _name;
395    static FaultVect _vect;
396    static FaultStat _count;
397  public:
398    FaultName name() const {return _name;}
399    FaultVect vect() {return _vect;}
400    FaultStat & countStat() {return _count;}
401#if FULL_SYSTEM
402    void invoke(ThreadContext * tc);
403#endif
404};
405
406class BreakpointFault : public MipsFault
407{
408  private:
409    static FaultName _name;
410    static FaultVect _vect;
411    static FaultStat _count;
412  public:
413    FaultName name() const {return _name;}
414    FaultVect vect() {return _vect;}
415    FaultStat & countStat() {return _count;}
416#if FULL_SYSTEM
417    void invoke(ThreadContext * tc);
418#endif
419};
420
421class ItbRefillFault : public MipsFault
422{
423  private:
424    static FaultName _name;
425    static FaultVect _vect;
426    static FaultStat _count;
427  public:
428    FaultName name() const {return _name;}
429    FaultVect vect() {return _vect;}
430    FaultStat & countStat() {return _count;}
431#if FULL_SYSTEM
432    void invoke(ThreadContext * tc);
433#endif
434};
435class DtbRefillFault : public MipsFault
436{
437  private:
438    static FaultName _name;
439    static FaultVect _vect;
440    static FaultStat _count;
441  public:
442    FaultName name() const {return _name;}
443    FaultVect vect() {return _vect;}
444    FaultStat & countStat() {return _count;}
445#if FULL_SYSTEM
446    void invoke(ThreadContext * tc);
447#endif
448};
449
450class ItbPageFault : public MipsFault
451{
452  private:
453    static FaultName _name;
454    static FaultVect _vect;
455    static FaultStat _count;
456  public:
457    FaultName name() const {return _name;}
458    FaultVect vect() {return _vect;}
459    FaultStat & countStat() {return _count;}
460#if FULL_SYSTEM
461    void invoke(ThreadContext * tc);
462#endif
463};
464
465class ItbInvalidFault : public MipsFault
466{
467  private:
468    static FaultName _name;
469    static FaultVect _vect;
470    static FaultStat _count;
471  public:
472    FaultName name() const {return _name;}
473    FaultVect vect() {return _vect;}
474    FaultStat & countStat() {return _count;}
475#if FULL_SYSTEM
476    void invoke(ThreadContext * tc);
477#endif
478
479};
480class TLBModifiedFault : public MipsFault
481{
482  private:
483    static FaultName _name;
484    static FaultVect _vect;
485    static FaultStat _count;
486  public:
487    FaultName name() const {return _name;}
488    FaultVect vect() {return _vect;}
489    FaultStat & countStat() {return _count;}
490#if FULL_SYSTEM
491    void invoke(ThreadContext * tc);
492#endif
493
494};
495
496class DtbInvalidFault : public MipsFault
497{
498  private:
499    static FaultName _name;
500    static FaultVect _vect;
501    static FaultStat _count;
502  public:
503    FaultName name() const {return _name;}
504    FaultVect vect() {return _vect;}
505    FaultStat & countStat() {return _count;}
506#if FULL_SYSTEM
507    void invoke(ThreadContext * tc);
508#endif
509
510};
511
512class FloatEnableFault : public MipsFault
513{
514  private:
515    static FaultName _name;
516    static FaultVect _vect;
517    static FaultStat _count;
518  public:
519    FaultName name() const {return _name;}
520    FaultVect vect() {return _vect;}
521    FaultStat & countStat() {return _count;}
522};
523
524class ItbMissFault : public MipsFault
525{
526  private:
527    static FaultName _name;
528    static FaultVect _vect;
529    static FaultStat _count;
530  public:
531    FaultName name() const {return _name;}
532    FaultVect vect() {return _vect;}
533    FaultStat & countStat() {return _count;}
534};
535
536class ItbAcvFault : public MipsFault
537{
538  private:
539    static FaultName _name;
540    static FaultVect _vect;
541    static FaultStat _count;
542  public:
543    FaultName name() const {return _name;}
544    FaultVect vect() {return _vect;}
545    FaultStat & countStat() {return _count;}
546};
547
548class IntegerOverflowFault : public MipsFault
549{
550  private:
551    static FaultName _name;
552    static FaultVect _vect;
553    static FaultStat _count;
554  public:
555    FaultName name() const {return _name;}
556    FaultVect vect() {return _vect;}
557    FaultStat & countStat() {return _count;}
558};
559
560class DspStateDisabledFault : public MipsFault
561{
562  private:
563    static FaultName _name;
564    static FaultVect _vect;
565    static FaultStat _count;
566  public:
567    FaultName name() const {return _name;}
568    FaultVect vect() {return _vect;}
569    FaultStat & countStat() {return _count;}
570    void invoke(ThreadContext * tc);
571};
572
573} // MipsISA namespace
574
575#endif // __MIPS_FAULTS_HH__
576