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