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