src/arch/x86/isa/microops/debug.isa

   1 // Copyright (c) 2008 The Hewlett-Packard Development Company
   2 // All rights reserved.
   3 //
   4 // The license below extends only to copyright in the software and shall
   5 // not be construed as granting a license to any other intellectual
   6 // property including but not limited to intellectual property relating
   7 // to a hardware implementation of the functionality of the software
   8 // licensed hereunder.  You may use the software subject to the license
   9 // terms below provided that you ensure that this notice is replicated
  10 // unmodified and in its entirety in all distributions of the software,
  11 // modified or unmodified, in source code or in binary form.
  12 //
  13 // Redistribution and use in source and binary forms, with or without
  14 // modification, are permitted provided that the following conditions are
  15 // met: redistributions of source code must retain the above copyright
  16 // notice, this list of conditions and the following disclaimer;
  17 // redistributions in binary form must reproduce the above copyright
  18 // notice, this list of conditions and the following disclaimer in the
  19 // documentation and/or other materials provided with the distribution;
  20 // neither the name of the copyright holders nor the names of its
  21 // contributors may be used to endorse or promote products derived from
  22 // this software without specific prior written permission.
  23 //
  24 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  27 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  28 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  29 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  30 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  31 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  32 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  33 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  34 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35 //
  36 // Authors: Gabe Black
  37
  38 //////////////////////////////////////////////////////////////////////////
  39 //
  40 // Debug Microops
  41 //
  42 //////////////////////////////////////////////////////////////////////////
  43
  44 output header {{
  45     class MicroDebugBase : public X86ISA::X86MicroopBase
  46     {
  47       protected:
  48         typedef GenericISA::M5DebugFault::DebugFunc DebugFunc;
  49         DebugFunc func;
  50         std::string message;
  51         uint8_t cc;
  52
  53       public:
  54         MicroDebugBase(ExtMachInst machInst, const char * mnem,
  55                 const char * instMnem, uint64_t setFlags,
  56                 DebugFunc _func, std::string _message, uint8_t _cc) :
  57             X86MicroopBase(machInst, mnem, instMnem, setFlags, No_OpClass),
  58                     func(_func), message(_message), cc(_cc)
  59         {}
  60
  61         std::string
  62         generateDisassembly(Addr pc, const SymbolTable *symtab) const
  63         {
  64             std::stringstream response;
  65
  66             printMnemonic(response, instMnem, mnemonic);
  67             response << "\"" << message << "\"";
  68
  69             return response.str();
  70         }
  71     };
  72 }};
  73
  74 def template MicroDebugDeclare {{
  75     class %(class_name)s : public %(base_class)s
  76     {
  77       public:
  78         %(class_name)s(ExtMachInst _machInst, const char * instMnem,
  79                 uint64_t setFlags, std::string _message, uint8_t _cc);
  80
  81         %(BasicExecDeclare)s
  82     };
  83 }};
  84
  85 def template MicroDebugExecute {{
  86         Fault
  87         %(class_name)s::execute(CPU_EXEC_CONTEXT *xc,
  88                 Trace::InstRecord *traceData) const
  89         {
  90             %(op_decl)s
  91             %(op_rd)s
  92             if (%(cond_test)s) {
  93                 return std::make_shared<GenericISA::M5DebugFault>(func,
  94                                                                   message);
  95             } else {
  96                 return NoFault;
  97             }
  98         }
  99 }};
 100
 101 def template MicroDebugConstructor {{
 102     %(class_name)s::%(class_name)s(
 103             ExtMachInst machInst, const char * instMnem, uint64_t setFlags,
 104             std::string _message, uint8_t _cc) :
 105         %(base_class)s(machInst, "%(func)s", instMnem,
 106                 setFlags, %(func_num)s, _message, _cc)
 107     {
 108         %(constructor)s;
 109     }
 110 }};
 111
 112 let {{
 113     class MicroDebug(X86Microop):
 114         def __init__(self, message, flags=None):
 115             self.message = message
 116             if flags:
 117                 if not isinstance(flags, (list, tuple)):
 118                     raise Exception, "flags must be a list or tuple of flags"
 119                 self.cond = " | ".join(flags)
 120                 self.className += "Flags"
 121             else:
 122                 self.cond = "0"
 123
 124         def getAllocator(self, microFlags):
 125             allocator = '''new %(class_name)s(machInst, macrocodeBlock,
 126                     %(flags)s, "%(message)s", %(cc)s)''' % {
 127                 "class_name" : self.className,
 128                 "flags" : self.microFlagsText(microFlags),
 129                 "message" : self.message,
 130                 "cc" : self.cond}
 131             return allocator
 132
 133     exec_output = ""
 134     header_output = ""
 135     decoder_output = ""
 136
 137     def buildDebugMicro(func, func_num):
 138         global exec_output, header_output, decoder_output
 139
 140         iop = InstObjParams(func, "Micro%sFlags" % func.capitalize(),
 141                 "MicroDebugBase",
 142                 {"code": "",
 143                  "func": func,
 144                  "func_num": "GenericISA::M5DebugFault::%s" % func_num,
 145                  "cond_test": "checkCondition(ccFlagBits | cfofBits | \
 146                                               dfBit | ecfBit | ezfBit, cc)"})
 147         exec_output += MicroDebugExecute.subst(iop)
 148         header_output += MicroDebugDeclare.subst(iop)
 149         decoder_output += MicroDebugConstructor.subst(iop)
 150
 151         iop = InstObjParams(func, "Micro%s" % func.capitalize(),
 152                 "MicroDebugBase",
 153                 {"code": "",
 154                  "func": func,
 155                  "func_num": "GenericISA::M5DebugFault::%s" % func_num,
 156                  "cond_test": "true"})
 157         exec_output += MicroDebugExecute.subst(iop)
 158         header_output += MicroDebugDeclare.subst(iop)
 159         decoder_output += MicroDebugConstructor.subst(iop)
 160
 161         class MicroDebugChild(MicroDebug):
 162             className = "Micro%s" % func.capitalize()
 163
 164         global microopClasses
 165         microopClasses[func] = MicroDebugChild
 166
 167     buildDebugMicro("panic", "PanicFunc")
 168     buildDebugMicro("fatal", "FatalFunc")
 169     buildDebugMicro("warn", "WarnFunc")
 170     buildDebugMicro("warn_once", "WarnOnceFunc")
 171 }};