faults.hh (5684:3995b7c2ae86) faults.hh (5851:7bd73614dc1d)
1/*
2 * Copyright (c) 2007 The Hewlett-Packard Development Company
3 * All rights reserved.
4 *
5 * Redistribution and use of this software in source and binary forms,
6 * with or without modification, are permitted provided that the
7 * following conditions are met:
8 *

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

64namespace X86ISA
65{
66 // Base class for all x86 "faults" where faults is in the m5 sense
67 class X86FaultBase : public FaultBase
68 {
69 protected:
70 const char * faultName;
71 const char * mnem;
1/*
2 * Copyright (c) 2007 The Hewlett-Packard Development Company
3 * All rights reserved.
4 *
5 * Redistribution and use of this software in source and binary forms,
6 * with or without modification, are permitted provided that the
7 * following conditions are met:
8 *

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

64namespace X86ISA
65{
66 // Base class for all x86 "faults" where faults is in the m5 sense
67 class X86FaultBase : public FaultBase
68 {
69 protected:
70 const char * faultName;
71 const char * mnem;
72 uint8_t vector;
72 uint64_t errorCode;
73
74 X86FaultBase(const char * _faultName, const char * _mnem,
73 uint64_t errorCode;
74
75 X86FaultBase(const char * _faultName, const char * _mnem,
75 uint64_t _errorCode = 0) :
76 faultName(_faultName), mnem(_mnem), errorCode(_errorCode)
76 const uint8_t _vector, uint64_t _errorCode = 0) :
77 faultName(_faultName), mnem(_mnem),
78 vector(_vector), errorCode(_errorCode)
77 {
78 }
79
80 const char * name() const
81 {
82 return faultName;
83 }
84

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

100 };
101
102 // Base class for x86 faults which behave as if the underlying instruction
103 // didn't happen.
104 class X86Fault : public X86FaultBase
105 {
106 protected:
107 X86Fault(const char * name, const char * mnem,
79 {
80 }
81
82 const char * name() const
83 {
84 return faultName;
85 }
86

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

102 };
103
104 // Base class for x86 faults which behave as if the underlying instruction
105 // didn't happen.
106 class X86Fault : public X86FaultBase
107 {
108 protected:
109 X86Fault(const char * name, const char * mnem,
108 uint64_t _errorCode = 0) :
109 X86FaultBase(name, mnem, _errorCode)
110 const uint8_t vector, uint64_t _errorCode = 0) :
111 X86FaultBase(name, mnem, vector, _errorCode)
110 {}
111 };
112
113 // Base class for x86 traps which behave as if the underlying instruction
114 // completed.
115 class X86Trap : public X86FaultBase
116 {
117 protected:
118 X86Trap(const char * name, const char * mnem,
112 {}
113 };
114
115 // Base class for x86 traps which behave as if the underlying instruction
116 // completed.
117 class X86Trap : public X86FaultBase
118 {
119 protected:
120 X86Trap(const char * name, const char * mnem,
119 uint64_t _errorCode = 0) :
120 X86FaultBase(name, mnem, _errorCode)
121 const uint8_t vector, uint64_t _errorCode = 0) :
122 X86FaultBase(name, mnem, vector, _errorCode)
121 {}
122
123#if FULL_SYSTEM
124 void invoke(ThreadContext * tc);
125#endif
126 };
127
128 // Base class for x86 aborts which seem to be catastrophic failures.
129 class X86Abort : public X86FaultBase
130 {
131 protected:
132 X86Abort(const char * name, const char * mnem,
123 {}
124
125#if FULL_SYSTEM
126 void invoke(ThreadContext * tc);
127#endif
128 };
129
130 // Base class for x86 aborts which seem to be catastrophic failures.
131 class X86Abort : public X86FaultBase
132 {
133 protected:
134 X86Abort(const char * name, const char * mnem,
133 uint64_t _errorCode = 0) :
134 X86FaultBase(name, mnem, _errorCode)
135 const uint8_t vector, uint64_t _errorCode = 0) :
136 X86FaultBase(name, mnem, vector, _errorCode)
135 {}
136
137#if FULL_SYSTEM
138 void invoke(ThreadContext * tc);
139#endif
140 };
141
142 // Base class for x86 interrupts.
143 class X86Interrupt : public X86FaultBase
144 {
145 protected:
137 {}
138
139#if FULL_SYSTEM
140 void invoke(ThreadContext * tc);
141#endif
142 };
143
144 // Base class for x86 interrupts.
145 class X86Interrupt : public X86FaultBase
146 {
147 protected:
146 uint8_t vector;
147 X86Interrupt(const char * name, const char * mnem, uint8_t _vector,
148 uint64_t _errorCode = 0) :
149 X86FaultBase(name, mnem, _errorCode), vector(_vector)
148 X86Interrupt(const char * name, const char * mnem,
149 const uint8_t _vector, uint64_t _errorCode = 0) :
150 X86FaultBase(name, mnem, _vector, _errorCode)
150 {}
151
152#if FULL_SYSTEM
153 void invoke(ThreadContext * tc);
154#endif
155 };
156
157 class UnimpInstFault : public FaultBase

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

203 // 31 Reserved
204 //Benign Interrupt 0-255 External Interrupts #INTR
205 //Benign Interrupt 0-255 Software Interrupts INTn
206
207 class DivideByZero : public X86Fault
208 {
209 public:
210 DivideByZero() :
151 {}
152
153#if FULL_SYSTEM
154 void invoke(ThreadContext * tc);
155#endif
156 };
157
158 class UnimpInstFault : public FaultBase

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

204 // 31 Reserved
205 //Benign Interrupt 0-255 External Interrupts #INTR
206 //Benign Interrupt 0-255 Software Interrupts INTn
207
208 class DivideByZero : public X86Fault
209 {
210 public:
211 DivideByZero() :
211 X86Fault("Divide-by-Zero-Error", "#DE")
212 X86Fault("Divide-by-Zero-Error", "#DE", 0)
212 {}
213 };
214
215 class DebugException : public X86FaultBase
216 {
217 public:
218 DebugException() :
213 {}
214 };
215
216 class DebugException : public X86FaultBase
217 {
218 public:
219 DebugException() :
219 X86FaultBase("Debug", "#DB")
220 X86FaultBase("Debug", "#DB", 1)
220 {}
221 };
222
223 class NonMaskableInterrupt : public X86Interrupt
224 {
225 public:
226 NonMaskableInterrupt(uint8_t _vector) :
221 {}
222 };
223
224 class NonMaskableInterrupt : public X86Interrupt
225 {
226 public:
227 NonMaskableInterrupt(uint8_t _vector) :
227 X86Interrupt("Non Maskable Interrupt", "#NMI", _vector)
228 X86Interrupt("Non Maskable Interrupt", "#NMI", 2, _vector)
228 {}
229 };
230
231 class Breakpoint : public X86Trap
232 {
233 public:
234 Breakpoint() :
229 {}
230 };
231
232 class Breakpoint : public X86Trap
233 {
234 public:
235 Breakpoint() :
235 X86Trap("Breakpoint", "#BP")
236 X86Trap("Breakpoint", "#BP", 3)
236 {}
237 };
238
239 class OverflowTrap : public X86Trap
240 {
241 public:
242 OverflowTrap() :
237 {}
238 };
239
240 class OverflowTrap : public X86Trap
241 {
242 public:
243 OverflowTrap() :
243 X86Trap("Overflow", "#OF")
244 X86Trap("Overflow", "#OF", 4)
244 {}
245 };
246
247 class BoundRange : public X86Fault
248 {
249 public:
250 BoundRange() :
245 {}
246 };
247
248 class BoundRange : public X86Fault
249 {
250 public:
251 BoundRange() :
251 X86Fault("Bound-Range", "#BR")
252 X86Fault("Bound-Range", "#BR", 5)
252 {}
253 };
254
255 class InvalidOpcode : public X86Fault
256 {
257 public:
258 InvalidOpcode() :
253 {}
254 };
255
256 class InvalidOpcode : public X86Fault
257 {
258 public:
259 InvalidOpcode() :
259 X86Fault("Invalid-Opcode", "#UD")
260 X86Fault("Invalid-Opcode", "#UD", 6)
260 {}
261 };
262
263 class DeviceNotAvailable : public X86Fault
264 {
265 public:
266 DeviceNotAvailable() :
261 {}
262 };
263
264 class DeviceNotAvailable : public X86Fault
265 {
266 public:
267 DeviceNotAvailable() :
267 X86Fault("Device-Not-Available", "#NM")
268 X86Fault("Device-Not-Available", "#NM", 7)
268 {}
269 };
270
271 class DoubleFault : public X86Abort
272 {
273 public:
274 DoubleFault() :
269 {}
270 };
271
272 class DoubleFault : public X86Abort
273 {
274 public:
275 DoubleFault() :
275 X86Abort("Double-Fault", "#DF")
276 X86Abort("Double-Fault", "#DF", 8)
276 {}
277 };
278
279 class InvalidTSS : public X86Fault
280 {
281 public:
282 InvalidTSS() :
277 {}
278 };
279
280 class InvalidTSS : public X86Fault
281 {
282 public:
283 InvalidTSS() :
283 X86Fault("Invalid-TSS", "#TS")
284 X86Fault("Invalid-TSS", "#TS", 10)
284 {}
285 };
286
287 class SegmentNotPresent : public X86Fault
288 {
289 public:
290 SegmentNotPresent() :
285 {}
286 };
287
288 class SegmentNotPresent : public X86Fault
289 {
290 public:
291 SegmentNotPresent() :
291 X86Fault("Segment-Not-Present", "#NP")
292 X86Fault("Segment-Not-Present", "#NP", 11)
292 {}
293 };
294
295 class StackFault : public X86Fault
296 {
297 public:
298 StackFault() :
293 {}
294 };
295
296 class StackFault : public X86Fault
297 {
298 public:
299 StackFault() :
299 X86Fault("Stack", "#SS")
300 X86Fault("Stack", "#SS", 12)
300 {}
301 };
302
303 class GeneralProtection : public X86Fault
304 {
305 public:
306 GeneralProtection(uint64_t _errorCode) :
301 {}
302 };
303
304 class GeneralProtection : public X86Fault
305 {
306 public:
307 GeneralProtection(uint64_t _errorCode) :
307 X86Fault("General-Protection", "#GP", _errorCode)
308 X86Fault("General-Protection", "#GP", 13, _errorCode)
308 {}
309 };
310
311 class PageFault : public X86Fault
312 {
313 public:
314 PageFault() :
309 {}
310 };
311
312 class PageFault : public X86Fault
313 {
314 public:
315 PageFault() :
315 X86Fault("Page-Fault", "#PF")
316 X86Fault("Page-Fault", "#PF", 14)
316 {}
317 };
318
319 class X87FpExceptionPending : public X86Fault
320 {
321 public:
322 X87FpExceptionPending() :
317 {}
318 };
319
320 class X87FpExceptionPending : public X86Fault
321 {
322 public:
323 X87FpExceptionPending() :
323 X86Fault("x87 Floating-Point Exception Pending", "#MF")
324 X86Fault("x87 Floating-Point Exception Pending", "#MF", 16)
324 {}
325 };
326
327 class AlignmentCheck : public X86Fault
328 {
329 public:
330 AlignmentCheck() :
325 {}
326 };
327
328 class AlignmentCheck : public X86Fault
329 {
330 public:
331 AlignmentCheck() :
331 X86Fault("Alignment-Check", "#AC")
332 X86Fault("Alignment-Check", "#AC", 17)
332 {}
333 };
334
335 class MachineCheck : public X86Abort
336 {
337 public:
338 MachineCheck() :
333 {}
334 };
335
336 class MachineCheck : public X86Abort
337 {
338 public:
339 MachineCheck() :
339 X86Abort("Machine-Check", "#MC")
340 X86Abort("Machine-Check", "#MC", 18)
340 {}
341 };
342
343 class SIMDFloatingPointFault : public X86Fault
344 {
345 public:
346 SIMDFloatingPointFault() :
341 {}
342 };
343
344 class SIMDFloatingPointFault : public X86Fault
345 {
346 public:
347 SIMDFloatingPointFault() :
347 X86Fault("SIMD Floating-Point", "#XF")
348 X86Fault("SIMD Floating-Point", "#XF", 19)
348 {}
349 };
350
351 class SecurityException : public X86FaultBase
352 {
353 public:
354 SecurityException() :
349 {}
350 };
351
352 class SecurityException : public X86FaultBase
353 {
354 public:
355 SecurityException() :
355 X86FaultBase("Security Exception", "#SX")
356 X86FaultBase("Security Exception", "#SX", 30)
356 {}
357 };
358
359 class ExternalInterrupt : public X86Interrupt
360 {
361 public:
362 ExternalInterrupt(uint8_t _vector) :
363 X86Interrupt("External Interrupt", "#INTR", _vector)

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

392 // These faults aren't part of the ISA definition. They trigger filling
393 // the tlb on a miss and are to take the place of a hardware table walker.
394 class FakeITLBFault : public X86Fault
395 {
396 protected:
397 Addr vaddr;
398 public:
399 FakeITLBFault(Addr _vaddr) :
357 {}
358 };
359
360 class ExternalInterrupt : public X86Interrupt
361 {
362 public:
363 ExternalInterrupt(uint8_t _vector) :
364 X86Interrupt("External Interrupt", "#INTR", _vector)

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

393 // These faults aren't part of the ISA definition. They trigger filling
394 // the tlb on a miss and are to take the place of a hardware table walker.
395 class FakeITLBFault : public X86Fault
396 {
397 protected:
398 Addr vaddr;
399 public:
400 FakeITLBFault(Addr _vaddr) :
400 X86Fault("fake instruction tlb fault", "itlb"),
401 X86Fault("fake instruction tlb fault", "itlb", 0),
401 vaddr(_vaddr)
402 {}
403
404 void invoke(ThreadContext * tc);
405 };
406
407 class FakeDTLBFault : public X86Fault
408 {
409 protected:
410 Addr vaddr;
411 public:
412 FakeDTLBFault(Addr _vaddr) :
402 vaddr(_vaddr)
403 {}
404
405 void invoke(ThreadContext * tc);
406 };
407
408 class FakeDTLBFault : public X86Fault
409 {
410 protected:
411 Addr vaddr;
412 public:
413 FakeDTLBFault(Addr _vaddr) :
413 X86Fault("fake data tlb fault", "dtlb"),
414 X86Fault("fake data tlb fault", "dtlb", 0),
414 vaddr(_vaddr)
415 {}
416
417 void invoke(ThreadContext * tc);
418 };
419};
420
421#endif // __ARCH_X86_FAULTS_HH__
415 vaddr(_vaddr)
416 {}
417
418 void invoke(ThreadContext * tc);
419 };
420};
421
422#endif // __ARCH_X86_FAULTS_HH__