faults.hh (6019:76890d8b28f5) faults.hh (6735:6437ad24a8a0)
1/*
2 * Copyright (c) 2003-2005 The Regents of The University of Michigan
3 * Copyright (c) 2007-2008 The Florida State University
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

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

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 *
1/*
2 * Copyright (c) 2003-2005 The Regents of The University of Michigan
3 * Copyright (c) 2007-2008 The Florida State University
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

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

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