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