1// -*- mode:c++ -*- 2 3// Copyright (c) 2003-2005 The Regents of The University of Michigan 4// All rights reserved. 5// 6// Redistribution and use in source and binary forms, with or without 7// modification, are permitted provided that the following conditions are 8// met: redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer; 10// redistributions in binary form must reproduce the above copyright 11// notice, this list of conditions and the following disclaimer in the 12// documentation and/or other materials provided with the distribution; 13// neither the name of the copyright holders nor the names of its 14// contributors may be used to endorse or promote products derived from 15// this software without specific prior written permission. 16// 17// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
| 1// -*- mode:c++ -*- 2 3// Copyright (c) 2003-2005 The Regents of The University of Michigan 4// All rights reserved. 5// 6// Redistribution and use in source and binary forms, with or without 7// modification, are permitted provided that the following conditions are 8// met: redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer; 10// redistributions in binary form must reproduce the above copyright 11// notice, this list of conditions and the following disclaimer in the 12// documentation and/or other materials provided with the distribution; 13// neither the name of the copyright holders nor the names of its 14// contributors may be used to endorse or promote products derived from 15// this software without specific prior written permission. 16// 17// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
28 29//////////////////////////////////////////////////////////////////// 30// 31// Unimplemented instructions 32// 33 34output header {{ 35 /** 36 * Static instruction class for unimplemented instructions that 37 * cause simulator termination. Note that these are recognized 38 * (legal) instructions that the simulator does not support; the 39 * 'Unknown' class is used for unrecognized/illegal instructions. 40 * This is a leaf class. 41 */ 42 class FailUnimplemented : public MipsStaticInst 43 { 44 public: 45 /// Constructor 46 FailUnimplemented(const char *_mnemonic, MachInst _machInst) 47 : MipsStaticInst(_mnemonic, _machInst, No_OpClass) 48 { 49 // don't call execute() (which panics) if we're on a 50 // speculative path 51 flags[IsNonSpeculative] = true; 52 } 53 54 %(BasicExecDeclare)s 55 56 std::string 57 generateDisassembly(Addr pc, const SymbolTable *symtab) const; 58 }; 59 60 /** 61 * Base class for unimplemented instructions that cause a warning 62 * to be printed (but do not terminate simulation). This 63 * implementation is a little screwy in that it will print a 64 * warning for each instance of a particular unimplemented machine 65 * instruction, not just for each unimplemented opcode. Should 66 * probably make the 'warned' flag a static member of the derived 67 * class. 68 */ 69 class WarnUnimplemented : public MipsStaticInst 70 { 71 private: 72 /// Have we warned on this instruction yet? 73 mutable bool warned; 74 75 public: 76 /// Constructor 77 WarnUnimplemented(const char *_mnemonic, MachInst _machInst) 78 : MipsStaticInst(_mnemonic, _machInst, No_OpClass), warned(false) 79 { 80 // don't call execute() (which panics) if we're on a 81 // speculative path 82 flags[IsNonSpeculative] = true; 83 } 84 85 %(BasicExecDeclare)s 86 87 std::string 88 generateDisassembly(Addr pc, const SymbolTable *symtab) const; 89 }; 90}}; 91 92output decoder {{ 93 std::string 94 FailUnimplemented::generateDisassembly(Addr pc, 95 const SymbolTable *symtab) const 96 { 97 return csprintf("%-10s (unimplemented)", mnemonic); 98 } 99 100 std::string 101 WarnUnimplemented::generateDisassembly(Addr pc, 102 const SymbolTable *symtab) const 103 { 104#ifdef SS_COMPATIBLE_DISASSEMBLY 105 return csprintf("%-10s", mnemonic); 106#else 107 return csprintf("%-10s (unimplemented)", mnemonic); 108#endif 109 } 110}}; 111 112output exec {{ 113 Fault 114 FailUnimplemented::execute(%(CPU_exec_context)s *xc, 115 Trace::InstRecord *traceData) const 116 { 117 panic("attempt to execute unimplemented instruction '%s' " 118 "(inst 0x%08x, opcode 0x%x, binary:%s)", mnemonic, machInst, OPCODE, 119 inst2string(machInst)); 120 return new UnimplementedOpcodeFault; 121 } 122 123 Fault 124 WarnUnimplemented::execute(%(CPU_exec_context)s *xc, 125 Trace::InstRecord *traceData) const 126 { 127 if (!warned) { 128 warn("instruction '%s' unimplemented\n", mnemonic); 129 warned = true; 130 } 131 132 return NoFault; 133 } 134}}; 135 136 137def format FailUnimpl() {{ 138 iop = InstObjParams(name, 'FailUnimplemented') 139 decode_block = BasicDecodeWithMnemonic.subst(iop) 140}}; 141 142def format WarnUnimpl() {{ 143 iop = InstObjParams(name, 'WarnUnimplemented') 144 decode_block = BasicDecodeWithMnemonic.subst(iop) 145}}; 146 147output header {{ 148 /** 149 * Static instruction class for unknown (illegal) instructions. 150 * These cause simulator termination if they are executed in a 151 * non-speculative mode. This is a leaf class. 152 */ 153 class Unknown : public MipsStaticInst 154 { 155 public: 156 /// Constructor 157 Unknown(MachInst _machInst) 158 : MipsStaticInst("unknown", _machInst, No_OpClass) 159 { 160 // don't call execute() (which panics) if we're on a 161 // speculative path 162 flags[IsNonSpeculative] = true; 163 } 164 165 %(BasicExecDeclare)s 166 167 std::string 168 generateDisassembly(Addr pc, const SymbolTable *symtab) const; 169 }; 170}}; 171
| 30 31//////////////////////////////////////////////////////////////////// 32// 33// Unimplemented instructions 34// 35 36output header {{ 37 /** 38 * Static instruction class for unimplemented instructions that 39 * cause simulator termination. Note that these are recognized 40 * (legal) instructions that the simulator does not support; the 41 * 'Unknown' class is used for unrecognized/illegal instructions. 42 * This is a leaf class. 43 */ 44 class FailUnimplemented : public MipsStaticInst 45 { 46 public: 47 /// Constructor 48 FailUnimplemented(const char *_mnemonic, MachInst _machInst) 49 : MipsStaticInst(_mnemonic, _machInst, No_OpClass) 50 { 51 // 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 MipsStaticInst 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, MachInst _machInst) 80 : MipsStaticInst(_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)s *xc, 117 Trace::InstRecord *traceData) const 118 { 119 panic("attempt to execute unimplemented instruction '%s' " 120 "(inst 0x%08x, opcode 0x%x, binary:%s)", mnemonic, machInst, OPCODE, 121 inst2string(machInst)); 122 return new UnimplementedOpcodeFault; 123 } 124 125 Fault 126 WarnUnimplemented::execute(%(CPU_exec_context)s *xc, 127 Trace::InstRecord *traceData) const 128 { 129 if (!warned) { 130 warn("instruction '%s' unimplemented\n", mnemonic); 131 warned = true; 132 } 133 134 return NoFault; 135 } 136}}; 137 138 139def format FailUnimpl() {{ 140 iop = InstObjParams(name, 'FailUnimplemented') 141 decode_block = BasicDecodeWithMnemonic.subst(iop) 142}}; 143 144def format WarnUnimpl() {{ 145 iop = InstObjParams(name, 'WarnUnimplemented') 146 decode_block = BasicDecodeWithMnemonic.subst(iop) 147}}; 148 149output header {{ 150 /** 151 * Static instruction class for unknown (illegal) instructions. 152 * These cause simulator termination if they are executed in a 153 * non-speculative mode. This is a leaf class. 154 */ 155 class Unknown : public MipsStaticInst 156 { 157 public: 158 /// Constructor 159 Unknown(MachInst _machInst) 160 : MipsStaticInst("unknown", _machInst, No_OpClass) 161 { 162 // don't call execute() (which panics) if we're on a 163 // speculative path 164 flags[IsNonSpeculative] = true; 165 } 166 167 %(BasicExecDeclare)s 168 169 std::string 170 generateDisassembly(Addr pc, const SymbolTable *symtab) const; 171 }; 172}}; 173
|