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,
57 StaticInst::StaticInstPtr inst = StaticInst::nullStaticInstPtr)
58 {}
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
116 void invoke(ThreadContext * tc,
117 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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
133 void invoke(ThreadContext * tc,
134 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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;}
162 void invoke(ThreadContext * tc,
163 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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;}
177 void invoke(ThreadContext * tc,
178 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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;}
240 void invoke(ThreadContext * tc,
241 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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;}
267 void invoke(ThreadContext * tc,
268 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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;}
282 void invoke(ThreadContext * tc,
283 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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;}
296 void invoke(ThreadContext * tc,
297 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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;}
310 void invoke(ThreadContext * tc,
311 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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;}
324 void invoke(ThreadContext * tc,
325 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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;}
339 void invoke(ThreadContext * tc,
340 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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;}
354 void invoke(ThreadContext * tc,
355 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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;}
368 void invoke(ThreadContext * tc,
369 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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
385 void invoke(ThreadContext * tc,
386 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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
404 void invoke(ThreadContext * tc,
405 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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
420 void invoke(ThreadContext * tc,
421 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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
436 void invoke(ThreadContext * tc,
437 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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
452 void invoke(ThreadContext * tc,
453 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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
468 void invoke(ThreadContext * tc,
469 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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
484 void invoke(ThreadContext * tc,
485 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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
500 void invoke(ThreadContext * tc,
501 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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
516 void invoke(ThreadContext * tc,
517 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
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
532 void invoke(ThreadContext * tc,
533 StaticInst::StaticInstPtr inst = nullStaticInstPtr);
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;}
595 void invoke(ThreadContext * tc,
596 StaticInstPtr inst = StaticInst::nullStaticInstPtr);
597};
598
599} // MipsISA namespace
600
601#endif // __MIPS_FAULTS_HH__