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