faults.hh revision 2800 
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(ThreadContext * tc);
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
84#if !FULL_SYSTEM
85class PageTableFault : public AlphaFault
86{
87  private:
88    Addr vaddr;
89    static FaultName _name;
90    static FaultVect _vect;
91    static FaultStat _count;
92  public:
93    PageTableFault(Addr va)
94        : vaddr(va) {}
95    FaultName name() {return _name;}
96    FaultVect vect() {return _vect;}
97    FaultStat & countStat() {return _count;}
98    void invoke(ThreadContext * tc);
99};
100
101static inline Fault genPageTableFault(Addr va)
102{
103    return new PageTableFault(va);
104}
105#endif
106
107static inline Fault genMachineCheckFault()
108{
109    return new MachineCheckFault;
110}
111
112static inline Fault genAlignmentFault()
113{
114    return new AlignmentFault;
115}
116
117class ResetFault : public AlphaFault
118{
119  private:
120    static FaultName _name;
121    static FaultVect _vect;
122    static FaultStat _count;
123  public:
124    FaultName name() {return _name;}
125    FaultVect vect() {return _vect;}
126    FaultStat & countStat() {return _count;}
127};
128
129class ArithmeticFault : public AlphaFault
130{
131  protected:
132    bool skipFaultingInstruction() {return true;}
133  private:
134    static FaultName _name;
135    static FaultVect _vect;
136    static FaultStat _count;
137  public:
138    FaultName name() {return _name;}
139    FaultVect vect() {return _vect;}
140    FaultStat & countStat() {return _count;}
141#if FULL_SYSTEM
142    void invoke(ThreadContext * tc);
143#endif
144};
145
146class InterruptFault : public AlphaFault
147{
148  protected:
149    bool setRestartAddress() {return false;}
150  private:
151    static FaultName _name;
152    static FaultVect _vect;
153    static FaultStat _count;
154  public:
155    FaultName name() {return _name;}
156    FaultVect vect() {return _vect;}
157    FaultStat & countStat() {return _count;}
158};
159
160class DtbFault : public AlphaFault
161{
162#if FULL_SYSTEM
163  private:
164    AlphaISA::VAddr vaddr;
165    uint32_t reqFlags;
166    uint64_t flags;
167  public:
168    DtbFault(AlphaISA::VAddr _vaddr, uint32_t _reqFlags, uint64_t _flags)
169        : vaddr(_vaddr), reqFlags(_reqFlags), flags(_flags)
170    { }
171#endif
172    FaultName name() = 0;
173    FaultVect vect() = 0;
174    FaultStat & countStat() = 0;
175#if FULL_SYSTEM
176    void invoke(ThreadContext * tc);
177#endif
178};
179
180class NDtbMissFault : public DtbFault
181{
182  private:
183    static FaultName _name;
184    static FaultVect _vect;
185    static FaultStat _count;
186  public:
187#if FULL_SYSTEM
188    NDtbMissFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags)
189        : DtbFault(vaddr, reqFlags, flags)
190    { }
191#endif
192    FaultName name() {return _name;}
193    FaultVect vect() {return _vect;}
194    FaultStat & countStat() {return _count;}
195};
196
197class PDtbMissFault : public DtbFault
198{
199  private:
200    static FaultName _name;
201    static FaultVect _vect;
202    static FaultStat _count;
203  public:
204#if FULL_SYSTEM
205    PDtbMissFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags)
206        : DtbFault(vaddr, reqFlags, flags)
207    { }
208#endif
209    FaultName name() {return _name;}
210    FaultVect vect() {return _vect;}
211    FaultStat & countStat() {return _count;}
212};
213
214class DtbPageFault : public DtbFault
215{
216  private:
217    static FaultName _name;
218    static FaultVect _vect;
219    static FaultStat _count;
220  public:
221#if FULL_SYSTEM
222    DtbPageFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags)
223        : DtbFault(vaddr, reqFlags, flags)
224    { }
225#endif
226    FaultName name() {return _name;}
227    FaultVect vect() {return _vect;}
228    FaultStat & countStat() {return _count;}
229};
230
231class DtbAcvFault : public DtbFault
232{
233  private:
234    static FaultName _name;
235    static FaultVect _vect;
236    static FaultStat _count;
237  public:
238#if FULL_SYSTEM
239    DtbAcvFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags)
240        : DtbFault(vaddr, reqFlags, flags)
241    { }
242#endif
243    FaultName name() {return _name;}
244    FaultVect vect() {return _vect;}
245    FaultStat & countStat() {return _count;}
246};
247
248class DtbAlignmentFault : public DtbFault
249{
250  private:
251    static FaultName _name;
252    static FaultVect _vect;
253    static FaultStat _count;
254  public:
255#if FULL_SYSTEM
256    DtbAlignmentFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags)
257        : DtbFault(vaddr, reqFlags, flags)
258    { }
259#endif
260    FaultName name() {return _name;}
261    FaultVect vect() {return _vect;}
262    FaultStat & countStat() {return _count;}
263};
264
265class ItbFault : public AlphaFault
266{
267  private:
268    Addr pc;
269  public:
270    ItbFault(Addr _pc)
271        : pc(_pc)
272    { }
273    FaultName name() = 0;
274    FaultVect vect() = 0;
275    FaultStat & countStat() = 0;
276#if FULL_SYSTEM
277    void invoke(ThreadContext * tc);
278#endif
279};
280
281class ItbMissFault : public ItbFault
282{
283  private:
284    static FaultName _name;
285    static FaultVect _vect;
286    static FaultStat _count;
287  public:
288    ItbMissFault(Addr pc)
289        : ItbFault(pc)
290    { }
291    FaultName name() {return _name;}
292    FaultVect vect() {return _vect;}
293    FaultStat & countStat() {return _count;}
294};
295
296class ItbPageFault : public ItbFault
297{
298  private:
299    static FaultName _name;
300    static FaultVect _vect;
301    static FaultStat _count;
302  public:
303    ItbPageFault(Addr pc)
304        : ItbFault(pc)
305    { }
306    FaultName name() {return _name;}
307    FaultVect vect() {return _vect;}
308    FaultStat & countStat() {return _count;}
309};
310
311class ItbAcvFault : public ItbFault
312{
313  private:
314    static FaultName _name;
315    static FaultVect _vect;
316    static FaultStat _count;
317  public:
318    ItbAcvFault(Addr pc)
319        : ItbFault(pc)
320    { }
321    FaultName name() {return _name;}
322    FaultVect vect() {return _vect;}
323    FaultStat & countStat() {return _count;}
324};
325
326class UnimplementedOpcodeFault : public AlphaFault
327{
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 FloatEnableFault : 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
350class PalFault : public AlphaFault
351{
352  protected:
353    bool skipFaultingInstruction() {return true;}
354  private:
355    static FaultName _name;
356    static FaultVect _vect;
357    static FaultStat _count;
358  public:
359    FaultName name() {return _name;}
360    FaultVect vect() {return _vect;}
361    FaultStat & countStat() {return _count;}
362};
363
364class IntegerOverflowFault : public AlphaFault
365{
366  private:
367    static FaultName _name;
368    static FaultVect _vect;
369    static FaultStat _count;
370  public:
371    FaultName name() {return _name;}
372    FaultVect vect() {return _vect;}
373    FaultStat & countStat() {return _count;}
374};
375
376} // AlphaISA namespace
377
378#endif // __FAULTS_HH__
379