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