faults.hh revision 2984
1/* 2 * Copyright (c) 2003-2005 The Regents of The University of Michigan 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are 7 * met: redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer; 9 * redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution; 12 * neither the name of the copyright holders nor the names of its 13 * contributors may be used to endorse or promote products derived from 14 * this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 * 28 * Authors: Gabe Black 29 * Kevin Lim 30 */ 31 32#ifndef __ALPHA_FAULTS_HH__ 33#define __ALPHA_FAULTS_HH__ 34 35#include "arch/alpha/pagetable.hh" 36#include "sim/faults.hh" 37 38// The design of the "name" and "vect" functions is in sim/faults.hh 39 40namespace AlphaISA 41{ 42 43typedef const Addr FaultVect; 44 45class AlphaFault : public FaultBase 46{ 47 protected: 48 virtual bool skipFaultingInstruction() {return false;} 49 virtual bool setRestartAddress() {return true;} 50 public: 51#if FULL_SYSTEM 52 void invoke(ThreadContext * tc); 53#endif 54 virtual FaultVect vect() = 0; 55 virtual FaultStat & countStat() = 0; 56}; 57 58class MachineCheckFault : public AlphaFault 59{ 60 private: 61 static FaultName _name; 62 static FaultVect _vect; 63 static FaultStat _count; 64 public: 65 FaultName name() {return _name;} 66 FaultVect vect() {return _vect;} 67 FaultStat & countStat() {return _count;} 68 bool isMachineCheckFault() {return true;} 69}; 70 71class AlignmentFault : public AlphaFault 72{ 73 private: 74 static FaultName _name; 75 static FaultVect _vect; 76 static FaultStat _count; 77 public: 78 FaultName name() {return _name;} 79 FaultVect vect() {return _vect;} 80 FaultStat & countStat() {return _count;} 81 bool isAlignmentFault() {return true;} 82}; 83 84#if !FULL_SYSTEM 85class PageTableFault : public AlphaFault 86{ 87 private: 88 Addr vaddr; 89 static FaultName _name; 90 static FaultVect _vect; 91 static FaultStat _count; 92 public: 93 PageTableFault(Addr va) 94 : vaddr(va) {} 95 FaultName name() {return _name;} 96 FaultVect vect() {return _vect;} 97 FaultStat & countStat() {return _count;} 98 void invoke(ThreadContext * tc); 99}; 100 101static inline Fault genPageTableFault(Addr va) 102{ 103 return new PageTableFault(va); 104} 105#endif 106 107static inline Fault genMachineCheckFault() 108{ 109 return new MachineCheckFault; 110} 111 112static inline Fault genAlignmentFault() 113{ 114 return new AlignmentFault; 115} 116 117class ResetFault : public AlphaFault 118{ 119 private: 120 static FaultName _name; 121 static FaultVect _vect; 122 static FaultStat _count; 123 public: 124 FaultName name() {return _name;} 125 FaultVect vect() {return _vect;} 126 FaultStat & countStat() {return _count;} 127}; 128 129class ArithmeticFault : public AlphaFault 130{ 131 protected: 132 bool skipFaultingInstruction() {return true;} 133 private: 134 static FaultName _name; 135 static FaultVect _vect; 136 static FaultStat _count; 137 public: 138 FaultName name() {return _name;} 139 FaultVect vect() {return _vect;} 140 FaultStat & countStat() {return _count;} 141#if FULL_SYSTEM 142 void invoke(ThreadContext * tc); 143#endif 144}; 145 146class InterruptFault : public AlphaFault 147{ 148 protected: 149 bool setRestartAddress() {return false;} 150 private: 151 static FaultName _name; 152 static FaultVect _vect; 153 static FaultStat _count; 154 public: 155 FaultName name() {return _name;} 156 FaultVect vect() {return _vect;} 157 FaultStat & countStat() {return _count;} 158}; 159 160class DtbFault : public AlphaFault 161{ 162#if FULL_SYSTEM 163 private: 164 AlphaISA::VAddr vaddr; 165 uint32_t reqFlags; 166 uint64_t flags; 167 public: 168 DtbFault(AlphaISA::VAddr _vaddr, uint32_t _reqFlags, uint64_t _flags) 169 : vaddr(_vaddr), reqFlags(_reqFlags), flags(_flags) 170 { } 171#endif 172 FaultName name() = 0; 173 FaultVect vect() = 0; 174 FaultStat & countStat() = 0; 175#if FULL_SYSTEM 176 void invoke(ThreadContext * tc); 177#endif 178}; 179 180class NDtbMissFault : public DtbFault 181{ 182 private: 183 static FaultName _name; 184 static FaultVect _vect; 185 static FaultStat _count; 186 public: 187#if FULL_SYSTEM 188 NDtbMissFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags) 189 : DtbFault(vaddr, reqFlags, flags) 190 { } 191#endif 192 FaultName name() {return _name;} 193 FaultVect vect() {return _vect;} 194 FaultStat & countStat() {return _count;} 195}; 196 197class PDtbMissFault : public DtbFault 198{ 199 private: 200 static FaultName _name; 201 static FaultVect _vect; 202 static FaultStat _count; 203 public: 204#if FULL_SYSTEM 205 PDtbMissFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags) 206 : DtbFault(vaddr, reqFlags, flags) 207 { } 208#endif 209 FaultName name() {return _name;} 210 FaultVect vect() {return _vect;} 211 FaultStat & countStat() {return _count;} 212}; 213 214class DtbPageFault : public DtbFault 215{ 216 private: 217 static FaultName _name; 218 static FaultVect _vect; 219 static FaultStat _count; 220 public: 221#if FULL_SYSTEM 222 DtbPageFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags) 223 : DtbFault(vaddr, reqFlags, flags) 224 { } 225#endif 226 FaultName name() {return _name;} 227 FaultVect vect() {return _vect;} 228 FaultStat & countStat() {return _count;} 229}; 230 231class DtbAcvFault : public DtbFault 232{ 233 private: 234 static FaultName _name; 235 static FaultVect _vect; 236 static FaultStat _count; 237 public: 238#if FULL_SYSTEM 239 DtbAcvFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags) 240 : DtbFault(vaddr, reqFlags, flags) 241 { } 242#endif 243 FaultName name() {return _name;} 244 FaultVect vect() {return _vect;} 245 FaultStat & countStat() {return _count;} 246}; 247 248class DtbAlignmentFault : public DtbFault 249{ 250 private: 251 static FaultName _name; 252 static FaultVect _vect; 253 static FaultStat _count; 254 public: 255#if FULL_SYSTEM 256 DtbAlignmentFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags) 257 : DtbFault(vaddr, reqFlags, flags) 258 { } 259#endif 260 FaultName name() {return _name;} 261 FaultVect vect() {return _vect;} 262 FaultStat & countStat() {return _count;} 263}; 264 265class ItbFault : public AlphaFault 266{ 267 private: 268 Addr pc; 269 public: 270 ItbFault(Addr _pc) 271 : pc(_pc) 272 { } 273 FaultName name() = 0; 274 FaultVect vect() = 0; 275 FaultStat & countStat() = 0; 276#if FULL_SYSTEM 277 void invoke(ThreadContext * tc); 278#endif 279}; 280 281class ItbMissFault : public ItbFault 282{ 283 private: 284 static FaultName _name; 285 static FaultVect _vect; 286 static FaultStat _count; 287 public: 288 ItbMissFault(Addr pc) 289 : ItbFault(pc) 290 { } 291 FaultName name() {return _name;} 292 FaultVect vect() {return _vect;} 293 FaultStat & countStat() {return _count;} 294}; 295 296class ItbPageFault : public ItbFault 297{ 298 private: 299 static FaultName _name; 300 static FaultVect _vect; 301 static FaultStat _count; 302 public: 303 ItbPageFault(Addr pc) 304 : ItbFault(pc) 305 { } 306 FaultName name() {return _name;} 307 FaultVect vect() {return _vect;} 308 FaultStat & countStat() {return _count;} 309}; 310 311class ItbAcvFault : public ItbFault 312{ 313 private: 314 static FaultName _name; 315 static FaultVect _vect; 316 static FaultStat _count; 317 public: 318 ItbAcvFault(Addr pc) 319 : ItbFault(pc) 320 { } 321 FaultName name() {return _name;} 322 FaultVect vect() {return _vect;} 323 FaultStat & countStat() {return _count;} 324}; 325 326class UnimplementedOpcodeFault : public AlphaFault 327{ 328 private: 329 static FaultName _name; 330 static FaultVect _vect; 331 static FaultStat _count; 332 public: 333 FaultName name() {return _name;} 334 FaultVect vect() {return _vect;} 335 FaultStat & countStat() {return _count;} 336}; 337 338class FloatEnableFault : public AlphaFault 339{ 340 private: 341 static FaultName _name; 342 static FaultVect _vect; 343 static FaultStat _count; 344 public: 345 FaultName name() {return _name;} 346 FaultVect vect() {return _vect;} 347 FaultStat & countStat() {return _count;} 348}; 349 350class PalFault : public AlphaFault 351{ 352 protected: 353 bool skipFaultingInstruction() {return true;} 354 private: 355 static FaultName _name; 356 static FaultVect _vect; 357 static FaultStat _count; 358 public: 359 FaultName name() {return _name;} 360 FaultVect vect() {return _vect;} 361 FaultStat & countStat() {return _count;} 362}; 363 364class IntegerOverflowFault : public AlphaFault 365{ 366 private: 367 static FaultName _name; 368 static FaultVect _vect; 369 static FaultStat _count; 370 public: 371 FaultName name() {return _name;} 372 FaultVect vect() {return _vect;} 373 FaultStat & countStat() {return _count;} 374}; 375 376} // AlphaISA namespace 377 378#endif // __FAULTS_HH__ 379