src/arch/mips/isa/formats/unimp.isa

   1 // -*- mode:c++ -*-
   2
   3 // Copyright (c) 2007 MIPS Technologies, Inc.
   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 // Authors: Korey Sewell
  30
  31 ////////////////////////////////////////////////////////////////////
  32 //
  33 // Unimplemented instructions
  34 //
  35
  36 output 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     class CP0Unimplemented : public MipsStaticInst
  62     {
  63       public:
  64         /// Constructor
  65         CP0Unimplemented(const char *_mnemonic, MachInst _machInst)
  66             : MipsStaticInst(_mnemonic, _machInst, No_OpClass)
  67         {
  68             // don't call execute() (which panics) if we're on a
  69             // speculative path
  70             flags[IsNonSpeculative] = true;
  71         }
  72
  73         %(BasicExecDeclare)s
  74
  75         std::string
  76         generateDisassembly(Addr pc, const SymbolTable *symtab) const;
  77     };
  78     class CP1Unimplemented : public MipsStaticInst
  79     {
  80       public:
  81         /// Constructor
  82         CP1Unimplemented(const char *_mnemonic, MachInst _machInst)
  83             : MipsStaticInst(_mnemonic, _machInst, No_OpClass)
  84         {
  85             // don't call execute() (which panics) if we're on a
  86             // speculative path
  87             flags[IsNonSpeculative] = true;
  88         }
  89
  90         %(BasicExecDeclare)s
  91
  92         std::string
  93         generateDisassembly(Addr pc, const SymbolTable *symtab) const;
  94     };
  95     class CP2Unimplemented : public MipsStaticInst
  96     {
  97       public:
  98         /// Constructor
  99         CP2Unimplemented(const char *_mnemonic, MachInst _machInst)
 100             : MipsStaticInst(_mnemonic, _machInst, No_OpClass)
 101         {
 102             // don't call execute() (which panics) if we're on a
 103             // speculative path
 104             flags[IsNonSpeculative] = true;
 105         }
 106
 107         %(BasicExecDeclare)s
 108
 109         std::string
 110         generateDisassembly(Addr pc, const SymbolTable *symtab) const;
 111     };
 112
 113     /**
 114      * Base class for unimplemented instructions that cause a warning
 115      * to be printed (but do not terminate simulation).  This
 116      * implementation is a little screwy in that it will print a
 117      * warning for each instance of a particular unimplemented machine
 118      * instruction, not just for each unimplemented opcode.  Should
 119      * probably make the 'warned' flag a static member of the derived
 120      * class.
 121      */
 122     class WarnUnimplemented : public MipsStaticInst
 123     {
 124       private:
 125         /// Have we warned on this instruction yet?
 126         mutable bool warned;
 127
 128       public:
 129         /// Constructor
 130         WarnUnimplemented(const char *_mnemonic, MachInst _machInst)
 131             : MipsStaticInst(_mnemonic, _machInst, No_OpClass), warned(false)
 132         {
 133             // don't call execute() (which panics) if we're on a
 134             // speculative path
 135             flags[IsNonSpeculative] = true;
 136         }
 137
 138         %(BasicExecDeclare)s
 139
 140         std::string
 141         generateDisassembly(Addr pc, const SymbolTable *symtab) const;
 142     };
 143 }};
 144
 145 output decoder {{
 146     std::string
 147     FailUnimplemented::generateDisassembly(Addr pc,
 148                                            const SymbolTable *symtab) const
 149     {
 150         return csprintf("%-10s (unimplemented)", mnemonic);
 151     }
 152
 153     std::string
 154     CP0Unimplemented::generateDisassembly(Addr pc,
 155                                            const SymbolTable *symtab) const
 156     {
 157         return csprintf("%-10s (unimplemented)", mnemonic);
 158     }
 159
 160     std::string
 161     CP1Unimplemented::generateDisassembly(Addr pc,
 162                                            const SymbolTable *symtab) const
 163     {
 164         return csprintf("%-10s (unimplemented)", mnemonic);
 165     }
 166     std::string
 167     CP2Unimplemented::generateDisassembly(Addr pc,
 168                                            const SymbolTable *symtab) const
 169     {
 170         return csprintf("%-10s (unimplemented)", mnemonic);
 171     }
 172
 173     std::string
 174     WarnUnimplemented::generateDisassembly(Addr pc,
 175                                            const SymbolTable *symtab) const
 176     {
 177         return csprintf("%-10s (unimplemented)", mnemonic);
 178     }
 179 }};
 180
 181 output exec {{
 182     Fault
 183     FailUnimplemented::execute(%(CPU_exec_context)s *xc,
 184                                Trace::InstRecord *traceData) const
 185     {
 186         panic("attempt to execute unimplemented instruction '%s' "
 187               "(inst 0x%08x, opcode 0x%x, binary:%s)", mnemonic, machInst, OPCODE,
 188               inst2string(machInst));
 189         return new UnimplementedOpcodeFault;
 190     }
 191
 192     Fault
 193     CP0Unimplemented::execute(%(CPU_exec_context)s *xc,
 194                                Trace::InstRecord *traceData) const
 195     {
 196 #if  FULL_SYSTEM
 197       if (!isCoprocessorEnabled(xc, 0)) {
 198         return new CoprocessorUnusableFault(0);
 199       }
 200       return new ReservedInstructionFault;
 201 #else
 202         panic("attempt to execute unimplemented instruction '%s' "
 203               "(inst 0x%08x, opcode 0x%x, binary:%s)", mnemonic, machInst, OPCODE,
 204               inst2string(machInst));
 205         return new UnimplementedOpcodeFault;
 206 #endif
 207     }
 208
 209     Fault
 210     CP1Unimplemented::execute(%(CPU_exec_context)s *xc,
 211                                Trace::InstRecord *traceData) const
 212     {
 213 #if  FULL_SYSTEM
 214       if (!isCoprocessorEnabled(xc, 1)) {
 215         return new CoprocessorUnusableFault(1);
 216       }
 217       return new ReservedInstructionFault;
 218 #else
 219         panic("attempt to execute unimplemented instruction '%s' "
 220               "(inst 0x%08x, opcode 0x%x, binary:%s)", mnemonic, machInst, OPCODE,
 221               inst2string(machInst));
 222         return new UnimplementedOpcodeFault;
 223 #endif
 224     }
 225     Fault
 226     CP2Unimplemented::execute(%(CPU_exec_context)s *xc,
 227                                Trace::InstRecord *traceData) const
 228     {
 229 #if  FULL_SYSTEM
 230       if (!isCoprocessorEnabled(xc, 2)) {
 231         return new CoprocessorUnusableFault(2);
 232       }
 233       return new ReservedInstructionFault;
 234 #else
 235         panic("attempt to execute unimplemented instruction '%s' "
 236               "(inst 0x%08x, opcode 0x%x, binary:%s)", mnemonic, machInst, OPCODE,
 237               inst2string(machInst));
 238         return new UnimplementedOpcodeFault;
 239 #endif
 240     }
 241
 242     Fault
 243     WarnUnimplemented::execute(%(CPU_exec_context)s *xc,
 244                                Trace::InstRecord *traceData) const
 245     {
 246         if (!warned) {
 247             warn("\tinstruction '%s' unimplemented\n", mnemonic);
 248             warned = true;
 249         }
 250
 251         return NoFault;
 252     }
 253 }};
 254
 255
 256 def format FailUnimpl() {{
 257     iop = InstObjParams(name, 'FailUnimplemented')
 258     decode_block = BasicDecodeWithMnemonic.subst(iop)
 259
 260 }};
 261 def format CP0Unimpl() {{
 262     iop = InstObjParams(name, 'CP0Unimplemented')
 263     decode_block = BasicDecodeWithMnemonic.subst(iop)
 264 }};
 265 def format CP1Unimpl() {{
 266     iop = InstObjParams(name, 'CP1Unimplemented')
 267     decode_block = BasicDecodeWithMnemonic.subst(iop)
 268 }};
 269 def format CP2Unimpl() {{
 270     iop = InstObjParams(name, 'CP2Unimplemented')
 271     decode_block = BasicDecodeWithMnemonic.subst(iop)
 272 }};
 273 def format WarnUnimpl() {{
 274     iop = InstObjParams(name, 'WarnUnimplemented')
 275     decode_block = BasicDecodeWithMnemonic.subst(iop)
 276 }};
 277