65 smcCode = ''' 66 HCR hcr = Hcr; 67 CPSR cpsr = Cpsr; 68 SCR scr = Scr; 69 70 if ((cpsr.mode != MODE_USER) && FullSystem) { 71 if (ArmSystem::haveVirtualization(xc->tcBase()) && 72 !inSecureState(scr, cpsr) && (cpsr.mode != MODE_HYP) && hcr.tsc) { 73 fault = std::make_shared<HypervisorTrap>(machInst, 0, 74 EC_SMC_TO_HYP); 75 } else { 76 if (scr.scd) { 77 fault = disabledFault(); 78 } else { 79 fault = std::make_shared<SecureMonitorCall>(machInst); 80 } 81 } 82 } else { 83 fault = disabledFault(); 84 } 85 ''' 86 87 smcIop = InstObjParams("smc", "Smc", "PredOp", 88 { "code": smcCode, 89 "predicate_test": predicateTest }, 90 ["IsNonSpeculative", "IsSerializeAfter"]) 91 header_output += BasicDeclare.subst(smcIop) 92 decoder_output += BasicConstructor.subst(smcIop) 93 exec_output += PredOpExecute.subst(smcIop) 94 95 hvcCode = ''' 96 CPSR cpsr = Cpsr; 97 SCR scr = Scr; 98 99 // Filter out the various cases where this instruction isn't defined 100 if (!FullSystem || !ArmSystem::haveVirtualization(xc->tcBase()) || 101 (cpsr.mode == MODE_USER) || 102 (ArmSystem::haveSecurity(xc->tcBase()) && (!scr.ns || !scr.hce))) { 103 fault = disabledFault(); 104 } else { 105 fault = std::make_shared<HypervisorCall>(machInst, imm); 106 } 107 ''' 108 109 hvcIop = InstObjParams("hvc", "Hvc", "ImmOp", 110 { "code": hvcCode, 111 "predicate_test": predicateTest }, 112 ["IsNonSpeculative", "IsSerializeAfter"]) 113 header_output += ImmOpDeclare.subst(hvcIop) 114 decoder_output += ImmOpConstructor.subst(hvcIop) 115 exec_output += PredOpExecute.subst(hvcIop) 116 117 eretCode = ''' 118 SCTLR sctlr = Sctlr; 119 CPSR old_cpsr = Cpsr; 120 old_cpsr.nz = CondCodesNZ; 121 old_cpsr.c = CondCodesC; 122 old_cpsr.v = CondCodesV; 123 old_cpsr.ge = CondCodesGE; 124 125 CPSR new_cpsr = cpsrWriteByInstr(old_cpsr, Spsr, Scr, Nsacr, 0xF, 126 true, sctlr.nmfi, xc->tcBase()); 127 Cpsr = ~CondCodesMask & new_cpsr; 128 CondCodesNZ = new_cpsr.nz; 129 CondCodesC = new_cpsr.c; 130 CondCodesV = new_cpsr.v; 131 CondCodesGE = new_cpsr.ge; 132 133 NextThumb = (new_cpsr).t; 134 NextJazelle = (new_cpsr).j; 135 NextItState = (((new_cpsr).it2 << 2) & 0xFC) 136 | ((new_cpsr).it1 & 0x3); 137 138 NPC = (old_cpsr.mode == MODE_HYP) ? ElrHyp : LR; 139 ''' 140 141 eretIop = InstObjParams("eret", "Eret", "PredOp", 142 { "code": eretCode, 143 "predicate_test": predicateTest }, 144 ["IsNonSpeculative", "IsSerializeAfter", 145 "IsSquashAfter"]) 146 header_output += BasicDeclare.subst(eretIop) 147 decoder_output += BasicConstructor.subst(eretIop) 148 exec_output += PredOpExecute.subst(eretIop) 149 150 crcCode = ''' 151 constexpr uint8_t size_bytes = %(sz)d; 152 constexpr uint32_t poly = %(polynom)s; 153 154 uint32_t data = htole(Op2); 155 auto data_buffer = reinterpret_cast<uint8_t*>(&data); 156 157 Dest = crc32<poly>( 158 data_buffer, /* Message Register */ 159 Op1, /* Initial Value of the CRC */ 160 size_bytes /* Size of the original Message */ 161 ); 162 ''' 163 164 def crc32Emit(mnem, implCode, castagnoli, size): 165 global header_output, decoder_output, exec_output 166 167 if castagnoli: 168 # crc32c instructions 169 poly = "0x1EDC6F41" 170 else: 171 # crc32 instructions 172 poly = "0x04C11DB7" 173 174 data = {'sz' : size, 'polynom': poly} 175 176 instCode = implCode % data 177 178 crcIop = InstObjParams(mnem, mnem.capitalize(), "RegRegRegOp", 179 { "code": instCode, 180 "predicate_test": predicateTest }, []) 181 header_output += RegRegRegOpDeclare.subst(crcIop) 182 decoder_output += RegRegRegOpConstructor.subst(crcIop) 183 exec_output += PredOpExecute.subst(crcIop) 184 185 crc32Emit("crc32b", crcCode, False, 1); 186 crc32Emit("crc32h", crcCode, False, 2); 187 crc32Emit("crc32w", crcCode, False, 4); 188 crc32Emit("crc32cb", crcCode, True, 1); 189 crc32Emit("crc32ch", crcCode, True, 2); 190 crc32Emit("crc32cw", crcCode, True, 4); 191 192}}; 193 194let {{ 195 196 header_output = decoder_output = exec_output = "" 197 198 mrsCpsrCode = ''' 199 CPSR cpsr = Cpsr; 200 cpsr.nz = CondCodesNZ; 201 cpsr.c = CondCodesC; 202 cpsr.v = CondCodesV; 203 cpsr.ge = CondCodesGE; 204 Dest = cpsr & 0xF8FF03DF 205 ''' 206 207 mrsCpsrIop = InstObjParams("mrs", "MrsCpsr", "MrsOp", 208 { "code": mrsCpsrCode, 209 "predicate_test": condPredicateTest }, 210 ["IsSerializeBefore"]) 211 header_output += MrsDeclare.subst(mrsCpsrIop) 212 decoder_output += MrsConstructor.subst(mrsCpsrIop) 213 exec_output += PredOpExecute.subst(mrsCpsrIop) 214 215 mrsSpsrCode = "Dest = Spsr" 216 mrsSpsrIop = InstObjParams("mrs", "MrsSpsr", "MrsOp", 217 { "code": mrsSpsrCode, 218 "predicate_test": predicateTest }, 219 ["IsSerializeBefore"]) 220 header_output += MrsDeclare.subst(mrsSpsrIop) 221 decoder_output += MrsConstructor.subst(mrsSpsrIop) 222 exec_output += PredOpExecute.subst(mrsSpsrIop) 223 224 mrsBankedRegCode = ''' 225 bool isIntReg; 226 int regIdx; 227 228 if (decodeMrsMsrBankedReg(byteMask, r, isIntReg, regIdx, Cpsr, Scr, Nsacr)) { 229 if (isIntReg) { 230 Dest = DecodedBankedIntReg; 231 } else { 232 Dest = xc->readMiscReg(regIdx); 233 } 234 } else { 235 return std::make_shared<UndefinedInstruction>(machInst, false, 236 mnemonic); 237 } 238 ''' 239 mrsBankedRegIop = InstObjParams("mrs", "MrsBankedReg", "MrsOp", 240 { "code": mrsBankedRegCode, 241 "predicate_test": predicateTest }, 242 ["IsSerializeBefore"]) 243 header_output += MrsBankedRegDeclare.subst(mrsBankedRegIop) 244 decoder_output += MrsBankedRegConstructor.subst(mrsBankedRegIop) 245 exec_output += PredOpExecute.subst(mrsBankedRegIop) 246 247 msrBankedRegCode = ''' 248 bool isIntReg; 249 int regIdx; 250 251 if (decodeMrsMsrBankedReg(byteMask, r, isIntReg, regIdx, Cpsr, Scr, Nsacr)) { 252 if (isIntReg) { 253 // This is a bit nasty, you would have thought that 254 // DecodedBankedIntReg wouldn't be written to unless the 255 // conditions on the IF statements above are met, however if 256 // you look at the generated C code you'll find that they are. 257 // However this is safe as DecodedBankedIntReg (which is used 258 // in operands.isa to get the index of DecodedBankedIntReg) 259 // will return INTREG_DUMMY if its not a valid integer 260 // register, so redirecting the write to somewhere we don't 261 // care about. 262 DecodedBankedIntReg = Op1; 263 } else { 264 xc->setMiscReg(regIdx, Op1); 265 } 266 } else { 267 return std::make_shared<UndefinedInstruction>(machInst, false, 268 mnemonic); 269 } 270 ''' 271 msrBankedRegIop = InstObjParams("msr", "MsrBankedReg", "MsrRegOp", 272 { "code": msrBankedRegCode, 273 "predicate_test": predicateTest }, 274 ["IsSerializeAfter", "IsNonSpeculative"]) 275 header_output += MsrBankedRegDeclare.subst(msrBankedRegIop) 276 decoder_output += MsrBankedRegConstructor.subst(msrBankedRegIop) 277 exec_output += PredOpExecute.subst(msrBankedRegIop) 278 279 msrCpsrRegCode = ''' 280 SCTLR sctlr = Sctlr; 281 CPSR old_cpsr = Cpsr; 282 old_cpsr.nz = CondCodesNZ; 283 old_cpsr.c = CondCodesC; 284 old_cpsr.v = CondCodesV; 285 old_cpsr.ge = CondCodesGE; 286 287 CPSR new_cpsr = 288 cpsrWriteByInstr(old_cpsr, Op1, Scr, Nsacr, byteMask, false, 289 sctlr.nmfi, xc->tcBase()); 290 Cpsr = ~CondCodesMask & new_cpsr; 291 CondCodesNZ = new_cpsr.nz; 292 CondCodesC = new_cpsr.c; 293 CondCodesV = new_cpsr.v; 294 CondCodesGE = new_cpsr.ge; 295 ''' 296 msrCpsrRegIop = InstObjParams("msr", "MsrCpsrReg", "MsrRegOp", 297 { "code": msrCpsrRegCode, 298 "predicate_test": condPredicateTest }, 299 ["IsSerializeAfter","IsNonSpeculative"]) 300 header_output += MsrRegDeclare.subst(msrCpsrRegIop) 301 decoder_output += MsrRegConstructor.subst(msrCpsrRegIop) 302 exec_output += PredOpExecute.subst(msrCpsrRegIop) 303 304 msrSpsrRegCode = "Spsr = spsrWriteByInstr(Spsr, Op1, byteMask, false);" 305 msrSpsrRegIop = InstObjParams("msr", "MsrSpsrReg", "MsrRegOp", 306 { "code": msrSpsrRegCode, 307 "predicate_test": predicateTest }, 308 ["IsSerializeAfter","IsNonSpeculative"]) 309 header_output += MsrRegDeclare.subst(msrSpsrRegIop) 310 decoder_output += MsrRegConstructor.subst(msrSpsrRegIop) 311 exec_output += PredOpExecute.subst(msrSpsrRegIop) 312 313 msrCpsrImmCode = ''' 314 SCTLR sctlr = Sctlr; 315 CPSR old_cpsr = Cpsr; 316 old_cpsr.nz = CondCodesNZ; 317 old_cpsr.c = CondCodesC; 318 old_cpsr.v = CondCodesV; 319 old_cpsr.ge = CondCodesGE; 320 CPSR new_cpsr = 321 cpsrWriteByInstr(old_cpsr, imm, Scr, Nsacr, byteMask, false, 322 sctlr.nmfi, xc->tcBase()); 323 Cpsr = ~CondCodesMask & new_cpsr; 324 CondCodesNZ = new_cpsr.nz; 325 CondCodesC = new_cpsr.c; 326 CondCodesV = new_cpsr.v; 327 CondCodesGE = new_cpsr.ge; 328 ''' 329 msrCpsrImmIop = InstObjParams("msr", "MsrCpsrImm", "MsrImmOp", 330 { "code": msrCpsrImmCode, 331 "predicate_test": condPredicateTest }, 332 ["IsSerializeAfter","IsNonSpeculative"]) 333 header_output += MsrImmDeclare.subst(msrCpsrImmIop) 334 decoder_output += MsrImmConstructor.subst(msrCpsrImmIop) 335 exec_output += PredOpExecute.subst(msrCpsrImmIop) 336 337 msrSpsrImmCode = "Spsr = spsrWriteByInstr(Spsr, imm, byteMask, false);" 338 msrSpsrImmIop = InstObjParams("msr", "MsrSpsrImm", "MsrImmOp", 339 { "code": msrSpsrImmCode, 340 "predicate_test": predicateTest }, 341 ["IsSerializeAfter","IsNonSpeculative"]) 342 header_output += MsrImmDeclare.subst(msrSpsrImmIop) 343 decoder_output += MsrImmConstructor.subst(msrSpsrImmIop) 344 exec_output += PredOpExecute.subst(msrSpsrImmIop) 345 346 revCode = ''' 347 uint32_t val = Op1; 348 Dest = swap_byte(val); 349 ''' 350 revIop = InstObjParams("rev", "Rev", "RegRegOp", 351 { "code": revCode, 352 "predicate_test": predicateTest }, []) 353 header_output += RegRegOpDeclare.subst(revIop) 354 decoder_output += RegRegOpConstructor.subst(revIop) 355 exec_output += PredOpExecute.subst(revIop) 356 357 rev16Code = ''' 358 uint32_t val = Op1; 359 Dest = (bits(val, 15, 8) << 0) | 360 (bits(val, 7, 0) << 8) | 361 (bits(val, 31, 24) << 16) | 362 (bits(val, 23, 16) << 24); 363 ''' 364 rev16Iop = InstObjParams("rev16", "Rev16", "RegRegOp", 365 { "code": rev16Code, 366 "predicate_test": predicateTest }, []) 367 header_output += RegRegOpDeclare.subst(rev16Iop) 368 decoder_output += RegRegOpConstructor.subst(rev16Iop) 369 exec_output += PredOpExecute.subst(rev16Iop) 370 371 revshCode = ''' 372 uint16_t val = Op1; 373 Dest = sext<16>(swap_byte(val)); 374 ''' 375 revshIop = InstObjParams("revsh", "Revsh", "RegRegOp", 376 { "code": revshCode, 377 "predicate_test": predicateTest }, []) 378 header_output += RegRegOpDeclare.subst(revshIop) 379 decoder_output += RegRegOpConstructor.subst(revshIop) 380 exec_output += PredOpExecute.subst(revshIop) 381 382 rbitCode = ''' 383 Dest = reverseBits(Op1); 384 ''' 385 rbitIop = InstObjParams("rbit", "Rbit", "RegRegOp", 386 { "code": rbitCode, 387 "predicate_test": predicateTest }, []) 388 header_output += RegRegOpDeclare.subst(rbitIop) 389 decoder_output += RegRegOpConstructor.subst(rbitIop) 390 exec_output += PredOpExecute.subst(rbitIop) 391 392 clzCode = ''' 393 Dest = (Op1 == 0) ? 32 : (31 - findMsbSet(Op1)); 394 ''' 395 clzIop = InstObjParams("clz", "Clz", "RegRegOp", 396 { "code": clzCode, 397 "predicate_test": predicateTest }, []) 398 header_output += RegRegOpDeclare.subst(clzIop) 399 decoder_output += RegRegOpConstructor.subst(clzIop) 400 exec_output += PredOpExecute.subst(clzIop) 401 402 ssatCode = ''' 403 int32_t operand = shift_rm_imm(Op1, shiftAmt, shiftType, 0); 404 int32_t res; 405 if (satInt(res, operand, imm)) 406 CpsrQ = 1 << 27; 407 Dest = res; 408 ''' 409 ssatIop = InstObjParams("ssat", "Ssat", "RegImmRegShiftOp", 410 { "code": ssatCode, 411 "predicate_test": pickPredicate(ssatCode) }, []) 412 header_output += RegImmRegShiftOpDeclare.subst(ssatIop) 413 decoder_output += RegImmRegShiftOpConstructor.subst(ssatIop) 414 exec_output += PredOpExecute.subst(ssatIop) 415 416 usatCode = ''' 417 int32_t operand = shift_rm_imm(Op1, shiftAmt, shiftType, 0); 418 int32_t res; 419 if (uSatInt(res, operand, imm)) 420 CpsrQ = 1 << 27; 421 Dest = res; 422 ''' 423 usatIop = InstObjParams("usat", "Usat", "RegImmRegShiftOp", 424 { "code": usatCode, 425 "predicate_test": pickPredicate(usatCode) }, []) 426 header_output += RegImmRegShiftOpDeclare.subst(usatIop) 427 decoder_output += RegImmRegShiftOpConstructor.subst(usatIop) 428 exec_output += PredOpExecute.subst(usatIop) 429 430 ssat16Code = ''' 431 int32_t res; 432 uint32_t resTemp = 0; 433 int32_t argLow = sext<16>(bits(Op1, 15, 0)); 434 int32_t argHigh = sext<16>(bits(Op1, 31, 16)); 435 if (satInt(res, argLow, imm)) 436 CpsrQ = 1 << 27; 437 replaceBits(resTemp, 15, 0, res); 438 if (satInt(res, argHigh, imm)) 439 CpsrQ = 1 << 27; 440 replaceBits(resTemp, 31, 16, res); 441 Dest = resTemp; 442 ''' 443 ssat16Iop = InstObjParams("ssat16", "Ssat16", "RegImmRegOp", 444 { "code": ssat16Code, 445 "predicate_test": pickPredicate(ssat16Code) }, []) 446 header_output += RegImmRegOpDeclare.subst(ssat16Iop) 447 decoder_output += RegImmRegOpConstructor.subst(ssat16Iop) 448 exec_output += PredOpExecute.subst(ssat16Iop) 449 450 usat16Code = ''' 451 int32_t res; 452 uint32_t resTemp = 0; 453 int32_t argLow = sext<16>(bits(Op1, 15, 0)); 454 int32_t argHigh = sext<16>(bits(Op1, 31, 16)); 455 if (uSatInt(res, argLow, imm)) 456 CpsrQ = 1 << 27; 457 replaceBits(resTemp, 15, 0, res); 458 if (uSatInt(res, argHigh, imm)) 459 CpsrQ = 1 << 27; 460 replaceBits(resTemp, 31, 16, res); 461 Dest = resTemp; 462 ''' 463 usat16Iop = InstObjParams("usat16", "Usat16", "RegImmRegOp", 464 { "code": usat16Code, 465 "predicate_test": pickPredicate(usat16Code) }, []) 466 header_output += RegImmRegOpDeclare.subst(usat16Iop) 467 decoder_output += RegImmRegOpConstructor.subst(usat16Iop) 468 exec_output += PredOpExecute.subst(usat16Iop) 469 470 sxtbIop = InstObjParams("sxtb", "Sxtb", "RegImmRegOp", 471 { "code": 472 "Dest = sext<8>((uint8_t)(Op1_ud >> imm));", 473 "predicate_test": predicateTest }, []) 474 header_output += RegImmRegOpDeclare.subst(sxtbIop) 475 decoder_output += RegImmRegOpConstructor.subst(sxtbIop) 476 exec_output += PredOpExecute.subst(sxtbIop) 477 478 sxtabIop = InstObjParams("sxtab", "Sxtab", "RegRegRegImmOp", 479 { "code": 480 ''' 481 Dest = sext<8>((uint8_t)(Op2_ud >> imm)) + 482 Op1; 483 ''', 484 "predicate_test": predicateTest }, []) 485 header_output += RegRegRegImmOpDeclare.subst(sxtabIop) 486 decoder_output += RegRegRegImmOpConstructor.subst(sxtabIop) 487 exec_output += PredOpExecute.subst(sxtabIop) 488 489 sxtb16Code = ''' 490 uint32_t resTemp = 0; 491 replaceBits(resTemp, 15, 0, sext<8>(bits(Op1, imm + 7, imm))); 492 replaceBits(resTemp, 31, 16, 493 sext<8>(bits(Op1, (imm + 23) % 32, (imm + 16) % 32))); 494 Dest = resTemp; 495 ''' 496 sxtb16Iop = InstObjParams("sxtb16", "Sxtb16", "RegImmRegOp", 497 { "code": sxtb16Code, 498 "predicate_test": predicateTest }, []) 499 header_output += RegImmRegOpDeclare.subst(sxtb16Iop) 500 decoder_output += RegImmRegOpConstructor.subst(sxtb16Iop) 501 exec_output += PredOpExecute.subst(sxtb16Iop) 502 503 sxtab16Code = ''' 504 uint32_t resTemp = 0; 505 replaceBits(resTemp, 15, 0, sext<8>(bits(Op2, imm + 7, imm)) + 506 bits(Op1, 15, 0)); 507 replaceBits(resTemp, 31, 16, 508 sext<8>(bits(Op2, (imm + 23) % 32, (imm + 16) % 32)) + 509 bits(Op1, 31, 16)); 510 Dest = resTemp; 511 ''' 512 sxtab16Iop = InstObjParams("sxtab16", "Sxtab16", "RegRegRegImmOp", 513 { "code": sxtab16Code, 514 "predicate_test": predicateTest }, []) 515 header_output += RegRegRegImmOpDeclare.subst(sxtab16Iop) 516 decoder_output += RegRegRegImmOpConstructor.subst(sxtab16Iop) 517 exec_output += PredOpExecute.subst(sxtab16Iop) 518 519 sxthCode = ''' 520 uint64_t rotated = (uint32_t)Op1; 521 rotated = (rotated | (rotated << 32)) >> imm; 522 Dest = sext<16>((uint16_t)rotated); 523 ''' 524 sxthIop = InstObjParams("sxth", "Sxth", "RegImmRegOp", 525 { "code": sxthCode, 526 "predicate_test": predicateTest }, []) 527 header_output += RegImmRegOpDeclare.subst(sxthIop) 528 decoder_output += RegImmRegOpConstructor.subst(sxthIop) 529 exec_output += PredOpExecute.subst(sxthIop) 530 531 sxtahCode = ''' 532 uint64_t rotated = (uint32_t)Op2; 533 rotated = (rotated | (rotated << 32)) >> imm; 534 Dest = sext<16>((uint16_t)rotated) + Op1; 535 ''' 536 sxtahIop = InstObjParams("sxtah", "Sxtah", "RegRegRegImmOp", 537 { "code": sxtahCode, 538 "predicate_test": predicateTest }, []) 539 header_output += RegRegRegImmOpDeclare.subst(sxtahIop) 540 decoder_output += RegRegRegImmOpConstructor.subst(sxtahIop) 541 exec_output += PredOpExecute.subst(sxtahIop) 542 543 uxtbIop = InstObjParams("uxtb", "Uxtb", "RegImmRegOp", 544 { "code": "Dest = (uint8_t)(Op1_ud >> imm);", 545 "predicate_test": predicateTest }, []) 546 header_output += RegImmRegOpDeclare.subst(uxtbIop) 547 decoder_output += RegImmRegOpConstructor.subst(uxtbIop) 548 exec_output += PredOpExecute.subst(uxtbIop) 549 550 uxtabIop = InstObjParams("uxtab", "Uxtab", "RegRegRegImmOp", 551 { "code": 552 "Dest = (uint8_t)(Op2_ud >> imm) + Op1;", 553 "predicate_test": predicateTest }, []) 554 header_output += RegRegRegImmOpDeclare.subst(uxtabIop) 555 decoder_output += RegRegRegImmOpConstructor.subst(uxtabIop) 556 exec_output += PredOpExecute.subst(uxtabIop) 557 558 uxtb16Code = ''' 559 uint32_t resTemp = 0; 560 replaceBits(resTemp, 15, 0, (uint8_t)(bits(Op1, imm + 7, imm))); 561 replaceBits(resTemp, 31, 16, 562 (uint8_t)(bits(Op1, (imm + 23) % 32, (imm + 16) % 32))); 563 Dest = resTemp; 564 ''' 565 uxtb16Iop = InstObjParams("uxtb16", "Uxtb16", "RegImmRegOp", 566 { "code": uxtb16Code, 567 "predicate_test": predicateTest }, []) 568 header_output += RegImmRegOpDeclare.subst(uxtb16Iop) 569 decoder_output += RegImmRegOpConstructor.subst(uxtb16Iop) 570 exec_output += PredOpExecute.subst(uxtb16Iop) 571 572 uxtab16Code = ''' 573 uint32_t resTemp = 0; 574 replaceBits(resTemp, 15, 0, (uint8_t)(bits(Op2, imm + 7, imm)) + 575 bits(Op1, 15, 0)); 576 replaceBits(resTemp, 31, 16, 577 (uint8_t)(bits(Op2, (imm + 23) % 32, (imm + 16) % 32)) + 578 bits(Op1, 31, 16)); 579 Dest = resTemp; 580 ''' 581 uxtab16Iop = InstObjParams("uxtab16", "Uxtab16", "RegRegRegImmOp", 582 { "code": uxtab16Code, 583 "predicate_test": predicateTest }, []) 584 header_output += RegRegRegImmOpDeclare.subst(uxtab16Iop) 585 decoder_output += RegRegRegImmOpConstructor.subst(uxtab16Iop) 586 exec_output += PredOpExecute.subst(uxtab16Iop) 587 588 uxthCode = ''' 589 uint64_t rotated = (uint32_t)Op1; 590 rotated = (rotated | (rotated << 32)) >> imm; 591 Dest = (uint16_t)rotated; 592 ''' 593 uxthIop = InstObjParams("uxth", "Uxth", "RegImmRegOp", 594 { "code": uxthCode, 595 "predicate_test": predicateTest }, []) 596 header_output += RegImmRegOpDeclare.subst(uxthIop) 597 decoder_output += RegImmRegOpConstructor.subst(uxthIop) 598 exec_output += PredOpExecute.subst(uxthIop) 599 600 uxtahCode = ''' 601 uint64_t rotated = (uint32_t)Op2; 602 rotated = (rotated | (rotated << 32)) >> imm; 603 Dest = (uint16_t)rotated + Op1; 604 ''' 605 uxtahIop = InstObjParams("uxtah", "Uxtah", "RegRegRegImmOp", 606 { "code": uxtahCode, 607 "predicate_test": predicateTest }, []) 608 header_output += RegRegRegImmOpDeclare.subst(uxtahIop) 609 decoder_output += RegRegRegImmOpConstructor.subst(uxtahIop) 610 exec_output += PredOpExecute.subst(uxtahIop) 611 612 selCode = ''' 613 uint32_t resTemp = 0; 614 for (unsigned i = 0; i < 4; i++) { 615 int low = i * 8; 616 int high = low + 7; 617 replaceBits(resTemp, high, low, 618 bits(CondCodesGE, i) ? 619 bits(Op1, high, low) : bits(Op2, high, low)); 620 } 621 Dest = resTemp; 622 ''' 623 selIop = InstObjParams("sel", "Sel", "RegRegRegOp", 624 { "code": selCode, 625 "predicate_test": predicateTest }, []) 626 header_output += RegRegRegOpDeclare.subst(selIop) 627 decoder_output += RegRegRegOpConstructor.subst(selIop) 628 exec_output += PredOpExecute.subst(selIop) 629 630 usad8Code = ''' 631 uint32_t resTemp = 0; 632 for (unsigned i = 0; i < 4; i++) { 633 int low = i * 8; 634 int high = low + 7; 635 int32_t diff = bits(Op1, high, low) - 636 bits(Op2, high, low); 637 resTemp += ((diff < 0) ? -diff : diff); 638 } 639 Dest = resTemp; 640 ''' 641 usad8Iop = InstObjParams("usad8", "Usad8", "RegRegRegOp", 642 { "code": usad8Code, 643 "predicate_test": predicateTest }, []) 644 header_output += RegRegRegOpDeclare.subst(usad8Iop) 645 decoder_output += RegRegRegOpConstructor.subst(usad8Iop) 646 exec_output += PredOpExecute.subst(usad8Iop) 647 648 usada8Code = ''' 649 uint32_t resTemp = 0; 650 for (unsigned i = 0; i < 4; i++) { 651 int low = i * 8; 652 int high = low + 7; 653 int32_t diff = bits(Op1, high, low) - 654 bits(Op2, high, low); 655 resTemp += ((diff < 0) ? -diff : diff); 656 } 657 Dest = Op3 + resTemp; 658 ''' 659 usada8Iop = InstObjParams("usada8", "Usada8", "RegRegRegRegOp", 660 { "code": usada8Code, 661 "predicate_test": predicateTest }, []) 662 header_output += RegRegRegRegOpDeclare.subst(usada8Iop) 663 decoder_output += RegRegRegRegOpConstructor.subst(usada8Iop) 664 exec_output += PredOpExecute.subst(usada8Iop) 665 666 bkptCode = 'return std::make_shared<PrefetchAbort>(PC, ArmFault::DebugEvent);\n' 667 bkptIop = InstObjParams("bkpt", "BkptInst", "PredOp", bkptCode) 668 header_output += BasicDeclare.subst(bkptIop) 669 decoder_output += BasicConstructor.subst(bkptIop) 670 exec_output += BasicExecute.subst(bkptIop) 671 672 nopIop = InstObjParams("nop", "NopInst", "ArmStaticInst", "", ['IsNop']) 673 header_output += BasicDeclare.subst(nopIop) 674 decoder_output += BasicConstructor64.subst(nopIop) 675 exec_output += BasicExecute.subst(nopIop) 676 677 yieldIop = InstObjParams("yield", "YieldInst", "PredOp", \ 678 { "code" : "", "predicate_test" : predicateTest }) 679 header_output += BasicDeclare.subst(yieldIop) 680 decoder_output += BasicConstructor.subst(yieldIop) 681 exec_output += PredOpExecute.subst(yieldIop) 682 683 wfeCode = ''' 684 CPSR cpsr = Cpsr; 685 SCR scr = Scr64; 686 687 // WFE Sleeps if SevMailbox==0 and no unmasked interrupts are pending, 688 ThreadContext *tc = xc->tcBase(); 689 if (SevMailbox == 1) { 690 SevMailbox = 0; 691 PseudoInst::quiesceSkip(tc); 692 } else if (tc->getCpuPtr()->getInterruptController( 693 tc->threadId())->checkInterrupts(tc)) { 694 PseudoInst::quiesceSkip(tc); 695 } else { 696 fault = trapWFx(tc, cpsr, scr, true); 697 if (fault == NoFault) { 698 PseudoInst::quiesce(tc); 699 } else { 700 PseudoInst::quiesceSkip(tc); 701 } 702 } 703 ''' 704 wfePredFixUpCode = ''' 705 // WFE is predicated false, reset SevMailbox to reduce spurious sleeps 706 // and SEV interrupts 707 SevMailbox = 1; 708 ''' 709 wfeIop = InstObjParams("wfe", "WfeInst", "PredOp", \ 710 { "code" : wfeCode, 711 "pred_fixup" : wfePredFixUpCode, 712 "predicate_test" : predicateTest }, 713 ["IsNonSpeculative", "IsQuiesce", 714 "IsSerializeAfter", "IsUnverifiable"]) 715 header_output += BasicDeclare.subst(wfeIop) 716 decoder_output += BasicConstructor.subst(wfeIop) 717 exec_output += QuiescePredOpExecuteWithFixup.subst(wfeIop) 718 719 wfiCode = ''' 720 HCR hcr = Hcr; 721 CPSR cpsr = Cpsr; 722 SCR scr = Scr64; 723 724 // WFI doesn't sleep if interrupts are pending (masked or not) 725 ThreadContext *tc = xc->tcBase(); 726 if (tc->getCpuPtr()->getInterruptController( 727 tc->threadId())->checkWfiWake(hcr, cpsr, scr)) { 728 PseudoInst::quiesceSkip(tc); 729 } else { 730 fault = trapWFx(tc, cpsr, scr, false); 731 if (fault == NoFault) { 732 PseudoInst::quiesce(tc); 733 } else { 734 PseudoInst::quiesceSkip(tc); 735 } 736 } 737 tc->getCpuPtr()->clearInterrupt(tc->threadId(), INT_ABT, 0); 738 ''' 739 wfiIop = InstObjParams("wfi", "WfiInst", "PredOp", \ 740 { "code" : wfiCode, "predicate_test" : predicateTest }, 741 ["IsNonSpeculative", "IsQuiesce", 742 "IsSerializeAfter", "IsUnverifiable"]) 743 header_output += BasicDeclare.subst(wfiIop) 744 decoder_output += BasicConstructor.subst(wfiIop) 745 exec_output += QuiescePredOpExecute.subst(wfiIop) 746 747 sevCode = ''' 748 SevMailbox = 1; 749 System *sys = xc->tcBase()->getSystemPtr(); 750 for (int x = 0; x < sys->numContexts(); x++) { 751 ThreadContext *oc = sys->getThreadContext(x); 752 if (oc == xc->tcBase()) 753 continue; 754 // Wake CPU with interrupt if they were sleeping 755 if (oc->readMiscReg(MISCREG_SEV_MAILBOX) == 0) { 756 // Post Interrupt and wake cpu if needed 757 oc->getCpuPtr()->postInterrupt(oc->threadId(), INT_SEV, 0); 758 } 759 } 760 ''' 761 sevIop = InstObjParams("sev", "SevInst", "PredOp", \ 762 { "code" : sevCode, "predicate_test" : predicateTest }, 763 ["IsNonSpeculative", "IsSquashAfter", "IsUnverifiable"]) 764 header_output += BasicDeclare.subst(sevIop) 765 decoder_output += BasicConstructor.subst(sevIop) 766 exec_output += PredOpExecute.subst(sevIop) 767 768 sevlCode = ''' 769 SevMailbox = 1; 770 ''' 771 sevlIop = InstObjParams("sevl", "SevlInst", "PredOp", \ 772 { "code" : sevlCode, "predicate_test" : predicateTest }, 773 ["IsNonSpeculative", "IsSquashAfter", "IsUnverifiable"]) 774 header_output += BasicDeclare.subst(sevlIop) 775 decoder_output += BasicConstructor.subst(sevlIop) 776 exec_output += BasicExecute.subst(sevlIop) 777 778 itIop = InstObjParams("it", "ItInst", "PredOp", \ 779 { "code" : ";", 780 "predicate_test" : predicateTest }, []) 781 header_output += BasicDeclare.subst(itIop) 782 decoder_output += BasicConstructor.subst(itIop) 783 exec_output += PredOpExecute.subst(itIop) 784 unknownCode = ''' 785 return std::make_shared<UndefinedInstruction>(machInst, true); 786 ''' 787 unknownIop = InstObjParams("unknown", "Unknown", "UnknownOp", \ 788 { "code": unknownCode, 789 "predicate_test": predicateTest }) 790 header_output += BasicDeclare.subst(unknownIop) 791 decoder_output += BasicConstructor.subst(unknownIop) 792 exec_output += PredOpExecute.subst(unknownIop) 793 794 ubfxCode = ''' 795 Dest = bits(Op1, imm2, imm1); 796 ''' 797 ubfxIop = InstObjParams("ubfx", "Ubfx", "RegRegImmImmOp", 798 { "code": ubfxCode, 799 "predicate_test": predicateTest }, []) 800 header_output += RegRegImmImmOpDeclare.subst(ubfxIop) 801 decoder_output += RegRegImmImmOpConstructor.subst(ubfxIop) 802 exec_output += PredOpExecute.subst(ubfxIop) 803 804 sbfxCode = ''' 805 int32_t resTemp = bits(Op1, imm2, imm1); 806 Dest = resTemp | -(resTemp & (1 << (imm2 - imm1))); 807 ''' 808 sbfxIop = InstObjParams("sbfx", "Sbfx", "RegRegImmImmOp", 809 { "code": sbfxCode, 810 "predicate_test": predicateTest }, []) 811 header_output += RegRegImmImmOpDeclare.subst(sbfxIop) 812 decoder_output += RegRegImmImmOpConstructor.subst(sbfxIop) 813 exec_output += PredOpExecute.subst(sbfxIop) 814 815 bfcCode = ''' 816 Dest = Op1 & ~(mask(imm2 - imm1 + 1) << imm1); 817 ''' 818 bfcIop = InstObjParams("bfc", "Bfc", "RegRegImmImmOp", 819 { "code": bfcCode, 820 "predicate_test": predicateTest }, []) 821 header_output += RegRegImmImmOpDeclare.subst(bfcIop) 822 decoder_output += RegRegImmImmOpConstructor.subst(bfcIop) 823 exec_output += PredOpExecute.subst(bfcIop) 824 825 bfiCode = ''' 826 uint32_t bitMask = (mask(imm2 - imm1 + 1) << imm1); 827 Dest = ((Op1 << imm1) & bitMask) | (Dest & ~bitMask); 828 ''' 829 bfiIop = InstObjParams("bfi", "Bfi", "RegRegImmImmOp", 830 { "code": bfiCode, 831 "predicate_test": predicateTest }, []) 832 header_output += RegRegImmImmOpDeclare.subst(bfiIop) 833 decoder_output += RegRegImmImmOpConstructor.subst(bfiIop) 834 exec_output += PredOpExecute.subst(bfiIop) 835 836 mrc14code = ''' 837 MiscRegIndex miscReg = (MiscRegIndex) xc->tcBase()->flattenRegId( 838 RegId(MiscRegClass, op1)).index(); 839 bool can_read, undefined; 840 std::tie(can_read, undefined) = canReadCoprocReg(miscReg, Scr, Cpsr); 841 if (!can_read || undefined) { 842 return std::make_shared<UndefinedInstruction>(machInst, false, 843 mnemonic); 844 } 845 if (mcrMrc14TrapToHyp((const MiscRegIndex) op1, Hcr, Cpsr, Scr, Hdcr, 846 Hstr, Hcptr, imm)) { 847 return std::make_shared<HypervisorTrap>(machInst, imm, 848 EC_TRAPPED_CP14_MCR_MRC); 849 } 850 Dest = MiscOp1; 851 ''' 852 853 mrc14Iop = InstObjParams("mrc", "Mrc14", "RegRegImmOp", 854 { "code": mrc14code, 855 "predicate_test": predicateTest }, []) 856 header_output += RegRegImmOpDeclare.subst(mrc14Iop) 857 decoder_output += RegRegImmOpConstructor.subst(mrc14Iop) 858 exec_output += PredOpExecute.subst(mrc14Iop) 859 860 861 mcr14code = ''' 862 MiscRegIndex miscReg = (MiscRegIndex) xc->tcBase()->flattenRegId( 863 RegId(MiscRegClass, dest)).index(); 864 bool can_write, undefined; 865 std::tie(can_write, undefined) = canWriteCoprocReg(miscReg, Scr, Cpsr); 866 if (undefined || !can_write) { 867 return std::make_shared<UndefinedInstruction>(machInst, false, 868 mnemonic); 869 } 870 if (mcrMrc14TrapToHyp(miscReg, Hcr, Cpsr, Scr, Hdcr, 871 Hstr, Hcptr, imm)) { 872 return std::make_shared<HypervisorTrap>(machInst, imm, 873 EC_TRAPPED_CP14_MCR_MRC); 874 } 875 MiscDest = Op1; 876 ''' 877 mcr14Iop = InstObjParams("mcr", "Mcr14", "RegRegImmOp", 878 { "code": mcr14code, 879 "predicate_test": predicateTest }, 880 ["IsSerializeAfter","IsNonSpeculative"]) 881 header_output += RegRegImmOpDeclare.subst(mcr14Iop) 882 decoder_output += RegRegImmOpConstructor.subst(mcr14Iop) 883 exec_output += PredOpExecute.subst(mcr14Iop) 884 885 mrc15code = ''' 886 int preFlatOp1 = snsBankedIndex(op1, xc->tcBase()); 887 MiscRegIndex miscReg = (MiscRegIndex) 888 xc->tcBase()->flattenRegId(RegId(MiscRegClass, 889 preFlatOp1)).index(); 890 bool hypTrap = mcrMrc15TrapToHyp(miscReg, Hcr, Cpsr, Scr, Hdcr, Hstr, 891 Hcptr, imm); 892 bool can_read, undefined; 893 std::tie(can_read, undefined) = canReadCoprocReg(miscReg, Scr, Cpsr); 894 // if we're in non secure PL1 mode then we can trap regargless of whether 895 // the register is accessable, in other modes we trap if only if the register 896 // IS accessable. 897 if (undefined || (!can_read && !(hypTrap && !inUserMode(Cpsr) && 898 !inSecureState(Scr, Cpsr)))) { 899 return std::make_shared<UndefinedInstruction>(machInst, false, 900 mnemonic); 901 } 902 if (hypTrap) { 903 return std::make_shared<HypervisorTrap>(machInst, imm, 904 EC_TRAPPED_CP15_MCR_MRC); 905 } 906 Dest = MiscNsBankedOp1; 907 ''' 908 909 mrc15Iop = InstObjParams("mrc", "Mrc15", "RegMiscRegImmOp", 910 { "code": mrc15code, 911 "predicate_test": predicateTest }, []) 912 header_output += RegMiscRegImmOpDeclare.subst(mrc15Iop) 913 decoder_output += RegMiscRegImmOpConstructor.subst(mrc15Iop) 914 exec_output += PredOpExecute.subst(mrc15Iop) 915 916 917 mcr15code = ''' 918 int preFlatDest = snsBankedIndex(dest, xc->tcBase()); 919 MiscRegIndex miscReg = (MiscRegIndex) 920 xc->tcBase()->flattenRegId(RegId(MiscRegClass, 921 preFlatDest)).index(); 922 bool hypTrap = mcrMrc15TrapToHyp(miscReg, Hcr, Cpsr, Scr, Hdcr, Hstr, 923 Hcptr, imm); 924 bool can_write, undefined; 925 std::tie(can_write, undefined) = canWriteCoprocReg(miscReg, Scr, Cpsr); 926 927 // if we're in non secure PL1 mode then we can trap regargless of whether 928 // the register is accessable, in other modes we trap if only if the register 929 // IS accessable. 930 if (undefined || (!can_write && !(hypTrap && !inUserMode(Cpsr) && 931 !inSecureState(Scr, Cpsr)))) { 932 return std::make_shared<UndefinedInstruction>(machInst, false, 933 mnemonic); 934 } 935 if (hypTrap) { 936 return std::make_shared<HypervisorTrap>(machInst, imm, 937 EC_TRAPPED_CP15_MCR_MRC); 938 } 939 MiscNsBankedDest = Op1; 940 ''' 941 mcr15Iop = InstObjParams("mcr", "Mcr15", "MiscRegRegImmOp", 942 { "code": mcr15code, 943 "predicate_test": predicateTest }, 944 ["IsSerializeAfter","IsNonSpeculative"]) 945 header_output += MiscRegRegImmOpDeclare.subst(mcr15Iop) 946 decoder_output += MiscRegRegImmOpConstructor.subst(mcr15Iop) 947 exec_output += PredOpExecute.subst(mcr15Iop) 948 949 950 mrrc15code = ''' 951 int preFlatOp1 = snsBankedIndex(op1, xc->tcBase()); 952 MiscRegIndex miscReg = (MiscRegIndex) 953 xc->tcBase()->flattenRegId(RegId(MiscRegClass, 954 preFlatOp1)).index(); 955 bool hypTrap = mcrrMrrc15TrapToHyp(miscReg, Cpsr, Scr, Hstr, Hcr, imm); 956 bool can_read, undefined; 957 std::tie(can_read, undefined) = canReadCoprocReg(miscReg, Scr, Cpsr); 958 // if we're in non secure PL1 mode then we can trap regargless of whether 959 // the register is accessable, in other modes we trap if only if the register 960 // IS accessable. 961 if (undefined || (!can_read && !(hypTrap && !inUserMode(Cpsr) && 962 !inSecureState(Scr, Cpsr)))) { 963 return std::make_shared<UndefinedInstruction>(machInst, false, 964 mnemonic); 965 } 966 if (hypTrap) { 967 return std::make_shared<HypervisorTrap>(machInst, imm, 968 EC_TRAPPED_CP15_MCRR_MRRC); 969 } 970 Dest = bits(MiscNsBankedOp164, 63, 32); 971 Dest2 = bits(MiscNsBankedOp164, 31, 0); 972 ''' 973 mrrc15Iop = InstObjParams("mrrc", "Mrrc15", "MrrcOp", 974 { "code": mrrc15code, 975 "predicate_test": predicateTest }, []) 976 header_output += MrrcOpDeclare.subst(mrrc15Iop) 977 decoder_output += MrrcOpConstructor.subst(mrrc15Iop) 978 exec_output += PredOpExecute.subst(mrrc15Iop) 979 980 981 mcrr15code = ''' 982 int preFlatDest = snsBankedIndex(dest, xc->tcBase()); 983 MiscRegIndex miscReg = (MiscRegIndex) 984 xc->tcBase()->flattenRegId(RegId(MiscRegClass, 985 preFlatDest)).index(); 986 bool hypTrap = mcrrMrrc15TrapToHyp(miscReg, Cpsr, Scr, Hstr, Hcr, imm); 987 bool can_write, undefined; 988 std::tie(can_write, undefined) = canWriteCoprocReg(miscReg, Scr, Cpsr); 989 990 // if we're in non secure PL1 mode then we can trap regargless of whether 991 // the register is accessable, in other modes we trap if only if the register 992 // IS accessable. 993 if (undefined || (!can_write && !(hypTrap && !inUserMode(Cpsr) && 994 !inSecureState(Scr, Cpsr)))) { 995 return std::make_shared<UndefinedInstruction>(machInst, false, 996 mnemonic); 997 } 998 if (hypTrap) { 999 return std::make_shared<HypervisorTrap>(machInst, imm, 1000 EC_TRAPPED_CP15_MCRR_MRRC); 1001 } 1002 MiscNsBankedDest64 = ((uint64_t) Op1 << 32) | Op2; 1003 ''' 1004 mcrr15Iop = InstObjParams("mcrr", "Mcrr15", "McrrOp", 1005 { "code": mcrr15code, 1006 "predicate_test": predicateTest }, []) 1007 header_output += McrrOpDeclare.subst(mcrr15Iop) 1008 decoder_output += McrrOpConstructor.subst(mcrr15Iop) 1009 exec_output += PredOpExecute.subst(mcrr15Iop) 1010 1011 1012 enterxCode = ''' 1013 NextThumb = true; 1014 NextJazelle = true; 1015 ''' 1016 enterxIop = InstObjParams("enterx", "Enterx", "PredOp", 1017 { "code": enterxCode, 1018 "predicate_test": predicateTest }, []) 1019 header_output += BasicDeclare.subst(enterxIop) 1020 decoder_output += BasicConstructor.subst(enterxIop) 1021 exec_output += PredOpExecute.subst(enterxIop) 1022 1023 leavexCode = ''' 1024 NextThumb = true; 1025 NextJazelle = false; 1026 ''' 1027 leavexIop = InstObjParams("leavex", "Leavex", "PredOp", 1028 { "code": leavexCode, 1029 "predicate_test": predicateTest }, []) 1030 header_output += BasicDeclare.subst(leavexIop) 1031 decoder_output += BasicConstructor.subst(leavexIop) 1032 exec_output += PredOpExecute.subst(leavexIop) 1033 1034 setendCode = ''' 1035 CPSR cpsr = Cpsr; 1036 cpsr.e = imm; 1037 Cpsr = cpsr; 1038 fault = checkSETENDEnabled(xc->tcBase(), cpsr); 1039 ''' 1040 setendIop = InstObjParams("setend", "Setend", "ImmOp", 1041 { "code": setendCode, 1042 "predicate_test": predicateTest }, 1043 ["IsSerializeAfter","IsNonSpeculative"]) 1044 header_output += ImmOpDeclare.subst(setendIop) 1045 decoder_output += ImmOpConstructor.subst(setendIop) 1046 exec_output += PredOpExecute.subst(setendIop) 1047 1048 clrexCode = ''' 1049 LLSCLock = 0; 1050 ''' 1051 clrexIop = InstObjParams("clrex", "Clrex","PredOp", 1052 { "code": clrexCode, 1053 "predicate_test": predicateTest },[]) 1054 header_output += BasicDeclare.subst(clrexIop) 1055 decoder_output += BasicConstructor.subst(clrexIop) 1056 exec_output += PredOpExecute.subst(clrexIop) 1057 1058 McrDcCheckCode = ''' 1059 int preFlatDest = snsBankedIndex(dest, xc->tcBase()); 1060 MiscRegIndex miscReg = (MiscRegIndex) xc->tcBase()->flattenRegId( 1061 RegId(MiscRegClass, preFlatDest)).index(); 1062 bool hypTrap = mcrMrc15TrapToHyp(miscReg, Hcr, Cpsr, Scr, Hdcr, Hstr, 1063 Hcptr, imm); 1064 bool can_write, undefined; 1065 std::tie(can_write, undefined) = canWriteCoprocReg(miscReg, Scr, Cpsr); 1066 1067 // if we're in non secure PL1 mode then we can trap regardless 1068 // of whether the register is accessible, in other modes we 1069 // trap if only if the register IS accessible. 1070 if (undefined || (!can_write & !(hypTrap & !inUserMode(Cpsr) & 1071 !inSecureState(Scr, Cpsr)))) { 1072 return std::make_shared<UndefinedInstruction>(machInst, false, 1073 mnemonic); 1074 } 1075 if (hypTrap) { 1076 return std::make_shared<HypervisorTrap>(machInst, imm, 1077 EC_TRAPPED_CP15_MCR_MRC); 1078 } 1079 ''' 1080 1081 McrDcimvacCode = ''' 1082 const Request::Flags memAccessFlags(ArmISA::TLB::MustBeOne | 1083 Request::INVALIDATE | 1084 Request::DST_POC); 1085 EA = Op1; 1086 ''' 1087 McrDcimvacIop = InstObjParams("mcr", "McrDcimvac", 1088 "MiscRegRegImmOp", 1089 {"memacc_code": McrDcCheckCode, 1090 "postacc_code": "", 1091 "ea_code": McrDcimvacCode, 1092 "predicate_test": predicateTest}, 1093 ['IsMemRef', 'IsStore']) 1094 header_output += MiscRegRegImmMemOpDeclare.subst(McrDcimvacIop) 1095 decoder_output += MiscRegRegImmOpConstructor.subst(McrDcimvacIop) 1096 exec_output += Mcr15Execute.subst(McrDcimvacIop) + \ 1097 Mcr15InitiateAcc.subst(McrDcimvacIop) + \ 1098 Mcr15CompleteAcc.subst(McrDcimvacIop) 1099 1100 McrDccmvacCode = ''' 1101 const Request::Flags memAccessFlags(ArmISA::TLB::MustBeOne | 1102 Request::CLEAN | 1103 Request::DST_POC); 1104 EA = Op1; 1105 ''' 1106 McrDccmvacIop = InstObjParams("mcr", "McrDccmvac", 1107 "MiscRegRegImmOp", 1108 {"memacc_code": McrDcCheckCode, 1109 "postacc_code": "", 1110 "ea_code": McrDccmvacCode, 1111 "predicate_test": predicateTest}, 1112 ['IsMemRef', 'IsStore']) 1113 header_output += MiscRegRegImmMemOpDeclare.subst(McrDccmvacIop) 1114 decoder_output += MiscRegRegImmOpConstructor.subst(McrDccmvacIop) 1115 exec_output += Mcr15Execute.subst(McrDccmvacIop) + \ 1116 Mcr15InitiateAcc.subst(McrDccmvacIop) + \ 1117 Mcr15CompleteAcc.subst(McrDccmvacIop) 1118 1119 McrDccmvauCode = ''' 1120 const Request::Flags memAccessFlags(ArmISA::TLB::MustBeOne | 1121 Request::CLEAN | 1122 Request::DST_POU); 1123 EA = Op1; 1124 ''' 1125 McrDccmvauIop = InstObjParams("mcr", "McrDccmvau", 1126 "MiscRegRegImmOp", 1127 {"memacc_code": McrDcCheckCode, 1128 "postacc_code": "", 1129 "ea_code": McrDccmvauCode, 1130 "predicate_test": predicateTest}, 1131 ['IsMemRef', 'IsStore']) 1132 header_output += MiscRegRegImmMemOpDeclare.subst(McrDccmvauIop) 1133 decoder_output += MiscRegRegImmOpConstructor.subst(McrDccmvauIop) 1134 exec_output += Mcr15Execute.subst(McrDccmvauIop) + \ 1135 Mcr15InitiateAcc.subst(McrDccmvauIop) + \ 1136 Mcr15CompleteAcc.subst(McrDccmvauIop) 1137 1138 McrDccimvacCode = ''' 1139 const Request::Flags memAccessFlags(ArmISA::TLB::MustBeOne | 1140 Request::CLEAN | 1141 Request::INVALIDATE | 1142 Request::DST_POC); 1143 EA = Op1; 1144 ''' 1145 McrDccimvacIop = InstObjParams("mcr", "McrDccimvac", 1146 "MiscRegRegImmOp", 1147 {"memacc_code": McrDcCheckCode, 1148 "postacc_code": "", 1149 "ea_code": McrDccimvacCode, 1150 "predicate_test": predicateTest}, 1151 ['IsMemRef', 'IsStore']) 1152 header_output += MiscRegRegImmMemOpDeclare.subst(McrDccimvacIop) 1153 decoder_output += MiscRegRegImmOpConstructor.subst(McrDccimvacIop) 1154 exec_output += Mcr15Execute.subst(McrDccimvacIop) + \ 1155 Mcr15InitiateAcc.subst(McrDccimvacIop) + \ 1156 Mcr15CompleteAcc.subst(McrDccimvacIop) 1157 1158 isbCode = ''' 1159 // If the barrier is due to a CP15 access check for hyp traps 1160 if ((imm != 0) && mcrMrc15TrapToHyp(MISCREG_CP15ISB, Hcr, Cpsr, Scr, 1161 Hdcr, Hstr, Hcptr, imm)) { 1162 return std::make_shared<HypervisorTrap>(machInst, imm, 1163 EC_TRAPPED_CP15_MCR_MRC); 1164 } 1165 ''' 1166 isbIop = InstObjParams("isb", "Isb", "ImmOp", 1167 {"code": isbCode, 1168 "predicate_test": predicateTest}, 1169 ['IsSquashAfter']) 1170 header_output += ImmOpDeclare.subst(isbIop) 1171 decoder_output += ImmOpConstructor.subst(isbIop) 1172 exec_output += PredOpExecute.subst(isbIop) 1173 1174 dsbCode = ''' 1175 // If the barrier is due to a CP15 access check for hyp traps 1176 if ((imm != 0) && mcrMrc15TrapToHyp(MISCREG_CP15DSB, Hcr, Cpsr, Scr, 1177 Hdcr, Hstr, Hcptr, imm)) { 1178 return std::make_shared<HypervisorTrap>(machInst, imm, 1179 EC_TRAPPED_CP15_MCR_MRC); 1180 } 1181 ''' 1182 dsbIop = InstObjParams("dsb", "Dsb", "ImmOp", 1183 {"code": dsbCode, 1184 "predicate_test": predicateTest}, 1185 ['IsMemBarrier', 'IsSerializeAfter']) 1186 header_output += ImmOpDeclare.subst(dsbIop) 1187 decoder_output += ImmOpConstructor.subst(dsbIop) 1188 exec_output += PredOpExecute.subst(dsbIop) 1189 1190 dmbCode = ''' 1191 // If the barrier is due to a CP15 access check for hyp traps 1192 if ((imm != 0) && mcrMrc15TrapToHyp(MISCREG_CP15DMB, Hcr, Cpsr, Scr, 1193 Hdcr, Hstr, Hcptr, imm)) { 1194 return std::make_shared<HypervisorTrap>(machInst, imm, 1195 EC_TRAPPED_CP15_MCR_MRC); 1196 } 1197 ''' 1198 dmbIop = InstObjParams("dmb", "Dmb", "ImmOp", 1199 {"code": dmbCode, 1200 "predicate_test": predicateTest}, 1201 ['IsMemBarrier']) 1202 header_output += ImmOpDeclare.subst(dmbIop) 1203 decoder_output += ImmOpConstructor.subst(dmbIop) 1204 exec_output += PredOpExecute.subst(dmbIop) 1205 1206 dbgCode = ''' 1207 ''' 1208 dbgIop = InstObjParams("dbg", "Dbg", "PredOp", 1209 {"code": dbgCode, 1210 "predicate_test": predicateTest}) 1211 header_output += BasicDeclare.subst(dbgIop) 1212 decoder_output += BasicConstructor.subst(dbgIop) 1213 exec_output += PredOpExecute.subst(dbgIop) 1214 1215 cpsCode = ''' 1216 uint32_t mode = bits(imm, 4, 0); 1217 uint32_t f = bits(imm, 5); 1218 uint32_t i = bits(imm, 6); 1219 uint32_t a = bits(imm, 7); 1220 bool setMode = bits(imm, 8); 1221 bool enable = bits(imm, 9); 1222 CPSR cpsr = Cpsr; 1223 SCTLR sctlr = Sctlr; 1224 if (cpsr.mode != MODE_USER) { 1225 if (enable) { 1226 if (f) cpsr.f = 0; 1227 if (i) cpsr.i = 0; 1228 if (a) cpsr.a = 0; 1229 } else { 1230 if (f && !sctlr.nmfi) cpsr.f = 1; 1231 if (i) cpsr.i = 1; 1232 if (a) cpsr.a = 1; 1233 } 1234 if (setMode) { 1235 cpsr.mode = mode; 1236 } 1237 } 1238 Cpsr = cpsr; 1239 ''' 1240 cpsIop = InstObjParams("cps", "Cps", "ImmOp", 1241 { "code": cpsCode, 1242 "predicate_test": predicateTest }, 1243 ["IsSerializeAfter","IsNonSpeculative"]) 1244 header_output += ImmOpDeclare.subst(cpsIop) 1245 decoder_output += ImmOpConstructor.subst(cpsIop) 1246 exec_output += PredOpExecute.subst(cpsIop) 1247}};
| 90 smcCode = ''' 91 HCR hcr = Hcr; 92 CPSR cpsr = Cpsr; 93 SCR scr = Scr; 94 95 if ((cpsr.mode != MODE_USER) && FullSystem) { 96 if (ArmSystem::haveVirtualization(xc->tcBase()) && 97 !inSecureState(scr, cpsr) && (cpsr.mode != MODE_HYP) && hcr.tsc) { 98 fault = std::make_shared<HypervisorTrap>(machInst, 0, 99 EC_SMC_TO_HYP); 100 } else { 101 if (scr.scd) { 102 fault = disabledFault(); 103 } else { 104 fault = std::make_shared<SecureMonitorCall>(machInst); 105 } 106 } 107 } else { 108 fault = disabledFault(); 109 } 110 ''' 111 112 smcIop = InstObjParams("smc", "Smc", "PredOp", 113 { "code": smcCode, 114 "predicate_test": predicateTest }, 115 ["IsNonSpeculative", "IsSerializeAfter"]) 116 header_output += BasicDeclare.subst(smcIop) 117 decoder_output += BasicConstructor.subst(smcIop) 118 exec_output += PredOpExecute.subst(smcIop) 119 120 hvcCode = ''' 121 CPSR cpsr = Cpsr; 122 SCR scr = Scr; 123 124 // Filter out the various cases where this instruction isn't defined 125 if (!FullSystem || !ArmSystem::haveVirtualization(xc->tcBase()) || 126 (cpsr.mode == MODE_USER) || 127 (ArmSystem::haveSecurity(xc->tcBase()) && (!scr.ns || !scr.hce))) { 128 fault = disabledFault(); 129 } else { 130 fault = std::make_shared<HypervisorCall>(machInst, imm); 131 } 132 ''' 133 134 hvcIop = InstObjParams("hvc", "Hvc", "ImmOp", 135 { "code": hvcCode, 136 "predicate_test": predicateTest }, 137 ["IsNonSpeculative", "IsSerializeAfter"]) 138 header_output += ImmOpDeclare.subst(hvcIop) 139 decoder_output += ImmOpConstructor.subst(hvcIop) 140 exec_output += PredOpExecute.subst(hvcIop) 141 142 eretCode = ''' 143 SCTLR sctlr = Sctlr; 144 CPSR old_cpsr = Cpsr; 145 old_cpsr.nz = CondCodesNZ; 146 old_cpsr.c = CondCodesC; 147 old_cpsr.v = CondCodesV; 148 old_cpsr.ge = CondCodesGE; 149 150 CPSR new_cpsr = cpsrWriteByInstr(old_cpsr, Spsr, Scr, Nsacr, 0xF, 151 true, sctlr.nmfi, xc->tcBase()); 152 Cpsr = ~CondCodesMask & new_cpsr; 153 CondCodesNZ = new_cpsr.nz; 154 CondCodesC = new_cpsr.c; 155 CondCodesV = new_cpsr.v; 156 CondCodesGE = new_cpsr.ge; 157 158 NextThumb = (new_cpsr).t; 159 NextJazelle = (new_cpsr).j; 160 NextItState = (((new_cpsr).it2 << 2) & 0xFC) 161 | ((new_cpsr).it1 & 0x3); 162 163 NPC = (old_cpsr.mode == MODE_HYP) ? ElrHyp : LR; 164 ''' 165 166 eretIop = InstObjParams("eret", "Eret", "PredOp", 167 { "code": eretCode, 168 "predicate_test": predicateTest }, 169 ["IsNonSpeculative", "IsSerializeAfter", 170 "IsSquashAfter"]) 171 header_output += BasicDeclare.subst(eretIop) 172 decoder_output += BasicConstructor.subst(eretIop) 173 exec_output += PredOpExecute.subst(eretIop) 174 175 crcCode = ''' 176 constexpr uint8_t size_bytes = %(sz)d; 177 constexpr uint32_t poly = %(polynom)s; 178 179 uint32_t data = htole(Op2); 180 auto data_buffer = reinterpret_cast<uint8_t*>(&data); 181 182 Dest = crc32<poly>( 183 data_buffer, /* Message Register */ 184 Op1, /* Initial Value of the CRC */ 185 size_bytes /* Size of the original Message */ 186 ); 187 ''' 188 189 def crc32Emit(mnem, implCode, castagnoli, size): 190 global header_output, decoder_output, exec_output 191 192 if castagnoli: 193 # crc32c instructions 194 poly = "0x1EDC6F41" 195 else: 196 # crc32 instructions 197 poly = "0x04C11DB7" 198 199 data = {'sz' : size, 'polynom': poly} 200 201 instCode = implCode % data 202 203 crcIop = InstObjParams(mnem, mnem.capitalize(), "RegRegRegOp", 204 { "code": instCode, 205 "predicate_test": predicateTest }, []) 206 header_output += RegRegRegOpDeclare.subst(crcIop) 207 decoder_output += RegRegRegOpConstructor.subst(crcIop) 208 exec_output += PredOpExecute.subst(crcIop) 209 210 crc32Emit("crc32b", crcCode, False, 1); 211 crc32Emit("crc32h", crcCode, False, 2); 212 crc32Emit("crc32w", crcCode, False, 4); 213 crc32Emit("crc32cb", crcCode, True, 1); 214 crc32Emit("crc32ch", crcCode, True, 2); 215 crc32Emit("crc32cw", crcCode, True, 4); 216 217}}; 218 219let {{ 220 221 header_output = decoder_output = exec_output = "" 222 223 mrsCpsrCode = ''' 224 CPSR cpsr = Cpsr; 225 cpsr.nz = CondCodesNZ; 226 cpsr.c = CondCodesC; 227 cpsr.v = CondCodesV; 228 cpsr.ge = CondCodesGE; 229 Dest = cpsr & 0xF8FF03DF 230 ''' 231 232 mrsCpsrIop = InstObjParams("mrs", "MrsCpsr", "MrsOp", 233 { "code": mrsCpsrCode, 234 "predicate_test": condPredicateTest }, 235 ["IsSerializeBefore"]) 236 header_output += MrsDeclare.subst(mrsCpsrIop) 237 decoder_output += MrsConstructor.subst(mrsCpsrIop) 238 exec_output += PredOpExecute.subst(mrsCpsrIop) 239 240 mrsSpsrCode = "Dest = Spsr" 241 mrsSpsrIop = InstObjParams("mrs", "MrsSpsr", "MrsOp", 242 { "code": mrsSpsrCode, 243 "predicate_test": predicateTest }, 244 ["IsSerializeBefore"]) 245 header_output += MrsDeclare.subst(mrsSpsrIop) 246 decoder_output += MrsConstructor.subst(mrsSpsrIop) 247 exec_output += PredOpExecute.subst(mrsSpsrIop) 248 249 mrsBankedRegCode = ''' 250 bool isIntReg; 251 int regIdx; 252 253 if (decodeMrsMsrBankedReg(byteMask, r, isIntReg, regIdx, Cpsr, Scr, Nsacr)) { 254 if (isIntReg) { 255 Dest = DecodedBankedIntReg; 256 } else { 257 Dest = xc->readMiscReg(regIdx); 258 } 259 } else { 260 return std::make_shared<UndefinedInstruction>(machInst, false, 261 mnemonic); 262 } 263 ''' 264 mrsBankedRegIop = InstObjParams("mrs", "MrsBankedReg", "MrsOp", 265 { "code": mrsBankedRegCode, 266 "predicate_test": predicateTest }, 267 ["IsSerializeBefore"]) 268 header_output += MrsBankedRegDeclare.subst(mrsBankedRegIop) 269 decoder_output += MrsBankedRegConstructor.subst(mrsBankedRegIop) 270 exec_output += PredOpExecute.subst(mrsBankedRegIop) 271 272 msrBankedRegCode = ''' 273 bool isIntReg; 274 int regIdx; 275 276 if (decodeMrsMsrBankedReg(byteMask, r, isIntReg, regIdx, Cpsr, Scr, Nsacr)) { 277 if (isIntReg) { 278 // This is a bit nasty, you would have thought that 279 // DecodedBankedIntReg wouldn't be written to unless the 280 // conditions on the IF statements above are met, however if 281 // you look at the generated C code you'll find that they are. 282 // However this is safe as DecodedBankedIntReg (which is used 283 // in operands.isa to get the index of DecodedBankedIntReg) 284 // will return INTREG_DUMMY if its not a valid integer 285 // register, so redirecting the write to somewhere we don't 286 // care about. 287 DecodedBankedIntReg = Op1; 288 } else { 289 xc->setMiscReg(regIdx, Op1); 290 } 291 } else { 292 return std::make_shared<UndefinedInstruction>(machInst, false, 293 mnemonic); 294 } 295 ''' 296 msrBankedRegIop = InstObjParams("msr", "MsrBankedReg", "MsrRegOp", 297 { "code": msrBankedRegCode, 298 "predicate_test": predicateTest }, 299 ["IsSerializeAfter", "IsNonSpeculative"]) 300 header_output += MsrBankedRegDeclare.subst(msrBankedRegIop) 301 decoder_output += MsrBankedRegConstructor.subst(msrBankedRegIop) 302 exec_output += PredOpExecute.subst(msrBankedRegIop) 303 304 msrCpsrRegCode = ''' 305 SCTLR sctlr = Sctlr; 306 CPSR old_cpsr = Cpsr; 307 old_cpsr.nz = CondCodesNZ; 308 old_cpsr.c = CondCodesC; 309 old_cpsr.v = CondCodesV; 310 old_cpsr.ge = CondCodesGE; 311 312 CPSR new_cpsr = 313 cpsrWriteByInstr(old_cpsr, Op1, Scr, Nsacr, byteMask, false, 314 sctlr.nmfi, xc->tcBase()); 315 Cpsr = ~CondCodesMask & new_cpsr; 316 CondCodesNZ = new_cpsr.nz; 317 CondCodesC = new_cpsr.c; 318 CondCodesV = new_cpsr.v; 319 CondCodesGE = new_cpsr.ge; 320 ''' 321 msrCpsrRegIop = InstObjParams("msr", "MsrCpsrReg", "MsrRegOp", 322 { "code": msrCpsrRegCode, 323 "predicate_test": condPredicateTest }, 324 ["IsSerializeAfter","IsNonSpeculative"]) 325 header_output += MsrRegDeclare.subst(msrCpsrRegIop) 326 decoder_output += MsrRegConstructor.subst(msrCpsrRegIop) 327 exec_output += PredOpExecute.subst(msrCpsrRegIop) 328 329 msrSpsrRegCode = "Spsr = spsrWriteByInstr(Spsr, Op1, byteMask, false);" 330 msrSpsrRegIop = InstObjParams("msr", "MsrSpsrReg", "MsrRegOp", 331 { "code": msrSpsrRegCode, 332 "predicate_test": predicateTest }, 333 ["IsSerializeAfter","IsNonSpeculative"]) 334 header_output += MsrRegDeclare.subst(msrSpsrRegIop) 335 decoder_output += MsrRegConstructor.subst(msrSpsrRegIop) 336 exec_output += PredOpExecute.subst(msrSpsrRegIop) 337 338 msrCpsrImmCode = ''' 339 SCTLR sctlr = Sctlr; 340 CPSR old_cpsr = Cpsr; 341 old_cpsr.nz = CondCodesNZ; 342 old_cpsr.c = CondCodesC; 343 old_cpsr.v = CondCodesV; 344 old_cpsr.ge = CondCodesGE; 345 CPSR new_cpsr = 346 cpsrWriteByInstr(old_cpsr, imm, Scr, Nsacr, byteMask, false, 347 sctlr.nmfi, xc->tcBase()); 348 Cpsr = ~CondCodesMask & new_cpsr; 349 CondCodesNZ = new_cpsr.nz; 350 CondCodesC = new_cpsr.c; 351 CondCodesV = new_cpsr.v; 352 CondCodesGE = new_cpsr.ge; 353 ''' 354 msrCpsrImmIop = InstObjParams("msr", "MsrCpsrImm", "MsrImmOp", 355 { "code": msrCpsrImmCode, 356 "predicate_test": condPredicateTest }, 357 ["IsSerializeAfter","IsNonSpeculative"]) 358 header_output += MsrImmDeclare.subst(msrCpsrImmIop) 359 decoder_output += MsrImmConstructor.subst(msrCpsrImmIop) 360 exec_output += PredOpExecute.subst(msrCpsrImmIop) 361 362 msrSpsrImmCode = "Spsr = spsrWriteByInstr(Spsr, imm, byteMask, false);" 363 msrSpsrImmIop = InstObjParams("msr", "MsrSpsrImm", "MsrImmOp", 364 { "code": msrSpsrImmCode, 365 "predicate_test": predicateTest }, 366 ["IsSerializeAfter","IsNonSpeculative"]) 367 header_output += MsrImmDeclare.subst(msrSpsrImmIop) 368 decoder_output += MsrImmConstructor.subst(msrSpsrImmIop) 369 exec_output += PredOpExecute.subst(msrSpsrImmIop) 370 371 revCode = ''' 372 uint32_t val = Op1; 373 Dest = swap_byte(val); 374 ''' 375 revIop = InstObjParams("rev", "Rev", "RegRegOp", 376 { "code": revCode, 377 "predicate_test": predicateTest }, []) 378 header_output += RegRegOpDeclare.subst(revIop) 379 decoder_output += RegRegOpConstructor.subst(revIop) 380 exec_output += PredOpExecute.subst(revIop) 381 382 rev16Code = ''' 383 uint32_t val = Op1; 384 Dest = (bits(val, 15, 8) << 0) | 385 (bits(val, 7, 0) << 8) | 386 (bits(val, 31, 24) << 16) | 387 (bits(val, 23, 16) << 24); 388 ''' 389 rev16Iop = InstObjParams("rev16", "Rev16", "RegRegOp", 390 { "code": rev16Code, 391 "predicate_test": predicateTest }, []) 392 header_output += RegRegOpDeclare.subst(rev16Iop) 393 decoder_output += RegRegOpConstructor.subst(rev16Iop) 394 exec_output += PredOpExecute.subst(rev16Iop) 395 396 revshCode = ''' 397 uint16_t val = Op1; 398 Dest = sext<16>(swap_byte(val)); 399 ''' 400 revshIop = InstObjParams("revsh", "Revsh", "RegRegOp", 401 { "code": revshCode, 402 "predicate_test": predicateTest }, []) 403 header_output += RegRegOpDeclare.subst(revshIop) 404 decoder_output += RegRegOpConstructor.subst(revshIop) 405 exec_output += PredOpExecute.subst(revshIop) 406 407 rbitCode = ''' 408 Dest = reverseBits(Op1); 409 ''' 410 rbitIop = InstObjParams("rbit", "Rbit", "RegRegOp", 411 { "code": rbitCode, 412 "predicate_test": predicateTest }, []) 413 header_output += RegRegOpDeclare.subst(rbitIop) 414 decoder_output += RegRegOpConstructor.subst(rbitIop) 415 exec_output += PredOpExecute.subst(rbitIop) 416 417 clzCode = ''' 418 Dest = (Op1 == 0) ? 32 : (31 - findMsbSet(Op1)); 419 ''' 420 clzIop = InstObjParams("clz", "Clz", "RegRegOp", 421 { "code": clzCode, 422 "predicate_test": predicateTest }, []) 423 header_output += RegRegOpDeclare.subst(clzIop) 424 decoder_output += RegRegOpConstructor.subst(clzIop) 425 exec_output += PredOpExecute.subst(clzIop) 426 427 ssatCode = ''' 428 int32_t operand = shift_rm_imm(Op1, shiftAmt, shiftType, 0); 429 int32_t res; 430 if (satInt(res, operand, imm)) 431 CpsrQ = 1 << 27; 432 Dest = res; 433 ''' 434 ssatIop = InstObjParams("ssat", "Ssat", "RegImmRegShiftOp", 435 { "code": ssatCode, 436 "predicate_test": pickPredicate(ssatCode) }, []) 437 header_output += RegImmRegShiftOpDeclare.subst(ssatIop) 438 decoder_output += RegImmRegShiftOpConstructor.subst(ssatIop) 439 exec_output += PredOpExecute.subst(ssatIop) 440 441 usatCode = ''' 442 int32_t operand = shift_rm_imm(Op1, shiftAmt, shiftType, 0); 443 int32_t res; 444 if (uSatInt(res, operand, imm)) 445 CpsrQ = 1 << 27; 446 Dest = res; 447 ''' 448 usatIop = InstObjParams("usat", "Usat", "RegImmRegShiftOp", 449 { "code": usatCode, 450 "predicate_test": pickPredicate(usatCode) }, []) 451 header_output += RegImmRegShiftOpDeclare.subst(usatIop) 452 decoder_output += RegImmRegShiftOpConstructor.subst(usatIop) 453 exec_output += PredOpExecute.subst(usatIop) 454 455 ssat16Code = ''' 456 int32_t res; 457 uint32_t resTemp = 0; 458 int32_t argLow = sext<16>(bits(Op1, 15, 0)); 459 int32_t argHigh = sext<16>(bits(Op1, 31, 16)); 460 if (satInt(res, argLow, imm)) 461 CpsrQ = 1 << 27; 462 replaceBits(resTemp, 15, 0, res); 463 if (satInt(res, argHigh, imm)) 464 CpsrQ = 1 << 27; 465 replaceBits(resTemp, 31, 16, res); 466 Dest = resTemp; 467 ''' 468 ssat16Iop = InstObjParams("ssat16", "Ssat16", "RegImmRegOp", 469 { "code": ssat16Code, 470 "predicate_test": pickPredicate(ssat16Code) }, []) 471 header_output += RegImmRegOpDeclare.subst(ssat16Iop) 472 decoder_output += RegImmRegOpConstructor.subst(ssat16Iop) 473 exec_output += PredOpExecute.subst(ssat16Iop) 474 475 usat16Code = ''' 476 int32_t res; 477 uint32_t resTemp = 0; 478 int32_t argLow = sext<16>(bits(Op1, 15, 0)); 479 int32_t argHigh = sext<16>(bits(Op1, 31, 16)); 480 if (uSatInt(res, argLow, imm)) 481 CpsrQ = 1 << 27; 482 replaceBits(resTemp, 15, 0, res); 483 if (uSatInt(res, argHigh, imm)) 484 CpsrQ = 1 << 27; 485 replaceBits(resTemp, 31, 16, res); 486 Dest = resTemp; 487 ''' 488 usat16Iop = InstObjParams("usat16", "Usat16", "RegImmRegOp", 489 { "code": usat16Code, 490 "predicate_test": pickPredicate(usat16Code) }, []) 491 header_output += RegImmRegOpDeclare.subst(usat16Iop) 492 decoder_output += RegImmRegOpConstructor.subst(usat16Iop) 493 exec_output += PredOpExecute.subst(usat16Iop) 494 495 sxtbIop = InstObjParams("sxtb", "Sxtb", "RegImmRegOp", 496 { "code": 497 "Dest = sext<8>((uint8_t)(Op1_ud >> imm));", 498 "predicate_test": predicateTest }, []) 499 header_output += RegImmRegOpDeclare.subst(sxtbIop) 500 decoder_output += RegImmRegOpConstructor.subst(sxtbIop) 501 exec_output += PredOpExecute.subst(sxtbIop) 502 503 sxtabIop = InstObjParams("sxtab", "Sxtab", "RegRegRegImmOp", 504 { "code": 505 ''' 506 Dest = sext<8>((uint8_t)(Op2_ud >> imm)) + 507 Op1; 508 ''', 509 "predicate_test": predicateTest }, []) 510 header_output += RegRegRegImmOpDeclare.subst(sxtabIop) 511 decoder_output += RegRegRegImmOpConstructor.subst(sxtabIop) 512 exec_output += PredOpExecute.subst(sxtabIop) 513 514 sxtb16Code = ''' 515 uint32_t resTemp = 0; 516 replaceBits(resTemp, 15, 0, sext<8>(bits(Op1, imm + 7, imm))); 517 replaceBits(resTemp, 31, 16, 518 sext<8>(bits(Op1, (imm + 23) % 32, (imm + 16) % 32))); 519 Dest = resTemp; 520 ''' 521 sxtb16Iop = InstObjParams("sxtb16", "Sxtb16", "RegImmRegOp", 522 { "code": sxtb16Code, 523 "predicate_test": predicateTest }, []) 524 header_output += RegImmRegOpDeclare.subst(sxtb16Iop) 525 decoder_output += RegImmRegOpConstructor.subst(sxtb16Iop) 526 exec_output += PredOpExecute.subst(sxtb16Iop) 527 528 sxtab16Code = ''' 529 uint32_t resTemp = 0; 530 replaceBits(resTemp, 15, 0, sext<8>(bits(Op2, imm + 7, imm)) + 531 bits(Op1, 15, 0)); 532 replaceBits(resTemp, 31, 16, 533 sext<8>(bits(Op2, (imm + 23) % 32, (imm + 16) % 32)) + 534 bits(Op1, 31, 16)); 535 Dest = resTemp; 536 ''' 537 sxtab16Iop = InstObjParams("sxtab16", "Sxtab16", "RegRegRegImmOp", 538 { "code": sxtab16Code, 539 "predicate_test": predicateTest }, []) 540 header_output += RegRegRegImmOpDeclare.subst(sxtab16Iop) 541 decoder_output += RegRegRegImmOpConstructor.subst(sxtab16Iop) 542 exec_output += PredOpExecute.subst(sxtab16Iop) 543 544 sxthCode = ''' 545 uint64_t rotated = (uint32_t)Op1; 546 rotated = (rotated | (rotated << 32)) >> imm; 547 Dest = sext<16>((uint16_t)rotated); 548 ''' 549 sxthIop = InstObjParams("sxth", "Sxth", "RegImmRegOp", 550 { "code": sxthCode, 551 "predicate_test": predicateTest }, []) 552 header_output += RegImmRegOpDeclare.subst(sxthIop) 553 decoder_output += RegImmRegOpConstructor.subst(sxthIop) 554 exec_output += PredOpExecute.subst(sxthIop) 555 556 sxtahCode = ''' 557 uint64_t rotated = (uint32_t)Op2; 558 rotated = (rotated | (rotated << 32)) >> imm; 559 Dest = sext<16>((uint16_t)rotated) + Op1; 560 ''' 561 sxtahIop = InstObjParams("sxtah", "Sxtah", "RegRegRegImmOp", 562 { "code": sxtahCode, 563 "predicate_test": predicateTest }, []) 564 header_output += RegRegRegImmOpDeclare.subst(sxtahIop) 565 decoder_output += RegRegRegImmOpConstructor.subst(sxtahIop) 566 exec_output += PredOpExecute.subst(sxtahIop) 567 568 uxtbIop = InstObjParams("uxtb", "Uxtb", "RegImmRegOp", 569 { "code": "Dest = (uint8_t)(Op1_ud >> imm);", 570 "predicate_test": predicateTest }, []) 571 header_output += RegImmRegOpDeclare.subst(uxtbIop) 572 decoder_output += RegImmRegOpConstructor.subst(uxtbIop) 573 exec_output += PredOpExecute.subst(uxtbIop) 574 575 uxtabIop = InstObjParams("uxtab", "Uxtab", "RegRegRegImmOp", 576 { "code": 577 "Dest = (uint8_t)(Op2_ud >> imm) + Op1;", 578 "predicate_test": predicateTest }, []) 579 header_output += RegRegRegImmOpDeclare.subst(uxtabIop) 580 decoder_output += RegRegRegImmOpConstructor.subst(uxtabIop) 581 exec_output += PredOpExecute.subst(uxtabIop) 582 583 uxtb16Code = ''' 584 uint32_t resTemp = 0; 585 replaceBits(resTemp, 15, 0, (uint8_t)(bits(Op1, imm + 7, imm))); 586 replaceBits(resTemp, 31, 16, 587 (uint8_t)(bits(Op1, (imm + 23) % 32, (imm + 16) % 32))); 588 Dest = resTemp; 589 ''' 590 uxtb16Iop = InstObjParams("uxtb16", "Uxtb16", "RegImmRegOp", 591 { "code": uxtb16Code, 592 "predicate_test": predicateTest }, []) 593 header_output += RegImmRegOpDeclare.subst(uxtb16Iop) 594 decoder_output += RegImmRegOpConstructor.subst(uxtb16Iop) 595 exec_output += PredOpExecute.subst(uxtb16Iop) 596 597 uxtab16Code = ''' 598 uint32_t resTemp = 0; 599 replaceBits(resTemp, 15, 0, (uint8_t)(bits(Op2, imm + 7, imm)) + 600 bits(Op1, 15, 0)); 601 replaceBits(resTemp, 31, 16, 602 (uint8_t)(bits(Op2, (imm + 23) % 32, (imm + 16) % 32)) + 603 bits(Op1, 31, 16)); 604 Dest = resTemp; 605 ''' 606 uxtab16Iop = InstObjParams("uxtab16", "Uxtab16", "RegRegRegImmOp", 607 { "code": uxtab16Code, 608 "predicate_test": predicateTest }, []) 609 header_output += RegRegRegImmOpDeclare.subst(uxtab16Iop) 610 decoder_output += RegRegRegImmOpConstructor.subst(uxtab16Iop) 611 exec_output += PredOpExecute.subst(uxtab16Iop) 612 613 uxthCode = ''' 614 uint64_t rotated = (uint32_t)Op1; 615 rotated = (rotated | (rotated << 32)) >> imm; 616 Dest = (uint16_t)rotated; 617 ''' 618 uxthIop = InstObjParams("uxth", "Uxth", "RegImmRegOp", 619 { "code": uxthCode, 620 "predicate_test": predicateTest }, []) 621 header_output += RegImmRegOpDeclare.subst(uxthIop) 622 decoder_output += RegImmRegOpConstructor.subst(uxthIop) 623 exec_output += PredOpExecute.subst(uxthIop) 624 625 uxtahCode = ''' 626 uint64_t rotated = (uint32_t)Op2; 627 rotated = (rotated | (rotated << 32)) >> imm; 628 Dest = (uint16_t)rotated + Op1; 629 ''' 630 uxtahIop = InstObjParams("uxtah", "Uxtah", "RegRegRegImmOp", 631 { "code": uxtahCode, 632 "predicate_test": predicateTest }, []) 633 header_output += RegRegRegImmOpDeclare.subst(uxtahIop) 634 decoder_output += RegRegRegImmOpConstructor.subst(uxtahIop) 635 exec_output += PredOpExecute.subst(uxtahIop) 636 637 selCode = ''' 638 uint32_t resTemp = 0; 639 for (unsigned i = 0; i < 4; i++) { 640 int low = i * 8; 641 int high = low + 7; 642 replaceBits(resTemp, high, low, 643 bits(CondCodesGE, i) ? 644 bits(Op1, high, low) : bits(Op2, high, low)); 645 } 646 Dest = resTemp; 647 ''' 648 selIop = InstObjParams("sel", "Sel", "RegRegRegOp", 649 { "code": selCode, 650 "predicate_test": predicateTest }, []) 651 header_output += RegRegRegOpDeclare.subst(selIop) 652 decoder_output += RegRegRegOpConstructor.subst(selIop) 653 exec_output += PredOpExecute.subst(selIop) 654 655 usad8Code = ''' 656 uint32_t resTemp = 0; 657 for (unsigned i = 0; i < 4; i++) { 658 int low = i * 8; 659 int high = low + 7; 660 int32_t diff = bits(Op1, high, low) - 661 bits(Op2, high, low); 662 resTemp += ((diff < 0) ? -diff : diff); 663 } 664 Dest = resTemp; 665 ''' 666 usad8Iop = InstObjParams("usad8", "Usad8", "RegRegRegOp", 667 { "code": usad8Code, 668 "predicate_test": predicateTest }, []) 669 header_output += RegRegRegOpDeclare.subst(usad8Iop) 670 decoder_output += RegRegRegOpConstructor.subst(usad8Iop) 671 exec_output += PredOpExecute.subst(usad8Iop) 672 673 usada8Code = ''' 674 uint32_t resTemp = 0; 675 for (unsigned i = 0; i < 4; i++) { 676 int low = i * 8; 677 int high = low + 7; 678 int32_t diff = bits(Op1, high, low) - 679 bits(Op2, high, low); 680 resTemp += ((diff < 0) ? -diff : diff); 681 } 682 Dest = Op3 + resTemp; 683 ''' 684 usada8Iop = InstObjParams("usada8", "Usada8", "RegRegRegRegOp", 685 { "code": usada8Code, 686 "predicate_test": predicateTest }, []) 687 header_output += RegRegRegRegOpDeclare.subst(usada8Iop) 688 decoder_output += RegRegRegRegOpConstructor.subst(usada8Iop) 689 exec_output += PredOpExecute.subst(usada8Iop) 690 691 bkptCode = 'return std::make_shared<PrefetchAbort>(PC, ArmFault::DebugEvent);\n' 692 bkptIop = InstObjParams("bkpt", "BkptInst", "PredOp", bkptCode) 693 header_output += BasicDeclare.subst(bkptIop) 694 decoder_output += BasicConstructor.subst(bkptIop) 695 exec_output += BasicExecute.subst(bkptIop) 696 697 nopIop = InstObjParams("nop", "NopInst", "ArmStaticInst", "", ['IsNop']) 698 header_output += BasicDeclare.subst(nopIop) 699 decoder_output += BasicConstructor64.subst(nopIop) 700 exec_output += BasicExecute.subst(nopIop) 701 702 yieldIop = InstObjParams("yield", "YieldInst", "PredOp", \ 703 { "code" : "", "predicate_test" : predicateTest }) 704 header_output += BasicDeclare.subst(yieldIop) 705 decoder_output += BasicConstructor.subst(yieldIop) 706 exec_output += PredOpExecute.subst(yieldIop) 707 708 wfeCode = ''' 709 CPSR cpsr = Cpsr; 710 SCR scr = Scr64; 711 712 // WFE Sleeps if SevMailbox==0 and no unmasked interrupts are pending, 713 ThreadContext *tc = xc->tcBase(); 714 if (SevMailbox == 1) { 715 SevMailbox = 0; 716 PseudoInst::quiesceSkip(tc); 717 } else if (tc->getCpuPtr()->getInterruptController( 718 tc->threadId())->checkInterrupts(tc)) { 719 PseudoInst::quiesceSkip(tc); 720 } else { 721 fault = trapWFx(tc, cpsr, scr, true); 722 if (fault == NoFault) { 723 PseudoInst::quiesce(tc); 724 } else { 725 PseudoInst::quiesceSkip(tc); 726 } 727 } 728 ''' 729 wfePredFixUpCode = ''' 730 // WFE is predicated false, reset SevMailbox to reduce spurious sleeps 731 // and SEV interrupts 732 SevMailbox = 1; 733 ''' 734 wfeIop = InstObjParams("wfe", "WfeInst", "PredOp", \ 735 { "code" : wfeCode, 736 "pred_fixup" : wfePredFixUpCode, 737 "predicate_test" : predicateTest }, 738 ["IsNonSpeculative", "IsQuiesce", 739 "IsSerializeAfter", "IsUnverifiable"]) 740 header_output += BasicDeclare.subst(wfeIop) 741 decoder_output += BasicConstructor.subst(wfeIop) 742 exec_output += QuiescePredOpExecuteWithFixup.subst(wfeIop) 743 744 wfiCode = ''' 745 HCR hcr = Hcr; 746 CPSR cpsr = Cpsr; 747 SCR scr = Scr64; 748 749 // WFI doesn't sleep if interrupts are pending (masked or not) 750 ThreadContext *tc = xc->tcBase(); 751 if (tc->getCpuPtr()->getInterruptController( 752 tc->threadId())->checkWfiWake(hcr, cpsr, scr)) { 753 PseudoInst::quiesceSkip(tc); 754 } else { 755 fault = trapWFx(tc, cpsr, scr, false); 756 if (fault == NoFault) { 757 PseudoInst::quiesce(tc); 758 } else { 759 PseudoInst::quiesceSkip(tc); 760 } 761 } 762 tc->getCpuPtr()->clearInterrupt(tc->threadId(), INT_ABT, 0); 763 ''' 764 wfiIop = InstObjParams("wfi", "WfiInst", "PredOp", \ 765 { "code" : wfiCode, "predicate_test" : predicateTest }, 766 ["IsNonSpeculative", "IsQuiesce", 767 "IsSerializeAfter", "IsUnverifiable"]) 768 header_output += BasicDeclare.subst(wfiIop) 769 decoder_output += BasicConstructor.subst(wfiIop) 770 exec_output += QuiescePredOpExecute.subst(wfiIop) 771 772 sevCode = ''' 773 SevMailbox = 1; 774 System *sys = xc->tcBase()->getSystemPtr(); 775 for (int x = 0; x < sys->numContexts(); x++) { 776 ThreadContext *oc = sys->getThreadContext(x); 777 if (oc == xc->tcBase()) 778 continue; 779 // Wake CPU with interrupt if they were sleeping 780 if (oc->readMiscReg(MISCREG_SEV_MAILBOX) == 0) { 781 // Post Interrupt and wake cpu if needed 782 oc->getCpuPtr()->postInterrupt(oc->threadId(), INT_SEV, 0); 783 } 784 } 785 ''' 786 sevIop = InstObjParams("sev", "SevInst", "PredOp", \ 787 { "code" : sevCode, "predicate_test" : predicateTest }, 788 ["IsNonSpeculative", "IsSquashAfter", "IsUnverifiable"]) 789 header_output += BasicDeclare.subst(sevIop) 790 decoder_output += BasicConstructor.subst(sevIop) 791 exec_output += PredOpExecute.subst(sevIop) 792 793 sevlCode = ''' 794 SevMailbox = 1; 795 ''' 796 sevlIop = InstObjParams("sevl", "SevlInst", "PredOp", \ 797 { "code" : sevlCode, "predicate_test" : predicateTest }, 798 ["IsNonSpeculative", "IsSquashAfter", "IsUnverifiable"]) 799 header_output += BasicDeclare.subst(sevlIop) 800 decoder_output += BasicConstructor.subst(sevlIop) 801 exec_output += BasicExecute.subst(sevlIop) 802 803 itIop = InstObjParams("it", "ItInst", "PredOp", \ 804 { "code" : ";", 805 "predicate_test" : predicateTest }, []) 806 header_output += BasicDeclare.subst(itIop) 807 decoder_output += BasicConstructor.subst(itIop) 808 exec_output += PredOpExecute.subst(itIop) 809 unknownCode = ''' 810 return std::make_shared<UndefinedInstruction>(machInst, true); 811 ''' 812 unknownIop = InstObjParams("unknown", "Unknown", "UnknownOp", \ 813 { "code": unknownCode, 814 "predicate_test": predicateTest }) 815 header_output += BasicDeclare.subst(unknownIop) 816 decoder_output += BasicConstructor.subst(unknownIop) 817 exec_output += PredOpExecute.subst(unknownIop) 818 819 ubfxCode = ''' 820 Dest = bits(Op1, imm2, imm1); 821 ''' 822 ubfxIop = InstObjParams("ubfx", "Ubfx", "RegRegImmImmOp", 823 { "code": ubfxCode, 824 "predicate_test": predicateTest }, []) 825 header_output += RegRegImmImmOpDeclare.subst(ubfxIop) 826 decoder_output += RegRegImmImmOpConstructor.subst(ubfxIop) 827 exec_output += PredOpExecute.subst(ubfxIop) 828 829 sbfxCode = ''' 830 int32_t resTemp = bits(Op1, imm2, imm1); 831 Dest = resTemp | -(resTemp & (1 << (imm2 - imm1))); 832 ''' 833 sbfxIop = InstObjParams("sbfx", "Sbfx", "RegRegImmImmOp", 834 { "code": sbfxCode, 835 "predicate_test": predicateTest }, []) 836 header_output += RegRegImmImmOpDeclare.subst(sbfxIop) 837 decoder_output += RegRegImmImmOpConstructor.subst(sbfxIop) 838 exec_output += PredOpExecute.subst(sbfxIop) 839 840 bfcCode = ''' 841 Dest = Op1 & ~(mask(imm2 - imm1 + 1) << imm1); 842 ''' 843 bfcIop = InstObjParams("bfc", "Bfc", "RegRegImmImmOp", 844 { "code": bfcCode, 845 "predicate_test": predicateTest }, []) 846 header_output += RegRegImmImmOpDeclare.subst(bfcIop) 847 decoder_output += RegRegImmImmOpConstructor.subst(bfcIop) 848 exec_output += PredOpExecute.subst(bfcIop) 849 850 bfiCode = ''' 851 uint32_t bitMask = (mask(imm2 - imm1 + 1) << imm1); 852 Dest = ((Op1 << imm1) & bitMask) | (Dest & ~bitMask); 853 ''' 854 bfiIop = InstObjParams("bfi", "Bfi", "RegRegImmImmOp", 855 { "code": bfiCode, 856 "predicate_test": predicateTest }, []) 857 header_output += RegRegImmImmOpDeclare.subst(bfiIop) 858 decoder_output += RegRegImmImmOpConstructor.subst(bfiIop) 859 exec_output += PredOpExecute.subst(bfiIop) 860 861 mrc14code = ''' 862 MiscRegIndex miscReg = (MiscRegIndex) xc->tcBase()->flattenRegId( 863 RegId(MiscRegClass, op1)).index(); 864 bool can_read, undefined; 865 std::tie(can_read, undefined) = canReadCoprocReg(miscReg, Scr, Cpsr); 866 if (!can_read || undefined) { 867 return std::make_shared<UndefinedInstruction>(machInst, false, 868 mnemonic); 869 } 870 if (mcrMrc14TrapToHyp((const MiscRegIndex) op1, Hcr, Cpsr, Scr, Hdcr, 871 Hstr, Hcptr, imm)) { 872 return std::make_shared<HypervisorTrap>(machInst, imm, 873 EC_TRAPPED_CP14_MCR_MRC); 874 } 875 Dest = MiscOp1; 876 ''' 877 878 mrc14Iop = InstObjParams("mrc", "Mrc14", "RegRegImmOp", 879 { "code": mrc14code, 880 "predicate_test": predicateTest }, []) 881 header_output += RegRegImmOpDeclare.subst(mrc14Iop) 882 decoder_output += RegRegImmOpConstructor.subst(mrc14Iop) 883 exec_output += PredOpExecute.subst(mrc14Iop) 884 885 886 mcr14code = ''' 887 MiscRegIndex miscReg = (MiscRegIndex) xc->tcBase()->flattenRegId( 888 RegId(MiscRegClass, dest)).index(); 889 bool can_write, undefined; 890 std::tie(can_write, undefined) = canWriteCoprocReg(miscReg, Scr, Cpsr); 891 if (undefined || !can_write) { 892 return std::make_shared<UndefinedInstruction>(machInst, false, 893 mnemonic); 894 } 895 if (mcrMrc14TrapToHyp(miscReg, Hcr, Cpsr, Scr, Hdcr, 896 Hstr, Hcptr, imm)) { 897 return std::make_shared<HypervisorTrap>(machInst, imm, 898 EC_TRAPPED_CP14_MCR_MRC); 899 } 900 MiscDest = Op1; 901 ''' 902 mcr14Iop = InstObjParams("mcr", "Mcr14", "RegRegImmOp", 903 { "code": mcr14code, 904 "predicate_test": predicateTest }, 905 ["IsSerializeAfter","IsNonSpeculative"]) 906 header_output += RegRegImmOpDeclare.subst(mcr14Iop) 907 decoder_output += RegRegImmOpConstructor.subst(mcr14Iop) 908 exec_output += PredOpExecute.subst(mcr14Iop) 909 910 mrc15code = ''' 911 int preFlatOp1 = snsBankedIndex(op1, xc->tcBase()); 912 MiscRegIndex miscReg = (MiscRegIndex) 913 xc->tcBase()->flattenRegId(RegId(MiscRegClass, 914 preFlatOp1)).index(); 915 bool hypTrap = mcrMrc15TrapToHyp(miscReg, Hcr, Cpsr, Scr, Hdcr, Hstr, 916 Hcptr, imm); 917 bool can_read, undefined; 918 std::tie(can_read, undefined) = canReadCoprocReg(miscReg, Scr, Cpsr); 919 // if we're in non secure PL1 mode then we can trap regargless of whether 920 // the register is accessable, in other modes we trap if only if the register 921 // IS accessable. 922 if (undefined || (!can_read && !(hypTrap && !inUserMode(Cpsr) && 923 !inSecureState(Scr, Cpsr)))) { 924 return std::make_shared<UndefinedInstruction>(machInst, false, 925 mnemonic); 926 } 927 if (hypTrap) { 928 return std::make_shared<HypervisorTrap>(machInst, imm, 929 EC_TRAPPED_CP15_MCR_MRC); 930 } 931 Dest = MiscNsBankedOp1; 932 ''' 933 934 mrc15Iop = InstObjParams("mrc", "Mrc15", "RegMiscRegImmOp", 935 { "code": mrc15code, 936 "predicate_test": predicateTest }, []) 937 header_output += RegMiscRegImmOpDeclare.subst(mrc15Iop) 938 decoder_output += RegMiscRegImmOpConstructor.subst(mrc15Iop) 939 exec_output += PredOpExecute.subst(mrc15Iop) 940 941 942 mcr15code = ''' 943 int preFlatDest = snsBankedIndex(dest, xc->tcBase()); 944 MiscRegIndex miscReg = (MiscRegIndex) 945 xc->tcBase()->flattenRegId(RegId(MiscRegClass, 946 preFlatDest)).index(); 947 bool hypTrap = mcrMrc15TrapToHyp(miscReg, Hcr, Cpsr, Scr, Hdcr, Hstr, 948 Hcptr, imm); 949 bool can_write, undefined; 950 std::tie(can_write, undefined) = canWriteCoprocReg(miscReg, Scr, Cpsr); 951 952 // if we're in non secure PL1 mode then we can trap regargless of whether 953 // the register is accessable, in other modes we trap if only if the register 954 // IS accessable. 955 if (undefined || (!can_write && !(hypTrap && !inUserMode(Cpsr) && 956 !inSecureState(Scr, Cpsr)))) { 957 return std::make_shared<UndefinedInstruction>(machInst, false, 958 mnemonic); 959 } 960 if (hypTrap) { 961 return std::make_shared<HypervisorTrap>(machInst, imm, 962 EC_TRAPPED_CP15_MCR_MRC); 963 } 964 MiscNsBankedDest = Op1; 965 ''' 966 mcr15Iop = InstObjParams("mcr", "Mcr15", "MiscRegRegImmOp", 967 { "code": mcr15code, 968 "predicate_test": predicateTest }, 969 ["IsSerializeAfter","IsNonSpeculative"]) 970 header_output += MiscRegRegImmOpDeclare.subst(mcr15Iop) 971 decoder_output += MiscRegRegImmOpConstructor.subst(mcr15Iop) 972 exec_output += PredOpExecute.subst(mcr15Iop) 973 974 975 mrrc15code = ''' 976 int preFlatOp1 = snsBankedIndex(op1, xc->tcBase()); 977 MiscRegIndex miscReg = (MiscRegIndex) 978 xc->tcBase()->flattenRegId(RegId(MiscRegClass, 979 preFlatOp1)).index(); 980 bool hypTrap = mcrrMrrc15TrapToHyp(miscReg, Cpsr, Scr, Hstr, Hcr, imm); 981 bool can_read, undefined; 982 std::tie(can_read, undefined) = canReadCoprocReg(miscReg, Scr, Cpsr); 983 // if we're in non secure PL1 mode then we can trap regargless of whether 984 // the register is accessable, in other modes we trap if only if the register 985 // IS accessable. 986 if (undefined || (!can_read && !(hypTrap && !inUserMode(Cpsr) && 987 !inSecureState(Scr, Cpsr)))) { 988 return std::make_shared<UndefinedInstruction>(machInst, false, 989 mnemonic); 990 } 991 if (hypTrap) { 992 return std::make_shared<HypervisorTrap>(machInst, imm, 993 EC_TRAPPED_CP15_MCRR_MRRC); 994 } 995 Dest = bits(MiscNsBankedOp164, 63, 32); 996 Dest2 = bits(MiscNsBankedOp164, 31, 0); 997 ''' 998 mrrc15Iop = InstObjParams("mrrc", "Mrrc15", "MrrcOp", 999 { "code": mrrc15code, 1000 "predicate_test": predicateTest }, []) 1001 header_output += MrrcOpDeclare.subst(mrrc15Iop) 1002 decoder_output += MrrcOpConstructor.subst(mrrc15Iop) 1003 exec_output += PredOpExecute.subst(mrrc15Iop) 1004 1005 1006 mcrr15code = ''' 1007 int preFlatDest = snsBankedIndex(dest, xc->tcBase()); 1008 MiscRegIndex miscReg = (MiscRegIndex) 1009 xc->tcBase()->flattenRegId(RegId(MiscRegClass, 1010 preFlatDest)).index(); 1011 bool hypTrap = mcrrMrrc15TrapToHyp(miscReg, Cpsr, Scr, Hstr, Hcr, imm); 1012 bool can_write, undefined; 1013 std::tie(can_write, undefined) = canWriteCoprocReg(miscReg, Scr, Cpsr); 1014 1015 // if we're in non secure PL1 mode then we can trap regargless of whether 1016 // the register is accessable, in other modes we trap if only if the register 1017 // IS accessable. 1018 if (undefined || (!can_write && !(hypTrap && !inUserMode(Cpsr) && 1019 !inSecureState(Scr, Cpsr)))) { 1020 return std::make_shared<UndefinedInstruction>(machInst, false, 1021 mnemonic); 1022 } 1023 if (hypTrap) { 1024 return std::make_shared<HypervisorTrap>(machInst, imm, 1025 EC_TRAPPED_CP15_MCRR_MRRC); 1026 } 1027 MiscNsBankedDest64 = ((uint64_t) Op1 << 32) | Op2; 1028 ''' 1029 mcrr15Iop = InstObjParams("mcrr", "Mcrr15", "McrrOp", 1030 { "code": mcrr15code, 1031 "predicate_test": predicateTest }, []) 1032 header_output += McrrOpDeclare.subst(mcrr15Iop) 1033 decoder_output += McrrOpConstructor.subst(mcrr15Iop) 1034 exec_output += PredOpExecute.subst(mcrr15Iop) 1035 1036 1037 enterxCode = ''' 1038 NextThumb = true; 1039 NextJazelle = true; 1040 ''' 1041 enterxIop = InstObjParams("enterx", "Enterx", "PredOp", 1042 { "code": enterxCode, 1043 "predicate_test": predicateTest }, []) 1044 header_output += BasicDeclare.subst(enterxIop) 1045 decoder_output += BasicConstructor.subst(enterxIop) 1046 exec_output += PredOpExecute.subst(enterxIop) 1047 1048 leavexCode = ''' 1049 NextThumb = true; 1050 NextJazelle = false; 1051 ''' 1052 leavexIop = InstObjParams("leavex", "Leavex", "PredOp", 1053 { "code": leavexCode, 1054 "predicate_test": predicateTest }, []) 1055 header_output += BasicDeclare.subst(leavexIop) 1056 decoder_output += BasicConstructor.subst(leavexIop) 1057 exec_output += PredOpExecute.subst(leavexIop) 1058 1059 setendCode = ''' 1060 CPSR cpsr = Cpsr; 1061 cpsr.e = imm; 1062 Cpsr = cpsr; 1063 fault = checkSETENDEnabled(xc->tcBase(), cpsr); 1064 ''' 1065 setendIop = InstObjParams("setend", "Setend", "ImmOp", 1066 { "code": setendCode, 1067 "predicate_test": predicateTest }, 1068 ["IsSerializeAfter","IsNonSpeculative"]) 1069 header_output += ImmOpDeclare.subst(setendIop) 1070 decoder_output += ImmOpConstructor.subst(setendIop) 1071 exec_output += PredOpExecute.subst(setendIop) 1072 1073 clrexCode = ''' 1074 LLSCLock = 0; 1075 ''' 1076 clrexIop = InstObjParams("clrex", "Clrex","PredOp", 1077 { "code": clrexCode, 1078 "predicate_test": predicateTest },[]) 1079 header_output += BasicDeclare.subst(clrexIop) 1080 decoder_output += BasicConstructor.subst(clrexIop) 1081 exec_output += PredOpExecute.subst(clrexIop) 1082 1083 McrDcCheckCode = ''' 1084 int preFlatDest = snsBankedIndex(dest, xc->tcBase()); 1085 MiscRegIndex miscReg = (MiscRegIndex) xc->tcBase()->flattenRegId( 1086 RegId(MiscRegClass, preFlatDest)).index(); 1087 bool hypTrap = mcrMrc15TrapToHyp(miscReg, Hcr, Cpsr, Scr, Hdcr, Hstr, 1088 Hcptr, imm); 1089 bool can_write, undefined; 1090 std::tie(can_write, undefined) = canWriteCoprocReg(miscReg, Scr, Cpsr); 1091 1092 // if we're in non secure PL1 mode then we can trap regardless 1093 // of whether the register is accessible, in other modes we 1094 // trap if only if the register IS accessible. 1095 if (undefined || (!can_write & !(hypTrap & !inUserMode(Cpsr) & 1096 !inSecureState(Scr, Cpsr)))) { 1097 return std::make_shared<UndefinedInstruction>(machInst, false, 1098 mnemonic); 1099 } 1100 if (hypTrap) { 1101 return std::make_shared<HypervisorTrap>(machInst, imm, 1102 EC_TRAPPED_CP15_MCR_MRC); 1103 } 1104 ''' 1105 1106 McrDcimvacCode = ''' 1107 const Request::Flags memAccessFlags(ArmISA::TLB::MustBeOne | 1108 Request::INVALIDATE | 1109 Request::DST_POC); 1110 EA = Op1; 1111 ''' 1112 McrDcimvacIop = InstObjParams("mcr", "McrDcimvac", 1113 "MiscRegRegImmOp", 1114 {"memacc_code": McrDcCheckCode, 1115 "postacc_code": "", 1116 "ea_code": McrDcimvacCode, 1117 "predicate_test": predicateTest}, 1118 ['IsMemRef', 'IsStore']) 1119 header_output += MiscRegRegImmMemOpDeclare.subst(McrDcimvacIop) 1120 decoder_output += MiscRegRegImmOpConstructor.subst(McrDcimvacIop) 1121 exec_output += Mcr15Execute.subst(McrDcimvacIop) + \ 1122 Mcr15InitiateAcc.subst(McrDcimvacIop) + \ 1123 Mcr15CompleteAcc.subst(McrDcimvacIop) 1124 1125 McrDccmvacCode = ''' 1126 const Request::Flags memAccessFlags(ArmISA::TLB::MustBeOne | 1127 Request::CLEAN | 1128 Request::DST_POC); 1129 EA = Op1; 1130 ''' 1131 McrDccmvacIop = InstObjParams("mcr", "McrDccmvac", 1132 "MiscRegRegImmOp", 1133 {"memacc_code": McrDcCheckCode, 1134 "postacc_code": "", 1135 "ea_code": McrDccmvacCode, 1136 "predicate_test": predicateTest}, 1137 ['IsMemRef', 'IsStore']) 1138 header_output += MiscRegRegImmMemOpDeclare.subst(McrDccmvacIop) 1139 decoder_output += MiscRegRegImmOpConstructor.subst(McrDccmvacIop) 1140 exec_output += Mcr15Execute.subst(McrDccmvacIop) + \ 1141 Mcr15InitiateAcc.subst(McrDccmvacIop) + \ 1142 Mcr15CompleteAcc.subst(McrDccmvacIop) 1143 1144 McrDccmvauCode = ''' 1145 const Request::Flags memAccessFlags(ArmISA::TLB::MustBeOne | 1146 Request::CLEAN | 1147 Request::DST_POU); 1148 EA = Op1; 1149 ''' 1150 McrDccmvauIop = InstObjParams("mcr", "McrDccmvau", 1151 "MiscRegRegImmOp", 1152 {"memacc_code": McrDcCheckCode, 1153 "postacc_code": "", 1154 "ea_code": McrDccmvauCode, 1155 "predicate_test": predicateTest}, 1156 ['IsMemRef', 'IsStore']) 1157 header_output += MiscRegRegImmMemOpDeclare.subst(McrDccmvauIop) 1158 decoder_output += MiscRegRegImmOpConstructor.subst(McrDccmvauIop) 1159 exec_output += Mcr15Execute.subst(McrDccmvauIop) + \ 1160 Mcr15InitiateAcc.subst(McrDccmvauIop) + \ 1161 Mcr15CompleteAcc.subst(McrDccmvauIop) 1162 1163 McrDccimvacCode = ''' 1164 const Request::Flags memAccessFlags(ArmISA::TLB::MustBeOne | 1165 Request::CLEAN | 1166 Request::INVALIDATE | 1167 Request::DST_POC); 1168 EA = Op1; 1169 ''' 1170 McrDccimvacIop = InstObjParams("mcr", "McrDccimvac", 1171 "MiscRegRegImmOp", 1172 {"memacc_code": McrDcCheckCode, 1173 "postacc_code": "", 1174 "ea_code": McrDccimvacCode, 1175 "predicate_test": predicateTest}, 1176 ['IsMemRef', 'IsStore']) 1177 header_output += MiscRegRegImmMemOpDeclare.subst(McrDccimvacIop) 1178 decoder_output += MiscRegRegImmOpConstructor.subst(McrDccimvacIop) 1179 exec_output += Mcr15Execute.subst(McrDccimvacIop) + \ 1180 Mcr15InitiateAcc.subst(McrDccimvacIop) + \ 1181 Mcr15CompleteAcc.subst(McrDccimvacIop) 1182 1183 isbCode = ''' 1184 // If the barrier is due to a CP15 access check for hyp traps 1185 if ((imm != 0) && mcrMrc15TrapToHyp(MISCREG_CP15ISB, Hcr, Cpsr, Scr, 1186 Hdcr, Hstr, Hcptr, imm)) { 1187 return std::make_shared<HypervisorTrap>(machInst, imm, 1188 EC_TRAPPED_CP15_MCR_MRC); 1189 } 1190 ''' 1191 isbIop = InstObjParams("isb", "Isb", "ImmOp", 1192 {"code": isbCode, 1193 "predicate_test": predicateTest}, 1194 ['IsSquashAfter']) 1195 header_output += ImmOpDeclare.subst(isbIop) 1196 decoder_output += ImmOpConstructor.subst(isbIop) 1197 exec_output += PredOpExecute.subst(isbIop) 1198 1199 dsbCode = ''' 1200 // If the barrier is due to a CP15 access check for hyp traps 1201 if ((imm != 0) && mcrMrc15TrapToHyp(MISCREG_CP15DSB, Hcr, Cpsr, Scr, 1202 Hdcr, Hstr, Hcptr, imm)) { 1203 return std::make_shared<HypervisorTrap>(machInst, imm, 1204 EC_TRAPPED_CP15_MCR_MRC); 1205 } 1206 ''' 1207 dsbIop = InstObjParams("dsb", "Dsb", "ImmOp", 1208 {"code": dsbCode, 1209 "predicate_test": predicateTest}, 1210 ['IsMemBarrier', 'IsSerializeAfter']) 1211 header_output += ImmOpDeclare.subst(dsbIop) 1212 decoder_output += ImmOpConstructor.subst(dsbIop) 1213 exec_output += PredOpExecute.subst(dsbIop) 1214 1215 dmbCode = ''' 1216 // If the barrier is due to a CP15 access check for hyp traps 1217 if ((imm != 0) && mcrMrc15TrapToHyp(MISCREG_CP15DMB, Hcr, Cpsr, Scr, 1218 Hdcr, Hstr, Hcptr, imm)) { 1219 return std::make_shared<HypervisorTrap>(machInst, imm, 1220 EC_TRAPPED_CP15_MCR_MRC); 1221 } 1222 ''' 1223 dmbIop = InstObjParams("dmb", "Dmb", "ImmOp", 1224 {"code": dmbCode, 1225 "predicate_test": predicateTest}, 1226 ['IsMemBarrier']) 1227 header_output += ImmOpDeclare.subst(dmbIop) 1228 decoder_output += ImmOpConstructor.subst(dmbIop) 1229 exec_output += PredOpExecute.subst(dmbIop) 1230 1231 dbgCode = ''' 1232 ''' 1233 dbgIop = InstObjParams("dbg", "Dbg", "PredOp", 1234 {"code": dbgCode, 1235 "predicate_test": predicateTest}) 1236 header_output += BasicDeclare.subst(dbgIop) 1237 decoder_output += BasicConstructor.subst(dbgIop) 1238 exec_output += PredOpExecute.subst(dbgIop) 1239 1240 cpsCode = ''' 1241 uint32_t mode = bits(imm, 4, 0); 1242 uint32_t f = bits(imm, 5); 1243 uint32_t i = bits(imm, 6); 1244 uint32_t a = bits(imm, 7); 1245 bool setMode = bits(imm, 8); 1246 bool enable = bits(imm, 9); 1247 CPSR cpsr = Cpsr; 1248 SCTLR sctlr = Sctlr; 1249 if (cpsr.mode != MODE_USER) { 1250 if (enable) { 1251 if (f) cpsr.f = 0; 1252 if (i) cpsr.i = 0; 1253 if (a) cpsr.a = 0; 1254 } else { 1255 if (f && !sctlr.nmfi) cpsr.f = 1; 1256 if (i) cpsr.i = 1; 1257 if (a) cpsr.a = 1; 1258 } 1259 if (setMode) { 1260 cpsr.mode = mode; 1261 } 1262 } 1263 Cpsr = cpsr; 1264 ''' 1265 cpsIop = InstObjParams("cps", "Cps", "ImmOp", 1266 { "code": cpsCode, 1267 "predicate_test": predicateTest }, 1268 ["IsSerializeAfter","IsNonSpeculative"]) 1269 header_output += ImmOpDeclare.subst(cpsIop) 1270 decoder_output += ImmOpConstructor.subst(cpsIop) 1271 exec_output += PredOpExecute.subst(cpsIop) 1272}};
|