contrib/llvm/lib/Target/X86/Disassembler/X86Disassembler.cpp

   1 //===-- X86Disassembler.cpp - Disassembler for x86 and x86_64 -------------===//
   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.
  11 // It contains code to translate the data produced by the decoder into
  12 //  MCInsts.
  13 //
  14 //
  15 // The X86 disassembler is a table-driven disassembler for the 16-, 32-, and
  16 // 64-bit X86 instruction sets.  The main decode sequence for an assembly
  17 // instruction in this disassembler is:
  18 //
  19 // 1. Read the prefix bytes and determine the attributes of the instruction.
  20 //    These attributes, recorded in enum attributeBits
  21 //    (X86DisassemblerDecoderCommon.h), form a bitmask.  The table CONTEXTS_SYM
  22 //    provides a mapping from bitmasks to contexts, which are represented by
  23 //    enum InstructionContext (ibid.).
  24 //
  25 // 2. Read the opcode, and determine what kind of opcode it is.  The
  26 //    disassembler distinguishes four kinds of opcodes, which are enumerated in
  27 //    OpcodeType (X86DisassemblerDecoderCommon.h): one-byte (0xnn), two-byte
  28 //    (0x0f 0xnn), three-byte-38 (0x0f 0x38 0xnn), or three-byte-3a
  29 //    (0x0f 0x3a 0xnn).  Mandatory prefixes are treated as part of the context.
  30 //
  31 // 3. Depending on the opcode type, look in one of four ClassDecision structures
  32 //    (X86DisassemblerDecoderCommon.h).  Use the opcode class to determine which
  33 //    OpcodeDecision (ibid.) to look the opcode in.  Look up the opcode, to get
  34 //    a ModRMDecision (ibid.).
  35 //
  36 // 4. Some instructions, such as escape opcodes or extended opcodes, or even
  37 //    instructions that have ModRM*Reg / ModRM*Mem forms in LLVM, need the
  38 //    ModR/M byte to complete decode.  The ModRMDecision's type is an entry from
  39 //    ModRMDecisionType (X86DisassemblerDecoderCommon.h) that indicates if the
  40 //    ModR/M byte is required and how to interpret it.
  41 //
  42 // 5. After resolving the ModRMDecision, the disassembler has a unique ID
  43 //    of type InstrUID (X86DisassemblerDecoderCommon.h).  Looking this ID up in
  44 //    INSTRUCTIONS_SYM yields the name of the instruction and the encodings and
  45 //    meanings of its operands.
  46 //
  47 // 6. For each operand, its encoding is an entry from OperandEncoding
  48 //    (X86DisassemblerDecoderCommon.h) and its type is an entry from
  49 //    OperandType (ibid.).  The encoding indicates how to read it from the
  50 //    instruction; the type indicates how to interpret the value once it has
  51 //    been read.  For example, a register operand could be stored in the R/M
  52 //    field of the ModR/M byte, the REG field of the ModR/M byte, or added to
  53 //    the main opcode.  This is orthogonal from its meaning (an GPR or an XMM
  54 //    register, for instance).  Given this information, the operands can be
  55 //    extracted and interpreted.
  56 //
  57 // 7. As the last step, the disassembler translates the instruction information
  58 //    and operands into a format understandable by the client - in this case, an
  59 //    MCInst for use by the MC infrastructure.
  60 //
  61 // The disassembler is broken broadly into two parts: the table emitter that
  62 // emits the instruction decode tables discussed above during compilation, and
  63 // the disassembler itself.  The table emitter is documented in more detail in
  64 // utils/TableGen/X86DisassemblerEmitter.h.
  65 //
  66 // X86Disassembler.cpp contains the code responsible for step 7, and for
  67 //   invoking the decoder to execute steps 1-6.
  68 // X86DisassemblerDecoderCommon.h contains the definitions needed by both the
  69 //   table emitter and the disassembler.
  70 // X86DisassemblerDecoder.h contains the public interface of the decoder,
  71 //   factored out into C for possible use by other projects.
  72 // X86DisassemblerDecoder.c contains the source code of the decoder, which is
  73 //   responsible for steps 1-6.
  74 //
  75 //===----------------------------------------------------------------------===//
  76
  77 #include "MCTargetDesc/X86BaseInfo.h"
  78 #include "MCTargetDesc/X86MCTargetDesc.h"
  79 #include "X86DisassemblerDecoder.h"
  80 #include "llvm/MC/MCContext.h"
  81 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
  82 #include "llvm/MC/MCExpr.h"
  83 #include "llvm/MC/MCInst.h"
  84 #include "llvm/MC/MCInstrInfo.h"
  85 #include "llvm/MC/MCSubtargetInfo.h"
  86 #include "llvm/Support/Debug.h"
  87 #include "llvm/Support/TargetRegistry.h"
  88 #include "llvm/Support/raw_ostream.h"
  89
  90 using namespace llvm;
  91 using namespace llvm::X86Disassembler;
  92
  93 #define DEBUG_TYPE "x86-disassembler"
  94
  95 void llvm::X86Disassembler::Debug(const char *file, unsigned line,
  96                                   const char *s) {
  97   dbgs() << file << ":" << line << ": " << s;
  98 }
  99
 100 StringRef llvm::X86Disassembler::GetInstrName(unsigned Opcode,
 101                                                 const void *mii) {
 102   const MCInstrInfo *MII = static_cast<const MCInstrInfo *>(mii);
 103   return MII->getName(Opcode);
 104 }
 105
 106 #define debug(s) LLVM_DEBUG(Debug(__FILE__, __LINE__, s));
 107
 108 namespace llvm {
 109
 110 // Fill-ins to make the compiler happy.  These constants are never actually
 111 //   assigned; they are just filler to make an automatically-generated switch
 112 //   statement work.
 113 namespace X86 {
 114   enum {
 115     BX_SI = 500,
 116     BX_DI = 501,
 117     BP_SI = 502,
 118     BP_DI = 503,
 119     sib   = 504,
 120     sib64 = 505
 121   };
 122 }
 123
 124 }
 125
 126 static bool translateInstruction(MCInst &target,
 127                                 InternalInstruction &source,
 128                                 const MCDisassembler *Dis);
 129
 130 namespace {
 131
 132 /// Generic disassembler for all X86 platforms. All each platform class should
 133 /// have to do is subclass the constructor, and provide a different
 134 /// disassemblerMode value.
 135 class X86GenericDisassembler : public MCDisassembler {
 136   std::unique_ptr<const MCInstrInfo> MII;
 137 public:
 138   X86GenericDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx,
 139                          std::unique_ptr<const MCInstrInfo> MII);
 140 public:
 141   DecodeStatus getInstruction(MCInst &instr, uint64_t &size,
 142                               ArrayRef<uint8_t> Bytes, uint64_t Address,
 143                               raw_ostream &vStream,
 144                               raw_ostream &cStream) const override;
 145
 146 private:
 147   DisassemblerMode              fMode;
 148 };
 149
 150 }
 151
 152 X86GenericDisassembler::X86GenericDisassembler(
 153                                          const MCSubtargetInfo &STI,
 154                                          MCContext &Ctx,
 155                                          std::unique_ptr<const MCInstrInfo> MII)
 156   : MCDisassembler(STI, Ctx), MII(std::move(MII)) {
 157   const FeatureBitset &FB = STI.getFeatureBits();
 158   if (FB[X86::Mode16Bit]) {
 159     fMode = MODE_16BIT;
 160     return;
 161   } else if (FB[X86::Mode32Bit]) {
 162     fMode = MODE_32BIT;
 163     return;
 164   } else if (FB[X86::Mode64Bit]) {
 165     fMode = MODE_64BIT;
 166     return;
 167   }
 168
 169   llvm_unreachable("Invalid CPU mode");
 170 }
 171
 172 namespace {
 173 struct Region {
 174   ArrayRef<uint8_t> Bytes;
 175   uint64_t Base;
 176   Region(ArrayRef<uint8_t> Bytes, uint64_t Base) : Bytes(Bytes), Base(Base) {}
 177 };
 178 } // end anonymous namespace
 179
 180 /// A callback function that wraps the readByte method from Region.
 181 ///
 182 /// @param Arg      - The generic callback parameter.  In this case, this should
 183 ///                   be a pointer to a Region.
 184 /// @param Byte     - A pointer to the byte to be read.
 185 /// @param Address  - The address to be read.
 186 static int regionReader(const void *Arg, uint8_t *Byte, uint64_t Address) {
 187   auto *R = static_cast<const Region *>(Arg);
 188   ArrayRef<uint8_t> Bytes = R->Bytes;
 189   unsigned Index = Address - R->Base;
 190   if (Bytes.size() <= Index)
 191     return -1;
 192   *Byte = Bytes[Index];
 193   return 0;
 194 }
 195
 196 /// logger - a callback function that wraps the operator<< method from
 197 ///   raw_ostream.
 198 ///
 199 /// @param arg      - The generic callback parameter.  This should be a pointe
 200 ///                   to a raw_ostream.
 201 /// @param log      - A string to be logged.  logger() adds a newline.
 202 static void logger(void* arg, const char* log) {
 203   if (!arg)
 204     return;
 205
 206   raw_ostream &vStream = *(static_cast<raw_ostream*>(arg));
 207   vStream << log << "\n";
 208 }
 209
 210 //
 211 // Public interface for the disassembler
 212 //
 213
 214 MCDisassembler::DecodeStatus X86GenericDisassembler::getInstruction(
 215     MCInst &Instr, uint64_t &Size, ArrayRef<uint8_t> Bytes, uint64_t Address,
 216     raw_ostream &VStream, raw_ostream &CStream) const {
 217   CommentStream = &CStream;
 218
 219   InternalInstruction InternalInstr;
 220
 221   dlog_t LoggerFn = logger;
 222   if (&VStream == &nulls())
 223     LoggerFn = nullptr; // Disable logging completely if it's going to nulls().
 224
 225   Region R(Bytes, Address);
 226
 227   int Ret = decodeInstruction(&InternalInstr, regionReader, (const void *)&R,
 228                               LoggerFn, (void *)&VStream,
 229                               (const void *)MII.get(), Address, fMode);
 230
 231   if (Ret) {
 232     Size = InternalInstr.readerCursor - Address;
 233     return Fail;
 234   } else {
 235     Size = InternalInstr.length;
 236     bool Ret = translateInstruction(Instr, InternalInstr, this);
 237     if (!Ret) {
 238       unsigned Flags = X86::IP_NO_PREFIX;
 239       if (InternalInstr.hasAdSize)
 240         Flags |= X86::IP_HAS_AD_SIZE;
 241       if (!InternalInstr.mandatoryPrefix) {
 242         if (InternalInstr.hasOpSize)
 243           Flags |= X86::IP_HAS_OP_SIZE;
 244         if (InternalInstr.repeatPrefix == 0xf2)
 245           Flags |= X86::IP_HAS_REPEAT_NE;
 246         else if (InternalInstr.repeatPrefix == 0xf3 &&
 247                  // It should not be 'pause' f3 90
 248                  InternalInstr.opcode != 0x90)
 249           Flags |= X86::IP_HAS_REPEAT;
 250         if (InternalInstr.hasLockPrefix)
 251           Flags |= X86::IP_HAS_LOCK;
 252       }
 253       Instr.setFlags(Flags);
 254     }
 255     return (!Ret) ? Success : Fail;
 256   }
 257 }
 258
 259 //
 260 // Private code that translates from struct InternalInstructions to MCInsts.
 261 //
 262
 263 /// translateRegister - Translates an internal register to the appropriate LLVM
 264 ///   register, and appends it as an operand to an MCInst.
 265 ///
 266 /// @param mcInst     - The MCInst to append to.
 267 /// @param reg        - The Reg to append.
 268 static void translateRegister(MCInst &mcInst, Reg reg) {
 269 #define ENTRY(x) X86::x,
 270   static constexpr MCPhysReg llvmRegnums[] = {ALL_REGS};
 271 #undef ENTRY
 272
 273   MCPhysReg llvmRegnum = llvmRegnums[reg];
 274   mcInst.addOperand(MCOperand::createReg(llvmRegnum));
 275 }
 276
 277 /// tryAddingSymbolicOperand - trys to add a symbolic operand in place of the
 278 /// immediate Value in the MCInst.
 279 ///
 280 /// @param Value      - The immediate Value, has had any PC adjustment made by
 281 ///                     the caller.
 282 /// @param isBranch   - If the instruction is a branch instruction
 283 /// @param Address    - The starting address of the instruction
 284 /// @param Offset     - The byte offset to this immediate in the instruction
 285 /// @param Width      - The byte width of this immediate in the instruction
 286 ///
 287 /// If the getOpInfo() function was set when setupForSymbolicDisassembly() was
 288 /// called then that function is called to get any symbolic information for the
 289 /// immediate in the instruction using the Address, Offset and Width.  If that
 290 /// returns non-zero then the symbolic information it returns is used to create
 291 /// an MCExpr and that is added as an operand to the MCInst.  If getOpInfo()
 292 /// returns zero and isBranch is true then a symbol look up for immediate Value
 293 /// is done and if a symbol is found an MCExpr is created with that, else
 294 /// an MCExpr with the immediate Value is created.  This function returns true
 295 /// if it adds an operand to the MCInst and false otherwise.
 296 static bool tryAddingSymbolicOperand(int64_t Value, bool isBranch,
 297                                      uint64_t Address, uint64_t Offset,
 298                                      uint64_t Width, MCInst &MI,
 299                                      const MCDisassembler *Dis) {
 300   return Dis->tryAddingSymbolicOperand(MI, Value, Address, isBranch,
 301                                        Offset, Width);
 302 }
 303
 304 /// tryAddingPcLoadReferenceComment - trys to add a comment as to what is being
 305 /// referenced by a load instruction with the base register that is the rip.
 306 /// These can often be addresses in a literal pool.  The Address of the
 307 /// instruction and its immediate Value are used to determine the address
 308 /// being referenced in the literal pool entry.  The SymbolLookUp call back will
 309 /// return a pointer to a literal 'C' string if the referenced address is an
 310 /// address into a section with 'C' string literals.
 311 static void tryAddingPcLoadReferenceComment(uint64_t Address, uint64_t Value,
 312                                             const void *Decoder) {
 313   const MCDisassembler *Dis = static_cast<const MCDisassembler*>(Decoder);
 314   Dis->tryAddingPcLoadReferenceComment(Value, Address);
 315 }
 316
 317 static const uint8_t segmentRegnums[SEG_OVERRIDE_max] = {
 318   0,        // SEG_OVERRIDE_NONE
 319   X86::CS,
 320   X86::SS,
 321   X86::DS,
 322   X86::ES,
 323   X86::FS,
 324   X86::GS
 325 };
 326
 327 /// translateSrcIndex   - Appends a source index operand to an MCInst.
 328 ///
 329 /// @param mcInst       - The MCInst to append to.
 330 /// @param insn         - The internal instruction.
 331 static bool translateSrcIndex(MCInst &mcInst, InternalInstruction &insn) {
 332   unsigned baseRegNo;
 333
 334   if (insn.mode == MODE_64BIT)
 335     baseRegNo = insn.hasAdSize ? X86::ESI : X86::RSI;
 336   else if (insn.mode == MODE_32BIT)
 337     baseRegNo = insn.hasAdSize ? X86::SI : X86::ESI;
 338   else {
 339     assert(insn.mode == MODE_16BIT);
 340     baseRegNo = insn.hasAdSize ? X86::ESI : X86::SI;
 341   }
 342   MCOperand baseReg = MCOperand::createReg(baseRegNo);
 343   mcInst.addOperand(baseReg);
 344
 345   MCOperand segmentReg;
 346   segmentReg = MCOperand::createReg(segmentRegnums[insn.segmentOverride]);
 347   mcInst.addOperand(segmentReg);
 348   return false;
 349 }
 350
 351 /// translateDstIndex   - Appends a destination index operand to an MCInst.
 352 ///
 353 /// @param mcInst       - The MCInst to append to.
 354 /// @param insn         - The internal instruction.
 355
 356 static bool translateDstIndex(MCInst &mcInst, InternalInstruction &insn) {
 357   unsigned baseRegNo;
 358
 359   if (insn.mode == MODE_64BIT)
 360     baseRegNo = insn.hasAdSize ? X86::EDI : X86::RDI;
 361   else if (insn.mode == MODE_32BIT)
 362     baseRegNo = insn.hasAdSize ? X86::DI : X86::EDI;
 363   else {
 364     assert(insn.mode == MODE_16BIT);
 365     baseRegNo = insn.hasAdSize ? X86::EDI : X86::DI;
 366   }
 367   MCOperand baseReg = MCOperand::createReg(baseRegNo);
 368   mcInst.addOperand(baseReg);
 369   return false;
 370 }
 371
 372 /// translateImmediate  - Appends an immediate operand to an MCInst.
 373 ///
 374 /// @param mcInst       - The MCInst to append to.
 375 /// @param immediate    - The immediate value to append.
 376 /// @param operand      - The operand, as stored in the descriptor table.
 377 /// @param insn         - The internal instruction.
 378 static void translateImmediate(MCInst &mcInst, uint64_t immediate,
 379                                const OperandSpecifier &operand,
 380                                InternalInstruction &insn,
 381                                const MCDisassembler *Dis) {
 382   // Sign-extend the immediate if necessary.
 383
 384   OperandType type = (OperandType)operand.type;
 385
 386   bool isBranch = false;
 387   uint64_t pcrel = 0;
 388   if (type == TYPE_REL) {
 389     isBranch = true;
 390     pcrel = insn.startLocation +
 391             insn.immediateOffset + insn.immediateSize;
 392     switch (operand.encoding) {
 393     default:
 394       break;
 395     case ENCODING_Iv:
 396       switch (insn.displacementSize) {
 397       default:
 398         break;
 399       case 1:
 400         if(immediate & 0x80)
 401           immediate |= ~(0xffull);
 402         break;
 403       case 2:
 404         if(immediate & 0x8000)
 405           immediate |= ~(0xffffull);
 406         break;
 407       case 4:
 408         if(immediate & 0x80000000)
 409           immediate |= ~(0xffffffffull);
 410         break;
 411       case 8:
 412         break;
 413       }
 414       break;
 415     case ENCODING_IB:
 416       if(immediate & 0x80)
 417         immediate |= ~(0xffull);
 418       break;
 419     case ENCODING_IW:
 420       if(immediate & 0x8000)
 421         immediate |= ~(0xffffull);
 422       break;
 423     case ENCODING_ID:
 424       if(immediate & 0x80000000)
 425         immediate |= ~(0xffffffffull);
 426       break;
 427     }
 428   }
 429   // By default sign-extend all X86 immediates based on their encoding.
 430   else if (type == TYPE_IMM) {
 431     switch (operand.encoding) {
 432     default:
 433       break;
 434     case ENCODING_IB:
 435       if(immediate & 0x80)
 436         immediate |= ~(0xffull);
 437       break;
 438     case ENCODING_IW:
 439       if(immediate & 0x8000)
 440         immediate |= ~(0xffffull);
 441       break;
 442     case ENCODING_ID:
 443       if(immediate & 0x80000000)
 444         immediate |= ~(0xffffffffull);
 445       break;
 446     case ENCODING_IO:
 447       break;
 448     }
 449   } else if (type == TYPE_IMM3) {
 450     // Check for immediates that printSSECC can't handle.
 451     if (immediate >= 8) {
 452       unsigned NewOpc;
 453       switch (mcInst.getOpcode()) {
 454       default: llvm_unreachable("unexpected opcode");
 455       case X86::CMPPDrmi:  NewOpc = X86::CMPPDrmi_alt;  break;
 456       case X86::CMPPDrri:  NewOpc = X86::CMPPDrri_alt;  break;
 457       case X86::CMPPSrmi:  NewOpc = X86::CMPPSrmi_alt;  break;
 458       case X86::CMPPSrri:  NewOpc = X86::CMPPSrri_alt;  break;
 459       case X86::CMPSDrm:   NewOpc = X86::CMPSDrm_alt;   break;
 460       case X86::CMPSDrr:   NewOpc = X86::CMPSDrr_alt;   break;
 461       case X86::CMPSSrm:   NewOpc = X86::CMPSSrm_alt;   break;
 462       case X86::CMPSSrr:   NewOpc = X86::CMPSSrr_alt;   break;
 463       case X86::VPCOMBri:  NewOpc = X86::VPCOMBri_alt;  break;
 464       case X86::VPCOMBmi:  NewOpc = X86::VPCOMBmi_alt;  break;
 465       case X86::VPCOMWri:  NewOpc = X86::VPCOMWri_alt;  break;
 466       case X86::VPCOMWmi:  NewOpc = X86::VPCOMWmi_alt;  break;
 467       case X86::VPCOMDri:  NewOpc = X86::VPCOMDri_alt;  break;
 468       case X86::VPCOMDmi:  NewOpc = X86::VPCOMDmi_alt;  break;
 469       case X86::VPCOMQri:  NewOpc = X86::VPCOMQri_alt;  break;
 470       case X86::VPCOMQmi:  NewOpc = X86::VPCOMQmi_alt;  break;
 471       case X86::VPCOMUBri: NewOpc = X86::VPCOMUBri_alt; break;
 472       case X86::VPCOMUBmi: NewOpc = X86::VPCOMUBmi_alt; break;
 473       case X86::VPCOMUWri: NewOpc = X86::VPCOMUWri_alt; break;
 474       case X86::VPCOMUWmi: NewOpc = X86::VPCOMUWmi_alt; break;
 475       case X86::VPCOMUDri: NewOpc = X86::VPCOMUDri_alt; break;
 476       case X86::VPCOMUDmi: NewOpc = X86::VPCOMUDmi_alt; break;
 477       case X86::VPCOMUQri: NewOpc = X86::VPCOMUQri_alt; break;
 478       case X86::VPCOMUQmi: NewOpc = X86::VPCOMUQmi_alt; break;
 479       }
 480       // Switch opcode to the one that doesn't get special printing.
 481       mcInst.setOpcode(NewOpc);
 482     }
 483   } else if (type == TYPE_IMM5) {
 484     // Check for immediates that printAVXCC can't handle.
 485     if (immediate >= 32) {
 486       unsigned NewOpc;
 487       switch (mcInst.getOpcode()) {
 488       default: llvm_unreachable("unexpected opcode");
 489       case X86::VCMPPDrmi:   NewOpc = X86::VCMPPDrmi_alt;   break;
 490       case X86::VCMPPDrri:   NewOpc = X86::VCMPPDrri_alt;   break;
 491       case X86::VCMPPSrmi:   NewOpc = X86::VCMPPSrmi_alt;   break;
 492       case X86::VCMPPSrri:   NewOpc = X86::VCMPPSrri_alt;   break;
 493       case X86::VCMPSDrm:    NewOpc = X86::VCMPSDrm_alt;    break;
 494       case X86::VCMPSDrr:    NewOpc = X86::VCMPSDrr_alt;    break;
 495       case X86::VCMPSSrm:    NewOpc = X86::VCMPSSrm_alt;    break;
 496       case X86::VCMPSSrr:    NewOpc = X86::VCMPSSrr_alt;    break;
 497       case X86::VCMPPDYrmi:  NewOpc = X86::VCMPPDYrmi_alt;  break;
 498       case X86::VCMPPDYrri:  NewOpc = X86::VCMPPDYrri_alt;  break;
 499       case X86::VCMPPSYrmi:  NewOpc = X86::VCMPPSYrmi_alt;  break;
 500       case X86::VCMPPSYrri:  NewOpc = X86::VCMPPSYrri_alt;  break;
 501       case X86::VCMPPDZrmi:  NewOpc = X86::VCMPPDZrmi_alt;  break;
 502       case X86::VCMPPDZrri:  NewOpc = X86::VCMPPDZrri_alt;  break;
 503       case X86::VCMPPDZrrib: NewOpc = X86::VCMPPDZrrib_alt; break;
 504       case X86::VCMPPSZrmi:  NewOpc = X86::VCMPPSZrmi_alt;  break;
 505       case X86::VCMPPSZrri:  NewOpc = X86::VCMPPSZrri_alt;  break;
 506       case X86::VCMPPSZrrib: NewOpc = X86::VCMPPSZrrib_alt; break;
 507       case X86::VCMPPDZ128rmi:  NewOpc = X86::VCMPPDZ128rmi_alt;  break;
 508       case X86::VCMPPDZ128rri:  NewOpc = X86::VCMPPDZ128rri_alt;  break;
 509       case X86::VCMPPSZ128rmi:  NewOpc = X86::VCMPPSZ128rmi_alt;  break;
 510       case X86::VCMPPSZ128rri:  NewOpc = X86::VCMPPSZ128rri_alt;  break;
 511       case X86::VCMPPDZ256rmi:  NewOpc = X86::VCMPPDZ256rmi_alt;  break;
 512       case X86::VCMPPDZ256rri:  NewOpc = X86::VCMPPDZ256rri_alt;  break;
 513       case X86::VCMPPSZ256rmi:  NewOpc = X86::VCMPPSZ256rmi_alt;  break;
 514       case X86::VCMPPSZ256rri:  NewOpc = X86::VCMPPSZ256rri_alt;  break;
 515       case X86::VCMPSDZrm_Int:  NewOpc = X86::VCMPSDZrmi_alt;  break;
 516       case X86::VCMPSDZrr_Int:  NewOpc = X86::VCMPSDZrri_alt;  break;
 517       case X86::VCMPSDZrrb_Int: NewOpc = X86::VCMPSDZrrb_alt;  break;
 518       case X86::VCMPSSZrm_Int:  NewOpc = X86::VCMPSSZrmi_alt;  break;
 519       case X86::VCMPSSZrr_Int:  NewOpc = X86::VCMPSSZrri_alt;  break;
 520       case X86::VCMPSSZrrb_Int: NewOpc = X86::VCMPSSZrrb_alt;  break;
 521       }
 522       // Switch opcode to the one that doesn't get special printing.
 523       mcInst.setOpcode(NewOpc);
 524     }
 525   } else if (type == TYPE_AVX512ICC) {
 526     if (immediate >= 8 || ((immediate & 0x3) == 3)) {
 527       unsigned NewOpc;
 528       switch (mcInst.getOpcode()) {
 529       default: llvm_unreachable("unexpected opcode");
 530       case X86::VPCMPBZ128rmi:    NewOpc = X86::VPCMPBZ128rmi_alt;    break;
 531       case X86::VPCMPBZ128rmik:   NewOpc = X86::VPCMPBZ128rmik_alt;   break;
 532       case X86::VPCMPBZ128rri:    NewOpc = X86::VPCMPBZ128rri_alt;    break;
 533       case X86::VPCMPBZ128rrik:   NewOpc = X86::VPCMPBZ128rrik_alt;   break;
 534       case X86::VPCMPBZ256rmi:    NewOpc = X86::VPCMPBZ256rmi_alt;    break;
 535       case X86::VPCMPBZ256rmik:   NewOpc = X86::VPCMPBZ256rmik_alt;   break;
 536       case X86::VPCMPBZ256rri:    NewOpc = X86::VPCMPBZ256rri_alt;    break;
 537       case X86::VPCMPBZ256rrik:   NewOpc = X86::VPCMPBZ256rrik_alt;   break;
 538       case X86::VPCMPBZrmi:       NewOpc = X86::VPCMPBZrmi_alt;       break;
 539       case X86::VPCMPBZrmik:      NewOpc = X86::VPCMPBZrmik_alt;      break;
 540       case X86::VPCMPBZrri:       NewOpc = X86::VPCMPBZrri_alt;       break;
 541       case X86::VPCMPBZrrik:      NewOpc = X86::VPCMPBZrrik_alt;      break;
 542       case X86::VPCMPDZ128rmi:    NewOpc = X86::VPCMPDZ128rmi_alt;    break;
 543       case X86::VPCMPDZ128rmib:   NewOpc = X86::VPCMPDZ128rmib_alt;   break;
 544       case X86::VPCMPDZ128rmibk:  NewOpc = X86::VPCMPDZ128rmibk_alt;  break;
 545       case X86::VPCMPDZ128rmik:   NewOpc = X86::VPCMPDZ128rmik_alt;   break;
 546       case X86::VPCMPDZ128rri:    NewOpc = X86::VPCMPDZ128rri_alt;    break;
 547       case X86::VPCMPDZ128rrik:   NewOpc = X86::VPCMPDZ128rrik_alt;   break;
 548       case X86::VPCMPDZ256rmi:    NewOpc = X86::VPCMPDZ256rmi_alt;    break;
 549       case X86::VPCMPDZ256rmib:   NewOpc = X86::VPCMPDZ256rmib_alt;   break;
 550       case X86::VPCMPDZ256rmibk:  NewOpc = X86::VPCMPDZ256rmibk_alt;  break;
 551       case X86::VPCMPDZ256rmik:   NewOpc = X86::VPCMPDZ256rmik_alt;   break;
 552       case X86::VPCMPDZ256rri:    NewOpc = X86::VPCMPDZ256rri_alt;    break;
 553       case X86::VPCMPDZ256rrik:   NewOpc = X86::VPCMPDZ256rrik_alt;   break;
 554       case X86::VPCMPDZrmi:       NewOpc = X86::VPCMPDZrmi_alt;       break;
 555       case X86::VPCMPDZrmib:      NewOpc = X86::VPCMPDZrmib_alt;      break;
 556       case X86::VPCMPDZrmibk:     NewOpc = X86::VPCMPDZrmibk_alt;     break;
 557       case X86::VPCMPDZrmik:      NewOpc = X86::VPCMPDZrmik_alt;      break;
 558       case X86::VPCMPDZrri:       NewOpc = X86::VPCMPDZrri_alt;       break;
 559       case X86::VPCMPDZrrik:      NewOpc = X86::VPCMPDZrrik_alt;      break;
 560       case X86::VPCMPQZ128rmi:    NewOpc = X86::VPCMPQZ128rmi_alt;    break;
 561       case X86::VPCMPQZ128rmib:   NewOpc = X86::VPCMPQZ128rmib_alt;   break;
 562       case X86::VPCMPQZ128rmibk:  NewOpc = X86::VPCMPQZ128rmibk_alt;  break;
 563       case X86::VPCMPQZ128rmik:   NewOpc = X86::VPCMPQZ128rmik_alt;   break;
 564       case X86::VPCMPQZ128rri:    NewOpc = X86::VPCMPQZ128rri_alt;    break;
 565       case X86::VPCMPQZ128rrik:   NewOpc = X86::VPCMPQZ128rrik_alt;   break;
 566       case X86::VPCMPQZ256rmi:    NewOpc = X86::VPCMPQZ256rmi_alt;    break;
 567       case X86::VPCMPQZ256rmib:   NewOpc = X86::VPCMPQZ256rmib_alt;   break;
 568       case X86::VPCMPQZ256rmibk:  NewOpc = X86::VPCMPQZ256rmibk_alt;  break;
 569       case X86::VPCMPQZ256rmik:   NewOpc = X86::VPCMPQZ256rmik_alt;   break;
 570       case X86::VPCMPQZ256rri:    NewOpc = X86::VPCMPQZ256rri_alt;    break;
 571       case X86::VPCMPQZ256rrik:   NewOpc = X86::VPCMPQZ256rrik_alt;   break;
 572       case X86::VPCMPQZrmi:       NewOpc = X86::VPCMPQZrmi_alt;       break;
 573       case X86::VPCMPQZrmib:      NewOpc = X86::VPCMPQZrmib_alt;      break;
 574       case X86::VPCMPQZrmibk:     NewOpc = X86::VPCMPQZrmibk_alt;     break;
 575       case X86::VPCMPQZrmik:      NewOpc = X86::VPCMPQZrmik_alt;      break;
 576       case X86::VPCMPQZrri:       NewOpc = X86::VPCMPQZrri_alt;       break;
 577       case X86::VPCMPQZrrik:      NewOpc = X86::VPCMPQZrrik_alt;      break;
 578       case X86::VPCMPUBZ128rmi:   NewOpc = X86::VPCMPUBZ128rmi_alt;   break;
 579       case X86::VPCMPUBZ128rmik:  NewOpc = X86::VPCMPUBZ128rmik_alt;  break;
 580       case X86::VPCMPUBZ128rri:   NewOpc = X86::VPCMPUBZ128rri_alt;   break;
 581       case X86::VPCMPUBZ128rrik:  NewOpc = X86::VPCMPUBZ128rrik_alt;  break;
 582       case X86::VPCMPUBZ256rmi:   NewOpc = X86::VPCMPUBZ256rmi_alt;   break;
 583       case X86::VPCMPUBZ256rmik:  NewOpc = X86::VPCMPUBZ256rmik_alt;  break;
 584       case X86::VPCMPUBZ256rri:   NewOpc = X86::VPCMPUBZ256rri_alt;   break;
 585       case X86::VPCMPUBZ256rrik:  NewOpc = X86::VPCMPUBZ256rrik_alt;  break;
 586       case X86::VPCMPUBZrmi:      NewOpc = X86::VPCMPUBZrmi_alt;      break;
 587       case X86::VPCMPUBZrmik:     NewOpc = X86::VPCMPUBZrmik_alt;     break;
 588       case X86::VPCMPUBZrri:      NewOpc = X86::VPCMPUBZrri_alt;      break;
 589       case X86::VPCMPUBZrrik:     NewOpc = X86::VPCMPUBZrrik_alt;     break;
 590       case X86::VPCMPUDZ128rmi:   NewOpc = X86::VPCMPUDZ128rmi_alt;   break;
 591       case X86::VPCMPUDZ128rmib:  NewOpc = X86::VPCMPUDZ128rmib_alt;  break;
 592       case X86::VPCMPUDZ128rmibk: NewOpc = X86::VPCMPUDZ128rmibk_alt; break;
 593       case X86::VPCMPUDZ128rmik:  NewOpc = X86::VPCMPUDZ128rmik_alt;  break;
 594       case X86::VPCMPUDZ128rri:   NewOpc = X86::VPCMPUDZ128rri_alt;   break;
 595       case X86::VPCMPUDZ128rrik:  NewOpc = X86::VPCMPUDZ128rrik_alt;  break;
 596       case X86::VPCMPUDZ256rmi:   NewOpc = X86::VPCMPUDZ256rmi_alt;   break;
 597       case X86::VPCMPUDZ256rmib:  NewOpc = X86::VPCMPUDZ256rmib_alt;  break;
 598       case X86::VPCMPUDZ256rmibk: NewOpc = X86::VPCMPUDZ256rmibk_alt; break;
 599       case X86::VPCMPUDZ256rmik:  NewOpc = X86::VPCMPUDZ256rmik_alt;  break;
 600       case X86::VPCMPUDZ256rri:   NewOpc = X86::VPCMPUDZ256rri_alt;   break;
 601       case X86::VPCMPUDZ256rrik:  NewOpc = X86::VPCMPUDZ256rrik_alt;  break;
 602       case X86::VPCMPUDZrmi:      NewOpc = X86::VPCMPUDZrmi_alt;      break;
 603       case X86::VPCMPUDZrmib:     NewOpc = X86::VPCMPUDZrmib_alt;     break;
 604       case X86::VPCMPUDZrmibk:    NewOpc = X86::VPCMPUDZrmibk_alt;    break;
 605       case X86::VPCMPUDZrmik:     NewOpc = X86::VPCMPUDZrmik_alt;     break;
 606       case X86::VPCMPUDZrri:      NewOpc = X86::VPCMPUDZrri_alt;      break;
 607       case X86::VPCMPUDZrrik:     NewOpc = X86::VPCMPUDZrrik_alt;     break;
 608       case X86::VPCMPUQZ128rmi:   NewOpc = X86::VPCMPUQZ128rmi_alt;   break;
 609       case X86::VPCMPUQZ128rmib:  NewOpc = X86::VPCMPUQZ128rmib_alt;  break;
 610       case X86::VPCMPUQZ128rmibk: NewOpc = X86::VPCMPUQZ128rmibk_alt; break;
 611       case X86::VPCMPUQZ128rmik:  NewOpc = X86::VPCMPUQZ128rmik_alt;  break;
 612       case X86::VPCMPUQZ128rri:   NewOpc = X86::VPCMPUQZ128rri_alt;   break;
 613       case X86::VPCMPUQZ128rrik:  NewOpc = X86::VPCMPUQZ128rrik_alt;  break;
 614       case X86::VPCMPUQZ256rmi:   NewOpc = X86::VPCMPUQZ256rmi_alt;   break;
 615       case X86::VPCMPUQZ256rmib:  NewOpc = X86::VPCMPUQZ256rmib_alt;  break;
 616       case X86::VPCMPUQZ256rmibk: NewOpc = X86::VPCMPUQZ256rmibk_alt; break;
 617       case X86::VPCMPUQZ256rmik:  NewOpc = X86::VPCMPUQZ256rmik_alt;  break;
 618       case X86::VPCMPUQZ256rri:   NewOpc = X86::VPCMPUQZ256rri_alt;   break;
 619       case X86::VPCMPUQZ256rrik:  NewOpc = X86::VPCMPUQZ256rrik_alt;  break;
 620       case X86::VPCMPUQZrmi:      NewOpc = X86::VPCMPUQZrmi_alt;      break;
 621       case X86::VPCMPUQZrmib:     NewOpc = X86::VPCMPUQZrmib_alt;     break;
 622       case X86::VPCMPUQZrmibk:    NewOpc = X86::VPCMPUQZrmibk_alt;    break;
 623       case X86::VPCMPUQZrmik:     NewOpc = X86::VPCMPUQZrmik_alt;     break;
 624       case X86::VPCMPUQZrri:      NewOpc = X86::VPCMPUQZrri_alt;      break;
 625       case X86::VPCMPUQZrrik:     NewOpc = X86::VPCMPUQZrrik_alt;     break;
 626       case X86::VPCMPUWZ128rmi:   NewOpc = X86::VPCMPUWZ128rmi_alt;   break;
 627       case X86::VPCMPUWZ128rmik:  NewOpc = X86::VPCMPUWZ128rmik_alt;  break;
 628       case X86::VPCMPUWZ128rri:   NewOpc = X86::VPCMPUWZ128rri_alt;   break;
 629       case X86::VPCMPUWZ128rrik:  NewOpc = X86::VPCMPUWZ128rrik_alt;  break;
 630       case X86::VPCMPUWZ256rmi:   NewOpc = X86::VPCMPUWZ256rmi_alt;   break;
 631       case X86::VPCMPUWZ256rmik:  NewOpc = X86::VPCMPUWZ256rmik_alt;  break;
 632       case X86::VPCMPUWZ256rri:   NewOpc = X86::VPCMPUWZ256rri_alt;   break;
 633       case X86::VPCMPUWZ256rrik:  NewOpc = X86::VPCMPUWZ256rrik_alt;  break;
 634       case X86::VPCMPUWZrmi:      NewOpc = X86::VPCMPUWZrmi_alt;      break;
 635       case X86::VPCMPUWZrmik:     NewOpc = X86::VPCMPUWZrmik_alt;     break;
 636       case X86::VPCMPUWZrri:      NewOpc = X86::VPCMPUWZrri_alt;      break;
 637       case X86::VPCMPUWZrrik:     NewOpc = X86::VPCMPUWZrrik_alt;     break;
 638       case X86::VPCMPWZ128rmi:    NewOpc = X86::VPCMPWZ128rmi_alt;    break;
 639       case X86::VPCMPWZ128rmik:   NewOpc = X86::VPCMPWZ128rmik_alt;   break;
 640       case X86::VPCMPWZ128rri:    NewOpc = X86::VPCMPWZ128rri_alt;    break;
 641       case X86::VPCMPWZ128rrik:   NewOpc = X86::VPCMPWZ128rrik_alt;   break;
 642       case X86::VPCMPWZ256rmi:    NewOpc = X86::VPCMPWZ256rmi_alt;    break;
 643       case X86::VPCMPWZ256rmik:   NewOpc = X86::VPCMPWZ256rmik_alt;   break;
 644       case X86::VPCMPWZ256rri:    NewOpc = X86::VPCMPWZ256rri_alt;    break;
 645       case X86::VPCMPWZ256rrik:   NewOpc = X86::VPCMPWZ256rrik_alt;   break;
 646       case X86::VPCMPWZrmi:       NewOpc = X86::VPCMPWZrmi_alt;       break;
 647       case X86::VPCMPWZrmik:      NewOpc = X86::VPCMPWZrmik_alt;      break;
 648       case X86::VPCMPWZrri:       NewOpc = X86::VPCMPWZrri_alt;       break;
 649       case X86::VPCMPWZrrik:      NewOpc = X86::VPCMPWZrrik_alt;      break;
 650       }
 651       // Switch opcode to the one that doesn't get special printing.
 652       mcInst.setOpcode(NewOpc);
 653     }
 654   }
 655
 656   switch (type) {
 657   case TYPE_XMM:
 658     mcInst.addOperand(MCOperand::createReg(X86::XMM0 + (immediate >> 4)));
 659     return;
 660   case TYPE_YMM:
 661     mcInst.addOperand(MCOperand::createReg(X86::YMM0 + (immediate >> 4)));
 662     return;
 663   case TYPE_ZMM:
 664     mcInst.addOperand(MCOperand::createReg(X86::ZMM0 + (immediate >> 4)));
 665     return;
 666   default:
 667     // operand is 64 bits wide.  Do nothing.
 668     break;
 669   }
 670
 671   if(!tryAddingSymbolicOperand(immediate + pcrel, isBranch, insn.startLocation,
 672                                insn.immediateOffset, insn.immediateSize,
 673                                mcInst, Dis))
 674     mcInst.addOperand(MCOperand::createImm(immediate));
 675
 676   if (type == TYPE_MOFFS) {
 677     MCOperand segmentReg;
 678     segmentReg = MCOperand::createReg(segmentRegnums[insn.segmentOverride]);
 679     mcInst.addOperand(segmentReg);
 680   }
 681 }
 682
 683 /// translateRMRegister - Translates a register stored in the R/M field of the
 684 ///   ModR/M byte to its LLVM equivalent and appends it to an MCInst.
 685 /// @param mcInst       - The MCInst to append to.
 686 /// @param insn         - The internal instruction to extract the R/M field
 687 ///                       from.
 688 /// @return             - 0 on success; -1 otherwise
 689 static bool translateRMRegister(MCInst &mcInst,
 690                                 InternalInstruction &insn) {
 691   if (insn.eaBase == EA_BASE_sib || insn.eaBase == EA_BASE_sib64) {
 692     debug("A R/M register operand may not have a SIB byte");
 693     return true;
 694   }
 695
 696   switch (insn.eaBase) {
 697   default:
 698     debug("Unexpected EA base register");
 699     return true;
 700   case EA_BASE_NONE:
 701     debug("EA_BASE_NONE for ModR/M base");
 702     return true;
 703 #define ENTRY(x) case EA_BASE_##x:
 704   ALL_EA_BASES
 705 #undef ENTRY
 706     debug("A R/M register operand may not have a base; "
 707           "the operand must be a register.");
 708     return true;
 709 #define ENTRY(x)                                                      \
 710   case EA_REG_##x:                                                    \
 711     mcInst.addOperand(MCOperand::createReg(X86::x)); break;
 712   ALL_REGS
 713 #undef ENTRY
 714   }
 715
 716   return false;
 717 }
 718
 719 /// translateRMMemory - Translates a memory operand stored in the Mod and R/M
 720 ///   fields of an internal instruction (and possibly its SIB byte) to a memory
 721 ///   operand in LLVM's format, and appends it to an MCInst.
 722 ///
 723 /// @param mcInst       - The MCInst to append to.
 724 /// @param insn         - The instruction to extract Mod, R/M, and SIB fields
 725 ///                       from.
 726 /// @return             - 0 on success; nonzero otherwise
 727 static bool translateRMMemory(MCInst &mcInst, InternalInstruction &insn,
 728                               const MCDisassembler *Dis) {
 729   // Addresses in an MCInst are represented as five operands:
 730   //   1. basereg       (register)  The R/M base, or (if there is a SIB) the
 731   //                                SIB base
 732   //   2. scaleamount   (immediate) 1, or (if there is a SIB) the specified
 733   //                                scale amount
 734   //   3. indexreg      (register)  x86_registerNONE, or (if there is a SIB)
 735   //                                the index (which is multiplied by the
 736   //                                scale amount)
 737   //   4. displacement  (immediate) 0, or the displacement if there is one
 738   //   5. segmentreg    (register)  x86_registerNONE for now, but could be set
 739   //                                if we have segment overrides
 740
 741   MCOperand baseReg;
 742   MCOperand scaleAmount;
 743   MCOperand indexReg;
 744   MCOperand displacement;
 745   MCOperand segmentReg;
 746   uint64_t pcrel = 0;
 747
 748   if (insn.eaBase == EA_BASE_sib || insn.eaBase == EA_BASE_sib64) {
 749     if (insn.sibBase != SIB_BASE_NONE) {
 750       switch (insn.sibBase) {
 751       default:
 752         debug("Unexpected sibBase");
 753         return true;
 754 #define ENTRY(x)                                          \
 755       case SIB_BASE_##x:                                  \
 756         baseReg = MCOperand::createReg(X86::x); break;
 757       ALL_SIB_BASES
 758 #undef ENTRY
 759       }
 760     } else {
 761       baseReg = MCOperand::createReg(X86::NoRegister);
 762     }
 763
 764     if (insn.sibIndex != SIB_INDEX_NONE) {
 765       switch (insn.sibIndex) {
 766       default:
 767         debug("Unexpected sibIndex");
 768         return true;
 769 #define ENTRY(x)                                          \
 770       case SIB_INDEX_##x:                                 \
 771         indexReg = MCOperand::createReg(X86::x); break;
 772       EA_BASES_32BIT
 773       EA_BASES_64BIT
 774       REGS_XMM
 775       REGS_YMM
 776       REGS_ZMM
 777 #undef ENTRY
 778       }
 779     } else {
 780       // Use EIZ/RIZ for a few ambiguous cases where the SIB byte is present,
 781       // but no index is used and modrm alone should have been enough.
 782       // -No base register in 32-bit mode. In 64-bit mode this is used to
 783       //  avoid rip-relative addressing.
 784       // -Any base register used other than ESP/RSP/R12D/R12. Using these as a
 785       //  base always requires a SIB byte.
 786       // -A scale other than 1 is used.
 787       if (insn.sibScale != 1 ||
 788           (insn.sibBase == SIB_BASE_NONE && insn.mode != MODE_64BIT) ||
 789           (insn.sibBase != SIB_BASE_NONE &&
 790            insn.sibBase != SIB_BASE_ESP && insn.sibBase != SIB_BASE_RSP &&
 791            insn.sibBase != SIB_BASE_R12D && insn.sibBase != SIB_BASE_R12)) {
 792         indexReg = MCOperand::createReg(insn.addressSize == 4 ? X86::EIZ :
 793                                                                 X86::RIZ);
 794       } else
 795         indexReg = MCOperand::createReg(X86::NoRegister);
 796     }
 797
 798     scaleAmount = MCOperand::createImm(insn.sibScale);
 799   } else {
 800     switch (insn.eaBase) {
 801     case EA_BASE_NONE:
 802       if (insn.eaDisplacement == EA_DISP_NONE) {
 803         debug("EA_BASE_NONE and EA_DISP_NONE for ModR/M base");
 804         return true;
 805       }
 806       if (insn.mode == MODE_64BIT){
 807         pcrel = insn.startLocation +
 808                 insn.displacementOffset + insn.displacementSize;
 809         tryAddingPcLoadReferenceComment(insn.startLocation +
 810                                         insn.displacementOffset,
 811                                         insn.displacement + pcrel, Dis);
 812         // Section 2.2.1.6
 813         baseReg = MCOperand::createReg(insn.addressSize == 4 ? X86::EIP :
 814                                                                X86::RIP);
 815       }
 816       else
 817         baseReg = MCOperand::createReg(X86::NoRegister);
 818
 819       indexReg = MCOperand::createReg(X86::NoRegister);
 820       break;
 821     case EA_BASE_BX_SI:
 822       baseReg = MCOperand::createReg(X86::BX);
 823       indexReg = MCOperand::createReg(X86::SI);
 824       break;
 825     case EA_BASE_BX_DI:
 826       baseReg = MCOperand::createReg(X86::BX);
 827       indexReg = MCOperand::createReg(X86::DI);
 828       break;
 829     case EA_BASE_BP_SI:
 830       baseReg = MCOperand::createReg(X86::BP);
 831       indexReg = MCOperand::createReg(X86::SI);
 832       break;
 833     case EA_BASE_BP_DI:
 834       baseReg = MCOperand::createReg(X86::BP);
 835       indexReg = MCOperand::createReg(X86::DI);
 836       break;
 837     default:
 838       indexReg = MCOperand::createReg(X86::NoRegister);
 839       switch (insn.eaBase) {
 840       default:
 841         debug("Unexpected eaBase");
 842         return true;
 843         // Here, we will use the fill-ins defined above.  However,
 844         //   BX_SI, BX_DI, BP_SI, and BP_DI are all handled above and
 845         //   sib and sib64 were handled in the top-level if, so they're only
 846         //   placeholders to keep the compiler happy.
 847 #define ENTRY(x)                                        \
 848       case EA_BASE_##x:                                 \
 849         baseReg = MCOperand::createReg(X86::x); break;
 850       ALL_EA_BASES
 851 #undef ENTRY
 852 #define ENTRY(x) case EA_REG_##x:
 853       ALL_REGS
 854 #undef ENTRY
 855         debug("A R/M memory operand may not be a register; "
 856               "the base field must be a base.");
 857         return true;
 858       }
 859     }
 860
 861     scaleAmount = MCOperand::createImm(1);
 862   }
 863
 864   displacement = MCOperand::createImm(insn.displacement);
 865
 866   segmentReg = MCOperand::createReg(segmentRegnums[insn.segmentOverride]);
 867
 868   mcInst.addOperand(baseReg);
 869   mcInst.addOperand(scaleAmount);
 870   mcInst.addOperand(indexReg);
 871   if(!tryAddingSymbolicOperand(insn.displacement + pcrel, false,
 872                                insn.startLocation, insn.displacementOffset,
 873                                insn.displacementSize, mcInst, Dis))
 874     mcInst.addOperand(displacement);
 875   mcInst.addOperand(segmentReg);
 876   return false;
 877 }
 878
 879 /// translateRM - Translates an operand stored in the R/M (and possibly SIB)
 880 ///   byte of an instruction to LLVM form, and appends it to an MCInst.
 881 ///
 882 /// @param mcInst       - The MCInst to append to.
 883 /// @param operand      - The operand, as stored in the descriptor table.
 884 /// @param insn         - The instruction to extract Mod, R/M, and SIB fields
 885 ///                       from.
 886 /// @return             - 0 on success; nonzero otherwise
 887 static bool translateRM(MCInst &mcInst, const OperandSpecifier &operand,
 888                         InternalInstruction &insn, const MCDisassembler *Dis) {
 889   switch (operand.type) {
 890   default:
 891     debug("Unexpected type for a R/M operand");
 892     return true;
 893   case TYPE_R8:
 894   case TYPE_R16:
 895   case TYPE_R32:
 896   case TYPE_R64:
 897   case TYPE_Rv:
 898   case TYPE_MM64:
 899   case TYPE_XMM:
 900   case TYPE_YMM:
 901   case TYPE_ZMM:
 902   case TYPE_VK:
 903   case TYPE_DEBUGREG:
 904   case TYPE_CONTROLREG:
 905   case TYPE_BNDR:
 906     return translateRMRegister(mcInst, insn);
 907   case TYPE_M:
 908   case TYPE_MVSIBX:
 909   case TYPE_MVSIBY:
 910   case TYPE_MVSIBZ:
 911     return translateRMMemory(mcInst, insn, Dis);
 912   }
 913 }
 914
 915 /// translateFPRegister - Translates a stack position on the FPU stack to its
 916 ///   LLVM form, and appends it to an MCInst.
 917 ///
 918 /// @param mcInst       - The MCInst to append to.
 919 /// @param stackPos     - The stack position to translate.
 920 static void translateFPRegister(MCInst &mcInst,
 921                                 uint8_t stackPos) {
 922   mcInst.addOperand(MCOperand::createReg(X86::ST0 + stackPos));
 923 }
 924
 925 /// translateMaskRegister - Translates a 3-bit mask register number to
 926 ///   LLVM form, and appends it to an MCInst.
 927 ///
 928 /// @param mcInst       - The MCInst to append to.
 929 /// @param maskRegNum   - Number of mask register from 0 to 7.
 930 /// @return             - false on success; true otherwise.
 931 static bool translateMaskRegister(MCInst &mcInst,
 932                                 uint8_t maskRegNum) {
 933   if (maskRegNum >= 8) {
 934     debug("Invalid mask register number");
 935     return true;
 936   }
 937
 938   mcInst.addOperand(MCOperand::createReg(X86::K0 + maskRegNum));
 939   return false;
 940 }
 941
 942 /// translateOperand - Translates an operand stored in an internal instruction
 943 ///   to LLVM's format and appends it to an MCInst.
 944 ///
 945 /// @param mcInst       - The MCInst to append to.
 946 /// @param operand      - The operand, as stored in the descriptor table.
 947 /// @param insn         - The internal instruction.
 948 /// @return             - false on success; true otherwise.
 949 static bool translateOperand(MCInst &mcInst, const OperandSpecifier &operand,
 950                              InternalInstruction &insn,
 951                              const MCDisassembler *Dis) {
 952   switch (operand.encoding) {
 953   default:
 954     debug("Unhandled operand encoding during translation");
 955     return true;
 956   case ENCODING_REG:
 957     translateRegister(mcInst, insn.reg);
 958     return false;
 959   case ENCODING_WRITEMASK:
 960     return translateMaskRegister(mcInst, insn.writemask);
 961   CASE_ENCODING_RM:
 962   CASE_ENCODING_VSIB:
 963     return translateRM(mcInst, operand, insn, Dis);
 964   case ENCODING_IB:
 965   case ENCODING_IW:
 966   case ENCODING_ID:
 967   case ENCODING_IO:
 968   case ENCODING_Iv:
 969   case ENCODING_Ia:
 970     translateImmediate(mcInst,
 971                        insn.immediates[insn.numImmediatesTranslated++],
 972                        operand,
 973                        insn,
 974                        Dis);
 975     return false;
 976   case ENCODING_IRC:
 977     mcInst.addOperand(MCOperand::createImm(insn.RC));
 978     return false;
 979   case ENCODING_SI:
 980     return translateSrcIndex(mcInst, insn);
 981   case ENCODING_DI:
 982     return translateDstIndex(mcInst, insn);
 983   case ENCODING_RB:
 984   case ENCODING_RW:
 985   case ENCODING_RD:
 986   case ENCODING_RO:
 987   case ENCODING_Rv:
 988     translateRegister(mcInst, insn.opcodeRegister);
 989     return false;
 990   case ENCODING_FP:
 991     translateFPRegister(mcInst, insn.modRM & 7);
 992     return false;
 993   case ENCODING_VVVV:
 994     translateRegister(mcInst, insn.vvvv);
 995     return false;
 996   case ENCODING_DUP:
 997     return translateOperand(mcInst, insn.operands[operand.type - TYPE_DUP0],
 998                             insn, Dis);
 999   }
1000 }
1001
1002 /// translateInstruction - Translates an internal instruction and all its
1003 ///   operands to an MCInst.
1004 ///
1005 /// @param mcInst       - The MCInst to populate with the instruction's data.
1006 /// @param insn         - The internal instruction.
1007 /// @return             - false on success; true otherwise.
1008 static bool translateInstruction(MCInst &mcInst,
1009                                 InternalInstruction &insn,
1010                                 const MCDisassembler *Dis) {
1011   if (!insn.spec) {
1012     debug("Instruction has no specification");
1013     return true;
1014   }
1015
1016   mcInst.clear();
1017   mcInst.setOpcode(insn.instructionID);
1018   // If when reading the prefix bytes we determined the overlapping 0xf2 or 0xf3
1019   // prefix bytes should be disassembled as xrelease and xacquire then set the
1020   // opcode to those instead of the rep and repne opcodes.
1021   if (insn.xAcquireRelease) {
1022     if(mcInst.getOpcode() == X86::REP_PREFIX)
1023       mcInst.setOpcode(X86::XRELEASE_PREFIX);
1024     else if(mcInst.getOpcode() == X86::REPNE_PREFIX)
1025       mcInst.setOpcode(X86::XACQUIRE_PREFIX);
1026   }
1027
1028   insn.numImmediatesTranslated = 0;
1029
1030   for (const auto &Op : insn.operands) {
1031     if (Op.encoding != ENCODING_NONE) {
1032       if (translateOperand(mcInst, Op, insn, Dis)) {
1033         return true;
1034       }
1035     }
1036   }
1037
1038   return false;
1039 }
1040
1041 static MCDisassembler *createX86Disassembler(const Target &T,
1042                                              const MCSubtargetInfo &STI,
1043                                              MCContext &Ctx) {
1044   std::unique_ptr<const MCInstrInfo> MII(T.createMCInstrInfo());
1045   return new X86GenericDisassembler(STI, Ctx, std::move(MII));
1046 }
1047
1048 extern "C" void LLVMInitializeX86Disassembler() {
1049   // Register the disassembler.
1050   TargetRegistry::RegisterMCDisassembler(getTheX86_32Target(),
1051                                          createX86Disassembler);
1052   TargetRegistry::RegisterMCDisassembler(getTheX86_64Target(),
1053                                          createX86Disassembler);
1054 }