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