faults.hh revision 5224:0e354459fb8a 
1/*
2 * Copyright (c) 2007 MIPS Technologies, Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * Authors: Gabe Black
29 *          Korey Sewell
30 *          Jaidev Patwardhan
31 */
32
33#ifndef __MIPS_FAULTS_HH__
34#define __MIPS_FAULTS_HH__
35
36#include "sim/faults.hh"
37
38// The design of the "name" and "vect" functions is in sim/faults.hh
39
40namespace MipsISA
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};
118class StoreAddressErrorFault : public MipsFault
119{
120  private:
121    static FaultName _name;
122    static FaultVect _vect;
123    static FaultStat _count;
124  public:
125    FaultName name() const {return _name;}
126    FaultVect vect() {return _vect;}
127    FaultStat & countStat() {return _count;}
128#if FULL_SYSTEM
129    void invoke(ThreadContext * tc);
130#endif
131
132};
133class UnimplementedOpcodeFault : public MipsFault
134{
135  private:
136    static FaultName _name;
137    static FaultVect _vect;
138    static FaultStat _count;
139  public:
140    FaultName name() const {return _name;}
141    FaultVect vect() {return _vect;}
142    FaultStat & countStat() {return _count;}
143};
144
145
146class TLBRefillIFetchFault : public MipsFault
147{
148  private:
149    Addr vaddr;
150    static FaultName _name;
151    static FaultVect _vect;
152    static FaultStat _count;
153  public:
154    FaultName name() const {return _name;}
155    FaultVect vect() {return _vect;}
156    FaultStat & countStat() {return _count;}
157    void invoke(ThreadContext * tc);
158};
159class TLBInvalidIFetchFault : public MipsFault
160{
161  private:
162    Addr vaddr;
163    static FaultName _name;
164    static FaultVect _vect;
165    static FaultStat _count;
166  public:
167    FaultName name() const {return _name;}
168    FaultVect vect() {return _vect;}
169    FaultStat & countStat() {return _count;}
170    void invoke(ThreadContext * tc);
171};
172
173class NDtbMissFault : public MipsFault
174{
175  private:
176    static FaultName _name;
177    static FaultVect _vect;
178    static FaultStat _count;
179  public:
180    FaultName name() const {return _name;}
181    FaultVect vect() {return _vect;}
182    FaultStat & countStat() {return _count;}
183};
184
185class PDtbMissFault : public MipsFault
186{
187  private:
188    static FaultName _name;
189    static FaultVect _vect;
190    static FaultStat _count;
191  public:
192    FaultName name() const {return _name;}
193    FaultVect vect() {return _vect;}
194    FaultStat & countStat() {return _count;}
195};
196
197class DtbPageFault : public MipsFault
198{
199  private:
200    static FaultName _name;
201    static FaultVect _vect;
202    static FaultStat _count;
203  public:
204    FaultName name() const {return _name;}
205    FaultVect vect() {return _vect;}
206    FaultStat & countStat() {return _count;}
207};
208
209class DtbAcvFault : public MipsFault
210{
211  private:
212    static FaultName _name;
213    static FaultVect _vect;
214    static FaultStat _count;
215  public:
216    FaultName name() const {return _name;}
217    FaultVect vect() {return _vect;}
218    FaultStat & countStat() {return _count;}
219};
220
221class CacheErrorFault : public MipsFault
222{
223  private:
224    Addr vaddr;
225    static FaultName _name;
226    static FaultVect _vect;
227    static FaultStat _count;
228  public:
229    FaultName name() const {return _name;}
230    FaultVect vect() {return _vect;}
231    FaultStat & countStat() {return _count;}
232    void invoke(ThreadContext * tc);
233};
234
235
236
237
238static inline Fault genMachineCheckFault()
239{
240    return new MachineCheckFault;
241}
242
243static inline Fault genAlignmentFault()
244{
245    return new AlignmentFault;
246}
247
248class ResetFault : public MipsFault
249{
250  private:
251    static FaultName _name;
252    static FaultVect _vect;
253    static FaultStat _count;
254  public:
255    FaultName name() const {return _name;}
256    FaultVect vect() {return _vect;}
257    FaultStat & countStat() {return _count;}
258    void invoke(ThreadContext * tc);
259
260};
261class SystemCallFault : public MipsFault
262{
263  private:
264    static FaultName _name;
265    static FaultVect _vect;
266    static FaultStat _count;
267  public:
268    FaultName name() const {return _name;}
269    FaultVect vect() {return _vect;}
270    FaultStat & countStat() {return _count;}
271    void invoke(ThreadContext * tc);
272};
273
274class SoftResetFault : public MipsFault
275{
276  private:
277    static FaultName _name;
278    static FaultVect _vect;
279    static FaultStat _count;
280  public:
281    FaultName name() const {return _name;}
282    FaultVect vect() {return _vect;}
283    FaultStat & countStat() {return _count;}
284    void invoke(ThreadContext * tc);
285};
286class DebugSingleStep : 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};
298class DebugInterrupt : public MipsFault
299{
300  private:
301    static FaultName _name;
302    static FaultVect _vect;
303    static FaultStat _count;
304  public:
305    FaultName name() const {return _name;}
306    FaultVect vect() {return _vect;}
307    FaultStat & countStat() {return _count;}
308    void invoke(ThreadContext * tc);
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    CoprocessorUnusableFault(int _procid){ coProcID = _procid;}
324};
325
326class ReservedInstructionFault : public MipsFault
327{
328  private:
329    static FaultName _name;
330    static FaultVect _vect;
331    static FaultStat _count;
332  public:
333    FaultName name() const {return _name;}
334    FaultVect vect() {return _vect;}
335    FaultStat & countStat() {return _count;}
336    void invoke(ThreadContext * tc);
337};
338
339class ThreadFault : public MipsFault
340{
341  private:
342    static FaultName _name;
343    static FaultVect _vect;
344    static FaultStat _count;
345  public:
346    FaultName name() const {return _name;}
347    FaultVect vect() {return _vect;}
348    FaultStat & countStat() {return _count;}
349    void invoke(ThreadContext * tc);
350};
351
352
353class ArithmeticFault : public MipsFault
354{
355  protected:
356    bool skipFaultingInstruction() {return true;}
357  private:
358    static FaultName _name;
359    static FaultVect _vect;
360    static FaultStat _count;
361  public:
362    FaultName name() const {return _name;}
363    FaultVect vect() {return _vect;}
364    FaultStat & countStat() {return _count;}
365#if FULL_SYSTEM
366    void invoke(ThreadContext * tc);
367#endif
368};
369
370class InterruptFault : public MipsFault
371{
372  protected:
373    bool setRestartAddress() {return false;}
374  private:
375    static FaultName _name;
376    static FaultVect _vect;
377    static FaultStat _count;
378  public:
379    FaultName name() const {return _name;}
380    FaultVect vect() {return _vect;}
381    FaultStat & countStat() {return _count;}
382
383#if FULL_SYSTEM
384    void invoke(ThreadContext * tc);
385#endif
386
387    //void invoke(ThreadContext * tc);
388};
389
390class TrapFault : public MipsFault
391{
392  private:
393    static FaultName _name;
394    static FaultVect _vect;
395    static FaultStat _count;
396  public:
397    FaultName name() const {return _name;}
398    FaultVect vect() {return _vect;}
399    FaultStat & countStat() {return _count;}
400#if FULL_SYSTEM
401    void invoke(ThreadContext * tc);
402#endif
403};
404
405class BreakpointFault : public MipsFault
406{
407  private:
408    static FaultName _name;
409    static FaultVect _vect;
410    static FaultStat _count;
411  public:
412    FaultName name() const {return _name;}
413    FaultVect vect() {return _vect;}
414    FaultStat & countStat() {return _count;}
415#if FULL_SYSTEM
416    void invoke(ThreadContext * tc);
417#endif
418};
419
420class ItbRefillFault : public MipsFault
421{
422  private:
423    static FaultName _name;
424    static FaultVect _vect;
425    static FaultStat _count;
426  public:
427    FaultName name() const {return _name;}
428    FaultVect vect() {return _vect;}
429    FaultStat & countStat() {return _count;}
430#if FULL_SYSTEM
431    void invoke(ThreadContext * tc);
432#endif
433};
434class DtbRefillFault : public MipsFault
435{
436  private:
437    static FaultName _name;
438    static FaultVect _vect;
439    static FaultStat _count;
440  public:
441    FaultName name() const {return _name;}
442    FaultVect vect() {return _vect;}
443    FaultStat & countStat() {return _count;}
444#if FULL_SYSTEM
445    void invoke(ThreadContext * tc);
446#endif
447};
448
449class ItbPageFault : public MipsFault
450{
451  private:
452    static FaultName _name;
453    static FaultVect _vect;
454    static FaultStat _count;
455  public:
456    FaultName name() const {return _name;}
457    FaultVect vect() {return _vect;}
458    FaultStat & countStat() {return _count;}
459#if FULL_SYSTEM
460    void invoke(ThreadContext * tc);
461#endif
462};
463
464class ItbInvalidFault : public MipsFault
465{
466  private:
467    static FaultName _name;
468    static FaultVect _vect;
469    static FaultStat _count;
470  public:
471    FaultName name() const {return _name;}
472    FaultVect vect() {return _vect;}
473    FaultStat & countStat() {return _count;}
474#if FULL_SYSTEM
475    void invoke(ThreadContext * tc);
476#endif
477
478};
479class TLBModifiedFault : public MipsFault
480{
481  private:
482    static FaultName _name;
483    static FaultVect _vect;
484    static FaultStat _count;
485  public:
486    FaultName name() const {return _name;}
487    FaultVect vect() {return _vect;}
488    FaultStat & countStat() {return _count;}
489#if FULL_SYSTEM
490    void invoke(ThreadContext * tc);
491#endif
492
493};
494
495class DtbInvalidFault : public MipsFault
496{
497  private:
498    static FaultName _name;
499    static FaultVect _vect;
500    static FaultStat _count;
501  public:
502    FaultName name() const {return _name;}
503    FaultVect vect() {return _vect;}
504    FaultStat & countStat() {return _count;}
505#if FULL_SYSTEM
506    void invoke(ThreadContext * tc);
507#endif
508
509};
510
511class FloatEnableFault : public MipsFault
512{
513  private:
514    static FaultName _name;
515    static FaultVect _vect;
516    static FaultStat _count;
517  public:
518    FaultName name() const {return _name;}
519    FaultVect vect() {return _vect;}
520    FaultStat & countStat() {return _count;}
521};
522
523class ItbMissFault : public MipsFault
524{
525  private:
526    static FaultName _name;
527    static FaultVect _vect;
528    static FaultStat _count;
529  public:
530    FaultName name() const {return _name;}
531    FaultVect vect() {return _vect;}
532    FaultStat & countStat() {return _count;}
533};
534
535class ItbAcvFault : public MipsFault
536{
537  private:
538    static FaultName _name;
539    static FaultVect _vect;
540    static FaultStat _count;
541  public:
542    FaultName name() const {return _name;}
543    FaultVect vect() {return _vect;}
544    FaultStat & countStat() {return _count;}
545};
546
547class IntegerOverflowFault : public MipsFault
548{
549  private:
550    static FaultName _name;
551    static FaultVect _vect;
552    static FaultStat _count;
553  public:
554    FaultName name() const {return _name;}
555    FaultVect vect() {return _vect;}
556    FaultStat & countStat() {return _count;}
557};
558
559class DspStateDisabledFault : public MipsFault
560{
561  private:
562    static FaultName _name;
563    static FaultVect _vect;
564    static FaultStat _count;
565  public:
566    FaultName name() const {return _name;}
567    FaultVect vect() {return _vect;}
568    FaultStat & countStat() {return _count;}
569    void invoke(ThreadContext * tc);
570};
571
572} // MipsISA namespace
573
574#endif // __MIPS_FAULTS_HH__
575