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