faults.hh revision 8563:58cf8f4a7c33 
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
229
230static inline Fault genMachineCheckFault()
231{
232    return new MachineCheckFault;
233}
234
235static inline Fault genAlignmentFault()
236{
237    return new AlignmentFault;
238}
239
240class ResetFault : public MipsFault
241{
242  private:
243    static FaultName _name;
244    static FaultVect _vect;
245    static FaultStat _count;
246  public:
247    FaultName name() const {return _name;}
248    FaultVect vect() {return _vect;}
249    FaultStat & countStat() {return _count;}
250    void invoke(ThreadContext * tc,
251            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
252
253};
254
255class SystemCallFault : public MipsFault
256{
257  private:
258    static FaultName _name;
259    static FaultVect _vect;
260    static FaultStat _count;
261  public:
262    FaultName name() const {return _name;}
263    FaultVect vect() {return _vect;}
264    FaultStat & countStat() {return _count;}
265#if FULL_SYSTEM
266    void invoke(ThreadContext * tc,
267            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
268#endif
269};
270
271class SoftResetFault : public MipsFault
272{
273  private:
274    static FaultName _name;
275    static FaultVect _vect;
276    static FaultStat _count;
277  public:
278    FaultName name() const {return _name;}
279    FaultVect vect() {return _vect;}
280    FaultStat & countStat() {return _count;}
281    void invoke(ThreadContext * tc,
282            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
283};
284
285class DebugSingleStep : public MipsFault
286{
287  private:
288    static FaultName _name;
289    static FaultVect _vect;
290    static FaultStat _count;
291  public:
292    FaultName name() const {return _name;}
293    FaultVect vect() {return _vect;}
294    FaultStat & countStat() {return _count;}
295    void invoke(ThreadContext * tc,
296            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
297};
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            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
311};
312
313class CoprocessorUnusableFault : public MipsFault
314{
315  private:
316    static FaultName _name;
317    static FaultVect _vect;
318    static FaultStat _count;
319    int coProcID;
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    CoprocessorUnusableFault(int _procid){ coProcID = _procid;}
327};
328
329class ReservedInstructionFault : public MipsFault
330{
331  private:
332    static FaultName _name;
333    static FaultVect _vect;
334    static FaultStat _count;
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};
342
343class ThreadFault : public MipsFault
344{
345  private:
346    static FaultName _name;
347    static FaultVect _vect;
348    static FaultStat _count;
349  public:
350    FaultName name() const {return _name;}
351    FaultVect vect() {return _vect;}
352    FaultStat & countStat() {return _count;}
353    void invoke(ThreadContext * tc,
354            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
372#endif
373};
374
375class InterruptFault : public MipsFault
376{
377  protected:
378    bool setRestartAddress() {return false;}
379  private:
380    static FaultName _name;
381    static FaultVect _vect;
382    static FaultStat _count;
383  public:
384    FaultName name() const {return _name;}
385    FaultVect vect() {return _vect;}
386    FaultStat & countStat() {return _count;}
387
388#if FULL_SYSTEM
389    void invoke(ThreadContext * tc,
390            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
391#endif
392};
393
394class TrapFault : public MipsFault
395{
396  private:
397    static FaultName _name;
398    static FaultVect _vect;
399    static FaultStat _count;
400  public:
401    FaultName name() const {return _name;}
402    FaultVect vect() {return _vect;}
403    FaultStat & countStat() {return _count;}
404#if FULL_SYSTEM
405    void invoke(ThreadContext * tc,
406            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
407#endif
408};
409
410class BreakpointFault : public MipsFault
411{
412  private:
413    static FaultName _name;
414    static FaultVect _vect;
415    static FaultStat _count;
416  public:
417    FaultName name() const {return _name;}
418    FaultVect vect() {return _vect;}
419    FaultStat & countStat() {return _count;}
420#if FULL_SYSTEM
421    void invoke(ThreadContext * tc,
422            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
439#endif
440};
441
442class DtbRefillFault : public MipsFault
443{
444  private:
445    static FaultName _name;
446    static FaultVect _vect;
447    static FaultStat _count;
448  public:
449    FaultName name() const {return _name;}
450    FaultVect vect() {return _vect;}
451    FaultStat & countStat() {return _count;}
452#if FULL_SYSTEM
453    void invoke(ThreadContext * tc,
454            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
455#endif
456};
457
458class ItbPageFault : public MipsFault
459{
460  private:
461    static FaultName _name;
462    static FaultVect _vect;
463    static FaultStat _count;
464  public:
465    FaultName name() const {return _name;}
466    FaultVect vect() {return _vect;}
467    FaultStat & countStat() {return _count;}
468#if FULL_SYSTEM
469    void invoke(ThreadContext * tc,
470            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
471#endif
472};
473
474class ItbInvalidFault : public MipsFault
475{
476  private:
477    static FaultName _name;
478    static FaultVect _vect;
479    static FaultStat _count;
480  public:
481    FaultName name() const {return _name;}
482    FaultVect vect() {return _vect;}
483    FaultStat & countStat() {return _count;}
484#if FULL_SYSTEM
485    void invoke(ThreadContext * tc,
486            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
487#endif
488};
489
490class TLBModifiedFault : public MipsFault
491{
492  private:
493    static FaultName _name;
494    static FaultVect _vect;
495    static FaultStat _count;
496  public:
497    FaultName name() const {return _name;}
498    FaultVect vect() {return _vect;}
499    FaultStat & countStat() {return _count;}
500#if FULL_SYSTEM
501    void invoke(ThreadContext * tc,
502            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
503#endif
504};
505
506class DtbInvalidFault : public MipsFault
507{
508  private:
509    static FaultName _name;
510    static FaultVect _vect;
511    static FaultStat _count;
512  public:
513    FaultName name() const {return _name;}
514    FaultVect vect() {return _vect;}
515    FaultStat & countStat() {return _count;}
516#if FULL_SYSTEM
517    void invoke(ThreadContext * tc,
518            StaticInst::StaticInstPtr inst = nullStaticInstPtr);
519#endif
520};
521
522class FloatEnableFault : public MipsFault
523{
524  private:
525    static FaultName _name;
526    static FaultVect _vect;
527    static FaultStat _count;
528  public:
529    FaultName name() const {return _name;}
530    FaultVect vect() {return _vect;}
531    FaultStat & countStat() {return _count;}
532};
533
534class ItbMissFault : public MipsFault
535{
536  private:
537    static FaultName _name;
538    static FaultVect _vect;
539    static FaultStat _count;
540  public:
541    FaultName name() const {return _name;}
542    FaultVect vect() {return _vect;}
543    FaultStat & countStat() {return _count;}
544};
545
546class ItbAcvFault : public MipsFault
547{
548  private:
549    static FaultName _name;
550    static FaultVect _vect;
551    static FaultStat _count;
552  public:
553    FaultName name() const {return _name;}
554    FaultVect vect() {return _vect;}
555    FaultStat & countStat() {return _count;}
556};
557
558class IntegerOverflowFault : public MipsFault
559{
560  private:
561    static FaultName _name;
562    static FaultVect _vect;
563    static FaultStat _count;
564  public:
565    FaultName name() const {return _name;}
566    FaultVect vect() {return _vect;}
567    FaultStat & countStat() {return _count;}
568};
569
570class DspStateDisabledFault : public MipsFault
571{
572  private:
573    static FaultName _name;
574    static FaultVect _vect;
575    static FaultStat _count;
576  public:
577    FaultName name() const {return _name;}
578    FaultVect vect() {return _vect;}
579    FaultStat & countStat() {return _count;}
580    void invoke(ThreadContext * tc,
581            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
582};
583
584} // namespace MipsISA
585
586#endif // __MIPS_FAULTS_HH__
587