faults.hh (8563:58cf8f4a7c33) faults.hh (8566:812d279f7b51)
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

--- 27 unchanged lines hidden (view full) ---

36
37#include "sim/faults.hh"
38
39namespace MipsISA
40{
41
42typedef const Addr FaultVect;
43
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

--- 27 unchanged lines hidden (view full) ---

36
37#include "sim/faults.hh"
38
39namespace MipsISA
40{
41
42typedef const Addr FaultVect;
43
44class MipsFault : public FaultBase
44class MipsFaultBase : public FaultBase
45{
46 protected:
47 virtual bool skipFaultingInstruction() {return false;}
48 virtual bool setRestartAddress() {return true;}
49 public:
45{
46 protected:
47 virtual bool skipFaultingInstruction() {return false;}
48 virtual bool setRestartAddress() {return true;}
49 public:
50 struct FaultVals
51 {
52 const FaultName name;
53 const FaultVect vect;
54 FaultStat count;
55 };
56
50 Addr badVAddr;
51 Addr entryHiAsid;
52 Addr entryHiVPN2;
53 Addr entryHiVPN2X;
54 Addr contextBadVPN2;
55#if FULL_SYSTEM
56 void invoke(ThreadContext * tc,
57 StaticInst::StaticInstPtr inst = StaticInst::nullStaticInstPtr)
58 {}
59 void setExceptionState(ThreadContext *, uint8_t);
60 void setHandlerPC(Addr, ThreadContext *);
61#endif
57 Addr badVAddr;
58 Addr entryHiAsid;
59 Addr entryHiVPN2;
60 Addr entryHiVPN2X;
61 Addr contextBadVPN2;
62#if FULL_SYSTEM
63 void invoke(ThreadContext * tc,
64 StaticInst::StaticInstPtr inst = StaticInst::nullStaticInstPtr)
65 {}
66 void setExceptionState(ThreadContext *, uint8_t);
67 void setHandlerPC(Addr, ThreadContext *);
68#endif
62 virtual FaultVect vect() = 0;
63 virtual FaultStat & countStat() = 0;
64};
65
69};
70
66class MachineCheckFault : public MipsFault
71template <typename T>
72class MipsFault : public MipsFaultBase
67{
73{
68 private:
69 static FaultName _name;
70 static FaultVect _vect;
71 static FaultStat _count;
74 protected:
75 static FaultVals vals;
72 public:
76 public:
73 FaultName name() const {return _name;}
74 FaultVect vect() {return _vect;}
75 FaultStat & countStat() {return _count;}
77 FaultName name() const { return vals.name; }
78 FaultVect vect() const { return vals.vect; }
79 FaultStat & countStat() { return vals.count; }
80};
81
82class MachineCheckFault : public MipsFault<MachineCheckFault>
83{
84 public:
76 bool isMachineCheckFault() {return true;}
77};
78
85 bool isMachineCheckFault() {return true;}
86};
87
79class NonMaskableInterrupt : public MipsFault
88class NonMaskableInterrupt : public MipsFault<NonMaskableInterrupt>
80{
89{
81 private:
82 static FaultName _name;
83 static FaultVect _vect;
84 static FaultStat _count;
85 public:
90 public:
86 FaultName name() const {return _name;}
87 FaultVect vect() {return _vect;}
88 FaultStat & countStat() {return _count;}
89 bool isNonMaskableInterrupt() {return true;}
90};
91
91 bool isNonMaskableInterrupt() {return true;}
92};
93
92class AlignmentFault : public MipsFault
94class AlignmentFault : public MipsFault<AlignmentFault>
93{
95{
94 private:
95 static FaultName _name;
96 static FaultVect _vect;
97 static FaultStat _count;
98 public:
96 public:
99 FaultName name() const {return _name;}
100 FaultVect vect() {return _vect;}
101 FaultStat & countStat() {return _count;}
102 bool isAlignmentFault() {return true;}
103};
104
97 bool isAlignmentFault() {return true;}
98};
99
105class AddressErrorFault : public MipsFault
100class AddressErrorFault : public MipsFault<AddressErrorFault>
106{
101{
107 private:
108 static FaultName _name;
109 static FaultVect _vect;
110 static FaultStat _count;
111 public:
102 public:
112 FaultName name() const {return _name;}
113 FaultVect vect() {return _vect;}
114 FaultStat & countStat() {return _count;}
115#if FULL_SYSTEM
116 void invoke(ThreadContext * tc,
117 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
118#endif
119
120};
121
103#if FULL_SYSTEM
104 void invoke(ThreadContext * tc,
105 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
106#endif
107
108};
109
122class StoreAddressErrorFault : public MipsFault
110class StoreAddressErrorFault : public MipsFault<StoreAddressErrorFault>
123{
111{
124 private:
125 static FaultName _name;
126 static FaultVect _vect;
127 static FaultStat _count;
128 public:
112 public:
129 FaultName name() const {return _name;}
130 FaultVect vect() {return _vect;}
131 FaultStat & countStat() {return _count;}
132#if FULL_SYSTEM
133 void invoke(ThreadContext * tc,
134 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
135#endif
136};
137
113#if FULL_SYSTEM
114 void invoke(ThreadContext * tc,
115 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
116#endif
117};
118
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};
119class UnimplementedOpcodeFault : public MipsFault<UnimplementedOpcodeFault> {};
149
120
150
151class TLBRefillIFetchFault : public MipsFault
121class TLBRefillIFetchFault : public MipsFault<TLBRefillIFetchFault>
152{
122{
153 private:
154 Addr vaddr;
155 static FaultName _name;
156 static FaultVect _vect;
157 static FaultStat _count;
158 public:
123 public:
159 FaultName name() const {return _name;}
160 FaultVect vect() {return _vect;}
161 FaultStat & countStat() {return _count;}
162 void invoke(ThreadContext * tc,
163 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
164};
165
124 void invoke(ThreadContext * tc,
125 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
126};
127
166class TLBInvalidIFetchFault : public MipsFault
128class TLBInvalidIFetchFault : public MipsFault<TLBInvalidIFetchFault>
167{
129{
168 private:
169 Addr vaddr;
170 static FaultName _name;
171 static FaultVect _vect;
172 static FaultStat _count;
173 public:
130 public:
174 FaultName name() const {return _name;}
175 FaultVect vect() {return _vect;}
176 FaultStat & countStat() {return _count;}
177 void invoke(ThreadContext * tc,
178 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
179};
180
131 void invoke(ThreadContext * tc,
132 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
133};
134
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};
135class NDtbMissFault : public MipsFault<NDtbMissFault> {};
136class PDtbMissFault : public MipsFault<PDtbMissFault> {};
137class DtbPageFault : public MipsFault<DtbPageFault> {};
138class DtbAcvFault : public MipsFault<DtbAcvFault> {};
192
139
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
229
230static inline Fault genMachineCheckFault()
231{
232 return new MachineCheckFault;
233}
234
235static inline Fault genAlignmentFault()
236{
237 return new AlignmentFault;
238}
239
140static inline Fault genMachineCheckFault()
141{
142 return new MachineCheckFault;
143}
144
145static inline Fault genAlignmentFault()
146{
147 return new AlignmentFault;
148}
149
240class ResetFault : public MipsFault
150class ResetFault : public MipsFault<ResetFault>
241{
151{
242 private:
243 static FaultName _name;
244 static FaultVect _vect;
245 static FaultStat _count;
246 public:
152 public:
247 FaultName name() const {return _name;}
248 FaultVect vect() {return _vect;}
249 FaultStat & countStat() {return _count;}
250 void invoke(ThreadContext * tc,
251 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
252
253};
254
153 void invoke(ThreadContext * tc,
154 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
155
156};
157
255class SystemCallFault : public MipsFault
158class SystemCallFault : public MipsFault<SystemCallFault>
256{
159{
257 private:
258 static FaultName _name;
259 static FaultVect _vect;
260 static FaultStat _count;
261 public:
160 public:
262 FaultName name() const {return _name;}
263 FaultVect vect() {return _vect;}
264 FaultStat & countStat() {return _count;}
265#if FULL_SYSTEM
266 void invoke(ThreadContext * tc,
267 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
268#endif
269};
270
161#if FULL_SYSTEM
162 void invoke(ThreadContext * tc,
163 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
164#endif
165};
166
271class SoftResetFault : public MipsFault
167class SoftResetFault : public MipsFault<SoftResetFault>
272{
168{
273 private:
274 static FaultName _name;
275 static FaultVect _vect;
276 static FaultStat _count;
277 public:
169 public:
278 FaultName name() const {return _name;}
279 FaultVect vect() {return _vect;}
280 FaultStat & countStat() {return _count;}
281 void invoke(ThreadContext * tc,
282 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
283};
284
170 void invoke(ThreadContext * tc,
171 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
172};
173
285class DebugSingleStep : public MipsFault
174class DebugSingleStep : public MipsFault<DebugSingleStep>
286{
175{
287 private:
288 static FaultName _name;
289 static FaultVect _vect;
290 static FaultStat _count;
291 public:
176 public:
292 FaultName name() const {return _name;}
293 FaultVect vect() {return _vect;}
294 FaultStat & countStat() {return _count;}
295 void invoke(ThreadContext * tc,
296 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
297};
298
177 void invoke(ThreadContext * tc,
178 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
179};
180
299class DebugInterrupt : public MipsFault
181class DebugInterrupt : public MipsFault<DebugInterrupt>
300{
182{
301 private:
302 static FaultName _name;
303 static FaultVect _vect;
304 static FaultStat _count;
305 public:
183 public:
306 FaultName name() const {return _name;}
307 FaultVect vect() {return _vect;}
308 FaultStat & countStat() {return _count;}
309 void invoke(ThreadContext * tc,
310 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
311};
312
184 void invoke(ThreadContext * tc,
185 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
186};
187
313class CoprocessorUnusableFault : public MipsFault
188class CoprocessorUnusableFault : public MipsFault<CoprocessorUnusableFault>
314{
189{
315 private:
316 static FaultName _name;
317 static FaultVect _vect;
318 static FaultStat _count;
190 protected:
319 int coProcID;
320 public:
191 int coProcID;
192 public:
321 FaultName name() const {return _name;}
322 FaultVect vect() {return _vect;}
323 FaultStat & countStat() {return _count;}
193 CoprocessorUnusableFault(int _procid) : coProcID(_procid)
194 {}
195
324 void invoke(ThreadContext * tc,
325 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
196 void invoke(ThreadContext * tc,
197 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
326 CoprocessorUnusableFault(int _procid){ coProcID = _procid;}
327};
328
198};
199
329class ReservedInstructionFault : public MipsFault
200class ReservedInstructionFault : public MipsFault<ReservedInstructionFault>
330{
201{
331 private:
332 static FaultName _name;
333 static FaultVect _vect;
334 static FaultStat _count;
335 public:
202 public:
336 FaultName name() const {return _name;}
337 FaultVect vect() {return _vect;}
338 FaultStat & countStat() {return _count;}
339 void invoke(ThreadContext * tc,
340 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
341};
342
203 void invoke(ThreadContext * tc,
204 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
205};
206
343class ThreadFault : public MipsFault
207class ThreadFault : public MipsFault<ThreadFault>
344{
208{
345 private:
346 static FaultName _name;
347 static FaultVect _vect;
348 static FaultStat _count;
349 public:
209 public:
350 FaultName name() const {return _name;}
351 FaultVect vect() {return _vect;}
352 FaultStat & countStat() {return _count;}
353 void invoke(ThreadContext * tc,
354 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
355};
356
210 void invoke(ThreadContext * tc,
211 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
212};
213
357class ArithmeticFault : public MipsFault
214class ArithmeticFault : public MipsFault<ArithmeticFault>
358{
359 protected:
360 bool skipFaultingInstruction() {return true;}
215{
216 protected:
217 bool skipFaultingInstruction() {return true;}
361 private:
362 static FaultName _name;
363 static FaultVect _vect;
364 static FaultStat _count;
365 public:
218 public:
366 FaultName name() const {return _name;}
367 FaultVect vect() {return _vect;}
368 FaultStat & countStat() {return _count;}
369#if FULL_SYSTEM
370 void invoke(ThreadContext * tc,
371 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
372#endif
373};
374
219#if FULL_SYSTEM
220 void invoke(ThreadContext * tc,
221 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
222#endif
223};
224
375class InterruptFault : public MipsFault
225class InterruptFault : public MipsFault<InterruptFault>
376{
377 protected:
378 bool setRestartAddress() {return false;}
226{
227 protected:
228 bool setRestartAddress() {return false;}
379 private:
380 static FaultName _name;
381 static FaultVect _vect;
382 static FaultStat _count;
383 public:
229 public:
384 FaultName name() const {return _name;}
385 FaultVect vect() {return _vect;}
386 FaultStat & countStat() {return _count;}
387
388#if FULL_SYSTEM
389 void invoke(ThreadContext * tc,
390 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
391#endif
392};
393
230#if FULL_SYSTEM
231 void invoke(ThreadContext * tc,
232 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
233#endif
234};
235
394class TrapFault : public MipsFault
236class TrapFault : public MipsFault<TrapFault>
395{
237{
396 private:
397 static FaultName _name;
398 static FaultVect _vect;
399 static FaultStat _count;
400 public:
238 public:
401 FaultName name() const {return _name;}
402 FaultVect vect() {return _vect;}
403 FaultStat & countStat() {return _count;}
404#if FULL_SYSTEM
405 void invoke(ThreadContext * tc,
406 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
407#endif
408};
409
239#if FULL_SYSTEM
240 void invoke(ThreadContext * tc,
241 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
242#endif
243};
244
410class BreakpointFault : public MipsFault
245class BreakpointFault : public MipsFault<BreakpointFault>
411{
246{
412 private:
413 static FaultName _name;
414 static FaultVect _vect;
415 static FaultStat _count;
416 public:
247 public:
417 FaultName name() const {return _name;}
418 FaultVect vect() {return _vect;}
419 FaultStat & countStat() {return _count;}
420#if FULL_SYSTEM
421 void invoke(ThreadContext * tc,
422 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
423#endif
424};
425
248#if FULL_SYSTEM
249 void invoke(ThreadContext * tc,
250 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
251#endif
252};
253
426class ItbRefillFault : public MipsFault
254class ItbRefillFault : public MipsFault<ItbRefillFault>
427{
255{
428 private:
429 static FaultName _name;
430 static FaultVect _vect;
431 static FaultStat _count;
432 public:
256 public:
433 FaultName name() const {return _name;}
434 FaultVect vect() {return _vect;}
435 FaultStat & countStat() {return _count;}
436#if FULL_SYSTEM
437 void invoke(ThreadContext * tc,
438 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
439#endif
440};
441
257#if FULL_SYSTEM
258 void invoke(ThreadContext * tc,
259 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
260#endif
261};
262
442class DtbRefillFault : public MipsFault
263class DtbRefillFault : public MipsFault<DtbRefillFault>
443{
264{
444 private:
445 static FaultName _name;
446 static FaultVect _vect;
447 static FaultStat _count;
448 public:
265 public:
449 FaultName name() const {return _name;}
450 FaultVect vect() {return _vect;}
451 FaultStat & countStat() {return _count;}
452#if FULL_SYSTEM
453 void invoke(ThreadContext * tc,
454 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
455#endif
456};
457
266#if FULL_SYSTEM
267 void invoke(ThreadContext * tc,
268 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
269#endif
270};
271
458class ItbPageFault : public MipsFault
272class ItbPageFault : public MipsFault<ItbPageFault>
459{
273{
460 private:
461 static FaultName _name;
462 static FaultVect _vect;
463 static FaultStat _count;
464 public:
274 public:
465 FaultName name() const {return _name;}
466 FaultVect vect() {return _vect;}
467 FaultStat & countStat() {return _count;}
468#if FULL_SYSTEM
469 void invoke(ThreadContext * tc,
470 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
471#endif
472};
473
275#if FULL_SYSTEM
276 void invoke(ThreadContext * tc,
277 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
278#endif
279};
280
474class ItbInvalidFault : public MipsFault
281class ItbInvalidFault : public MipsFault<ItbInvalidFault>
475{
282{
476 private:
477 static FaultName _name;
478 static FaultVect _vect;
479 static FaultStat _count;
480 public:
283 public:
481 FaultName name() const {return _name;}
482 FaultVect vect() {return _vect;}
483 FaultStat & countStat() {return _count;}
484#if FULL_SYSTEM
485 void invoke(ThreadContext * tc,
486 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
487#endif
488};
489
284#if FULL_SYSTEM
285 void invoke(ThreadContext * tc,
286 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
287#endif
288};
289
490class TLBModifiedFault : public MipsFault
290class TLBModifiedFault : public MipsFault<TLBModifiedFault>
491{
291{
492 private:
493 static FaultName _name;
494 static FaultVect _vect;
495 static FaultStat _count;
496 public:
292 public:
497 FaultName name() const {return _name;}
498 FaultVect vect() {return _vect;}
499 FaultStat & countStat() {return _count;}
500#if FULL_SYSTEM
501 void invoke(ThreadContext * tc,
502 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
503#endif
504};
505
293#if FULL_SYSTEM
294 void invoke(ThreadContext * tc,
295 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
296#endif
297};
298
506class DtbInvalidFault : public MipsFault
299class DtbInvalidFault : public MipsFault<DtbInvalidFault>
507{
300{
508 private:
509 static FaultName _name;
510 static FaultVect _vect;
511 static FaultStat _count;
512 public:
301 public:
513 FaultName name() const {return _name;}
514 FaultVect vect() {return _vect;}
515 FaultStat & countStat() {return _count;}
516#if FULL_SYSTEM
517 void invoke(ThreadContext * tc,
518 StaticInst::StaticInstPtr inst = nullStaticInstPtr);
519#endif
520};
521
302#if FULL_SYSTEM
303 void invoke(ThreadContext * tc,
304 StaticInst::StaticInstPtr inst = nullStaticInstPtr);
305#endif
306};
307
522class FloatEnableFault : public MipsFault
523{
524 private:
525 static FaultName _name;
526 static FaultVect _vect;
527 static FaultStat _count;
528 public:
529 FaultName name() const {return _name;}
530 FaultVect vect() {return _vect;}
531 FaultStat & countStat() {return _count;}
532};
308class FloatEnableFault : public MipsFault<FloatEnableFault> {};
309class ItbMissFault : public MipsFault<ItbMissFault> {};
310class ItbAcvFault : public MipsFault<ItbAcvFault> {};
311class IntegerOverflowFault : public MipsFault<IntegerOverflowFault> {};
533
312
534class ItbMissFault : public MipsFault
313class DspStateDisabledFault : public MipsFault<DspStateDisabledFault>
535{
314{
536 private:
537 static FaultName _name;
538 static FaultVect _vect;
539 static FaultStat _count;
540 public:
315 public:
541 FaultName name() const {return _name;}
542 FaultVect vect() {return _vect;}
543 FaultStat & countStat() {return _count;}
544};
545
546class ItbAcvFault : public MipsFault
547{
548 private:
549 static FaultName _name;
550 static FaultVect _vect;
551 static FaultStat _count;
552 public:
553 FaultName name() const {return _name;}
554 FaultVect vect() {return _vect;}
555 FaultStat & countStat() {return _count;}
556};
557
558class IntegerOverflowFault : public MipsFault
559{
560 private:
561 static FaultName _name;
562 static FaultVect _vect;
563 static FaultStat _count;
564 public:
565 FaultName name() const {return _name;}
566 FaultVect vect() {return _vect;}
567 FaultStat & countStat() {return _count;}
568};
569
570class DspStateDisabledFault : public MipsFault
571{
572 private:
573 static FaultName _name;
574 static FaultVect _vect;
575 static FaultStat _count;
576 public:
577 FaultName name() const {return _name;}
578 FaultVect vect() {return _vect;}
579 FaultStat & countStat() {return _count;}
580 void invoke(ThreadContext * tc,
581 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
582};
583
584} // namespace MipsISA
585
586#endif // __MIPS_FAULTS_HH__
316 void invoke(ThreadContext * tc,
317 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
318};
319
320} // namespace MipsISA
321
322#endif // __MIPS_FAULTS_HH__