basic.isa (12236:126ac9da6050) | basic.isa (12275:4b4dd932c710) |
---|---|
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 --- 16 unchanged lines hidden (view full) --- 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// Basic instruction class declaration template. 32def template BasicDeclare {{ | 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 --- 16 unchanged lines hidden (view full) --- 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// 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); 41 Fault execute(ExecContext *, Trace::InstRecord *) const; 42 }; | 33/** 34 * Static instruction class for "%(mnemonic)s". 35 */ 36class %(class_name)s : public %(base_class)s 37{ 38 public: 39 // Constructor. 40 %(class_name)s(ExtMachInst machInst); 41 Fault execute(ExecContext *, Trace::InstRecord *) const; 42}; |
43}}; 44 45// Basic instruction class declaration template. 46def template FpBasicDeclare {{ | 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); 55 Fault execute(ExecContext *, Trace::InstRecord *) const; 56 Fault doFpOp(ExecContext *, 57 Trace::InstRecord *) const M5_NO_INLINE; 58 }; | 47/** 48 * Static instruction class for "%(mnemonic)s". 49 */ 50class %(class_name)s : public %(base_class)s 51{ 52 public: 53 // Constructor. 54 %(class_name)s(ExtMachInst machInst); 55 Fault execute(ExecContext *, Trace::InstRecord *) const; 56 Fault doFpOp(ExecContext *, Trace::InstRecord *) const M5_NO_INLINE; 57}; |
59}}; 60 61// Basic instruction class declaration template. 62def template BasicDeclareWithMnemonic {{ | 58}}; 59 60// Basic instruction class declaration template. 61def 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); 71 Fault execute(ExecContext *, Trace::InstRecord *) const; 72 }; | 62/** 63 * Static instruction class for "%(mnemonic)s". 64 */ 65class %(class_name)s : public %(base_class)s 66{ 67 public: 68 // Constructor. 69 %(class_name)s(const char *mnemonic, ExtMachInst machInst); 70 Fault execute(ExecContext *, Trace::InstRecord *) const; 71}; |
73}}; 74 75// Basic instruction class constructor template. 76def template BasicConstructor {{ | 72}}; 73 74// Basic instruction class constructor template. 75def 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 } | 76%(class_name)s::%(class_name)s(ExtMachInst machInst) : 77 %(base_class)s("%(mnemonic)s", machInst, %(op_class)s) 78{ 79 %(constructor)s; 80} |
82}}; 83 84// Basic instruction class constructor template. 85def template BasicConstructorWithMnemonic {{ | 81}}; 82 83// Basic instruction class constructor template. 84def 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 } | 85%(class_name)s::%(class_name)s(const char *mnemonic, ExtMachInst machInst) : 86 %(base_class)s(mnemonic, machInst, %(op_class)s) 87{ 88 %(constructor)s; 89} |
92}}; 93 94// Basic instruction class execute method template. 95def template BasicExecute {{ | 90}}; 91 92// Basic instruction class execute method template. 93def template BasicExecute {{ |
96 Fault 97 %(class_name)s::execute(ExecContext *xc, 98 Trace::InstRecord *traceData) const 99 { 100 Fault fault = NoFault; | 94Fault 95%(class_name)s::execute(ExecContext *xc, 96 Trace::InstRecord *traceData) const 97{ 98 Fault fault = NoFault; |
101 | 99 |
102 %(fp_enable_check)s; 103 %(op_decl)s; 104 %(op_rd)s; 105 %(code)s; | 100 %(fp_enable_check)s; 101 %(op_decl)s; 102 %(op_rd)s; 103 %(code)s; |
106 | 104 |
107 if (fault == NoFault) { 108 %(op_wb)s; 109 } 110 return fault; 111 } | 105 if (fault == NoFault) { 106 %(op_wb)s; 107 } 108 return fault; 109} |
112}}; 113 114def template DoFpOpExecute {{ | 110}}; 111 112def 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 } | 113Fault 114%(class_name)s::doFpOp(ExecContext *xc, Trace::InstRecord *traceData) const 115{ 116 Fault fault = NoFault; 117 %(op_decl)s; 118 %(op_rd)s; 119 %(fp_code)s; 120 if (fault == NoFault) { 121 %(op_wb)s; 122 } 123 return fault; 124} |
128}}; 129 130// Basic decode template. 131def template BasicDecode {{ | 125}}; 126 127// Basic decode template. 128def template BasicDecode {{ |
132 return new %(class_name)s(machInst); | 129return new %(class_name)s(machInst); |
133}}; 134 135// Basic decode template, passing mnemonic in as string arg to constructor. 136def template BasicDecodeWithMnemonic {{ | 130}}; 131 132// Basic decode template, passing mnemonic in as string arg to constructor. 133def template BasicDecodeWithMnemonic {{ |
137 return new %(class_name)s("%(mnemonic)s", machInst); | 134return 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) {{ | 135}}; 136 137// The most basic instruction format... used only for a few misc. insts 138def 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) | 139 code = filterDoubles(code) 140 iop = InstObjParams(name, Name, 'SparcStaticInst', code, flags) 141 header_output = BasicDeclare.subst(iop) 142 decoder_output = BasicConstructor.subst(iop) 143 decode_block = BasicDecode.subst(iop) 144 exec_output = BasicExecute.subst(iop) 145 |
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>) { --- 7 unchanged lines hidden (view full) --- 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', | 146}}; 147 148def format FpBasic(code, *flags) {{ 149 exec_code = """ 150 Fsr |= bits(Fsr, 4, 0) << 5; 151 Fsr = insertBits(Fsr, 4, 0, 0); 152 int newrnd = M5_FE_TONEAREST; 153 switch (Fsr<31:30>) { --- 7 unchanged lines hidden (view full) --- 161 __asm__ __volatile__("" ::: "memory"); 162 fault = doFpOp(xc, traceData); 163 __asm__ __volatile__("" ::: "memory"); 164 m5_fesetround(oldrnd); 165 return fault; 166""" 167 fp_code = filterDoubles(code) 168 iop = InstObjParams(name, Name, 'SparcStaticInst', |
171 { "code" : exec_code, "fp_code" : fp_code }, flags) | 169 { "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}}; | 170 header_output = FpBasicDeclare.subst(iop) 171 decoder_output = BasicConstructor.subst(iop) 172 decode_block = BasicDecode.subst(iop) 173 exec_output = BasicExecute.subst(iop) 174 exec_output += DoFpOpExecute.subst(iop) 175}}; |