faults.hh revision 6378:4a2ff62c3b4f 
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 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};
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};
160
161class TLBInvalidIFetchFault : public MipsFault
162{
163  private:
164    Addr vaddr;
165    static FaultName _name;
166    static FaultVect _vect;
167    static FaultStat _count;
168  public:
169    FaultName name() const {return _name;}
170    FaultVect vect() {return _vect;}
171    FaultStat & countStat() {return _count;}
172    void invoke(ThreadContext * tc);
173};
174
175class NDtbMissFault : public MipsFault
176{
177  private:
178    static FaultName _name;
179    static FaultVect _vect;
180    static FaultStat _count;
181  public:
182    FaultName name() const {return _name;}
183    FaultVect vect() {return _vect;}
184    FaultStat & countStat() {return _count;}
185};
186
187class PDtbMissFault : public MipsFault
188{
189  private:
190    static FaultName _name;
191    static FaultVect _vect;
192    static FaultStat _count;
193  public:
194    FaultName name() const {return _name;}
195    FaultVect vect() {return _vect;}
196    FaultStat & countStat() {return _count;}
197};
198
199class DtbPageFault : public MipsFault
200{
201  private:
202    static FaultName _name;
203    static FaultVect _vect;
204    static FaultStat _count;
205  public:
206    FaultName name() const {return _name;}
207    FaultVect vect() {return _vect;}
208    FaultStat & countStat() {return _count;}
209};
210
211class DtbAcvFault : public MipsFault
212{
213  private:
214    static FaultName _name;
215    static FaultVect _vect;
216    static FaultStat _count;
217  public:
218    FaultName name() const {return _name;}
219    FaultVect vect() {return _vect;}
220    FaultStat & countStat() {return _count;}
221};
222
223class CacheErrorFault : public MipsFault
224{
225  private:
226    Addr vaddr;
227    static FaultName _name;
228    static FaultVect _vect;
229    static FaultStat _count;
230  public:
231    FaultName name() const {return _name;}
232    FaultVect vect() {return _vect;}
233    FaultStat & countStat() {return _count;}
234    void invoke(ThreadContext * tc);
235};
236
237
238
239
240static inline Fault genMachineCheckFault()
241{
242    return new MachineCheckFault;
243}
244
245static inline Fault genAlignmentFault()
246{
247    return new AlignmentFault;
248}
249
250class ResetFault : public MipsFault
251{
252  private:
253    static FaultName _name;
254    static FaultVect _vect;
255    static FaultStat _count;
256  public:
257    FaultName name() const {return _name;}
258    FaultVect vect() {return _vect;}
259    FaultStat & countStat() {return _count;}
260    void invoke(ThreadContext * tc);
261
262};
263
264class SystemCallFault : public MipsFault
265{
266  private:
267    static FaultName _name;
268    static FaultVect _vect;
269    static FaultStat _count;
270  public:
271    FaultName name() const {return _name;}
272    FaultVect vect() {return _vect;}
273    FaultStat & countStat() {return _count;}
274    void invoke(ThreadContext * tc);
275};
276
277class SoftResetFault : public MipsFault
278{
279  private:
280    static FaultName _name;
281    static FaultVect _vect;
282    static FaultStat _count;
283  public:
284    FaultName name() const {return _name;}
285    FaultVect vect() {return _vect;}
286    FaultStat & countStat() {return _count;}
287    void invoke(ThreadContext * tc);
288};
289
290class DebugSingleStep : public MipsFault
291{
292  private:
293    static FaultName _name;
294    static FaultVect _vect;
295    static FaultStat _count;
296  public:
297    FaultName name() const {return _name;}
298    FaultVect vect() {return _vect;}
299    FaultStat & countStat() {return _count;}
300    void invoke(ThreadContext * tc);
301};
302
303class DebugInterrupt : public MipsFault
304{
305  private:
306    static FaultName _name;
307    static FaultVect _vect;
308    static FaultStat _count;
309  public:
310    FaultName name() const {return _name;}
311    FaultVect vect() {return _vect;}
312    FaultStat & countStat() {return _count;}
313    void invoke(ThreadContext * tc);
314};
315
316class CoprocessorUnusableFault : public MipsFault
317{
318  private:
319    static FaultName _name;
320    static FaultVect _vect;
321    static FaultStat _count;
322    int coProcID;
323  public:
324    FaultName name() const {return _name;}
325    FaultVect vect() {return _vect;}
326    FaultStat & countStat() {return _count;}
327    void invoke(ThreadContext * tc);
328    CoprocessorUnusableFault(int _procid){ coProcID = _procid;}
329};
330
331class ReservedInstructionFault : public MipsFault
332{
333  private:
334    static FaultName _name;
335    static FaultVect _vect;
336    static FaultStat _count;
337  public:
338    FaultName name() const {return _name;}
339    FaultVect vect() {return _vect;}
340    FaultStat & countStat() {return _count;}
341    void invoke(ThreadContext * tc);
342};
343
344class ThreadFault : 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};
356
357class ArithmeticFault : public MipsFault
358{
359  protected:
360    bool skipFaultingInstruction() {return true;}
361  private:
362    static FaultName _name;
363    static FaultVect _vect;
364    static FaultStat _count;
365  public:
366    FaultName name() const {return _name;}
367    FaultVect vect() {return _vect;}
368    FaultStat & countStat() {return _count;}
369#if FULL_SYSTEM
370    void invoke(ThreadContext * tc);
371#endif
372};
373
374class InterruptFault : public MipsFault
375{
376  protected:
377    bool setRestartAddress() {return false;}
378  private:
379    static FaultName _name;
380    static FaultVect _vect;
381    static FaultStat _count;
382  public:
383    FaultName name() const {return _name;}
384    FaultVect vect() {return _vect;}
385    FaultStat & countStat() {return _count;}
386
387#if FULL_SYSTEM
388    void invoke(ThreadContext * tc);
389#endif
390};
391
392class TrapFault : public MipsFault
393{
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#if FULL_SYSTEM
403    void invoke(ThreadContext * tc);
404#endif
405};
406
407class BreakpointFault : public MipsFault
408{
409  private:
410    static FaultName _name;
411    static FaultVect _vect;
412    static FaultStat _count;
413  public:
414    FaultName name() const {return _name;}
415    FaultVect vect() {return _vect;}
416    FaultStat & countStat() {return _count;}
417#if FULL_SYSTEM
418    void invoke(ThreadContext * tc);
419#endif
420};
421
422class ItbRefillFault : public MipsFault
423{
424  private:
425    static FaultName _name;
426    static FaultVect _vect;
427    static FaultStat _count;
428  public:
429    FaultName name() const {return _name;}
430    FaultVect vect() {return _vect;}
431    FaultStat & countStat() {return _count;}
432#if FULL_SYSTEM
433    void invoke(ThreadContext * tc);
434#endif
435};
436
437class DtbRefillFault : public MipsFault
438{
439  private:
440    static FaultName _name;
441    static FaultVect _vect;
442    static FaultStat _count;
443  public:
444    FaultName name() const {return _name;}
445    FaultVect vect() {return _vect;}
446    FaultStat & countStat() {return _count;}
447#if FULL_SYSTEM
448    void invoke(ThreadContext * tc);
449#endif
450};
451
452class ItbPageFault : public MipsFault
453{
454  private:
455    static FaultName _name;
456    static FaultVect _vect;
457    static FaultStat _count;
458  public:
459    FaultName name() const {return _name;}
460    FaultVect vect() {return _vect;}
461    FaultStat & countStat() {return _count;}
462#if FULL_SYSTEM
463    void invoke(ThreadContext * tc);
464#endif
465};
466
467class ItbInvalidFault : public MipsFault
468{
469  private:
470    static FaultName _name;
471    static FaultVect _vect;
472    static FaultStat _count;
473  public:
474    FaultName name() const {return _name;}
475    FaultVect vect() {return _vect;}
476    FaultStat & countStat() {return _count;}
477#if FULL_SYSTEM
478    void invoke(ThreadContext * tc);
479#endif
480};
481
482class TLBModifiedFault : public MipsFault
483{
484  private:
485    static FaultName _name;
486    static FaultVect _vect;
487    static FaultStat _count;
488  public:
489    FaultName name() const {return _name;}
490    FaultVect vect() {return _vect;}
491    FaultStat & countStat() {return _count;}
492#if FULL_SYSTEM
493    void invoke(ThreadContext * tc);
494#endif
495};
496
497class DtbInvalidFault : public MipsFault
498{
499  private:
500    static FaultName _name;
501    static FaultVect _vect;
502    static FaultStat _count;
503  public:
504    FaultName name() const {return _name;}
505    FaultVect vect() {return _vect;}
506    FaultStat & countStat() {return _count;}
507#if FULL_SYSTEM
508    void invoke(ThreadContext * tc);
509#endif
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