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

   1 // Copyright (c) 2008 The Hewlett-Packard Development Company
   2 // All rights reserved.
   3 //
   4 // Redistribution and use of this software in source and binary forms,
   5 // with or without modification, are permitted provided that the
   6 // following conditions are met:
   7 //
   8 // The software must be used only for Non-Commercial Use which means any
   9 // use which is NOT directed to receiving any direct monetary
  10 // compensation for, or commercial advantage from such use.  Illustrative
  11 // examples of non-commercial use are academic research, personal study,
  12 // teaching, education and corporate research & development.
  13 // Illustrative examples of commercial use are distributing products for
  14 // commercial advantage and providing services using the software for
  15 // commercial advantage.
  16 //
  17 // If you wish to use this software or functionality therein that may be
  18 // covered by patents for commercial use, please contact:
  19 //     Director of Intellectual Property Licensing
  20 //     Office of Strategy and Technology
  21 //     Hewlett-Packard Company
  22 //     1501 Page Mill Road
  23 //     Palo Alto, California  94304
  24 //
  25 // Redistributions of source code must retain the above copyright notice,
  26 // this list of conditions and the following disclaimer.  Redistributions
  27 // in binary form must reproduce the above copyright notice, this list of
  28 // conditions and the following disclaimer in the documentation and/or
  29 // other materials provided with the distribution.  Neither the name of
  30 // the COPYRIGHT HOLDER(s), HEWLETT-PACKARD COMPANY, nor the names of its
  31 // contributors may be used to endorse or promote products derived from
  32 // this software without specific prior written permission.  No right of
  33 // sublicense is granted herewith.  Derivatives of the software and
  34 // output created using the software may be prepared, but only for
  35 // Non-Commercial Uses.  Derivatives of the software may be shared with
  36 // others provided: (i) the others agree to abide by the list of
  37 // conditions herein which includes the Non-Commercial Use restrictions;
  38 // and (ii) such Derivatives of the software include the above copyright
  39 // notice to acknowledge the contribution from this software where
  40 // applicable, this list of conditions and the disclaimer below.
  41 //
  42 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  43 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  44 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  45 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  46 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  47 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  48 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  49 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  50 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  51 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  52 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  53 //
  54 // Authors: Gabe Black
  55
  56 //////////////////////////////////////////////////////////////////////////
  57 //
  58 // Debug Microops
  59 //
  60 //////////////////////////////////////////////////////////////////////////
  61
  62 output header {{
  63     class MicroDebugBase : public X86ISA::X86MicroopBase
  64     {
  65       protected:
  66         std::string message;
  67         uint8_t cc;
  68
  69       public:
  70         MicroDebugBase(ExtMachInst _machInst, const char * mnem,
  71                 const char * instMnem,
  72                 bool isMicro, bool isDelayed, bool isFirst, bool isLast,
  73                 std::string _message, uint8_t _cc);
  74
  75         MicroDebugBase(ExtMachInst _machInst, const char * mnem,
  76                 const char * instMnem, std::string _message, uint8_t _cc);
  77
  78         std::string generateDisassembly(Addr pc,
  79                 const SymbolTable *symtab) const;
  80     };
  81 }};
  82
  83 def template MicroDebugDeclare {{
  84     class %(class_name)s : public %(base_class)s
  85     {
  86       private:
  87         void buildMe();
  88       public:
  89         %(class_name)s(ExtMachInst _machInst, const char * instMnem,
  90                 bool isMicro, bool isDelayed, bool isFirst, bool isLast,
  91                 std::string _message, uint8_t _cc);
  92
  93         %(class_name)s(ExtMachInst _machInst, const char * instMnem,
  94                 std::string _message, uint8_t _cc);
  95
  96         %(BasicExecDeclare)s
  97     };
  98 }};
  99
 100 def template MicroDebugExecute {{
 101         Fault %(class_name)s::execute(%(CPU_exec_context)s *xc,
 102                 Trace::InstRecord *traceData) const
 103         {
 104             %(op_decl)s
 105             %(op_rd)s
 106             if (%(cond_test)s) {
 107                 %(func)s("%s\n", message);
 108             }
 109             return NoFault;
 110         }
 111 }};
 112
 113 output decoder {{
 114     inline MicroDebugBase::MicroDebugBase(
 115             ExtMachInst machInst, const char * mnem, const char * instMnem,
 116             std::string _message, uint8_t _cc) :
 117         X86MicroopBase(machInst, mnem, instMnem,
 118                 false, false, false, false, No_OpClass),
 119         message(_message), cc(_cc)
 120     {
 121     }
 122
 123     inline MicroDebugBase::MicroDebugBase(
 124             ExtMachInst machInst, const char * mnem, const char * instMnem,
 125             bool isMicro, bool isDelayed, bool isFirst, bool isLast,
 126             std::string _message, uint8_t _cc) :
 127         X86MicroopBase(machInst, mnem, instMnem,
 128                 isMicro, isDelayed, isFirst, isLast, No_OpClass),
 129                 message(_message), cc(_cc)
 130     {
 131     }
 132 }};
 133
 134 def template MicroDebugConstructor {{
 135
 136     inline void %(class_name)s::buildMe()
 137     {
 138         %(constructor)s;
 139     }
 140
 141     inline %(class_name)s::%(class_name)s(
 142             ExtMachInst machInst, const char * instMnem,
 143             std::string _message, uint8_t _cc) :
 144         %(base_class)s(machInst, "%(func)s", instMnem, _message, _cc)
 145     {
 146         buildMe();
 147     }
 148
 149     inline %(class_name)s::%(class_name)s(
 150             ExtMachInst machInst, const char * instMnem,
 151             bool isMicro, bool isDelayed, bool isFirst, bool isLast,
 152             std::string _message, uint8_t _cc) :
 153         %(base_class)s(machInst, "%(func)s", instMnem,
 154                 isMicro, isDelayed, isFirst, isLast, _message, _cc)
 155     {
 156         buildMe();
 157     }
 158 }};
 159
 160 output decoder {{
 161     std::string MicroDebugBase::generateDisassembly(Addr pc,
 162             const SymbolTable *symtab) const
 163     {
 164         std::stringstream response;
 165
 166         printMnemonic(response, instMnem, mnemonic);
 167         response << "\"" << message << "\"";
 168
 169         return response.str();
 170     }
 171 }};
 172
 173 let {{
 174     class MicroDebug(X86Microop):
 175         def __init__(self, message, flags=None):
 176             self.message = message
 177             if flags:
 178                 if not isinstance(flags, (list, tuple)):
 179                     raise Exception, "flags must be a list or tuple of flags"
 180                 self.cond = " | ".join(flags)
 181                 self.className += "Flags"
 182             else:
 183                 self.cond = "0"
 184
 185         def getAllocator(self, *microFlags):
 186             allocator = '''new %(class_name)s(machInst, macrocodeBlock
 187                     %(flags)s, "%(message)s", %(cc)s)''' % {
 188                 "class_name" : self.className,
 189                 "flags" : self.microFlagsText(microFlags),
 190                 "message" : self.message,
 191                 "cc" : self.cond}
 192             return allocator
 193
 194     exec_output = ""
 195     header_output = ""
 196     decoder_output = ""
 197
 198     def buildDebugMicro(func):
 199         global exec_output, header_output, decoder_output
 200
 201         iop = InstObjParams(func, "Micro%sFlags" % func.capitalize(),
 202                 "MicroDebugBase",
 203                 {"code": "",
 204                  "func": func,
 205                  "cond_test": "checkCondition(ccFlagBits, cc)"})
 206         exec_output += MicroDebugExecute.subst(iop)
 207         header_output += MicroDebugDeclare.subst(iop)
 208         decoder_output += MicroDebugConstructor.subst(iop)
 209
 210         iop = InstObjParams(func, "Micro%s" % func.capitalize(),
 211                 "MicroDebugBase",
 212                 {"code": "",
 213                  "func": func,
 214                  "cond_test": "true"})
 215         exec_output += MicroDebugExecute.subst(iop)
 216         header_output += MicroDebugDeclare.subst(iop)
 217         decoder_output += MicroDebugConstructor.subst(iop)
 218
 219         class MicroDebugChild(MicroDebug):
 220             className = "Micro%s" % func.capitalize()
 221
 222         global microopClasses
 223         microopClasses[func] = MicroDebugChild
 224
 225     buildDebugMicro("panic")
 226     buildDebugMicro("fatal")
 227     buildDebugMicro("warn")
 228     buildDebugMicro("warn_once")
 229 }};