faults.hh (6379:75d4aaf7dd54) faults.hh (7678:f19b6a3a8cec)
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

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

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

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

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

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

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

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

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;

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

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;

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

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;

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

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;

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

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;

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

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;

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

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;

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

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;

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

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__