1// Copyright (c) 2006-2007 The Regents of The University of Michigan 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: redistributions of source code must retain the above copyright 7// notice, this list of conditions and the following disclaimer; 8// redistributions in binary form must reproduce the above copyright 9// notice, this list of conditions and the following disclaimer in the 10// documentation and/or other materials provided with the distribution; 11// neither the name of the copyright holders nor the names of its 12// contributors may be used to endorse or promote products derived from 13// this software without specific prior written permission. 14// 15// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 18// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 19// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 21// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26// 27// Authors: Ali Saidi 28// Gabe Black 29// Steve Reinhardt 30
| 1// Copyright (c) 2006-2007 The Regents of The University of Michigan 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: redistributions of source code must retain the above copyright 7// notice, this list of conditions and the following disclaimer; 8// redistributions in binary form must reproduce the above copyright 9// notice, this list of conditions and the following disclaimer in the 10// documentation and/or other materials provided with the distribution; 11// neither the name of the copyright holders nor the names of its 12// contributors may be used to endorse or promote products derived from 13// this software without specific prior written permission. 14// 15// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 18// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 19// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 21// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26// 27// Authors: Ali Saidi 28// Gabe Black 29// Steve Reinhardt 30
|
31// Declarations for execute() methods. 32def template BasicExecDeclare {{ 33 Fault execute(ExecContext *, Trace::InstRecord *) const; 34}}; 35 36def template DoFpOpDeclare {{ 37 Fault doFpOp(ExecContext *, Trace::InstRecord *) 38 const M5_NO_INLINE; 39}}; 40 41// Definitions of execute methods that panic. 42def template BasicExecPanic {{ 43 Fault 44 execute(ExecContext *, Trace::InstRecord *) const 45 { 46 panic("Execute method called when it shouldn't!"); 47 M5_DUMMY_RETURN 48 } 49}}; 50
| |
51// Basic instruction class declaration template. 52def template BasicDeclare {{ 53 /** 54 * Static instruction class for "%(mnemonic)s". 55 */ 56 class %(class_name)s : public %(base_class)s 57 { 58 public: 59 // Constructor. 60 %(class_name)s(ExtMachInst machInst);
| 31// Basic instruction class declaration template. 32def template BasicDeclare {{ 33 /** 34 * Static instruction class for "%(mnemonic)s". 35 */ 36 class %(class_name)s : public %(base_class)s 37 { 38 public: 39 // Constructor. 40 %(class_name)s(ExtMachInst machInst);
|
61 %(BasicExecDeclare)s
| 41 Fault execute(ExecContext *, Trace::InstRecord *) const;
|
62 }; 63}}; 64 65// Basic instruction class declaration template. 66def template FpBasicDeclare {{ 67 /** 68 * Static instruction class for "%(mnemonic)s". 69 */ 70 class %(class_name)s : public %(base_class)s 71 { 72 public: 73 // Constructor. 74 %(class_name)s(ExtMachInst machInst);
| 42 }; 43}}; 44 45// Basic instruction class declaration template. 46def template FpBasicDeclare {{ 47 /** 48 * Static instruction class for "%(mnemonic)s". 49 */ 50 class %(class_name)s : public %(base_class)s 51 { 52 public: 53 // Constructor. 54 %(class_name)s(ExtMachInst machInst);
|
75 %(BasicExecDeclare)s 76 %(DoFpOpDeclare)s
| 55 Fault execute(ExecContext *, Trace::InstRecord *) const; 56 Fault doFpOp(ExecContext *, 57 Trace::InstRecord *) const M5_NO_INLINE;
|
77 }; 78}}; 79 80// Basic instruction class declaration template. 81def template BasicDeclareWithMnemonic {{ 82 /** 83 * Static instruction class for "%(mnemonic)s". 84 */ 85 class %(class_name)s : public %(base_class)s 86 { 87 public: 88 // Constructor. 89 %(class_name)s(const char * mnemonic, ExtMachInst machInst);
| 58 }; 59}}; 60 61// Basic instruction class declaration template. 62def template BasicDeclareWithMnemonic {{ 63 /** 64 * Static instruction class for "%(mnemonic)s". 65 */ 66 class %(class_name)s : public %(base_class)s 67 { 68 public: 69 // Constructor. 70 %(class_name)s(const char * mnemonic, ExtMachInst machInst);
|
90 %(BasicExecDeclare)s
| 71 Fault execute(ExecContext *, Trace::InstRecord *) const;
|
91 }; 92}}; 93 94// Basic instruction class constructor template. 95def template BasicConstructor {{ 96 %(class_name)s::%(class_name)s(ExtMachInst machInst) 97 : %(base_class)s("%(mnemonic)s", machInst, %(op_class)s) 98 { 99 %(constructor)s; 100 } 101}}; 102 103// Basic instruction class constructor template. 104def template BasicConstructorWithMnemonic {{ 105 %(class_name)s::%(class_name)s(const char * mnemonic, 106 ExtMachInst machInst) 107 : %(base_class)s(mnemonic, machInst, %(op_class)s) 108 { 109 %(constructor)s; 110 } 111}}; 112 113// Basic instruction class execute method template. 114def template BasicExecute {{ 115 Fault 116 %(class_name)s::execute(ExecContext *xc, 117 Trace::InstRecord *traceData) const 118 { 119 Fault fault = NoFault; 120 121 %(fp_enable_check)s; 122 %(op_decl)s; 123 %(op_rd)s; 124 %(code)s; 125 126 if (fault == NoFault) { 127 %(op_wb)s; 128 } 129 return fault; 130 } 131}}; 132 133def template DoFpOpExecute {{ 134 Fault 135 %(class_name)s::doFpOp(ExecContext *xc, 136 Trace::InstRecord *traceData) const 137 { 138 Fault fault = NoFault; 139 %(op_decl)s; 140 %(op_rd)s; 141 %(fp_code)s; 142 if (fault == NoFault) { 143 %(op_wb)s; 144 } 145 return fault; 146 } 147}}; 148 149// Basic decode template. 150def template BasicDecode {{ 151 return new %(class_name)s(machInst); 152}}; 153 154// Basic decode template, passing mnemonic in as string arg to constructor. 155def template BasicDecodeWithMnemonic {{ 156 return new %(class_name)s("%(mnemonic)s", machInst); 157}}; 158 159// The most basic instruction format... used only for a few misc. insts 160def format BasicOperate(code, *flags) {{ 161 code = filterDoubles(code) 162 iop = InstObjParams(name, Name, 'SparcStaticInst', code, flags) 163 header_output = BasicDeclare.subst(iop) 164 decoder_output = BasicConstructor.subst(iop) 165 decode_block = BasicDecode.subst(iop) 166 exec_output = BasicExecute.subst(iop) 167}}; 168 169def format FpBasic(code, *flags) {{ 170 exec_code = """ 171 Fsr |= bits(Fsr, 4, 0) << 5; 172 Fsr = insertBits(Fsr, 4, 0, 0); 173 int newrnd = M5_FE_TONEAREST; 174 switch (Fsr<31:30>) { 175 case 0: newrnd = M5_FE_TONEAREST; break; 176 case 1: newrnd = M5_FE_TOWARDZERO; break; 177 case 2: newrnd = M5_FE_UPWARD; break; 178 case 3: newrnd = M5_FE_DOWNWARD; break; 179 } 180 int oldrnd = m5_fegetround(); 181 m5_fesetround(newrnd); 182 __asm__ __volatile__("" ::: "memory"); 183 fault = doFpOp(xc, traceData); 184 __asm__ __volatile__("" ::: "memory"); 185 m5_fesetround(oldrnd); 186 return fault; 187""" 188 fp_code = filterDoubles(code) 189 iop = InstObjParams(name, Name, 'SparcStaticInst', 190 { "code" : exec_code, "fp_code" : fp_code }, flags) 191 header_output = FpBasicDeclare.subst(iop) 192 decoder_output = BasicConstructor.subst(iop) 193 decode_block = BasicDecode.subst(iop) 194 exec_output = BasicExecute.subst(iop) 195 exec_output += DoFpOpExecute.subst(iop) 196}};
| 72 }; 73}}; 74 75// Basic instruction class constructor template. 76def template BasicConstructor {{ 77 %(class_name)s::%(class_name)s(ExtMachInst machInst) 78 : %(base_class)s("%(mnemonic)s", machInst, %(op_class)s) 79 { 80 %(constructor)s; 81 } 82}}; 83 84// Basic instruction class constructor template. 85def template BasicConstructorWithMnemonic {{ 86 %(class_name)s::%(class_name)s(const char * mnemonic, 87 ExtMachInst machInst) 88 : %(base_class)s(mnemonic, machInst, %(op_class)s) 89 { 90 %(constructor)s; 91 } 92}}; 93 94// Basic instruction class execute method template. 95def template BasicExecute {{ 96 Fault 97 %(class_name)s::execute(ExecContext *xc, 98 Trace::InstRecord *traceData) const 99 { 100 Fault fault = NoFault; 101 102 %(fp_enable_check)s; 103 %(op_decl)s; 104 %(op_rd)s; 105 %(code)s; 106 107 if (fault == NoFault) { 108 %(op_wb)s; 109 } 110 return fault; 111 } 112}}; 113 114def template DoFpOpExecute {{ 115 Fault 116 %(class_name)s::doFpOp(ExecContext *xc, 117 Trace::InstRecord *traceData) const 118 { 119 Fault fault = NoFault; 120 %(op_decl)s; 121 %(op_rd)s; 122 %(fp_code)s; 123 if (fault == NoFault) { 124 %(op_wb)s; 125 } 126 return fault; 127 } 128}}; 129 130// Basic decode template. 131def template BasicDecode {{ 132 return new %(class_name)s(machInst); 133}}; 134 135// Basic decode template, passing mnemonic in as string arg to constructor. 136def template BasicDecodeWithMnemonic {{ 137 return new %(class_name)s("%(mnemonic)s", machInst); 138}}; 139 140// The most basic instruction format... used only for a few misc. insts 141def format BasicOperate(code, *flags) {{ 142 code = filterDoubles(code) 143 iop = InstObjParams(name, Name, 'SparcStaticInst', code, flags) 144 header_output = BasicDeclare.subst(iop) 145 decoder_output = BasicConstructor.subst(iop) 146 decode_block = BasicDecode.subst(iop) 147 exec_output = BasicExecute.subst(iop) 148}}; 149 150def format FpBasic(code, *flags) {{ 151 exec_code = """ 152 Fsr |= bits(Fsr, 4, 0) << 5; 153 Fsr = insertBits(Fsr, 4, 0, 0); 154 int newrnd = M5_FE_TONEAREST; 155 switch (Fsr<31:30>) { 156 case 0: newrnd = M5_FE_TONEAREST; break; 157 case 1: newrnd = M5_FE_TOWARDZERO; break; 158 case 2: newrnd = M5_FE_UPWARD; break; 159 case 3: newrnd = M5_FE_DOWNWARD; break; 160 } 161 int oldrnd = m5_fegetround(); 162 m5_fesetround(newrnd); 163 __asm__ __volatile__("" ::: "memory"); 164 fault = doFpOp(xc, traceData); 165 __asm__ __volatile__("" ::: "memory"); 166 m5_fesetround(oldrnd); 167 return fault; 168""" 169 fp_code = filterDoubles(code) 170 iop = InstObjParams(name, Name, 'SparcStaticInst', 171 { "code" : exec_code, "fp_code" : fp_code }, flags) 172 header_output = FpBasicDeclare.subst(iop) 173 decoder_output = BasicConstructor.subst(iop) 174 decode_block = BasicDecode.subst(iop) 175 exec_output = BasicExecute.subst(iop) 176 exec_output += DoFpOpExecute.subst(iop) 177}};
|