faults.hh revision 2523 
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
29#ifndef __ALPHA_FAULTS_HH__
30#define __ALPHA_FAULTS_HH__
31
32#include "sim/faults.hh"
33
34// The design of the "name" and "vect" functions is in sim/faults.hh
35
36namespace SparcISA
37{
38
39typedef const uint32_t TrapType;
40typedef const uint32_t FaultPriority;
41
42class SparcFault : public FaultBase
43{
44  public:
45#if FULL_SYSTEM
46    void invoke(ExecContext * xc);
47#endif
48    virtual TrapType trapType() = 0;
49    virtual FaultPriority priority() = 0;
50    virtual FaultStat & countStat() = 0;
51};
52
53class InternalProcessorError : public SparcFault
54{
55  private:
56    static FaultName _name;
57    static TrapType _trapType;
58    static FaultPriority _priority;
59    static FaultStat _count;
60  public:
61    FaultName name() {return _name;}
62    TrapType trapType() {return _trapType;}
63    FaultPriority priority() {return _priority;}
64    FaultStat & countStat() {return _count;}
65    bool isMachineCheckFault() {return true;}
66};
67
68class MemAddressNotAligned : public SparcFault
69{
70  private:
71    static FaultName _name;
72    static TrapType _trapType;
73    static FaultPriority _priority;
74    static FaultStat _count;
75  public:
76    FaultName name() {return _name;}
77    TrapType trapType() {return _trapType;}
78    FaultPriority priority() {return _priority;}
79    FaultStat & countStat() {return _count;}
80    bool isAlignmentFault() {return true;}
81};
82
83static inline Fault genMachineCheckFault()
84{
85    return new InternalProcessorError;
86}
87
88static inline Fault genAlignmentFault()
89{
90    return new MemAddressNotAligned;
91}
92
93class PowerOnReset : public SparcFault
94{
95  private:
96    static FaultName _name;
97    static TrapType _trapType;
98    static FaultPriority _priority;
99    static FaultStat _count;
100  public:
101    FaultName name() {return _name;}
102    TrapType trapType() {return _trapType;}
103    FaultPriority priority() {return _priority;}
104    FaultStat & countStat() {return _count;}
105};
106
107class WatchDogReset : public SparcFault
108{
109  private:
110    static FaultName _name;
111    static TrapType _trapType;
112    static FaultPriority _priority;
113    static FaultStat _count;
114  public:
115    FaultName name() {return _name;}
116    TrapType trapType() {return _trapType;}
117    FaultPriority priority() {return _priority;}
118    FaultStat & countStat() {return _count;}
119};
120
121class ExternallyInitiatedReset : 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 SoftwareInitiatedReset : 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 REDStateException : 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 InstructionAccessException : 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 InstructionAccessMMUMiss : 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 InstructionAccessError : 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 IllegalInstruction : 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 PrivilegedOpcode : 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 UnimplementedLDD : 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 UnimplementedSTD : 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 FpDisabled : 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 FpExceptionIEEE754 : 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 FpExceptionOther : 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 TagOverflow : 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 DivisionByZero : 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 DataAccessException : 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 DataAccessMMUMiss : 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 DataAccessError : 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 DataAccessProtection : 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 LDDFMemAddressNotAligned : 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 STDFMemAddressNotAligned : 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 PrivilegedAction : 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 LDQFMemAddressNotAligned : 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 STQFMemAddressNotAligned : 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 AsyncDataError : 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 EnumeratedFault : public SparcFault
472{
473  protected:
474    uint32_t _n;
475    virtual TrapType baseTrapType() = 0;
476  public:
477    EnumeratedFault(uint32_t n) : SparcFault() {_n = n;}
478    TrapType trapType() {return baseTrapType() + _n;}
479};
480
481class CleanWindow : public EnumeratedFault
482{
483  private:
484    static FaultName _name;
485    static TrapType _baseTrapType;
486    static FaultPriority _priority;
487    static FaultStat _count;
488    TrapType baseTrapType() {return _baseTrapType;}
489  public:
490    CleanWindow(uint32_t n) : EnumeratedFault(n) {;}
491    FaultName name() {return _name;}
492    FaultPriority priority() {return _priority;}
493    FaultStat & countStat() {return _count;}
494};
495
496class InterruptLevelN : public EnumeratedFault
497{
498  private:
499    static FaultName _name;
500    static TrapType _baseTrapType;
501    static FaultStat _count;
502    TrapType baseTrapType() {return _baseTrapType;}
503  public:
504    InterruptLevelN(uint32_t n) : EnumeratedFault(n) {;}
505    FaultName name() {return _name;}
506    FaultPriority priority() {return 32 - _n;}
507    FaultStat & countStat() {return _count;}
508};
509
510class SpillNNormal : public EnumeratedFault
511{
512  private:
513    static FaultName _name;
514    static TrapType _baseTrapType;
515    static FaultPriority _priority;
516    static FaultStat _count;
517    TrapType baseTrapType() {return _baseTrapType;}
518  public:
519    SpillNNormal(uint32_t n) : EnumeratedFault(n) {;}
520    FaultName name() {return _name;}
521    FaultPriority priority() {return _priority;}
522    FaultStat & countStat() {return _count;}
523};
524
525class SpillNOther : public EnumeratedFault
526{
527  private:
528    static FaultName _name;
529    static TrapType _baseTrapType;
530    static FaultPriority _priority;
531    static FaultStat _count;
532    TrapType baseTrapType() {return _baseTrapType;}
533  public:
534    SpillNOther(uint32_t n) : EnumeratedFault(n) {;}
535    FaultName name() {return _name;}
536    FaultPriority priority() {return _priority;}
537    FaultStat & countStat() {return _count;}
538};
539
540class FillNNormal : public EnumeratedFault
541{
542  private:
543    static FaultName _name;
544    static TrapType _baseTrapType;
545    static FaultPriority _priority;
546    static FaultStat _count;
547    TrapType baseTrapType() {return _baseTrapType;}
548  public:
549    FillNNormal(uint32_t n) : EnumeratedFault(n) {;}
550    FaultName name() {return _name;}
551    FaultPriority priority() {return _priority;}
552    FaultStat & countStat() {return _count;}
553};
554
555class FillNOther : public EnumeratedFault
556{
557  private:
558    static FaultName _name;
559    static TrapType _baseTrapType;
560    static FaultPriority _priority;
561    static FaultStat _count;
562    TrapType baseTrapType() {return _baseTrapType;}
563  public:
564    FillNOther(uint32_t n) : EnumeratedFault(n) {;}
565    FaultName name() {return _name;}
566    FaultPriority priority() {return _priority;}
567    FaultStat & countStat() {return _count;}
568};
569
570class TrapInstruction : public EnumeratedFault
571{
572  private:
573    static FaultName _name;
574    static TrapType _baseTrapType;
575    static FaultPriority _priority;
576    static FaultStat _count;
577    TrapType baseTrapType() {return _baseTrapType;}
578  public:
579    TrapInstruction(uint32_t n) : EnumeratedFault(n) {;}
580    FaultName name() {return _name;}
581    FaultPriority priority() {return _priority;}
582    FaultStat & countStat() {return _count;}
583};
584
585class UnimpFault : public SparcFault
586{
587  private:
588    static FaultName _name;
589    static TrapType _trapType;
590    static FaultPriority _priority;
591    static FaultStat _count;
592    std::string panicStr;
593  public:
594    UnimpFault(std::string _str)
595        : panicStr(_str)
596    { }
597
598    FaultName name() {return _name;}
599    TrapType trapType() {return _trapType;}
600    FaultPriority priority() {return _priority;}
601    FaultStat & countStat() {return _count;}
602#if FULL_SYSTEM
603    void invoke(ExecContext * xc);
604#endif
605};
606
607
608} // SparcISA namespace
609
610#endif // __FAULTS_HH__
611