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