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