macroop.isa revision 7620:3d8a23caa1ef
1// -*- mode:c++ -*- 2 3// Copyright (c) 2007 The Hewlett-Packard Development Company 4// All rights reserved. 5// 6// The license below extends only to copyright in the software and shall 7// not be construed as granting a license to any other intellectual 8// property including but not limited to intellectual property relating 9// to a hardware implementation of the functionality of the software 10// licensed hereunder. You may use the software subject to the license 11// terms below provided that you ensure that this notice is replicated 12// unmodified and in its entirety in all distributions of the software, 13// modified or unmodified, in source code or in binary form. 14// 15// Redistribution and use in source and binary forms, with or without 16// modification, are permitted provided that the following conditions are 17// met: redistributions of source code must retain the above copyright 18// notice, this list of conditions and the following disclaimer; 19// redistributions in binary form must reproduce the above copyright 20// notice, this list of conditions and the following disclaimer in the 21// documentation and/or other materials provided with the distribution; 22// neither the name of the copyright holders nor the names of its 23// contributors may be used to endorse or promote products derived from 24// this software without specific prior written permission. 25// 26// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 27// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 28// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 29// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 30// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 31// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 32// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 33// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 34// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 35// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 36// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 37// 38// Authors: Gabe Black 39 40////////////////////////////////////////////////////////////////////////////// 41// 42// Architecture independent 43// 44 45// Execute method for macroops. 46def template MacroExecPanic {{ 47 Fault execute(%(CPU_exec_context)s *, Trace::InstRecord *) const 48 { 49 panic("Tried to execute macroop directly!"); 50 return NoFault; 51 } 52}}; 53 54output header {{ 55 56 // Base class for combinationally generated macroops 57 class Macroop : public X86ISA::MacroopBase 58 { 59 public: 60 Macroop(const char *mnem, ExtMachInst _machInst, 61 uint32_t _numMicroops, X86ISA::EmulEnv _env) 62 : MacroopBase(mnem, _machInst, _numMicroops, _env) 63 {} 64 %(MacroExecPanic)s 65 }; 66}}; 67 68////////////////////////////////////////////////////////////////////////////// 69// 70// X86 specific 71// 72////////////////////////////////////////////////////////////////////////////// 73 74// Basic instruction class declaration template. 75def template MacroDeclare {{ 76 namespace X86Macroop 77 { 78 /** 79 * Static instruction class for "%(mnemonic)s". 80 */ 81 class %(class_name)s : public %(base_class)s 82 { 83 private: 84 %(declareLabels)s 85 public: 86 // Constructor. 87 %(class_name)s(ExtMachInst machInst, X86ISA::EmulEnv _env); 88 89 std::string 90 generateDisassembly(Addr pc, const SymbolTable *symtab) const; 91 }; 92 }; 93}}; 94 95def template MacroDisassembly {{ 96 std::string 97 X86Macroop::%(class_name)s::generateDisassembly(Addr pc, 98 const SymbolTable *symtab) const 99 { 100 std::stringstream out; 101 out << mnemonic << "\t"; 102 103 int regSize = %(regSize)s; 104 %(disassembly)s 105 // Shut up gcc. 106 regSize = regSize; 107 return out.str(); 108 } 109}}; 110 111// Basic instruction class constructor template. 112def template MacroConstructor {{ 113 inline X86Macroop::%(class_name)s::%(class_name)s( 114 ExtMachInst machInst, EmulEnv _env) 115 : %(base_class)s("%(mnemonic)s", machInst, %(num_microops)s, _env) 116 { 117 %(adjust_env)s; 118 %(adjust_imm)s; 119 %(adjust_disp)s; 120 %(init_env)s; 121 %(constructor)s; 122 const char *macrocodeBlock = "%(class_name)s"; 123 //alloc_microops is the code that sets up the microops 124 //array in the parent class. 125 %(alloc_microops)s; 126 } 127}}; 128 129let {{ 130 from micro_asm import Combinational_Macroop, Rom_Macroop 131 class X86Macroop(Combinational_Macroop): 132 def add_microop(self, mnemonic, microop): 133 microop.mnemonic = mnemonic 134 microop.micropc = len(self.microops) 135 self.microops.append(microop) 136 def setAdjustEnv(self, val): 137 self.adjust_env = val 138 def adjustImm(self, val): 139 self.adjust_imm += val 140 def adjustDisp(self, val): 141 self.adjust_disp += val 142 def __init__(self, name): 143 super(X86Macroop, self).__init__(name) 144 self.directives = { 145 "adjust_env" : self.setAdjustEnv, 146 "adjust_imm" : self.adjustImm, 147 "adjust_disp" : self.adjustDisp 148 } 149 self.declared = False 150 self.adjust_env = "" 151 self.init_env = "" 152 self.adjust_imm = ''' 153 uint64_t adjustedImm = IMMEDIATE; 154 //This is to pacify gcc in case the immediate isn't used. 155 adjustedImm = adjustedImm; 156 ''' 157 self.adjust_disp = ''' 158 uint64_t adjustedDisp = DISPLACEMENT; 159 //This is to pacify gcc in case the displacement isn't used. 160 adjustedDisp = adjustedDisp; 161 ''' 162 def getAllocator(self, env): 163 return "new X86Macroop::%s(machInst, %s)" % \ 164 (self.name, env.getAllocator()) 165 def getMnemonic(self): 166 mnemonic = self.name.lower() 167 mnemonic = re.match(r'[^_]*', mnemonic).group(0) 168 return mnemonic 169 def getDeclaration(self): 170 #FIXME This first parameter should be the mnemonic. I need to 171 #write some code which pulls that out 172 declareLabels = "" 173 for (label, microop) in self.labels.items(): 174 declareLabels += "const static uint64_t label_%s = %d;\n" \ 175 % (label, microop.micropc) 176 iop = InstObjParams(self.getMnemonic(), self.name, "Macroop", 177 {"code" : "", 178 "declareLabels" : declareLabels 179 }) 180 return MacroDeclare.subst(iop); 181 def getDefinition(self, env): 182 #FIXME This first parameter should be the mnemonic. I need to 183 #write some code which pulls that out 184 numMicroops = len(self.microops) 185 allocMicroops = '' 186 micropc = 0 187 for op in self.microops: 188 flags = ["IsMicroop"] 189 if micropc == numMicroops - 1: 190 flags.append("IsLastMicroop") 191 else: 192 flags.append("IsDelayedCommit") 193 if micropc == 0: 194 flags.append("IsFirstMicroop") 195 allocMicroops += \ 196 "microops[%d] = %s;\n" % \ 197 (micropc, op.getAllocator(flags)) 198 micropc += 1 199 if env.useStackSize: 200 useStackSize = "true" 201 else: 202 useStackSize = "false" 203 if env.memoryInst: 204 memoryInst = "true" 205 else: 206 memoryInst = "false" 207 regSize = '''(%s || (env.base == INTREG_RSP && %s) ? 208 env.stackSize : 209 env.dataSize)''' % (useStackSize, memoryInst) 210 iop = InstObjParams(self.getMnemonic(), self.name, "Macroop", 211 {"code" : "", "num_microops" : numMicroops, 212 "alloc_microops" : allocMicroops, 213 "adjust_env" : self.adjust_env, 214 "adjust_imm" : self.adjust_imm, 215 "adjust_disp" : self.adjust_disp, 216 "disassembly" : env.disassembly, 217 "regSize" : regSize, 218 "init_env" : self.initEnv}) 219 return MacroConstructor.subst(iop) + \ 220 MacroDisassembly.subst(iop); 221}}; 222 223let {{ 224 class EmulEnv(object): 225 def __init__(self): 226 self.reg = "0" 227 self.regUsed = False 228 self.regm = "0" 229 self.regmUsed = False 230 self.seg = "SEGMENT_REG_DS" 231 self.size = None 232 self.addressSize = "ADDRSIZE" 233 self.dataSize = "OPSIZE" 234 self.stackSize = "STACKSIZE" 235 self.doModRM = False 236 self.disassembly = "" 237 self.firstArgument = True 238 self.useStackSize = False 239 self.memoryInst = False 240 241 def addToDisassembly(self, code): 242 if not self.firstArgument: 243 self.disassembly += "out << \", \";\n" 244 self.firstArgument = False 245 self.disassembly += code 246 247 def getAllocator(self): 248 if self.size == 'b': 249 self.dataSize = 1 250 elif self.size == 'd': 251 self.dataSize = 4 252 #This is for "double plus" which is normally a double word unless 253 #the REX W bit is set, in which case it's a quad word. It's used 254 #for some SSE instructions. 255 elif self.size == 'dp': 256 self.dataSize = "(REX_W ? 8 : 4)" 257 elif self.size == 'q': 258 self.dataSize = 8 259 elif self.size == 'v': 260 self.dataSize = "OPSIZE" 261 elif self.size == 'w': 262 self.dataSize = 2 263 elif self.size == 'z': 264 self.dataSize = "((OPSIZE == 8) ? 4 : OPSIZE)" 265 elif self.size: 266 raise Exception, "Unrecognized size type %s!" % self.size 267 return '''EmulEnv(%(reg)s, 268 %(regm)s, 269 %(dataSize)s, 270 %(addressSize)s, 271 %(stackSize)s)''' % \ 272 self.__dict__ 273 274 def addReg(self, reg): 275 if not self.regUsed: 276 self.reg = reg 277 self.regUsed = True 278 elif not self.regmUsed: 279 self.regm = reg 280 self.regmUsed = True 281 else: 282 raise Exception, "EmulEnv is out of register specialization spots." 283 def setSize(self, size): 284 if not self.size: 285 self.size = size 286 else: 287 if self.size != size: 288 raise Exception, "Conflicting register sizes %s and %s!" %\ 289 (self.size, size) 290}}; 291 292let {{ 293 doModRMString = "env.doModRM(machInst);\n" 294 noModRMString = "env.setSeg(machInst);\n" 295 def genMacroop(Name, env): 296 blocks = OutputBlocks() 297 if not macroopDict.has_key(Name): 298 raise Exception, "Unrecognized instruction: %s" % Name 299 macroop = macroopDict[Name] 300 if not macroop.declared: 301 if env.doModRM: 302 macroop.initEnv = doModRMString 303 else: 304 macroop.initEnv = noModRMString 305 blocks.header_output = macroop.getDeclaration() 306 blocks.decoder_output = macroop.getDefinition(env) 307 macroop.declared = True 308 blocks.decode_block = "return %s;\n" % macroop.getAllocator(env) 309 return blocks 310}}; 311