lib/Target/X86/MCTargetDesc/X86MCCodeEmitter.cpp

   1 //===-- X86MCCodeEmitter.cpp - Convert X86 code to machine code -----------===//
   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 implements the X86MCCodeEmitter class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "MCTargetDesc/X86BaseInfo.h"
  15 #include "MCTargetDesc/X86FixupKinds.h"
  16 #include "MCTargetDesc/X86MCTargetDesc.h"
  17 #include "llvm/ADT/SmallVector.h"
  18 #include "llvm/MC/MCCodeEmitter.h"
  19 #include "llvm/MC/MCContext.h"
  20 #include "llvm/MC/MCExpr.h"
  21 #include "llvm/MC/MCFixup.h"
  22 #include "llvm/MC/MCInst.h"
  23 #include "llvm/MC/MCInstrDesc.h"
  24 #include "llvm/MC/MCInstrInfo.h"
  25 #include "llvm/MC/MCRegisterInfo.h"
  26 #include "llvm/MC/MCSubtargetInfo.h"
  27 #include "llvm/MC/MCSymbol.h"
  28 #include "llvm/Support/ErrorHandling.h"
  29 #include "llvm/Support/raw_ostream.h"
  30 #include <cassert>
  31 #include <cstdint>
  32 #include <cstdlib>
  33
  34 using namespace llvm;
  35
  36 #define DEBUG_TYPE "mccodeemitter"
  37
  38 namespace {
  39
  40 class X86MCCodeEmitter : public MCCodeEmitter {
  41   const MCInstrInfo &MCII;
  42   MCContext &Ctx;
  43
  44 public:
  45   X86MCCodeEmitter(const MCInstrInfo &mcii, MCContext &ctx)
  46     : MCII(mcii), Ctx(ctx) {
  47   }
  48   X86MCCodeEmitter(const X86MCCodeEmitter &) = delete;
  49   X86MCCodeEmitter &operator=(const X86MCCodeEmitter &) = delete;
  50   ~X86MCCodeEmitter() override = default;
  51
  52   bool is64BitMode(const MCSubtargetInfo &STI) const {
  53     return STI.getFeatureBits()[X86::Mode64Bit];
  54   }
  55
  56   bool is32BitMode(const MCSubtargetInfo &STI) const {
  57     return STI.getFeatureBits()[X86::Mode32Bit];
  58   }
  59
  60   bool is16BitMode(const MCSubtargetInfo &STI) const {
  61     return STI.getFeatureBits()[X86::Mode16Bit];
  62   }
  63
  64   /// Is16BitMemOperand - Return true if the specified instruction has
  65   /// a 16-bit memory operand. Op specifies the operand # of the memoperand.
  66   bool Is16BitMemOperand(const MCInst &MI, unsigned Op,
  67                          const MCSubtargetInfo &STI) const {
  68     const MCOperand &BaseReg  = MI.getOperand(Op+X86::AddrBaseReg);
  69     const MCOperand &IndexReg = MI.getOperand(Op+X86::AddrIndexReg);
  70     const MCOperand &Disp     = MI.getOperand(Op+X86::AddrDisp);
  71
  72     if (is16BitMode(STI) && BaseReg.getReg() == 0 &&
  73         Disp.isImm() && Disp.getImm() < 0x10000)
  74       return true;
  75     if ((BaseReg.getReg() != 0 &&
  76          X86MCRegisterClasses[X86::GR16RegClassID].contains(BaseReg.getReg())) ||
  77         (IndexReg.getReg() != 0 &&
  78          X86MCRegisterClasses[X86::GR16RegClassID].contains(IndexReg.getReg())))
  79       return true;
  80     return false;
  81   }
  82
  83   unsigned GetX86RegNum(const MCOperand &MO) const {
  84     return Ctx.getRegisterInfo()->getEncodingValue(MO.getReg()) & 0x7;
  85   }
  86
  87   unsigned getX86RegEncoding(const MCInst &MI, unsigned OpNum) const {
  88     return Ctx.getRegisterInfo()->getEncodingValue(
  89                                                  MI.getOperand(OpNum).getReg());
  90   }
  91
  92   // Does this register require a bit to be set in REX prefix.
  93   bool isREXExtendedReg(const MCInst &MI, unsigned OpNum) const {
  94     return (getX86RegEncoding(MI, OpNum) >> 3) & 1;
  95   }
  96
  97   void EmitByte(uint8_t C, unsigned &CurByte, raw_ostream &OS) const {
  98     OS << (char)C;
  99     ++CurByte;
 100   }
 101
 102   void EmitConstant(uint64_t Val, unsigned Size, unsigned &CurByte,
 103                     raw_ostream &OS) const {
 104     // Output the constant in little endian byte order.
 105     for (unsigned i = 0; i != Size; ++i) {
 106       EmitByte(Val & 255, CurByte, OS);
 107       Val >>= 8;
 108     }
 109   }
 110
 111   void EmitImmediate(const MCOperand &Disp, SMLoc Loc,
 112                      unsigned ImmSize, MCFixupKind FixupKind,
 113                      unsigned &CurByte, raw_ostream &OS,
 114                      SmallVectorImpl<MCFixup> &Fixups,
 115                      int ImmOffset = 0) const;
 116
 117   static uint8_t ModRMByte(unsigned Mod, unsigned RegOpcode, unsigned RM) {
 118     assert(Mod < 4 && RegOpcode < 8 && RM < 8 && "ModRM Fields out of range!");
 119     return RM | (RegOpcode << 3) | (Mod << 6);
 120   }
 121
 122   void EmitRegModRMByte(const MCOperand &ModRMReg, unsigned RegOpcodeFld,
 123                         unsigned &CurByte, raw_ostream &OS) const {
 124     EmitByte(ModRMByte(3, RegOpcodeFld, GetX86RegNum(ModRMReg)), CurByte, OS);
 125   }
 126
 127   void EmitSIBByte(unsigned SS, unsigned Index, unsigned Base,
 128                    unsigned &CurByte, raw_ostream &OS) const {
 129     // SIB byte is in the same format as the ModRMByte.
 130     EmitByte(ModRMByte(SS, Index, Base), CurByte, OS);
 131   }
 132
 133   void emitMemModRMByte(const MCInst &MI, unsigned Op, unsigned RegOpcodeField,
 134                         uint64_t TSFlags, bool Rex, unsigned &CurByte,
 135                         raw_ostream &OS, SmallVectorImpl<MCFixup> &Fixups,
 136                         const MCSubtargetInfo &STI) const;
 137
 138   void encodeInstruction(const MCInst &MI, raw_ostream &OS,
 139                          SmallVectorImpl<MCFixup> &Fixups,
 140                          const MCSubtargetInfo &STI) const override;
 141
 142   void EmitVEXOpcodePrefix(uint64_t TSFlags, unsigned &CurByte, int MemOperand,
 143                            const MCInst &MI, const MCInstrDesc &Desc,
 144                            raw_ostream &OS) const;
 145
 146   void EmitSegmentOverridePrefix(unsigned &CurByte, unsigned SegOperand,
 147                                  const MCInst &MI, raw_ostream &OS) const;
 148
 149   bool emitOpcodePrefix(uint64_t TSFlags, unsigned &CurByte, int MemOperand,
 150                         const MCInst &MI, const MCInstrDesc &Desc,
 151                         const MCSubtargetInfo &STI, raw_ostream &OS) const;
 152
 153   uint8_t DetermineREXPrefix(const MCInst &MI, uint64_t TSFlags,
 154                              int MemOperand, const MCInstrDesc &Desc) const;
 155
 156   bool isPCRel32Branch(const MCInst &MI) const;
 157 };
 158
 159 } // end anonymous namespace
 160
 161 /// isDisp8 - Return true if this signed displacement fits in a 8-bit
 162 /// sign-extended field.
 163 static bool isDisp8(int Value) {
 164   return Value == (int8_t)Value;
 165 }
 166
 167 /// isCDisp8 - Return true if this signed displacement fits in a 8-bit
 168 /// compressed dispacement field.
 169 static bool isCDisp8(uint64_t TSFlags, int Value, int& CValue) {
 170   assert(((TSFlags & X86II::EncodingMask) == X86II::EVEX) &&
 171          "Compressed 8-bit displacement is only valid for EVEX inst.");
 172
 173   unsigned CD8_Scale =
 174     (TSFlags & X86II::CD8_Scale_Mask) >> X86II::CD8_Scale_Shift;
 175   if (CD8_Scale == 0) {
 176     CValue = Value;
 177     return isDisp8(Value);
 178   }
 179
 180   unsigned Mask = CD8_Scale - 1;
 181   assert((CD8_Scale & Mask) == 0 && "Invalid memory object size.");
 182   if (Value & Mask) // Unaligned offset
 183     return false;
 184   Value /= (int)CD8_Scale;
 185   bool Ret = (Value == (int8_t)Value);
 186
 187   if (Ret)
 188     CValue = Value;
 189   return Ret;
 190 }
 191
 192 /// getImmFixupKind - Return the appropriate fixup kind to use for an immediate
 193 /// in an instruction with the specified TSFlags.
 194 static MCFixupKind getImmFixupKind(uint64_t TSFlags) {
 195   unsigned Size = X86II::getSizeOfImm(TSFlags);
 196   bool isPCRel = X86II::isImmPCRel(TSFlags);
 197
 198   if (X86II::isImmSigned(TSFlags)) {
 199     switch (Size) {
 200     default: llvm_unreachable("Unsupported signed fixup size!");
 201     case 4: return MCFixupKind(X86::reloc_signed_4byte);
 202     }
 203   }
 204   return MCFixup::getKindForSize(Size, isPCRel);
 205 }
 206
 207 /// Is32BitMemOperand - Return true if the specified instruction has
 208 /// a 32-bit memory operand. Op specifies the operand # of the memoperand.
 209 static bool Is32BitMemOperand(const MCInst &MI, unsigned Op) {
 210   const MCOperand &BaseReg  = MI.getOperand(Op+X86::AddrBaseReg);
 211   const MCOperand &IndexReg = MI.getOperand(Op+X86::AddrIndexReg);
 212
 213   if ((BaseReg.getReg() != 0 &&
 214        X86MCRegisterClasses[X86::GR32RegClassID].contains(BaseReg.getReg())) ||
 215       (IndexReg.getReg() != 0 &&
 216        X86MCRegisterClasses[X86::GR32RegClassID].contains(IndexReg.getReg())))
 217     return true;
 218   if (BaseReg.getReg() == X86::EIP) {
 219     assert(IndexReg.getReg() == 0 && "Invalid eip-based address.");
 220     return true;
 221   }
 222   return false;
 223 }
 224
 225 /// Is64BitMemOperand - Return true if the specified instruction has
 226 /// a 64-bit memory operand. Op specifies the operand # of the memoperand.
 227 #ifndef NDEBUG
 228 static bool Is64BitMemOperand(const MCInst &MI, unsigned Op) {
 229   const MCOperand &BaseReg  = MI.getOperand(Op+X86::AddrBaseReg);
 230   const MCOperand &IndexReg = MI.getOperand(Op+X86::AddrIndexReg);
 231
 232   if ((BaseReg.getReg() != 0 &&
 233        X86MCRegisterClasses[X86::GR64RegClassID].contains(BaseReg.getReg())) ||
 234       (IndexReg.getReg() != 0 &&
 235        X86MCRegisterClasses[X86::GR64RegClassID].contains(IndexReg.getReg())))
 236     return true;
 237   return false;
 238 }
 239 #endif
 240
 241 /// StartsWithGlobalOffsetTable - Check if this expression starts with
 242 ///  _GLOBAL_OFFSET_TABLE_ and if it is of the form
 243 ///  _GLOBAL_OFFSET_TABLE_-symbol. This is needed to support PIC on ELF
 244 /// i386 as _GLOBAL_OFFSET_TABLE_ is magical. We check only simple case that
 245 /// are know to be used: _GLOBAL_OFFSET_TABLE_ by itself or at the start
 246 /// of a binary expression.
 247 enum GlobalOffsetTableExprKind {
 248   GOT_None,
 249   GOT_Normal,
 250   GOT_SymDiff
 251 };
 252 static GlobalOffsetTableExprKind
 253 StartsWithGlobalOffsetTable(const MCExpr *Expr) {
 254   const MCExpr *RHS = nullptr;
 255   if (Expr->getKind() == MCExpr::Binary) {
 256     const MCBinaryExpr *BE = static_cast<const MCBinaryExpr *>(Expr);
 257     Expr = BE->getLHS();
 258     RHS = BE->getRHS();
 259   }
 260
 261   if (Expr->getKind() != MCExpr::SymbolRef)
 262     return GOT_None;
 263
 264   const MCSymbolRefExpr *Ref = static_cast<const MCSymbolRefExpr*>(Expr);
 265   const MCSymbol &S = Ref->getSymbol();
 266   if (S.getName() != "_GLOBAL_OFFSET_TABLE_")
 267     return GOT_None;
 268   if (RHS && RHS->getKind() == MCExpr::SymbolRef)
 269     return GOT_SymDiff;
 270   return GOT_Normal;
 271 }
 272
 273 static bool HasSecRelSymbolRef(const MCExpr *Expr) {
 274   if (Expr->getKind() == MCExpr::SymbolRef) {
 275     const MCSymbolRefExpr *Ref = static_cast<const MCSymbolRefExpr*>(Expr);
 276     return Ref->getKind() == MCSymbolRefExpr::VK_SECREL;
 277   }
 278   return false;
 279 }
 280
 281 bool X86MCCodeEmitter::isPCRel32Branch(const MCInst &MI) const {
 282   unsigned Opcode = MI.getOpcode();
 283   const MCInstrDesc &Desc = MCII.get(Opcode);
 284   if ((Opcode != X86::CALL64pcrel32 && Opcode != X86::JMP_4) ||
 285       getImmFixupKind(Desc.TSFlags) != FK_PCRel_4)
 286     return false;
 287
 288   unsigned CurOp = X86II::getOperandBias(Desc);
 289   const MCOperand &Op = MI.getOperand(CurOp);
 290   if (!Op.isExpr())
 291     return false;
 292
 293   const MCSymbolRefExpr *Ref = dyn_cast<MCSymbolRefExpr>(Op.getExpr());
 294   return Ref && Ref->getKind() == MCSymbolRefExpr::VK_None;
 295 }
 296
 297 void X86MCCodeEmitter::
 298 EmitImmediate(const MCOperand &DispOp, SMLoc Loc, unsigned Size,
 299               MCFixupKind FixupKind, unsigned &CurByte, raw_ostream &OS,
 300               SmallVectorImpl<MCFixup> &Fixups, int ImmOffset) const {
 301   const MCExpr *Expr = nullptr;
 302   if (DispOp.isImm()) {
 303     // If this is a simple integer displacement that doesn't require a
 304     // relocation, emit it now.
 305     if (FixupKind != FK_PCRel_1 &&
 306         FixupKind != FK_PCRel_2 &&
 307         FixupKind != FK_PCRel_4) {
 308       EmitConstant(DispOp.getImm()+ImmOffset, Size, CurByte, OS);
 309       return;
 310     }
 311     Expr = MCConstantExpr::create(DispOp.getImm(), Ctx);
 312   } else {
 313     Expr = DispOp.getExpr();
 314   }
 315
 316   // If we have an immoffset, add it to the expression.
 317   if ((FixupKind == FK_Data_4 ||
 318        FixupKind == FK_Data_8 ||
 319        FixupKind == MCFixupKind(X86::reloc_signed_4byte))) {
 320     GlobalOffsetTableExprKind Kind = StartsWithGlobalOffsetTable(Expr);
 321     if (Kind != GOT_None) {
 322       assert(ImmOffset == 0);
 323
 324       if (Size == 8) {
 325         FixupKind = MCFixupKind(X86::reloc_global_offset_table8);
 326       } else {
 327         assert(Size == 4);
 328         FixupKind = MCFixupKind(X86::reloc_global_offset_table);
 329       }
 330
 331       if (Kind == GOT_Normal)
 332         ImmOffset = CurByte;
 333     } else if (Expr->getKind() == MCExpr::SymbolRef) {
 334       if (HasSecRelSymbolRef(Expr)) {
 335         FixupKind = MCFixupKind(FK_SecRel_4);
 336       }
 337     } else if (Expr->getKind() == MCExpr::Binary) {
 338       const MCBinaryExpr *Bin = static_cast<const MCBinaryExpr*>(Expr);
 339       if (HasSecRelSymbolRef(Bin->getLHS())
 340           || HasSecRelSymbolRef(Bin->getRHS())) {
 341         FixupKind = MCFixupKind(FK_SecRel_4);
 342       }
 343     }
 344   }
 345
 346   // If the fixup is pc-relative, we need to bias the value to be relative to
 347   // the start of the field, not the end of the field.
 348   if (FixupKind == FK_PCRel_4 ||
 349       FixupKind == MCFixupKind(X86::reloc_riprel_4byte) ||
 350       FixupKind == MCFixupKind(X86::reloc_riprel_4byte_movq_load) ||
 351       FixupKind == MCFixupKind(X86::reloc_riprel_4byte_relax) ||
 352       FixupKind == MCFixupKind(X86::reloc_riprel_4byte_relax_rex) ||
 353       FixupKind == MCFixupKind(X86::reloc_branch_4byte_pcrel))
 354     ImmOffset -= 4;
 355   if (FixupKind == FK_PCRel_2)
 356     ImmOffset -= 2;
 357   if (FixupKind == FK_PCRel_1)
 358     ImmOffset -= 1;
 359
 360   if (ImmOffset)
 361     Expr = MCBinaryExpr::createAdd(Expr, MCConstantExpr::create(ImmOffset, Ctx),
 362                                    Ctx);
 363
 364   // Emit a symbolic constant as a fixup and 4 zeros.
 365   Fixups.push_back(MCFixup::create(CurByte, Expr, FixupKind, Loc));
 366   EmitConstant(0, Size, CurByte, OS);
 367 }
 368
 369 void X86MCCodeEmitter::emitMemModRMByte(const MCInst &MI, unsigned Op,
 370                                         unsigned RegOpcodeField,
 371                                         uint64_t TSFlags, bool Rex,
 372                                         unsigned &CurByte, raw_ostream &OS,
 373                                         SmallVectorImpl<MCFixup> &Fixups,
 374                                         const MCSubtargetInfo &STI) const {
 375   const MCOperand &Disp     = MI.getOperand(Op+X86::AddrDisp);
 376   const MCOperand &Base     = MI.getOperand(Op+X86::AddrBaseReg);
 377   const MCOperand &Scale    = MI.getOperand(Op+X86::AddrScaleAmt);
 378   const MCOperand &IndexReg = MI.getOperand(Op+X86::AddrIndexReg);
 379   unsigned BaseReg = Base.getReg();
 380   bool HasEVEX = (TSFlags & X86II::EncodingMask) == X86II::EVEX;
 381
 382   // Handle %rip relative addressing.
 383   if (BaseReg == X86::RIP ||
 384       BaseReg == X86::EIP) {    // [disp32+rIP] in X86-64 mode
 385     assert(is64BitMode(STI) && "Rip-relative addressing requires 64-bit mode");
 386     assert(IndexReg.getReg() == 0 && "Invalid rip-relative address");
 387     EmitByte(ModRMByte(0, RegOpcodeField, 5), CurByte, OS);
 388
 389     unsigned Opcode = MI.getOpcode();
 390     // movq loads are handled with a special relocation form which allows the
 391     // linker to eliminate some loads for GOT references which end up in the
 392     // same linkage unit.
 393     unsigned FixupKind = [=]() {
 394       switch (Opcode) {
 395       default:
 396         return X86::reloc_riprel_4byte;
 397       case X86::MOV64rm:
 398         assert(Rex);
 399         return X86::reloc_riprel_4byte_movq_load;
 400       case X86::CALL64m:
 401       case X86::JMP64m:
 402       case X86::TEST64mr:
 403       case X86::ADC64rm:
 404       case X86::ADD64rm:
 405       case X86::AND64rm:
 406       case X86::CMP64rm:
 407       case X86::OR64rm:
 408       case X86::SBB64rm:
 409       case X86::SUB64rm:
 410       case X86::XOR64rm:
 411         return Rex ? X86::reloc_riprel_4byte_relax_rex
 412                    : X86::reloc_riprel_4byte_relax;
 413       }
 414     }();
 415
 416     // rip-relative addressing is actually relative to the *next* instruction.
 417     // Since an immediate can follow the mod/rm byte for an instruction, this
 418     // means that we need to bias the displacement field of the instruction with
 419     // the size of the immediate field. If we have this case, add it into the
 420     // expression to emit.
 421     // Note: rip-relative addressing using immediate displacement values should
 422     // not be adjusted, assuming it was the user's intent.
 423     int ImmSize = !Disp.isImm() && X86II::hasImm(TSFlags)
 424                       ? X86II::getSizeOfImm(TSFlags)
 425                       : 0;
 426
 427     EmitImmediate(Disp, MI.getLoc(), 4, MCFixupKind(FixupKind),
 428                   CurByte, OS, Fixups, -ImmSize);
 429     return;
 430   }
 431
 432   unsigned BaseRegNo = BaseReg ? GetX86RegNum(Base) : -1U;
 433
 434   // 16-bit addressing forms of the ModR/M byte have a different encoding for
 435   // the R/M field and are far more limited in which registers can be used.
 436   if (Is16BitMemOperand(MI, Op, STI)) {
 437     if (BaseReg) {
 438       // For 32-bit addressing, the row and column values in Table 2-2 are
 439       // basically the same. It's AX/CX/DX/BX/SP/BP/SI/DI in that order, with
 440       // some special cases. And GetX86RegNum reflects that numbering.
 441       // For 16-bit addressing it's more fun, as shown in the SDM Vol 2A,
 442       // Table 2-1 "16-Bit Addressing Forms with the ModR/M byte". We can only
 443       // use SI/DI/BP/BX, which have "row" values 4-7 in no particular order,
 444       // while values 0-3 indicate the allowed combinations (base+index) of
 445       // those: 0 for BX+SI, 1 for BX+DI, 2 for BP+SI, 3 for BP+DI.
 446       //
 447       // R16Table[] is a lookup from the normal RegNo, to the row values from
 448       // Table 2-1 for 16-bit addressing modes. Where zero means disallowed.
 449       static const unsigned R16Table[] = { 0, 0, 0, 7, 0, 6, 4, 5 };
 450       unsigned RMfield = R16Table[BaseRegNo];
 451
 452       assert(RMfield && "invalid 16-bit base register");
 453
 454       if (IndexReg.getReg()) {
 455         unsigned IndexReg16 = R16Table[GetX86RegNum(IndexReg)];
 456
 457         assert(IndexReg16 && "invalid 16-bit index register");
 458         // We must have one of SI/DI (4,5), and one of BP/BX (6,7).
 459         assert(((IndexReg16 ^ RMfield) & 2) &&
 460                "invalid 16-bit base/index register combination");
 461         assert(Scale.getImm() == 1 &&
 462                "invalid scale for 16-bit memory reference");
 463
 464         // Allow base/index to appear in either order (although GAS doesn't).
 465         if (IndexReg16 & 2)
 466           RMfield = (RMfield & 1) | ((7 - IndexReg16) << 1);
 467         else
 468           RMfield = (IndexReg16 & 1) | ((7 - RMfield) << 1);
 469       }
 470
 471       if (Disp.isImm() && isDisp8(Disp.getImm())) {
 472         if (Disp.getImm() == 0 && BaseRegNo != N86::EBP) {
 473           // There is no displacement; just the register.
 474           EmitByte(ModRMByte(0, RegOpcodeField, RMfield), CurByte, OS);
 475           return;
 476         }
 477         // Use the [REG]+disp8 form, including for [BP] which cannot be encoded.
 478         EmitByte(ModRMByte(1, RegOpcodeField, RMfield), CurByte, OS);
 479         EmitImmediate(Disp, MI.getLoc(), 1, FK_Data_1, CurByte, OS, Fixups);
 480         return;
 481       }
 482       // This is the [REG]+disp16 case.
 483       EmitByte(ModRMByte(2, RegOpcodeField, RMfield), CurByte, OS);
 484     } else {
 485       // There is no BaseReg; this is the plain [disp16] case.
 486       EmitByte(ModRMByte(0, RegOpcodeField, 6), CurByte, OS);
 487     }
 488
 489     // Emit 16-bit displacement for plain disp16 or [REG]+disp16 cases.
 490     EmitImmediate(Disp, MI.getLoc(), 2, FK_Data_2, CurByte, OS, Fixups);
 491     return;
 492   }
 493
 494   // Determine whether a SIB byte is needed.
 495   // If no BaseReg, issue a RIP relative instruction only if the MCE can
 496   // resolve addresses on-the-fly, otherwise use SIB (Intel Manual 2A, table
 497   // 2-7) and absolute references.
 498
 499   if (// The SIB byte must be used if there is an index register.
 500       IndexReg.getReg() == 0 &&
 501       // The SIB byte must be used if the base is ESP/RSP/R12, all of which
 502       // encode to an R/M value of 4, which indicates that a SIB byte is
 503       // present.
 504       BaseRegNo != N86::ESP &&
 505       // If there is no base register and we're in 64-bit mode, we need a SIB
 506       // byte to emit an addr that is just 'disp32' (the non-RIP relative form).
 507       (!is64BitMode(STI) || BaseReg != 0)) {
 508
 509     if (BaseReg == 0) {          // [disp32]     in X86-32 mode
 510       EmitByte(ModRMByte(0, RegOpcodeField, 5), CurByte, OS);
 511       EmitImmediate(Disp, MI.getLoc(), 4, FK_Data_4, CurByte, OS, Fixups);
 512       return;
 513     }
 514
 515     // If the base is not EBP/ESP and there is no displacement, use simple
 516     // indirect register encoding, this handles addresses like [EAX].  The
 517     // encoding for [EBP] with no displacement means [disp32] so we handle it
 518     // by emitting a displacement of 0 below.
 519     if (Disp.isImm() && Disp.getImm() == 0 && BaseRegNo != N86::EBP) {
 520       EmitByte(ModRMByte(0, RegOpcodeField, BaseRegNo), CurByte, OS);
 521       return;
 522     }
 523
 524     // Otherwise, if the displacement fits in a byte, encode as [REG+disp8].
 525     if (Disp.isImm()) {
 526       if (!HasEVEX && isDisp8(Disp.getImm())) {
 527         EmitByte(ModRMByte(1, RegOpcodeField, BaseRegNo), CurByte, OS);
 528         EmitImmediate(Disp, MI.getLoc(), 1, FK_Data_1, CurByte, OS, Fixups);
 529         return;
 530       }
 531       // Try EVEX compressed 8-bit displacement first; if failed, fall back to
 532       // 32-bit displacement.
 533       int CDisp8 = 0;
 534       if (HasEVEX && isCDisp8(TSFlags, Disp.getImm(), CDisp8)) {
 535         EmitByte(ModRMByte(1, RegOpcodeField, BaseRegNo), CurByte, OS);
 536         EmitImmediate(Disp, MI.getLoc(), 1, FK_Data_1, CurByte, OS, Fixups,
 537                       CDisp8 - Disp.getImm());
 538         return;
 539       }
 540     }
 541
 542     // Otherwise, emit the most general non-SIB encoding: [REG+disp32]
 543     EmitByte(ModRMByte(2, RegOpcodeField, BaseRegNo), CurByte, OS);
 544     unsigned Opcode = MI.getOpcode();
 545     unsigned FixupKind = Opcode == X86::MOV32rm ? X86::reloc_signed_4byte_relax
 546                                                 : X86::reloc_signed_4byte;
 547     EmitImmediate(Disp, MI.getLoc(), 4, MCFixupKind(FixupKind), CurByte, OS,
 548                   Fixups);
 549     return;
 550   }
 551
 552   // We need a SIB byte, so start by outputting the ModR/M byte first
 553   assert(IndexReg.getReg() != X86::ESP &&
 554          IndexReg.getReg() != X86::RSP && "Cannot use ESP as index reg!");
 555
 556   bool ForceDisp32 = false;
 557   bool ForceDisp8  = false;
 558   int CDisp8 = 0;
 559   int ImmOffset = 0;
 560   if (BaseReg == 0) {
 561     // If there is no base register, we emit the special case SIB byte with
 562     // MOD=0, BASE=5, to JUST get the index, scale, and displacement.
 563     EmitByte(ModRMByte(0, RegOpcodeField, 4), CurByte, OS);
 564     ForceDisp32 = true;
 565   } else if (!Disp.isImm()) {
 566     // Emit the normal disp32 encoding.
 567     EmitByte(ModRMByte(2, RegOpcodeField, 4), CurByte, OS);
 568     ForceDisp32 = true;
 569   } else if (Disp.getImm() == 0 &&
 570              // Base reg can't be anything that ends up with '5' as the base
 571              // reg, it is the magic [*] nomenclature that indicates no base.
 572              BaseRegNo != N86::EBP) {
 573     // Emit no displacement ModR/M byte
 574     EmitByte(ModRMByte(0, RegOpcodeField, 4), CurByte, OS);
 575   } else if (!HasEVEX && isDisp8(Disp.getImm())) {
 576     // Emit the disp8 encoding.
 577     EmitByte(ModRMByte(1, RegOpcodeField, 4), CurByte, OS);
 578     ForceDisp8 = true;           // Make sure to force 8 bit disp if Base=EBP
 579   } else if (HasEVEX && isCDisp8(TSFlags, Disp.getImm(), CDisp8)) {
 580     // Emit the disp8 encoding.
 581     EmitByte(ModRMByte(1, RegOpcodeField, 4), CurByte, OS);
 582     ForceDisp8 = true;           // Make sure to force 8 bit disp if Base=EBP
 583     ImmOffset = CDisp8 - Disp.getImm();
 584   } else {
 585     // Emit the normal disp32 encoding.
 586     EmitByte(ModRMByte(2, RegOpcodeField, 4), CurByte, OS);
 587   }
 588
 589   // Calculate what the SS field value should be...
 590   static const unsigned SSTable[] = { ~0U, 0, 1, ~0U, 2, ~0U, ~0U, ~0U, 3 };
 591   unsigned SS = SSTable[Scale.getImm()];
 592
 593   if (BaseReg == 0) {
 594     // Handle the SIB byte for the case where there is no base, see Intel
 595     // Manual 2A, table 2-7. The displacement has already been output.
 596     unsigned IndexRegNo;
 597     if (IndexReg.getReg())
 598       IndexRegNo = GetX86RegNum(IndexReg);
 599     else // Examples: [ESP+1*<noreg>+4] or [scaled idx]+disp32 (MOD=0,BASE=5)
 600       IndexRegNo = 4;
 601     EmitSIBByte(SS, IndexRegNo, 5, CurByte, OS);
 602   } else {
 603     unsigned IndexRegNo;
 604     if (IndexReg.getReg())
 605       IndexRegNo = GetX86RegNum(IndexReg);
 606     else
 607       IndexRegNo = 4;   // For example [ESP+1*<noreg>+4]
 608     EmitSIBByte(SS, IndexRegNo, GetX86RegNum(Base), CurByte, OS);
 609   }
 610
 611   // Do we need to output a displacement?
 612   if (ForceDisp8)
 613     EmitImmediate(Disp, MI.getLoc(), 1, FK_Data_1, CurByte, OS, Fixups, ImmOffset);
 614   else if (ForceDisp32 || Disp.getImm() != 0)
 615     EmitImmediate(Disp, MI.getLoc(), 4, MCFixupKind(X86::reloc_signed_4byte),
 616                   CurByte, OS, Fixups);
 617 }
 618
 619 /// EmitVEXOpcodePrefix - AVX instructions are encoded using a opcode prefix
 620 /// called VEX.
 621 void X86MCCodeEmitter::EmitVEXOpcodePrefix(uint64_t TSFlags, unsigned &CurByte,
 622                                            int MemOperand, const MCInst &MI,
 623                                            const MCInstrDesc &Desc,
 624                                            raw_ostream &OS) const {
 625   assert(!(TSFlags & X86II::LOCK) && "Can't have LOCK VEX.");
 626
 627   uint64_t Encoding = TSFlags & X86II::EncodingMask;
 628   bool HasEVEX_K = TSFlags & X86II::EVEX_K;
 629   bool HasVEX_4V = TSFlags & X86II::VEX_4V;
 630   bool HasEVEX_RC = TSFlags & X86II::EVEX_RC;
 631
 632   // VEX_R: opcode externsion equivalent to REX.R in
 633   // 1's complement (inverted) form
 634   //
 635   //  1: Same as REX_R=0 (must be 1 in 32-bit mode)
 636   //  0: Same as REX_R=1 (64 bit mode only)
 637   //
 638   uint8_t VEX_R = 0x1;
 639   uint8_t EVEX_R2 = 0x1;
 640
 641   // VEX_X: equivalent to REX.X, only used when a
 642   // register is used for index in SIB Byte.
 643   //
 644   //  1: Same as REX.X=0 (must be 1 in 32-bit mode)
 645   //  0: Same as REX.X=1 (64-bit mode only)
 646   uint8_t VEX_X = 0x1;
 647
 648   // VEX_B:
 649   //
 650   //  1: Same as REX_B=0 (ignored in 32-bit mode)
 651   //  0: Same as REX_B=1 (64 bit mode only)
 652   //
 653   uint8_t VEX_B = 0x1;
 654
 655   // VEX_W: opcode specific (use like REX.W, or used for
 656   // opcode extension, or ignored, depending on the opcode byte)
 657   uint8_t VEX_W = (TSFlags & X86II::VEX_W) ? 1 : 0;
 658
 659   // VEX_5M (VEX m-mmmmm field):
 660   //
 661   //  0b00000: Reserved for future use
 662   //  0b00001: implied 0F leading opcode
 663   //  0b00010: implied 0F 38 leading opcode bytes
 664   //  0b00011: implied 0F 3A leading opcode bytes
 665   //  0b00100-0b11111: Reserved for future use
 666   //  0b01000: XOP map select - 08h instructions with imm byte
 667   //  0b01001: XOP map select - 09h instructions with no imm byte
 668   //  0b01010: XOP map select - 0Ah instructions with imm dword
 669   uint8_t VEX_5M;
 670   switch (TSFlags & X86II::OpMapMask) {
 671   default: llvm_unreachable("Invalid prefix!");
 672   case X86II::TB:   VEX_5M = 0x1; break; // 0F
 673   case X86II::T8:   VEX_5M = 0x2; break; // 0F 38
 674   case X86II::TA:   VEX_5M = 0x3; break; // 0F 3A
 675   case X86II::XOP8: VEX_5M = 0x8; break;
 676   case X86II::XOP9: VEX_5M = 0x9; break;
 677   case X86II::XOPA: VEX_5M = 0xA; break;
 678   }
 679
 680   // VEX_4V (VEX vvvv field): a register specifier
 681   // (in 1's complement form) or 1111 if unused.
 682   uint8_t VEX_4V = 0xf;
 683   uint8_t EVEX_V2 = 0x1;
 684
 685   // EVEX_L2/VEX_L (Vector Length):
 686   //
 687   // L2 L
 688   //  0 0: scalar or 128-bit vector
 689   //  0 1: 256-bit vector
 690   //  1 0: 512-bit vector
 691   //
 692   uint8_t VEX_L = (TSFlags & X86II::VEX_L) ? 1 : 0;
 693   uint8_t EVEX_L2 = (TSFlags & X86II::EVEX_L2) ? 1 : 0;
 694
 695   // VEX_PP: opcode extension providing equivalent
 696   // functionality of a SIMD prefix
 697   //
 698   //  0b00: None
 699   //  0b01: 66
 700   //  0b10: F3
 701   //  0b11: F2
 702   //
 703   uint8_t VEX_PP;
 704   switch (TSFlags & X86II::OpPrefixMask) {
 705   default: llvm_unreachable("Invalid op prefix!");
 706   case X86II::PS: VEX_PP = 0x0; break; // none
 707   case X86II::PD: VEX_PP = 0x1; break; // 66
 708   case X86II::XS: VEX_PP = 0x2; break; // F3
 709   case X86II::XD: VEX_PP = 0x3; break; // F2
 710   }
 711
 712   // EVEX_U
 713   uint8_t EVEX_U = 1; // Always '1' so far
 714
 715   // EVEX_z
 716   uint8_t EVEX_z = (HasEVEX_K && (TSFlags & X86II::EVEX_Z)) ? 1 : 0;
 717
 718   // EVEX_b
 719   uint8_t EVEX_b = (TSFlags & X86II::EVEX_B) ? 1 : 0;
 720
 721   // EVEX_rc
 722   uint8_t EVEX_rc = 0;
 723
 724   // EVEX_aaa
 725   uint8_t EVEX_aaa = 0;
 726
 727   bool EncodeRC = false;
 728
 729   // Classify VEX_B, VEX_4V, VEX_R, VEX_X
 730   unsigned NumOps = Desc.getNumOperands();
 731   unsigned CurOp = X86II::getOperandBias(Desc);
 732
 733   switch (TSFlags & X86II::FormMask) {
 734   default: llvm_unreachable("Unexpected form in EmitVEXOpcodePrefix!");
 735   case X86II::RawFrm:
 736     break;
 737   case X86II::MRMDestMem: {
 738     // MRMDestMem instructions forms:
 739     //  MemAddr, src1(ModR/M)
 740     //  MemAddr, src1(VEX_4V), src2(ModR/M)
 741     //  MemAddr, src1(ModR/M), imm8
 742     //
 743     unsigned BaseRegEnc = getX86RegEncoding(MI, MemOperand + X86::AddrBaseReg);
 744     VEX_B = ~(BaseRegEnc >> 3) & 1;
 745     unsigned IndexRegEnc = getX86RegEncoding(MI, MemOperand+X86::AddrIndexReg);
 746     VEX_X = ~(IndexRegEnc >> 3) & 1;
 747     if (!HasVEX_4V) // Only needed with VSIB which don't use VVVV.
 748       EVEX_V2 = ~(IndexRegEnc >> 4) & 1;
 749
 750     CurOp += X86::AddrNumOperands;
 751
 752     if (HasEVEX_K)
 753       EVEX_aaa = getX86RegEncoding(MI, CurOp++);
 754
 755     if (HasVEX_4V) {
 756       unsigned VRegEnc = getX86RegEncoding(MI, CurOp++);
 757       VEX_4V = ~VRegEnc & 0xf;
 758       EVEX_V2 = ~(VRegEnc >> 4) & 1;
 759     }
 760
 761     unsigned RegEnc = getX86RegEncoding(MI, CurOp++);
 762     VEX_R = ~(RegEnc >> 3) & 1;
 763     EVEX_R2 = ~(RegEnc >> 4) & 1;
 764     break;
 765   }
 766   case X86II::MRMSrcMem: {
 767     // MRMSrcMem instructions forms:
 768     //  src1(ModR/M), MemAddr
 769     //  src1(ModR/M), src2(VEX_4V), MemAddr
 770     //  src1(ModR/M), MemAddr, imm8
 771     //  src1(ModR/M), MemAddr, src2(Imm[7:4])
 772     //
 773     //  FMA4:
 774     //  dst(ModR/M.reg), src1(VEX_4V), src2(ModR/M), src3(Imm[7:4])
 775     unsigned RegEnc = getX86RegEncoding(MI, CurOp++);
 776     VEX_R = ~(RegEnc >> 3) & 1;
 777     EVEX_R2 = ~(RegEnc >> 4) & 1;
 778
 779     if (HasEVEX_K)
 780       EVEX_aaa = getX86RegEncoding(MI, CurOp++);
 781
 782     if (HasVEX_4V) {
 783       unsigned VRegEnc = getX86RegEncoding(MI, CurOp++);
 784       VEX_4V = ~VRegEnc & 0xf;
 785       EVEX_V2 = ~(VRegEnc >> 4) & 1;
 786     }
 787
 788     unsigned BaseRegEnc = getX86RegEncoding(MI, MemOperand + X86::AddrBaseReg);
 789     VEX_B = ~(BaseRegEnc >> 3) & 1;
 790     unsigned IndexRegEnc = getX86RegEncoding(MI, MemOperand+X86::AddrIndexReg);
 791     VEX_X = ~(IndexRegEnc >> 3) & 1;
 792     if (!HasVEX_4V) // Only needed with VSIB which don't use VVVV.
 793       EVEX_V2 = ~(IndexRegEnc >> 4) & 1;
 794
 795     break;
 796   }
 797   case X86II::MRMSrcMem4VOp3: {
 798     // Instruction format for 4VOp3:
 799     //   src1(ModR/M), MemAddr, src3(VEX_4V)
 800     unsigned RegEnc = getX86RegEncoding(MI, CurOp++);
 801     VEX_R = ~(RegEnc >> 3) & 1;
 802
 803     unsigned BaseRegEnc = getX86RegEncoding(MI, MemOperand + X86::AddrBaseReg);
 804     VEX_B = ~(BaseRegEnc >> 3) & 1;
 805     unsigned IndexRegEnc = getX86RegEncoding(MI, MemOperand+X86::AddrIndexReg);
 806     VEX_X = ~(IndexRegEnc >> 3) & 1;
 807
 808     VEX_4V = ~getX86RegEncoding(MI, CurOp + X86::AddrNumOperands) & 0xf;
 809     break;
 810   }
 811   case X86II::MRMSrcMemOp4: {
 812     //  dst(ModR/M.reg), src1(VEX_4V), src2(Imm[7:4]), src3(ModR/M),
 813     unsigned RegEnc = getX86RegEncoding(MI, CurOp++);
 814     VEX_R = ~(RegEnc >> 3) & 1;
 815
 816     unsigned VRegEnc = getX86RegEncoding(MI, CurOp++);
 817     VEX_4V = ~VRegEnc & 0xf;
 818
 819     unsigned BaseRegEnc = getX86RegEncoding(MI, MemOperand + X86::AddrBaseReg);
 820     VEX_B = ~(BaseRegEnc >> 3) & 1;
 821     unsigned IndexRegEnc = getX86RegEncoding(MI, MemOperand+X86::AddrIndexReg);
 822     VEX_X = ~(IndexRegEnc >> 3) & 1;
 823     break;
 824   }
 825   case X86II::MRM0m: case X86II::MRM1m:
 826   case X86II::MRM2m: case X86II::MRM3m:
 827   case X86II::MRM4m: case X86II::MRM5m:
 828   case X86II::MRM6m: case X86II::MRM7m: {
 829     // MRM[0-9]m instructions forms:
 830     //  MemAddr
 831     //  src1(VEX_4V), MemAddr
 832     if (HasVEX_4V) {
 833       unsigned VRegEnc = getX86RegEncoding(MI, CurOp++);
 834       VEX_4V = ~VRegEnc & 0xf;
 835       EVEX_V2 = ~(VRegEnc >> 4) & 1;
 836     }
 837
 838     if (HasEVEX_K)
 839       EVEX_aaa = getX86RegEncoding(MI, CurOp++);
 840
 841     unsigned BaseRegEnc = getX86RegEncoding(MI, MemOperand + X86::AddrBaseReg);
 842     VEX_B = ~(BaseRegEnc >> 3) & 1;
 843     unsigned IndexRegEnc = getX86RegEncoding(MI, MemOperand+X86::AddrIndexReg);
 844     VEX_X = ~(IndexRegEnc >> 3) & 1;
 845     break;
 846   }
 847   case X86II::MRMSrcReg: {
 848     // MRMSrcReg instructions forms:
 849     //  dst(ModR/M), src1(VEX_4V), src2(ModR/M), src3(Imm[7:4])
 850     //  dst(ModR/M), src1(ModR/M)
 851     //  dst(ModR/M), src1(ModR/M), imm8
 852     //
 853     //  FMA4:
 854     //  dst(ModR/M.reg), src1(VEX_4V), src2(Imm[7:4]), src3(ModR/M),
 855     unsigned RegEnc = getX86RegEncoding(MI, CurOp++);
 856     VEX_R = ~(RegEnc >> 3) & 1;
 857     EVEX_R2 = ~(RegEnc >> 4) & 1;
 858
 859     if (HasEVEX_K)
 860       EVEX_aaa = getX86RegEncoding(MI, CurOp++);
 861
 862     if (HasVEX_4V) {
 863       unsigned VRegEnc = getX86RegEncoding(MI, CurOp++);
 864       VEX_4V = ~VRegEnc & 0xf;
 865       EVEX_V2 = ~(VRegEnc >> 4) & 1;
 866     }
 867
 868     RegEnc = getX86RegEncoding(MI, CurOp++);
 869     VEX_B = ~(RegEnc >> 3) & 1;
 870     VEX_X = ~(RegEnc >> 4) & 1;
 871
 872     if (EVEX_b) {
 873       if (HasEVEX_RC) {
 874         unsigned RcOperand = NumOps-1;
 875         assert(RcOperand >= CurOp);
 876         EVEX_rc = MI.getOperand(RcOperand).getImm() & 0x3;
 877       }
 878       EncodeRC = true;
 879     }
 880     break;
 881   }
 882   case X86II::MRMSrcReg4VOp3: {
 883     // Instruction format for 4VOp3:
 884     //   src1(ModR/M), src2(ModR/M), src3(VEX_4V)
 885     unsigned RegEnc = getX86RegEncoding(MI, CurOp++);
 886     VEX_R = ~(RegEnc >> 3) & 1;
 887
 888     RegEnc = getX86RegEncoding(MI, CurOp++);
 889     VEX_B = ~(RegEnc >> 3) & 1;
 890
 891     VEX_4V = ~getX86RegEncoding(MI, CurOp++) & 0xf;
 892     break;
 893   }
 894   case X86II::MRMSrcRegOp4: {
 895     //  dst(ModR/M.reg), src1(VEX_4V), src2(Imm[7:4]), src3(ModR/M),
 896     unsigned RegEnc = getX86RegEncoding(MI, CurOp++);
 897     VEX_R = ~(RegEnc >> 3) & 1;
 898
 899     unsigned VRegEnc = getX86RegEncoding(MI, CurOp++);
 900     VEX_4V = ~VRegEnc & 0xf;
 901
 902     // Skip second register source (encoded in Imm[7:4])
 903     ++CurOp;
 904
 905     RegEnc = getX86RegEncoding(MI, CurOp++);
 906     VEX_B = ~(RegEnc >> 3) & 1;
 907     VEX_X = ~(RegEnc >> 4) & 1;
 908     break;
 909   }
 910   case X86II::MRMDestReg: {
 911     // MRMDestReg instructions forms:
 912     //  dst(ModR/M), src(ModR/M)
 913     //  dst(ModR/M), src(ModR/M), imm8
 914     //  dst(ModR/M), src1(VEX_4V), src2(ModR/M)
 915     unsigned RegEnc = getX86RegEncoding(MI, CurOp++);
 916     VEX_B = ~(RegEnc >> 3) & 1;
 917     VEX_X = ~(RegEnc >> 4) & 1;
 918
 919     if (HasEVEX_K)
 920       EVEX_aaa = getX86RegEncoding(MI, CurOp++);
 921
 922     if (HasVEX_4V) {
 923       unsigned VRegEnc = getX86RegEncoding(MI, CurOp++);
 924       VEX_4V = ~VRegEnc & 0xf;
 925       EVEX_V2 = ~(VRegEnc >> 4) & 1;
 926     }
 927
 928     RegEnc = getX86RegEncoding(MI, CurOp++);
 929     VEX_R = ~(RegEnc >> 3) & 1;
 930     EVEX_R2 = ~(RegEnc >> 4) & 1;
 931     if (EVEX_b)
 932       EncodeRC = true;
 933     break;
 934   }
 935   case X86II::MRM0r: case X86II::MRM1r:
 936   case X86II::MRM2r: case X86II::MRM3r:
 937   case X86II::MRM4r: case X86II::MRM5r:
 938   case X86II::MRM6r: case X86II::MRM7r: {
 939     // MRM0r-MRM7r instructions forms:
 940     //  dst(VEX_4V), src(ModR/M), imm8
 941     if (HasVEX_4V) {
 942       unsigned VRegEnc = getX86RegEncoding(MI, CurOp++);
 943       VEX_4V = ~VRegEnc & 0xf;
 944       EVEX_V2 = ~(VRegEnc >> 4) & 1;
 945     }
 946     if (HasEVEX_K)
 947       EVEX_aaa = getX86RegEncoding(MI, CurOp++);
 948
 949     unsigned RegEnc = getX86RegEncoding(MI, CurOp++);
 950     VEX_B = ~(RegEnc >> 3) & 1;
 951     VEX_X = ~(RegEnc >> 4) & 1;
 952     break;
 953   }
 954   }
 955
 956   if (Encoding == X86II::VEX || Encoding == X86II::XOP) {
 957     // VEX opcode prefix can have 2 or 3 bytes
 958     //
 959     //  3 bytes:
 960     //    +-----+ +--------------+ +-------------------+
 961     //    | C4h | | RXB | m-mmmm | | W | vvvv | L | pp |
 962     //    +-----+ +--------------+ +-------------------+
 963     //  2 bytes:
 964     //    +-----+ +-------------------+
 965     //    | C5h | | R | vvvv | L | pp |
 966     //    +-----+ +-------------------+
 967     //
 968     //  XOP uses a similar prefix:
 969     //    +-----+ +--------------+ +-------------------+
 970     //    | 8Fh | | RXB | m-mmmm | | W | vvvv | L | pp |
 971     //    +-----+ +--------------+ +-------------------+
 972     uint8_t LastByte = VEX_PP | (VEX_L << 2) | (VEX_4V << 3);
 973
 974     // Can we use the 2 byte VEX prefix?
 975     if (Encoding == X86II::VEX && VEX_B && VEX_X && !VEX_W && (VEX_5M == 1)) {
 976       EmitByte(0xC5, CurByte, OS);
 977       EmitByte(LastByte | (VEX_R << 7), CurByte, OS);
 978       return;
 979     }
 980
 981     // 3 byte VEX prefix
 982     EmitByte(Encoding == X86II::XOP ? 0x8F : 0xC4, CurByte, OS);
 983     EmitByte(VEX_R << 7 | VEX_X << 6 | VEX_B << 5 | VEX_5M, CurByte, OS);
 984     EmitByte(LastByte | (VEX_W << 7), CurByte, OS);
 985   } else {
 986     assert(Encoding == X86II::EVEX && "unknown encoding!");
 987     // EVEX opcode prefix can have 4 bytes
 988     //
 989     // +-----+ +--------------+ +-------------------+ +------------------------+
 990     // | 62h | | RXBR' | 00mm | | W | vvvv | U | pp | | z | L'L | b | v' | aaa |
 991     // +-----+ +--------------+ +-------------------+ +------------------------+
 992     assert((VEX_5M & 0x3) == VEX_5M
 993            && "More than 2 significant bits in VEX.m-mmmm fields for EVEX!");
 994
 995     EmitByte(0x62, CurByte, OS);
 996     EmitByte((VEX_R   << 7) |
 997              (VEX_X   << 6) |
 998              (VEX_B   << 5) |
 999              (EVEX_R2 << 4) |
1000              VEX_5M, CurByte, OS);
1001     EmitByte((VEX_W   << 7) |
1002              (VEX_4V  << 3) |
1003              (EVEX_U  << 2) |
1004              VEX_PP, CurByte, OS);
1005     if (EncodeRC)
1006       EmitByte((EVEX_z  << 7) |
1007                (EVEX_rc << 5) |
1008                (EVEX_b  << 4) |
1009                (EVEX_V2 << 3) |
1010                EVEX_aaa, CurByte, OS);
1011     else
1012       EmitByte((EVEX_z  << 7) |
1013                (EVEX_L2 << 6) |
1014                (VEX_L   << 5) |
1015                (EVEX_b  << 4) |
1016                (EVEX_V2 << 3) |
1017                EVEX_aaa, CurByte, OS);
1018   }
1019 }
1020
1021 /// DetermineREXPrefix - Determine if the MCInst has to be encoded with a X86-64
1022 /// REX prefix which specifies 1) 64-bit instructions, 2) non-default operand
1023 /// size, and 3) use of X86-64 extended registers.
1024 uint8_t X86MCCodeEmitter::DetermineREXPrefix(const MCInst &MI, uint64_t TSFlags,
1025                                              int MemOperand,
1026                                              const MCInstrDesc &Desc) const {
1027   uint8_t REX = 0;
1028   bool UsesHighByteReg = false;
1029
1030   if (TSFlags & X86II::REX_W)
1031     REX |= 1 << 3; // set REX.W
1032
1033   if (MI.getNumOperands() == 0) return REX;
1034
1035   unsigned NumOps = MI.getNumOperands();
1036   unsigned CurOp = X86II::getOperandBias(Desc);
1037
1038   // If it accesses SPL, BPL, SIL, or DIL, then it requires a 0x40 REX prefix.
1039   for (unsigned i = CurOp; i != NumOps; ++i) {
1040     const MCOperand &MO = MI.getOperand(i);
1041     if (!MO.isReg()) continue;
1042     unsigned Reg = MO.getReg();
1043     if (Reg == X86::AH || Reg == X86::BH || Reg == X86::CH || Reg == X86::DH)
1044       UsesHighByteReg = true;
1045     if (X86II::isX86_64NonExtLowByteReg(Reg))
1046       // FIXME: The caller of DetermineREXPrefix slaps this prefix onto anything
1047       // that returns non-zero.
1048       REX |= 0x40; // REX fixed encoding prefix
1049   }
1050
1051   switch (TSFlags & X86II::FormMask) {
1052   case X86II::AddRegFrm:
1053     REX |= isREXExtendedReg(MI, CurOp++) << 0; // REX.B
1054     break;
1055   case X86II::MRMSrcReg:
1056     REX |= isREXExtendedReg(MI, CurOp++) << 2; // REX.R
1057     REX |= isREXExtendedReg(MI, CurOp++) << 0; // REX.B
1058     break;
1059   case X86II::MRMSrcMem: {
1060     REX |= isREXExtendedReg(MI, CurOp++) << 2; // REX.R
1061     REX |= isREXExtendedReg(MI, MemOperand+X86::AddrBaseReg) << 0; // REX.B
1062     REX |= isREXExtendedReg(MI, MemOperand+X86::AddrIndexReg) << 1; // REX.X
1063     CurOp += X86::AddrNumOperands;
1064     break;
1065   }
1066   case X86II::MRMDestReg:
1067     REX |= isREXExtendedReg(MI, CurOp++) << 0; // REX.B
1068     REX |= isREXExtendedReg(MI, CurOp++) << 2; // REX.R
1069     break;
1070   case X86II::MRMDestMem:
1071     REX |= isREXExtendedReg(MI, MemOperand+X86::AddrBaseReg) << 0; // REX.B
1072     REX |= isREXExtendedReg(MI, MemOperand+X86::AddrIndexReg) << 1; // REX.X
1073     CurOp += X86::AddrNumOperands;
1074     REX |= isREXExtendedReg(MI, CurOp++) << 2; // REX.R
1075     break;
1076   case X86II::MRMXm:
1077   case X86II::MRM0m: case X86II::MRM1m:
1078   case X86II::MRM2m: case X86II::MRM3m:
1079   case X86II::MRM4m: case X86II::MRM5m:
1080   case X86II::MRM6m: case X86II::MRM7m:
1081     REX |= isREXExtendedReg(MI, MemOperand+X86::AddrBaseReg) << 0; // REX.B
1082     REX |= isREXExtendedReg(MI, MemOperand+X86::AddrIndexReg) << 1; // REX.X
1083     break;
1084   case X86II::MRMXr:
1085   case X86II::MRM0r: case X86II::MRM1r:
1086   case X86II::MRM2r: case X86II::MRM3r:
1087   case X86II::MRM4r: case X86II::MRM5r:
1088   case X86II::MRM6r: case X86II::MRM7r:
1089     REX |= isREXExtendedReg(MI, CurOp++) << 0; // REX.B
1090     break;
1091   }
1092   if (REX && UsesHighByteReg)
1093     report_fatal_error("Cannot encode high byte register in REX-prefixed instruction");
1094
1095   return REX;
1096 }
1097
1098 /// EmitSegmentOverridePrefix - Emit segment override opcode prefix as needed
1099 void X86MCCodeEmitter::EmitSegmentOverridePrefix(unsigned &CurByte,
1100                                                  unsigned SegOperand,
1101                                                  const MCInst &MI,
1102                                                  raw_ostream &OS) const {
1103   // Check for explicit segment override on memory operand.
1104   switch (MI.getOperand(SegOperand).getReg()) {
1105   default: llvm_unreachable("Unknown segment register!");
1106   case 0: break;
1107   case X86::CS: EmitByte(0x2E, CurByte, OS); break;
1108   case X86::SS: EmitByte(0x36, CurByte, OS); break;
1109   case X86::DS: EmitByte(0x3E, CurByte, OS); break;
1110   case X86::ES: EmitByte(0x26, CurByte, OS); break;
1111   case X86::FS: EmitByte(0x64, CurByte, OS); break;
1112   case X86::GS: EmitByte(0x65, CurByte, OS); break;
1113   }
1114 }
1115
1116 /// Emit all instruction prefixes prior to the opcode.
1117 ///
1118 /// MemOperand is the operand # of the start of a memory operand if present.  If
1119 /// Not present, it is -1.
1120 ///
1121 /// Returns true if a REX prefix was used.
1122 bool X86MCCodeEmitter::emitOpcodePrefix(uint64_t TSFlags, unsigned &CurByte,
1123                                         int MemOperand, const MCInst &MI,
1124                                         const MCInstrDesc &Desc,
1125                                         const MCSubtargetInfo &STI,
1126                                         raw_ostream &OS) const {
1127   bool Ret = false;
1128   // Emit the operand size opcode prefix as needed.
1129   if ((TSFlags & X86II::OpSizeMask) == (is16BitMode(STI) ? X86II::OpSize32
1130                                                          : X86II::OpSize16))
1131     EmitByte(0x66, CurByte, OS);
1132
1133   // Emit the LOCK opcode prefix.
1134   if (TSFlags & X86II::LOCK || MI.getFlags() & X86::IP_HAS_LOCK)
1135     EmitByte(0xF0, CurByte, OS);
1136
1137   switch (TSFlags & X86II::OpPrefixMask) {
1138   case X86II::PD:   // 66
1139     EmitByte(0x66, CurByte, OS);
1140     break;
1141   case X86II::XS:   // F3
1142     EmitByte(0xF3, CurByte, OS);
1143     break;
1144   case X86II::XD:   // F2
1145     EmitByte(0xF2, CurByte, OS);
1146     break;
1147   }
1148
1149   // Handle REX prefix.
1150   // FIXME: Can this come before F2 etc to simplify emission?
1151   if (is64BitMode(STI)) {
1152     if (uint8_t REX = DetermineREXPrefix(MI, TSFlags, MemOperand, Desc)) {
1153       EmitByte(0x40 | REX, CurByte, OS);
1154       Ret = true;
1155     }
1156   } else {
1157     assert(!(TSFlags & X86II::REX_W) && "REX.W requires 64bit mode.");
1158   }
1159
1160   // 0x0F escape code must be emitted just before the opcode.
1161   switch (TSFlags & X86II::OpMapMask) {
1162   case X86II::TB:  // Two-byte opcode map
1163   case X86II::T8:  // 0F 38
1164   case X86II::TA:  // 0F 3A
1165     EmitByte(0x0F, CurByte, OS);
1166     break;
1167   }
1168
1169   switch (TSFlags & X86II::OpMapMask) {
1170   case X86II::T8:    // 0F 38
1171     EmitByte(0x38, CurByte, OS);
1172     break;
1173   case X86II::TA:    // 0F 3A
1174     EmitByte(0x3A, CurByte, OS);
1175     break;
1176   }
1177   return Ret;
1178 }
1179
1180 void X86MCCodeEmitter::
1181 encodeInstruction(const MCInst &MI, raw_ostream &OS,
1182                   SmallVectorImpl<MCFixup> &Fixups,
1183                   const MCSubtargetInfo &STI) const {
1184   unsigned Opcode = MI.getOpcode();
1185   const MCInstrDesc &Desc = MCII.get(Opcode);
1186   uint64_t TSFlags = Desc.TSFlags;
1187   unsigned Flags = MI.getFlags();
1188
1189   // Pseudo instructions don't get encoded.
1190   if ((TSFlags & X86II::FormMask) == X86II::Pseudo)
1191     return;
1192
1193   unsigned NumOps = Desc.getNumOperands();
1194   unsigned CurOp = X86II::getOperandBias(Desc);
1195
1196   // Keep track of the current byte being emitted.
1197   unsigned CurByte = 0;
1198
1199   // Encoding type for this instruction.
1200   uint64_t Encoding = TSFlags & X86II::EncodingMask;
1201
1202   // It uses the VEX.VVVV field?
1203   bool HasVEX_4V = TSFlags & X86II::VEX_4V;
1204   bool HasVEX_I8Reg = (TSFlags & X86II::ImmMask) == X86II::Imm8Reg;
1205
1206   // It uses the EVEX.aaa field?
1207   bool HasEVEX_K = TSFlags & X86II::EVEX_K;
1208   bool HasEVEX_RC = TSFlags & X86II::EVEX_RC;
1209
1210   // Used if a register is encoded in 7:4 of immediate.
1211   unsigned I8RegNum = 0;
1212
1213   // Determine where the memory operand starts, if present.
1214   int MemoryOperand = X86II::getMemoryOperandNo(TSFlags);
1215   if (MemoryOperand != -1) MemoryOperand += CurOp;
1216
1217   // Emit segment override opcode prefix as needed.
1218   if (MemoryOperand >= 0)
1219     EmitSegmentOverridePrefix(CurByte, MemoryOperand+X86::AddrSegmentReg,
1220                               MI, OS);
1221
1222   // Emit the repeat opcode prefix as needed.
1223   if (TSFlags & X86II::REP || Flags & X86::IP_HAS_REPEAT)
1224     EmitByte(0xF3, CurByte, OS);
1225   if (Flags & X86::IP_HAS_REPEAT_NE)
1226     EmitByte(0xF2, CurByte, OS);
1227
1228   // Emit the address size opcode prefix as needed.
1229   bool need_address_override;
1230   uint64_t AdSize = TSFlags & X86II::AdSizeMask;
1231   if ((is16BitMode(STI) && AdSize == X86II::AdSize32) ||
1232       (is32BitMode(STI) && AdSize == X86II::AdSize16) ||
1233       (is64BitMode(STI) && AdSize == X86II::AdSize32)) {
1234     need_address_override = true;
1235   } else if (MemoryOperand < 0) {
1236     need_address_override = false;
1237   } else if (is64BitMode(STI)) {
1238     assert(!Is16BitMemOperand(MI, MemoryOperand, STI));
1239     need_address_override = Is32BitMemOperand(MI, MemoryOperand);
1240   } else if (is32BitMode(STI)) {
1241     assert(!Is64BitMemOperand(MI, MemoryOperand));
1242     need_address_override = Is16BitMemOperand(MI, MemoryOperand, STI);
1243   } else {
1244     assert(is16BitMode(STI));
1245     assert(!Is64BitMemOperand(MI, MemoryOperand));
1246     need_address_override = !Is16BitMemOperand(MI, MemoryOperand, STI);
1247   }
1248
1249   if (need_address_override)
1250     EmitByte(0x67, CurByte, OS);
1251
1252   bool Rex = false;
1253   if (Encoding == 0)
1254     Rex = emitOpcodePrefix(TSFlags, CurByte, MemoryOperand, MI, Desc, STI, OS);
1255   else
1256     EmitVEXOpcodePrefix(TSFlags, CurByte, MemoryOperand, MI, Desc, OS);
1257
1258   uint8_t BaseOpcode = X86II::getBaseOpcodeFor(TSFlags);
1259
1260   if (TSFlags & X86II::Has3DNow0F0FOpcode)
1261     BaseOpcode = 0x0F;   // Weird 3DNow! encoding.
1262
1263   uint64_t Form = TSFlags & X86II::FormMask;
1264   switch (Form) {
1265   default: errs() << "FORM: " << Form << "\n";
1266     llvm_unreachable("Unknown FormMask value in X86MCCodeEmitter!");
1267   case X86II::Pseudo:
1268     llvm_unreachable("Pseudo instruction shouldn't be emitted");
1269   case X86II::RawFrmDstSrc: {
1270     unsigned siReg = MI.getOperand(1).getReg();
1271     assert(((siReg == X86::SI && MI.getOperand(0).getReg() == X86::DI) ||
1272             (siReg == X86::ESI && MI.getOperand(0).getReg() == X86::EDI) ||
1273             (siReg == X86::RSI && MI.getOperand(0).getReg() == X86::RDI)) &&
1274            "SI and DI register sizes do not match");
1275     // Emit segment override opcode prefix as needed (not for %ds).
1276     if (MI.getOperand(2).getReg() != X86::DS)
1277       EmitSegmentOverridePrefix(CurByte, 2, MI, OS);
1278     // Emit AdSize prefix as needed.
1279     if ((!is32BitMode(STI) && siReg == X86::ESI) ||
1280         (is32BitMode(STI) && siReg == X86::SI))
1281       EmitByte(0x67, CurByte, OS);
1282     CurOp += 3; // Consume operands.
1283     EmitByte(BaseOpcode, CurByte, OS);
1284     break;
1285   }
1286   case X86II::RawFrmSrc: {
1287     unsigned siReg = MI.getOperand(0).getReg();
1288     // Emit segment override opcode prefix as needed (not for %ds).
1289     if (MI.getOperand(1).getReg() != X86::DS)
1290       EmitSegmentOverridePrefix(CurByte, 1, MI, OS);
1291     // Emit AdSize prefix as needed.
1292     if ((!is32BitMode(STI) && siReg == X86::ESI) ||
1293         (is32BitMode(STI) && siReg == X86::SI))
1294       EmitByte(0x67, CurByte, OS);
1295     CurOp += 2; // Consume operands.
1296     EmitByte(BaseOpcode, CurByte, OS);
1297     break;
1298   }
1299   case X86II::RawFrmDst: {
1300     unsigned siReg = MI.getOperand(0).getReg();
1301     // Emit AdSize prefix as needed.
1302     if ((!is32BitMode(STI) && siReg == X86::EDI) ||
1303         (is32BitMode(STI) && siReg == X86::DI))
1304       EmitByte(0x67, CurByte, OS);
1305     ++CurOp; // Consume operand.
1306     EmitByte(BaseOpcode, CurByte, OS);
1307     break;
1308   }
1309   case X86II::RawFrm: {
1310     EmitByte(BaseOpcode, CurByte, OS);
1311
1312     if (!is64BitMode(STI) || !isPCRel32Branch(MI))
1313       break;
1314
1315     const MCOperand &Op = MI.getOperand(CurOp++);
1316     EmitImmediate(Op, MI.getLoc(), X86II::getSizeOfImm(TSFlags),
1317                   MCFixupKind(X86::reloc_branch_4byte_pcrel), CurByte, OS,
1318                   Fixups);
1319     break;
1320   }
1321   case X86II::RawFrmMemOffs:
1322     // Emit segment override opcode prefix as needed.
1323     EmitSegmentOverridePrefix(CurByte, 1, MI, OS);
1324     EmitByte(BaseOpcode, CurByte, OS);
1325     EmitImmediate(MI.getOperand(CurOp++), MI.getLoc(),
1326                   X86II::getSizeOfImm(TSFlags), getImmFixupKind(TSFlags),
1327                   CurByte, OS, Fixups);
1328     ++CurOp; // skip segment operand
1329     break;
1330   case X86II::RawFrmImm8:
1331     EmitByte(BaseOpcode, CurByte, OS);
1332     EmitImmediate(MI.getOperand(CurOp++), MI.getLoc(),
1333                   X86II::getSizeOfImm(TSFlags), getImmFixupKind(TSFlags),
1334                   CurByte, OS, Fixups);
1335     EmitImmediate(MI.getOperand(CurOp++), MI.getLoc(), 1, FK_Data_1, CurByte,
1336                   OS, Fixups);
1337     break;
1338   case X86II::RawFrmImm16:
1339     EmitByte(BaseOpcode, CurByte, OS);
1340     EmitImmediate(MI.getOperand(CurOp++), MI.getLoc(),
1341                   X86II::getSizeOfImm(TSFlags), getImmFixupKind(TSFlags),
1342                   CurByte, OS, Fixups);
1343     EmitImmediate(MI.getOperand(CurOp++), MI.getLoc(), 2, FK_Data_2, CurByte,
1344                   OS, Fixups);
1345     break;
1346
1347   case X86II::AddRegFrm:
1348     EmitByte(BaseOpcode + GetX86RegNum(MI.getOperand(CurOp++)), CurByte, OS);
1349     break;
1350
1351   case X86II::MRMDestReg: {
1352     EmitByte(BaseOpcode, CurByte, OS);
1353     unsigned SrcRegNum = CurOp + 1;
1354
1355     if (HasEVEX_K) // Skip writemask
1356       ++SrcRegNum;
1357
1358     if (HasVEX_4V) // Skip 1st src (which is encoded in VEX_VVVV)
1359       ++SrcRegNum;
1360
1361     EmitRegModRMByte(MI.getOperand(CurOp),
1362                      GetX86RegNum(MI.getOperand(SrcRegNum)), CurByte, OS);
1363     CurOp = SrcRegNum + 1;
1364     break;
1365   }
1366   case X86II::MRMDestMem: {
1367     EmitByte(BaseOpcode, CurByte, OS);
1368     unsigned SrcRegNum = CurOp + X86::AddrNumOperands;
1369
1370     if (HasEVEX_K) // Skip writemask
1371       ++SrcRegNum;
1372
1373     if (HasVEX_4V) // Skip 1st src (which is encoded in VEX_VVVV)
1374       ++SrcRegNum;
1375
1376     emitMemModRMByte(MI, CurOp, GetX86RegNum(MI.getOperand(SrcRegNum)), TSFlags,
1377                      Rex, CurByte, OS, Fixups, STI);
1378     CurOp = SrcRegNum + 1;
1379     break;
1380   }
1381   case X86II::MRMSrcReg: {
1382     EmitByte(BaseOpcode, CurByte, OS);
1383     unsigned SrcRegNum = CurOp + 1;
1384
1385     if (HasEVEX_K) // Skip writemask
1386       ++SrcRegNum;
1387
1388     if (HasVEX_4V) // Skip 1st src (which is encoded in VEX_VVVV)
1389       ++SrcRegNum;
1390
1391     EmitRegModRMByte(MI.getOperand(SrcRegNum),
1392                      GetX86RegNum(MI.getOperand(CurOp)), CurByte, OS);
1393     CurOp = SrcRegNum + 1;
1394     if (HasVEX_I8Reg)
1395       I8RegNum = getX86RegEncoding(MI, CurOp++);
1396     // do not count the rounding control operand
1397     if (HasEVEX_RC)
1398       --NumOps;
1399     break;
1400   }
1401   case X86II::MRMSrcReg4VOp3: {
1402     EmitByte(BaseOpcode, CurByte, OS);
1403     unsigned SrcRegNum = CurOp + 1;
1404
1405     EmitRegModRMByte(MI.getOperand(SrcRegNum),
1406                      GetX86RegNum(MI.getOperand(CurOp)), CurByte, OS);
1407     CurOp = SrcRegNum + 1;
1408     ++CurOp; // Encoded in VEX.VVVV
1409     break;
1410   }
1411   case X86II::MRMSrcRegOp4: {
1412     EmitByte(BaseOpcode, CurByte, OS);
1413     unsigned SrcRegNum = CurOp + 1;
1414
1415     // Skip 1st src (which is encoded in VEX_VVVV)
1416     ++SrcRegNum;
1417
1418     // Capture 2nd src (which is encoded in Imm[7:4])
1419     assert(HasVEX_I8Reg && "MRMSrcRegOp4 should imply VEX_I8Reg");
1420     I8RegNum = getX86RegEncoding(MI, SrcRegNum++);
1421
1422     EmitRegModRMByte(MI.getOperand(SrcRegNum),
1423                      GetX86RegNum(MI.getOperand(CurOp)), CurByte, OS);
1424     CurOp = SrcRegNum + 1;
1425     break;
1426   }
1427   case X86II::MRMSrcMem: {
1428     unsigned FirstMemOp = CurOp+1;
1429
1430     if (HasEVEX_K) // Skip writemask
1431       ++FirstMemOp;
1432
1433     if (HasVEX_4V)
1434       ++FirstMemOp;  // Skip the register source (which is encoded in VEX_VVVV).
1435
1436     EmitByte(BaseOpcode, CurByte, OS);
1437
1438     emitMemModRMByte(MI, FirstMemOp, GetX86RegNum(MI.getOperand(CurOp)),
1439                      TSFlags, Rex, CurByte, OS, Fixups, STI);
1440     CurOp = FirstMemOp + X86::AddrNumOperands;
1441     if (HasVEX_I8Reg)
1442       I8RegNum = getX86RegEncoding(MI, CurOp++);
1443     break;
1444   }
1445   case X86II::MRMSrcMem4VOp3: {
1446     unsigned FirstMemOp = CurOp+1;
1447
1448     EmitByte(BaseOpcode, CurByte, OS);
1449
1450     emitMemModRMByte(MI, FirstMemOp, GetX86RegNum(MI.getOperand(CurOp)),
1451                      TSFlags, Rex, CurByte, OS, Fixups, STI);
1452     CurOp = FirstMemOp + X86::AddrNumOperands;
1453     ++CurOp; // Encoded in VEX.VVVV.
1454     break;
1455   }
1456   case X86II::MRMSrcMemOp4: {
1457     unsigned FirstMemOp = CurOp+1;
1458
1459     ++FirstMemOp;  // Skip the register source (which is encoded in VEX_VVVV).
1460
1461     // Capture second register source (encoded in Imm[7:4])
1462     assert(HasVEX_I8Reg && "MRMSrcRegOp4 should imply VEX_I8Reg");
1463     I8RegNum = getX86RegEncoding(MI, FirstMemOp++);
1464
1465     EmitByte(BaseOpcode, CurByte, OS);
1466
1467     emitMemModRMByte(MI, FirstMemOp, GetX86RegNum(MI.getOperand(CurOp)),
1468                      TSFlags, Rex, CurByte, OS, Fixups, STI);
1469     CurOp = FirstMemOp + X86::AddrNumOperands;
1470     break;
1471   }
1472
1473   case X86II::MRMXr:
1474   case X86II::MRM0r: case X86II::MRM1r:
1475   case X86II::MRM2r: case X86II::MRM3r:
1476   case X86II::MRM4r: case X86II::MRM5r:
1477   case X86II::MRM6r: case X86II::MRM7r:
1478     if (HasVEX_4V) // Skip the register dst (which is encoded in VEX_VVVV).
1479       ++CurOp;
1480     if (HasEVEX_K) // Skip writemask
1481       ++CurOp;
1482     EmitByte(BaseOpcode, CurByte, OS);
1483     EmitRegModRMByte(MI.getOperand(CurOp++),
1484                      (Form == X86II::MRMXr) ? 0 : Form-X86II::MRM0r,
1485                      CurByte, OS);
1486     break;
1487
1488   case X86II::MRMXm:
1489   case X86II::MRM0m: case X86II::MRM1m:
1490   case X86II::MRM2m: case X86II::MRM3m:
1491   case X86II::MRM4m: case X86II::MRM5m:
1492   case X86II::MRM6m: case X86II::MRM7m:
1493     if (HasVEX_4V) // Skip the register dst (which is encoded in VEX_VVVV).
1494       ++CurOp;
1495     if (HasEVEX_K) // Skip writemask
1496       ++CurOp;
1497     EmitByte(BaseOpcode, CurByte, OS);
1498     emitMemModRMByte(MI, CurOp,
1499                      (Form == X86II::MRMXm) ? 0 : Form - X86II::MRM0m, TSFlags,
1500                      Rex, CurByte, OS, Fixups, STI);
1501     CurOp += X86::AddrNumOperands;
1502     break;
1503
1504   case X86II::MRM_C0: case X86II::MRM_C1: case X86II::MRM_C2:
1505   case X86II::MRM_C3: case X86II::MRM_C4: case X86II::MRM_C5:
1506   case X86II::MRM_C6: case X86II::MRM_C7: case X86II::MRM_C8:
1507   case X86II::MRM_C9: case X86II::MRM_CA: case X86II::MRM_CB:
1508   case X86II::MRM_CC: case X86II::MRM_CD: case X86II::MRM_CE:
1509   case X86II::MRM_CF: case X86II::MRM_D0: case X86II::MRM_D1:
1510   case X86II::MRM_D2: case X86II::MRM_D3: case X86II::MRM_D4:
1511   case X86II::MRM_D5: case X86II::MRM_D6: case X86II::MRM_D7:
1512   case X86II::MRM_D8: case X86II::MRM_D9: case X86II::MRM_DA:
1513   case X86II::MRM_DB: case X86II::MRM_DC: case X86II::MRM_DD:
1514   case X86II::MRM_DE: case X86II::MRM_DF: case X86II::MRM_E0:
1515   case X86II::MRM_E1: case X86II::MRM_E2: case X86II::MRM_E3:
1516   case X86II::MRM_E4: case X86II::MRM_E5: case X86II::MRM_E6:
1517   case X86II::MRM_E7: case X86II::MRM_E8: case X86II::MRM_E9:
1518   case X86II::MRM_EA: case X86II::MRM_EB: case X86II::MRM_EC:
1519   case X86II::MRM_ED: case X86II::MRM_EE: case X86II::MRM_EF:
1520   case X86II::MRM_F0: case X86II::MRM_F1: case X86II::MRM_F2:
1521   case X86II::MRM_F3: case X86II::MRM_F4: case X86II::MRM_F5:
1522   case X86II::MRM_F6: case X86II::MRM_F7: case X86II::MRM_F8:
1523   case X86II::MRM_F9: case X86II::MRM_FA: case X86II::MRM_FB:
1524   case X86II::MRM_FC: case X86II::MRM_FD: case X86II::MRM_FE:
1525   case X86II::MRM_FF:
1526     EmitByte(BaseOpcode, CurByte, OS);
1527     EmitByte(0xC0 + Form - X86II::MRM_C0, CurByte, OS);
1528     break;
1529   }
1530
1531   if (HasVEX_I8Reg) {
1532     // The last source register of a 4 operand instruction in AVX is encoded
1533     // in bits[7:4] of a immediate byte.
1534     assert(I8RegNum < 16 && "Register encoding out of range");
1535     I8RegNum <<= 4;
1536     if (CurOp != NumOps) {
1537       unsigned Val = MI.getOperand(CurOp++).getImm();
1538       assert(Val < 16 && "Immediate operand value out of range");
1539       I8RegNum |= Val;
1540     }
1541     EmitImmediate(MCOperand::createImm(I8RegNum), MI.getLoc(), 1, FK_Data_1,
1542                   CurByte, OS, Fixups);
1543   } else {
1544     // If there is a remaining operand, it must be a trailing immediate. Emit it
1545     // according to the right size for the instruction. Some instructions
1546     // (SSE4a extrq and insertq) have two trailing immediates.
1547     while (CurOp != NumOps && NumOps - CurOp <= 2) {
1548       EmitImmediate(MI.getOperand(CurOp++), MI.getLoc(),
1549                     X86II::getSizeOfImm(TSFlags), getImmFixupKind(TSFlags),
1550                     CurByte, OS, Fixups);
1551     }
1552   }
1553
1554   if (TSFlags & X86II::Has3DNow0F0FOpcode)
1555     EmitByte(X86II::getBaseOpcodeFor(TSFlags), CurByte, OS);
1556
1557 #ifndef NDEBUG
1558   // FIXME: Verify.
1559   if (/*!Desc.isVariadic() &&*/ CurOp != NumOps) {
1560     errs() << "Cannot encode all operands of: ";
1561     MI.dump();
1562     errs() << '\n';
1563     abort();
1564   }
1565 #endif
1566 }
1567
1568 MCCodeEmitter *llvm::createX86MCCodeEmitter(const MCInstrInfo &MCII,
1569                                             const MCRegisterInfo &MRI,
1570                                             MCContext &Ctx) {
1571   return new X86MCCodeEmitter(MCII, Ctx);
1572 }