faults.hh revision 8562:1b0bc57e9cbe 
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    void invoke(ThreadContext * tc,
266            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
267};
268
269class SoftResetFault : public MipsFault
270{
271  private:
272    static FaultName _name;
273    static FaultVect _vect;
274    static FaultStat _count;
275  public:
276    FaultName name() const {return _name;}
277    FaultVect vect() {return _vect;}
278    FaultStat & countStat() {return _count;}
279    void invoke(ThreadContext * tc,
280            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
281};
282
283class DebugSingleStep : public MipsFault
284{
285  private:
286    static FaultName _name;
287    static FaultVect _vect;
288    static FaultStat _count;
289  public:
290    FaultName name() const {return _name;}
291    FaultVect vect() {return _vect;}
292    FaultStat & countStat() {return _count;}
293    void invoke(ThreadContext * tc,
294            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
295};
296
297class DebugInterrupt : public MipsFault
298{
299  private:
300    static FaultName _name;
301    static FaultVect _vect;
302    static FaultStat _count;
303  public:
304    FaultName name() const {return _name;}
305    FaultVect vect() {return _vect;}
306    FaultStat & countStat() {return _count;}
307    void invoke(ThreadContext * tc,
308            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
309};
310
311class CoprocessorUnusableFault : public MipsFault
312{
313  private:
314    static FaultName _name;
315    static FaultVect _vect;
316    static FaultStat _count;
317    int coProcID;
318  public:
319    FaultName name() const {return _name;}
320    FaultVect vect() {return _vect;}
321    FaultStat & countStat() {return _count;}
322    void invoke(ThreadContext * tc,
323            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
339};
340
341class ThreadFault : public MipsFault
342{
343  private:
344    static FaultName _name;
345    static FaultVect _vect;
346    static FaultStat _count;
347  public:
348    FaultName name() const {return _name;}
349    FaultVect vect() {return _vect;}
350    FaultStat & countStat() {return _count;}
351    void invoke(ThreadContext * tc,
352            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
353};
354
355class ArithmeticFault : public MipsFault
356{
357  protected:
358    bool skipFaultingInstruction() {return true;}
359  private:
360    static FaultName _name;
361    static FaultVect _vect;
362    static FaultStat _count;
363  public:
364    FaultName name() const {return _name;}
365    FaultVect vect() {return _vect;}
366    FaultStat & countStat() {return _count;}
367#if FULL_SYSTEM
368    void invoke(ThreadContext * tc,
369            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
370#endif
371};
372
373class InterruptFault : public MipsFault
374{
375  protected:
376    bool setRestartAddress() {return false;}
377  private:
378    static FaultName _name;
379    static FaultVect _vect;
380    static FaultStat _count;
381  public:
382    FaultName name() const {return _name;}
383    FaultVect vect() {return _vect;}
384    FaultStat & countStat() {return _count;}
385
386#if FULL_SYSTEM
387    void invoke(ThreadContext * tc,
388            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
405#endif
406};
407
408class BreakpointFault : public MipsFault
409{
410  private:
411    static FaultName _name;
412    static FaultVect _vect;
413    static FaultStat _count;
414  public:
415    FaultName name() const {return _name;}
416    FaultVect vect() {return _vect;}
417    FaultStat & countStat() {return _count;}
418#if FULL_SYSTEM
419    void invoke(ThreadContext * tc,
420            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
421#endif
422};
423
424class ItbRefillFault : public MipsFault
425{
426  private:
427    static FaultName _name;
428    static FaultVect _vect;
429    static FaultStat _count;
430  public:
431    FaultName name() const {return _name;}
432    FaultVect vect() {return _vect;}
433    FaultStat & countStat() {return _count;}
434#if FULL_SYSTEM
435    void invoke(ThreadContext * tc,
436            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
437#endif
438};
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            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
453#endif
454};
455
456class ItbPageFault : public MipsFault
457{
458  private:
459    static FaultName _name;
460    static FaultVect _vect;
461    static FaultStat _count;
462  public:
463    FaultName name() const {return _name;}
464    FaultVect vect() {return _vect;}
465    FaultStat & countStat() {return _count;}
466#if FULL_SYSTEM
467    void invoke(ThreadContext * tc,
468            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
469#endif
470};
471
472class ItbInvalidFault : public MipsFault
473{
474  private:
475    static FaultName _name;
476    static FaultVect _vect;
477    static FaultStat _count;
478  public:
479    FaultName name() const {return _name;}
480    FaultVect vect() {return _vect;}
481    FaultStat & countStat() {return _count;}
482#if FULL_SYSTEM
483    void invoke(ThreadContext * tc,
484            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
485#endif
486};
487
488class TLBModifiedFault : public MipsFault
489{
490  private:
491    static FaultName _name;
492    static FaultVect _vect;
493    static FaultStat _count;
494  public:
495    FaultName name() const {return _name;}
496    FaultVect vect() {return _vect;}
497    FaultStat & countStat() {return _count;}
498#if FULL_SYSTEM
499    void invoke(ThreadContext * tc,
500            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
501#endif
502};
503
504class DtbInvalidFault : public MipsFault
505{
506  private:
507    static FaultName _name;
508    static FaultVect _vect;
509    static FaultStat _count;
510  public:
511    FaultName name() const {return _name;}
512    FaultVect vect() {return _vect;}
513    FaultStat & countStat() {return _count;}
514#if FULL_SYSTEM
515    void invoke(ThreadContext * tc,
516            StaticInst::StaticInstPtr inst = nullStaticInstPtr);
517#endif
518};
519
520class FloatEnableFault : public MipsFault
521{
522  private:
523    static FaultName _name;
524    static FaultVect _vect;
525    static FaultStat _count;
526  public:
527    FaultName name() const {return _name;}
528    FaultVect vect() {return _vect;}
529    FaultStat & countStat() {return _count;}
530};
531
532class ItbMissFault : public MipsFault
533{
534  private:
535    static FaultName _name;
536    static FaultVect _vect;
537    static FaultStat _count;
538  public:
539    FaultName name() const {return _name;}
540    FaultVect vect() {return _vect;}
541    FaultStat & countStat() {return _count;}
542};
543
544class ItbAcvFault : public MipsFault
545{
546  private:
547    static FaultName _name;
548    static FaultVect _vect;
549    static FaultStat _count;
550  public:
551    FaultName name() const {return _name;}
552    FaultVect vect() {return _vect;}
553    FaultStat & countStat() {return _count;}
554};
555
556class IntegerOverflowFault : public MipsFault
557{
558  private:
559    static FaultName _name;
560    static FaultVect _vect;
561    static FaultStat _count;
562  public:
563    FaultName name() const {return _name;}
564    FaultVect vect() {return _vect;}
565    FaultStat & countStat() {return _count;}
566};
567
568class DspStateDisabledFault : public MipsFault
569{
570  private:
571    static FaultName _name;
572    static FaultVect _vect;
573    static FaultStat _count;
574  public:
575    FaultName name() const {return _name;}
576    FaultVect vect() {return _vect;}
577    FaultStat & countStat() {return _count;}
578    void invoke(ThreadContext * tc,
579            StaticInstPtr inst = StaticInst::nullStaticInstPtr);
580};
581
582} // namespace MipsISA
583
584#endif // __MIPS_FAULTS_HH__
585