m5ops.isa revision 11289:ab19693da8c9
1// 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 11// unmodified and in its entirety in all distributions of the software, 12// modified or unmodified, in source code or in binary form. 13// 14// Redistribution and use in source and binary forms, with or without 15// modification, are permitted provided that the following conditions are 16// met: redistributions of source code must retain the above copyright 17// notice, this list of conditions and the following disclaimer; 18// redistributions in binary form must reproduce the above copyright 19// notice, this list of conditions and the following disclaimer in the 20// documentation and/or other materials provided with the distribution; 21// neither the name of the copyright holders nor the names of its 22// contributors may be used to endorse or promote products derived from 23// this software without specific prior written permission. 24// 25// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 26// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 27// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 28// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 29// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 30// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 31// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 32// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 33// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 34// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 35// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 36// 37// Authors: Gene Wu 38 39 40let {{ 41 header_output = ''' 42 uint64_t join32to64(uint32_t r1, uint32_t r0); 43 ''' 44 decoder_output = ''' 45 uint64_t join32to64(uint32_t r1, uint32_t r0) 46 { 47 uint64_t r = r1; 48 r <<= 32; 49 r |= r0; 50 return r; 51 } 52 ''' 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 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 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 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 106 quiesceCyclesCode = ''' 107 PseudoInst::quiesceCycles(xc->tcBase(), join32to64(R1, R0)); 108 ''' 109 110 quiesceCyclesCode64 = ''' 111 PseudoInst::quiesceCycles(xc->tcBase(), X0); 112 ''' 113 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 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 ''' 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 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 ''' 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 180 wakeCpuCode = ''' 181 PseudoInst::wakeCPU(xc->tcBase(), join32to64(R1,R0)); 182 ''' 183 184 wakeCpuCode64 = ''' 185 PseudoInst::wakeCPU(xc->tcBase(), X0); 186 ''' 187 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 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", 212 { "code": '''warn_once("Obsolete M5 ivle instruction encountered.\\n");''', 213 "predicate_test": predicateTest }) 214 header_output += BasicDeclare.subst(deprecated_ivleIop) 215 decoder_output += BasicConstructor.subst(deprecated_ivleIop) 216 exec_output += PredOpExecute.subst(deprecated_ivleIop) 217 218 deprecated_exit_code = ''' 219 warn_once("Obsolete M5 exit instruction encountered.\\n"); 220 PseudoInst::m5exit(xc->tcBase(), 0); 221 ''' 222 223 deprecated_exitIop = InstObjParams("deprecated_exit", "Deprecated_exit", "PredOp", 224 { "code": deprecated_exit_code, 225 "predicate_test": predicateTest }, 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 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 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(), join32to64(R1, R0), 280 join32to64(R3, R2)); 281 R0 = bits(ip_val, 31, 0); 282 R1 = bits(ip_val, 63, 32); 283 ''' 284 285 initparamCode64 = ''' 286 X0 = PseudoInst::initParam(xc->tcBase(), X0, X1); 287 ''' 288 289 initparamIop = InstObjParams("initparam", "Initparam", "PredOp", 290 { "code": initparamCode, 291 "predicate_test": predicateTest }, 292 ["IsNonSpeculative"]) 293 header_output += BasicDeclare.subst(initparamIop) 294 decoder_output += BasicConstructor.subst(initparamIop) 295 exec_output += PredOpExecute.subst(initparamIop) 296 297 initparamIop = InstObjParams("initparam", "Initparam64", "PredOp", 298 { "code": initparamCode64, 299 "predicate_test": predicateTest }, 300 ["IsNonSpeculative"]) 301 header_output += BasicDeclare.subst(initparamIop) 302 decoder_output += BasicConstructor.subst(initparamIop) 303 exec_output += PredOpExecute.subst(initparamIop) 304 305 resetstats_code = ''' 306 PseudoInst::resetstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2)); 307 ''' 308 309 resetstats_code64 = ''' 310 PseudoInst::resetstats(xc->tcBase(), X0, X1); 311 ''' 312 resetstatsIop = InstObjParams("resetstats", "Resetstats", "PredOp", 313 { "code": resetstats_code, 314 "predicate_test": predicateTest }, 315 ["IsNonSpeculative"]) 316 header_output += BasicDeclare.subst(resetstatsIop) 317 decoder_output += BasicConstructor.subst(resetstatsIop) 318 exec_output += PredOpExecute.subst(resetstatsIop) 319 320 resetstatsIop = InstObjParams("resetstats", "Resetstats64", "PredOp", 321 { "code": resetstats_code64, 322 "predicate_test": predicateTest }, 323 ["IsNonSpeculative"]) 324 header_output += BasicDeclare.subst(resetstatsIop) 325 decoder_output += BasicConstructor.subst(resetstatsIop) 326 exec_output += PredOpExecute.subst(resetstatsIop) 327 328 dumpstats_code = ''' 329 PseudoInst::dumpstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2)); 330 ''' 331 332 dumpstats_code64 = ''' 333 PseudoInst::dumpstats(xc->tcBase(), X0, X1); 334 ''' 335 336 dumpstatsIop = InstObjParams("dumpstats", "Dumpstats", "PredOp", 337 { "code": dumpstats_code, 338 "predicate_test": predicateTest }, 339 ["IsNonSpeculative"]) 340 header_output += BasicDeclare.subst(dumpstatsIop) 341 decoder_output += BasicConstructor.subst(dumpstatsIop) 342 exec_output += PredOpExecute.subst(dumpstatsIop) 343 344 dumpstatsIop = InstObjParams("dumpstats", "Dumpstats64", "PredOp", 345 { "code": dumpstats_code64, 346 "predicate_test": predicateTest }, 347 ["IsNonSpeculative"]) 348 header_output += BasicDeclare.subst(dumpstatsIop) 349 decoder_output += BasicConstructor.subst(dumpstatsIop) 350 exec_output += PredOpExecute.subst(dumpstatsIop) 351 352 dumpresetstats_code = ''' 353 PseudoInst::dumpresetstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2)); 354 ''' 355 356 dumpresetstats_code64 = ''' 357 PseudoInst::dumpresetstats(xc->tcBase(), X0, X1); 358 ''' 359 360 dumpresetstatsIop = InstObjParams("dumpresetstats", "Dumpresetstats", "PredOp", 361 { "code": dumpresetstats_code, 362 "predicate_test": predicateTest }, 363 ["IsNonSpeculative"]) 364 header_output += BasicDeclare.subst(dumpresetstatsIop) 365 decoder_output += BasicConstructor.subst(dumpresetstatsIop) 366 exec_output += PredOpExecute.subst(dumpresetstatsIop) 367 368 dumpresetstatsIop = InstObjParams("dumpresetstats", "Dumpresetstats64", "PredOp", 369 { "code": dumpresetstats_code64, 370 "predicate_test": predicateTest }, 371 ["IsNonSpeculative"]) 372 header_output += BasicDeclare.subst(dumpresetstatsIop) 373 decoder_output += BasicConstructor.subst(dumpresetstatsIop) 374 exec_output += PredOpExecute.subst(dumpresetstatsIop) 375 376 m5checkpoint_code = ''' 377 PseudoInst::m5checkpoint(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2)); 378 ''' 379 380 m5checkpoint_code64 = ''' 381 PseudoInst::m5checkpoint(xc->tcBase(), X0, X1); 382 ''' 383 384 m5checkpointIop = InstObjParams("m5checkpoint", "M5checkpoint", "PredOp", 385 { "code": m5checkpoint_code, 386 "predicate_test": predicateTest }, 387 ["IsNonSpeculative", "IsUnverifiable"]) 388 header_output += BasicDeclare.subst(m5checkpointIop) 389 decoder_output += BasicConstructor.subst(m5checkpointIop) 390 exec_output += PredOpExecute.subst(m5checkpointIop) 391 392 m5checkpointIop = InstObjParams("m5checkpoint", "M5checkpoint64", "PredOp", 393 { "code": m5checkpoint_code64, 394 "predicate_test": predicateTest }, 395 ["IsNonSpeculative", "IsUnverifiable"]) 396 header_output += BasicDeclare.subst(m5checkpointIop) 397 decoder_output += BasicConstructor.subst(m5checkpointIop) 398 exec_output += PredOpExecute.subst(m5checkpointIop) 399 400 m5readfileCode = ''' 401 int n = 4; 402 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false); 403 R0 = PseudoInst::readfile(xc->tcBase(), R0, join32to64(R3,R2), offset); 404 ''' 405 406 m5readfileCode64 = ''' 407 int n = 2; 408 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false); 409 n = 3; 410 X0 = PseudoInst::readfile(xc->tcBase(), X0, X1, offset); 411 ''' 412 413 m5readfileIop = InstObjParams("m5readfile", "M5readfile", "PredOp", 414 { "code": m5readfileCode, 415 "predicate_test": predicateTest }, 416 ["IsNonSpeculative", "IsUnverifiable"]) 417 header_output += BasicDeclare.subst(m5readfileIop) 418 decoder_output += BasicConstructor.subst(m5readfileIop) 419 exec_output += PredOpExecute.subst(m5readfileIop) 420 421 m5readfileIop = InstObjParams("m5readfile", "M5readfile64", "PredOp", 422 { "code": m5readfileCode64, 423 "predicate_test": predicateTest }, 424 ["IsNonSpeculative", "IsUnverifiable"]) 425 header_output += BasicDeclare.subst(m5readfileIop) 426 decoder_output += BasicConstructor.subst(m5readfileIop) 427 exec_output += PredOpExecute.subst(m5readfileIop) 428 429 m5writefileCode = ''' 430 int n = 4; 431 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false); 432 n = 6; 433 Addr filenameAddr = getArgument(xc->tcBase(), n, sizeof(Addr), false); 434 R0 = PseudoInst::writefile(xc->tcBase(), R0, join32to64(R3,R2), offset, 435 filenameAddr); 436 ''' 437 438 m5writefileCode64 = ''' 439 int n = 2; 440 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false); 441 n = 3; 442 Addr filenameAddr = getArgument(xc->tcBase(), n, sizeof(Addr), false); 443 X0 = PseudoInst::writefile(xc->tcBase(), X0, X1, offset, 444 filenameAddr); 445 ''' 446 447 m5writefileIop = InstObjParams("m5writefile", "M5writefile", "PredOp", 448 { "code": m5writefileCode, 449 "predicate_test": predicateTest }, 450 ["IsNonSpeculative"]) 451 header_output += BasicDeclare.subst(m5writefileIop) 452 decoder_output += BasicConstructor.subst(m5writefileIop) 453 exec_output += PredOpExecute.subst(m5writefileIop) 454 455 m5writefileIop = InstObjParams("m5writefile", "M5writefile64", "PredOp", 456 { "code": m5writefileCode64, 457 "predicate_test": predicateTest }, 458 ["IsNonSpeculative"]) 459 header_output += BasicDeclare.subst(m5writefileIop) 460 decoder_output += BasicConstructor.subst(m5writefileIop) 461 exec_output += PredOpExecute.subst(m5writefileIop) 462 463 m5breakIop = InstObjParams("m5break", "M5break", "PredOp", 464 { "code": "PseudoInst::debugbreak(xc->tcBase());", 465 "predicate_test": predicateTest }, 466 ["IsNonSpeculative"]) 467 header_output += BasicDeclare.subst(m5breakIop) 468 decoder_output += BasicConstructor.subst(m5breakIop) 469 exec_output += PredOpExecute.subst(m5breakIop) 470 471 m5switchcpuIop = InstObjParams("m5switchcpu", "M5switchcpu", "PredOp", 472 { "code": "PseudoInst::switchcpu(xc->tcBase());", 473 "predicate_test": predicateTest }, 474 ["IsNonSpeculative"]) 475 header_output += BasicDeclare.subst(m5switchcpuIop) 476 decoder_output += BasicConstructor.subst(m5switchcpuIop) 477 exec_output += PredOpExecute.subst(m5switchcpuIop) 478 479 m5addsymbolCode = ''' 480 PseudoInst::addsymbol(xc->tcBase(), join32to64(R1, R0), R2); 481 ''' 482 m5addsymbolCode64 = ''' 483 PseudoInst::addsymbol(xc->tcBase(), X0, X1); 484 ''' 485 m5addsymbolIop = InstObjParams("m5addsymbol", "M5addsymbol", "PredOp", 486 { "code": m5addsymbolCode, 487 "predicate_test": predicateTest }, 488 ["IsNonSpeculative"]) 489 header_output += BasicDeclare.subst(m5addsymbolIop) 490 decoder_output += BasicConstructor.subst(m5addsymbolIop) 491 exec_output += PredOpExecute.subst(m5addsymbolIop) 492 493 m5addsymbolIop = InstObjParams("m5addsymbol", "M5addsymbol64", "PredOp", 494 { "code": m5addsymbolCode64, 495 "predicate_test": predicateTest }, 496 ["IsNonSpeculative"]) 497 header_output += BasicDeclare.subst(m5addsymbolIop) 498 decoder_output += BasicConstructor.subst(m5addsymbolIop) 499 exec_output += PredOpExecute.subst(m5addsymbolIop) 500 501 m5panicCode = '''panic("M5 panic instruction called at pc=%#x.", 502 xc->pcState().pc());''' 503 504 m5panicIop = InstObjParams("m5panic", "M5panic", "PredOp", 505 { "code": m5panicCode, 506 "predicate_test": predicateTest }, 507 ["IsNonSpeculative"]) 508 header_output += BasicDeclare.subst(m5panicIop) 509 decoder_output += BasicConstructor.subst(m5panicIop) 510 exec_output += PredOpExecute.subst(m5panicIop) 511 512 m5workbeginCode = '''PseudoInst::workbegin( 513 xc->tcBase(), 514 join32to64(R1, R0), 515 join32to64(R3, R2) 516 );''' 517 518 m5workbeginCode64 = '''PseudoInst::workbegin( 519 xc->tcBase(), 520 X0, 521 X1 522 );''' 523 524 m5workbeginIop = InstObjParams("m5workbegin", "M5workbegin", "PredOp", 525 { "code": m5workbeginCode, 526 "predicate_test": predicateTest }, 527 ["IsNonSpeculative"]) 528 header_output += BasicDeclare.subst(m5workbeginIop) 529 decoder_output += BasicConstructor.subst(m5workbeginIop) 530 exec_output += PredOpExecute.subst(m5workbeginIop) 531 532 m5workbeginIop = InstObjParams("m5workbegin", "M5workbegin64", "PredOp", 533 { "code": m5workbeginCode64, 534 "predicate_test": predicateTest }, 535 ["IsNonSpeculative"]) 536 header_output += BasicDeclare.subst(m5workbeginIop) 537 decoder_output += BasicConstructor.subst(m5workbeginIop) 538 exec_output += PredOpExecute.subst(m5workbeginIop) 539 540 m5workendCode = '''PseudoInst::workend( 541 xc->tcBase(), 542 join32to64(R1, R0), 543 join32to64(R3, R2) 544 );''' 545 546 m5workendCode64 = '''PseudoInst::workend( 547 xc->tcBase(), 548 X0, 549 X1 550 );''' 551 552 m5workendIop = InstObjParams("m5workend", "M5workend", "PredOp", 553 { "code": m5workendCode, 554 "predicate_test": predicateTest }, 555 ["IsNonSpeculative"]) 556 header_output += BasicDeclare.subst(m5workendIop) 557 decoder_output += BasicConstructor.subst(m5workendIop) 558 exec_output += PredOpExecute.subst(m5workendIop) 559 560 m5workendIop = InstObjParams("m5workend", "M5workend64", "PredOp", 561 { "code": m5workendCode64, 562 "predicate_test": predicateTest }, 563 ["IsNonSpeculative"]) 564 header_output += BasicDeclare.subst(m5workendIop) 565 decoder_output += BasicConstructor.subst(m5workendIop) 566 exec_output += PredOpExecute.subst(m5workendIop) 567}}; 568