faults.hh revision 2612
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 29#ifndef __ALPHA_FAULTS_HH__ 30#define __ALPHA_FAULTS_HH__ 31 32#include "arch/alpha/isa_traits.hh" 33#include "sim/faults.hh" 34 35// The design of the "name" and "vect" functions is in sim/faults.hh 36 37namespace AlphaISA 38{ 39 40typedef const Addr FaultVect; 41 42class AlphaFault : public FaultBase 43{ 44 protected: 45 virtual bool skipFaultingInstruction() {return false;} 46 virtual bool setRestartAddress() {return true;} 47 public: 48#if FULL_SYSTEM 49 void invoke(ExecContext * xc); 50#endif 51 virtual FaultVect vect() = 0; 52 virtual FaultStat & countStat() = 0; 53}; 54 55class MachineCheckFault : public AlphaFault 56{ 57 private: 58 static FaultName _name; 59 static FaultVect _vect; 60 static FaultStat _count; 61 public: 62 FaultName name() {return _name;} 63 FaultVect vect() {return _vect;} 64 FaultStat & countStat() {return _count;} 65 bool isMachineCheckFault() {return true;} 66}; 67 68class AlignmentFault : public AlphaFault 69{ 70 private: 71 static FaultName _name; 72 static FaultVect _vect; 73 static FaultStat _count; 74 public: 75 FaultName name() {return _name;} 76 FaultVect vect() {return _vect;} 77 FaultStat & countStat() {return _count;} 78 bool isAlignmentFault() {return true;} 79}; 80 81static inline Fault genMachineCheckFault() 82{ 83 return new MachineCheckFault; 84} 85 86static inline Fault genAlignmentFault() 87{ 88 return new AlignmentFault; 89} 90 91class ResetFault : public AlphaFault 92{ 93 private: 94 static FaultName _name; 95 static FaultVect _vect; 96 static FaultStat _count; 97 public: 98 FaultName name() {return _name;} 99 FaultVect vect() {return _vect;} 100 FaultStat & countStat() {return _count;} 101}; 102 103class ArithmeticFault : public AlphaFault 104{ 105 protected: 106 bool skipFaultingInstruction() {return true;} 107 private: 108 static FaultName _name; 109 static FaultVect _vect; 110 static FaultStat _count; 111 public: 112 FaultName name() {return _name;} 113 FaultVect vect() {return _vect;} 114 FaultStat & countStat() {return _count;} 115#if FULL_SYSTEM 116 void invoke(ExecContext * xc); 117#endif 118}; 119 120class InterruptFault : public AlphaFault 121{ 122 protected: 123 bool setRestartAddress() {return false;} 124 private: 125 static FaultName _name; 126 static FaultVect _vect; 127 static FaultStat _count; 128 public: 129 FaultName name() {return _name;} 130 FaultVect vect() {return _vect;} 131 FaultStat & countStat() {return _count;} 132}; 133 134class DtbFault : public AlphaFault 135{ 136#if FULL_SYSTEM 137 private: 138 AlphaISA::VAddr vaddr; 139 uint32_t reqFlags; 140 uint64_t flags; 141 public: 142 DtbFault(AlphaISA::VAddr _vaddr, uint32_t _reqFlags, uint64_t _flags) 143 : vaddr(_vaddr), reqFlags(_reqFlags), flags(_flags) 144 { } 145#endif 146 FaultName name() = 0; 147 FaultVect vect() = 0; 148 FaultStat & countStat() = 0; 149#if FULL_SYSTEM 150 void invoke(ExecContext * xc); 151#endif 152}; 153 154class NDtbMissFault : public DtbFault 155{ 156 private: 157 static FaultName _name; 158 static FaultVect _vect; 159 static FaultStat _count; 160 public: 161#if FULL_SYSTEM 162 NDtbMissFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags) 163 : DtbFault(vaddr, reqFlags, flags) 164 { } 165#endif 166 FaultName name() {return _name;} 167 FaultVect vect() {return _vect;} 168 FaultStat & countStat() {return _count;} 169}; 170 171class PDtbMissFault : public DtbFault 172{ 173 private: 174 static FaultName _name; 175 static FaultVect _vect; 176 static FaultStat _count; 177 public: 178#if FULL_SYSTEM 179 PDtbMissFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags) 180 : DtbFault(vaddr, reqFlags, flags) 181 { } 182#endif 183 FaultName name() {return _name;} 184 FaultVect vect() {return _vect;} 185 FaultStat & countStat() {return _count;} 186}; 187 188class DtbPageFault : public DtbFault 189{ 190 private: 191 static FaultName _name; 192 static FaultVect _vect; 193 static FaultStat _count; 194 public: 195#if FULL_SYSTEM 196 DtbPageFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags) 197 : DtbFault(vaddr, reqFlags, flags) 198 { } 199#endif 200 FaultName name() {return _name;} 201 FaultVect vect() {return _vect;} 202 FaultStat & countStat() {return _count;} 203}; 204 205class DtbAcvFault : public DtbFault 206{ 207 private: 208 static FaultName _name; 209 static FaultVect _vect; 210 static FaultStat _count; 211 public: 212#if FULL_SYSTEM 213 DtbAcvFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags) 214 : DtbFault(vaddr, reqFlags, flags) 215 { } 216#endif 217 FaultName name() {return _name;} 218 FaultVect vect() {return _vect;} 219 FaultStat & countStat() {return _count;} 220}; 221 222class DtbAlignmentFault : public DtbFault 223{ 224 private: 225 static FaultName _name; 226 static FaultVect _vect; 227 static FaultStat _count; 228 public: 229#if FULL_SYSTEM 230 DtbAlignmentFault(AlphaISA::VAddr vaddr, uint32_t reqFlags, uint64_t flags) 231 : DtbFault(vaddr, reqFlags, flags) 232 { } 233#endif 234 FaultName name() {return _name;} 235 FaultVect vect() {return _vect;} 236 FaultStat & countStat() {return _count;} 237}; 238 239class ItbFault : public AlphaFault 240{ 241 private: 242 Addr pc; 243 public: 244 ItbFault(Addr _pc) 245 : pc(_pc) 246 { } 247 FaultName name() = 0; 248 FaultVect vect() = 0; 249 FaultStat & countStat() = 0; 250#if FULL_SYSTEM 251 void invoke(ExecContext * xc); 252#endif 253}; 254 255class ItbMissFault : public ItbFault 256{ 257 private: 258 static FaultName _name; 259 static FaultVect _vect; 260 static FaultStat _count; 261 public: 262 ItbMissFault(Addr pc) 263 : ItbFault(pc) 264 { } 265 FaultName name() {return _name;} 266 FaultVect vect() {return _vect;} 267 FaultStat & countStat() {return _count;} 268}; 269 270class ItbPageFault : public ItbFault 271{ 272 private: 273 static FaultName _name; 274 static FaultVect _vect; 275 static FaultStat _count; 276 public: 277 ItbPageFault(Addr pc) 278 : ItbFault(pc) 279 { } 280 FaultName name() {return _name;} 281 FaultVect vect() {return _vect;} 282 FaultStat & countStat() {return _count;} 283}; 284 285class ItbAcvFault : public ItbFault 286{ 287 private: 288 static FaultName _name; 289 static FaultVect _vect; 290 static FaultStat _count; 291 public: 292 ItbAcvFault(Addr pc) 293 : ItbFault(pc) 294 { } 295 FaultName name() {return _name;} 296 FaultVect vect() {return _vect;} 297 FaultStat & countStat() {return _count;} 298}; 299 300class UnimplementedOpcodeFault : public AlphaFault 301{ 302 private: 303 static FaultName _name; 304 static FaultVect _vect; 305 static FaultStat _count; 306 public: 307 FaultName name() {return _name;} 308 FaultVect vect() {return _vect;} 309 FaultStat & countStat() {return _count;} 310}; 311 312class FloatEnableFault : public AlphaFault 313{ 314 private: 315 static FaultName _name; 316 static FaultVect _vect; 317 static FaultStat _count; 318 public: 319 FaultName name() {return _name;} 320 FaultVect vect() {return _vect;} 321 FaultStat & countStat() {return _count;} 322}; 323 324class PalFault : public AlphaFault 325{ 326 protected: 327 bool skipFaultingInstruction() {return true;} 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 IntegerOverflowFault : 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 350} // AlphaISA namespace 351 352#endif // __FAULTS_HH__ 353