// -*- mode:c++ -*- // Copyright (c) 2007 MIPS Technologies, Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer; // redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the distribution; // neither the name of the copyright holders nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // // Authors: Korey Sewell //////////////////////////////////////////////////////////////////// // // Unimplemented instructions // output header {{ /** * Static instruction class for unimplemented instructions that * cause simulator termination. Note that these are recognized * (legal) instructions that the simulator does not support; the * 'Unknown' class is used for unrecognized/illegal instructions. * This is a leaf class. */ class FailUnimplemented : public MipsStaticInst { public: /// Constructor FailUnimplemented(const char *_mnemonic, MachInst _machInst) : MipsStaticInst(_mnemonic, _machInst, No_OpClass) { // don't call execute() (which panics) if we're on a // speculative path flags[IsNonSpeculative] = true; } %(BasicExecDeclare)s std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const; }; class CP0Unimplemented : public MipsStaticInst { public: /// Constructor CP0Unimplemented(const char *_mnemonic, MachInst _machInst) : MipsStaticInst(_mnemonic, _machInst, No_OpClass) { // don't call execute() (which panics) if we're on a // speculative path flags[IsNonSpeculative] = true; } %(BasicExecDeclare)s std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const; }; class CP1Unimplemented : public MipsStaticInst { public: /// Constructor CP1Unimplemented(const char *_mnemonic, MachInst _machInst) : MipsStaticInst(_mnemonic, _machInst, No_OpClass) { // don't call execute() (which panics) if we're on a // speculative path flags[IsNonSpeculative] = true; } %(BasicExecDeclare)s std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const; }; class CP2Unimplemented : public MipsStaticInst { public: /// Constructor CP2Unimplemented(const char *_mnemonic, MachInst _machInst) : MipsStaticInst(_mnemonic, _machInst, No_OpClass) { // don't call execute() (which panics) if we're on a // speculative path flags[IsNonSpeculative] = true; } %(BasicExecDeclare)s std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const; }; /** * Base class for unimplemented instructions that cause a warning * to be printed (but do not terminate simulation). This * implementation is a little screwy in that it will print a * warning for each instance of a particular unimplemented machine * instruction, not just for each unimplemented opcode. Should * probably make the 'warned' flag a static member of the derived * class. */ class WarnUnimplemented : public MipsStaticInst { private: /// Have we warned on this instruction yet? mutable bool warned; public: /// Constructor WarnUnimplemented(const char *_mnemonic, MachInst _machInst) : MipsStaticInst(_mnemonic, _machInst, No_OpClass), warned(false) { // don't call execute() (which panics) if we're on a // speculative path flags[IsNonSpeculative] = true; } %(BasicExecDeclare)s std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const; }; }}; output decoder {{ std::string FailUnimplemented::generateDisassembly(Addr pc, const SymbolTable *symtab) const { return csprintf("%-10s (unimplemented)", mnemonic); } std::string CP0Unimplemented::generateDisassembly(Addr pc, const SymbolTable *symtab) const { return csprintf("%-10s (unimplemented)", mnemonic); } std::string CP1Unimplemented::generateDisassembly(Addr pc, const SymbolTable *symtab) const { return csprintf("%-10s (unimplemented)", mnemonic); } std::string CP2Unimplemented::generateDisassembly(Addr pc, const SymbolTable *symtab) const { return csprintf("%-10s (unimplemented)", mnemonic); } std::string WarnUnimplemented::generateDisassembly(Addr pc, const SymbolTable *symtab) const { return csprintf("%-10s (unimplemented)", mnemonic); } }}; output exec {{ Fault FailUnimplemented::execute(%(CPU_exec_context)s *xc, Trace::InstRecord *traceData) const { panic("attempt to execute unimplemented instruction '%s' " "(inst 0x%08x, opcode 0x%x, binary:%s)", mnemonic, machInst, OPCODE, inst2string(machInst)); return NoFault; } Fault CP0Unimplemented::execute(%(CPU_exec_context)s *xc, Trace::InstRecord *traceData) const { if (FULL_SYSTEM) { if (!isCoprocessorEnabled(xc, 0)) return new CoprocessorUnusableFault(0); else return new ReservedInstructionFault; } else { panic("attempt to execute unimplemented instruction '%s' " "(inst %#08x, opcode %#x, binary:%s)", mnemonic, machInst, OPCODE, inst2string(machInst)); return NoFault; } } Fault CP1Unimplemented::execute(%(CPU_exec_context)s *xc, Trace::InstRecord *traceData) const { if (FULL_SYSTEM) { if (!isCoprocessorEnabled(xc, 1)) return new CoprocessorUnusableFault(1); else return new ReservedInstructionFault; } else { panic("attempt to execute unimplemented instruction '%s' " "(inst %#08x, opcode %#x, binary:%s)", mnemonic, machInst, OPCODE, inst2string(machInst)); return NoFault; } } Fault CP2Unimplemented::execute(%(CPU_exec_context)s *xc, Trace::InstRecord *traceData) const { if (FULL_SYSTEM) { if (!isCoprocessorEnabled(xc, 2)) return new CoprocessorUnusableFault(2); else return new ReservedInstructionFault; } else { panic("attempt to execute unimplemented instruction '%s' " "(inst %#08x, opcode %#x, binary:%s)", mnemonic, machInst, OPCODE, inst2string(machInst)); return NoFault; } } Fault WarnUnimplemented::execute(%(CPU_exec_context)s *xc, Trace::InstRecord *traceData) const { if (!warned) { warn("\tinstruction '%s' unimplemented\n", mnemonic); warned = true; } return NoFault; } }}; def format FailUnimpl() {{ iop = InstObjParams(name, 'FailUnimplemented') decode_block = BasicDecodeWithMnemonic.subst(iop) }}; def format CP0Unimpl() {{ iop = InstObjParams(name, 'CP0Unimplemented') decode_block = BasicDecodeWithMnemonic.subst(iop) }}; def format CP1Unimpl() {{ iop = InstObjParams(name, 'CP1Unimplemented') decode_block = BasicDecodeWithMnemonic.subst(iop) }}; def format CP2Unimpl() {{ iop = InstObjParams(name, 'CP2Unimplemented') decode_block = BasicDecodeWithMnemonic.subst(iop) }}; def format WarnUnimpl() {{ iop = InstObjParams(name, 'WarnUnimplemented') decode_block = BasicDecodeWithMnemonic.subst(iop) }};