From 4f9ead58ff1ff1c630a503b39b49f171bfbf4173 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Fri, 17 Mar 2006 14:02:38 -0500 Subject: Clean up and fix for compilation --HG-- extra : convert_revision : c4e66cd678313f7fe169787cb1bf3e45f114c4fd --- arch/sparc/isa/formats/integerop.isa | 152 ++++++++++++++++++++++++++--------- arch/sparc/isa/formats/priv.isa | 27 +++---- 2 files changed, 123 insertions(+), 56 deletions(-) (limited to 'arch/sparc/isa/formats') diff --git a/arch/sparc/isa/formats/integerop.isa b/arch/sparc/isa/formats/integerop.isa index 7b6bfa54d..e7bd4c2a4 100644 --- a/arch/sparc/isa/formats/integerop.isa +++ b/arch/sparc/isa/formats/integerop.isa @@ -7,11 +7,11 @@ output header {{ /** * Base class for integer operations. */ - class IntegerOp : public SparcStaticInst + class IntOp : public SparcStaticInst { protected: // Constructor - IntegerOp(const char *mnem, ExtMachInst _machInst, OpClass __opClass) : + IntOp(const char *mnem, ExtMachInst _machInst, OpClass __opClass) : SparcStaticInst(mnem, _machInst, __opClass) { } @@ -19,24 +19,68 @@ output header {{ std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const; }; + + /** + * Base class for 10 bit immediate integer operations. + */ + class IntOpImm10 : public IntOp + { + protected: + // Constructor + IntOpImm10(const char *mnem, ExtMachInst _machInst, OpClass __opClass) : + IntOp(mnem, _machInst, __opClass), imm(SIMM10) + { + } + + uint32_t imm; + }; + + /** + * Base class for 13 bit immediate integer operations. + */ + class IntOpImm13 : public IntOp + { + protected: + // Constructor + IntOpImm13(const char *mnem, ExtMachInst _machInst, OpClass __opClass) : + IntOp(mnem, _machInst, __opClass), imm(SIMM13) + { + } + + uint32_t imm; + }; }}; output decoder {{ - std::string IntegerOp::generateDisassembly(Addr pc, + std::string IntOp::generateDisassembly(Addr pc, const SymbolTable *symtab) const { return "Integer instruction\n"; } }}; -def template IntegerExecute {{ +def template IntOpExecute {{ + Fault %(class_name)s::execute(%(CPU_exec_context)s *xc, + Trace::InstRecord *traceData) const + { + Fault fault = NoFault; + + %(op_decl)s; + %(op_rd)s; + %(code)s; + + //Write the resulting state to the execution context + if(fault == NoFault) + %(op_wb)s; + return fault; + } +}}; + +def template IntOpCcExecute {{ Fault %(class_name)s::execute(%(CPU_exec_context)s *xc, Trace::InstRecord *traceData) const { Fault fault; - //These are set to constants when the execute method - //is generated - bool useCc = ; %(op_decl)s; %(op_rd)s; @@ -46,46 +90,76 @@ def template IntegerExecute {{ if(fault == NoFault) { %(op_wb)s; - if(useCc) - { - CcrIccN = Rd & (1 << 63); - CcrIccZ = (Rd == 0); - CcrIccV = ivValue; - CcrIccC = icValue; - CcrXccN = Rd & (1 << 31); - CcrXccZ = ((Rd & 0xFFFFFFFF) == 0); - CcrXccV = xvValue; - CcrXccC = xcValue; - } + CcrIccN = Rd & (1 << 63); + CcrIccZ = (Rd == 0); + CcrIccV = ivValue; + CcrIccC = icValue; + CcrXccN = Rd & (1 << 31); + CcrXccZ = ((Rd & 0xFFFFFFFF) == 0); + CcrXccV = xvValue; + CcrXccC = xcValue; } return fault; } }}; -// Primary format for integer operate instructions: -def format IntegerOp(code, *opt_flags) {{ - orig_code = code - cblk = CodeBlock(code) - for (marker, value) in (('ivValue', '0'), ('icValue', '0'), - ('xvValue', '0'), ('xcValue', '0')): - code.replace(marker, value) - iop = InstObjParams(name, Name, 'SparcStaticInst', cblk, opt_flags) +def template IntOpCcResExecute {{ + Fault %(class_name)s::execute(%(CPU_exec_context)s *xc, + Trace::InstRecord *traceData) const + { + Fault fault; + + %(op_decl)s; + %(op_rd)s; + %(code)s; + + //Write the resulting state to the execution context + if(fault == NoFault) + { + %(op_wb)s; + CcrIccN = Rd & (1 << 63); + CcrIccZ = (Rd == 0); + CcrXccN = Rd & (1 << 31); + CcrXccZ = ((Rd & 0xFFFFFFFF) == 0); + CcrIccV = CcrIccC = CcrXccV = CcrXccC = 0; + } + return fault; + } +}}; + +let {{ + def doIntFormat(code, execTemplate, name, Name, opt_flags): + (usesImm, cblk, immCblk, rString, iString) = splitOutImm(code) + iop = InstObjParams(name, Name, 'IntOp', cblk, opt_flags) header_output = BasicDeclare.subst(iop) decoder_output = BasicConstructor.subst(iop) - decode_block = BasicDecode.subst(iop) - exec_output = IntegerExecute.subst(iop) + exec_output = execTemplate.subst(iop) + if usesImm: + imm_iop = InstObjParams(name, Name + 'Imm', 'IntOpImm' + iString, + immCblk, opt_flags) + header_output += BasicDeclare.subst(imm_iop) + decoder_output += BasicConstructor.subst(imm_iop) + exec_output += execTemplate.subst(imm_iop) + decode_block = ROrImmDecode.subst(iop) + else: + decode_block = BasicDecode.subst(iop) }}; // Primary format for integer operate instructions: -def format IntegerOpCc(code, icValue, ivValue, xcValue, xvValue, *opt_flags) {{ - orig_code = code - cblk = CodeBlock(code) - for (marker, value) in (('ivValue', ivValue), ('icValue', icValue), - ('xvValue', xvValue), ('xcValue', xcValue)): - code.replace(marker, value) - iop = InstObjParams(name, Name, 'SparcStaticInst', cblk, opt_flags) - header_output = BasicDeclare.subst(iop) - decoder_output = BasicConstructor.subst(iop) - decode_block = BasicDecode.subst(iop) - exec_output = IntegerExecute.subst(iop) +def format IntOp(code, *opt_flags) {{ + doIntFormat(code, IntOpExecute, name, Name, opt_flags) }}; + +// Primary format for integer operate instructions: +def format IntOpCc(code, icValue, ivValue, xcValue, xvValue, *opt_flags) {{ + for (marker, value) in (('ivValue', ivValue), ('icValue', icValue), + ('xvValue', xvValue), ('xcValue', xcValue)): + code.replace(marker, value) + doIntFormat(code, IntOpCcExecute, name, Name, opt_flags) +}}; + +// Primary format for integer operate instructions: +def format IntOpCcRes(code, *opt_flags) {{ + doIntFormat(code, IntOpCcResExecute, name, Name, opt_flags) +}}; + diff --git a/arch/sparc/isa/formats/priv.isa b/arch/sparc/isa/formats/priv.isa index 7c0d8a985..c89e769b4 100644 --- a/arch/sparc/isa/formats/priv.isa +++ b/arch/sparc/isa/formats/priv.isa @@ -1,6 +1,6 @@ //////////////////////////////////////////////////////////////////// // -// Privelege mode instructions +// Privilege mode instructions // output header {{ @@ -92,8 +92,8 @@ def template PrivExecute {{ %(op_rd)s; //If the processor isn't in privileged mode, fault out right away - if(!pstate_priv) - return new PrivilegedOpCode + if(!PstatePriv) + return new PrivilegedOpcode %(code)s; %(op_wb)s; @@ -108,7 +108,7 @@ def template PrivTickExecute {{ %(op_rd)s; //If the processor isn't in privileged mode, fault out right away - if(!pstate_priv && tick_npt) + if(!PstatePriv && TickNpt) return new PrivilegedAction %(code)s; @@ -116,20 +116,13 @@ def template PrivTickExecute {{ } }}; -def template Rb2OrImm13Decode {{ - { - return (I ? (SparcStaticInst *)(new %(class_name)sImm(machInst)) - : (SparcStaticInst *)(new %(class_name)s(machInst))); - } -}}; - // Primary format for integer operate instructions: def format Priv(code, *opt_flags) {{ uses_imm = (code.find('Rs2_or_imm13') != -1) if uses_imm: orig_code = code - code = re.sub(r'Rs2_or_imm', 'Rs2', orig_code) - imm_code = re.sub(r'Rs2_or_imm(\.\w+)?', 'imm', orig_code) + code = re.sub(r'Rs2_or_imm13', 'Rs2', orig_code) + imm_code = re.sub(r'Rs2_or_imm13(\.\w+)?', 'imm', orig_code) cblk = CodeBlock(code) iop = InstObjParams(name, Name, 'Priv', cblk, opt_flags) header_output = BasicDeclare.subst(iop) @@ -142,7 +135,7 @@ def format Priv(code, *opt_flags) {{ header_output += BasicDeclare.subst(imm_iop) decoder_output += BasicConstructor.subst(imm_iop) exec_output += PrivExecute.subst(imm_iop) - decode_block = Rb2OrImm13Decode.subst(iop) + decode_block = ROrImmDecode.subst(iop) else: decode_block = BasicDecode.subst(iop) }}; @@ -152,8 +145,8 @@ def format PrivTick(code, *opt_flags) {{ uses_imm = (code.find('Rs2_or_imm13') != -1) if uses_imm: orig_code = code - code = re.sub(r'Rs2_or_imm', 'Rs2', orig_code) - imm_code = re.sub(r'Rs2_or_imm(\.\w+)?', 'imm', orig_code) + code = re.sub(r'Rs2_or_imm13', 'Rs2', orig_code) + imm_code = re.sub(r'Rs2_or_imm13(\.\w+)?', 'imm', orig_code) cblk = CodeBlock(code) iop = InstObjParams(name, Name, 'PrivTick', cblk, opt_flags) header_output = BasicDeclare.subst(iop) @@ -166,7 +159,7 @@ def format PrivTick(code, *opt_flags) {{ header_output += BasicDeclare.subst(imm_iop) decoder_output += BasicConstructor.subst(imm_iop) exec_output += PrivTickExecute.subst(imm_iop) - decode_block = Rb2OrImm13Decode.subst(iop) + decode_block = Rb2OrImmDecode.subst(iop) else: decode_block = BasicDecode.subst(iop) }}; -- cgit v1.2.3