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