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