src/arch/mips/isa/formats/noop.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 // Nop
  34 //
  35
  36 output header {{
  37     /**
  38      * Static instruction class for no-ops.  This is a leaf class.
  39      */
  40     class Nop : public MipsStaticInst
  41     {
  42         /// Disassembly of original instruction.
  43         const std::string originalDisassembly;
  44
  45       public:
  46         /// Constructor
  47         Nop(const std::string _originalDisassembly, MachInst _machInst)
  48             : MipsStaticInst("nop", _machInst, No_OpClass),
  49               originalDisassembly(_originalDisassembly)
  50         {
  51             flags[IsNop] = true;
  52         }
  53
  54         ~Nop() { }
  55
  56         std::string
  57         generateDisassembly(Addr pc, const SymbolTable *symtab) const;
  58
  59         %(BasicExecDeclare)s
  60     };
  61 }};
  62
  63 output decoder {{
  64     std::string Nop::generateDisassembly(Addr pc,
  65                                          const SymbolTable *symtab) const
  66     {
  67         return csprintf("%-10s %s", "nop", originalDisassembly);
  68     }
  69
  70     /// Helper function for decoding nops.  Substitute Nop object
  71     /// for original inst passed in as arg (and delete latter).
  72     inline
  73     MipsStaticInst *
  74     makeNop(MipsStaticInst *inst)
  75     {
  76         std::string nop_str = "(" + inst->disassemble(0) + ")";
  77         MipsStaticInst *nop = new Nop(nop_str, inst->machInst);
  78         delete inst;
  79         return nop;
  80     }
  81 }};
  82
  83 output exec {{
  84     Fault
  85     Nop::execute(%(CPU_exec_context)s *, Trace::InstRecord *) const
  86     {
  87         return NoFault;
  88     }
  89 }};
  90
  91 // Int & FP operate instructions use RD as dest, so check for
  92 // RD == 0 to detect nops
  93 def template RegNopCheckDecode {{
  94  {
  95      MipsStaticInst *i = new %(class_name)s(machInst);
  96      //if (RD == 0) {
  97          //i = makeNop(i);
  98          //}
  99      return i;
 100  }
 101 }};
 102
 103 def template OperateNopCheckDecode {{
 104  {
 105      MipsStaticInst *i = new %(class_name)s(machInst);
 106      //if (RD == 0) {
 107      // i = makeNop(i);
 108      //}
 109      return i;
 110  }
 111 }};
 112
 113 // IntImm & Memory  instructions use Rt as dest, so check for
 114 // Rt == 0 to detect nops
 115 def template ImmNopCheckDecode {{
 116  {
 117      MipsStaticInst *i = new %(class_name)s(machInst);
 118      //if (RT == 0) {
 119      // i = makeNop(i);
 120      // }
 121      return i;
 122  }
 123 }};
 124
 125
 126 // Like BasicOperate format, but generates NOP if RC/FC == 31
 127 def format BasicOperateWithNopCheck(code, *opt_args) {{
 128     iop = InstObjParams(name, Name, 'MipsStaticInst', code,
 129                         opt_args)
 130     header_output = BasicDeclare.subst(iop)
 131     decoder_output = BasicConstructor.subst(iop)
 132     decode_block = OperateNopCheckDecode.subst(iop)
 133     exec_output = BasicExecute.subst(iop)
 134 }};
 135
 136 def format Nop() {{
 137         decode_block = 'return new Nop(\"\",machInst);\n'
 138 }};
 139