faults.hh revision 2632:1bb2f91485ea 
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 "arch/alpha/isa_traits.hh"
33#include "sim/faults.hh"
34
35// The design of the "name" and "vect" functions is in sim/faults.hh
36
37namespace AlphaISA
38{
39
40typedef const Addr FaultVect;
41
42class AlphaFault : public FaultBase
43{
44  protected:
45    virtual bool skipFaultingInstruction() {return false;}
46    virtual bool setRestartAddress() {return true;}
47  public:
48#if FULL_SYSTEM
49    void invoke(ExecContext * xc);
50#endif
51    virtual FaultVect vect() = 0;
52    virtual FaultStat & countStat() = 0;
53};
54
55class MachineCheckFault : public AlphaFault
56{
57  private:
58    static FaultName _name;
59    static FaultVect _vect;
60    static FaultStat _count;
61  public:
62    FaultName name() {return _name;}
63    FaultVect vect() {return _vect;}
64    FaultStat & countStat() {return _count;}
65    bool isMachineCheckFault() {return true;}
66};
67
68class AlignmentFault : public AlphaFault
69{
70  private:
71    static FaultName _name;
72    static FaultVect _vect;
73    static FaultStat _count;
74  public:
75    FaultName name() {return _name;}
76    FaultVect vect() {return _vect;}
77    FaultStat & countStat() {return _count;}
78    bool isAlignmentFault() {return true;}
79};
80
81static inline Fault genMachineCheckFault()
82{
83    return new MachineCheckFault;
84}
85
86static inline Fault genAlignmentFault()
87{
88    return new AlignmentFault;
89}
90
91class ResetFault : public AlphaFault
92{
93  private:
94    static FaultName _name;
95    static FaultVect _vect;
96    static FaultStat _count;
97  public:
98    FaultName name() {return _name;}
99    FaultVect vect() {return _vect;}
100    FaultStat & countStat() {return _count;}
101};
102
103class ArithmeticFault : public AlphaFault
104{
105  protected:
106    bool skipFaultingInstruction() {return true;}
107  private:
108    static FaultName _name;
109    static FaultVect _vect;
110    static FaultStat _count;
111  public:
112    FaultName name() {return _name;}
113    FaultVect vect() {return _vect;}
114    FaultStat & countStat() {return _count;}
115#if FULL_SYSTEM
116    void invoke(ExecContext * xc);
117#endif
118};
119
120class InterruptFault : public AlphaFault
121{
122  protected:
123    bool setRestartAddress() {return false;}
124  private:
125    static FaultName _name;
126    static FaultVect _vect;
127    static FaultStat _count;
128  public:
129    FaultName name() {return _name;}
130    FaultVect vect() {return _vect;}
131    FaultStat & countStat() {return _count;}
132};
133
134class DtbFault : public AlphaFault
135{
136#if FULL_SYSTEM
137  private:
138    AlphaISA::VAddr vaddr;
139    uint32_t reqFlags;
140    uint64_t flags;
141  public:
142    DtbFault(AlphaISA::VAddr _vaddr, uint32_t _reqFlags, uint64_t _flags)
143        : vaddr(_vaddr), reqFlags(_reqFlags), flags(_flags)
144    { }
145#endif
146    FaultName name() = 0;
147    FaultVect vect() = 0;
148    FaultStat & countStat() = 0;
149#if FULL_SYSTEM
150    void invoke(ExecContext * xc);
151#endif
152};
153
154class NDtbMissFault : public DtbFault
155{
156  private:
157    static FaultName _name;
158    static FaultVect _vect;
159    static FaultStat _count;
160  public:
161#if FULL_SYSTEM
162    NDtbMissFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags)
163        : DtbFault(vaddr, reqFlags, flags)
164    { }
165#endif
166    FaultName name() {return _name;}
167    FaultVect vect() {return _vect;}
168    FaultStat & countStat() {return _count;}
169};
170
171class PDtbMissFault : public DtbFault
172{
173  private:
174    static FaultName _name;
175    static FaultVect _vect;
176    static FaultStat _count;
177  public:
178#if FULL_SYSTEM
179    PDtbMissFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags)
180        : DtbFault(vaddr, reqFlags, flags)
181    { }
182#endif
183    FaultName name() {return _name;}
184    FaultVect vect() {return _vect;}
185    FaultStat & countStat() {return _count;}
186};
187
188class DtbPageFault : public DtbFault
189{
190  private:
191    static FaultName _name;
192    static FaultVect _vect;
193    static FaultStat _count;
194  public:
195#if FULL_SYSTEM
196    DtbPageFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags)
197        : DtbFault(vaddr, reqFlags, flags)
198    { }
199#endif
200    FaultName name() {return _name;}
201    FaultVect vect() {return _vect;}
202    FaultStat & countStat() {return _count;}
203};
204
205class DtbAcvFault : public DtbFault
206{
207  private:
208    static FaultName _name;
209    static FaultVect _vect;
210    static FaultStat _count;
211  public:
212#if FULL_SYSTEM
213    DtbAcvFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags)
214        : DtbFault(vaddr, reqFlags, flags)
215    { }
216#endif
217    FaultName name() {return _name;}
218    FaultVect vect() {return _vect;}
219    FaultStat & countStat() {return _count;}
220};
221
222class DtbAlignmentFault : public DtbFault
223{
224  private:
225    static FaultName _name;
226    static FaultVect _vect;
227    static FaultStat _count;
228  public:
229#if FULL_SYSTEM
230    DtbAlignmentFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags)
231        : DtbFault(vaddr, reqFlags, flags)
232    { }
233#endif
234    FaultName name() {return _name;}
235    FaultVect vect() {return _vect;}
236    FaultStat & countStat() {return _count;}
237};
238
239class ItbFault : public AlphaFault
240{
241  private:
242    Addr pc;
243  public:
244    ItbFault(Addr _pc)
245        : pc(_pc)
246    { }
247    FaultName name() = 0;
248    FaultVect vect() = 0;
249    FaultStat & countStat() = 0;
250#if FULL_SYSTEM
251    void invoke(ExecContext * xc);
252#endif
253};
254
255class ItbMissFault : public ItbFault
256{
257  private:
258    static FaultName _name;
259    static FaultVect _vect;
260    static FaultStat _count;
261  public:
262    ItbMissFault(Addr pc)
263        : ItbFault(pc)
264    { }
265    FaultName name() {return _name;}
266    FaultVect vect() {return _vect;}
267    FaultStat & countStat() {return _count;}
268};
269
270class ItbPageFault : public ItbFault
271{
272  private:
273    static FaultName _name;
274    static FaultVect _vect;
275    static FaultStat _count;
276  public:
277    ItbPageFault(Addr pc)
278        : ItbFault(pc)
279    { }
280    FaultName name() {return _name;}
281    FaultVect vect() {return _vect;}
282    FaultStat & countStat() {return _count;}
283};
284
285class ItbAcvFault : public ItbFault
286{
287  private:
288    static FaultName _name;
289    static FaultVect _vect;
290    static FaultStat _count;
291  public:
292    ItbAcvFault(Addr pc)
293        : ItbFault(pc)
294    { }
295    FaultName name() {return _name;}
296    FaultVect vect() {return _vect;}
297    FaultStat & countStat() {return _count;}
298};
299
300class UnimplementedOpcodeFault : public AlphaFault
301{
302  private:
303    static FaultName _name;
304    static FaultVect _vect;
305    static FaultStat _count;
306  public:
307    FaultName name() {return _name;}
308    FaultVect vect() {return _vect;}
309    FaultStat & countStat() {return _count;}
310};
311
312class FloatEnableFault : public AlphaFault
313{
314  private:
315    static FaultName _name;
316    static FaultVect _vect;
317    static FaultStat _count;
318  public:
319    FaultName name() {return _name;}
320    FaultVect vect() {return _vect;}
321    FaultStat & countStat() {return _count;}
322};
323
324class PalFault : public AlphaFault
325{
326  protected:
327    bool skipFaultingInstruction() {return true;}
328  private:
329    static FaultName _name;
330    static FaultVect _vect;
331    static FaultStat _count;
332  public:
333    FaultName name() {return _name;}
334    FaultVect vect() {return _vect;}
335    FaultStat & countStat() {return _count;}
336};
337
338class IntegerOverflowFault : public AlphaFault
339{
340  private:
341    static FaultName _name;
342    static FaultVect _vect;
343    static FaultStat _count;
344  public:
345    FaultName name() {return _name;}
346    FaultVect vect() {return _vect;}
347    FaultStat & countStat() {return _count;}
348};
349
350} // AlphaISA namespace
351
352#endif // __FAULTS_HH__
353