1 //===- X86RecognizableInstr.cpp - Disassembler instruction spec --*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file is part of the X86 Disassembler Emitter. 11 // It contains the implementation of a single recognizable instruction. 12 // Documentation for the disassembler emitter in general can be found in 13 // X86DisasemblerEmitter.h. 14 // 15 //===----------------------------------------------------------------------===// 16 17 #include "X86RecognizableInstr.h" 18 #include "X86DisassemblerShared.h" 19 #include "X86ModRMFilters.h" 20 #include "llvm/Support/ErrorHandling.h" 21 #include <string> 22 23 using namespace llvm; 24 25 #define MRM_MAPPING \ 26 MAP(C0, 64) \ 27 MAP(C1, 65) \ 28 MAP(C2, 66) \ 29 MAP(C3, 67) \ 30 MAP(C4, 68) \ 31 MAP(C5, 69) \ 32 MAP(C6, 70) \ 33 MAP(C7, 71) \ 34 MAP(C8, 72) \ 35 MAP(C9, 73) \ 36 MAP(CA, 74) \ 37 MAP(CB, 75) \ 38 MAP(CC, 76) \ 39 MAP(CD, 77) \ 40 MAP(CE, 78) \ 41 MAP(CF, 79) \ 42 MAP(D0, 80) \ 43 MAP(D1, 81) \ 44 MAP(D2, 82) \ 45 MAP(D3, 83) \ 46 MAP(D4, 84) \ 47 MAP(D5, 85) \ 48 MAP(D6, 86) \ 49 MAP(D7, 87) \ 50 MAP(D8, 88) \ 51 MAP(D9, 89) \ 52 MAP(DA, 90) \ 53 MAP(DB, 91) \ 54 MAP(DC, 92) \ 55 MAP(DD, 93) \ 56 MAP(DE, 94) \ 57 MAP(DF, 95) \ 58 MAP(E0, 96) \ 59 MAP(E1, 97) \ 60 MAP(E2, 98) \ 61 MAP(E3, 99) \ 62 MAP(E4, 100) \ 63 MAP(E5, 101) \ 64 MAP(E6, 102) \ 65 MAP(E7, 103) \ 66 MAP(E8, 104) \ 67 MAP(E9, 105) \ 68 MAP(EA, 106) \ 69 MAP(EB, 107) \ 70 MAP(EC, 108) \ 71 MAP(ED, 109) \ 72 MAP(EE, 110) \ 73 MAP(EF, 111) \ 74 MAP(F0, 112) \ 75 MAP(F1, 113) \ 76 MAP(F2, 114) \ 77 MAP(F3, 115) \ 78 MAP(F4, 116) \ 79 MAP(F5, 117) \ 80 MAP(F6, 118) \ 81 MAP(F7, 119) \ 82 MAP(F8, 120) \ 83 MAP(F9, 121) \ 84 MAP(FA, 122) \ 85 MAP(FB, 123) \ 86 MAP(FC, 124) \ 87 MAP(FD, 125) \ 88 MAP(FE, 126) \ 89 MAP(FF, 127) 90 91 // A clone of X86 since we can't depend on something that is generated. 92 namespace X86Local { 93 enum { 94 Pseudo = 0, 95 RawFrm = 1, 96 AddRegFrm = 2, 97 RawFrmMemOffs = 3, 98 RawFrmSrc = 4, 99 RawFrmDst = 5, 100 RawFrmDstSrc = 6, 101 RawFrmImm8 = 7, 102 RawFrmImm16 = 8, 103 MRMDestMem = 32, 104 MRMSrcMem = 33, 105 MRMSrcMem4VOp3 = 34, 106 MRMSrcMemOp4 = 35, 107 MRMXm = 39, 108 MRM0m = 40, MRM1m = 41, MRM2m = 42, MRM3m = 43, 109 MRM4m = 44, MRM5m = 45, MRM6m = 46, MRM7m = 47, 110 MRMDestReg = 48, 111 MRMSrcReg = 49, 112 MRMSrcReg4VOp3 = 50, 113 MRMSrcRegOp4 = 51, 114 MRMXr = 55, 115 MRM0r = 56, MRM1r = 57, MRM2r = 58, MRM3r = 59, 116 MRM4r = 60, MRM5r = 61, MRM6r = 62, MRM7r = 63, 117 #define MAP(from, to) MRM_##from = to, 118 MRM_MAPPING 119 #undef MAP 120 }; 121 122 enum { 123 OB = 0, TB = 1, T8 = 2, TA = 3, XOP8 = 4, XOP9 = 5, XOPA = 6 124 }; 125 126 enum { 127 PS = 1, PD = 2, XS = 3, XD = 4 128 }; 129 130 enum { 131 VEX = 1, XOP = 2, EVEX = 3 132 }; 133 134 enum { 135 OpSize16 = 1, OpSize32 = 2 136 }; 137 138 enum { 139 AdSize16 = 1, AdSize32 = 2, AdSize64 = 3 140 }; 141 } 142 143 using namespace X86Disassembler; 144 145 /// byteFromBitsInit - Extracts a value at most 8 bits in width from a BitsInit. 146 /// Useful for switch statements and the like. 147 /// 148 /// @param init - A reference to the BitsInit to be decoded. 149 /// @return - The field, with the first bit in the BitsInit as the lowest 150 /// order bit. 151 static uint8_t byteFromBitsInit(BitsInit &init) { 152 int width = init.getNumBits(); 153 154 assert(width <= 8 && "Field is too large for uint8_t!"); 155 156 int index; 157 uint8_t mask = 0x01; 158 159 uint8_t ret = 0; 160 161 for (index = 0; index < width; index++) { 162 if (static_cast<BitInit*>(init.getBit(index))->getValue()) 163 ret |= mask; 164 165 mask <<= 1; 166 } 167 168 return ret; 169 } 170 171 /// byteFromRec - Extract a value at most 8 bits in with from a Record given the 172 /// name of the field. 173 /// 174 /// @param rec - The record from which to extract the value. 175 /// @param name - The name of the field in the record. 176 /// @return - The field, as translated by byteFromBitsInit(). 177 static uint8_t byteFromRec(const Record* rec, const std::string &name) { 178 BitsInit* bits = rec->getValueAsBitsInit(name); 179 return byteFromBitsInit(*bits); 180 } 181 182 RecognizableInstr::RecognizableInstr(DisassemblerTables &tables, 183 const CodeGenInstruction &insn, 184 InstrUID uid) { 185 UID = uid; 186 187 Rec = insn.TheDef; 188 Name = Rec->getName(); 189 Spec = &tables.specForUID(UID); 190 191 if (!Rec->isSubClassOf("X86Inst")) { 192 ShouldBeEmitted = false; 193 return; 194 } 195 196 OpPrefix = byteFromRec(Rec, "OpPrefixBits"); 197 OpMap = byteFromRec(Rec, "OpMapBits"); 198 Opcode = byteFromRec(Rec, "Opcode"); 199 Form = byteFromRec(Rec, "FormBits"); 200 Encoding = byteFromRec(Rec, "OpEncBits"); 201 202 OpSize = byteFromRec(Rec, "OpSizeBits"); 203 AdSize = byteFromRec(Rec, "AdSizeBits"); 204 HasREX_WPrefix = Rec->getValueAsBit("hasREX_WPrefix"); 205 HasVEX_4V = Rec->getValueAsBit("hasVEX_4V"); 206 HasVEX_WPrefix = Rec->getValueAsBit("hasVEX_WPrefix"); 207 IgnoresVEX_L = Rec->getValueAsBit("ignoresVEX_L"); 208 HasEVEX_L2Prefix = Rec->getValueAsBit("hasEVEX_L2"); 209 HasEVEX_K = Rec->getValueAsBit("hasEVEX_K"); 210 HasEVEX_KZ = Rec->getValueAsBit("hasEVEX_Z"); 211 HasEVEX_B = Rec->getValueAsBit("hasEVEX_B"); 212 IsCodeGenOnly = Rec->getValueAsBit("isCodeGenOnly"); 213 ForceDisassemble = Rec->getValueAsBit("ForceDisassemble"); 214 CD8_Scale = byteFromRec(Rec, "CD8_Scale"); 215 216 Name = Rec->getName(); 217 218 Operands = &insn.Operands.OperandList; 219 220 HasVEX_LPrefix = Rec->getValueAsBit("hasVEX_L"); 221 222 // Check for 64-bit inst which does not require REX 223 Is32Bit = false; 224 Is64Bit = false; 225 // FIXME: Is there some better way to check for In64BitMode? 226 std::vector<Record*> Predicates = Rec->getValueAsListOfDefs("Predicates"); 227 for (unsigned i = 0, e = Predicates.size(); i != e; ++i) { 228 if (Predicates[i]->getName().find("Not64Bit") != Name.npos || 229 Predicates[i]->getName().find("In32Bit") != Name.npos) { 230 Is32Bit = true; 231 break; 232 } 233 if (Predicates[i]->getName().find("In64Bit") != Name.npos) { 234 Is64Bit = true; 235 break; 236 } 237 } 238 239 if (Form == X86Local::Pseudo || (IsCodeGenOnly && !ForceDisassemble)) { 240 ShouldBeEmitted = false; 241 return; 242 } 243 244 // Special case since there is no attribute class for 64-bit and VEX 245 if (Name == "VMASKMOVDQU64") { 246 ShouldBeEmitted = false; 247 return; 248 } 249 250 ShouldBeEmitted = true; 251 } 252 253 void RecognizableInstr::processInstr(DisassemblerTables &tables, 254 const CodeGenInstruction &insn, 255 InstrUID uid) 256 { 257 // Ignore "asm parser only" instructions. 258 if (insn.TheDef->getValueAsBit("isAsmParserOnly")) 259 return; 260 261 RecognizableInstr recogInstr(tables, insn, uid); 262 263 if (recogInstr.shouldBeEmitted()) { 264 recogInstr.emitInstructionSpecifier(); 265 recogInstr.emitDecodePath(tables); 266 } 267 } 268 269 #define EVEX_KB(n) (HasEVEX_KZ && HasEVEX_B ? n##_KZ_B : \ 270 (HasEVEX_K && HasEVEX_B ? n##_K_B : \ 271 (HasEVEX_KZ ? n##_KZ : \ 272 (HasEVEX_K? n##_K : (HasEVEX_B ? n##_B : n))))) 273 274 InstructionContext RecognizableInstr::insnContext() const { 275 InstructionContext insnContext; 276 277 if (Encoding == X86Local::EVEX) { 278 if (HasVEX_LPrefix && HasEVEX_L2Prefix) { 279 errs() << "Don't support VEX.L if EVEX_L2 is enabled: " << Name << "\n"; 280 llvm_unreachable("Don't support VEX.L if EVEX_L2 is enabled"); 281 } 282 // VEX_L & VEX_W 283 if (HasVEX_LPrefix && HasVEX_WPrefix) { 284 if (OpPrefix == X86Local::PD) 285 insnContext = EVEX_KB(IC_EVEX_L_W_OPSIZE); 286 else if (OpPrefix == X86Local::XS) 287 insnContext = EVEX_KB(IC_EVEX_L_W_XS); 288 else if (OpPrefix == X86Local::XD) 289 insnContext = EVEX_KB(IC_EVEX_L_W_XD); 290 else if (OpPrefix == X86Local::PS) 291 insnContext = EVEX_KB(IC_EVEX_L_W); 292 else { 293 errs() << "Instruction does not use a prefix: " << Name << "\n"; 294 llvm_unreachable("Invalid prefix"); 295 } 296 } else if (HasVEX_LPrefix) { 297 // VEX_L 298 if (OpPrefix == X86Local::PD) 299 insnContext = EVEX_KB(IC_EVEX_L_OPSIZE); 300 else if (OpPrefix == X86Local::XS) 301 insnContext = EVEX_KB(IC_EVEX_L_XS); 302 else if (OpPrefix == X86Local::XD) 303 insnContext = EVEX_KB(IC_EVEX_L_XD); 304 else if (OpPrefix == X86Local::PS) 305 insnContext = EVEX_KB(IC_EVEX_L); 306 else { 307 errs() << "Instruction does not use a prefix: " << Name << "\n"; 308 llvm_unreachable("Invalid prefix"); 309 } 310 } 311 else if (HasEVEX_L2Prefix && HasVEX_WPrefix) { 312 // EVEX_L2 & VEX_W 313 if (OpPrefix == X86Local::PD) 314 insnContext = EVEX_KB(IC_EVEX_L2_W_OPSIZE); 315 else if (OpPrefix == X86Local::XS) 316 insnContext = EVEX_KB(IC_EVEX_L2_W_XS); 317 else if (OpPrefix == X86Local::XD) 318 insnContext = EVEX_KB(IC_EVEX_L2_W_XD); 319 else if (OpPrefix == X86Local::PS) 320 insnContext = EVEX_KB(IC_EVEX_L2_W); 321 else { 322 errs() << "Instruction does not use a prefix: " << Name << "\n"; 323 llvm_unreachable("Invalid prefix"); 324 } 325 } else if (HasEVEX_L2Prefix) { 326 // EVEX_L2 327 if (OpPrefix == X86Local::PD) 328 insnContext = EVEX_KB(IC_EVEX_L2_OPSIZE); 329 else if (OpPrefix == X86Local::XD) 330 insnContext = EVEX_KB(IC_EVEX_L2_XD); 331 else if (OpPrefix == X86Local::XS) 332 insnContext = EVEX_KB(IC_EVEX_L2_XS); 333 else if (OpPrefix == X86Local::PS) 334 insnContext = EVEX_KB(IC_EVEX_L2); 335 else { 336 errs() << "Instruction does not use a prefix: " << Name << "\n"; 337 llvm_unreachable("Invalid prefix"); 338 } 339 } 340 else if (HasVEX_WPrefix) { 341 // VEX_W 342 if (OpPrefix == X86Local::PD) 343 insnContext = EVEX_KB(IC_EVEX_W_OPSIZE); 344 else if (OpPrefix == X86Local::XS) 345 insnContext = EVEX_KB(IC_EVEX_W_XS); 346 else if (OpPrefix == X86Local::XD) 347 insnContext = EVEX_KB(IC_EVEX_W_XD); 348 else if (OpPrefix == X86Local::PS) 349 insnContext = EVEX_KB(IC_EVEX_W); 350 else { 351 errs() << "Instruction does not use a prefix: " << Name << "\n"; 352 llvm_unreachable("Invalid prefix"); 353 } 354 } 355 // No L, no W 356 else if (OpPrefix == X86Local::PD) 357 insnContext = EVEX_KB(IC_EVEX_OPSIZE); 358 else if (OpPrefix == X86Local::XD) 359 insnContext = EVEX_KB(IC_EVEX_XD); 360 else if (OpPrefix == X86Local::XS) 361 insnContext = EVEX_KB(IC_EVEX_XS); 362 else 363 insnContext = EVEX_KB(IC_EVEX); 364 /// eof EVEX 365 } else if (Encoding == X86Local::VEX || Encoding == X86Local::XOP) { 366 if (HasVEX_LPrefix && HasVEX_WPrefix) { 367 if (OpPrefix == X86Local::PD) 368 insnContext = IC_VEX_L_W_OPSIZE; 369 else if (OpPrefix == X86Local::XS) 370 insnContext = IC_VEX_L_W_XS; 371 else if (OpPrefix == X86Local::XD) 372 insnContext = IC_VEX_L_W_XD; 373 else if (OpPrefix == X86Local::PS) 374 insnContext = IC_VEX_L_W; 375 else { 376 errs() << "Instruction does not use a prefix: " << Name << "\n"; 377 llvm_unreachable("Invalid prefix"); 378 } 379 } else if (OpPrefix == X86Local::PD && HasVEX_LPrefix) 380 insnContext = IC_VEX_L_OPSIZE; 381 else if (OpPrefix == X86Local::PD && HasVEX_WPrefix) 382 insnContext = IC_VEX_W_OPSIZE; 383 else if (OpPrefix == X86Local::PD) 384 insnContext = IC_VEX_OPSIZE; 385 else if (HasVEX_LPrefix && OpPrefix == X86Local::XS) 386 insnContext = IC_VEX_L_XS; 387 else if (HasVEX_LPrefix && OpPrefix == X86Local::XD) 388 insnContext = IC_VEX_L_XD; 389 else if (HasVEX_WPrefix && OpPrefix == X86Local::XS) 390 insnContext = IC_VEX_W_XS; 391 else if (HasVEX_WPrefix && OpPrefix == X86Local::XD) 392 insnContext = IC_VEX_W_XD; 393 else if (HasVEX_WPrefix && OpPrefix == X86Local::PS) 394 insnContext = IC_VEX_W; 395 else if (HasVEX_LPrefix && OpPrefix == X86Local::PS) 396 insnContext = IC_VEX_L; 397 else if (OpPrefix == X86Local::XD) 398 insnContext = IC_VEX_XD; 399 else if (OpPrefix == X86Local::XS) 400 insnContext = IC_VEX_XS; 401 else if (OpPrefix == X86Local::PS) 402 insnContext = IC_VEX; 403 else { 404 errs() << "Instruction does not use a prefix: " << Name << "\n"; 405 llvm_unreachable("Invalid prefix"); 406 } 407 } else if (Is64Bit || HasREX_WPrefix || AdSize == X86Local::AdSize64) { 408 if (HasREX_WPrefix && (OpSize == X86Local::OpSize16 || OpPrefix == X86Local::PD)) 409 insnContext = IC_64BIT_REXW_OPSIZE; 410 else if (HasREX_WPrefix && AdSize == X86Local::AdSize32) 411 insnContext = IC_64BIT_REXW_ADSIZE; 412 else if (OpSize == X86Local::OpSize16 && OpPrefix == X86Local::XD) 413 insnContext = IC_64BIT_XD_OPSIZE; 414 else if (OpSize == X86Local::OpSize16 && OpPrefix == X86Local::XS) 415 insnContext = IC_64BIT_XS_OPSIZE; 416 else if (OpSize == X86Local::OpSize16 && AdSize == X86Local::AdSize32) 417 insnContext = IC_64BIT_OPSIZE_ADSIZE; 418 else if (OpSize == X86Local::OpSize16 || OpPrefix == X86Local::PD) 419 insnContext = IC_64BIT_OPSIZE; 420 else if (AdSize == X86Local::AdSize32) 421 insnContext = IC_64BIT_ADSIZE; 422 else if (HasREX_WPrefix && OpPrefix == X86Local::XS) 423 insnContext = IC_64BIT_REXW_XS; 424 else if (HasREX_WPrefix && OpPrefix == X86Local::XD) 425 insnContext = IC_64BIT_REXW_XD; 426 else if (OpPrefix == X86Local::XD) 427 insnContext = IC_64BIT_XD; 428 else if (OpPrefix == X86Local::XS) 429 insnContext = IC_64BIT_XS; 430 else if (HasREX_WPrefix) 431 insnContext = IC_64BIT_REXW; 432 else 433 insnContext = IC_64BIT; 434 } else { 435 if (OpSize == X86Local::OpSize16 && OpPrefix == X86Local::XD) 436 insnContext = IC_XD_OPSIZE; 437 else if (OpSize == X86Local::OpSize16 && OpPrefix == X86Local::XS) 438 insnContext = IC_XS_OPSIZE; 439 else if (OpSize == X86Local::OpSize16 && AdSize == X86Local::AdSize16) 440 insnContext = IC_OPSIZE_ADSIZE; 441 else if (OpSize == X86Local::OpSize16 || OpPrefix == X86Local::PD) 442 insnContext = IC_OPSIZE; 443 else if (AdSize == X86Local::AdSize16) 444 insnContext = IC_ADSIZE; 445 else if (OpPrefix == X86Local::XD) 446 insnContext = IC_XD; 447 else if (OpPrefix == X86Local::XS) 448 insnContext = IC_XS; 449 else 450 insnContext = IC; 451 } 452 453 return insnContext; 454 } 455 456 void RecognizableInstr::adjustOperandEncoding(OperandEncoding &encoding) { 457 // The scaling factor for AVX512 compressed displacement encoding is an 458 // instruction attribute. Adjust the ModRM encoding type to include the 459 // scale for compressed displacement. 460 if (encoding != ENCODING_RM || CD8_Scale == 0) 461 return; 462 encoding = (OperandEncoding)(encoding + Log2_32(CD8_Scale)); 463 assert(encoding <= ENCODING_RM_CD64 && "Invalid CDisp scaling"); 464 } 465 466 void RecognizableInstr::handleOperand(bool optional, unsigned &operandIndex, 467 unsigned &physicalOperandIndex, 468 unsigned numPhysicalOperands, 469 const unsigned *operandMapping, 470 OperandEncoding (*encodingFromString) 471 (const std::string&, 472 uint8_t OpSize)) { 473 if (optional) { 474 if (physicalOperandIndex >= numPhysicalOperands) 475 return; 476 } else { 477 assert(physicalOperandIndex < numPhysicalOperands); 478 } 479 480 while (operandMapping[operandIndex] != operandIndex) { 481 Spec->operands[operandIndex].encoding = ENCODING_DUP; 482 Spec->operands[operandIndex].type = 483 (OperandType)(TYPE_DUP0 + operandMapping[operandIndex]); 484 ++operandIndex; 485 } 486 487 const std::string &typeName = (*Operands)[operandIndex].Rec->getName(); 488 489 OperandEncoding encoding = encodingFromString(typeName, OpSize); 490 // Adjust the encoding type for an operand based on the instruction. 491 adjustOperandEncoding(encoding); 492 Spec->operands[operandIndex].encoding = encoding; 493 Spec->operands[operandIndex].type = typeFromString(typeName, 494 HasREX_WPrefix, OpSize); 495 496 ++operandIndex; 497 ++physicalOperandIndex; 498 } 499 500 void RecognizableInstr::emitInstructionSpecifier() { 501 Spec->name = Name; 502 503 Spec->insnContext = insnContext(); 504 505 const std::vector<CGIOperandList::OperandInfo> &OperandList = *Operands; 506 507 unsigned numOperands = OperandList.size(); 508 unsigned numPhysicalOperands = 0; 509 510 // operandMapping maps from operands in OperandList to their originals. 511 // If operandMapping[i] != i, then the entry is a duplicate. 512 unsigned operandMapping[X86_MAX_OPERANDS]; 513 assert(numOperands <= X86_MAX_OPERANDS && "X86_MAX_OPERANDS is not large enough"); 514 515 for (unsigned operandIndex = 0; operandIndex < numOperands; ++operandIndex) { 516 if (!OperandList[operandIndex].Constraints.empty()) { 517 const CGIOperandList::ConstraintInfo &Constraint = 518 OperandList[operandIndex].Constraints[0]; 519 if (Constraint.isTied()) { 520 operandMapping[operandIndex] = operandIndex; 521 operandMapping[Constraint.getTiedOperand()] = operandIndex; 522 } else { 523 ++numPhysicalOperands; 524 operandMapping[operandIndex] = operandIndex; 525 } 526 } else { 527 ++numPhysicalOperands; 528 operandMapping[operandIndex] = operandIndex; 529 } 530 } 531 532 #define HANDLE_OPERAND(class) \ 533 handleOperand(false, \ 534 operandIndex, \ 535 physicalOperandIndex, \ 536 numPhysicalOperands, \ 537 operandMapping, \ 538 class##EncodingFromString); 539 540 #define HANDLE_OPTIONAL(class) \ 541 handleOperand(true, \ 542 operandIndex, \ 543 physicalOperandIndex, \ 544 numPhysicalOperands, \ 545 operandMapping, \ 546 class##EncodingFromString); 547 548 // operandIndex should always be < numOperands 549 unsigned operandIndex = 0; 550 // physicalOperandIndex should always be < numPhysicalOperands 551 unsigned physicalOperandIndex = 0; 552 553 #ifndef NDEBUG 554 // Given the set of prefix bits, how many additional operands does the 555 // instruction have? 556 unsigned additionalOperands = 0; 557 if (HasVEX_4V) 558 ++additionalOperands; 559 if (HasEVEX_K) 560 ++additionalOperands; 561 #endif 562 563 switch (Form) { 564 default: llvm_unreachable("Unhandled form"); 565 case X86Local::RawFrmSrc: 566 HANDLE_OPERAND(relocation); 567 return; 568 case X86Local::RawFrmDst: 569 HANDLE_OPERAND(relocation); 570 return; 571 case X86Local::RawFrmDstSrc: 572 HANDLE_OPERAND(relocation); 573 HANDLE_OPERAND(relocation); 574 return; 575 case X86Local::RawFrm: 576 // Operand 1 (optional) is an address or immediate. 577 assert(numPhysicalOperands <= 1 && 578 "Unexpected number of operands for RawFrm"); 579 HANDLE_OPTIONAL(relocation) 580 break; 581 case X86Local::RawFrmMemOffs: 582 // Operand 1 is an address. 583 HANDLE_OPERAND(relocation); 584 break; 585 case X86Local::AddRegFrm: 586 // Operand 1 is added to the opcode. 587 // Operand 2 (optional) is an address. 588 assert(numPhysicalOperands >= 1 && numPhysicalOperands <= 2 && 589 "Unexpected number of operands for AddRegFrm"); 590 HANDLE_OPERAND(opcodeModifier) 591 HANDLE_OPTIONAL(relocation) 592 break; 593 case X86Local::MRMDestReg: 594 // Operand 1 is a register operand in the R/M field. 595 // - In AVX512 there may be a mask operand here - 596 // Operand 2 is a register operand in the Reg/Opcode field. 597 // - In AVX, there is a register operand in the VEX.vvvv field here - 598 // Operand 3 (optional) is an immediate. 599 assert(numPhysicalOperands >= 2 + additionalOperands && 600 numPhysicalOperands <= 3 + additionalOperands && 601 "Unexpected number of operands for MRMDestRegFrm"); 602 603 HANDLE_OPERAND(rmRegister) 604 if (HasEVEX_K) 605 HANDLE_OPERAND(writemaskRegister) 606 607 if (HasVEX_4V) 608 // FIXME: In AVX, the register below becomes the one encoded 609 // in ModRMVEX and the one above the one in the VEX.VVVV field 610 HANDLE_OPERAND(vvvvRegister) 611 612 HANDLE_OPERAND(roRegister) 613 HANDLE_OPTIONAL(immediate) 614 break; 615 case X86Local::MRMDestMem: 616 // Operand 1 is a memory operand (possibly SIB-extended) 617 // Operand 2 is a register operand in the Reg/Opcode field. 618 // - In AVX, there is a register operand in the VEX.vvvv field here - 619 // Operand 3 (optional) is an immediate. 620 assert(numPhysicalOperands >= 2 + additionalOperands && 621 numPhysicalOperands <= 3 + additionalOperands && 622 "Unexpected number of operands for MRMDestMemFrm with VEX_4V"); 623 624 HANDLE_OPERAND(memory) 625 626 if (HasEVEX_K) 627 HANDLE_OPERAND(writemaskRegister) 628 629 if (HasVEX_4V) 630 // FIXME: In AVX, the register below becomes the one encoded 631 // in ModRMVEX and the one above the one in the VEX.VVVV field 632 HANDLE_OPERAND(vvvvRegister) 633 634 HANDLE_OPERAND(roRegister) 635 HANDLE_OPTIONAL(immediate) 636 break; 637 case X86Local::MRMSrcReg: 638 // Operand 1 is a register operand in the Reg/Opcode field. 639 // Operand 2 is a register operand in the R/M field. 640 // - In AVX, there is a register operand in the VEX.vvvv field here - 641 // Operand 3 (optional) is an immediate. 642 // Operand 4 (optional) is an immediate. 643 644 assert(numPhysicalOperands >= 2 + additionalOperands && 645 numPhysicalOperands <= 4 + additionalOperands && 646 "Unexpected number of operands for MRMSrcRegFrm"); 647 648 HANDLE_OPERAND(roRegister) 649 650 if (HasEVEX_K) 651 HANDLE_OPERAND(writemaskRegister) 652 653 if (HasVEX_4V) 654 // FIXME: In AVX, the register below becomes the one encoded 655 // in ModRMVEX and the one above the one in the VEX.VVVV field 656 HANDLE_OPERAND(vvvvRegister) 657 658 HANDLE_OPERAND(rmRegister) 659 HANDLE_OPTIONAL(immediate) 660 HANDLE_OPTIONAL(immediate) // above might be a register in 7:4 661 HANDLE_OPTIONAL(immediate) 662 break; 663 case X86Local::MRMSrcReg4VOp3: 664 assert(numPhysicalOperands == 3 && 665 "Unexpected number of operands for MRMSrcRegFrm"); 666 HANDLE_OPERAND(roRegister) 667 HANDLE_OPERAND(rmRegister) 668 HANDLE_OPERAND(vvvvRegister) 669 break; 670 case X86Local::MRMSrcRegOp4: 671 assert(numPhysicalOperands >= 4 && numPhysicalOperands <= 5 && 672 "Unexpected number of operands for MRMSrcRegOp4Frm"); 673 HANDLE_OPERAND(roRegister) 674 HANDLE_OPERAND(vvvvRegister) 675 HANDLE_OPERAND(immediate) // Register in imm[7:4] 676 HANDLE_OPERAND(rmRegister) 677 HANDLE_OPTIONAL(immediate) 678 break; 679 case X86Local::MRMSrcMem: 680 // Operand 1 is a register operand in the Reg/Opcode field. 681 // Operand 2 is a memory operand (possibly SIB-extended) 682 // - In AVX, there is a register operand in the VEX.vvvv field here - 683 // Operand 3 (optional) is an immediate. 684 685 assert(numPhysicalOperands >= 2 + additionalOperands && 686 numPhysicalOperands <= 4 + additionalOperands && 687 "Unexpected number of operands for MRMSrcMemFrm"); 688 689 HANDLE_OPERAND(roRegister) 690 691 if (HasEVEX_K) 692 HANDLE_OPERAND(writemaskRegister) 693 694 if (HasVEX_4V) 695 // FIXME: In AVX, the register below becomes the one encoded 696 // in ModRMVEX and the one above the one in the VEX.VVVV field 697 HANDLE_OPERAND(vvvvRegister) 698 699 HANDLE_OPERAND(memory) 700 HANDLE_OPTIONAL(immediate) 701 HANDLE_OPTIONAL(immediate) // above might be a register in 7:4 702 break; 703 case X86Local::MRMSrcMem4VOp3: 704 assert(numPhysicalOperands == 3 && 705 "Unexpected number of operands for MRMSrcMemFrm"); 706 HANDLE_OPERAND(roRegister) 707 HANDLE_OPERAND(memory) 708 HANDLE_OPERAND(vvvvRegister) 709 break; 710 case X86Local::MRMSrcMemOp4: 711 assert(numPhysicalOperands >= 4 && numPhysicalOperands <= 5 && 712 "Unexpected number of operands for MRMSrcMemOp4Frm"); 713 HANDLE_OPERAND(roRegister) 714 HANDLE_OPERAND(vvvvRegister) 715 HANDLE_OPERAND(immediate) // Register in imm[7:4] 716 HANDLE_OPERAND(memory) 717 HANDLE_OPTIONAL(immediate) 718 break; 719 case X86Local::MRMXr: 720 case X86Local::MRM0r: 721 case X86Local::MRM1r: 722 case X86Local::MRM2r: 723 case X86Local::MRM3r: 724 case X86Local::MRM4r: 725 case X86Local::MRM5r: 726 case X86Local::MRM6r: 727 case X86Local::MRM7r: 728 // Operand 1 is a register operand in the R/M field. 729 // Operand 2 (optional) is an immediate or relocation. 730 // Operand 3 (optional) is an immediate. 731 assert(numPhysicalOperands >= 0 + additionalOperands && 732 numPhysicalOperands <= 3 + additionalOperands && 733 "Unexpected number of operands for MRMnr"); 734 735 if (HasVEX_4V) 736 HANDLE_OPERAND(vvvvRegister) 737 738 if (HasEVEX_K) 739 HANDLE_OPERAND(writemaskRegister) 740 HANDLE_OPTIONAL(rmRegister) 741 HANDLE_OPTIONAL(relocation) 742 HANDLE_OPTIONAL(immediate) 743 break; 744 case X86Local::MRMXm: 745 case X86Local::MRM0m: 746 case X86Local::MRM1m: 747 case X86Local::MRM2m: 748 case X86Local::MRM3m: 749 case X86Local::MRM4m: 750 case X86Local::MRM5m: 751 case X86Local::MRM6m: 752 case X86Local::MRM7m: 753 // Operand 1 is a memory operand (possibly SIB-extended) 754 // Operand 2 (optional) is an immediate or relocation. 755 assert(numPhysicalOperands >= 1 + additionalOperands && 756 numPhysicalOperands <= 2 + additionalOperands && 757 "Unexpected number of operands for MRMnm"); 758 759 if (HasVEX_4V) 760 HANDLE_OPERAND(vvvvRegister) 761 if (HasEVEX_K) 762 HANDLE_OPERAND(writemaskRegister) 763 HANDLE_OPERAND(memory) 764 HANDLE_OPTIONAL(relocation) 765 break; 766 case X86Local::RawFrmImm8: 767 // operand 1 is a 16-bit immediate 768 // operand 2 is an 8-bit immediate 769 assert(numPhysicalOperands == 2 && 770 "Unexpected number of operands for X86Local::RawFrmImm8"); 771 HANDLE_OPERAND(immediate) 772 HANDLE_OPERAND(immediate) 773 break; 774 case X86Local::RawFrmImm16: 775 // operand 1 is a 16-bit immediate 776 // operand 2 is a 16-bit immediate 777 HANDLE_OPERAND(immediate) 778 HANDLE_OPERAND(immediate) 779 break; 780 case X86Local::MRM_F8: 781 if (Opcode == 0xc6) { 782 assert(numPhysicalOperands == 1 && 783 "Unexpected number of operands for X86Local::MRM_F8"); 784 HANDLE_OPERAND(immediate) 785 } else if (Opcode == 0xc7) { 786 assert(numPhysicalOperands == 1 && 787 "Unexpected number of operands for X86Local::MRM_F8"); 788 HANDLE_OPERAND(relocation) 789 } 790 break; 791 case X86Local::MRM_C0: case X86Local::MRM_C1: case X86Local::MRM_C2: 792 case X86Local::MRM_C3: case X86Local::MRM_C4: case X86Local::MRM_C8: 793 case X86Local::MRM_C9: case X86Local::MRM_CA: case X86Local::MRM_CB: 794 case X86Local::MRM_CF: case X86Local::MRM_D0: case X86Local::MRM_D1: 795 case X86Local::MRM_D4: case X86Local::MRM_D5: case X86Local::MRM_D6: 796 case X86Local::MRM_D7: case X86Local::MRM_D8: case X86Local::MRM_D9: 797 case X86Local::MRM_DA: case X86Local::MRM_DB: case X86Local::MRM_DC: 798 case X86Local::MRM_DD: case X86Local::MRM_DE: case X86Local::MRM_DF: 799 case X86Local::MRM_E0: case X86Local::MRM_E1: case X86Local::MRM_E2: 800 case X86Local::MRM_E3: case X86Local::MRM_E4: case X86Local::MRM_E5: 801 case X86Local::MRM_E8: case X86Local::MRM_E9: case X86Local::MRM_EA: 802 case X86Local::MRM_EB: case X86Local::MRM_EC: case X86Local::MRM_ED: 803 case X86Local::MRM_EE: case X86Local::MRM_EF: case X86Local::MRM_F0: 804 case X86Local::MRM_F1: case X86Local::MRM_F2: case X86Local::MRM_F3: 805 case X86Local::MRM_F4: case X86Local::MRM_F5: case X86Local::MRM_F6: 806 case X86Local::MRM_F7: case X86Local::MRM_F9: case X86Local::MRM_FA: 807 case X86Local::MRM_FB: case X86Local::MRM_FC: case X86Local::MRM_FD: 808 case X86Local::MRM_FE: case X86Local::MRM_FF: 809 // Ignored. 810 break; 811 } 812 813 #undef HANDLE_OPERAND 814 #undef HANDLE_OPTIONAL 815 } 816 817 void RecognizableInstr::emitDecodePath(DisassemblerTables &tables) const { 818 // Special cases where the LLVM tables are not complete 819 820 #define MAP(from, to) \ 821 case X86Local::MRM_##from: 822 823 OpcodeType opcodeType = (OpcodeType)-1; 824 825 ModRMFilter* filter = nullptr; 826 uint8_t opcodeToSet = 0; 827 828 switch (OpMap) { 829 default: llvm_unreachable("Invalid map!"); 830 case X86Local::OB: 831 case X86Local::TB: 832 case X86Local::T8: 833 case X86Local::TA: 834 case X86Local::XOP8: 835 case X86Local::XOP9: 836 case X86Local::XOPA: 837 switch (OpMap) { 838 default: llvm_unreachable("Unexpected map!"); 839 case X86Local::OB: opcodeType = ONEBYTE; break; 840 case X86Local::TB: opcodeType = TWOBYTE; break; 841 case X86Local::T8: opcodeType = THREEBYTE_38; break; 842 case X86Local::TA: opcodeType = THREEBYTE_3A; break; 843 case X86Local::XOP8: opcodeType = XOP8_MAP; break; 844 case X86Local::XOP9: opcodeType = XOP9_MAP; break; 845 case X86Local::XOPA: opcodeType = XOPA_MAP; break; 846 } 847 848 switch (Form) { 849 default: llvm_unreachable("Invalid form!"); 850 case X86Local::Pseudo: llvm_unreachable("Pseudo should not be emitted!"); 851 case X86Local::RawFrm: 852 case X86Local::AddRegFrm: 853 case X86Local::RawFrmMemOffs: 854 case X86Local::RawFrmSrc: 855 case X86Local::RawFrmDst: 856 case X86Local::RawFrmDstSrc: 857 case X86Local::RawFrmImm8: 858 case X86Local::RawFrmImm16: 859 filter = new DumbFilter(); 860 break; 861 case X86Local::MRMDestReg: 862 case X86Local::MRMSrcReg: 863 case X86Local::MRMSrcReg4VOp3: 864 case X86Local::MRMSrcRegOp4: 865 case X86Local::MRMXr: 866 filter = new ModFilter(true); 867 break; 868 case X86Local::MRMDestMem: 869 case X86Local::MRMSrcMem: 870 case X86Local::MRMSrcMem4VOp3: 871 case X86Local::MRMSrcMemOp4: 872 case X86Local::MRMXm: 873 filter = new ModFilter(false); 874 break; 875 case X86Local::MRM0r: case X86Local::MRM1r: 876 case X86Local::MRM2r: case X86Local::MRM3r: 877 case X86Local::MRM4r: case X86Local::MRM5r: 878 case X86Local::MRM6r: case X86Local::MRM7r: 879 filter = new ExtendedFilter(true, Form - X86Local::MRM0r); 880 break; 881 case X86Local::MRM0m: case X86Local::MRM1m: 882 case X86Local::MRM2m: case X86Local::MRM3m: 883 case X86Local::MRM4m: case X86Local::MRM5m: 884 case X86Local::MRM6m: case X86Local::MRM7m: 885 filter = new ExtendedFilter(false, Form - X86Local::MRM0m); 886 break; 887 MRM_MAPPING 888 filter = new ExactFilter(0xC0 + Form - X86Local::MRM_C0); \ 889 break; 890 } // switch (Form) 891 892 opcodeToSet = Opcode; 893 break; 894 } // switch (OpMap) 895 896 unsigned AddressSize = 0; 897 switch (AdSize) { 898 case X86Local::AdSize16: AddressSize = 16; break; 899 case X86Local::AdSize32: AddressSize = 32; break; 900 case X86Local::AdSize64: AddressSize = 64; break; 901 } 902 903 assert(opcodeType != (OpcodeType)-1 && 904 "Opcode type not set"); 905 assert(filter && "Filter not set"); 906 907 if (Form == X86Local::AddRegFrm) { 908 assert(((opcodeToSet & 7) == 0) && 909 "ADDREG_FRM opcode not aligned"); 910 911 uint8_t currentOpcode; 912 913 for (currentOpcode = opcodeToSet; 914 currentOpcode < opcodeToSet + 8; 915 ++currentOpcode) 916 tables.setTableFields(opcodeType, 917 insnContext(), 918 currentOpcode, 919 *filter, 920 UID, Is32Bit, IgnoresVEX_L, AddressSize); 921 } else { 922 tables.setTableFields(opcodeType, 923 insnContext(), 924 opcodeToSet, 925 *filter, 926 UID, Is32Bit, IgnoresVEX_L, AddressSize); 927 } 928 929 delete filter; 930 931 #undef MAP 932 } 933 934 #define TYPE(str, type) if (s == str) return type; 935 OperandType RecognizableInstr::typeFromString(const std::string &s, 936 bool hasREX_WPrefix, 937 uint8_t OpSize) { 938 if(hasREX_WPrefix) { 939 // For instructions with a REX_W prefix, a declared 32-bit register encoding 940 // is special. 941 TYPE("GR32", TYPE_R32) 942 } 943 if(OpSize == X86Local::OpSize16) { 944 // For OpSize16 instructions, a declared 16-bit register or 945 // immediate encoding is special. 946 TYPE("GR16", TYPE_Rv) 947 TYPE("i16imm", TYPE_IMMv) 948 } else if(OpSize == X86Local::OpSize32) { 949 // For OpSize32 instructions, a declared 32-bit register or 950 // immediate encoding is special. 951 TYPE("GR32", TYPE_Rv) 952 } 953 TYPE("i16mem", TYPE_Mv) 954 TYPE("i16imm", TYPE_IMM16) 955 TYPE("i16i8imm", TYPE_IMMv) 956 TYPE("GR16", TYPE_R16) 957 TYPE("i32mem", TYPE_Mv) 958 TYPE("i32imm", TYPE_IMMv) 959 TYPE("i32i8imm", TYPE_IMM32) 960 TYPE("GR32", TYPE_R32) 961 TYPE("GR32orGR64", TYPE_R32) 962 TYPE("i64mem", TYPE_Mv) 963 TYPE("i64i32imm", TYPE_IMM64) 964 TYPE("i64i8imm", TYPE_IMM64) 965 TYPE("GR64", TYPE_R64) 966 TYPE("i8mem", TYPE_M8) 967 TYPE("i8imm", TYPE_IMM8) 968 TYPE("u8imm", TYPE_UIMM8) 969 TYPE("i32u8imm", TYPE_UIMM8) 970 TYPE("GR8", TYPE_R8) 971 TYPE("VR128", TYPE_XMM128) 972 TYPE("VR128X", TYPE_XMM128) 973 TYPE("f128mem", TYPE_M128) 974 TYPE("f256mem", TYPE_M256) 975 TYPE("f512mem", TYPE_M512) 976 TYPE("FR128", TYPE_XMM128) 977 TYPE("FR64", TYPE_XMM64) 978 TYPE("FR64X", TYPE_XMM64) 979 TYPE("f64mem", TYPE_M64FP) 980 TYPE("sdmem", TYPE_M64FP) 981 TYPE("FR32", TYPE_XMM32) 982 TYPE("FR32X", TYPE_XMM32) 983 TYPE("f32mem", TYPE_M32FP) 984 TYPE("ssmem", TYPE_M32FP) 985 TYPE("RST", TYPE_ST) 986 TYPE("i128mem", TYPE_M128) 987 TYPE("i256mem", TYPE_M256) 988 TYPE("i512mem", TYPE_M512) 989 TYPE("i64i32imm_pcrel", TYPE_REL64) 990 TYPE("i16imm_pcrel", TYPE_REL16) 991 TYPE("i32imm_pcrel", TYPE_REL32) 992 TYPE("SSECC", TYPE_IMM3) 993 TYPE("XOPCC", TYPE_IMM3) 994 TYPE("AVXCC", TYPE_IMM5) 995 TYPE("AVX512ICC", TYPE_AVX512ICC) 996 TYPE("AVX512RC", TYPE_IMM32) 997 TYPE("brtarget32", TYPE_RELv) 998 TYPE("brtarget16", TYPE_RELv) 999 TYPE("brtarget8", TYPE_REL8) 1000 TYPE("f80mem", TYPE_M80FP) 1001 TYPE("lea64_32mem", TYPE_LEA) 1002 TYPE("lea64mem", TYPE_LEA) 1003 TYPE("VR64", TYPE_MM64) 1004 TYPE("i64imm", TYPE_IMMv) 1005 TYPE("anymem", TYPE_M) 1006 TYPE("opaque32mem", TYPE_M1616) 1007 TYPE("opaque48mem", TYPE_M1632) 1008 TYPE("opaque80mem", TYPE_M1664) 1009 TYPE("opaque512mem", TYPE_M512) 1010 TYPE("SEGMENT_REG", TYPE_SEGMENTREG) 1011 TYPE("DEBUG_REG", TYPE_DEBUGREG) 1012 TYPE("CONTROL_REG", TYPE_CONTROLREG) 1013 TYPE("srcidx8", TYPE_SRCIDX8) 1014 TYPE("srcidx16", TYPE_SRCIDX16) 1015 TYPE("srcidx32", TYPE_SRCIDX32) 1016 TYPE("srcidx64", TYPE_SRCIDX64) 1017 TYPE("dstidx8", TYPE_DSTIDX8) 1018 TYPE("dstidx16", TYPE_DSTIDX16) 1019 TYPE("dstidx32", TYPE_DSTIDX32) 1020 TYPE("dstidx64", TYPE_DSTIDX64) 1021 TYPE("offset16_8", TYPE_MOFFS8) 1022 TYPE("offset16_16", TYPE_MOFFS16) 1023 TYPE("offset16_32", TYPE_MOFFS32) 1024 TYPE("offset32_8", TYPE_MOFFS8) 1025 TYPE("offset32_16", TYPE_MOFFS16) 1026 TYPE("offset32_32", TYPE_MOFFS32) 1027 TYPE("offset32_64", TYPE_MOFFS64) 1028 TYPE("offset64_8", TYPE_MOFFS8) 1029 TYPE("offset64_16", TYPE_MOFFS16) 1030 TYPE("offset64_32", TYPE_MOFFS32) 1031 TYPE("offset64_64", TYPE_MOFFS64) 1032 TYPE("VR256", TYPE_XMM256) 1033 TYPE("VR256X", TYPE_XMM256) 1034 TYPE("VR512", TYPE_XMM512) 1035 TYPE("VK1", TYPE_VK1) 1036 TYPE("VK1WM", TYPE_VK1) 1037 TYPE("VK2", TYPE_VK2) 1038 TYPE("VK2WM", TYPE_VK2) 1039 TYPE("VK4", TYPE_VK4) 1040 TYPE("VK4WM", TYPE_VK4) 1041 TYPE("VK8", TYPE_VK8) 1042 TYPE("VK8WM", TYPE_VK8) 1043 TYPE("VK16", TYPE_VK16) 1044 TYPE("VK16WM", TYPE_VK16) 1045 TYPE("VK32", TYPE_VK32) 1046 TYPE("VK32WM", TYPE_VK32) 1047 TYPE("VK64", TYPE_VK64) 1048 TYPE("VK64WM", TYPE_VK64) 1049 TYPE("GR32_NOAX", TYPE_Rv) 1050 TYPE("vx64mem", TYPE_M64) 1051 TYPE("vx128mem", TYPE_M128) 1052 TYPE("vx256mem", TYPE_M256) 1053 TYPE("vy128mem", TYPE_M128) 1054 TYPE("vy256mem", TYPE_M256) 1055 TYPE("vx64xmem", TYPE_M64) 1056 TYPE("vx128xmem", TYPE_M128) 1057 TYPE("vx256xmem", TYPE_M256) 1058 TYPE("vy128xmem", TYPE_M128) 1059 TYPE("vy256xmem", TYPE_M256) 1060 TYPE("vy512mem", TYPE_M512) 1061 TYPE("vz512mem", TYPE_M512) 1062 TYPE("BNDR", TYPE_BNDR) 1063 errs() << "Unhandled type string " << s << "\n"; 1064 llvm_unreachable("Unhandled type string"); 1065 } 1066 #undef TYPE 1067 1068 #define ENCODING(str, encoding) if (s == str) return encoding; 1069 OperandEncoding 1070 RecognizableInstr::immediateEncodingFromString(const std::string &s, 1071 uint8_t OpSize) { 1072 if(OpSize != X86Local::OpSize16) { 1073 // For instructions without an OpSize prefix, a declared 16-bit register or 1074 // immediate encoding is special. 1075 ENCODING("i16imm", ENCODING_IW) 1076 } 1077 ENCODING("i32i8imm", ENCODING_IB) 1078 ENCODING("SSECC", ENCODING_IB) 1079 ENCODING("XOPCC", ENCODING_IB) 1080 ENCODING("AVXCC", ENCODING_IB) 1081 ENCODING("AVX512ICC", ENCODING_IB) 1082 ENCODING("AVX512RC", ENCODING_IB) 1083 ENCODING("i16imm", ENCODING_Iv) 1084 ENCODING("i16i8imm", ENCODING_IB) 1085 ENCODING("i32imm", ENCODING_Iv) 1086 ENCODING("i64i32imm", ENCODING_ID) 1087 ENCODING("i64i8imm", ENCODING_IB) 1088 ENCODING("i8imm", ENCODING_IB) 1089 ENCODING("u8imm", ENCODING_IB) 1090 ENCODING("i32u8imm", ENCODING_IB) 1091 // This is not a typo. Instructions like BLENDVPD put 1092 // register IDs in 8-bit immediates nowadays. 1093 ENCODING("FR32", ENCODING_IB) 1094 ENCODING("FR64", ENCODING_IB) 1095 ENCODING("FR128", ENCODING_IB) 1096 ENCODING("VR128", ENCODING_IB) 1097 ENCODING("VR256", ENCODING_IB) 1098 ENCODING("FR32X", ENCODING_IB) 1099 ENCODING("FR64X", ENCODING_IB) 1100 ENCODING("VR128X", ENCODING_IB) 1101 ENCODING("VR256X", ENCODING_IB) 1102 ENCODING("VR512", ENCODING_IB) 1103 errs() << "Unhandled immediate encoding " << s << "\n"; 1104 llvm_unreachable("Unhandled immediate encoding"); 1105 } 1106 1107 OperandEncoding 1108 RecognizableInstr::rmRegisterEncodingFromString(const std::string &s, 1109 uint8_t OpSize) { 1110 ENCODING("RST", ENCODING_FP) 1111 ENCODING("GR16", ENCODING_RM) 1112 ENCODING("GR32", ENCODING_RM) 1113 ENCODING("GR32orGR64", ENCODING_RM) 1114 ENCODING("GR64", ENCODING_RM) 1115 ENCODING("GR8", ENCODING_RM) 1116 ENCODING("VR128", ENCODING_RM) 1117 ENCODING("VR128X", ENCODING_RM) 1118 ENCODING("FR128", ENCODING_RM) 1119 ENCODING("FR64", ENCODING_RM) 1120 ENCODING("FR32", ENCODING_RM) 1121 ENCODING("FR64X", ENCODING_RM) 1122 ENCODING("FR32X", ENCODING_RM) 1123 ENCODING("VR64", ENCODING_RM) 1124 ENCODING("VR256", ENCODING_RM) 1125 ENCODING("VR256X", ENCODING_RM) 1126 ENCODING("VR512", ENCODING_RM) 1127 ENCODING("VK1", ENCODING_RM) 1128 ENCODING("VK2", ENCODING_RM) 1129 ENCODING("VK4", ENCODING_RM) 1130 ENCODING("VK8", ENCODING_RM) 1131 ENCODING("VK16", ENCODING_RM) 1132 ENCODING("VK32", ENCODING_RM) 1133 ENCODING("VK64", ENCODING_RM) 1134 ENCODING("BNDR", ENCODING_RM) 1135 errs() << "Unhandled R/M register encoding " << s << "\n"; 1136 llvm_unreachable("Unhandled R/M register encoding"); 1137 } 1138 1139 OperandEncoding 1140 RecognizableInstr::roRegisterEncodingFromString(const std::string &s, 1141 uint8_t OpSize) { 1142 ENCODING("GR16", ENCODING_REG) 1143 ENCODING("GR32", ENCODING_REG) 1144 ENCODING("GR32orGR64", ENCODING_REG) 1145 ENCODING("GR64", ENCODING_REG) 1146 ENCODING("GR8", ENCODING_REG) 1147 ENCODING("VR128", ENCODING_REG) 1148 ENCODING("FR128", ENCODING_REG) 1149 ENCODING("FR64", ENCODING_REG) 1150 ENCODING("FR32", ENCODING_REG) 1151 ENCODING("VR64", ENCODING_REG) 1152 ENCODING("SEGMENT_REG", ENCODING_REG) 1153 ENCODING("DEBUG_REG", ENCODING_REG) 1154 ENCODING("CONTROL_REG", ENCODING_REG) 1155 ENCODING("VR256", ENCODING_REG) 1156 ENCODING("VR256X", ENCODING_REG) 1157 ENCODING("VR128X", ENCODING_REG) 1158 ENCODING("FR64X", ENCODING_REG) 1159 ENCODING("FR32X", ENCODING_REG) 1160 ENCODING("VR512", ENCODING_REG) 1161 ENCODING("VK1", ENCODING_REG) 1162 ENCODING("VK2", ENCODING_REG) 1163 ENCODING("VK4", ENCODING_REG) 1164 ENCODING("VK8", ENCODING_REG) 1165 ENCODING("VK16", ENCODING_REG) 1166 ENCODING("VK32", ENCODING_REG) 1167 ENCODING("VK64", ENCODING_REG) 1168 ENCODING("VK1WM", ENCODING_REG) 1169 ENCODING("VK2WM", ENCODING_REG) 1170 ENCODING("VK4WM", ENCODING_REG) 1171 ENCODING("VK8WM", ENCODING_REG) 1172 ENCODING("VK16WM", ENCODING_REG) 1173 ENCODING("VK32WM", ENCODING_REG) 1174 ENCODING("VK64WM", ENCODING_REG) 1175 ENCODING("BNDR", ENCODING_REG) 1176 errs() << "Unhandled reg/opcode register encoding " << s << "\n"; 1177 llvm_unreachable("Unhandled reg/opcode register encoding"); 1178 } 1179 1180 OperandEncoding 1181 RecognizableInstr::vvvvRegisterEncodingFromString(const std::string &s, 1182 uint8_t OpSize) { 1183 ENCODING("GR32", ENCODING_VVVV) 1184 ENCODING("GR64", ENCODING_VVVV) 1185 ENCODING("FR32", ENCODING_VVVV) 1186 ENCODING("FR128", ENCODING_VVVV) 1187 ENCODING("FR64", ENCODING_VVVV) 1188 ENCODING("VR128", ENCODING_VVVV) 1189 ENCODING("VR256", ENCODING_VVVV) 1190 ENCODING("FR32X", ENCODING_VVVV) 1191 ENCODING("FR64X", ENCODING_VVVV) 1192 ENCODING("VR128X", ENCODING_VVVV) 1193 ENCODING("VR256X", ENCODING_VVVV) 1194 ENCODING("VR512", ENCODING_VVVV) 1195 ENCODING("VK1", ENCODING_VVVV) 1196 ENCODING("VK2", ENCODING_VVVV) 1197 ENCODING("VK4", ENCODING_VVVV) 1198 ENCODING("VK8", ENCODING_VVVV) 1199 ENCODING("VK16", ENCODING_VVVV) 1200 ENCODING("VK32", ENCODING_VVVV) 1201 ENCODING("VK64", ENCODING_VVVV) 1202 errs() << "Unhandled VEX.vvvv register encoding " << s << "\n"; 1203 llvm_unreachable("Unhandled VEX.vvvv register encoding"); 1204 } 1205 1206 OperandEncoding 1207 RecognizableInstr::writemaskRegisterEncodingFromString(const std::string &s, 1208 uint8_t OpSize) { 1209 ENCODING("VK1WM", ENCODING_WRITEMASK) 1210 ENCODING("VK2WM", ENCODING_WRITEMASK) 1211 ENCODING("VK4WM", ENCODING_WRITEMASK) 1212 ENCODING("VK8WM", ENCODING_WRITEMASK) 1213 ENCODING("VK16WM", ENCODING_WRITEMASK) 1214 ENCODING("VK32WM", ENCODING_WRITEMASK) 1215 ENCODING("VK64WM", ENCODING_WRITEMASK) 1216 errs() << "Unhandled mask register encoding " << s << "\n"; 1217 llvm_unreachable("Unhandled mask register encoding"); 1218 } 1219 1220 OperandEncoding 1221 RecognizableInstr::memoryEncodingFromString(const std::string &s, 1222 uint8_t OpSize) { 1223 ENCODING("i16mem", ENCODING_RM) 1224 ENCODING("i32mem", ENCODING_RM) 1225 ENCODING("i64mem", ENCODING_RM) 1226 ENCODING("i8mem", ENCODING_RM) 1227 ENCODING("ssmem", ENCODING_RM) 1228 ENCODING("sdmem", ENCODING_RM) 1229 ENCODING("f128mem", ENCODING_RM) 1230 ENCODING("f256mem", ENCODING_RM) 1231 ENCODING("f512mem", ENCODING_RM) 1232 ENCODING("f64mem", ENCODING_RM) 1233 ENCODING("f32mem", ENCODING_RM) 1234 ENCODING("i128mem", ENCODING_RM) 1235 ENCODING("i256mem", ENCODING_RM) 1236 ENCODING("i512mem", ENCODING_RM) 1237 ENCODING("f80mem", ENCODING_RM) 1238 ENCODING("lea64_32mem", ENCODING_RM) 1239 ENCODING("lea64mem", ENCODING_RM) 1240 ENCODING("anymem", ENCODING_RM) 1241 ENCODING("opaque32mem", ENCODING_RM) 1242 ENCODING("opaque48mem", ENCODING_RM) 1243 ENCODING("opaque80mem", ENCODING_RM) 1244 ENCODING("opaque512mem", ENCODING_RM) 1245 ENCODING("vx64mem", ENCODING_RM) 1246 ENCODING("vx128mem", ENCODING_RM) 1247 ENCODING("vx256mem", ENCODING_RM) 1248 ENCODING("vy128mem", ENCODING_RM) 1249 ENCODING("vy256mem", ENCODING_RM) 1250 ENCODING("vx64xmem", ENCODING_RM) 1251 ENCODING("vx128xmem", ENCODING_RM) 1252 ENCODING("vx256xmem", ENCODING_RM) 1253 ENCODING("vy128xmem", ENCODING_RM) 1254 ENCODING("vy256xmem", ENCODING_RM) 1255 ENCODING("vy512mem", ENCODING_RM) 1256 ENCODING("vz512mem", ENCODING_RM) 1257 errs() << "Unhandled memory encoding " << s << "\n"; 1258 llvm_unreachable("Unhandled memory encoding"); 1259 } 1260 1261 OperandEncoding 1262 RecognizableInstr::relocationEncodingFromString(const std::string &s, 1263 uint8_t OpSize) { 1264 if(OpSize != X86Local::OpSize16) { 1265 // For instructions without an OpSize prefix, a declared 16-bit register or 1266 // immediate encoding is special. 1267 ENCODING("i16imm", ENCODING_IW) 1268 } 1269 ENCODING("i16imm", ENCODING_Iv) 1270 ENCODING("i16i8imm", ENCODING_IB) 1271 ENCODING("i32imm", ENCODING_Iv) 1272 ENCODING("i32i8imm", ENCODING_IB) 1273 ENCODING("i64i32imm", ENCODING_ID) 1274 ENCODING("i64i8imm", ENCODING_IB) 1275 ENCODING("i8imm", ENCODING_IB) 1276 ENCODING("u8imm", ENCODING_IB) 1277 ENCODING("i32u8imm", ENCODING_IB) 1278 ENCODING("i64i32imm_pcrel", ENCODING_ID) 1279 ENCODING("i16imm_pcrel", ENCODING_IW) 1280 ENCODING("i32imm_pcrel", ENCODING_ID) 1281 ENCODING("brtarget32", ENCODING_Iv) 1282 ENCODING("brtarget16", ENCODING_Iv) 1283 ENCODING("brtarget8", ENCODING_IB) 1284 ENCODING("i64imm", ENCODING_IO) 1285 ENCODING("offset16_8", ENCODING_Ia) 1286 ENCODING("offset16_16", ENCODING_Ia) 1287 ENCODING("offset16_32", ENCODING_Ia) 1288 ENCODING("offset32_8", ENCODING_Ia) 1289 ENCODING("offset32_16", ENCODING_Ia) 1290 ENCODING("offset32_32", ENCODING_Ia) 1291 ENCODING("offset32_64", ENCODING_Ia) 1292 ENCODING("offset64_8", ENCODING_Ia) 1293 ENCODING("offset64_16", ENCODING_Ia) 1294 ENCODING("offset64_32", ENCODING_Ia) 1295 ENCODING("offset64_64", ENCODING_Ia) 1296 ENCODING("srcidx8", ENCODING_SI) 1297 ENCODING("srcidx16", ENCODING_SI) 1298 ENCODING("srcidx32", ENCODING_SI) 1299 ENCODING("srcidx64", ENCODING_SI) 1300 ENCODING("dstidx8", ENCODING_DI) 1301 ENCODING("dstidx16", ENCODING_DI) 1302 ENCODING("dstidx32", ENCODING_DI) 1303 ENCODING("dstidx64", ENCODING_DI) 1304 errs() << "Unhandled relocation encoding " << s << "\n"; 1305 llvm_unreachable("Unhandled relocation encoding"); 1306 } 1307 1308 OperandEncoding 1309 RecognizableInstr::opcodeModifierEncodingFromString(const std::string &s, 1310 uint8_t OpSize) { 1311 ENCODING("GR32", ENCODING_Rv) 1312 ENCODING("GR64", ENCODING_RO) 1313 ENCODING("GR16", ENCODING_Rv) 1314 ENCODING("GR8", ENCODING_RB) 1315 ENCODING("GR32_NOAX", ENCODING_Rv) 1316 errs() << "Unhandled opcode modifier encoding " << s << "\n"; 1317 llvm_unreachable("Unhandled opcode modifier encoding"); 1318 } 1319 #undef ENCODING 1320