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 87static inline Fault genMachineCheckFault() 88{ 89 return new MachineCheckFault; 90} 91 92class ResetFault : public AlphaFault 93{ 94 private: 95 static FaultName _name; 96 static FaultVect _vect; 97 static FaultStat _count; 98 99 public: 100 FaultName name() const {return _name;} 101 FaultVect vect() {return _vect;} 102 FaultStat & countStat() {return _count;} 103}; 104 105class ArithmeticFault : public AlphaFault 106{ 107 private: 108 static FaultName _name; 109 static FaultVect _vect; 110 static FaultStat _count; 111 112 protected: 113 bool skipFaultingInstruction() {return true;} 114 115 public: 116 FaultName name() const {return _name;} 117 FaultVect vect() {return _vect;} 118 FaultStat & countStat() {return _count;} 119#if FULL_SYSTEM 120 void invoke(ThreadContext * tc, 121 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 122#endif 123}; 124 125class InterruptFault : public AlphaFault 126{ 127 private: 128 static FaultName _name; 129 static FaultVect _vect; 130 static FaultStat _count; 131 132 protected: 133 bool setRestartAddress() {return false;} 134 135 public: 136 FaultName name() const {return _name;} 137 FaultVect vect() {return _vect;} 138 FaultStat & countStat() {return _count;} 139}; 140 141class DtbFault : public AlphaFault 142{ 143 protected: 144 VAddr vaddr; 145 Request::Flags reqFlags; 146 uint64_t flags; 147 148 public: 149 DtbFault(VAddr _vaddr, Request::Flags _reqFlags, uint64_t _flags) 150 : vaddr(_vaddr), reqFlags(_reqFlags), flags(_flags) 151 { } 152 FaultName name() const = 0; 153 FaultVect vect() = 0; 154 FaultStat & countStat() = 0; 155#if FULL_SYSTEM 156 void invoke(ThreadContext * tc, 157 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 158#endif 159}; 160 161class NDtbMissFault : public DtbFault 162{ 163 private: 164 static FaultName _name; 165 static FaultVect _vect; 166 static FaultStat _count; 167 168 public: 169 NDtbMissFault(VAddr vaddr, Request::Flags reqFlags, uint64_t flags) 170 : DtbFault(vaddr, reqFlags, flags) 171 { } 172 FaultName name() const {return _name;} 173 FaultVect vect() {return _vect;} 174 FaultStat & countStat() {return _count;} 175#if !FULL_SYSTEM 176 void invoke(ThreadContext * tc, 177 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 178#endif 179}; 180 181class PDtbMissFault : public DtbFault 182{ 183 private: 184 static FaultName _name; 185 static FaultVect _vect; 186 static FaultStat _count; 187 188 public: 189 PDtbMissFault(VAddr vaddr, Request::Flags reqFlags, uint64_t flags) 190 : DtbFault(vaddr, reqFlags, flags) 191 { } 192 FaultName name() const {return _name;} 193 FaultVect vect() {return _vect;} 194 FaultStat & countStat() {return _count;} 195}; 196 197class DtbPageFault : public DtbFault 198{ 199 private: 200 static FaultName _name; 201 static FaultVect _vect; 202 static FaultStat _count; 203 204 public: 205 DtbPageFault(VAddr vaddr, Request::Flags reqFlags, uint64_t flags) 206 : DtbFault(vaddr, reqFlags, flags) 207 { } 208 FaultName name() const {return _name;} 209 FaultVect vect() {return _vect;} 210 FaultStat & countStat() {return _count;} 211}; 212 213class DtbAcvFault : public DtbFault 214{ 215 private: 216 static FaultName _name; 217 static FaultVect _vect; 218 static FaultStat _count; 219 220 public: 221 DtbAcvFault(VAddr vaddr, Request::Flags reqFlags, uint64_t flags) 222 : DtbFault(vaddr, reqFlags, flags) 223 { } 224 FaultName name() const {return _name;} 225 FaultVect vect() {return _vect;} 226 FaultStat & countStat() {return _count;} 227}; 228 229class DtbAlignmentFault : public DtbFault 230{ 231 private: 232 static FaultName _name; 233 static FaultVect _vect; 234 static FaultStat _count; 235 236 public: 237 DtbAlignmentFault(VAddr vaddr, Request::Flags reqFlags, uint64_t flags) 238 : DtbFault(vaddr, reqFlags, flags) 239 { } 240 FaultName name() const {return _name;} 241 FaultVect vect() {return _vect;} 242 FaultStat & countStat() {return _count;} 243}; 244 245class ItbFault : public AlphaFault 246{ 247 protected: 248 Addr pc; 249 250 public: 251 ItbFault(Addr _pc) : pc(_pc) { } 252 FaultName name() const = 0; 253 FaultVect vect() = 0; 254 FaultStat & countStat() = 0; 255#if FULL_SYSTEM 256 void invoke(ThreadContext * tc, 257 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 258#endif 259}; 260 261class ItbPageFault : public ItbFault 262{ 263 private: 264 static FaultName _name; 265 static FaultVect _vect; 266 static FaultStat _count; 267 268 public: 269 ItbPageFault(Addr pc) : ItbFault(pc) { } 270 FaultName name() const {return _name;} 271 FaultVect vect() {return _vect;} 272 FaultStat & countStat() {return _count;} 273#if !FULL_SYSTEM 274 void invoke(ThreadContext * tc, 275 StaticInstPtr inst = StaticInst::nullStaticInstPtr); 276#endif 277}; 278 279class ItbAcvFault : public ItbFault 280{ 281 private: 282 static FaultName _name; 283 static FaultVect _vect; 284 static FaultStat _count; 285 286 public: 287 ItbAcvFault(Addr pc) : ItbFault(pc) { } 288 FaultName name() const {return _name;} 289 FaultVect vect() {return _vect;} 290 FaultStat & countStat() {return _count;} 291}; 292 293class UnimplementedOpcodeFault : public AlphaFault 294{ 295 private: 296 static FaultName _name; 297 static FaultVect _vect; 298 static FaultStat _count; 299 300 public: 301 FaultName name() const {return _name;} 302 FaultVect vect() {return _vect;} 303 FaultStat & countStat() {return _count;} 304}; 305 306class FloatEnableFault : public AlphaFault 307{ 308 private: 309 static FaultName _name; 310 static FaultVect _vect; 311 static FaultStat _count; 312 313 public: 314 FaultName name() const {return _name;} 315 FaultVect vect() {return _vect;} 316 FaultStat & countStat() {return _count;} 317}; 318 319class PalFault : public AlphaFault 320{ 321 private: 322 static FaultName _name; 323 static FaultVect _vect; 324 static FaultStat _count; 325 326 protected: 327 bool skipFaultingInstruction() {return true;} 328 329 public: 330 FaultName name() const {return _name;} 331 FaultVect vect() {return _vect;} 332 FaultStat & countStat() {return _count;} 333}; 334 335class IntegerOverflowFault : public AlphaFault 336{ 337 private: 338 static FaultName _name; 339 static FaultVect _vect; 340 static FaultStat _count; 341 342 public: 343 FaultName name() const {return _name;} 344 FaultVect vect() {return _vect;} 345 FaultStat & countStat() {return _count;} 346}; 347 348} // namespace AlphaISA 349 350#endif // __ARCH_ALPHA_FAULTS_HH__ |