faults.hh revision 2800 
1/*
2 * Copyright (c) 2003-2005 The Regents of The University of Michigan
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 *          Kevin Lim
30 */
31
32#ifndef __ALPHA_FAULTS_HH__
33#define __ALPHA_FAULTS_HH__
34
35#include "sim/faults.hh"
36
37// The design of the "name" and "vect" functions is in sim/faults.hh
38
39namespace SparcISA
40{
41
42typedef const uint32_t TrapType;
43typedef const uint32_t FaultPriority;
44
45class SparcFault : public FaultBase
46{
47  public:
48#if FULL_SYSTEM
49    void invoke(ThreadContext * tc);
50#endif
51    virtual TrapType trapType() = 0;
52    virtual FaultPriority priority() = 0;
53    virtual FaultStat & countStat() = 0;
54};
55
56class InternalProcessorError : public SparcFault
57{
58  private:
59    static FaultName _name;
60    static TrapType _trapType;
61    static FaultPriority _priority;
62    static FaultStat _count;
63  public:
64    FaultName name() {return _name;}
65    TrapType trapType() {return _trapType;}
66    FaultPriority priority() {return _priority;}
67    FaultStat & countStat() {return _count;}
68    bool isMachineCheckFault() {return true;}
69};
70
71class MemAddressNotAligned : public SparcFault
72{
73  private:
74    static FaultName _name;
75    static TrapType _trapType;
76    static FaultPriority _priority;
77    static FaultStat _count;
78  public:
79    FaultName name() {return _name;}
80    TrapType trapType() {return _trapType;}
81    FaultPriority priority() {return _priority;}
82    FaultStat & countStat() {return _count;}
83    bool isAlignmentFault() {return true;}
84};
85
86#if !FULL_SYSTEM
87class PageTableFault : public SparcFault
88{
89  private:
90    Addr vaddr;
91    static FaultName _name;
92    static TrapType _trapType;
93    static FaultPriority _priority;
94    static FaultStat _count;
95  public:
96    PageTableFault(Addr va)
97        : vaddr(va) {}
98    FaultName name() {return _name;}
99    TrapType trapType() {return _trapType;}
100    FaultPriority priority() {return _priority;}
101    FaultStat & countStat() {return _count;}
102    void invoke(ThreadContext * tc);
103};
104
105static inline Fault genPageTableFault(Addr va)
106{
107    return new PageTableFault(va);
108}
109#endif
110
111static inline Fault genMachineCheckFault()
112{
113    return new InternalProcessorError;
114}
115
116static inline Fault genAlignmentFault()
117{
118    return new MemAddressNotAligned;
119}
120
121class PowerOnReset : public SparcFault
122{
123  private:
124    static FaultName _name;
125    static TrapType _trapType;
126    static FaultPriority _priority;
127    static FaultStat _count;
128  public:
129    FaultName name() {return _name;}
130    TrapType trapType() {return _trapType;}
131    FaultPriority priority() {return _priority;}
132    FaultStat & countStat() {return _count;}
133};
134
135class WatchDogReset : public SparcFault
136{
137  private:
138    static FaultName _name;
139    static TrapType _trapType;
140    static FaultPriority _priority;
141    static FaultStat _count;
142  public:
143    FaultName name() {return _name;}
144    TrapType trapType() {return _trapType;}
145    FaultPriority priority() {return _priority;}
146    FaultStat & countStat() {return _count;}
147};
148
149class ExternallyInitiatedReset : public SparcFault
150{
151  private:
152    static FaultName _name;
153    static TrapType _trapType;
154    static FaultPriority _priority;
155    static FaultStat _count;
156  public:
157    FaultName name() {return _name;}
158    TrapType trapType() {return _trapType;}
159    FaultPriority priority() {return _priority;}
160    FaultStat & countStat() {return _count;}
161};
162
163class SoftwareInitiatedReset : public SparcFault
164{
165  private:
166    static FaultName _name;
167    static TrapType _trapType;
168    static FaultPriority _priority;
169    static FaultStat _count;
170  public:
171    FaultName name() {return _name;}
172    TrapType trapType() {return _trapType;}
173    FaultPriority priority() {return _priority;}
174    FaultStat & countStat() {return _count;}
175};
176
177class REDStateException : public SparcFault
178{
179  private:
180    static FaultName _name;
181    static TrapType _trapType;
182    static FaultPriority _priority;
183    static FaultStat _count;
184  public:
185    FaultName name() {return _name;}
186    TrapType trapType() {return _trapType;}
187    FaultPriority priority() {return _priority;}
188    FaultStat & countStat() {return _count;}
189};
190
191class InstructionAccessException : public SparcFault
192{
193  private:
194    static FaultName _name;
195    static TrapType _trapType;
196    static FaultPriority _priority;
197    static FaultStat _count;
198  public:
199    FaultName name() {return _name;}
200    TrapType trapType() {return _trapType;}
201    FaultPriority priority() {return _priority;}
202    FaultStat & countStat() {return _count;}
203};
204
205class InstructionAccessMMUMiss : public SparcFault
206{
207  private:
208    static FaultName _name;
209    static TrapType _trapType;
210    static FaultPriority _priority;
211    static FaultStat _count;
212  public:
213    FaultName name() {return _name;}
214    TrapType trapType() {return _trapType;}
215    FaultPriority priority() {return _priority;}
216    FaultStat & countStat() {return _count;}
217};
218
219class InstructionAccessError : public SparcFault
220{
221  private:
222    static FaultName _name;
223    static TrapType _trapType;
224    static FaultPriority _priority;
225    static FaultStat _count;
226  public:
227    FaultName name() {return _name;}
228    TrapType trapType() {return _trapType;}
229    FaultPriority priority() {return _priority;}
230    FaultStat & countStat() {return _count;}
231};
232
233class IllegalInstruction : public SparcFault
234{
235  private:
236    static FaultName _name;
237    static TrapType _trapType;
238    static FaultPriority _priority;
239    static FaultStat _count;
240  public:
241    FaultName name() {return _name;}
242    TrapType trapType() {return _trapType;}
243    FaultPriority priority() {return _priority;}
244    FaultStat & countStat() {return _count;}
245};
246
247class PrivilegedOpcode : public SparcFault
248{
249  private:
250    static FaultName _name;
251    static TrapType _trapType;
252    static FaultPriority _priority;
253    static FaultStat _count;
254  public:
255    FaultName name() {return _name;}
256    TrapType trapType() {return _trapType;}
257    FaultPriority priority() {return _priority;}
258    FaultStat & countStat() {return _count;}
259};
260
261class UnimplementedLDD : public SparcFault
262{
263  private:
264    static FaultName _name;
265    static TrapType _trapType;
266    static FaultPriority _priority;
267    static FaultStat _count;
268  public:
269    FaultName name() {return _name;}
270    TrapType trapType() {return _trapType;}
271    FaultPriority priority() {return _priority;}
272    FaultStat & countStat() {return _count;}
273};
274
275class UnimplementedSTD : public SparcFault
276{
277  private:
278    static FaultName _name;
279    static TrapType _trapType;
280    static FaultPriority _priority;
281    static FaultStat _count;
282  public:
283    FaultName name() {return _name;}
284    TrapType trapType() {return _trapType;}
285    FaultPriority priority() {return _priority;}
286    FaultStat & countStat() {return _count;}
287};
288
289class FpDisabled : public SparcFault
290{
291  private:
292    static FaultName _name;
293    static TrapType _trapType;
294    static FaultPriority _priority;
295    static FaultStat _count;
296  public:
297    FaultName name() {return _name;}
298    TrapType trapType() {return _trapType;}
299    FaultPriority priority() {return _priority;}
300    FaultStat & countStat() {return _count;}
301};
302
303class FpExceptionIEEE754 : public SparcFault
304{
305  private:
306    static FaultName _name;
307    static TrapType _trapType;
308    static FaultPriority _priority;
309    static FaultStat _count;
310  public:
311    FaultName name() {return _name;}
312    TrapType trapType() {return _trapType;}
313    FaultPriority priority() {return _priority;}
314    FaultStat & countStat() {return _count;}
315};
316
317class FpExceptionOther : public SparcFault
318{
319  private:
320    static FaultName _name;
321    static TrapType _trapType;
322    static FaultPriority _priority;
323    static FaultStat _count;
324  public:
325    FaultName name() {return _name;}
326    TrapType trapType() {return _trapType;}
327    FaultPriority priority() {return _priority;}
328    FaultStat & countStat() {return _count;}
329};
330
331class TagOverflow : public SparcFault
332{
333  private:
334    static FaultName _name;
335    static TrapType _trapType;
336    static FaultPriority _priority;
337    static FaultStat _count;
338  public:
339    FaultName name() {return _name;}
340    TrapType trapType() {return _trapType;}
341    FaultPriority priority() {return _priority;}
342    FaultStat & countStat() {return _count;}
343};
344
345class DivisionByZero : public SparcFault
346{
347  private:
348    static FaultName _name;
349    static TrapType _trapType;
350    static FaultPriority _priority;
351    static FaultStat _count;
352  public:
353    FaultName name() {return _name;}
354    TrapType trapType() {return _trapType;}
355    FaultPriority priority() {return _priority;}
356    FaultStat & countStat() {return _count;}
357};
358
359class DataAccessException : public SparcFault
360{
361  private:
362    static FaultName _name;
363    static TrapType _trapType;
364    static FaultPriority _priority;
365    static FaultStat _count;
366  public:
367    FaultName name() {return _name;}
368    TrapType trapType() {return _trapType;}
369    FaultPriority priority() {return _priority;}
370    FaultStat & countStat() {return _count;}
371};
372
373class DataAccessMMUMiss : public SparcFault
374{
375  private:
376    static FaultName _name;
377    static TrapType _trapType;
378    static FaultPriority _priority;
379    static FaultStat _count;
380  public:
381    FaultName name() {return _name;}
382    TrapType trapType() {return _trapType;}
383    FaultPriority priority() {return _priority;}
384    FaultStat & countStat() {return _count;}
385};
386
387class DataAccessError : public SparcFault
388{
389  private:
390    static FaultName _name;
391    static TrapType _trapType;
392    static FaultPriority _priority;
393    static FaultStat _count;
394  public:
395    FaultName name() {return _name;}
396    TrapType trapType() {return _trapType;}
397    FaultPriority priority() {return _priority;}
398    FaultStat & countStat() {return _count;}
399};
400
401class DataAccessProtection : public SparcFault
402{
403  private:
404    static FaultName _name;
405    static TrapType _trapType;
406    static FaultPriority _priority;
407    static FaultStat _count;
408  public:
409    FaultName name() {return _name;}
410    TrapType trapType() {return _trapType;}
411    FaultPriority priority() {return _priority;}
412    FaultStat & countStat() {return _count;}
413};
414
415class LDDFMemAddressNotAligned : public SparcFault
416{
417  private:
418    static FaultName _name;
419    static TrapType _trapType;
420    static FaultPriority _priority;
421    static FaultStat _count;
422  public:
423    FaultName name() {return _name;}
424    TrapType trapType() {return _trapType;}
425    FaultPriority priority() {return _priority;}
426    FaultStat & countStat() {return _count;}
427};
428
429class STDFMemAddressNotAligned : public SparcFault
430{
431  private:
432    static FaultName _name;
433    static TrapType _trapType;
434    static FaultPriority _priority;
435    static FaultStat _count;
436  public:
437    FaultName name() {return _name;}
438    TrapType trapType() {return _trapType;}
439    FaultPriority priority() {return _priority;}
440    FaultStat & countStat() {return _count;}
441};
442
443class PrivilegedAction : public SparcFault
444{
445  private:
446    static FaultName _name;
447    static TrapType _trapType;
448    static FaultPriority _priority;
449    static FaultStat _count;
450  public:
451    FaultName name() {return _name;}
452    TrapType trapType() {return _trapType;}
453    FaultPriority priority() {return _priority;}
454    FaultStat & countStat() {return _count;}
455};
456
457class LDQFMemAddressNotAligned : public SparcFault
458{
459  private:
460    static FaultName _name;
461    static TrapType _trapType;
462    static FaultPriority _priority;
463    static FaultStat _count;
464  public:
465    FaultName name() {return _name;}
466    TrapType trapType() {return _trapType;}
467    FaultPriority priority() {return _priority;}
468    FaultStat & countStat() {return _count;}
469};
470
471class STQFMemAddressNotAligned : public SparcFault
472{
473  private:
474    static FaultName _name;
475    static TrapType _trapType;
476    static FaultPriority _priority;
477    static FaultStat _count;
478  public:
479    FaultName name() {return _name;}
480    TrapType trapType() {return _trapType;}
481    FaultPriority priority() {return _priority;}
482    FaultStat & countStat() {return _count;}
483};
484
485class AsyncDataError : public SparcFault
486{
487  private:
488    static FaultName _name;
489    static TrapType _trapType;
490    static FaultPriority _priority;
491    static FaultStat _count;
492  public:
493    FaultName name() {return _name;}
494    TrapType trapType() {return _trapType;}
495    FaultPriority priority() {return _priority;}
496    FaultStat & countStat() {return _count;}
497};
498
499class CleanWindow : public SparcFault
500{
501  private:
502    static FaultName _name;
503    static TrapType _trapType;
504    static FaultPriority _priority;
505    static FaultStat _count;
506  public:
507    FaultName name() {return _name;}
508    TrapType trapType() {return _trapType;}
509    FaultPriority priority() {return _priority;}
510    FaultStat & countStat() {return _count;}
511};
512
513class EnumeratedFault : public SparcFault
514{
515  protected:
516    uint32_t _n;
517    virtual TrapType baseTrapType() = 0;
518  public:
519    EnumeratedFault(uint32_t n) : SparcFault() {_n = n;}
520    TrapType trapType() {return baseTrapType() + _n;}
521};
522
523class InterruptLevelN : public EnumeratedFault
524{
525  private:
526    static FaultName _name;
527    static TrapType _baseTrapType;
528    static FaultStat _count;
529    TrapType baseTrapType() {return _baseTrapType;}
530  public:
531    InterruptLevelN(uint32_t n) : EnumeratedFault(n) {;}
532    FaultName name() {return _name;}
533    FaultPriority priority() {return 32 - _n;}
534    FaultStat & countStat() {return _count;}
535};
536
537class SpillNNormal : public EnumeratedFault
538{
539  private:
540    static FaultName _name;
541    static TrapType _baseTrapType;
542    static FaultPriority _priority;
543    static FaultStat _count;
544    TrapType baseTrapType() {return _baseTrapType;}
545  public:
546    SpillNNormal(uint32_t n) : EnumeratedFault(n) {;}
547    FaultName name() {return _name;}
548    FaultPriority priority() {return _priority;}
549    FaultStat & countStat() {return _count;}
550};
551
552class SpillNOther : public EnumeratedFault
553{
554  private:
555    static FaultName _name;
556    static TrapType _baseTrapType;
557    static FaultPriority _priority;
558    static FaultStat _count;
559    TrapType baseTrapType() {return _baseTrapType;}
560  public:
561    SpillNOther(uint32_t n) : EnumeratedFault(n) {;}
562    FaultName name() {return _name;}
563    FaultPriority priority() {return _priority;}
564    FaultStat & countStat() {return _count;}
565};
566
567class FillNNormal : public EnumeratedFault
568{
569  private:
570    static FaultName _name;
571    static TrapType _baseTrapType;
572    static FaultPriority _priority;
573    static FaultStat _count;
574    TrapType baseTrapType() {return _baseTrapType;}
575  public:
576    FillNNormal(uint32_t n) : EnumeratedFault(n) {;}
577    FaultName name() {return _name;}
578    FaultPriority priority() {return _priority;}
579    FaultStat & countStat() {return _count;}
580};
581
582class FillNOther : public EnumeratedFault
583{
584  private:
585    static FaultName _name;
586    static TrapType _baseTrapType;
587    static FaultPriority _priority;
588    static FaultStat _count;
589    TrapType baseTrapType() {return _baseTrapType;}
590  public:
591    FillNOther(uint32_t n) : EnumeratedFault(n) {;}
592    FaultName name() {return _name;}
593    FaultPriority priority() {return _priority;}
594    FaultStat & countStat() {return _count;}
595};
596
597class TrapInstruction : public EnumeratedFault
598{
599  private:
600    static FaultName _name;
601    static TrapType _baseTrapType;
602    static FaultPriority _priority;
603    static FaultStat _count;
604    uint64_t syscall_num;
605    TrapType baseTrapType() {return _baseTrapType;}
606  public:
607    TrapInstruction(uint32_t n, uint64_t syscall) :
608        EnumeratedFault(n), syscall_num(syscall) {;}
609    FaultName name() {return _name;}
610    FaultPriority priority() {return _priority;}
611    FaultStat & countStat() {return _count;}
612#if !FULL_SYSTEM
613    void invoke(ThreadContext * tc);
614#endif
615};
616
617
618} // SparcISA namespace
619
620#endif // __FAULTS_HH__
621