faults.hh revision 3552:186aa07d5fa1 
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 uint32_t TrapType;
43typedef 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    void invoke(ThreadContext * tc);
134};
135
136class WatchDogReset : public SparcFault
137{
138  private:
139    static FaultName _name;
140    static TrapType _trapType;
141    static FaultPriority _priority;
142    static FaultStat _count;
143  public:
144    FaultName name() {return _name;}
145    TrapType trapType() {return _trapType;}
146    FaultPriority priority() {return _priority;}
147    FaultStat & countStat() {return _count;}
148};
149
150class ExternallyInitiatedReset : public SparcFault
151{
152  private:
153    static FaultName _name;
154    static TrapType _trapType;
155    static FaultPriority _priority;
156    static FaultStat _count;
157  public:
158    FaultName name() {return _name;}
159    TrapType trapType() {return _trapType;}
160    FaultPriority priority() {return _priority;}
161    FaultStat & countStat() {return _count;}
162};
163
164class SoftwareInitiatedReset : public SparcFault
165{
166  private:
167    static FaultName _name;
168    static TrapType _trapType;
169    static FaultPriority _priority;
170    static FaultStat _count;
171  public:
172    FaultName name() {return _name;}
173    TrapType trapType() {return _trapType;}
174    FaultPriority priority() {return _priority;}
175    FaultStat & countStat() {return _count;}
176};
177
178class REDStateException : public SparcFault
179{
180  private:
181    static FaultName _name;
182    static TrapType _trapType;
183    static FaultPriority _priority;
184    static FaultStat _count;
185  public:
186    FaultName name() {return _name;}
187    TrapType trapType() {return _trapType;}
188    FaultPriority priority() {return _priority;}
189    FaultStat & countStat() {return _count;}
190};
191
192class InstructionAccessException : public SparcFault
193{
194  private:
195    static FaultName _name;
196    static TrapType _trapType;
197    static FaultPriority _priority;
198    static FaultStat _count;
199  public:
200    FaultName name() {return _name;}
201    TrapType trapType() {return _trapType;}
202    FaultPriority priority() {return _priority;}
203    FaultStat & countStat() {return _count;}
204};
205
206class InstructionAccessMMUMiss : public SparcFault
207{
208  private:
209    static FaultName _name;
210    static TrapType _trapType;
211    static FaultPriority _priority;
212    static FaultStat _count;
213  public:
214    FaultName name() {return _name;}
215    TrapType trapType() {return _trapType;}
216    FaultPriority priority() {return _priority;}
217    FaultStat & countStat() {return _count;}
218};
219
220class InstructionAccessError : public SparcFault
221{
222  private:
223    static FaultName _name;
224    static TrapType _trapType;
225    static FaultPriority _priority;
226    static FaultStat _count;
227  public:
228    FaultName name() {return _name;}
229    TrapType trapType() {return _trapType;}
230    FaultPriority priority() {return _priority;}
231    FaultStat & countStat() {return _count;}
232};
233
234class IllegalInstruction : public SparcFault
235{
236  private:
237    static FaultName _name;
238    static TrapType _trapType;
239    static FaultPriority _priority;
240    static FaultStat _count;
241  public:
242    FaultName name() {return _name;}
243    TrapType trapType() {return _trapType;}
244    FaultPriority priority() {return _priority;}
245    FaultStat & countStat() {return _count;}
246};
247
248class PrivilegedOpcode : public SparcFault
249{
250  private:
251    static FaultName _name;
252    static TrapType _trapType;
253    static FaultPriority _priority;
254    static FaultStat _count;
255  public:
256    FaultName name() {return _name;}
257    TrapType trapType() {return _trapType;}
258    FaultPriority priority() {return _priority;}
259    FaultStat & countStat() {return _count;}
260};
261
262class UnimplementedLDD : public SparcFault
263{
264  private:
265    static FaultName _name;
266    static TrapType _trapType;
267    static FaultPriority _priority;
268    static FaultStat _count;
269  public:
270    FaultName name() {return _name;}
271    TrapType trapType() {return _trapType;}
272    FaultPriority priority() {return _priority;}
273    FaultStat & countStat() {return _count;}
274};
275
276class UnimplementedSTD : public SparcFault
277{
278  private:
279    static FaultName _name;
280    static TrapType _trapType;
281    static FaultPriority _priority;
282    static FaultStat _count;
283  public:
284    FaultName name() {return _name;}
285    TrapType trapType() {return _trapType;}
286    FaultPriority priority() {return _priority;}
287    FaultStat & countStat() {return _count;}
288};
289
290class FpDisabled : public SparcFault
291{
292  private:
293    static FaultName _name;
294    static TrapType _trapType;
295    static FaultPriority _priority;
296    static FaultStat _count;
297  public:
298    FaultName name() {return _name;}
299    TrapType trapType() {return _trapType;}
300    FaultPriority priority() {return _priority;}
301    FaultStat & countStat() {return _count;}
302};
303
304class FpExceptionIEEE754 : public SparcFault
305{
306  private:
307    static FaultName _name;
308    static TrapType _trapType;
309    static FaultPriority _priority;
310    static FaultStat _count;
311  public:
312    FaultName name() {return _name;}
313    TrapType trapType() {return _trapType;}
314    FaultPriority priority() {return _priority;}
315    FaultStat & countStat() {return _count;}
316};
317
318class FpExceptionOther : public SparcFault
319{
320  private:
321    static FaultName _name;
322    static TrapType _trapType;
323    static FaultPriority _priority;
324    static FaultStat _count;
325  public:
326    FaultName name() {return _name;}
327    TrapType trapType() {return _trapType;}
328    FaultPriority priority() {return _priority;}
329    FaultStat & countStat() {return _count;}
330};
331
332class TagOverflow : public SparcFault
333{
334  private:
335    static FaultName _name;
336    static TrapType _trapType;
337    static FaultPriority _priority;
338    static FaultStat _count;
339  public:
340    FaultName name() {return _name;}
341    TrapType trapType() {return _trapType;}
342    FaultPriority priority() {return _priority;}
343    FaultStat & countStat() {return _count;}
344};
345
346class DivisionByZero : public SparcFault
347{
348  private:
349    static FaultName _name;
350    static TrapType _trapType;
351    static FaultPriority _priority;
352    static FaultStat _count;
353  public:
354    FaultName name() {return _name;}
355    TrapType trapType() {return _trapType;}
356    FaultPriority priority() {return _priority;}
357    FaultStat & countStat() {return _count;}
358};
359
360class DataAccessException : public SparcFault
361{
362  private:
363    static FaultName _name;
364    static TrapType _trapType;
365    static FaultPriority _priority;
366    static FaultStat _count;
367  public:
368    FaultName name() {return _name;}
369    TrapType trapType() {return _trapType;}
370    FaultPriority priority() {return _priority;}
371    FaultStat & countStat() {return _count;}
372};
373
374class DataAccessMMUMiss : public SparcFault
375{
376  private:
377    static FaultName _name;
378    static TrapType _trapType;
379    static FaultPriority _priority;
380    static FaultStat _count;
381  public:
382    FaultName name() {return _name;}
383    TrapType trapType() {return _trapType;}
384    FaultPriority priority() {return _priority;}
385    FaultStat & countStat() {return _count;}
386};
387
388class DataAccessError : public SparcFault
389{
390  private:
391    static FaultName _name;
392    static TrapType _trapType;
393    static FaultPriority _priority;
394    static FaultStat _count;
395  public:
396    FaultName name() {return _name;}
397    TrapType trapType() {return _trapType;}
398    FaultPriority priority() {return _priority;}
399    FaultStat & countStat() {return _count;}
400};
401
402class DataAccessProtection : public SparcFault
403{
404  private:
405    static FaultName _name;
406    static TrapType _trapType;
407    static FaultPriority _priority;
408    static FaultStat _count;
409  public:
410    FaultName name() {return _name;}
411    TrapType trapType() {return _trapType;}
412    FaultPriority priority() {return _priority;}
413    FaultStat & countStat() {return _count;}
414};
415
416class LDDFMemAddressNotAligned : public SparcFault
417{
418  private:
419    static FaultName _name;
420    static TrapType _trapType;
421    static FaultPriority _priority;
422    static FaultStat _count;
423  public:
424    FaultName name() {return _name;}
425    TrapType trapType() {return _trapType;}
426    FaultPriority priority() {return _priority;}
427    FaultStat & countStat() {return _count;}
428};
429
430class STDFMemAddressNotAligned : public SparcFault
431{
432  private:
433    static FaultName _name;
434    static TrapType _trapType;
435    static FaultPriority _priority;
436    static FaultStat _count;
437  public:
438    FaultName name() {return _name;}
439    TrapType trapType() {return _trapType;}
440    FaultPriority priority() {return _priority;}
441    FaultStat & countStat() {return _count;}
442};
443
444class PrivilegedAction : public SparcFault
445{
446  private:
447    static FaultName _name;
448    static TrapType _trapType;
449    static FaultPriority _priority;
450    static FaultStat _count;
451  public:
452    FaultName name() {return _name;}
453    TrapType trapType() {return _trapType;}
454    FaultPriority priority() {return _priority;}
455    FaultStat & countStat() {return _count;}
456};
457
458class LDQFMemAddressNotAligned : public SparcFault
459{
460  private:
461    static FaultName _name;
462    static TrapType _trapType;
463    static FaultPriority _priority;
464    static FaultStat _count;
465  public:
466    FaultName name() {return _name;}
467    TrapType trapType() {return _trapType;}
468    FaultPriority priority() {return _priority;}
469    FaultStat & countStat() {return _count;}
470};
471
472class STQFMemAddressNotAligned : public SparcFault
473{
474  private:
475    static FaultName _name;
476    static TrapType _trapType;
477    static FaultPriority _priority;
478    static FaultStat _count;
479  public:
480    FaultName name() {return _name;}
481    TrapType trapType() {return _trapType;}
482    FaultPriority priority() {return _priority;}
483    FaultStat & countStat() {return _count;}
484};
485
486class AsyncDataError : public SparcFault
487{
488  private:
489    static FaultName _name;
490    static TrapType _trapType;
491    static FaultPriority _priority;
492    static FaultStat _count;
493  public:
494    FaultName name() {return _name;}
495    TrapType trapType() {return _trapType;}
496    FaultPriority priority() {return _priority;}
497    FaultStat & countStat() {return _count;}
498};
499
500class CleanWindow : public SparcFault
501{
502  private:
503    static FaultName _name;
504    static TrapType _trapType;
505    static FaultPriority _priority;
506    static FaultStat _count;
507  public:
508    FaultName name() {return _name;}
509    TrapType trapType() {return _trapType;}
510    FaultPriority priority() {return _priority;}
511    FaultStat & countStat() {return _count;}
512};
513
514class EnumeratedFault : public SparcFault
515{
516  protected:
517    uint32_t _n;
518    virtual TrapType baseTrapType() = 0;
519  public:
520    EnumeratedFault(uint32_t n) : SparcFault() {_n = n;}
521    TrapType trapType() {return baseTrapType() + _n;}
522};
523
524class InterruptLevelN : public EnumeratedFault
525{
526  private:
527    static FaultName _name;
528    static TrapType _baseTrapType;
529    static FaultStat _count;
530    TrapType baseTrapType() {return _baseTrapType;}
531  public:
532    InterruptLevelN(uint32_t n) : EnumeratedFault(n) {;}
533    FaultName name() {return _name;}
534    FaultPriority priority() {return 32 - _n;}
535    FaultStat & countStat() {return _count;}
536};
537
538class SpillNNormal : public EnumeratedFault
539{
540  private:
541    static FaultName _name;
542    static TrapType _baseTrapType;
543    static FaultPriority _priority;
544    static FaultStat _count;
545    TrapType baseTrapType() {return _baseTrapType;}
546  public:
547    SpillNNormal(uint32_t n) : EnumeratedFault(n) {;}
548    FaultName name() {return _name;}
549    FaultPriority priority() {return _priority;}
550    FaultStat & countStat() {return _count;}
551    //These need to be handled specially to enable spill traps in SE
552#if !FULL_SYSTEM
553    void invoke(ThreadContext * tc);
554#endif
555};
556
557class SpillNOther : public EnumeratedFault
558{
559  private:
560    static FaultName _name;
561    static TrapType _baseTrapType;
562    static FaultPriority _priority;
563    static FaultStat _count;
564    TrapType baseTrapType() {return _baseTrapType;}
565  public:
566    SpillNOther(uint32_t n) : EnumeratedFault(n) {;}
567    FaultName name() {return _name;}
568    FaultPriority priority() {return _priority;}
569    FaultStat & countStat() {return _count;}
570};
571
572class FillNNormal : public EnumeratedFault
573{
574  private:
575    static FaultName _name;
576    static TrapType _baseTrapType;
577    static FaultPriority _priority;
578    static FaultStat _count;
579    TrapType baseTrapType() {return _baseTrapType;}
580  public:
581    FillNNormal(uint32_t n) : EnumeratedFault(n) {;}
582    FaultName name() {return _name;}
583    FaultPriority priority() {return _priority;}
584    FaultStat & countStat() {return _count;}
585    //These need to be handled specially to enable fill traps in SE
586#if !FULL_SYSTEM
587    void invoke(ThreadContext * tc);
588#endif
589};
590
591class FillNOther : public EnumeratedFault
592{
593  private:
594    static FaultName _name;
595    static TrapType _baseTrapType;
596    static FaultPriority _priority;
597    static FaultStat _count;
598    TrapType baseTrapType() {return _baseTrapType;}
599  public:
600    FillNOther(uint32_t n) : EnumeratedFault(n) {;}
601    FaultName name() {return _name;}
602    FaultPriority priority() {return _priority;}
603    FaultStat & countStat() {return _count;}
604};
605
606class TrapInstruction : public EnumeratedFault
607{
608  private:
609    static FaultName _name;
610    static TrapType _baseTrapType;
611    static FaultPriority _priority;
612    static FaultStat _count;
613    TrapType baseTrapType() {return _baseTrapType;}
614  public:
615    TrapInstruction(int32_t n) : EnumeratedFault(n) {;}
616    FaultName name() {return _name;}
617    FaultPriority priority() {return _priority;}
618    FaultStat & countStat() {return _count;}
619};
620
621
622} // SparcISA namespace
623
624#endif // __FAULTS_HH__
625