faults.hh (8569:498d3aacd292) faults.hh (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
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__
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__