specop.isa revision 5293:5ea2a6dc8f17
1// Copyright (c) 2007 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// Fault Microop 59// 60////////////////////////////////////////////////////////////////////////// 61 62output header {{ 63 class MicroFaultBase : public X86ISA::X86MicroopBase 64 { 65 protected: 66 Fault fault; 67 uint8_t cc; 68 69 public: 70 MicroFaultBase(ExtMachInst _machInst, const char * instMnem, 71 bool isMicro, bool isDelayed, bool isFirst, bool isLast, 72 Fault _fault, uint8_t _cc); 73 74 MicroFaultBase(ExtMachInst _machInst, const char * instMnem, 75 Fault _fault, uint8_t _cc); 76 77 std::string generateDisassembly(Addr pc, 78 const SymbolTable *symtab) const; 79 }; 80 81 class MicroHalt : public X86ISA::X86MicroopBase 82 { 83 public: 84 MicroHalt(ExtMachInst _machInst, const char * instMnem, 85 bool isMicro, bool isDelayed, bool isFirst, bool isLast) : 86 X86MicroopBase(_machInst, "halt", instMnem, 87 isMicro, isDelayed, isFirst, isLast, No_OpClass) 88 { 89 } 90 91 MicroHalt(ExtMachInst _machInst, const char * instMnem) : 92 X86MicroopBase(_machInst, "halt", instMnem, 93 false, false, false, false, No_OpClass) 94 { 95 } 96 97 %(BasicExecDeclare)s 98 }; 99}}; 100 101def template MicroFaultDeclare {{ 102 class %(class_name)s : public %(base_class)s 103 { 104 private: 105 void buildMe(); 106 public: 107 %(class_name)s(ExtMachInst _machInst, const char * instMnem, 108 bool isMicro, bool isDelayed, bool isFirst, bool isLast, 109 Fault _fault, uint8_t _cc); 110 111 %(class_name)s(ExtMachInst _machInst, const char * instMnem, 112 Fault _fault, uint8_t _cc); 113 114 %(BasicExecDeclare)s 115 }; 116}}; 117 118def template MicroFaultExecute {{ 119 Fault %(class_name)s::execute(%(CPU_exec_context)s *xc, 120 Trace::InstRecord *traceData) const 121 { 122 %(op_decl)s; 123 %(op_rd)s; 124 if (%(cond_test)s) { 125 //Return the fault we were constructed with 126 return fault; 127 } else { 128 return NoFault; 129 } 130 } 131}}; 132 133output exec {{ 134 Fault 135 MicroHalt::execute(%(CPU_exec_context)s *xc, 136 Trace::InstRecord * traceData) const 137 { 138 xc->tcBase()->suspend(); 139 return NoFault; 140 } 141}}; 142 143output decoder {{ 144 inline MicroFaultBase::MicroFaultBase( 145 ExtMachInst machInst, const char * instMnem, 146 Fault _fault, uint8_t _cc) : 147 X86MicroopBase(machInst, "fault", instMnem, 148 false, false, false, false, No_OpClass), 149 fault(_fault), cc(_cc) 150 { 151 } 152 153 inline MicroFaultBase::MicroFaultBase( 154 ExtMachInst machInst, const char * instMnem, 155 bool isMicro, bool isDelayed, bool isFirst, bool isLast, 156 Fault _fault, uint8_t _cc) : 157 X86MicroopBase(machInst, "fault", instMnem, 158 isMicro, isDelayed, isFirst, isLast, No_OpClass), 159 fault(_fault), cc(_cc) 160 { 161 } 162}}; 163 164def template MicroFaultConstructor {{ 165 166 inline void %(class_name)s::buildMe() 167 { 168 %(constructor)s; 169 } 170 171 inline %(class_name)s::%(class_name)s( 172 ExtMachInst machInst, const char * instMnem, 173 Fault _fault, uint8_t _cc) : 174 %(base_class)s(machInst, instMnem, _fault, _cc) 175 { 176 buildMe(); 177 } 178 179 inline %(class_name)s::%(class_name)s( 180 ExtMachInst machInst, const char * instMnem, 181 bool isMicro, bool isDelayed, bool isFirst, bool isLast, 182 Fault _fault, uint8_t _cc) : 183 %(base_class)s(machInst, instMnem, 184 isMicro, isDelayed, isFirst, isLast, _fault, _cc) 185 { 186 buildMe(); 187 } 188}}; 189 190output decoder {{ 191 std::string MicroFaultBase::generateDisassembly(Addr pc, 192 const SymbolTable *symtab) const 193 { 194 std::stringstream response; 195 196 printMnemonic(response, instMnem, mnemonic); 197 if(fault) 198 response << fault->name(); 199 else 200 response << "No Fault"; 201 202 return response.str(); 203 } 204}}; 205 206let {{ 207 class Fault(X86Microop): 208 className = "MicroFault" 209 def __init__(self, fault, flags=None): 210 self.fault = fault 211 if flags: 212 if not isinstance(flags, (list, tuple)): 213 raise Exception, "flags must be a list or tuple of flags" 214 self.cond = " | ".join(flags) 215 self.className += "Flags" 216 else: 217 self.cond = "0" 218 219 def getAllocator(self, *microFlags): 220 allocator = '''new %(class_name)s(machInst, mnemonic 221 %(flags)s, %(fault)s, %(cc)s)''' % { 222 "class_name" : self.className, 223 "flags" : self.microFlagsText(microFlags), 224 "fault" : self.fault, 225 "cc" : self.cond} 226 return allocator 227 228 iop = InstObjParams("fault", "MicroFaultFlags", "MicroFaultBase", 229 {"code": "", 230 "cond_test": "checkCondition(ccFlagBits, cc)"}) 231 exec_output = MicroFaultExecute.subst(iop) 232 header_output = MicroFaultDeclare.subst(iop) 233 decoder_output = MicroFaultConstructor.subst(iop) 234 iop = InstObjParams("fault", "MicroFault", "MicroFaultBase", 235 {"code": "", 236 "cond_test": "true"}) 237 exec_output += MicroFaultExecute.subst(iop) 238 header_output += MicroFaultDeclare.subst(iop) 239 decoder_output += MicroFaultConstructor.subst(iop) 240 microopClasses["fault"] = Fault 241 242 class Halt(X86Microop): 243 def __init__(self): 244 pass 245 246 def getAllocator(self, *microFlags): 247 return "new MicroHalt(machInst, mnemonic %s)" % \ 248 self.microFlagsText(microFlags) 249 250 microopClasses["halt"] = Halt 251}}; 252