m5ops.isa (9687:22e9258c06bb) | m5ops.isa (10037:5cac77888310) |
---|---|
1// | 1// |
2// Copyright (c) 2010 ARM Limited | 2// Copyright (c) 2010, 2012-2013 ARM Limited |
3// All rights reserved 4// 5// The license below extends only to copyright in the software and shall 6// not be construed as granting a license to any other intellectual 7// property including but not limited to intellectual property relating 8// to a hardware implementation of the functionality of the software 9// licensed hereunder. You may use the software subject to the license 10// terms below provided that you ensure that this notice is replicated --- 42 unchanged lines hidden (view full) --- 53 exec_output = ''' 54 uint64_t join32to64(uint32_t r1, uint32_t r0); 55 ''' 56 57 58 armCode = ''' 59 PseudoInst::arm(xc->tcBase()); 60 ''' | 3// All rights reserved 4// 5// The license below extends only to copyright in the software and shall 6// not be construed as granting a license to any other intellectual 7// property including but not limited to intellectual property relating 8// to a hardware implementation of the functionality of the software 9// licensed hereunder. You may use the software subject to the license 10// terms below provided that you ensure that this notice is replicated --- 42 unchanged lines hidden (view full) --- 53 exec_output = ''' 54 uint64_t join32to64(uint32_t r1, uint32_t r0); 55 ''' 56 57 58 armCode = ''' 59 PseudoInst::arm(xc->tcBase()); 60 ''' |
61 |
|
61 armIop = InstObjParams("arm", "Arm", "PredOp", 62 { "code": armCode, 63 "predicate_test": predicateTest }, 64 ["IsNonSpeculative"]) 65 header_output += BasicDeclare.subst(armIop) 66 decoder_output += BasicConstructor.subst(armIop) 67 exec_output += PredOpExecute.subst(armIop) 68 69 quiesceCode = ''' 70 PseudoInst::quiesce(xc->tcBase()); 71 ''' | 62 armIop = InstObjParams("arm", "Arm", "PredOp", 63 { "code": armCode, 64 "predicate_test": predicateTest }, 65 ["IsNonSpeculative"]) 66 header_output += BasicDeclare.subst(armIop) 67 decoder_output += BasicConstructor.subst(armIop) 68 exec_output += PredOpExecute.subst(armIop) 69 70 quiesceCode = ''' 71 PseudoInst::quiesce(xc->tcBase()); 72 ''' |
73 |
|
72 quiesceIop = InstObjParams("quiesce", "Quiesce", "PredOp", 73 { "code": quiesceCode, 74 "predicate_test": predicateTest }, 75 ["IsNonSpeculative", "IsQuiesce"]) 76 header_output += BasicDeclare.subst(quiesceIop) 77 decoder_output += BasicConstructor.subst(quiesceIop) 78 exec_output += QuiescePredOpExecute.subst(quiesceIop) 79 80 quiesceNsCode = ''' 81 PseudoInst::quiesceNs(xc->tcBase(), join32to64(R1, R0)); 82 ''' 83 | 74 quiesceIop = InstObjParams("quiesce", "Quiesce", "PredOp", 75 { "code": quiesceCode, 76 "predicate_test": predicateTest }, 77 ["IsNonSpeculative", "IsQuiesce"]) 78 header_output += BasicDeclare.subst(quiesceIop) 79 decoder_output += BasicConstructor.subst(quiesceIop) 80 exec_output += QuiescePredOpExecute.subst(quiesceIop) 81 82 quiesceNsCode = ''' 83 PseudoInst::quiesceNs(xc->tcBase(), join32to64(R1, R0)); 84 ''' 85 |
86 quiesceNsCode64 = ''' 87 PseudoInst::quiesceNs(xc->tcBase(), X0); 88 ''' 89 |
|
84 quiesceNsIop = InstObjParams("quiesceNs", "QuiesceNs", "PredOp", 85 { "code": quiesceNsCode, 86 "predicate_test": predicateTest }, 87 ["IsNonSpeculative", "IsQuiesce"]) 88 header_output += BasicDeclare.subst(quiesceNsIop) 89 decoder_output += BasicConstructor.subst(quiesceNsIop) 90 exec_output += QuiescePredOpExecute.subst(quiesceNsIop) 91 | 90 quiesceNsIop = InstObjParams("quiesceNs", "QuiesceNs", "PredOp", 91 { "code": quiesceNsCode, 92 "predicate_test": predicateTest }, 93 ["IsNonSpeculative", "IsQuiesce"]) 94 header_output += BasicDeclare.subst(quiesceNsIop) 95 decoder_output += BasicConstructor.subst(quiesceNsIop) 96 exec_output += QuiescePredOpExecute.subst(quiesceNsIop) 97 |
98 quiesceNsIop = InstObjParams("quiesceNs", "QuiesceNs64", "PredOp", 99 { "code": quiesceNsCode64, 100 "predicate_test": predicateTest }, 101 ["IsNonSpeculative", "IsQuiesce"]) 102 header_output += BasicDeclare.subst(quiesceNsIop) 103 decoder_output += BasicConstructor.subst(quiesceNsIop) 104 exec_output += QuiescePredOpExecute.subst(quiesceNsIop) 105 |
|
92 quiesceCyclesCode = ''' 93 PseudoInst::quiesceCycles(xc->tcBase(), join32to64(R1, R0)); 94 ''' 95 | 106 quiesceCyclesCode = ''' 107 PseudoInst::quiesceCycles(xc->tcBase(), join32to64(R1, R0)); 108 ''' 109 |
110 quiesceCyclesCode64 = ''' 111 PseudoInst::quiesceCycles(xc->tcBase(), X0); 112 ''' 113 |
|
96 quiesceCyclesIop = InstObjParams("quiesceCycles", "QuiesceCycles", "PredOp", 97 { "code": quiesceCyclesCode, 98 "predicate_test": predicateTest }, 99 ["IsNonSpeculative", "IsQuiesce", "IsUnverifiable"]) 100 header_output += BasicDeclare.subst(quiesceCyclesIop) 101 decoder_output += BasicConstructor.subst(quiesceCyclesIop) 102 exec_output += QuiescePredOpExecute.subst(quiesceCyclesIop) 103 | 114 quiesceCyclesIop = InstObjParams("quiesceCycles", "QuiesceCycles", "PredOp", 115 { "code": quiesceCyclesCode, 116 "predicate_test": predicateTest }, 117 ["IsNonSpeculative", "IsQuiesce", "IsUnverifiable"]) 118 header_output += BasicDeclare.subst(quiesceCyclesIop) 119 decoder_output += BasicConstructor.subst(quiesceCyclesIop) 120 exec_output += QuiescePredOpExecute.subst(quiesceCyclesIop) 121 |
122 quiesceCyclesIop = InstObjParams("quiesceCycles", "QuiesceCycles64", "PredOp", 123 { "code": quiesceCyclesCode64, 124 "predicate_test": predicateTest }, 125 ["IsNonSpeculative", "IsQuiesce", "IsUnverifiable"]) 126 header_output += BasicDeclare.subst(quiesceCyclesIop) 127 decoder_output += BasicConstructor.subst(quiesceCyclesIop) 128 exec_output += QuiescePredOpExecute.subst(quiesceCyclesIop) 129 |
|
104 quiesceTimeCode = ''' 105 uint64_t qt_val = PseudoInst::quiesceTime(xc->tcBase()); 106 R0 = bits(qt_val, 31, 0); 107 R1 = bits(qt_val, 63, 32); 108 ''' 109 | 130 quiesceTimeCode = ''' 131 uint64_t qt_val = PseudoInst::quiesceTime(xc->tcBase()); 132 R0 = bits(qt_val, 31, 0); 133 R1 = bits(qt_val, 63, 32); 134 ''' 135 |
136 quiesceTimeCode64 = ''' 137 X0 = PseudoInst::quiesceTime(xc->tcBase()); 138 ''' |
|
110 quiesceTimeIop = InstObjParams("quiesceTime", "QuiesceTime", "PredOp", 111 { "code": quiesceTimeCode, 112 "predicate_test": predicateTest }, 113 ["IsNonSpeculative", "IsUnverifiable"]) 114 header_output += BasicDeclare.subst(quiesceTimeIop) 115 decoder_output += BasicConstructor.subst(quiesceTimeIop) 116 exec_output += PredOpExecute.subst(quiesceTimeIop) 117 | 139 quiesceTimeIop = InstObjParams("quiesceTime", "QuiesceTime", "PredOp", 140 { "code": quiesceTimeCode, 141 "predicate_test": predicateTest }, 142 ["IsNonSpeculative", "IsUnverifiable"]) 143 header_output += BasicDeclare.subst(quiesceTimeIop) 144 decoder_output += BasicConstructor.subst(quiesceTimeIop) 145 exec_output += PredOpExecute.subst(quiesceTimeIop) 146 |
147 quiesceTimeIop = InstObjParams("quiesceTime", "QuiesceTime64", "PredOp", 148 { "code": quiesceTimeCode64, 149 "predicate_test": predicateTest }, 150 ["IsNonSpeculative", "IsUnverifiable"]) 151 header_output += BasicDeclare.subst(quiesceTimeIop) 152 decoder_output += BasicConstructor.subst(quiesceTimeIop) 153 exec_output += PredOpExecute.subst(quiesceTimeIop) 154 |
|
118 rpnsCode = ''' 119 uint64_t rpns_val = PseudoInst::rpns(xc->tcBase()); 120 R0 = bits(rpns_val, 31, 0); 121 R1 = bits(rpns_val, 63, 32); 122 ''' 123 | 155 rpnsCode = ''' 156 uint64_t rpns_val = PseudoInst::rpns(xc->tcBase()); 157 R0 = bits(rpns_val, 31, 0); 158 R1 = bits(rpns_val, 63, 32); 159 ''' 160 |
161 rpnsCode64 = ''' 162 X0 = PseudoInst::rpns(xc->tcBase()); 163 ''' |
|
124 rpnsIop = InstObjParams("rpns", "Rpns", "PredOp", 125 { "code": rpnsCode, 126 "predicate_test": predicateTest }, 127 ["IsNonSpeculative", "IsUnverifiable"]) 128 header_output += BasicDeclare.subst(rpnsIop) 129 decoder_output += BasicConstructor.subst(rpnsIop) 130 exec_output += PredOpExecute.subst(rpnsIop) 131 | 164 rpnsIop = InstObjParams("rpns", "Rpns", "PredOp", 165 { "code": rpnsCode, 166 "predicate_test": predicateTest }, 167 ["IsNonSpeculative", "IsUnverifiable"]) 168 header_output += BasicDeclare.subst(rpnsIop) 169 decoder_output += BasicConstructor.subst(rpnsIop) 170 exec_output += PredOpExecute.subst(rpnsIop) 171 |
172 rpnsIop = InstObjParams("rpns", "Rpns64", "PredOp", 173 { "code": rpnsCode64, 174 "predicate_test": predicateTest }, 175 ["IsNonSpeculative", "IsUnverifiable"]) 176 header_output += BasicDeclare.subst(rpnsIop) 177 decoder_output += BasicConstructor.subst(rpnsIop) 178 exec_output += PredOpExecute.subst(rpnsIop) 179 |
|
132 wakeCpuCode = ''' 133 PseudoInst::wakeCPU(xc->tcBase(), join32to64(R1,R0)); 134 ''' 135 | 180 wakeCpuCode = ''' 181 PseudoInst::wakeCPU(xc->tcBase(), join32to64(R1,R0)); 182 ''' 183 |
184 wakeCpuCode64 = ''' 185 PseudoInst::wakeCPU(xc->tcBase(), X0); 186 ''' 187 |
|
136 wakeCPUIop = InstObjParams("wakeCPU", "WakeCPU", "PredOp", 137 { "code": wakeCpuCode, 138 "predicate_test": predicateTest }, 139 ["IsNonSpeculative", "IsUnverifiable"]) 140 header_output += BasicDeclare.subst(wakeCPUIop) 141 decoder_output += BasicConstructor.subst(wakeCPUIop) 142 exec_output += PredOpExecute.subst(wakeCPUIop) 143 | 188 wakeCPUIop = InstObjParams("wakeCPU", "WakeCPU", "PredOp", 189 { "code": wakeCpuCode, 190 "predicate_test": predicateTest }, 191 ["IsNonSpeculative", "IsUnverifiable"]) 192 header_output += BasicDeclare.subst(wakeCPUIop) 193 decoder_output += BasicConstructor.subst(wakeCPUIop) 194 exec_output += PredOpExecute.subst(wakeCPUIop) 195 |
196 wakeCPUIop = InstObjParams("wakeCPU", "WakeCPU64", "PredOp", 197 { "code": wakeCpuCode64, 198 "predicate_test": predicateTest }, 199 ["IsNonSpeculative", "IsUnverifiable"]) 200 header_output += BasicDeclare.subst(wakeCPUIop) 201 decoder_output += BasicConstructor.subst(wakeCPUIop) 202 exec_output += PredOpExecute.subst(wakeCPUIop) 203 |
|
144 deprecated_ivlbIop = InstObjParams("deprecated_ivlb", "Deprecated_ivlb", "PredOp", 145 { "code": '''warn_once("Obsolete M5 ivlb instruction encountered.\\n");''', 146 "predicate_test": predicateTest }) 147 header_output += BasicDeclare.subst(deprecated_ivlbIop) 148 decoder_output += BasicConstructor.subst(deprecated_ivlbIop) 149 exec_output += PredOpExecute.subst(deprecated_ivlbIop) 150 151 deprecated_ivleIop = InstObjParams("deprecated_ivle", "Deprecated_ivle", "PredOp", --- 14 unchanged lines hidden (view full) --- 166 ["No_OpClass", "IsNonSpeculative"]) 167 header_output += BasicDeclare.subst(deprecated_exitIop) 168 decoder_output += BasicConstructor.subst(deprecated_exitIop) 169 exec_output += PredOpExecute.subst(deprecated_exitIop) 170 171 m5exit_code = ''' 172 PseudoInst::m5exit(xc->tcBase(), join32to64(R1, R0)); 173 ''' | 204 deprecated_ivlbIop = InstObjParams("deprecated_ivlb", "Deprecated_ivlb", "PredOp", 205 { "code": '''warn_once("Obsolete M5 ivlb instruction encountered.\\n");''', 206 "predicate_test": predicateTest }) 207 header_output += BasicDeclare.subst(deprecated_ivlbIop) 208 decoder_output += BasicConstructor.subst(deprecated_ivlbIop) 209 exec_output += PredOpExecute.subst(deprecated_ivlbIop) 210 211 deprecated_ivleIop = InstObjParams("deprecated_ivle", "Deprecated_ivle", "PredOp", --- 14 unchanged lines hidden (view full) --- 226 ["No_OpClass", "IsNonSpeculative"]) 227 header_output += BasicDeclare.subst(deprecated_exitIop) 228 decoder_output += BasicConstructor.subst(deprecated_exitIop) 229 exec_output += PredOpExecute.subst(deprecated_exitIop) 230 231 m5exit_code = ''' 232 PseudoInst::m5exit(xc->tcBase(), join32to64(R1, R0)); 233 ''' |
234 235 m5exit_code64 = ''' 236 PseudoInst::m5exit(xc->tcBase(), X0); 237 ''' 238 |
|
174 m5exitIop = InstObjParams("m5exit", "M5exit", "PredOp", 175 { "code": m5exit_code, 176 "predicate_test": predicateTest }, 177 ["No_OpClass", "IsNonSpeculative"]) 178 header_output += BasicDeclare.subst(m5exitIop) 179 decoder_output += BasicConstructor.subst(m5exitIop) 180 exec_output += PredOpExecute.subst(m5exitIop) 181 182 m5fail_code = ''' 183 PseudoInst::m5fail(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2)); 184 ''' 185 m5failIop = InstObjParams("m5fail", "M5fail", "PredOp", 186 { "code": m5fail_code, 187 "predicate_test": predicateTest }, 188 ["No_OpClass", "IsNonSpeculative"]) 189 header_output += BasicDeclare.subst(m5failIop) 190 decoder_output += BasicConstructor.subst(m5failIop) 191 exec_output += PredOpExecute.subst(m5failIop) 192 | 239 m5exitIop = InstObjParams("m5exit", "M5exit", "PredOp", 240 { "code": m5exit_code, 241 "predicate_test": predicateTest }, 242 ["No_OpClass", "IsNonSpeculative"]) 243 header_output += BasicDeclare.subst(m5exitIop) 244 decoder_output += BasicConstructor.subst(m5exitIop) 245 exec_output += PredOpExecute.subst(m5exitIop) 246 247 m5fail_code = ''' 248 PseudoInst::m5fail(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2)); 249 ''' 250 m5failIop = InstObjParams("m5fail", "M5fail", "PredOp", 251 { "code": m5fail_code, 252 "predicate_test": predicateTest }, 253 ["No_OpClass", "IsNonSpeculative"]) 254 header_output += BasicDeclare.subst(m5failIop) 255 decoder_output += BasicConstructor.subst(m5failIop) 256 exec_output += PredOpExecute.subst(m5failIop) 257 |
258 m5exitIop = InstObjParams("m5exit", "M5exit64", "PredOp", 259 { "code": m5exit_code64, 260 "predicate_test": predicateTest }, 261 ["No_OpClass", "IsNonSpeculative"]) 262 header_output += BasicDeclare.subst(m5exitIop) 263 decoder_output += BasicConstructor.subst(m5exitIop) 264 exec_output += PredOpExecute.subst(m5exitIop) 265 |
|
193 loadsymbolCode = ''' 194 PseudoInst::loadsymbol(xc->tcBase()); 195 ''' 196 197 loadsymbolIop = InstObjParams("loadsymbol", "Loadsymbol", "PredOp", 198 { "code": loadsymbolCode, 199 "predicate_test": predicateTest }, 200 ["No_OpClass", "IsNonSpeculative"]) 201 header_output += BasicDeclare.subst(loadsymbolIop) 202 decoder_output += BasicConstructor.subst(loadsymbolIop) 203 exec_output += PredOpExecute.subst(loadsymbolIop) 204 205 initparamCode = ''' 206 uint64_t ip_val = PseudoInst::initParam(xc->tcBase()); 207 R0 = bits(ip_val, 31, 0); 208 R1 = bits(ip_val, 63, 32); 209 ''' 210 | 266 loadsymbolCode = ''' 267 PseudoInst::loadsymbol(xc->tcBase()); 268 ''' 269 270 loadsymbolIop = InstObjParams("loadsymbol", "Loadsymbol", "PredOp", 271 { "code": loadsymbolCode, 272 "predicate_test": predicateTest }, 273 ["No_OpClass", "IsNonSpeculative"]) 274 header_output += BasicDeclare.subst(loadsymbolIop) 275 decoder_output += BasicConstructor.subst(loadsymbolIop) 276 exec_output += PredOpExecute.subst(loadsymbolIop) 277 278 initparamCode = ''' 279 uint64_t ip_val = PseudoInst::initParam(xc->tcBase()); 280 R0 = bits(ip_val, 31, 0); 281 R1 = bits(ip_val, 63, 32); 282 ''' 283 |
284 initparamCode64 = ''' 285 X0 = PseudoInst::initParam(xc->tcBase()); 286 ''' 287 |
|
211 initparamIop = InstObjParams("initparam", "Initparam", "PredOp", 212 { "code": initparamCode, 213 "predicate_test": predicateTest }, 214 ["IsNonSpeculative"]) 215 header_output += BasicDeclare.subst(initparamIop) 216 decoder_output += BasicConstructor.subst(initparamIop) 217 exec_output += PredOpExecute.subst(initparamIop) 218 | 288 initparamIop = InstObjParams("initparam", "Initparam", "PredOp", 289 { "code": initparamCode, 290 "predicate_test": predicateTest }, 291 ["IsNonSpeculative"]) 292 header_output += BasicDeclare.subst(initparamIop) 293 decoder_output += BasicConstructor.subst(initparamIop) 294 exec_output += PredOpExecute.subst(initparamIop) 295 |
296 initparamIop = InstObjParams("initparam", "Initparam64", "PredOp", 297 { "code": initparamCode64, 298 "predicate_test": predicateTest }, 299 ["IsNonSpeculative"]) 300 header_output += BasicDeclare.subst(initparamIop) 301 decoder_output += BasicConstructor.subst(initparamIop) 302 exec_output += PredOpExecute.subst(initparamIop) 303 |
|
219 resetstats_code = ''' 220 PseudoInst::resetstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2)); 221 ''' 222 | 304 resetstats_code = ''' 305 PseudoInst::resetstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2)); 306 ''' 307 |
308 resetstats_code64 = ''' 309 PseudoInst::resetstats(xc->tcBase(), X0, X1); 310 ''' |
|
223 resetstatsIop = InstObjParams("resetstats", "Resetstats", "PredOp", 224 { "code": resetstats_code, 225 "predicate_test": predicateTest }, 226 ["IsNonSpeculative"]) 227 header_output += BasicDeclare.subst(resetstatsIop) 228 decoder_output += BasicConstructor.subst(resetstatsIop) 229 exec_output += PredOpExecute.subst(resetstatsIop) 230 | 311 resetstatsIop = InstObjParams("resetstats", "Resetstats", "PredOp", 312 { "code": resetstats_code, 313 "predicate_test": predicateTest }, 314 ["IsNonSpeculative"]) 315 header_output += BasicDeclare.subst(resetstatsIop) 316 decoder_output += BasicConstructor.subst(resetstatsIop) 317 exec_output += PredOpExecute.subst(resetstatsIop) 318 |
319 resetstatsIop = InstObjParams("resetstats", "Resetstats64", "PredOp", 320 { "code": resetstats_code64, 321 "predicate_test": predicateTest }, 322 ["IsNonSpeculative"]) 323 header_output += BasicDeclare.subst(resetstatsIop) 324 decoder_output += BasicConstructor.subst(resetstatsIop) 325 exec_output += PredOpExecute.subst(resetstatsIop) 326 |
|
231 dumpstats_code = ''' 232 PseudoInst::dumpstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2)); 233 ''' | 327 dumpstats_code = ''' 328 PseudoInst::dumpstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2)); 329 ''' |
330 331 dumpstats_code64 = ''' 332 PseudoInst::dumpstats(xc->tcBase(), X0, X1); 333 ''' 334 |
|
234 dumpstatsIop = InstObjParams("dumpstats", "Dumpstats", "PredOp", 235 { "code": dumpstats_code, 236 "predicate_test": predicateTest }, 237 ["IsNonSpeculative"]) 238 header_output += BasicDeclare.subst(dumpstatsIop) 239 decoder_output += BasicConstructor.subst(dumpstatsIop) 240 exec_output += PredOpExecute.subst(dumpstatsIop) 241 | 335 dumpstatsIop = InstObjParams("dumpstats", "Dumpstats", "PredOp", 336 { "code": dumpstats_code, 337 "predicate_test": predicateTest }, 338 ["IsNonSpeculative"]) 339 header_output += BasicDeclare.subst(dumpstatsIop) 340 decoder_output += BasicConstructor.subst(dumpstatsIop) 341 exec_output += PredOpExecute.subst(dumpstatsIop) 342 |
343 dumpstatsIop = InstObjParams("dumpstats", "Dumpstats64", "PredOp", 344 { "code": dumpstats_code64, 345 "predicate_test": predicateTest }, 346 ["IsNonSpeculative"]) 347 header_output += BasicDeclare.subst(dumpstatsIop) 348 decoder_output += BasicConstructor.subst(dumpstatsIop) 349 exec_output += PredOpExecute.subst(dumpstatsIop) 350 |
|
242 dumpresetstats_code = ''' 243 PseudoInst::dumpresetstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2)); 244 ''' | 351 dumpresetstats_code = ''' 352 PseudoInst::dumpresetstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2)); 353 ''' |
354 355 dumpresetstats_code64 = ''' 356 PseudoInst::dumpresetstats(xc->tcBase(), X0, X1); 357 ''' 358 |
|
245 dumpresetstatsIop = InstObjParams("dumpresetstats", "Dumpresetstats", "PredOp", 246 { "code": dumpresetstats_code, 247 "predicate_test": predicateTest }, 248 ["IsNonSpeculative"]) 249 header_output += BasicDeclare.subst(dumpresetstatsIop) 250 decoder_output += BasicConstructor.subst(dumpresetstatsIop) 251 exec_output += PredOpExecute.subst(dumpresetstatsIop) 252 | 359 dumpresetstatsIop = InstObjParams("dumpresetstats", "Dumpresetstats", "PredOp", 360 { "code": dumpresetstats_code, 361 "predicate_test": predicateTest }, 362 ["IsNonSpeculative"]) 363 header_output += BasicDeclare.subst(dumpresetstatsIop) 364 decoder_output += BasicConstructor.subst(dumpresetstatsIop) 365 exec_output += PredOpExecute.subst(dumpresetstatsIop) 366 |
367 dumpresetstatsIop = InstObjParams("dumpresetstats", "Dumpresetstats64", "PredOp", 368 { "code": dumpresetstats_code64, 369 "predicate_test": predicateTest }, 370 ["IsNonSpeculative"]) 371 header_output += BasicDeclare.subst(dumpresetstatsIop) 372 decoder_output += BasicConstructor.subst(dumpresetstatsIop) 373 exec_output += PredOpExecute.subst(dumpresetstatsIop) 374 |
|
253 m5checkpoint_code = ''' 254 PseudoInst::m5checkpoint(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2)); 255 ''' | 375 m5checkpoint_code = ''' 376 PseudoInst::m5checkpoint(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2)); 377 ''' |
378 379 m5checkpoint_code64 = ''' 380 PseudoInst::m5checkpoint(xc->tcBase(), X0, X1); 381 ''' 382 |
|
256 m5checkpointIop = InstObjParams("m5checkpoint", "M5checkpoint", "PredOp", 257 { "code": m5checkpoint_code, 258 "predicate_test": predicateTest }, 259 ["IsNonSpeculative", "IsUnverifiable"]) 260 header_output += BasicDeclare.subst(m5checkpointIop) 261 decoder_output += BasicConstructor.subst(m5checkpointIop) 262 exec_output += PredOpExecute.subst(m5checkpointIop) 263 | 383 m5checkpointIop = InstObjParams("m5checkpoint", "M5checkpoint", "PredOp", 384 { "code": m5checkpoint_code, 385 "predicate_test": predicateTest }, 386 ["IsNonSpeculative", "IsUnverifiable"]) 387 header_output += BasicDeclare.subst(m5checkpointIop) 388 decoder_output += BasicConstructor.subst(m5checkpointIop) 389 exec_output += PredOpExecute.subst(m5checkpointIop) 390 |
391 m5checkpointIop = InstObjParams("m5checkpoint", "M5checkpoint64", "PredOp", 392 { "code": m5checkpoint_code64, 393 "predicate_test": predicateTest }, 394 ["IsNonSpeculative", "IsUnverifiable"]) 395 header_output += BasicDeclare.subst(m5checkpointIop) 396 decoder_output += BasicConstructor.subst(m5checkpointIop) 397 exec_output += PredOpExecute.subst(m5checkpointIop) 398 |
|
264 m5readfileCode = ''' 265 int n = 4; 266 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false); 267 R0 = PseudoInst::readfile(xc->tcBase(), R0, join32to64(R3,R2), offset); 268 ''' | 399 m5readfileCode = ''' 400 int n = 4; 401 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false); 402 R0 = PseudoInst::readfile(xc->tcBase(), R0, join32to64(R3,R2), offset); 403 ''' |
404 405 m5readfileCode64 = ''' 406 int n = 4; 407 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false); 408 n = 6; 409 X0 = PseudoInst::readfile(xc->tcBase(), (uint32_t)X0, X1, offset); 410 ''' 411 |
|
269 m5readfileIop = InstObjParams("m5readfile", "M5readfile", "PredOp", 270 { "code": m5readfileCode, 271 "predicate_test": predicateTest }, 272 ["IsNonSpeculative", "IsUnverifiable"]) 273 header_output += BasicDeclare.subst(m5readfileIop) 274 decoder_output += BasicConstructor.subst(m5readfileIop) 275 exec_output += PredOpExecute.subst(m5readfileIop) 276 | 412 m5readfileIop = InstObjParams("m5readfile", "M5readfile", "PredOp", 413 { "code": m5readfileCode, 414 "predicate_test": predicateTest }, 415 ["IsNonSpeculative", "IsUnverifiable"]) 416 header_output += BasicDeclare.subst(m5readfileIop) 417 decoder_output += BasicConstructor.subst(m5readfileIop) 418 exec_output += PredOpExecute.subst(m5readfileIop) 419 |
420 m5readfileIop = InstObjParams("m5readfile", "M5readfile64", "PredOp", 421 { "code": m5readfileCode64, 422 "predicate_test": predicateTest }, 423 ["IsNonSpeculative", "IsUnverifiable"]) 424 header_output += BasicDeclare.subst(m5readfileIop) 425 decoder_output += BasicConstructor.subst(m5readfileIop) 426 exec_output += PredOpExecute.subst(m5readfileIop) 427 |
|
277 m5writefileCode = ''' 278 int n = 4; 279 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false); 280 n = 6; 281 Addr filenameAddr = getArgument(xc->tcBase(), n, sizeof(Addr), false); 282 R0 = PseudoInst::writefile(xc->tcBase(), R0, join32to64(R3,R2), offset, 283 filenameAddr); 284 ''' | 428 m5writefileCode = ''' 429 int n = 4; 430 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false); 431 n = 6; 432 Addr filenameAddr = getArgument(xc->tcBase(), n, sizeof(Addr), false); 433 R0 = PseudoInst::writefile(xc->tcBase(), R0, join32to64(R3,R2), offset, 434 filenameAddr); 435 ''' |
436 437 m5writefileCode64 = ''' 438 int n = 4; 439 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false); 440 n = 6; 441 Addr filenameAddr = getArgument(xc->tcBase(), n, sizeof(Addr), false); 442 X0 = PseudoInst::writefile(xc->tcBase(), (uint32_t)X0, X1, offset, 443 filenameAddr); 444 ''' 445 |
|
285 m5writefileIop = InstObjParams("m5writefile", "M5writefile", "PredOp", 286 { "code": m5writefileCode, 287 "predicate_test": predicateTest }, 288 ["IsNonSpeculative"]) 289 header_output += BasicDeclare.subst(m5writefileIop) 290 decoder_output += BasicConstructor.subst(m5writefileIop) 291 exec_output += PredOpExecute.subst(m5writefileIop) 292 | 446 m5writefileIop = InstObjParams("m5writefile", "M5writefile", "PredOp", 447 { "code": m5writefileCode, 448 "predicate_test": predicateTest }, 449 ["IsNonSpeculative"]) 450 header_output += BasicDeclare.subst(m5writefileIop) 451 decoder_output += BasicConstructor.subst(m5writefileIop) 452 exec_output += PredOpExecute.subst(m5writefileIop) 453 |
454 m5writefileIop = InstObjParams("m5writefile", "M5writefile64", "PredOp", 455 { "code": m5writefileCode64, 456 "predicate_test": predicateTest }, 457 ["IsNonSpeculative"]) 458 header_output += BasicDeclare.subst(m5writefileIop) 459 decoder_output += BasicConstructor.subst(m5writefileIop) 460 exec_output += PredOpExecute.subst(m5writefileIop) 461 |
|
293 m5breakIop = InstObjParams("m5break", "M5break", "PredOp", 294 { "code": "PseudoInst::debugbreak(xc->tcBase());", 295 "predicate_test": predicateTest }, 296 ["IsNonSpeculative"]) 297 header_output += BasicDeclare.subst(m5breakIop) 298 decoder_output += BasicConstructor.subst(m5breakIop) 299 exec_output += PredOpExecute.subst(m5breakIop) 300 301 m5switchcpuIop = InstObjParams("m5switchcpu", "M5switchcpu", "PredOp", 302 { "code": "PseudoInst::switchcpu(xc->tcBase());", 303 "predicate_test": predicateTest }, 304 ["IsNonSpeculative"]) 305 header_output += BasicDeclare.subst(m5switchcpuIop) 306 decoder_output += BasicConstructor.subst(m5switchcpuIop) 307 exec_output += PredOpExecute.subst(m5switchcpuIop) 308 309 m5addsymbolCode = ''' 310 PseudoInst::addsymbol(xc->tcBase(), join32to64(R1, R0), R2); 311 ''' | 462 m5breakIop = InstObjParams("m5break", "M5break", "PredOp", 463 { "code": "PseudoInst::debugbreak(xc->tcBase());", 464 "predicate_test": predicateTest }, 465 ["IsNonSpeculative"]) 466 header_output += BasicDeclare.subst(m5breakIop) 467 decoder_output += BasicConstructor.subst(m5breakIop) 468 exec_output += PredOpExecute.subst(m5breakIop) 469 470 m5switchcpuIop = InstObjParams("m5switchcpu", "M5switchcpu", "PredOp", 471 { "code": "PseudoInst::switchcpu(xc->tcBase());", 472 "predicate_test": predicateTest }, 473 ["IsNonSpeculative"]) 474 header_output += BasicDeclare.subst(m5switchcpuIop) 475 decoder_output += BasicConstructor.subst(m5switchcpuIop) 476 exec_output += PredOpExecute.subst(m5switchcpuIop) 477 478 m5addsymbolCode = ''' 479 PseudoInst::addsymbol(xc->tcBase(), join32to64(R1, R0), R2); 480 ''' |
481 m5addsymbolCode64 = ''' 482 PseudoInst::addsymbol(xc->tcBase(), X0, (uint32_t)X1); 483 ''' |
|
312 m5addsymbolIop = InstObjParams("m5addsymbol", "M5addsymbol", "PredOp", 313 { "code": m5addsymbolCode, 314 "predicate_test": predicateTest }, 315 ["IsNonSpeculative"]) 316 header_output += BasicDeclare.subst(m5addsymbolIop) 317 decoder_output += BasicConstructor.subst(m5addsymbolIop) 318 exec_output += PredOpExecute.subst(m5addsymbolIop) 319 | 484 m5addsymbolIop = InstObjParams("m5addsymbol", "M5addsymbol", "PredOp", 485 { "code": m5addsymbolCode, 486 "predicate_test": predicateTest }, 487 ["IsNonSpeculative"]) 488 header_output += BasicDeclare.subst(m5addsymbolIop) 489 decoder_output += BasicConstructor.subst(m5addsymbolIop) 490 exec_output += PredOpExecute.subst(m5addsymbolIop) 491 |
492 m5addsymbolIop = InstObjParams("m5addsymbol", "M5addsymbol64", "PredOp", 493 { "code": m5addsymbolCode64, 494 "predicate_test": predicateTest }, 495 ["IsNonSpeculative"]) 496 header_output += BasicDeclare.subst(m5addsymbolIop) 497 decoder_output += BasicConstructor.subst(m5addsymbolIop) 498 exec_output += PredOpExecute.subst(m5addsymbolIop) 499 |
|
320 m5panicCode = '''panic("M5 panic instruction called at pc=%#x.", 321 xc->pcState().pc());''' | 500 m5panicCode = '''panic("M5 panic instruction called at pc=%#x.", 501 xc->pcState().pc());''' |
502 |
|
322 m5panicIop = InstObjParams("m5panic", "M5panic", "PredOp", 323 { "code": m5panicCode, 324 "predicate_test": predicateTest }, 325 ["IsNonSpeculative"]) 326 header_output += BasicDeclare.subst(m5panicIop) 327 decoder_output += BasicConstructor.subst(m5panicIop) 328 exec_output += PredOpExecute.subst(m5panicIop) 329 330 m5workbeginCode = '''PseudoInst::workbegin( 331 xc->tcBase(), 332 join32to64(R1, R0), 333 join32to64(R3, R2) 334 );''' | 503 m5panicIop = InstObjParams("m5panic", "M5panic", "PredOp", 504 { "code": m5panicCode, 505 "predicate_test": predicateTest }, 506 ["IsNonSpeculative"]) 507 header_output += BasicDeclare.subst(m5panicIop) 508 decoder_output += BasicConstructor.subst(m5panicIop) 509 exec_output += PredOpExecute.subst(m5panicIop) 510 511 m5workbeginCode = '''PseudoInst::workbegin( 512 xc->tcBase(), 513 join32to64(R1, R0), 514 join32to64(R3, R2) 515 );''' |
516 517 m5workbeginCode64 = '''PseudoInst::workbegin( 518 xc->tcBase(), 519 X0, 520 X1 521 );''' 522 |
|
335 m5workbeginIop = InstObjParams("m5workbegin", "M5workbegin", "PredOp", 336 { "code": m5workbeginCode, 337 "predicate_test": predicateTest }, 338 ["IsNonSpeculative"]) 339 header_output += BasicDeclare.subst(m5workbeginIop) 340 decoder_output += BasicConstructor.subst(m5workbeginIop) 341 exec_output += PredOpExecute.subst(m5workbeginIop) 342 | 523 m5workbeginIop = InstObjParams("m5workbegin", "M5workbegin", "PredOp", 524 { "code": m5workbeginCode, 525 "predicate_test": predicateTest }, 526 ["IsNonSpeculative"]) 527 header_output += BasicDeclare.subst(m5workbeginIop) 528 decoder_output += BasicConstructor.subst(m5workbeginIop) 529 exec_output += PredOpExecute.subst(m5workbeginIop) 530 |
531 m5workbeginIop = InstObjParams("m5workbegin", "M5workbegin64", "PredOp", 532 { "code": m5workbeginCode64, 533 "predicate_test": predicateTest }, 534 ["IsNonSpeculative"]) 535 header_output += BasicDeclare.subst(m5workbeginIop) 536 decoder_output += BasicConstructor.subst(m5workbeginIop) 537 exec_output += PredOpExecute.subst(m5workbeginIop) 538 |
|
343 m5workendCode = '''PseudoInst::workend( 344 xc->tcBase(), 345 join32to64(R1, R0), 346 join32to64(R3, R2) 347 );''' | 539 m5workendCode = '''PseudoInst::workend( 540 xc->tcBase(), 541 join32to64(R1, R0), 542 join32to64(R3, R2) 543 );''' |
544 545 m5workendCode64 = '''PseudoInst::workend( 546 xc->tcBase(), 547 X0, 548 X1 549 );''' 550 |
|
348 m5workendIop = InstObjParams("m5workend", "M5workend", "PredOp", 349 { "code": m5workendCode, 350 "predicate_test": predicateTest }, 351 ["IsNonSpeculative"]) 352 header_output += BasicDeclare.subst(m5workendIop) 353 decoder_output += BasicConstructor.subst(m5workendIop) 354 exec_output += PredOpExecute.subst(m5workendIop) 355 | 551 m5workendIop = InstObjParams("m5workend", "M5workend", "PredOp", 552 { "code": m5workendCode, 553 "predicate_test": predicateTest }, 554 ["IsNonSpeculative"]) 555 header_output += BasicDeclare.subst(m5workendIop) 556 decoder_output += BasicConstructor.subst(m5workendIop) 557 exec_output += PredOpExecute.subst(m5workendIop) 558 |
559 m5workendIop = InstObjParams("m5workend", "M5workend64", "PredOp", 560 { "code": m5workendCode64, 561 "predicate_test": predicateTest }, 562 ["IsNonSpeculative"]) 563 header_output += BasicDeclare.subst(m5workendIop) 564 decoder_output += BasicConstructor.subst(m5workendIop) 565 exec_output += PredOpExecute.subst(m5workendIop) |
|
356}}; | 566}}; |