unimp.isa revision 10196:be0e1724eb39
112855Sgabeblack@google.com// -*- mode:c++ -*- 212855Sgabeblack@google.com 312855Sgabeblack@google.com// Copyright (c) 2003-2005 The Regents of The University of Michigan 412855Sgabeblack@google.com// All rights reserved. 512855Sgabeblack@google.com// 612855Sgabeblack@google.com// Redistribution and use in source and binary forms, with or without 712855Sgabeblack@google.com// modification, are permitted provided that the following conditions are 812855Sgabeblack@google.com// met: redistributions of source code must retain the above copyright 912855Sgabeblack@google.com// notice, this list of conditions and the following disclaimer; 1012855Sgabeblack@google.com// redistributions in binary form must reproduce the above copyright 1112855Sgabeblack@google.com// notice, this list of conditions and the following disclaimer in the 1212855Sgabeblack@google.com// documentation and/or other materials provided with the distribution; 1312855Sgabeblack@google.com// neither the name of the copyright holders nor the names of its 1412855Sgabeblack@google.com// contributors may be used to endorse or promote products derived from 1512855Sgabeblack@google.com// this software without specific prior written permission. 1612855Sgabeblack@google.com// 1712855Sgabeblack@google.com// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 1812855Sgabeblack@google.com// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 1912855Sgabeblack@google.com// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2012855Sgabeblack@google.com// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2112855Sgabeblack@google.com// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2212855Sgabeblack@google.com// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 2312855Sgabeblack@google.com// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 2412855Sgabeblack@google.com// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 2512855Sgabeblack@google.com// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2612855Sgabeblack@google.com// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 2712855Sgabeblack@google.com// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 2812855Sgabeblack@google.com// 2912855Sgabeblack@google.com// Authors: Steve Reinhardt 3012855Sgabeblack@google.com 3112855Sgabeblack@google.com//////////////////////////////////////////////////////////////////// 3212855Sgabeblack@google.com// 3312855Sgabeblack@google.com// Unimplemented instructions 3412855Sgabeblack@google.com// 3512855Sgabeblack@google.com 3612855Sgabeblack@google.comoutput header {{ 3712855Sgabeblack@google.com /** 3812855Sgabeblack@google.com * Static instruction class for unimplemented instructions that 3912855Sgabeblack@google.com * cause simulator termination. Note that these are recognized 4012855Sgabeblack@google.com * (legal) instructions that the simulator does not support; the 4112855Sgabeblack@google.com * 'Unknown' class is used for unrecognized/illegal instructions. 4212855Sgabeblack@google.com * This is a leaf class. 4312855Sgabeblack@google.com */ 4412855Sgabeblack@google.com class FailUnimplemented : public AlphaStaticInst 4512855Sgabeblack@google.com { 4612855Sgabeblack@google.com public: 4712855Sgabeblack@google.com /// Constructor 4812855Sgabeblack@google.com FailUnimplemented(const char *_mnemonic, ExtMachInst _machInst) 4912855Sgabeblack@google.com : AlphaStaticInst(_mnemonic, _machInst, No_OpClass) 5012855Sgabeblack@google.com { 5112855Sgabeblack@google.com // don't call execute() (which panics) if we're on a 52 // speculative path 53 flags[IsNonSpeculative] = true; 54 } 55 56 %(BasicExecDeclare)s 57 58 std::string 59 generateDisassembly(Addr pc, const SymbolTable *symtab) const; 60 }; 61 62 /** 63 * Base class for unimplemented instructions that cause a warning 64 * to be printed (but do not terminate simulation). This 65 * implementation is a little screwy in that it will print a 66 * warning for each instance of a particular unimplemented machine 67 * instruction, not just for each unimplemented opcode. Should 68 * probably make the 'warned' flag a static member of the derived 69 * class. 70 */ 71 class WarnUnimplemented : public AlphaStaticInst 72 { 73 private: 74 /// Have we warned on this instruction yet? 75 mutable bool warned; 76 77 public: 78 /// Constructor 79 WarnUnimplemented(const char *_mnemonic, ExtMachInst _machInst) 80 : AlphaStaticInst(_mnemonic, _machInst, No_OpClass), warned(false) 81 { 82 // don't call execute() (which panics) if we're on a 83 // speculative path 84 flags[IsNonSpeculative] = true; 85 } 86 87 %(BasicExecDeclare)s 88 89 std::string 90 generateDisassembly(Addr pc, const SymbolTable *symtab) const; 91 }; 92}}; 93 94output decoder {{ 95 std::string 96 FailUnimplemented::generateDisassembly(Addr pc, 97 const SymbolTable *symtab) const 98 { 99 return csprintf("%-10s (unimplemented)", mnemonic); 100 } 101 102 std::string 103 WarnUnimplemented::generateDisassembly(Addr pc, 104 const SymbolTable *symtab) const 105 { 106#ifdef SS_COMPATIBLE_DISASSEMBLY 107 return csprintf("%-10s", mnemonic); 108#else 109 return csprintf("%-10s (unimplemented)", mnemonic); 110#endif 111 } 112}}; 113 114output exec {{ 115 Fault 116 FailUnimplemented::execute(CPU_EXEC_CONTEXT *xc, 117 Trace::InstRecord *traceData) const 118 { 119 panic("attempt to execute unimplemented instruction '%s' " 120 "(inst 0x%08x, opcode 0x%x)", mnemonic, machInst, OPCODE); 121 return new UnimplementedOpcodeFault; 122 } 123 124 Fault 125 WarnUnimplemented::execute(CPU_EXEC_CONTEXT *xc, 126 Trace::InstRecord *traceData) const 127 { 128 if (!warned) { 129 warn("instruction '%s' unimplemented\n", mnemonic); 130 warned = true; 131 } 132 133 return NoFault; 134 } 135}}; 136 137 138def format FailUnimpl() {{ 139 iop = InstObjParams(name, 'FailUnimplemented') 140 decode_block = BasicDecodeWithMnemonic.subst(iop) 141}}; 142 143def format WarnUnimpl() {{ 144 iop = InstObjParams(name, 'WarnUnimplemented') 145 decode_block = BasicDecodeWithMnemonic.subst(iop) 146}}; 147 148output header {{ 149 /** 150 * Static instruction class for unknown (illegal) instructions. 151 * These cause simulator termination if they are executed in a 152 * non-speculative mode. This is a leaf class. 153 */ 154 class Unknown : public AlphaStaticInst 155 { 156 public: 157 /// Constructor 158 Unknown(ExtMachInst _machInst) 159 : AlphaStaticInst("unknown", _machInst, No_OpClass) 160 { 161 // don't call execute() (which panics) if we're on a 162 // speculative path 163 flags[IsNonSpeculative] = true; 164 } 165 166 %(BasicExecDeclare)s 167 168 std::string 169 generateDisassembly(Addr pc, const SymbolTable *symtab) const; 170 }; 171}}; 172 173