1/*
2 * Copyright (c) 2003-2005 The Regents of The University of Michigan
3 * Copyright (c) 2007 MIPS Technologies, Inc.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are
8 * met: redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer;
10 * redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution;
13 * neither the name of the copyright holders nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 *
29 * Authors: Gabe Black
30 * Korey Sewell
31 * Jaidev Patwardhan
32 */
33
34#ifndef __MIPS_FAULTS_HH__
35#define __MIPS_FAULTS_HH__
36
37#include "sim/faults.hh"
38
39namespace MipsISA
40{
41
42typedef const Addr FaultVect;
43
44class MipsFault : public FaultBase
45{
46 protected:
47 virtual bool skipFaultingInstruction() {return false;}
48 virtual bool setRestartAddress() {return true;}
49 public:
50 Addr badVAddr;
51 Addr entryHiAsid;
52 Addr entryHiVPN2;
53 Addr entryHiVPN2X;
54 Addr contextBadVPN2;
55#if FULL_SYSTEM
| 1/*
2 * Copyright (c) 2003-2005 The Regents of The University of Michigan
3 * Copyright (c) 2007 MIPS Technologies, Inc.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are
8 * met: redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer;
10 * redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution;
13 * neither the name of the copyright holders nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 *
29 * Authors: Gabe Black
30 * Korey Sewell
31 * Jaidev Patwardhan
32 */
33
34#ifndef __MIPS_FAULTS_HH__
35#define __MIPS_FAULTS_HH__
36
37#include "sim/faults.hh"
38
39namespace MipsISA
40{
41
42typedef const Addr FaultVect;
43
44class MipsFault : public FaultBase
45{
46 protected:
47 virtual bool skipFaultingInstruction() {return false;}
48 virtual bool setRestartAddress() {return true;}
49 public:
50 Addr badVAddr;
51 Addr entryHiAsid;
52 Addr entryHiVPN2;
53 Addr entryHiVPN2X;
54 Addr contextBadVPN2;
55#if FULL_SYSTEM
|
56 void invoke(ThreadContext * tc) {};
| 56 void invoke(ThreadContext * tc,
57 StaticInst::StaticInstPtr inst = StaticInst::nullStaticInstPtr)
58 {}
|
57 void setExceptionState(ThreadContext *, uint8_t);
58 void setHandlerPC(Addr, ThreadContext *);
59#endif
60 virtual FaultVect vect() = 0;
61 virtual FaultStat & countStat() = 0;
62};
63
64class MachineCheckFault : public MipsFault
65{
66 private:
67 static FaultName _name;
68 static FaultVect _vect;
69 static FaultStat _count;
70 public:
71 FaultName name() const {return _name;}
72 FaultVect vect() {return _vect;}
73 FaultStat & countStat() {return _count;}
74 bool isMachineCheckFault() {return true;}
75};
76
77class NonMaskableInterrupt : public MipsFault
78{
79 private:
80 static FaultName _name;
81 static FaultVect _vect;
82 static FaultStat _count;
83 public:
84 FaultName name() const {return _name;}
85 FaultVect vect() {return _vect;}
86 FaultStat & countStat() {return _count;}
87 bool isNonMaskableInterrupt() {return true;}
88};
89
90class AlignmentFault : public MipsFault
91{
92 private:
93 static FaultName _name;
94 static FaultVect _vect;
95 static FaultStat _count;
96 public:
97 FaultName name() const {return _name;}
98 FaultVect vect() {return _vect;}
99 FaultStat & countStat() {return _count;}
100 bool isAlignmentFault() {return true;}
101};
102
103class AddressErrorFault : public MipsFault
104{
105 private:
106 static FaultName _name;
107 static FaultVect _vect;
108 static FaultStat _count;
109 public:
110 FaultName name() const {return _name;}
111 FaultVect vect() {return _vect;}
112 FaultStat & countStat() {return _count;}
113#if FULL_SYSTEM
| 59 void setExceptionState(ThreadContext *, uint8_t);
60 void setHandlerPC(Addr, ThreadContext *);
61#endif
62 virtual FaultVect vect() = 0;
63 virtual FaultStat & countStat() = 0;
64};
65
66class MachineCheckFault : public MipsFault
67{
68 private:
69 static FaultName _name;
70 static FaultVect _vect;
71 static FaultStat _count;
72 public:
73 FaultName name() const {return _name;}
74 FaultVect vect() {return _vect;}
75 FaultStat & countStat() {return _count;}
76 bool isMachineCheckFault() {return true;}
77};
78
79class NonMaskableInterrupt : public MipsFault
80{
81 private:
82 static FaultName _name;
83 static FaultVect _vect;
84 static FaultStat _count;
85 public:
86 FaultName name() const {return _name;}
87 FaultVect vect() {return _vect;}
88 FaultStat & countStat() {return _count;}
89 bool isNonMaskableInterrupt() {return true;}
90};
91
92class AlignmentFault : public MipsFault
93{
94 private:
95 static FaultName _name;
96 static FaultVect _vect;
97 static FaultStat _count;
98 public:
99 FaultName name() const {return _name;}
100 FaultVect vect() {return _vect;}
101 FaultStat & countStat() {return _count;}
102 bool isAlignmentFault() {return true;}
103};
104
105class AddressErrorFault : public MipsFault
106{
107 private:
108 static FaultName _name;
109 static FaultVect _vect;
110 static FaultStat _count;
111 public:
112 FaultName name() const {return _name;}
113 FaultVect vect() {return _vect;}
114 FaultStat & countStat() {return _count;}
115#if FULL_SYSTEM
|
114 void invoke(ThreadContext * tc);
| 116 void invoke(ThreadContext * tc,
117 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
115#endif
116
117};
118
119class StoreAddressErrorFault : public MipsFault
120{
121 private:
122 static FaultName _name;
123 static FaultVect _vect;
124 static FaultStat _count;
125 public:
126 FaultName name() const {return _name;}
127 FaultVect vect() {return _vect;}
128 FaultStat & countStat() {return _count;}
129#if FULL_SYSTEM
| 118#endif
119
120};
121
122class StoreAddressErrorFault : public MipsFault
123{
124 private:
125 static FaultName _name;
126 static FaultVect _vect;
127 static FaultStat _count;
128 public:
129 FaultName name() const {return _name;}
130 FaultVect vect() {return _vect;}
131 FaultStat & countStat() {return _count;}
132#if FULL_SYSTEM
|
130 void invoke(ThreadContext * tc);
| 133 void invoke(ThreadContext * tc,
134 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
131#endif
132};
133
134class UnimplementedOpcodeFault : public MipsFault
135{
136 private:
137 static FaultName _name;
138 static FaultVect _vect;
139 static FaultStat _count;
140 public:
141 FaultName name() const {return _name;}
142 FaultVect vect() {return _vect;}
143 FaultStat & countStat() {return _count;}
144};
145
146
147class TLBRefillIFetchFault : public MipsFault
148{
149 private:
150 Addr vaddr;
151 static FaultName _name;
152 static FaultVect _vect;
153 static FaultStat _count;
154 public:
155 FaultName name() const {return _name;}
156 FaultVect vect() {return _vect;}
157 FaultStat & countStat() {return _count;}
| 135#endif
136};
137
138class UnimplementedOpcodeFault : public MipsFault
139{
140 private:
141 static FaultName _name;
142 static FaultVect _vect;
143 static FaultStat _count;
144 public:
145 FaultName name() const {return _name;}
146 FaultVect vect() {return _vect;}
147 FaultStat & countStat() {return _count;}
148};
149
150
151class TLBRefillIFetchFault : public MipsFault
152{
153 private:
154 Addr vaddr;
155 static FaultName _name;
156 static FaultVect _vect;
157 static FaultStat _count;
158 public:
159 FaultName name() const {return _name;}
160 FaultVect vect() {return _vect;}
161 FaultStat & countStat() {return _count;}
|
158 void invoke(ThreadContext * tc);
| 162 void invoke(ThreadContext * tc,
163 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
159};
160
161class TLBInvalidIFetchFault : public MipsFault
162{
163 private:
164 Addr vaddr;
165 static FaultName _name;
166 static FaultVect _vect;
167 static FaultStat _count;
168 public:
169 FaultName name() const {return _name;}
170 FaultVect vect() {return _vect;}
171 FaultStat & countStat() {return _count;}
| 164};
165
166class TLBInvalidIFetchFault : public MipsFault
167{
168 private:
169 Addr vaddr;
170 static FaultName _name;
171 static FaultVect _vect;
172 static FaultStat _count;
173 public:
174 FaultName name() const {return _name;}
175 FaultVect vect() {return _vect;}
176 FaultStat & countStat() {return _count;}
|
172 void invoke(ThreadContext * tc);
| 177 void invoke(ThreadContext * tc,
178 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
173};
174
175class NDtbMissFault : public MipsFault
176{
177 private:
178 static FaultName _name;
179 static FaultVect _vect;
180 static FaultStat _count;
181 public:
182 FaultName name() const {return _name;}
183 FaultVect vect() {return _vect;}
184 FaultStat & countStat() {return _count;}
185};
186
187class PDtbMissFault : public MipsFault
188{
189 private:
190 static FaultName _name;
191 static FaultVect _vect;
192 static FaultStat _count;
193 public:
194 FaultName name() const {return _name;}
195 FaultVect vect() {return _vect;}
196 FaultStat & countStat() {return _count;}
197};
198
199class DtbPageFault : public MipsFault
200{
201 private:
202 static FaultName _name;
203 static FaultVect _vect;
204 static FaultStat _count;
205 public:
206 FaultName name() const {return _name;}
207 FaultVect vect() {return _vect;}
208 FaultStat & countStat() {return _count;}
209};
210
211class DtbAcvFault : public MipsFault
212{
213 private:
214 static FaultName _name;
215 static FaultVect _vect;
216 static FaultStat _count;
217 public:
218 FaultName name() const {return _name;}
219 FaultVect vect() {return _vect;}
220 FaultStat & countStat() {return _count;}
221};
222
223class CacheErrorFault : public MipsFault
224{
225 private:
226 Addr vaddr;
227 static FaultName _name;
228 static FaultVect _vect;
229 static FaultStat _count;
230 public:
231 FaultName name() const {return _name;}
232 FaultVect vect() {return _vect;}
233 FaultStat & countStat() {return _count;}
| 179};
180
181class NDtbMissFault : public MipsFault
182{
183 private:
184 static FaultName _name;
185 static FaultVect _vect;
186 static FaultStat _count;
187 public:
188 FaultName name() const {return _name;}
189 FaultVect vect() {return _vect;}
190 FaultStat & countStat() {return _count;}
191};
192
193class PDtbMissFault : public MipsFault
194{
195 private:
196 static FaultName _name;
197 static FaultVect _vect;
198 static FaultStat _count;
199 public:
200 FaultName name() const {return _name;}
201 FaultVect vect() {return _vect;}
202 FaultStat & countStat() {return _count;}
203};
204
205class DtbPageFault : public MipsFault
206{
207 private:
208 static FaultName _name;
209 static FaultVect _vect;
210 static FaultStat _count;
211 public:
212 FaultName name() const {return _name;}
213 FaultVect vect() {return _vect;}
214 FaultStat & countStat() {return _count;}
215};
216
217class DtbAcvFault : public MipsFault
218{
219 private:
220 static FaultName _name;
221 static FaultVect _vect;
222 static FaultStat _count;
223 public:
224 FaultName name() const {return _name;}
225 FaultVect vect() {return _vect;}
226 FaultStat & countStat() {return _count;}
227};
228
229class CacheErrorFault : public MipsFault
230{
231 private:
232 Addr vaddr;
233 static FaultName _name;
234 static FaultVect _vect;
235 static FaultStat _count;
236 public:
237 FaultName name() const {return _name;}
238 FaultVect vect() {return _vect;}
239 FaultStat & countStat() {return _count;}
|
234 void invoke(ThreadContext * tc);
| 240 void invoke(ThreadContext * tc,
241 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
235};
236
237
238
239
240static inline Fault genMachineCheckFault()
241{
242 return new MachineCheckFault;
243}
244
245static inline Fault genAlignmentFault()
246{
247 return new AlignmentFault;
248}
249
250class ResetFault : public MipsFault
251{
252 private:
253 static FaultName _name;
254 static FaultVect _vect;
255 static FaultStat _count;
256 public:
257 FaultName name() const {return _name;}
258 FaultVect vect() {return _vect;}
259 FaultStat & countStat() {return _count;}
| 242};
243
244
245
246
247static inline Fault genMachineCheckFault()
248{
249 return new MachineCheckFault;
250}
251
252static inline Fault genAlignmentFault()
253{
254 return new AlignmentFault;
255}
256
257class ResetFault : public MipsFault
258{
259 private:
260 static FaultName _name;
261 static FaultVect _vect;
262 static FaultStat _count;
263 public:
264 FaultName name() const {return _name;}
265 FaultVect vect() {return _vect;}
266 FaultStat & countStat() {return _count;}
|
260 void invoke(ThreadContext * tc);
| 267 void invoke(ThreadContext * tc,
268 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
261
262};
263
264class SystemCallFault : public MipsFault
265{
266 private:
267 static FaultName _name;
268 static FaultVect _vect;
269 static FaultStat _count;
270 public:
271 FaultName name() const {return _name;}
272 FaultVect vect() {return _vect;}
273 FaultStat & countStat() {return _count;}
| 269
270};
271
272class SystemCallFault : public MipsFault
273{
274 private:
275 static FaultName _name;
276 static FaultVect _vect;
277 static FaultStat _count;
278 public:
279 FaultName name() const {return _name;}
280 FaultVect vect() {return _vect;}
281 FaultStat & countStat() {return _count;}
|
274 void invoke(ThreadContext * tc);
| 282 void invoke(ThreadContext * tc,
283 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
275};
276
277class SoftResetFault : public MipsFault
278{
279 private:
280 static FaultName _name;
281 static FaultVect _vect;
282 static FaultStat _count;
283 public:
284 FaultName name() const {return _name;}
285 FaultVect vect() {return _vect;}
286 FaultStat & countStat() {return _count;}
| 284};
285
286class SoftResetFault : public MipsFault
287{
288 private:
289 static FaultName _name;
290 static FaultVect _vect;
291 static FaultStat _count;
292 public:
293 FaultName name() const {return _name;}
294 FaultVect vect() {return _vect;}
295 FaultStat & countStat() {return _count;}
|
287 void invoke(ThreadContext * tc);
| 296 void invoke(ThreadContext * tc,
297 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
288};
289
290class DebugSingleStep : public MipsFault
291{
292 private:
293 static FaultName _name;
294 static FaultVect _vect;
295 static FaultStat _count;
296 public:
297 FaultName name() const {return _name;}
298 FaultVect vect() {return _vect;}
299 FaultStat & countStat() {return _count;}
| 298};
299
300class DebugSingleStep : public MipsFault
301{
302 private:
303 static FaultName _name;
304 static FaultVect _vect;
305 static FaultStat _count;
306 public:
307 FaultName name() const {return _name;}
308 FaultVect vect() {return _vect;}
309 FaultStat & countStat() {return _count;}
|
300 void invoke(ThreadContext * tc);
| 310 void invoke(ThreadContext * tc,
311 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
301};
302
303class DebugInterrupt : public MipsFault
304{
305 private:
306 static FaultName _name;
307 static FaultVect _vect;
308 static FaultStat _count;
309 public:
310 FaultName name() const {return _name;}
311 FaultVect vect() {return _vect;}
312 FaultStat & countStat() {return _count;}
| 312};
313
314class DebugInterrupt : public MipsFault
315{
316 private:
317 static FaultName _name;
318 static FaultVect _vect;
319 static FaultStat _count;
320 public:
321 FaultName name() const {return _name;}
322 FaultVect vect() {return _vect;}
323 FaultStat & countStat() {return _count;}
|
313 void invoke(ThreadContext * tc);
| 324 void invoke(ThreadContext * tc,
325 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
314};
315
316class CoprocessorUnusableFault : public MipsFault
317{
318 private:
319 static FaultName _name;
320 static FaultVect _vect;
321 static FaultStat _count;
322 int coProcID;
323 public:
324 FaultName name() const {return _name;}
325 FaultVect vect() {return _vect;}
326 FaultStat & countStat() {return _count;}
| 326};
327
328class CoprocessorUnusableFault : public MipsFault
329{
330 private:
331 static FaultName _name;
332 static FaultVect _vect;
333 static FaultStat _count;
334 int coProcID;
335 public:
336 FaultName name() const {return _name;}
337 FaultVect vect() {return _vect;}
338 FaultStat & countStat() {return _count;}
|
327 void invoke(ThreadContext * tc);
| 339 void invoke(ThreadContext * tc,
340 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
328 CoprocessorUnusableFault(int _procid){ coProcID = _procid;}
329};
330
331class ReservedInstructionFault : public MipsFault
332{
333 private:
334 static FaultName _name;
335 static FaultVect _vect;
336 static FaultStat _count;
337 public:
338 FaultName name() const {return _name;}
339 FaultVect vect() {return _vect;}
340 FaultStat & countStat() {return _count;}
| 341 CoprocessorUnusableFault(int _procid){ coProcID = _procid;}
342};
343
344class ReservedInstructionFault : public MipsFault
345{
346 private:
347 static FaultName _name;
348 static FaultVect _vect;
349 static FaultStat _count;
350 public:
351 FaultName name() const {return _name;}
352 FaultVect vect() {return _vect;}
353 FaultStat & countStat() {return _count;}
|
341 void invoke(ThreadContext * tc);
| 354 void invoke(ThreadContext * tc,
355 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
342};
343
344class ThreadFault : public MipsFault
345{
346 private:
347 static FaultName _name;
348 static FaultVect _vect;
349 static FaultStat _count;
350 public:
351 FaultName name() const {return _name;}
352 FaultVect vect() {return _vect;}
353 FaultStat & countStat() {return _count;}
| 356};
357
358class ThreadFault : public MipsFault
359{
360 private:
361 static FaultName _name;
362 static FaultVect _vect;
363 static FaultStat _count;
364 public:
365 FaultName name() const {return _name;}
366 FaultVect vect() {return _vect;}
367 FaultStat & countStat() {return _count;}
|
354 void invoke(ThreadContext * tc);
| 368 void invoke(ThreadContext * tc,
369 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
355};
356
357class ArithmeticFault : public MipsFault
358{
359 protected:
360 bool skipFaultingInstruction() {return true;}
361 private:
362 static FaultName _name;
363 static FaultVect _vect;
364 static FaultStat _count;
365 public:
366 FaultName name() const {return _name;}
367 FaultVect vect() {return _vect;}
368 FaultStat & countStat() {return _count;}
369#if FULL_SYSTEM
| 370};
371
372class ArithmeticFault : public MipsFault
373{
374 protected:
375 bool skipFaultingInstruction() {return true;}
376 private:
377 static FaultName _name;
378 static FaultVect _vect;
379 static FaultStat _count;
380 public:
381 FaultName name() const {return _name;}
382 FaultVect vect() {return _vect;}
383 FaultStat & countStat() {return _count;}
384#if FULL_SYSTEM
|
370 void invoke(ThreadContext * tc);
| 385 void invoke(ThreadContext * tc,
386 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
371#endif
372};
373
374class InterruptFault : public MipsFault
375{
376 protected:
377 bool setRestartAddress() {return false;}
378 private:
379 static FaultName _name;
380 static FaultVect _vect;
381 static FaultStat _count;
382 public:
383 FaultName name() const {return _name;}
384 FaultVect vect() {return _vect;}
385 FaultStat & countStat() {return _count;}
386
387#if FULL_SYSTEM
| 387#endif
388};
389
390class InterruptFault : public MipsFault
391{
392 protected:
393 bool setRestartAddress() {return false;}
394 private:
395 static FaultName _name;
396 static FaultVect _vect;
397 static FaultStat _count;
398 public:
399 FaultName name() const {return _name;}
400 FaultVect vect() {return _vect;}
401 FaultStat & countStat() {return _count;}
402
403#if FULL_SYSTEM
|
388 void invoke(ThreadContext * tc);
| 404 void invoke(ThreadContext * tc,
405 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
389#endif
390};
391
392class TrapFault : public MipsFault
393{
394 private:
395 static FaultName _name;
396 static FaultVect _vect;
397 static FaultStat _count;
398 public:
399 FaultName name() const {return _name;}
400 FaultVect vect() {return _vect;}
401 FaultStat & countStat() {return _count;}
402#if FULL_SYSTEM
| 406#endif
407};
408
409class TrapFault : public MipsFault
410{
411 private:
412 static FaultName _name;
413 static FaultVect _vect;
414 static FaultStat _count;
415 public:
416 FaultName name() const {return _name;}
417 FaultVect vect() {return _vect;}
418 FaultStat & countStat() {return _count;}
419#if FULL_SYSTEM
|
403 void invoke(ThreadContext * tc);
| 420 void invoke(ThreadContext * tc,
421 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
404#endif
405};
406
407class BreakpointFault : public MipsFault
408{
409 private:
410 static FaultName _name;
411 static FaultVect _vect;
412 static FaultStat _count;
413 public:
414 FaultName name() const {return _name;}
415 FaultVect vect() {return _vect;}
416 FaultStat & countStat() {return _count;}
417#if FULL_SYSTEM
| 422#endif
423};
424
425class BreakpointFault : public MipsFault
426{
427 private:
428 static FaultName _name;
429 static FaultVect _vect;
430 static FaultStat _count;
431 public:
432 FaultName name() const {return _name;}
433 FaultVect vect() {return _vect;}
434 FaultStat & countStat() {return _count;}
435#if FULL_SYSTEM
|
418 void invoke(ThreadContext * tc);
| 436 void invoke(ThreadContext * tc,
437 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
419#endif
420};
421
422class ItbRefillFault : public MipsFault
423{
424 private:
425 static FaultName _name;
426 static FaultVect _vect;
427 static FaultStat _count;
428 public:
429 FaultName name() const {return _name;}
430 FaultVect vect() {return _vect;}
431 FaultStat & countStat() {return _count;}
432#if FULL_SYSTEM
| 438#endif
439};
440
441class ItbRefillFault : public MipsFault
442{
443 private:
444 static FaultName _name;
445 static FaultVect _vect;
446 static FaultStat _count;
447 public:
448 FaultName name() const {return _name;}
449 FaultVect vect() {return _vect;}
450 FaultStat & countStat() {return _count;}
451#if FULL_SYSTEM
|
433 void invoke(ThreadContext * tc);
| 452 void invoke(ThreadContext * tc,
453 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
434#endif
435};
436
437class DtbRefillFault : public MipsFault
438{
439 private:
440 static FaultName _name;
441 static FaultVect _vect;
442 static FaultStat _count;
443 public:
444 FaultName name() const {return _name;}
445 FaultVect vect() {return _vect;}
446 FaultStat & countStat() {return _count;}
447#if FULL_SYSTEM
| 454#endif
455};
456
457class DtbRefillFault : public MipsFault
458{
459 private:
460 static FaultName _name;
461 static FaultVect _vect;
462 static FaultStat _count;
463 public:
464 FaultName name() const {return _name;}
465 FaultVect vect() {return _vect;}
466 FaultStat & countStat() {return _count;}
467#if FULL_SYSTEM
|
448 void invoke(ThreadContext * tc);
| 468 void invoke(ThreadContext * tc,
469 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
449#endif
450};
451
452class ItbPageFault : public MipsFault
453{
454 private:
455 static FaultName _name;
456 static FaultVect _vect;
457 static FaultStat _count;
458 public:
459 FaultName name() const {return _name;}
460 FaultVect vect() {return _vect;}
461 FaultStat & countStat() {return _count;}
462#if FULL_SYSTEM
| 470#endif
471};
472
473class ItbPageFault : public MipsFault
474{
475 private:
476 static FaultName _name;
477 static FaultVect _vect;
478 static FaultStat _count;
479 public:
480 FaultName name() const {return _name;}
481 FaultVect vect() {return _vect;}
482 FaultStat & countStat() {return _count;}
483#if FULL_SYSTEM
|
463 void invoke(ThreadContext * tc);
| 484 void invoke(ThreadContext * tc,
485 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
464#endif
465};
466
467class ItbInvalidFault : public MipsFault
468{
469 private:
470 static FaultName _name;
471 static FaultVect _vect;
472 static FaultStat _count;
473 public:
474 FaultName name() const {return _name;}
475 FaultVect vect() {return _vect;}
476 FaultStat & countStat() {return _count;}
477#if FULL_SYSTEM
| 486#endif
487};
488
489class ItbInvalidFault : public MipsFault
490{
491 private:
492 static FaultName _name;
493 static FaultVect _vect;
494 static FaultStat _count;
495 public:
496 FaultName name() const {return _name;}
497 FaultVect vect() {return _vect;}
498 FaultStat & countStat() {return _count;}
499#if FULL_SYSTEM
|
478 void invoke(ThreadContext * tc);
| 500 void invoke(ThreadContext * tc,
501 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
479#endif
480};
481
482class TLBModifiedFault : public MipsFault
483{
484 private:
485 static FaultName _name;
486 static FaultVect _vect;
487 static FaultStat _count;
488 public:
489 FaultName name() const {return _name;}
490 FaultVect vect() {return _vect;}
491 FaultStat & countStat() {return _count;}
492#if FULL_SYSTEM
| 502#endif
503};
504
505class TLBModifiedFault : public MipsFault
506{
507 private:
508 static FaultName _name;
509 static FaultVect _vect;
510 static FaultStat _count;
511 public:
512 FaultName name() const {return _name;}
513 FaultVect vect() {return _vect;}
514 FaultStat & countStat() {return _count;}
515#if FULL_SYSTEM
|
493 void invoke(ThreadContext * tc);
| 516 void invoke(ThreadContext * tc,
517 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
494#endif
495};
496
497class DtbInvalidFault : public MipsFault
498{
499 private:
500 static FaultName _name;
501 static FaultVect _vect;
502 static FaultStat _count;
503 public:
504 FaultName name() const {return _name;}
505 FaultVect vect() {return _vect;}
506 FaultStat & countStat() {return _count;}
507#if FULL_SYSTEM
| 518#endif
519};
520
521class DtbInvalidFault : public MipsFault
522{
523 private:
524 static FaultName _name;
525 static FaultVect _vect;
526 static FaultStat _count;
527 public:
528 FaultName name() const {return _name;}
529 FaultVect vect() {return _vect;}
530 FaultStat & countStat() {return _count;}
531#if FULL_SYSTEM
|
508 void invoke(ThreadContext * tc);
| 532 void invoke(ThreadContext * tc,
533 StaticInst::StaticInstPtr inst = nullStaticInstPtr);
|
509#endif
510};
511
512class FloatEnableFault : public MipsFault
513{
514 private:
515 static FaultName _name;
516 static FaultVect _vect;
517 static FaultStat _count;
518 public:
519 FaultName name() const {return _name;}
520 FaultVect vect() {return _vect;}
521 FaultStat & countStat() {return _count;}
522};
523
524class ItbMissFault : public MipsFault
525{
526 private:
527 static FaultName _name;
528 static FaultVect _vect;
529 static FaultStat _count;
530 public:
531 FaultName name() const {return _name;}
532 FaultVect vect() {return _vect;}
533 FaultStat & countStat() {return _count;}
534};
535
536class ItbAcvFault : public MipsFault
537{
538 private:
539 static FaultName _name;
540 static FaultVect _vect;
541 static FaultStat _count;
542 public:
543 FaultName name() const {return _name;}
544 FaultVect vect() {return _vect;}
545 FaultStat & countStat() {return _count;}
546};
547
548class IntegerOverflowFault : public MipsFault
549{
550 private:
551 static FaultName _name;
552 static FaultVect _vect;
553 static FaultStat _count;
554 public:
555 FaultName name() const {return _name;}
556 FaultVect vect() {return _vect;}
557 FaultStat & countStat() {return _count;}
558};
559
560class DspStateDisabledFault : public MipsFault
561{
562 private:
563 static FaultName _name;
564 static FaultVect _vect;
565 static FaultStat _count;
566 public:
567 FaultName name() const {return _name;}
568 FaultVect vect() {return _vect;}
569 FaultStat & countStat() {return _count;}
| 534#endif
535};
536
537class FloatEnableFault : public MipsFault
538{
539 private:
540 static FaultName _name;
541 static FaultVect _vect;
542 static FaultStat _count;
543 public:
544 FaultName name() const {return _name;}
545 FaultVect vect() {return _vect;}
546 FaultStat & countStat() {return _count;}
547};
548
549class ItbMissFault : public MipsFault
550{
551 private:
552 static FaultName _name;
553 static FaultVect _vect;
554 static FaultStat _count;
555 public:
556 FaultName name() const {return _name;}
557 FaultVect vect() {return _vect;}
558 FaultStat & countStat() {return _count;}
559};
560
561class ItbAcvFault : public MipsFault
562{
563 private:
564 static FaultName _name;
565 static FaultVect _vect;
566 static FaultStat _count;
567 public:
568 FaultName name() const {return _name;}
569 FaultVect vect() {return _vect;}
570 FaultStat & countStat() {return _count;}
571};
572
573class IntegerOverflowFault : public MipsFault
574{
575 private:
576 static FaultName _name;
577 static FaultVect _vect;
578 static FaultStat _count;
579 public:
580 FaultName name() const {return _name;}
581 FaultVect vect() {return _vect;}
582 FaultStat & countStat() {return _count;}
583};
584
585class DspStateDisabledFault : public MipsFault
586{
587 private:
588 static FaultName _name;
589 static FaultVect _vect;
590 static FaultStat _count;
591 public:
592 FaultName name() const {return _name;}
593 FaultVect vect() {return _vect;}
594 FaultStat & countStat() {return _count;}
|
570 void invoke(ThreadContext * tc);
| 595 void invoke(ThreadContext * tc,
596 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
|
571};
572
573} // MipsISA namespace
574
575#endif // __MIPS_FAULTS_HH__
| 597};
598
599} // MipsISA namespace
600
601#endif // __MIPS_FAULTS_HH__
|