faults.hh revision 2527
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 29#ifndef __ALPHA_FAULTS_HH__ 30#define __ALPHA_FAULTS_HH__ 31 32#include "sim/faults.hh" 33 34// The design of the "name" and "vect" functions is in sim/faults.hh 35 36namespace SparcISA 37{ 38 39typedef const uint32_t TrapType; 40typedef const uint32_t FaultPriority; 41 42class SparcFault : public FaultBase 43{ 44 public: 45#if FULL_SYSTEM 46 void invoke(ExecContext * xc); 47#endif 48 virtual TrapType trapType() = 0; 49 virtual FaultPriority priority() = 0; 50 virtual FaultStat & countStat() = 0; 51}; 52 53class InternalProcessorError : public SparcFault 54{ 55 private: 56 static FaultName _name; 57 static TrapType _trapType; 58 static FaultPriority _priority; 59 static FaultStat _count; 60 public: 61 FaultName name() {return _name;} 62 TrapType trapType() {return _trapType;} 63 FaultPriority priority() {return _priority;} 64 FaultStat & countStat() {return _count;} 65 bool isMachineCheckFault() {return true;} 66}; 67 68class MemAddressNotAligned : public SparcFault 69{ 70 private: 71 static FaultName _name; 72 static TrapType _trapType; 73 static FaultPriority _priority; 74 static FaultStat _count; 75 public: 76 FaultName name() {return _name;} 77 TrapType trapType() {return _trapType;} 78 FaultPriority priority() {return _priority;} 79 FaultStat & countStat() {return _count;} 80 bool isAlignmentFault() {return true;} 81}; 82 83static inline Fault genMachineCheckFault() 84{ 85 return new InternalProcessorError; 86} 87 88static inline Fault genAlignmentFault() 89{ 90 return new MemAddressNotAligned; 91} 92 93class PowerOnReset : public SparcFault 94{ 95 private: 96 static FaultName _name; 97 static TrapType _trapType; 98 static FaultPriority _priority; 99 static FaultStat _count; 100 public: 101 FaultName name() {return _name;} 102 TrapType trapType() {return _trapType;} 103 FaultPriority priority() {return _priority;} 104 FaultStat & countStat() {return _count;} 105}; 106 107class WatchDogReset : public SparcFault 108{ 109 private: 110 static FaultName _name; 111 static TrapType _trapType; 112 static FaultPriority _priority; 113 static FaultStat _count; 114 public: 115 FaultName name() {return _name;} 116 TrapType trapType() {return _trapType;} 117 FaultPriority priority() {return _priority;} 118 FaultStat & countStat() {return _count;} 119}; 120 121class ExternallyInitiatedReset : public SparcFault 122{ 123 private: 124 static FaultName _name; 125 static TrapType _trapType; 126 static FaultPriority _priority; 127 static FaultStat _count; 128 public: 129 FaultName name() {return _name;} 130 TrapType trapType() {return _trapType;} 131 FaultPriority priority() {return _priority;} 132 FaultStat & countStat() {return _count;} 133}; 134 135class SoftwareInitiatedReset : public SparcFault 136{ 137 private: 138 static FaultName _name; 139 static TrapType _trapType; 140 static FaultPriority _priority; 141 static FaultStat _count; 142 public: 143 FaultName name() {return _name;} 144 TrapType trapType() {return _trapType;} 145 FaultPriority priority() {return _priority;} 146 FaultStat & countStat() {return _count;} 147}; 148 149class REDStateException : public SparcFault 150{ 151 private: 152 static FaultName _name; 153 static TrapType _trapType; 154 static FaultPriority _priority; 155 static FaultStat _count; 156 public: 157 FaultName name() {return _name;} 158 TrapType trapType() {return _trapType;} 159 FaultPriority priority() {return _priority;} 160 FaultStat & countStat() {return _count;} 161}; 162 163class InstructionAccessException : public SparcFault 164{ 165 private: 166 static FaultName _name; 167 static TrapType _trapType; 168 static FaultPriority _priority; 169 static FaultStat _count; 170 public: 171 FaultName name() {return _name;} 172 TrapType trapType() {return _trapType;} 173 FaultPriority priority() {return _priority;} 174 FaultStat & countStat() {return _count;} 175}; 176 177class InstructionAccessMMUMiss : public SparcFault 178{ 179 private: 180 static FaultName _name; 181 static TrapType _trapType; 182 static FaultPriority _priority; 183 static FaultStat _count; 184 public: 185 FaultName name() {return _name;} 186 TrapType trapType() {return _trapType;} 187 FaultPriority priority() {return _priority;} 188 FaultStat & countStat() {return _count;} 189}; 190 191class InstructionAccessError : public SparcFault 192{ 193 private: 194 static FaultName _name; 195 static TrapType _trapType; 196 static FaultPriority _priority; 197 static FaultStat _count; 198 public: 199 FaultName name() {return _name;} 200 TrapType trapType() {return _trapType;} 201 FaultPriority priority() {return _priority;} 202 FaultStat & countStat() {return _count;} 203}; 204 205class IllegalInstruction : public SparcFault 206{ 207 private: 208 static FaultName _name; 209 static TrapType _trapType; 210 static FaultPriority _priority; 211 static FaultStat _count; 212 public: 213 FaultName name() {return _name;} 214 TrapType trapType() {return _trapType;} 215 FaultPriority priority() {return _priority;} 216 FaultStat & countStat() {return _count;} 217}; 218 219class PrivilegedOpcode : public SparcFault 220{ 221 private: 222 static FaultName _name; 223 static TrapType _trapType; 224 static FaultPriority _priority; 225 static FaultStat _count; 226 public: 227 FaultName name() {return _name;} 228 TrapType trapType() {return _trapType;} 229 FaultPriority priority() {return _priority;} 230 FaultStat & countStat() {return _count;} 231}; 232 233class UnimplementedLDD : public SparcFault 234{ 235 private: 236 static FaultName _name; 237 static TrapType _trapType; 238 static FaultPriority _priority; 239 static FaultStat _count; 240 public: 241 FaultName name() {return _name;} 242 TrapType trapType() {return _trapType;} 243 FaultPriority priority() {return _priority;} 244 FaultStat & countStat() {return _count;} 245}; 246 247class UnimplementedSTD : public SparcFault 248{ 249 private: 250 static FaultName _name; 251 static TrapType _trapType; 252 static FaultPriority _priority; 253 static FaultStat _count; 254 public: 255 FaultName name() {return _name;} 256 TrapType trapType() {return _trapType;} 257 FaultPriority priority() {return _priority;} 258 FaultStat & countStat() {return _count;} 259}; 260 261class FpDisabled : public SparcFault 262{ 263 private: 264 static FaultName _name; 265 static TrapType _trapType; 266 static FaultPriority _priority; 267 static FaultStat _count; 268 public: 269 FaultName name() {return _name;} 270 TrapType trapType() {return _trapType;} 271 FaultPriority priority() {return _priority;} 272 FaultStat & countStat() {return _count;} 273}; 274 275class FpExceptionIEEE754 : public SparcFault 276{ 277 private: 278 static FaultName _name; 279 static TrapType _trapType; 280 static FaultPriority _priority; 281 static FaultStat _count; 282 public: 283 FaultName name() {return _name;} 284 TrapType trapType() {return _trapType;} 285 FaultPriority priority() {return _priority;} 286 FaultStat & countStat() {return _count;} 287}; 288 289class FpExceptionOther : public SparcFault 290{ 291 private: 292 static FaultName _name; 293 static TrapType _trapType; 294 static FaultPriority _priority; 295 static FaultStat _count; 296 public: 297 FaultName name() {return _name;} 298 TrapType trapType() {return _trapType;} 299 FaultPriority priority() {return _priority;} 300 FaultStat & countStat() {return _count;} 301}; 302 303class TagOverflow : public SparcFault 304{ 305 private: 306 static FaultName _name; 307 static TrapType _trapType; 308 static FaultPriority _priority; 309 static FaultStat _count; 310 public: 311 FaultName name() {return _name;} 312 TrapType trapType() {return _trapType;} 313 FaultPriority priority() {return _priority;} 314 FaultStat & countStat() {return _count;} 315}; 316 317class DivisionByZero : public SparcFault 318{ 319 private: 320 static FaultName _name; 321 static TrapType _trapType; 322 static FaultPriority _priority; 323 static FaultStat _count; 324 public: 325 FaultName name() {return _name;} 326 TrapType trapType() {return _trapType;} 327 FaultPriority priority() {return _priority;} 328 FaultStat & countStat() {return _count;} 329}; 330 331class DataAccessException : public SparcFault 332{ 333 private: 334 static FaultName _name; 335 static TrapType _trapType; 336 static FaultPriority _priority; 337 static FaultStat _count; 338 public: 339 FaultName name() {return _name;} 340 TrapType trapType() {return _trapType;} 341 FaultPriority priority() {return _priority;} 342 FaultStat & countStat() {return _count;} 343}; 344 345class DataAccessMMUMiss : public SparcFault 346{ 347 private: 348 static FaultName _name; 349 static TrapType _trapType; 350 static FaultPriority _priority; 351 static FaultStat _count; 352 public: 353 FaultName name() {return _name;} 354 TrapType trapType() {return _trapType;} 355 FaultPriority priority() {return _priority;} 356 FaultStat & countStat() {return _count;} 357}; 358 359class DataAccessError : public SparcFault 360{ 361 private: 362 static FaultName _name; 363 static TrapType _trapType; 364 static FaultPriority _priority; 365 static FaultStat _count; 366 public: 367 FaultName name() {return _name;} 368 TrapType trapType() {return _trapType;} 369 FaultPriority priority() {return _priority;} 370 FaultStat & countStat() {return _count;} 371}; 372 373class DataAccessProtection : public SparcFault 374{ 375 private: 376 static FaultName _name; 377 static TrapType _trapType; 378 static FaultPriority _priority; 379 static FaultStat _count; 380 public: 381 FaultName name() {return _name;} 382 TrapType trapType() {return _trapType;} 383 FaultPriority priority() {return _priority;} 384 FaultStat & countStat() {return _count;} 385}; 386 387class LDDFMemAddressNotAligned : public SparcFault 388{ 389 private: 390 static FaultName _name; 391 static TrapType _trapType; 392 static FaultPriority _priority; 393 static FaultStat _count; 394 public: 395 FaultName name() {return _name;} 396 TrapType trapType() {return _trapType;} 397 FaultPriority priority() {return _priority;} 398 FaultStat & countStat() {return _count;} 399}; 400 401class STDFMemAddressNotAligned : public SparcFault 402{ 403 private: 404 static FaultName _name; 405 static TrapType _trapType; 406 static FaultPriority _priority; 407 static FaultStat _count; 408 public: 409 FaultName name() {return _name;} 410 TrapType trapType() {return _trapType;} 411 FaultPriority priority() {return _priority;} 412 FaultStat & countStat() {return _count;} 413}; 414 415class PrivilegedAction : public SparcFault 416{ 417 private: 418 static FaultName _name; 419 static TrapType _trapType; 420 static FaultPriority _priority; 421 static FaultStat _count; 422 public: 423 FaultName name() {return _name;} 424 TrapType trapType() {return _trapType;} 425 FaultPriority priority() {return _priority;} 426 FaultStat & countStat() {return _count;} 427}; 428 429class LDQFMemAddressNotAligned : public SparcFault 430{ 431 private: 432 static FaultName _name; 433 static TrapType _trapType; 434 static FaultPriority _priority; 435 static FaultStat _count; 436 public: 437 FaultName name() {return _name;} 438 TrapType trapType() {return _trapType;} 439 FaultPriority priority() {return _priority;} 440 FaultStat & countStat() {return _count;} 441}; 442 443class STQFMemAddressNotAligned : public SparcFault 444{ 445 private: 446 static FaultName _name; 447 static TrapType _trapType; 448 static FaultPriority _priority; 449 static FaultStat _count; 450 public: 451 FaultName name() {return _name;} 452 TrapType trapType() {return _trapType;} 453 FaultPriority priority() {return _priority;} 454 FaultStat & countStat() {return _count;} 455}; 456 457class AsyncDataError : public SparcFault 458{ 459 private: 460 static FaultName _name; 461 static TrapType _trapType; 462 static FaultPriority _priority; 463 static FaultStat _count; 464 public: 465 FaultName name() {return _name;} 466 TrapType trapType() {return _trapType;} 467 FaultPriority priority() {return _priority;} 468 FaultStat & countStat() {return _count;} 469}; 470 471class CleanWindow : public SparcFault 472{ 473 private: 474 static FaultName _name; 475 static TrapType _trapType; 476 static FaultPriority _priority; 477 static FaultStat _count; 478 public: 479 FaultName name() {return _name;} 480 TrapType trapType() {return _trapType;} 481 FaultPriority priority() {return _priority;} 482 FaultStat & countStat() {return _count;} 483}; 484 485class EnumeratedFault : public SparcFault 486{ 487 protected: 488 uint32_t _n; 489 virtual TrapType baseTrapType() = 0; 490 public: 491 EnumeratedFault(uint32_t n) : SparcFault() {_n = n;} 492 TrapType trapType() {return baseTrapType() + _n;} 493}; 494 495class InterruptLevelN : public EnumeratedFault 496{ 497 private: 498 static FaultName _name; 499 static TrapType _baseTrapType; 500 static FaultStat _count; 501 TrapType baseTrapType() {return _baseTrapType;} 502 public: 503 InterruptLevelN(uint32_t n) : EnumeratedFault(n) {;} 504 FaultName name() {return _name;} 505 FaultPriority priority() {return 32 - _n;} 506 FaultStat & countStat() {return _count;} 507}; 508 509class SpillNNormal : public EnumeratedFault 510{ 511 private: 512 static FaultName _name; 513 static TrapType _baseTrapType; 514 static FaultPriority _priority; 515 static FaultStat _count; 516 TrapType baseTrapType() {return _baseTrapType;} 517 public: 518 SpillNNormal(uint32_t n) : EnumeratedFault(n) {;} 519 FaultName name() {return _name;} 520 FaultPriority priority() {return _priority;} 521 FaultStat & countStat() {return _count;} 522}; 523 524class SpillNOther : public EnumeratedFault 525{ 526 private: 527 static FaultName _name; 528 static TrapType _baseTrapType; 529 static FaultPriority _priority; 530 static FaultStat _count; 531 TrapType baseTrapType() {return _baseTrapType;} 532 public: 533 SpillNOther(uint32_t n) : EnumeratedFault(n) {;} 534 FaultName name() {return _name;} 535 FaultPriority priority() {return _priority;} 536 FaultStat & countStat() {return _count;} 537}; 538 539class FillNNormal : public EnumeratedFault 540{ 541 private: 542 static FaultName _name; 543 static TrapType _baseTrapType; 544 static FaultPriority _priority; 545 static FaultStat _count; 546 TrapType baseTrapType() {return _baseTrapType;} 547 public: 548 FillNNormal(uint32_t n) : EnumeratedFault(n) {;} 549 FaultName name() {return _name;} 550 FaultPriority priority() {return _priority;} 551 FaultStat & countStat() {return _count;} 552}; 553 554class FillNOther : public EnumeratedFault 555{ 556 private: 557 static FaultName _name; 558 static TrapType _baseTrapType; 559 static FaultPriority _priority; 560 static FaultStat _count; 561 TrapType baseTrapType() {return _baseTrapType;} 562 public: 563 FillNOther(uint32_t n) : EnumeratedFault(n) {;} 564 FaultName name() {return _name;} 565 FaultPriority priority() {return _priority;} 566 FaultStat & countStat() {return _count;} 567}; 568 569class TrapInstruction : public EnumeratedFault 570{ 571 private: 572 static FaultName _name; 573 static TrapType _baseTrapType; 574 static FaultPriority _priority; 575 static FaultStat _count; 576 TrapType baseTrapType() {return _baseTrapType;} 577 public: 578 TrapInstruction(uint32_t n) : EnumeratedFault(n) {;} 579 FaultName name() {return _name;} 580 FaultPriority priority() {return _priority;} 581 FaultStat & countStat() {return _count;} 582}; 583 584} // SparcISA namespace 585 586#endif // __FAULTS_HH__ 587