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