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 //////////////////////////////////////////////////////////////////////////
  37 //
  38 // Debug Microops
  39 //
  40 //////////////////////////////////////////////////////////////////////////
  41
  42 output header {{
  43     class MicroDebug : public X86ISA::X86MicroopBase
  44     {
  45       protected:
  46         std::shared_ptr<GenericISA::M5DebugFault> fault;
  47
  48       public:
  49         MicroDebug(ExtMachInst _machInst, const char *mnem,
  50                 const char *instMnem, uint64_t setFlags,
  51                 GenericISA::M5DebugFault *_fault);
  52
  53         Fault
  54         execute(ExecContext *xc, Trace::InstRecord *traceData) const
  55         {
  56             return fault;
  57         }
  58
  59         std::string
  60         generateDisassembly(Addr pc, const Loader::SymbolTable *symtab) const
  61         {
  62             std::stringstream response;
  63
  64             printMnemonic(response, instMnem, mnemonic);
  65             response << "\"" << fault->message() << "\"";
  66
  67             return response.str();
  68         }
  69     };
  70
  71     class MicroDebugFlags : public MicroDebug
  72     {
  73       protected:
  74         uint8_t cc;
  75
  76       public:
  77         MicroDebugFlags(ExtMachInst _machInst, const char *mnem,
  78                 const char *instMnem, uint64_t setFlags,
  79                 GenericISA::M5DebugFault *_fault, uint8_t _cc);
  80
  81         Fault execute(ExecContext *, Trace::InstRecord *) const;
  82     };
  83 }};
  84
  85 output decoder {{
  86     MicroDebug::MicroDebug(ExtMachInst _machInst, const char *mnem,
  87             const char *instMnem, uint64_t setFlags,
  88             GenericISA::M5DebugFault *_fault) :
  89         X86ISA::X86MicroopBase(_machInst, mnem, instMnem,
  90                                setFlags, No_OpClass),
  91         fault(_fault)
  92     {}
  93 }};
  94
  95 def template MicroDebugFlagsExecute {{
  96         Fault
  97         %(class_name)s::execute(ExecContext *xc,
  98                 Trace::InstRecord *traceData) const
  99         {
 100             %(op_decl)s
 101             %(op_rd)s
 102             if (%(cond_test)s) {
 103                 return %(base_class)s::execute(xc, traceData);
 104             } else {
 105                 return NoFault;
 106             }
 107         }
 108 }};
 109
 110 def template MicroDebugFlagsConstructor {{
 111     %(class_name)s::%(class_name)s(
 112             ExtMachInst machInst, const char *mnem,
 113             const char *instMnem, uint64_t setFlags,
 114             GenericISA::M5DebugFault *_fault, uint8_t _cc) :
 115         %(base_class)s(machInst, mnem, instMnem, setFlags, _fault),
 116         cc(_cc)
 117     {
 118         %(constructor)s;
 119     }
 120 }};
 121
 122 let {{
 123     iop = InstObjParams("", "MicroDebugFlags", "MicroDebug",
 124             {"code": "",
 125              "cond_test": "checkCondition(ccFlagBits | cfofBits | \
 126                                               dfBit | ecfBit | ezfBit, cc)"})
 127     exec_output = MicroDebugFlagsExecute.subst(iop)
 128     decoder_output = MicroDebugFlagsConstructor.subst(iop)
 129 }};
 130
 131 let {{
 132     class MicroDebug(X86Microop):
 133         def __init__(self, name, fault, message, once, flags):
 134             self.name = name
 135             self.fault = fault
 136             self.message = message
 137             self.once = once
 138             self.flags = flags
 139             if flags and not isinstance(flags, (list, tuple)):
 140                 raise Exception("flags must be a list or tuple of flags")
 141
 142             self.className = "MicroDebugFlags" if flags else "MicroDebug"
 143
 144         def getAllocator(self, microFlags):
 145             if self.once:
 146                 fault_allocator_template = \
 147                     "new %(fault_type)s(%(token)s, %(message)s)"
 148             else:
 149                 fault_allocator_template = \
 150                     "new %(fault_type)s(%(message)s)"
 151             fault_allocator = fault_allocator_template % {
 152                 "fault_type": self.fault,
 153                 "token": "std::string(\"%s\")" % self.message,
 154                 "message": "\"%s\"" % self.message
 155             }
 156
 157             args = ["machInst", "\"%s\"" % self.name, "macrocodeBlock",
 158                 self.microFlagsText(microFlags), fault_allocator]
 159
 160             if self.flags:
 161                 args.append(" | ".join(self.flags))
 162
 163             return "new " + self.className + "(" + ", ".join(args) + ")"
 164
 165     def buildDebugMicro(name, with_once=False):
 166         global microopClasses
 167
 168         fault_class = "GenericISA::M5" + name.capitalize() + "Fault"
 169
 170         class MicroDebugChild(MicroDebug):
 171             def __init__(self, message, flags=None):
 172                 super(MicroDebugChild, self).__init__(
 173                         name, fault_class, message, False, flags)
 174
 175         microopClasses[name] = MicroDebugChild
 176
 177         if with_once:
 178             fault_once_class = \
 179                 "GenericISA::M5" + name.capitalize() + "OnceFault"
 180             name_once = name + "_once"
 181
 182             class MicroDebugOnceChild(MicroDebug):
 183                 def __init__(self, message, flags=None):
 184                     super(MicroDebugOnceChild, self).__init__(
 185                             name_once, fault_once_class, message, True, flags)
 186
 187             microopClasses[name_once] = MicroDebugOnceChild
 188
 189     buildDebugMicro("panic")
 190     buildDebugMicro("fatal")
 191     buildDebugMicro("hack", True)
 192     buildDebugMicro("inform", True)
 193     buildDebugMicro("warn", True)
 194 }};