mem.isa (3349:fec4a86fa212) | mem.isa (3953:300d526414e6) |
---|---|
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 --- 112 unchanged lines hidden (view full) --- 121 std::string 122 MemoryNoDisp::generateDisassembly(Addr pc, const SymbolTable *symtab) const 123 { 124 return csprintf("%-10s (r%d)", mnemonic, RB); 125 } 126}}; 127 128def format LoadAddress(code) {{ | 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 --- 112 unchanged lines hidden (view full) --- 121 std::string 122 MemoryNoDisp::generateDisassembly(Addr pc, const SymbolTable *symtab) const 123 { 124 return csprintf("%-10s (r%d)", mnemonic, RB); 125 } 126}}; 127 128def format LoadAddress(code) {{ |
129 iop = InstObjParams(name, Name, 'MemoryDisp32', CodeBlock(code)) | 129 iop = InstObjParams(name, Name, 'MemoryDisp32', code) |
130 header_output = BasicDeclare.subst(iop) 131 decoder_output = BasicConstructor.subst(iop) 132 decode_block = BasicDecode.subst(iop) 133 exec_output = BasicExecute.subst(iop) 134}}; 135 136 137def template LoadStoreDeclare {{ --- 48 unchanged lines hidden (view full) --- 186 187 188def template CompleteAccDeclare {{ 189 Fault completeAcc(PacketPtr, %(CPU_exec_context)s *, 190 Trace::InstRecord *) const; 191}}; 192 193 | 130 header_output = BasicDeclare.subst(iop) 131 decoder_output = BasicConstructor.subst(iop) 132 decode_block = BasicDecode.subst(iop) 133 exec_output = BasicExecute.subst(iop) 134}}; 135 136 137def template LoadStoreDeclare {{ --- 48 unchanged lines hidden (view full) --- 186 187 188def template CompleteAccDeclare {{ 189 Fault completeAcc(PacketPtr, %(CPU_exec_context)s *, 190 Trace::InstRecord *) const; 191}}; 192 193 |
194def template LoadStoreConstructor {{ | 194def template EACompConstructor {{ |
195 /** TODO: change op_class to AddrGenOp or something (requires 196 * creating new member of OpClass enum in op_class.hh, updating 197 * config files, etc.). */ 198 inline %(class_name)s::EAComp::EAComp(ExtMachInst machInst) 199 : %(base_class)s("%(mnemonic)s (EAComp)", machInst, IntAluOp) 200 { | 195 /** TODO: change op_class to AddrGenOp or something (requires 196 * creating new member of OpClass enum in op_class.hh, updating 197 * config files, etc.). */ 198 inline %(class_name)s::EAComp::EAComp(ExtMachInst machInst) 199 : %(base_class)s("%(mnemonic)s (EAComp)", machInst, IntAluOp) 200 { |
201 %(ea_constructor)s; | 201 %(constructor)s; |
202 } | 202 } |
203}}; |
|
203 | 204 |
205 206def template MemAccConstructor {{ |
|
204 inline %(class_name)s::MemAcc::MemAcc(ExtMachInst machInst) 205 : %(base_class)s("%(mnemonic)s (MemAcc)", machInst, %(op_class)s) 206 { | 207 inline %(class_name)s::MemAcc::MemAcc(ExtMachInst machInst) 208 : %(base_class)s("%(mnemonic)s (MemAcc)", machInst, %(op_class)s) 209 { |
207 %(memacc_constructor)s; | 210 %(constructor)s; |
208 } | 211 } |
212}}; |
|
209 | 213 |
214 215def template LoadStoreConstructor {{ |
|
210 inline %(class_name)s::%(class_name)s(ExtMachInst machInst) 211 : %(base_class)s("%(mnemonic)s", machInst, %(op_class)s, 212 new EAComp(machInst), new MemAcc(machInst)) 213 { 214 %(constructor)s; 215 } 216}}; 217 --- 4 unchanged lines hidden (view full) --- 222 Trace::InstRecord *traceData) const 223 { 224 Addr EA; 225 Fault fault = NoFault; 226 227 %(fp_enable_check)s; 228 %(op_decl)s; 229 %(op_rd)s; | 216 inline %(class_name)s::%(class_name)s(ExtMachInst machInst) 217 : %(base_class)s("%(mnemonic)s", machInst, %(op_class)s, 218 new EAComp(machInst), new MemAcc(machInst)) 219 { 220 %(constructor)s; 221 } 222}}; 223 --- 4 unchanged lines hidden (view full) --- 228 Trace::InstRecord *traceData) const 229 { 230 Addr EA; 231 Fault fault = NoFault; 232 233 %(fp_enable_check)s; 234 %(op_decl)s; 235 %(op_rd)s; |
230 %(code)s; | 236 %(ea_code)s; |
231 232 if (fault == NoFault) { 233 %(op_wb)s; 234 xc->setEA(EA); 235 } 236 237 return fault; 238 } --- 9 unchanged lines hidden (view full) --- 248 249 %(fp_enable_check)s; 250 %(op_decl)s; 251 %(op_rd)s; 252 EA = xc->getEA(); 253 254 if (fault == NoFault) { 255 fault = xc->read(EA, (uint%(mem_acc_size)d_t&)Mem, memAccessFlags); | 237 238 if (fault == NoFault) { 239 %(op_wb)s; 240 xc->setEA(EA); 241 } 242 243 return fault; 244 } --- 9 unchanged lines hidden (view full) --- 254 255 %(fp_enable_check)s; 256 %(op_decl)s; 257 %(op_rd)s; 258 EA = xc->getEA(); 259 260 if (fault == NoFault) { 261 fault = xc->read(EA, (uint%(mem_acc_size)d_t&)Mem, memAccessFlags); |
256 %(code)s; | 262 %(memacc_code)s; |
257 } 258 259 if (fault == NoFault) { 260 %(op_wb)s; 261 } 262 263 return fault; 264 } --- 82 unchanged lines hidden (view full) --- 347 uint64_t write_result = 0; 348 349 %(fp_enable_check)s; 350 %(op_decl)s; 351 %(op_rd)s; 352 EA = xc->getEA(); 353 354 if (fault == NoFault) { | 263 } 264 265 if (fault == NoFault) { 266 %(op_wb)s; 267 } 268 269 return fault; 270 } --- 82 unchanged lines hidden (view full) --- 353 uint64_t write_result = 0; 354 355 %(fp_enable_check)s; 356 %(op_decl)s; 357 %(op_rd)s; 358 EA = xc->getEA(); 359 360 if (fault == NoFault) { |
355 %(code)s; | 361 %(memacc_code)s; |
356 } 357 358 if (fault == NoFault) { 359 fault = xc->write((uint%(mem_acc_size)d_t&)Mem, EA, 360 memAccessFlags, &write_result); 361 if (traceData) { traceData->setData(Mem); } 362 } 363 --- 128 unchanged lines hidden (view full) --- 492 Fault fault = NoFault; 493 494 %(fp_enable_check)s; 495 %(op_decl)s; 496 %(op_rd)s; 497 EA = xc->getEA(); 498 499 if (fault == NoFault) { | 362 } 363 364 if (fault == NoFault) { 365 fault = xc->write((uint%(mem_acc_size)d_t&)Mem, EA, 366 memAccessFlags, &write_result); 367 if (traceData) { traceData->setData(Mem); } 368 } 369 --- 128 unchanged lines hidden (view full) --- 498 Fault fault = NoFault; 499 500 %(fp_enable_check)s; 501 %(op_decl)s; 502 %(op_rd)s; 503 EA = xc->getEA(); 504 505 if (fault == NoFault) { |
500 %(code)s; | 506 %(memacc_code)s; |
501 } 502 503 return NoFault; 504 } 505}}; 506 507def template MiscExecute {{ 508 Fault %(class_name)s::execute(%(CPU_exec_context)s *xc, --- 68 unchanged lines hidden (view full) --- 577 decode_template = BasicDecode, exec_template_base = ''): 578 # Make sure flags are in lists (convert to lists if not). 579 mem_flags = makeList(mem_flags) 580 inst_flags = makeList(inst_flags) 581 582 # add hook to get effective addresses into execution trace output. 583 ea_code += '\nif (traceData) { traceData->setAddr(EA); }\n' 584 | 507 } 508 509 return NoFault; 510 } 511}}; 512 513def template MiscExecute {{ 514 Fault %(class_name)s::execute(%(CPU_exec_context)s *xc, --- 68 unchanged lines hidden (view full) --- 583 decode_template = BasicDecode, exec_template_base = ''): 584 # Make sure flags are in lists (convert to lists if not). 585 mem_flags = makeList(mem_flags) 586 inst_flags = makeList(inst_flags) 587 588 # add hook to get effective addresses into execution trace output. 589 ea_code += '\nif (traceData) { traceData->setAddr(EA); }\n' 590 |
585 # generate code block objects 586 ea_cblk = CodeBlock(ea_code) 587 memacc_cblk = CodeBlock(memacc_code) 588 postacc_cblk = CodeBlock(postacc_code) 589 | |
590 # Some CPU models execute the memory operation as an atomic unit, 591 # while others want to separate them into an effective address 592 # computation and a memory access operation. As a result, we need 593 # to generate three StaticInst objects. Note that the latter two 594 # are nested inside the larger "atomic" one. 595 | 591 # Some CPU models execute the memory operation as an atomic unit, 592 # while others want to separate them into an effective address 593 # computation and a memory access operation. As a result, we need 594 # to generate three StaticInst objects. Note that the latter two 595 # are nested inside the larger "atomic" one. 596 |
596 # generate InstObjParams for EAComp object 597 ea_iop = InstObjParams(name, Name, base_class, ea_cblk, inst_flags) | 597 # Generate InstObjParams for each of the three objects. Note that 598 # they differ only in the set of code objects contained (which in 599 # turn affects the object's overall operand list). 600 iop = InstObjParams(name, Name, base_class, 601 { 'ea_code':ea_code, 'memacc_code':memacc_code, 'postacc_code':postacc_code }, 602 inst_flags) 603 ea_iop = InstObjParams(name, Name, base_class, 604 { 'ea_code':ea_code }, 605 inst_flags) 606 memacc_iop = InstObjParams(name, Name, base_class, 607 { 'memacc_code':memacc_code, 'postacc_code':postacc_code }, 608 inst_flags) |
598 | 609 |
599 # generate InstObjParams for MemAcc object 600 memacc_iop = InstObjParams(name, Name, base_class, memacc_cblk, inst_flags) 601 # in the split execution model, the MemAcc portion is responsible 602 # for the post-access code. 603 memacc_iop.postacc_code = postacc_cblk.code 604 605 # generate InstObjParams for InitiateAcc, CompleteAcc object 606 # The code used depends on the template being used 607 if (exec_template_base == 'Load'): 608 initiateacc_cblk = CodeBlock(ea_code + memacc_code) 609 completeacc_cblk = CodeBlock(memacc_code + postacc_code) 610 elif (exec_template_base.startswith('Store')): 611 initiateacc_cblk = CodeBlock(ea_code + memacc_code) 612 completeacc_cblk = CodeBlock(postacc_code) 613 else: 614 initiateacc_cblk = '' 615 completeacc_cblk = '' 616 617 initiateacc_iop = InstObjParams(name, Name, base_class, initiateacc_cblk, 618 inst_flags) 619 620 completeacc_iop = InstObjParams(name, Name, base_class, completeacc_cblk, 621 inst_flags) 622 623 if (exec_template_base == 'Load'): 624 initiateacc_iop.ea_code = ea_cblk.code 625 initiateacc_iop.memacc_code = memacc_cblk.code 626 completeacc_iop.memacc_code = memacc_cblk.code 627 completeacc_iop.postacc_code = postacc_cblk.code 628 elif (exec_template_base.startswith('Store')): 629 initiateacc_iop.ea_code = ea_cblk.code 630 initiateacc_iop.memacc_code = memacc_cblk.code 631 completeacc_iop.postacc_code = postacc_cblk.code 632 633 # generate InstObjParams for unified execution 634 cblk = CodeBlock(ea_code + memacc_code + postacc_code) 635 iop = InstObjParams(name, Name, base_class, cblk, inst_flags) 636 637 iop.ea_constructor = ea_cblk.constructor 638 iop.ea_code = ea_cblk.code 639 iop.memacc_constructor = memacc_cblk.constructor 640 iop.memacc_code = memacc_cblk.code 641 iop.postacc_code = postacc_cblk.code 642 | |
643 if mem_flags: 644 s = '\n\tmemAccessFlags = ' + string.join(mem_flags, '|') + ';' 645 iop.constructor += s 646 memacc_iop.constructor += s 647 648 # select templates 649 650 # define aliases... most StoreCond templates are the same as the 651 # corresponding Store templates (only CompleteAcc is different). 652 StoreCondMemAccExecute = StoreMemAccExecute 653 StoreCondExecute = StoreExecute 654 StoreCondInitiateAcc = StoreInitiateAcc 655 656 memAccExecTemplate = eval(exec_template_base + 'MemAccExecute') 657 fullExecTemplate = eval(exec_template_base + 'Execute') 658 initiateAccTemplate = eval(exec_template_base + 'InitiateAcc') 659 completeAccTemplate = eval(exec_template_base + 'CompleteAcc') 660 661 # (header_output, decoder_output, decode_block, exec_output) | 610 if mem_flags: 611 s = '\n\tmemAccessFlags = ' + string.join(mem_flags, '|') + ';' 612 iop.constructor += s 613 memacc_iop.constructor += s 614 615 # select templates 616 617 # define aliases... most StoreCond templates are the same as the 618 # corresponding Store templates (only CompleteAcc is different). 619 StoreCondMemAccExecute = StoreMemAccExecute 620 StoreCondExecute = StoreExecute 621 StoreCondInitiateAcc = StoreInitiateAcc 622 623 memAccExecTemplate = eval(exec_template_base + 'MemAccExecute') 624 fullExecTemplate = eval(exec_template_base + 'Execute') 625 initiateAccTemplate = eval(exec_template_base + 'InitiateAcc') 626 completeAccTemplate = eval(exec_template_base + 'CompleteAcc') 627 628 # (header_output, decoder_output, decode_block, exec_output) |
662 return (LoadStoreDeclare.subst(iop), LoadStoreConstructor.subst(iop), | 629 return (LoadStoreDeclare.subst(iop), 630 EACompConstructor.subst(ea_iop) 631 + MemAccConstructor.subst(memacc_iop) 632 + LoadStoreConstructor.subst(iop), |
663 decode_template.subst(iop), 664 EACompExecute.subst(ea_iop) 665 + memAccExecTemplate.subst(memacc_iop) 666 + fullExecTemplate.subst(iop) | 633 decode_template.subst(iop), 634 EACompExecute.subst(ea_iop) 635 + memAccExecTemplate.subst(memacc_iop) 636 + fullExecTemplate.subst(iop) |
667 + initiateAccTemplate.subst(initiateacc_iop) 668 + completeAccTemplate.subst(completeacc_iop)) | 637 + initiateAccTemplate.subst(iop) 638 + completeAccTemplate.subst(iop)) |
669}}; 670 671def format LoadOrNop(memacc_code, ea_code = {{ EA = Rb + disp; }}, 672 mem_flags = [], inst_flags = []) {{ 673 (header_output, decoder_output, decode_block, exec_output) = \ 674 LoadStoreBase(name, Name, ea_code, memacc_code, mem_flags, inst_flags, 675 decode_template = LoadNopCheckDecode, 676 exec_template_base = 'Load') --- 60 unchanged lines hidden --- | 639}}; 640 641def format LoadOrNop(memacc_code, ea_code = {{ EA = Rb + disp; }}, 642 mem_flags = [], inst_flags = []) {{ 643 (header_output, decoder_output, decode_block, exec_output) = \ 644 LoadStoreBase(name, Name, ea_code, memacc_code, mem_flags, inst_flags, 645 decode_template = LoadNopCheckDecode, 646 exec_template_base = 'Load') --- 60 unchanged lines hidden --- |