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