mem.isa revision 2239
1// -*- mode:c++ -*- 2 3// Copyright (c) 2003-2005 The Regents of The University of Michigan 4// All rights reserved. 5// 6// Redistribution and use in source and binary forms, with or without 7// modification, are permitted provided that the following conditions are 8// met: redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer; 10// redistributions in binary form must reproduce the above copyright 11// notice, this list of conditions and the following disclaimer in the 12// documentation and/or other materials provided with the distribution; 13// neither the name of the copyright holders nor the names of its 14// contributors may be used to endorse or promote products derived from 15// this software without specific prior written permission. 16// 17// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 29output header {{ 30 /** 31 * Base class for general Mips memory-format instructions. 32 */ 33 class Memory : public MipsStaticInst 34 { 35 protected: 36 37 /// Memory request flags. See mem_req_base.hh. 38 unsigned memAccessFlags; 39 /// Pointer to EAComp object. 40 const StaticInstPtr eaCompPtr; 41 /// Pointer to MemAcc object. 42 const StaticInstPtr memAccPtr; 43 44 /// Displacement for EA calculation (signed). 45 int32_t disp; 46 47 /// Constructor 48 Memory(const char *mnem, MachInst _machInst, OpClass __opClass, 49 StaticInstPtr _eaCompPtr = nullStaticInstPtr, 50 StaticInstPtr _memAccPtr = nullStaticInstPtr) 51 : MipsStaticInst(mnem, _machInst, __opClass), 52 memAccessFlags(0), eaCompPtr(_eaCompPtr), memAccPtr(_memAccPtr), 53 disp(OFFSET) 54 { 55 //If Bit 15 is 1 then Sign Extend 56 int32_t temp = disp & 0x00008000; 57 58 if (temp > 0) { 59 disp |= 0xFFFF0000; 60 } 61 } 62 63 std::string 64 generateDisassembly(Addr pc, const SymbolTable *symtab) const; 65 66 public: 67 68 const StaticInstPtr &eaCompInst() const { return eaCompPtr; } 69 const StaticInstPtr &memAccInst() const { return memAccPtr; } 70 }; 71 72}}; 73 74 75output decoder {{ 76 std::string 77 Memory::generateDisassembly(Addr pc, const SymbolTable *symtab) const 78 { 79 return csprintf("%-10s %c%d,%d(r%d)", mnemonic, 80 flags[IsFloating] ? 'f' : 'r', RT, disp, RS); 81 } 82 83}}; 84 85def format LoadAddress(code) {{ 86 iop = InstObjParams(name, Name, 'MemoryDisp32', CodeBlock(code)) 87 header_output = BasicDeclare.subst(iop) 88 decoder_output = BasicConstructor.subst(iop) 89 decode_block = BasicDecode.subst(iop) 90 exec_output = BasicExecute.subst(iop) 91}}; 92 93 94def template LoadStoreDeclare {{ 95 /** 96 * Static instruction class for "%(mnemonic)s". 97 */ 98 class %(class_name)s : public %(base_class)s 99 { 100 protected: 101 102 /** 103 * "Fake" effective address computation class for "%(mnemonic)s". 104 */ 105 class EAComp : public %(base_class)s 106 { 107 public: 108 /// Constructor 109 EAComp(MachInst machInst); 110 111 %(BasicExecDeclare)s 112 }; 113 114 /** 115 * "Fake" memory access instruction class for "%(mnemonic)s". 116 */ 117 class MemAcc : public %(base_class)s 118 { 119 public: 120 /// Constructor 121 MemAcc(MachInst machInst); 122 123 %(BasicExecDeclare)s 124 }; 125 126 public: 127 128 /// Constructor. 129 %(class_name)s(MachInst machInst); 130 131 %(BasicExecDeclare)s 132 133 %(InitiateAccDeclare)s 134 135 %(CompleteAccDeclare)s 136 }; 137}}; 138 139 140def template InitiateAccDeclare {{ 141 Fault initiateAcc(%(CPU_exec_context)s *, Trace::InstRecord *) const; 142}}; 143 144 145def template CompleteAccDeclare {{ 146 Fault completeAcc(uint8_t *, %(CPU_exec_context)s *, Trace::InstRecord *) const; 147}}; 148 149 150def template LoadStoreConstructor {{ 151 /** TODO: change op_class to AddrGenOp or something (requires 152 * creating new member of OpClass enum in op_class.hh, updating 153 * config files, etc.). */ 154 inline %(class_name)s::EAComp::EAComp(MachInst machInst) 155 : %(base_class)s("%(mnemonic)s (EAComp)", machInst, IntAluOp) 156 { 157 %(ea_constructor)s; 158 } 159 160 inline %(class_name)s::MemAcc::MemAcc(MachInst machInst) 161 : %(base_class)s("%(mnemonic)s (MemAcc)", machInst, %(op_class)s) 162 { 163 %(memacc_constructor)s; 164 } 165 166 inline %(class_name)s::%(class_name)s(MachInst machInst) 167 : %(base_class)s("%(mnemonic)s", machInst, %(op_class)s, 168 new EAComp(machInst), new MemAcc(machInst)) 169 { 170 %(constructor)s; 171 } 172}}; 173 174 175def template EACompExecute {{ 176 Fault 177 %(class_name)s::EAComp::execute(%(CPU_exec_context)s *xc, 178 Trace::InstRecord *traceData) const 179 { 180 Addr EA; 181 Fault fault = NoFault; 182 183 %(fp_enable_check)s; 184 %(op_decl)s; 185 %(op_rd)s; 186 %(code)s; 187 188 if (fault == NoFault) { 189 %(op_wb)s; 190 xc->setEA(EA); 191 } 192 193 return fault; 194 } 195}}; 196 197def template LoadMemAccExecute {{ 198 Fault 199 %(class_name)s::MemAcc::execute(%(CPU_exec_context)s *xc, 200 Trace::InstRecord *traceData) const 201 { 202 Addr EA; 203 Fault fault = NoFault; 204 205 %(fp_enable_check)s; 206 %(op_decl)s; 207 %(op_rd)s; 208 EA = xc->getEA(); 209 210 if (fault == NoFault) { 211 fault = xc->read(EA, (uint%(mem_acc_size)d_t&)Mem, memAccessFlags); 212 %(code)s; 213 } 214 215 if (fault == NoFault) { 216 %(op_wb)s; 217 } 218 219 return fault; 220 } 221}}; 222 223 224def template LoadExecute {{ 225 Fault %(class_name)s::execute(%(CPU_exec_context)s *xc, 226 Trace::InstRecord *traceData) const 227 { 228 Addr EA; 229 Fault fault = NoFault; 230 231 %(fp_enable_check)s; 232 %(op_decl)s; 233 %(op_rd)s; 234 %(ea_code)s; 235 236 if (fault == NoFault) { 237 fault = xc->read(EA, (uint%(mem_acc_size)d_t&)Mem, memAccessFlags); 238 %(memacc_code)s; 239 } 240 241 if (fault == NoFault) { 242 %(op_wb)s; 243 } 244 245 return fault; 246 } 247}}; 248 249 250def template LoadInitiateAcc {{ 251 Fault %(class_name)s::initiateAcc(%(CPU_exec_context)s *xc, 252 Trace::InstRecord *traceData) const 253 { 254 Addr EA; 255 Fault fault = NoFault; 256 257 %(fp_enable_check)s; 258 %(op_src_decl)s; 259 %(op_rd)s; 260 %(ea_code)s; 261 262 if (fault == NoFault) { 263 fault = xc->read(EA, (uint%(mem_acc_size)d_t &)Mem, memAccessFlags); 264 } 265 266 return fault; 267 } 268}}; 269 270 271def template LoadCompleteAcc {{ 272 Fault %(class_name)s::completeAcc(uint8_t *data, 273 %(CPU_exec_context)s *xc, 274 Trace::InstRecord *traceData) const 275 { 276 Fault fault = NoFault; 277 278 %(fp_enable_check)s; 279 %(op_src_decl)s; 280 %(op_dest_decl)s; 281 282 memcpy(&Mem, data, sizeof(Mem)); 283 284 if (fault == NoFault) { 285 %(memacc_code)s; 286 } 287 288 if (fault == NoFault) { 289 %(op_wb)s; 290 } 291 292 return fault; 293 } 294}}; 295 296 297def template StoreMemAccExecute {{ 298 Fault 299 %(class_name)s::MemAcc::execute(%(CPU_exec_context)s *xc, 300 Trace::InstRecord *traceData) const 301 { 302 Addr EA; 303 Fault fault = NoFault; 304 uint64_t write_result = 0; 305 306 %(fp_enable_check)s; 307 %(op_decl)s; 308 %(op_rd)s; 309 EA = xc->getEA(); 310 311 if (fault == NoFault) { 312 %(code)s; 313 } 314 315 if (fault == NoFault) { 316 fault = xc->write((uint%(mem_acc_size)d_t&)Mem, EA, 317 memAccessFlags, &write_result); 318 if (traceData) { traceData->setData(Mem); } 319 } 320 321 if (fault == NoFault) { 322 %(postacc_code)s; 323 } 324 325 if (fault == NoFault) { 326 %(op_wb)s; 327 } 328 329 return fault; 330 } 331}}; 332 333 334def template StoreExecute {{ 335 Fault %(class_name)s::execute(%(CPU_exec_context)s *xc, 336 Trace::InstRecord *traceData) const 337 { 338 Addr EA; 339 Fault fault = NoFault; 340 uint64_t write_result = 0; 341 342 %(fp_enable_check)s; 343 %(op_decl)s; 344 %(op_rd)s; 345 %(ea_code)s; 346 347 if (fault == NoFault) { 348 %(memacc_code)s; 349 } 350 351 if (fault == NoFault) { 352 fault = xc->write((uint%(mem_acc_size)d_t&)Mem, EA, 353 memAccessFlags, &write_result); 354 if (traceData) { traceData->setData(Mem); } 355 } 356 357 if (fault == NoFault) { 358 %(postacc_code)s; 359 } 360 361 if (fault == NoFault) { 362 %(op_wb)s; 363 } 364 365 return fault; 366 } 367}}; 368 369def template StoreInitiateAcc {{ 370 Fault %(class_name)s::initiateAcc(%(CPU_exec_context)s *xc, 371 Trace::InstRecord *traceData) const 372 { 373 Addr EA; 374 Fault fault = NoFault; 375 uint64_t write_result = 0; 376 377 %(fp_enable_check)s; 378 %(op_src_decl)s; 379 %(op_dest_decl)s; 380 %(op_rd)s; 381 %(ea_code)s; 382 383 if (fault == NoFault) { 384 %(memacc_code)s; 385 } 386 387 if (fault == NoFault) { 388 fault = xc->write((uint%(mem_acc_size)d_t&)Mem, EA, 389 memAccessFlags, &write_result); 390 if (traceData) { traceData->setData(Mem); } 391 } 392 393 return fault; 394 } 395}}; 396 397 398def template StoreCompleteAcc {{ 399 Fault %(class_name)s::completeAcc(uint8_t *data, 400 %(CPU_exec_context)s *xc, 401 Trace::InstRecord *traceData) const 402 { 403 Fault fault = NoFault; 404 uint64_t write_result = 0; 405 406 %(fp_enable_check)s; 407 %(op_dest_decl)s; 408 409 memcpy(&write_result, data, sizeof(write_result)); 410 411 if (fault == NoFault) { 412 %(postacc_code)s; 413 } 414 415 if (fault == NoFault) { 416 %(op_wb)s; 417 } 418 419 return fault; 420 } 421}}; 422 423// load instructions use Rt as dest, so check for 424// Rt == 31 to detect nops 425def template LoadNopCheckDecode {{ 426 { 427 MipsStaticInst *i = new %(class_name)s(machInst); 428 if (RT == 0) { 429 i = makeNop(i); 430 } 431 return i; 432 } 433}}; 434 435def format LoadMemory(memacc_code, ea_code = {{ EA = Rs + disp; }}, 436 mem_flags = [], inst_flags = []) {{ 437 (header_output, decoder_output, decode_block, exec_output) = \ 438 LoadStoreBase(name, Name, ea_code, memacc_code, mem_flags, inst_flags, 439 decode_template = LoadNopCheckDecode, 440 exec_template_base = 'Load') 441}}; 442 443 444def format StoreMemory(memacc_code, ea_code = {{ EA = Rs + disp; }}, 445 mem_flags = [], inst_flags = []) {{ 446 (header_output, decoder_output, decode_block, exec_output) = \ 447 LoadStoreBase(name, Name, ea_code, memacc_code, mem_flags, inst_flags, 448 exec_template_base = 'Store') 449}}; 450 451//FP loads are offloaded to these formats for now ... 452def format LoadMemory2(ea_code = {{ EA = Rs + disp; }}, memacc_code = {{ }}, 453 mem_flags = [], inst_flags = []) {{ 454 (header_output, decoder_output, decode_block, exec_output) = \ 455 LoadStoreBase(name, Name, ea_code, memacc_code, mem_flags, inst_flags, 456 decode_template = LoadNopCheckDecode, 457 exec_template_base = 'Load') 458}}; 459 460 461//FP stores are offloaded to these formats for now ... 462def format StoreMemory2(ea_code = {{ EA = Rs + disp; }},memacc_code = {{ }}, 463 mem_flags = [], inst_flags = []) {{ 464 (header_output, decoder_output, decode_block, exec_output) = \ 465 LoadStoreBase(name, Name, ea_code, memacc_code, mem_flags, inst_flags, 466 decode_template = LoadNopCheckDecode, 467 exec_template_base = 'Store') 468}}; 469 470