131d157ae1ac2cd9c787dc3c1d28e64c682803844Jia Liu//===-- X86MCCodeEmitter.cpp - Convert X86 code to machine code -----------===// 2457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner// 3457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner// The LLVM Compiler Infrastructure 4457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner// 5457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner// This file is distributed under the University of Illinois Open Source 6457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner// License. See LICENSE.TXT for details. 7457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner// 8457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner//===----------------------------------------------------------------------===// 9457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner// 10457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner// This file implements the X86MCCodeEmitter class. 11457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner// 12457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner//===----------------------------------------------------------------------===// 13457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner 148c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng#include "MCTargetDesc/X86MCTargetDesc.h" 158c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng#include "MCTargetDesc/X86BaseInfo.h" 168c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng#include "MCTargetDesc/X86FixupKinds.h" 17457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner#include "llvm/MC/MCCodeEmitter.h" 187abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao#include "llvm/MC/MCContext.h" 194a2e5edb94c5d6ceb2f8f99ec031963e4c3862f9Chris Lattner#include "llvm/MC/MCExpr.h" 2092b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner#include "llvm/MC/MCInst.h" 218c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng#include "llvm/MC/MCInstrInfo.h" 228c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng#include "llvm/MC/MCRegisterInfo.h" 2359ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng#include "llvm/MC/MCSubtargetInfo.h" 2464e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola#include "llvm/MC/MCSymbol.h" 2592b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner#include "llvm/Support/raw_ostream.h" 2659ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng 27457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattnerusing namespace llvm; 28457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner 29dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "mccodeemitter" 30dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 31457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattnernamespace { 32457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattnerclass X86MCCodeEmitter : public MCCodeEmitter { 3386a1c32e67b23c5e9e42dff9eb86e99ba15bb42fCraig Topper X86MCCodeEmitter(const X86MCCodeEmitter &) LLVM_DELETED_FUNCTION; 3486a1c32e67b23c5e9e42dff9eb86e99ba15bb42fCraig Topper void operator=(const X86MCCodeEmitter &) LLVM_DELETED_FUNCTION; 3559ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng const MCInstrInfo &MCII; 364a2e5edb94c5d6ceb2f8f99ec031963e4c3862f9Chris Lattner MCContext &Ctx; 37457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattnerpublic: 3836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines X86MCCodeEmitter(const MCInstrInfo &mcii, MCContext &ctx) 3936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines : MCII(mcii), Ctx(ctx) { 40457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner } 41457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner 42457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner ~X86MCCodeEmitter() {} 4373c557458c0e28899f37c557bcaf36c2b6701260Daniel Dunbar 4436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool is64BitMode(const MCSubtargetInfo &STI) const { 4559ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng return (STI.getFeatureBits() & X86::Mode64Bit) != 0; 4659ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng } 4759ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng 4836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool is32BitMode(const MCSubtargetInfo &STI) const { 4936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return (STI.getFeatureBits() & X86::Mode32Bit) != 0; 5036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 5136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 5236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool is16BitMode(const MCSubtargetInfo &STI) const { 5336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return (STI.getFeatureBits() & X86::Mode16Bit) != 0; 5436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 5536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 5636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines /// Is16BitMemOperand - Return true if the specified instruction has 5736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines /// a 16-bit memory operand. Op specifies the operand # of the memoperand. 5836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool Is16BitMemOperand(const MCInst &MI, unsigned Op, 5936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const MCSubtargetInfo &STI) const { 6036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const MCOperand &BaseReg = MI.getOperand(Op+X86::AddrBaseReg); 6136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const MCOperand &IndexReg = MI.getOperand(Op+X86::AddrIndexReg); 6236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const MCOperand &Disp = MI.getOperand(Op+X86::AddrDisp); 6336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 6436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (is16BitMode(STI) && BaseReg.getReg() == 0 && 6536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Disp.isImm() && Disp.getImm() < 0x10000) 6636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return true; 6736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if ((BaseReg.getReg() != 0 && 6836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines X86MCRegisterClasses[X86::GR16RegClassID].contains(BaseReg.getReg())) || 6936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (IndexReg.getReg() != 0 && 7036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines X86MCRegisterClasses[X86::GR16RegClassID].contains(IndexReg.getReg()))) 7136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return true; 7236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 734fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger } 744fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger 757abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao unsigned GetX86RegNum(const MCOperand &MO) const { 7699cb622041a0839c7dfcf0263c5102a305a0fdb5Bill Wendling return Ctx.getRegisterInfo()->getEncodingValue(MO.getReg()) & 0x7; 7728249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner } 785a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes 795a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // On regular x86, both XMM0-XMM7 and XMM8-XMM15 are encoded in the range 805a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // 0-7 and the difference between the 2 groups is given by the REX prefix. 815a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // In the VEX prefix, registers are seen sequencially from 0-15 and encoded 825a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // in 1's complement form, example: 835a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // 845a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // ModRM field => XMM9 => 1 855a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // VEX.VVVV => XMM9 => ~9 865a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // 875a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // See table 4-35 of Intel AVX Programming Reference for details. 887abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao unsigned char getVEXRegisterEncoding(const MCInst &MI, 897abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao unsigned OpNum) const { 905a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes unsigned SrcReg = MI.getOperand(OpNum).getReg(); 915a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes unsigned SrcRegNum = GetX86RegNum(MI.getOperand(OpNum)); 92566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper if (X86II::isX86_64ExtendedReg(SrcReg)) 93566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper SrcRegNum |= 8; 9496716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 955a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // The registers represented through VEX_VVVV should 965a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // be encoded in 1's complement form. 975a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes return (~SrcRegNum) & 0xf; 985a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes } 9996716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 1000780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned char getWriteMaskRegisterEncoding(const MCInst &MI, 1010780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned OpNum) const { 1020780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky assert(X86::K0 != MI.getOperand(OpNum).getReg() && 1030780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky "Invalid mask register as write-mask!"); 1040780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned MaskRegNum = GetX86RegNum(MI.getOperand(OpNum)); 1050780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky return MaskRegNum; 1060780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 1070780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 10837ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner void EmitByte(unsigned char C, unsigned &CurByte, raw_ostream &OS) const { 10992b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner OS << (char)C; 11037ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner ++CurByte; 111457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner } 11296716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 11337ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner void EmitConstant(uint64_t Val, unsigned Size, unsigned &CurByte, 11437ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner raw_ostream &OS) const { 11528249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner // Output the constant in little endian byte order. 11628249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner for (unsigned i = 0; i != Size; ++i) { 11737ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(Val & 255, CurByte, OS); 11828249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner Val >>= 8; 11928249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner } 12028249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner } 1210e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner 122cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach void EmitImmediate(const MCOperand &Disp, SMLoc Loc, 123cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner unsigned ImmSize, MCFixupKind FixupKind, 124a38c707d8219a29f50564c826d2aa3154e214c66Chris Lattner unsigned &CurByte, raw_ostream &OS, 125835acabce13993e210b7cef0020a585125f9cb1eChris Lattner SmallVectorImpl<MCFixup> &Fixups, 126835acabce13993e210b7cef0020a585125f9cb1eChris Lattner int ImmOffset = 0) const; 12796716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 12828249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner inline static unsigned char ModRMByte(unsigned Mod, unsigned RegOpcode, 12928249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner unsigned RM) { 13028249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner assert(Mod < 4 && RegOpcode < 8 && RM < 8 && "ModRM Fields out of range!"); 13128249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner return RM | (RegOpcode << 3) | (Mod << 6); 13228249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner } 13396716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 13428249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner void EmitRegModRMByte(const MCOperand &ModRMReg, unsigned RegOpcodeFld, 13537ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner unsigned &CurByte, raw_ostream &OS) const { 13637ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(3, RegOpcodeFld, GetX86RegNum(ModRMReg)), CurByte, OS); 13728249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner } 13896716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 1390e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner void EmitSIBByte(unsigned SS, unsigned Index, unsigned Base, 14037ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner unsigned &CurByte, raw_ostream &OS) const { 14137ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner // SIB byte is in the same format as the ModRMByte. 14237ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(SS, Index, Base), CurByte, OS); 1430e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner } 14496716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 14596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 1461ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner void EmitMemModRMByte(const MCInst &MI, unsigned Op, 14796716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes unsigned RegOpcodeField, 14899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes uint64_t TSFlags, unsigned &CurByte, raw_ostream &OS, 14936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SmallVectorImpl<MCFixup> &Fixups, 15036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const MCSubtargetInfo &STI) const; 15196716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 15273c557458c0e28899f37c557bcaf36c2b6701260Daniel Dunbar void EncodeInstruction(const MCInst &MI, raw_ostream &OS, 15336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SmallVectorImpl<MCFixup> &Fixups, 15436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const MCSubtargetInfo &STI) const override; 15596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 1561cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes void EmitVEXOpcodePrefix(uint64_t TSFlags, unsigned &CurByte, int MemOperand, 157e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInst &MI, const MCInstrDesc &Desc, 15899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes raw_ostream &OS) const; 15999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 16036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void EmitSegmentOverridePrefix(unsigned &CurByte, unsigned SegOperand, 16136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const MCInst &MI, raw_ostream &OS) const; 1621cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes 163834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner void EmitOpcodePrefix(uint64_t TSFlags, unsigned &CurByte, int MemOperand, 164e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInst &MI, const MCInstrDesc &Desc, 16536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const MCSubtargetInfo &STI, 16699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes raw_ostream &OS) const; 167457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner}; 168457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner 169457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner} // end anonymous namespace 170457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner 171457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner 17259ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan ChengMCCodeEmitter *llvm::createX86MCCodeEmitter(const MCInstrInfo &MCII, 173918f55fe239f00651e396be841f2b3b6e242f98dJim Grosbach const MCRegisterInfo &MRI, 17459ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng const MCSubtargetInfo &STI, 17559ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng MCContext &Ctx) { 17636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return new X86MCCodeEmitter(MCII, Ctx); 17792b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner} 17892b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner 17996716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes/// isDisp8 - Return true if this signed displacement fits in a 8-bit 18096716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes/// sign-extended field. 1811ac23b10384543fcc7343beeac542b2ab626eeecChris Lattnerstatic bool isDisp8(int Value) { 1821ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner return Value == (signed char)Value; 1831ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner} 1841ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner 1850780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky/// isCDisp8 - Return true if this signed displacement fits in a 8-bit 1860780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky/// compressed dispacement field. 1870780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovskystatic bool isCDisp8(uint64_t TSFlags, int Value, int& CValue) { 18836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert((TSFlags & X86II::EncodingMask) >> X86II::EncodingShift == X86II::EVEX && 1890780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky "Compressed 8-bit displacement is only valid for EVEX inst."); 1900780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 1910780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned CD8E = (TSFlags >> X86II::EVEX_CD8EShift) & X86II::EVEX_CD8EMask; 1920780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned CD8V = (TSFlags >> X86II::EVEX_CD8VShift) & X86II::EVEX_CD8VMask; 1930780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 1940780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (CD8V == 0 && CD8E == 0) { 1950780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky CValue = Value; 1960780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky return isDisp8(Value); 1970780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 1980780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 1990780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned MemObjSize = 1U << CD8E; 2000780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (CD8V & 4) { 2010780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // Fixed vector length 2020780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky MemObjSize *= 1U << (CD8V & 0x3); 2030780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } else { 2040780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // Modified vector length 2050780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky bool EVEX_b = (TSFlags >> X86II::VEXShift) & X86II::EVEX_B; 2060780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (!EVEX_b) { 2070780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned EVEX_LL = ((TSFlags >> X86II::VEXShift) & X86II::VEX_L) ? 1 : 0; 2080780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_LL += ((TSFlags >> X86II::VEXShift) & X86II::EVEX_L2) ? 2 : 0; 2090780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky assert(EVEX_LL < 3 && ""); 2100780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 2110780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned NumElems = (1U << (EVEX_LL + 4)) / MemObjSize; 2120780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky NumElems /= 1U << (CD8V & 0x3); 2130780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 2140780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky MemObjSize *= NumElems; 2150780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 2160780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 2170780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 2180780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned MemObjMask = MemObjSize - 1; 2190780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky assert((MemObjSize & MemObjMask) == 0 && "Invalid memory object size."); 2200780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 2210780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (Value & MemObjMask) // Unaligned offset 2220780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky return false; 22336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Value /= (int)MemObjSize; 2240780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky bool Ret = (Value == (signed char)Value); 2250780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 2260780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (Ret) 2270780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky CValue = Value; 2280780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky return Ret; 2290780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky} 2300780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 231cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner/// getImmFixupKind - Return the appropriate fixup kind to use for an immediate 232cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner/// in an instruction with the specified TSFlags. 23399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopesstatic MCFixupKind getImmFixupKind(uint64_t TSFlags) { 234cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner unsigned Size = X86II::getSizeOfImm(TSFlags); 235cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner bool isPCRel = X86II::isImmPCRel(TSFlags); 23696716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 23736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::isImmSigned(TSFlags)) { 23836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines switch (Size) { 23936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines default: llvm_unreachable("Unsupported signed fixup size!"); 24036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case 4: return MCFixupKind(X86::reloc_signed_4byte); 24136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 24236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 243e04ed7e45f194f14a7b28bbf3f55694d8e2bcf80Rafael Espindola return MCFixup::getKindForSize(Size, isPCRel); 244cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner} 245cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner 2464fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger/// Is32BitMemOperand - Return true if the specified instruction has 2474fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger/// a 32-bit memory operand. Op specifies the operand # of the memoperand. 2488a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattnerstatic bool Is32BitMemOperand(const MCInst &MI, unsigned Op) { 2498a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner const MCOperand &BaseReg = MI.getOperand(Op+X86::AddrBaseReg); 2508a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner const MCOperand &IndexReg = MI.getOperand(Op+X86::AddrIndexReg); 2514e423359721fa88cb50ccea51ccf1c520d765ad0Bruno Cardoso Lopes 2528c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng if ((BaseReg.getReg() != 0 && 2538c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng X86MCRegisterClasses[X86::GR32RegClassID].contains(BaseReg.getReg())) || 2548c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng (IndexReg.getReg() != 0 && 2558c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng X86MCRegisterClasses[X86::GR32RegClassID].contains(IndexReg.getReg()))) 2568a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner return true; 2578a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner return false; 2588a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner} 259cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner 2604fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger/// Is64BitMemOperand - Return true if the specified instruction has 2614fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger/// a 64-bit memory operand. Op specifies the operand # of the memoperand. 262d9e85ef08bdd41b285f77af6c95f5ec17b43c80aJoerg Sonnenberger#ifndef NDEBUG 2634fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenbergerstatic bool Is64BitMemOperand(const MCInst &MI, unsigned Op) { 2644fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger const MCOperand &BaseReg = MI.getOperand(Op+X86::AddrBaseReg); 2654fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger const MCOperand &IndexReg = MI.getOperand(Op+X86::AddrIndexReg); 2664fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger 2674fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger if ((BaseReg.getReg() != 0 && 2684fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger X86MCRegisterClasses[X86::GR64RegClassID].contains(BaseReg.getReg())) || 2694fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger (IndexReg.getReg() != 0 && 2704fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger X86MCRegisterClasses[X86::GR64RegClassID].contains(IndexReg.getReg()))) 2714fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger return true; 2724fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger return false; 2734fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger} 274d9e85ef08bdd41b285f77af6c95f5ec17b43c80aJoerg Sonnenberger#endif 2754fd3d292753bd8232a76d5ac6b107f5899e5bfaaJoerg Sonnenberger 276f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola/// StartsWithGlobalOffsetTable - Check if this expression starts with 277f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola/// _GLOBAL_OFFSET_TABLE_ and if it is of the form 278f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola/// _GLOBAL_OFFSET_TABLE_-symbol. This is needed to support PIC on ELF 279f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola/// i386 as _GLOBAL_OFFSET_TABLE_ is magical. We check only simple case that 28064e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola/// are know to be used: _GLOBAL_OFFSET_TABLE_ by itself or at the start 28164e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola/// of a binary expression. 282f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindolaenum GlobalOffsetTableExprKind { 283f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola GOT_None, 284f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola GOT_Normal, 285f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola GOT_SymDiff 286f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola}; 287f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindolastatic GlobalOffsetTableExprKind 288f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael EspindolaStartsWithGlobalOffsetTable(const MCExpr *Expr) { 289dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const MCExpr *RHS = nullptr; 29064e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola if (Expr->getKind() == MCExpr::Binary) { 29164e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola const MCBinaryExpr *BE = static_cast<const MCBinaryExpr *>(Expr); 29264e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola Expr = BE->getLHS(); 293f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola RHS = BE->getRHS(); 29464e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola } 29564e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola 29664e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola if (Expr->getKind() != MCExpr::SymbolRef) 297f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola return GOT_None; 29864e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola 29964e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola const MCSymbolRefExpr *Ref = static_cast<const MCSymbolRefExpr*>(Expr); 30064e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola const MCSymbol &S = Ref->getSymbol(); 301f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola if (S.getName() != "_GLOBAL_OFFSET_TABLE_") 302f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola return GOT_None; 303f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola if (RHS && RHS->getKind() == MCExpr::SymbolRef) 304f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola return GOT_SymDiff; 305f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola return GOT_Normal; 30664e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola} 30764e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola 30893d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindolastatic bool HasSecRelSymbolRef(const MCExpr *Expr) { 30993d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindola if (Expr->getKind() == MCExpr::SymbolRef) { 31093d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindola const MCSymbolRefExpr *Ref = static_cast<const MCSymbolRefExpr*>(Expr); 31193d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindola return Ref->getKind() == MCSymbolRefExpr::VK_SECREL; 31293d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindola } 31393d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindola return false; 31493d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindola} 31593d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindola 3160e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattnervoid X86MCCodeEmitter:: 317cb5dca38157a48c734660746e7f7340d5db7c2dbJim GrosbachEmitImmediate(const MCOperand &DispOp, SMLoc Loc, unsigned Size, 318cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach MCFixupKind FixupKind, unsigned &CurByte, raw_ostream &OS, 319835acabce13993e210b7cef0020a585125f9cb1eChris Lattner SmallVectorImpl<MCFixup> &Fixups, int ImmOffset) const { 320dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const MCExpr *Expr = nullptr; 3218496a26113859288730d0d97637d032de53b2a7eChris Lattner if (DispOp.isImm()) { 32277169a919718b74f62ab6a577f65ac5ef9547abaBruno Cardoso Lopes // If this is a simple integer displacement that doesn't require a 32377169a919718b74f62ab6a577f65ac5ef9547abaBruno Cardoso Lopes // relocation, emit it now. 324e04ed7e45f194f14a7b28bbf3f55694d8e2bcf80Rafael Espindola if (FixupKind != FK_PCRel_1 && 32577169a919718b74f62ab6a577f65ac5ef9547abaBruno Cardoso Lopes FixupKind != FK_PCRel_2 && 3264e423359721fa88cb50ccea51ccf1c520d765ad0Bruno Cardoso Lopes FixupKind != FK_PCRel_4) { 327d93ceeb125c11a96eb85618bb9a8a7d664a1d8f4Rafael Espindola EmitConstant(DispOp.getImm()+ImmOffset, Size, CurByte, OS); 328d93ceeb125c11a96eb85618bb9a8a7d664a1d8f4Rafael Espindola return; 329d93ceeb125c11a96eb85618bb9a8a7d664a1d8f4Rafael Espindola } 330d93ceeb125c11a96eb85618bb9a8a7d664a1d8f4Rafael Espindola Expr = MCConstantExpr::Create(DispOp.getImm(), Ctx); 331d93ceeb125c11a96eb85618bb9a8a7d664a1d8f4Rafael Espindola } else { 332d93ceeb125c11a96eb85618bb9a8a7d664a1d8f4Rafael Espindola Expr = DispOp.getExpr(); 3330e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner } 33437ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner 335835acabce13993e210b7cef0020a585125f9cb1eChris Lattner // If we have an immoffset, add it to the expression. 336a4d0bd84f7bdc78784e44b623ded448988022e4bEli Friedman if ((FixupKind == FK_Data_4 || 337d4a19b6a72d19a6f90b676aac37118664b7b7a84Anton Korobeynikov FixupKind == FK_Data_8 || 338f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola FixupKind == MCFixupKind(X86::reloc_signed_4byte))) { 339f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola GlobalOffsetTableExprKind Kind = StartsWithGlobalOffsetTable(Expr); 340f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola if (Kind != GOT_None) { 341f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola assert(ImmOffset == 0); 342f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola 343dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Size == 8) { 344dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines FixupKind = MCFixupKind(X86::reloc_global_offset_table8); 345dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else { 346dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(Size == 4); 347dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines FixupKind = MCFixupKind(X86::reloc_global_offset_table); 348dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 349dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 350f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola if (Kind == GOT_Normal) 351f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola ImmOffset = CurByte; 352d4a19b6a72d19a6f90b676aac37118664b7b7a84Anton Korobeynikov } else if (Expr->getKind() == MCExpr::SymbolRef) { 35393d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindola if (HasSecRelSymbolRef(Expr)) { 35493d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindola FixupKind = MCFixupKind(FK_SecRel_4); 35593d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindola } 35693d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindola } else if (Expr->getKind() == MCExpr::Binary) { 35793d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindola const MCBinaryExpr *Bin = static_cast<const MCBinaryExpr*>(Expr); 35893d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindola if (HasSecRelSymbolRef(Bin->getLHS()) 35993d0b06e2adca2d9f3d4ec544f352cc4e5e9618aRafael Espindola || HasSecRelSymbolRef(Bin->getRHS())) { 360d4a19b6a72d19a6f90b676aac37118664b7b7a84Anton Korobeynikov FixupKind = MCFixupKind(FK_SecRel_4); 361d4a19b6a72d19a6f90b676aac37118664b7b7a84Anton Korobeynikov } 362f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola } 36364e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola } 36464e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola 365a08b587494a09a94a72245dd9d7088564e511f4eChris Lattner // If the fixup is pc-relative, we need to bias the value to be relative to 366a08b587494a09a94a72245dd9d7088564e511f4eChris Lattner // the start of the field, not the end of the field. 367e04ed7e45f194f14a7b28bbf3f55694d8e2bcf80Rafael Espindola if (FixupKind == FK_PCRel_4 || 3689fdac902d4300f2b0b8f4830ff276cc8199864b5Daniel Dunbar FixupKind == MCFixupKind(X86::reloc_riprel_4byte) || 3699fdac902d4300f2b0b8f4830ff276cc8199864b5Daniel Dunbar FixupKind == MCFixupKind(X86::reloc_riprel_4byte_movq_load)) 370a08b587494a09a94a72245dd9d7088564e511f4eChris Lattner ImmOffset -= 4; 371e04ed7e45f194f14a7b28bbf3f55694d8e2bcf80Rafael Espindola if (FixupKind == FK_PCRel_2) 372da3051a17f586b069951931eeed9317cad41243bChris Lattner ImmOffset -= 2; 373e04ed7e45f194f14a7b28bbf3f55694d8e2bcf80Rafael Espindola if (FixupKind == FK_PCRel_1) 374a08b587494a09a94a72245dd9d7088564e511f4eChris Lattner ImmOffset -= 1; 37596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 3764a2e5edb94c5d6ceb2f8f99ec031963e4c3862f9Chris Lattner if (ImmOffset) 377a08b587494a09a94a72245dd9d7088564e511f4eChris Lattner Expr = MCBinaryExpr::CreateAdd(Expr, MCConstantExpr::Create(ImmOffset, Ctx), 3784a2e5edb94c5d6ceb2f8f99ec031963e4c3862f9Chris Lattner Ctx); 37996716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 3805dccfadbf4f46a0a06240f3591f7500e75b1d8cdChris Lattner // Emit a symbolic constant as a fixup and 4 zeros. 381cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach Fixups.push_back(MCFixup::Create(CurByte, Expr, FixupKind, Loc)); 382a38c707d8219a29f50564c826d2aa3154e214c66Chris Lattner EmitConstant(0, Size, CurByte, OS); 3830e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner} 3840e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner 3851ac23b10384543fcc7343beeac542b2ab626eeecChris Lattnervoid X86MCCodeEmitter::EmitMemModRMByte(const MCInst &MI, unsigned Op, 3861ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner unsigned RegOpcodeField, 38799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes uint64_t TSFlags, unsigned &CurByte, 3885dccfadbf4f46a0a06240f3591f7500e75b1d8cdChris Lattner raw_ostream &OS, 38936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SmallVectorImpl<MCFixup> &Fixups, 39036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const MCSubtargetInfo &STI) const{ 3918a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner const MCOperand &Disp = MI.getOperand(Op+X86::AddrDisp); 3928a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner const MCOperand &Base = MI.getOperand(Op+X86::AddrBaseReg); 3938a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner const MCOperand &Scale = MI.getOperand(Op+X86::AddrScaleAmt); 3948a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner const MCOperand &IndexReg = MI.getOperand(Op+X86::AddrIndexReg); 3951ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner unsigned BaseReg = Base.getReg(); 39636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned char Encoding = (TSFlags & X86II::EncodingMask) >> 39736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines X86II::EncodingShift; 39836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool HasEVEX = (Encoding == X86II::EVEX); 39996716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 4001e35d0e9234836c4cea5ec9d1ec11dcc017911beChris Lattner // Handle %rip relative addressing. 4011e35d0e9234836c4cea5ec9d1ec11dcc017911beChris Lattner if (BaseReg == X86::RIP) { // [disp32+RIP] in X86-64 mode 40236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(is64BitMode(STI) && "Rip-relative addressing requires 64-bit mode"); 403497f1eb2b89721e81b65237df90d23cb60de16b0Eric Christopher assert(IndexReg.getReg() == 0 && "Invalid rip-relative address"); 4041e35d0e9234836c4cea5ec9d1ec11dcc017911beChris Lattner EmitByte(ModRMByte(0, RegOpcodeField, 5), CurByte, OS); 40596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 4060f53cf22361d89690dcf58409decb43d2a3ad60fChris Lattner unsigned FixupKind = X86::reloc_riprel_4byte; 40796716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 4080f53cf22361d89690dcf58409decb43d2a3ad60fChris Lattner // movq loads are handled with a special relocation form which allows the 4090f53cf22361d89690dcf58409decb43d2a3ad60fChris Lattner // linker to eliminate some loads for GOT references which end up in the 4100f53cf22361d89690dcf58409decb43d2a3ad60fChris Lattner // same linkage unit. 411d0eeeeb5580622d8700fd1009bbf2465789303a8Jakob Stoklund Olesen if (MI.getOpcode() == X86::MOV64rm) 4120f53cf22361d89690dcf58409decb43d2a3ad60fChris Lattner FixupKind = X86::reloc_riprel_4byte_movq_load; 41396716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 414835acabce13993e210b7cef0020a585125f9cb1eChris Lattner // rip-relative addressing is actually relative to the *next* instruction. 415835acabce13993e210b7cef0020a585125f9cb1eChris Lattner // Since an immediate can follow the mod/rm byte for an instruction, this 416835acabce13993e210b7cef0020a585125f9cb1eChris Lattner // means that we need to bias the immediate field of the instruction with 417835acabce13993e210b7cef0020a585125f9cb1eChris Lattner // the size of the immediate field. If we have this case, add it into the 418835acabce13993e210b7cef0020a585125f9cb1eChris Lattner // expression to emit. 419835acabce13993e210b7cef0020a585125f9cb1eChris Lattner int ImmSize = X86II::hasImm(TSFlags) ? X86II::getSizeOfImm(TSFlags) : 0; 42096716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 421cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach EmitImmediate(Disp, MI.getLoc(), 4, MCFixupKind(FixupKind), 422835acabce13993e210b7cef0020a585125f9cb1eChris Lattner CurByte, OS, Fixups, -ImmSize); 4231e35d0e9234836c4cea5ec9d1ec11dcc017911beChris Lattner return; 4241e35d0e9234836c4cea5ec9d1ec11dcc017911beChris Lattner } 42596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 4261e35d0e9234836c4cea5ec9d1ec11dcc017911beChris Lattner unsigned BaseRegNo = BaseReg ? GetX86RegNum(Base) : -1U; 42796716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 42836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // 16-bit addressing forms of the ModR/M byte have a different encoding for 42936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // the R/M field and are far more limited in which registers can be used. 43036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Is16BitMemOperand(MI, Op, STI)) { 43136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (BaseReg) { 43236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // For 32-bit addressing, the row and column values in Table 2-2 are 43336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // basically the same. It's AX/CX/DX/BX/SP/BP/SI/DI in that order, with 43436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // some special cases. And GetX86RegNum reflects that numbering. 43536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // For 16-bit addressing it's more fun, as shown in the SDM Vol 2A, 43636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Table 2-1 "16-Bit Addressing Forms with the ModR/M byte". We can only 43736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // use SI/DI/BP/BX, which have "row" values 4-7 in no particular order, 43836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // while values 0-3 indicate the allowed combinations (base+index) of 43936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // those: 0 for BX+SI, 1 for BX+DI, 2 for BP+SI, 3 for BP+DI. 44036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // 44136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // R16Table[] is a lookup from the normal RegNo, to the row values from 44236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Table 2-1 for 16-bit addressing modes. Where zero means disallowed. 44336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines static const unsigned R16Table[] = { 0, 0, 0, 7, 0, 6, 4, 5 }; 44436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned RMfield = R16Table[BaseRegNo]; 44536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 44636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(RMfield && "invalid 16-bit base register"); 44736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 44836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (IndexReg.getReg()) { 44936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned IndexReg16 = R16Table[GetX86RegNum(IndexReg)]; 45036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 45136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(IndexReg16 && "invalid 16-bit index register"); 45236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // We must have one of SI/DI (4,5), and one of BP/BX (6,7). 45336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(((IndexReg16 ^ RMfield) & 2) && 45436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "invalid 16-bit base/index register combination"); 45536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(Scale.getImm() == 1 && 45636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "invalid scale for 16-bit memory reference"); 45736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 45836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Allow base/index to appear in either order (although GAS doesn't). 45936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (IndexReg16 & 2) 46036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines RMfield = (RMfield & 1) | ((7 - IndexReg16) << 1); 46136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines else 46236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines RMfield = (IndexReg16 & 1) | ((7 - RMfield) << 1); 46336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 46436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 46536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Disp.isImm() && isDisp8(Disp.getImm())) { 46636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Disp.getImm() == 0 && BaseRegNo != N86::EBP) { 46736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // There is no displacement; just the register. 46836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(ModRMByte(0, RegOpcodeField, RMfield), CurByte, OS); 46936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return; 47036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 47136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Use the [REG]+disp8 form, including for [BP] which cannot be encoded. 47236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(ModRMByte(1, RegOpcodeField, RMfield), CurByte, OS); 47336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitImmediate(Disp, MI.getLoc(), 1, FK_Data_1, CurByte, OS, Fixups); 47436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return; 47536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 47636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // This is the [REG]+disp16 case. 47736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(ModRMByte(2, RegOpcodeField, RMfield), CurByte, OS); 47836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } else { 47936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // There is no BaseReg; this is the plain [disp16] case. 48036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(ModRMByte(0, RegOpcodeField, 6), CurByte, OS); 48136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 48236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 48336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Emit 16-bit displacement for plain disp16 or [REG]+disp16 cases. 48436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitImmediate(Disp, MI.getLoc(), 2, FK_Data_2, CurByte, OS, Fixups); 48536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return; 48636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 48736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 488a8168ec732781813172f203f73956561a09f4a67Chris Lattner // Determine whether a SIB byte is needed. 48996716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes // If no BaseReg, issue a RIP relative instruction only if the MCE can 4901ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner // resolve addresses on-the-fly, otherwise use SIB (Intel Manual 2A, table 4911ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner // 2-7) and absolute references. 4925526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner 493a8168ec732781813172f203f73956561a09f4a67Chris Lattner if (// The SIB byte must be used if there is an index register. 49496716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes IndexReg.getReg() == 0 && 4955526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner // The SIB byte must be used if the base is ESP/RSP/R12, all of which 4965526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner // encode to an R/M value of 4, which indicates that a SIB byte is 4975526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner // present. 4985526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner BaseRegNo != N86::ESP && 499a8168ec732781813172f203f73956561a09f4a67Chris Lattner // If there is no base register and we're in 64-bit mode, we need a SIB 500a8168ec732781813172f203f73956561a09f4a67Chris Lattner // byte to emit an addr that is just 'disp32' (the non-RIP relative form). 50136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (!is64BitMode(STI) || BaseReg != 0)) { 502a8168ec732781813172f203f73956561a09f4a67Chris Lattner 5031e35d0e9234836c4cea5ec9d1ec11dcc017911beChris Lattner if (BaseReg == 0) { // [disp32] in X86-32 mode 50437ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(0, RegOpcodeField, 5), CurByte, OS); 505cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach EmitImmediate(Disp, MI.getLoc(), 4, FK_Data_4, CurByte, OS, Fixups); 506a8168ec732781813172f203f73956561a09f4a67Chris Lattner return; 507a8168ec732781813172f203f73956561a09f4a67Chris Lattner } 50896716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 509a8168ec732781813172f203f73956561a09f4a67Chris Lattner // If the base is not EBP/ESP and there is no displacement, use simple 510a8168ec732781813172f203f73956561a09f4a67Chris Lattner // indirect register encoding, this handles addresses like [EAX]. The 511a8168ec732781813172f203f73956561a09f4a67Chris Lattner // encoding for [EBP] with no displacement means [disp32] so we handle it 512a8168ec732781813172f203f73956561a09f4a67Chris Lattner // by emitting a displacement of 0 below. 5138496a26113859288730d0d97637d032de53b2a7eChris Lattner if (Disp.isImm() && Disp.getImm() == 0 && BaseRegNo != N86::EBP) { 51437ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(0, RegOpcodeField, BaseRegNo), CurByte, OS); 515a8168ec732781813172f203f73956561a09f4a67Chris Lattner return; 5161ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner } 51796716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 518a8168ec732781813172f203f73956561a09f4a67Chris Lattner // Otherwise, if the displacement fits in a byte, encode as [REG+disp8]. 5190780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (Disp.isImm()) { 5200780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (!HasEVEX && isDisp8(Disp.getImm())) { 5210780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EmitByte(ModRMByte(1, RegOpcodeField, BaseRegNo), CurByte, OS); 5220780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EmitImmediate(Disp, MI.getLoc(), 1, FK_Data_1, CurByte, OS, Fixups); 5230780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky return; 5240780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 5250780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // Try EVEX compressed 8-bit displacement first; if failed, fall back to 5260780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // 32-bit displacement. 5270780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky int CDisp8 = 0; 5280780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasEVEX && isCDisp8(TSFlags, Disp.getImm(), CDisp8)) { 5290780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EmitByte(ModRMByte(1, RegOpcodeField, BaseRegNo), CurByte, OS); 5300780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EmitImmediate(Disp, MI.getLoc(), 1, FK_Data_1, CurByte, OS, Fixups, 5310780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky CDisp8 - Disp.getImm()); 5320780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky return; 5330780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 534a8168ec732781813172f203f73956561a09f4a67Chris Lattner } 53596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 536a8168ec732781813172f203f73956561a09f4a67Chris Lattner // Otherwise, emit the most general non-SIB encoding: [REG+disp32] 53737ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(2, RegOpcodeField, BaseRegNo), CurByte, OS); 538cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach EmitImmediate(Disp, MI.getLoc(), 4, MCFixupKind(X86::reloc_signed_4byte), CurByte, OS, 539a8c02c3bdd68e65d14fb6b0d56989663754059b0Rafael Espindola Fixups); 5400e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner return; 5410e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner } 54296716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 5430e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // We need a SIB byte, so start by outputting the ModR/M byte first 5440e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner assert(IndexReg.getReg() != X86::ESP && 5450e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner IndexReg.getReg() != X86::RSP && "Cannot use ESP as index reg!"); 54696716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 5470e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner bool ForceDisp32 = false; 5480e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner bool ForceDisp8 = false; 5490780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky int CDisp8 = 0; 5500780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky int ImmOffset = 0; 5510e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner if (BaseReg == 0) { 5520e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // If there is no base register, we emit the special case SIB byte with 5530e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // MOD=0, BASE=5, to JUST get the index, scale, and displacement. 55437ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(0, RegOpcodeField, 4), CurByte, OS); 5550e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner ForceDisp32 = true; 5568496a26113859288730d0d97637d032de53b2a7eChris Lattner } else if (!Disp.isImm()) { 5570e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // Emit the normal disp32 encoding. 55837ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(2, RegOpcodeField, 4), CurByte, OS); 5590e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner ForceDisp32 = true; 560618d0ed4bc0b68d87f86eace0cd6b9c05329dfc7Chris Lattner } else if (Disp.getImm() == 0 && 561618d0ed4bc0b68d87f86eace0cd6b9c05329dfc7Chris Lattner // Base reg can't be anything that ends up with '5' as the base 562618d0ed4bc0b68d87f86eace0cd6b9c05329dfc7Chris Lattner // reg, it is the magic [*] nomenclature that indicates no base. 563618d0ed4bc0b68d87f86eace0cd6b9c05329dfc7Chris Lattner BaseRegNo != N86::EBP) { 5640e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // Emit no displacement ModR/M byte 56537ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(0, RegOpcodeField, 4), CurByte, OS); 5660780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } else if (!HasEVEX && isDisp8(Disp.getImm())) { 5670e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // Emit the disp8 encoding. 56837ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(1, RegOpcodeField, 4), CurByte, OS); 5690e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner ForceDisp8 = true; // Make sure to force 8 bit disp if Base=EBP 5700780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } else if (HasEVEX && isCDisp8(TSFlags, Disp.getImm(), CDisp8)) { 5710780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // Emit the disp8 encoding. 5720780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EmitByte(ModRMByte(1, RegOpcodeField, 4), CurByte, OS); 5730780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky ForceDisp8 = true; // Make sure to force 8 bit disp if Base=EBP 5740780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky ImmOffset = CDisp8 - Disp.getImm(); 5750e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner } else { 5760e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // Emit the normal disp32 encoding. 57737ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(2, RegOpcodeField, 4), CurByte, OS); 5781ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner } 57996716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 5800e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // Calculate what the SS field value should be... 581a44defeb2208376ca3113ffdddc391570ba865b8Jeffrey Yasskin static const unsigned SSTable[] = { ~0U, 0, 1, ~0U, 2, ~0U, ~0U, ~0U, 3 }; 5820e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner unsigned SS = SSTable[Scale.getImm()]; 58396716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 5840e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner if (BaseReg == 0) { 58596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes // Handle the SIB byte for the case where there is no base, see Intel 5860e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // Manual 2A, table 2-7. The displacement has already been output. 5870e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner unsigned IndexRegNo; 5880e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner if (IndexReg.getReg()) 5890e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner IndexRegNo = GetX86RegNum(IndexReg); 5900e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner else // Examples: [ESP+1*<noreg>+4] or [scaled idx]+disp32 (MOD=0,BASE=5) 5910e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner IndexRegNo = 4; 59237ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitSIBByte(SS, IndexRegNo, 5, CurByte, OS); 5930e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner } else { 5940e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner unsigned IndexRegNo; 5950e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner if (IndexReg.getReg()) 5960e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner IndexRegNo = GetX86RegNum(IndexReg); 5970e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner else 5980e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner IndexRegNo = 4; // For example [ESP+1*<noreg>+4] 59937ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitSIBByte(SS, IndexRegNo, GetX86RegNum(Base), CurByte, OS); 6000e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner } 60196716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 6020e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // Do we need to output a displacement? 6030e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner if (ForceDisp8) 6040780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EmitImmediate(Disp, MI.getLoc(), 1, FK_Data_1, CurByte, OS, Fixups, ImmOffset); 6058496a26113859288730d0d97637d032de53b2a7eChris Lattner else if (ForceDisp32 || Disp.getImm() != 0) 606cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach EmitImmediate(Disp, MI.getLoc(), 4, MCFixupKind(X86::reloc_signed_4byte), 607cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach CurByte, OS, Fixups); 6081ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner} 6091ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner 61099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes/// EmitVEXOpcodePrefix - AVX instructions are encoded using a opcode prefix 61199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes/// called VEX. 61299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopesvoid X86MCCodeEmitter::EmitVEXOpcodePrefix(uint64_t TSFlags, unsigned &CurByte, 6131cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes int MemOperand, const MCInst &MI, 614e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &Desc, 6151cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes raw_ostream &OS) const { 61636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned char Encoding = (TSFlags & X86II::EncodingMask) >> 61736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines X86II::EncodingShift; 61836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool HasEVEX_K = ((TSFlags >> X86II::VEXShift) & X86II::EVEX_K); 619b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper bool HasVEX_4V = (TSFlags >> X86II::VEXShift) & X86II::VEX_4V; 620b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper bool HasVEX_4VOp3 = (TSFlags >> X86II::VEXShift) & X86II::VEX_4VOp3; 6219d3f3c5f400578855f6f7b71670cb8514b4fac0fCraig Topper bool HasMemOp4 = (TSFlags >> X86II::VEXShift) & X86II::MemOp4; 62236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool HasEVEX_RC = (TSFlags >> X86II::VEXShift) & X86II::EVEX_RC; 623788184365a4a949eb83b0036045e6793bc6c20f0Bruno Cardoso Lopes 62499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX_R: opcode externsion equivalent to REX.R in 62599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 1's complement (inverted) form 62699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 62799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 1: Same as REX_R=0 (must be 1 in 32-bit mode) 62899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0: Same as REX_R=1 (64 bit mode only) 62999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 63099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned char VEX_R = 0x1; 6310780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned char EVEX_R2 = 0x1; 63299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 633c902a59f4c786a2a047f0b4c964a93108f248915Bruno Cardoso Lopes // VEX_X: equivalent to REX.X, only used when a 634c902a59f4c786a2a047f0b4c964a93108f248915Bruno Cardoso Lopes // register is used for index in SIB Byte. 635c902a59f4c786a2a047f0b4c964a93108f248915Bruno Cardoso Lopes // 636c902a59f4c786a2a047f0b4c964a93108f248915Bruno Cardoso Lopes // 1: Same as REX.X=0 (must be 1 in 32-bit mode) 637c902a59f4c786a2a047f0b4c964a93108f248915Bruno Cardoso Lopes // 0: Same as REX.X=1 (64-bit mode only) 638c902a59f4c786a2a047f0b4c964a93108f248915Bruno Cardoso Lopes unsigned char VEX_X = 0x1; 639c902a59f4c786a2a047f0b4c964a93108f248915Bruno Cardoso Lopes 64099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX_B: 64199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 64299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 1: Same as REX_B=0 (ignored in 32-bit mode) 64399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0: Same as REX_B=1 (64 bit mode only) 64499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 64599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned char VEX_B = 0x1; 64699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 64799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX_W: opcode specific (use like REX.W, or used for 64899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // opcode extension, or ignored, depending on the opcode byte) 64999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned char VEX_W = 0; 65099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 65199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX_5M (VEX m-mmmmm field): 65299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 65399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b00000: Reserved for future use 65499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b00001: implied 0F leading opcode 65599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b00010: implied 0F 38 leading opcode bytes 65699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b00011: implied 0F 3A leading opcode bytes 65799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b00100-0b11111: Reserved for future use 658ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin // 0b01000: XOP map select - 08h instructions with imm byte 659bd0decae3c0af9eb38592f305935559782096c9eCraig Topper // 0b01001: XOP map select - 09h instructions with no imm byte 660bd0decae3c0af9eb38592f305935559782096c9eCraig Topper // 0b01010: XOP map select - 0Ah instructions with imm dword 66136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned char VEX_5M = 0; 66299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 66399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX_4V (VEX vvvv field): a register specifier 66499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // (in 1's complement form) or 1111 if unused. 66599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned char VEX_4V = 0xf; 6660780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned char EVEX_V2 = 0x1; 66799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 66899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX_L (Vector Length): 66999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 67099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0: scalar or 128-bit vector 67199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 1: 256-bit vector 67299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 67399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned char VEX_L = 0; 6740780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned char EVEX_L2 = 0; 67599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 67699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX_PP: opcode extension providing equivalent 67799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // functionality of a SIMD prefix 67899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 67999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b00: None 6807be0d2c8e944d0f51db8abb0fb4c8fb7c1bfe8f8Bruno Cardoso Lopes // 0b01: 66 68199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b10: F3 68299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b11: F2 68399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 68499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned char VEX_PP = 0; 68599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 6860780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // EVEX_U 6870780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned char EVEX_U = 1; // Always '1' so far 6880780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 6890780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // EVEX_z 6900780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned char EVEX_z = 0; 6910780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 6920780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // EVEX_b 6930780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned char EVEX_b = 0; 6940780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 69536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // EVEX_rc 69636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned char EVEX_rc = 0; 69736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 6980780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // EVEX_aaa 6990780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned char EVEX_aaa = 0; 7000780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 70136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool EncodeRC = false; 7027be0d2c8e944d0f51db8abb0fb4c8fb7c1bfe8f8Bruno Cardoso Lopes 703229e4523f2f12929defa09ac4ef9f3652f21f1ecJoerg Sonnenberger if ((TSFlags >> X86II::VEXShift) & X86II::VEX_W) 7046596a6207627ed59f568883924a21e642934c083Bruno Cardoso Lopes VEX_W = 1; 7056596a6207627ed59f568883924a21e642934c083Bruno Cardoso Lopes 706229e4523f2f12929defa09ac4ef9f3652f21f1ecJoerg Sonnenberger if ((TSFlags >> X86II::VEXShift) & X86II::VEX_L) 70787a85c7ef0d1a96c73473de90d3b2b28d24538a5Bruno Cardoso Lopes VEX_L = 1; 70836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (((TSFlags >> X86II::VEXShift) & X86II::EVEX_L2)) 7090780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_L2 = 1; 7100780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 7110780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasEVEX_K && ((TSFlags >> X86II::VEXShift) & X86II::EVEX_Z)) 7120780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_z = 1; 7130780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 71436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (((TSFlags >> X86II::VEXShift) & X86II::EVEX_B)) 7150780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_b = 1; 71687a85c7ef0d1a96c73473de90d3b2b28d24538a5Bruno Cardoso Lopes 71736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines switch (TSFlags & X86II::OpPrefixMask) { 71836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines default: break; // VEX_PP already correct 71936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::PD: VEX_PP = 0x1; break; // 66 72036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::XS: VEX_PP = 0x2; break; // F3 72136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::XD: VEX_PP = 0x3; break; // F2 72299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes } 72399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 72436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines switch (TSFlags & X86II::OpMapMask) { 72536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines default: llvm_unreachable("Invalid prefix!"); 72636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::TB: VEX_5M = 0x1; break; // 0F 72736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::T8: VEX_5M = 0x2; break; // 0F 38 72836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::TA: VEX_5M = 0x3; break; // 0F 3A 72936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::XOP8: VEX_5M = 0x8; break; 73036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::XOP9: VEX_5M = 0x9; break; 73136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::XOPA: VEX_5M = 0xA; break; 73236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 733ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin 7340c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // Classify VEX_B, VEX_4V, VEX_R, VEX_X 735177cf1e1a3685209ab805f82897902a8d2b61661Elena Demikhovsky unsigned NumOps = Desc.getNumOperands(); 73636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned CurOp = X86II::getOperandBias(Desc); 737177cf1e1a3685209ab805f82897902a8d2b61661Elena Demikhovsky 73899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes switch (TSFlags & X86II::FormMask) { 73936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines default: llvm_unreachable("Unexpected form in EmitVEXOpcodePrefix!"); 74036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::RawFrm: 74136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines break; 7420c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes case X86II::MRMDestMem: { 7430c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MRMDestMem instructions forms: 7440c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MemAddr, src1(ModR/M) 7450c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MemAddr, src1(VEX_4V), src2(ModR/M) 7460c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MemAddr, src1(ModR/M), imm8 7470c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // 7480780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (X86II::isX86_64ExtendedReg(MI.getOperand(MemOperand + 7490780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky X86::AddrBaseReg).getReg())) 7500c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_B = 0x0; 7510780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (X86II::isX86_64ExtendedReg(MI.getOperand(MemOperand + 7520780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky X86::AddrIndexReg).getReg())) 7530c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_X = 0x0; 75436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MI.getOperand(MemOperand + 7550780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky X86::AddrIndexReg).getReg())) 7560780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_V2 = 0x0; 7570c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes 7580780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky CurOp += X86::AddrNumOperands; 7590780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 7600780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasEVEX_K) 7610780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_aaa = getWriteMaskRegisterEncoding(MI, CurOp++); 7620780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 7630780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasVEX_4V) { 7640780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky VEX_4V = getVEXRegisterEncoding(MI, CurOp); 76536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MI.getOperand(CurOp).getReg())) 7660780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_V2 = 0x0; 7670780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky CurOp++; 7680780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 7690c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes 7700c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes const MCOperand &MO = MI.getOperand(CurOp); 7710780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (MO.isReg()) { 7720780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (X86II::isX86_64ExtendedReg(MO.getReg())) 7730780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky VEX_R = 0x0; 77436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MO.getReg())) 7750780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_R2 = 0x0; 7760780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 7770c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes break; 7780c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes } 779566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper case X86II::MRMSrcMem: 7800c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MRMSrcMem instructions forms: 7810c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // src1(ModR/M), MemAddr 7820c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // src1(ModR/M), src2(VEX_4V), MemAddr 7830c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // src1(ModR/M), MemAddr, imm8 7840c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // src1(ModR/M), MemAddr, src2(VEX_I8IMM) 7850c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // 7861b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes // FMA4: 7871b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes // dst(ModR/M.reg), src1(VEX_4V), src2(ModR/M), src3(VEX_I8IMM) 7881b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes // dst(ModR/M.reg), src1(VEX_4V), src2(VEX_I8IMM), src3(ModR/M), 7890780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (X86II::isX86_64ExtendedReg(MI.getOperand(CurOp).getReg())) 7900c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_R = 0x0; 79136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MI.getOperand(CurOp).getReg())) 7920780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_R2 = 0x0; 7930780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky CurOp++; 7940c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes 7950780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasEVEX_K) 7960780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_aaa = getWriteMaskRegisterEncoding(MI, CurOp++); 7970780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 7980780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasVEX_4V) { 799177cf1e1a3685209ab805f82897902a8d2b61661Elena Demikhovsky VEX_4V = getVEXRegisterEncoding(MI, CurOp); 80036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MI.getOperand(CurOp).getReg())) 8010780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_V2 = 0x0; 8020780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky CurOp++; 8030780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 8040c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes 8050c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (X86II::isX86_64ExtendedReg( 806566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper MI.getOperand(MemOperand+X86::AddrBaseReg).getReg())) 8070c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_B = 0x0; 8080c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (X86II::isX86_64ExtendedReg( 809566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper MI.getOperand(MemOperand+X86::AddrIndexReg).getReg())) 8100c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_X = 0x0; 81136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MI.getOperand(MemOperand + 81236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines X86::AddrIndexReg).getReg())) 8130780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_V2 = 0x0; 81417730847d59c919d97f097d46a3fcba1888e5300Craig Topper 815b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper if (HasVEX_4VOp3) 8161f7a1b68a07ea6bdf521525a7928f4a8c5216713Manman Ren // Instruction format for 4VOp3: 8171f7a1b68a07ea6bdf521525a7928f4a8c5216713Manman Ren // src1(ModR/M), MemAddr, src3(VEX_4V) 8181f7a1b68a07ea6bdf521525a7928f4a8c5216713Manman Ren // CurOp points to start of the MemoryOperand, 8191f7a1b68a07ea6bdf521525a7928f4a8c5216713Manman Ren // it skips TIED_TO operands if exist, then increments past src1. 8201f7a1b68a07ea6bdf521525a7928f4a8c5216713Manman Ren // CurOp + X86::AddrNumOperands will point to src3. 8211f7a1b68a07ea6bdf521525a7928f4a8c5216713Manman Ren VEX_4V = getVEXRegisterEncoding(MI, CurOp+X86::AddrNumOperands); 8220c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes break; 823147b7cad2fefa3260e2da8f7cfe31ac07f352cebBruno Cardoso Lopes case X86II::MRM0m: case X86II::MRM1m: 824147b7cad2fefa3260e2da8f7cfe31ac07f352cebBruno Cardoso Lopes case X86II::MRM2m: case X86II::MRM3m: 825147b7cad2fefa3260e2da8f7cfe31ac07f352cebBruno Cardoso Lopes case X86II::MRM4m: case X86II::MRM5m: 826566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper case X86II::MRM6m: case X86II::MRM7m: { 8270c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MRM[0-9]m instructions forms: 8280c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MemAddr 829566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper // src1(VEX_4V), MemAddr 8300780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasVEX_4V) { 8310780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky VEX_4V = getVEXRegisterEncoding(MI, CurOp); 83236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MI.getOperand(CurOp).getReg())) 8330780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_V2 = 0x0; 8345bdf397e25bf0e5a6473f44d49a04e8ff184c442Craig Topper CurOp++; 8350780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 8360780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 8370780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasEVEX_K) 8380780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_aaa = getWriteMaskRegisterEncoding(MI, CurOp++); 839566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper 840566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper if (X86II::isX86_64ExtendedReg( 841566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper MI.getOperand(MemOperand+X86::AddrBaseReg).getReg())) 8420c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_B = 0x0; 843566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper if (X86II::isX86_64ExtendedReg( 844566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper MI.getOperand(MemOperand+X86::AddrIndexReg).getReg())) 8450c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_X = 0x0; 8460c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes break; 847566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper } 84899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes case X86II::MRMSrcReg: 8490c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MRMSrcReg instructions forms: 8500c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // dst(ModR/M), src1(VEX_4V), src2(ModR/M), src3(VEX_I8IMM) 8510c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // dst(ModR/M), src1(ModR/M) 8520c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // dst(ModR/M), src1(ModR/M), imm8 8530c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // 8549d3f3c5f400578855f6f7b71670cb8514b4fac0fCraig Topper // FMA4: 8559d3f3c5f400578855f6f7b71670cb8514b4fac0fCraig Topper // dst(ModR/M.reg), src1(VEX_4V), src2(ModR/M), src3(VEX_I8IMM) 8569d3f3c5f400578855f6f7b71670cb8514b4fac0fCraig Topper // dst(ModR/M.reg), src1(VEX_4V), src2(VEX_I8IMM), src3(ModR/M), 8570c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (X86II::isX86_64ExtendedReg(MI.getOperand(CurOp).getReg())) 85899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes VEX_R = 0x0; 85936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MI.getOperand(CurOp).getReg())) 8600780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_R2 = 0x0; 8614b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes CurOp++; 86299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 8630780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasEVEX_K) 8640780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_aaa = getWriteMaskRegisterEncoding(MI, CurOp++); 8650780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 8660780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasVEX_4V) { 8670780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky VEX_4V = getVEXRegisterEncoding(MI, CurOp); 86836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MI.getOperand(CurOp).getReg())) 8690780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_V2 = 0x0; 8700780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky CurOp++; 8710780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 8729d3f3c5f400578855f6f7b71670cb8514b4fac0fCraig Topper 8739d3f3c5f400578855f6f7b71670cb8514b4fac0fCraig Topper if (HasMemOp4) // Skip second register source (encoded in I8IMM) 8749d3f3c5f400578855f6f7b71670cb8514b4fac0fCraig Topper CurOp++; 8759d3f3c5f400578855f6f7b71670cb8514b4fac0fCraig Topper 8760c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (X86II::isX86_64ExtendedReg(MI.getOperand(CurOp).getReg())) 8770c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_B = 0x0; 87836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MI.getOperand(CurOp).getReg())) 8790780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky VEX_X = 0x0; 88017730847d59c919d97f097d46a3fcba1888e5300Craig Topper CurOp++; 881b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper if (HasVEX_4VOp3) 88236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines VEX_4V = getVEXRegisterEncoding(MI, CurOp++); 88336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (EVEX_b) { 88436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (HasEVEX_RC) { 88536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned RcOperand = NumOps-1; 88636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(RcOperand >= CurOp); 88736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EVEX_rc = MI.getOperand(RcOperand).getImm() & 0x3; 88836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 88936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EncodeRC = true; 89036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 8910c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes break; 8920c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes case X86II::MRMDestReg: 8930c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MRMDestReg instructions forms: 8940c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // dst(ModR/M), src(ModR/M) 8950c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // dst(ModR/M), src(ModR/M), imm8 8968647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper // dst(ModR/M), src1(VEX_4V), src2(ModR/M) 8978647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper if (X86II::isX86_64ExtendedReg(MI.getOperand(CurOp).getReg())) 8980c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_B = 0x0; 89936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MI.getOperand(CurOp).getReg())) 9000780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky VEX_X = 0x0; 9018647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper CurOp++; 9028647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper 9030780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasEVEX_K) 9040780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_aaa = getWriteMaskRegisterEncoding(MI, CurOp++); 9050780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 9060780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasVEX_4V) { 9070780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky VEX_4V = getVEXRegisterEncoding(MI, CurOp); 90836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MI.getOperand(CurOp).getReg())) 9090780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_V2 = 0x0; 9100780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky CurOp++; 9110780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 9128647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper 9138647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper if (X86II::isX86_64ExtendedReg(MI.getOperand(CurOp).getReg())) 9140c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_R = 0x0; 91536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MI.getOperand(CurOp).getReg())) 9160780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_R2 = 0x0; 91736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (EVEX_b) 91836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EncodeRC = true; 9190c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes break; 9200c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes case X86II::MRM0r: case X86II::MRM1r: 9210c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes case X86II::MRM2r: case X86II::MRM3r: 9220c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes case X86II::MRM4r: case X86II::MRM5r: 9230c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes case X86II::MRM6r: case X86II::MRM7r: 9240c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MRM0r-MRM7r instructions forms: 9250c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // dst(VEX_4V), src(ModR/M), imm8 9261765e74c15c83db437018a3c9efabbeb4ce9cbdeElena Demikhovsky if (HasVEX_4V) { 9271765e74c15c83db437018a3c9efabbeb4ce9cbdeElena Demikhovsky VEX_4V = getVEXRegisterEncoding(MI, CurOp); 92836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MI.getOperand(CurOp).getReg())) 9291765e74c15c83db437018a3c9efabbeb4ce9cbdeElena Demikhovsky EVEX_V2 = 0x0; 9301765e74c15c83db437018a3c9efabbeb4ce9cbdeElena Demikhovsky CurOp++; 93136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 9320780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasEVEX_K) 9330780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EVEX_aaa = getWriteMaskRegisterEncoding(MI, CurOp++); 9340780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 9350780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (X86II::isX86_64ExtendedReg(MI.getOperand(CurOp).getReg())) 9360c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_B = 0x0; 93736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (X86II::is32ExtendedReg(MI.getOperand(CurOp).getReg())) 9380780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky VEX_X = 0x0; 9390c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes break; 94099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes } 94199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 94236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Encoding == X86II::VEX || Encoding == X86II::XOP) { 9430780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // VEX opcode prefix can have 2 or 3 bytes 9440780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // 9450780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // 3 bytes: 9460780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // +-----+ +--------------+ +-------------------+ 9470780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // | C4h | | RXB | m-mmmm | | W | vvvv | L | pp | 9480780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // +-----+ +--------------+ +-------------------+ 9490780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // 2 bytes: 9500780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // +-----+ +-------------------+ 9510780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // | C5h | | R | vvvv | L | pp | 9520780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // +-----+ +-------------------+ 9530780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // 95436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // XOP uses a similar prefix: 95536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // +-----+ +--------------+ +-------------------+ 95636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // | 8Fh | | RXB | m-mmmm | | W | vvvv | L | pp | 95736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // +-----+ +--------------+ +-------------------+ 9580780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky unsigned char LastByte = VEX_PP | (VEX_L << 2) | (VEX_4V << 3); 95999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 96036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Can we use the 2 byte VEX prefix? 96136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Encoding == X86II::VEX && VEX_B && VEX_X && !VEX_W && (VEX_5M == 1)) { 9620780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EmitByte(0xC5, CurByte, OS); 9630780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EmitByte(LastByte | (VEX_R << 7), CurByte, OS); 9640780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky return; 9650780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 96699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 9670780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // 3 byte VEX prefix 96836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(Encoding == X86II::XOP ? 0x8F : 0xC4, CurByte, OS); 9690780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EmitByte(VEX_R << 7 | VEX_X << 6 | VEX_B << 5 | VEX_5M, CurByte, OS); 9700780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EmitByte(LastByte | (VEX_W << 7), CurByte, OS); 9710780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } else { 97236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(Encoding == X86II::EVEX && "unknown encoding!"); 9730780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // EVEX opcode prefix can have 4 bytes 9740780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // 9750780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // +-----+ +--------------+ +-------------------+ +------------------------+ 9760780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // | 62h | | RXBR' | 00mm | | W | vvvv | U | pp | | z | L'L | b | v' | aaa | 9770780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // +-----+ +--------------+ +-------------------+ +------------------------+ 9780780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky assert((VEX_5M & 0x3) == VEX_5M 9790780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky && "More than 2 significant bits in VEX.m-mmmm fields for EVEX!"); 9800780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 9810780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky VEX_5M &= 0x3; 9820780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 9830780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EmitByte(0x62, CurByte, OS); 9840780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EmitByte((VEX_R << 7) | 9850780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky (VEX_X << 6) | 9860780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky (VEX_B << 5) | 9870780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky (EVEX_R2 << 4) | 9880780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky VEX_5M, CurByte, OS); 9890780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky EmitByte((VEX_W << 7) | 9900780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky (VEX_4V << 3) | 9910780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky (EVEX_U << 2) | 9920780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky VEX_PP, CurByte, OS); 99336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (EncodeRC) 99436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte((EVEX_z << 7) | 99536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (EVEX_rc << 5) | 99636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (EVEX_b << 4) | 99736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (EVEX_V2 << 3) | 99836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EVEX_aaa, CurByte, OS); 99936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines else 100036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte((EVEX_z << 7) | 100136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (EVEX_L2 << 6) | 100236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (VEX_L << 5) | 100336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (EVEX_b << 4) | 100436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (EVEX_V2 << 3) | 100536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EVEX_aaa, CurByte, OS); 10060780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 100799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes} 100899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 100939a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner/// DetermineREXPrefix - Determine if the MCInst has to be encoded with a X86-64 101039a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner/// REX prefix which specifies 1) 64-bit instructions, 2) non-default operand 101139a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner/// size, and 3) use of X86-64 extended registers. 101299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopesstatic unsigned DetermineREXPrefix(const MCInst &MI, uint64_t TSFlags, 1013e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &Desc) { 10147e85180d15c4d5a451fbc078f7194a41c6230a57Chris Lattner unsigned REX = 0; 101539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (TSFlags & X86II::REX_W) 1016e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << 3; // set REX.W 101796716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 101839a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (MI.getNumOperands() == 0) return REX; 101996716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 102039a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner unsigned NumOps = MI.getNumOperands(); 102139a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner // FIXME: MCInst should explicitize the two-addrness. 102239a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner bool isTwoAddr = NumOps > 1 && 1023e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng Desc.getOperandConstraint(1, MCOI::TIED_TO) != -1; 102496716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 102539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner // If it accesses SPL, BPL, SIL, or DIL, then it requires a 0x40 REX prefix. 102639a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner unsigned i = isTwoAddr ? 1 : 0; 102739a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner for (; i != NumOps; ++i) { 102839a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner const MCOperand &MO = MI.getOperand(i); 102939a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (!MO.isReg()) continue; 103039a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner unsigned Reg = MO.getReg(); 10318c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng if (!X86II::isX86_64NonExtLowByteReg(Reg)) continue; 1032faa75f6f6f2b37359a458fd9acd57c58ee26eea9Chris Lattner // FIXME: The caller of DetermineREXPrefix slaps this prefix onto anything 1033faa75f6f6f2b37359a458fd9acd57c58ee26eea9Chris Lattner // that returns non-zero. 1034e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 0x40; // REX fixed encoding prefix 103539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner break; 103639a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 103796716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 103839a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner switch (TSFlags & X86II::FormMask) { 103939a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRMSrcReg: 104039a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (MI.getOperand(0).isReg() && 10418c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng X86II::isX86_64ExtendedReg(MI.getOperand(0).getReg())) 1042e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << 2; // set REX.R 104339a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner i = isTwoAddr ? 2 : 1; 104439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner for (; i != NumOps; ++i) { 104539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner const MCOperand &MO = MI.getOperand(i); 10468c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng if (MO.isReg() && X86II::isX86_64ExtendedReg(MO.getReg())) 1047e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << 0; // set REX.B 104839a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 104939a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner break; 105039a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRMSrcMem: { 105139a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (MI.getOperand(0).isReg() && 10528c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng X86II::isX86_64ExtendedReg(MI.getOperand(0).getReg())) 1053e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << 2; // set REX.R 105439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner unsigned Bit = 0; 105539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner i = isTwoAddr ? 2 : 1; 105639a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner for (; i != NumOps; ++i) { 105739a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner const MCOperand &MO = MI.getOperand(i); 105839a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (MO.isReg()) { 10598c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng if (X86II::isX86_64ExtendedReg(MO.getReg())) 1060e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << Bit; // set REX.B (Bit=0) and REX.X (Bit=1) 106139a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner Bit++; 106239a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 106339a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 106439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner break; 106539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 106636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRMXm: 106739a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRM0m: case X86II::MRM1m: 106839a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRM2m: case X86II::MRM3m: 106939a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRM4m: case X86II::MRM5m: 107039a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRM6m: case X86II::MRM7m: 107139a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRMDestMem: { 1072ac0ed5dc082dff9ce359af5422f5b82047b4fe6bChris Lattner unsigned e = (isTwoAddr ? X86::AddrNumOperands+1 : X86::AddrNumOperands); 107339a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner i = isTwoAddr ? 1 : 0; 107439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (NumOps > e && MI.getOperand(e).isReg() && 10758c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng X86II::isX86_64ExtendedReg(MI.getOperand(e).getReg())) 1076e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << 2; // set REX.R 107739a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner unsigned Bit = 0; 107839a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner for (; i != e; ++i) { 107939a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner const MCOperand &MO = MI.getOperand(i); 108039a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (MO.isReg()) { 10818c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng if (X86II::isX86_64ExtendedReg(MO.getReg())) 1082e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << Bit; // REX.B (Bit=0) and REX.X (Bit=1) 108339a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner Bit++; 108439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 108539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 108639a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner break; 108739a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 108839a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner default: 108939a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (MI.getOperand(0).isReg() && 10908c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng X86II::isX86_64ExtendedReg(MI.getOperand(0).getReg())) 1091e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << 0; // set REX.B 109239a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner i = isTwoAddr ? 2 : 1; 109339a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner for (unsigned e = NumOps; i != e; ++i) { 109439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner const MCOperand &MO = MI.getOperand(i); 10958c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng if (MO.isReg() && X86II::isX86_64ExtendedReg(MO.getReg())) 1096e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << 2; // set REX.R 109739a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 109839a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner break; 109939a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 110039a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner return REX; 110139a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner} 110292b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner 11031cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes/// EmitSegmentOverridePrefix - Emit segment override opcode prefix as needed 110436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesvoid X86MCCodeEmitter::EmitSegmentOverridePrefix(unsigned &CurByte, 110536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned SegOperand, 110636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const MCInst &MI, 110736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines raw_ostream &OS) const { 110836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Check for explicit segment override on memory operand. 110936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines switch (MI.getOperand(SegOperand).getReg()) { 111036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines default: llvm_unreachable("Unknown segment register!"); 111136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case 0: break; 111236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86::CS: EmitByte(0x2E, CurByte, OS); break; 111336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86::SS: EmitByte(0x36, CurByte, OS); break; 111436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86::DS: EmitByte(0x3E, CurByte, OS); break; 111536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86::ES: EmitByte(0x26, CurByte, OS); break; 111636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86::FS: EmitByte(0x64, CurByte, OS); break; 111736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86::GS: EmitByte(0x65, CurByte, OS); break; 111892b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner } 11191cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes} 11201cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes 11211cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes/// EmitOpcodePrefix - Emit all instruction prefixes prior to the opcode. 11221cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes/// 11231cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes/// MemOperand is the operand # of the start of a memory operand if present. If 11241cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes/// Not present, it is -1. 11251cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopesvoid X86MCCodeEmitter::EmitOpcodePrefix(uint64_t TSFlags, unsigned &CurByte, 11261cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes int MemOperand, const MCInst &MI, 1127e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &Desc, 112836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const MCSubtargetInfo &STI, 11291cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes raw_ostream &OS) const { 11301cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes 113178a194693bb9bbfa1080454cded0166265b803e5Chris Lattner // Emit the operand size opcode prefix as needed. 113236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned char OpSize = (TSFlags & X86II::OpSizeMask) >> X86II::OpSizeShift; 113336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (OpSize == (is16BitMode(STI) ? X86II::OpSize32 : X86II::OpSize16)) 113478a194693bb9bbfa1080454cded0166265b803e5Chris Lattner EmitByte(0x66, CurByte, OS); 113596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 113636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines switch (TSFlags & X86II::OpPrefixMask) { 113736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::PD: // 66 113836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(0x66, CurByte, OS); 113975485d6746f8b5b23c17cf6d2364e7e1e0705992Craig Topper break; 114036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::XS: // F3 114137ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0xF3, CurByte, OS); 11421e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner break; 114336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::XD: // F2 114437ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0xF2, CurByte, OS); 11451e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner break; 11461e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner } 114796716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 11481e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner // Handle REX prefix. 114939a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner // FIXME: Can this come before F2 etc to simplify emission? 115036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (is64BitMode(STI)) { 115139a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (unsigned REX = DetermineREXPrefix(MI, TSFlags, Desc)) 115237ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0x40 | REX, CurByte, OS); 11531e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner } 115496716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 11551e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner // 0x0F escape code must be emitted just before the opcode. 115636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines switch (TSFlags & X86II::OpMapMask) { 115736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::TB: // Two-byte opcode map 115836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::T8: // 0F 38 115936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::TA: // 0F 3A 116037ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0x0F, CurByte, OS); 116136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines break; 116236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 116396716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 116436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines switch (TSFlags & X86II::OpMapMask) { 11651e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner case X86II::T8: // 0F 38 116637ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0x38, CurByte, OS); 11671e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner break; 11681e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner case X86II::TA: // 0F 3A 116937ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0x3A, CurByte, OS); 11701e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner break; 11711e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner } 117299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes} 117399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 117499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopesvoid X86MCCodeEmitter:: 117599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso LopesEncodeInstruction(const MCInst &MI, raw_ostream &OS, 117636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SmallVectorImpl<MCFixup> &Fixups, 117736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const MCSubtargetInfo &STI) const { 117899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned Opcode = MI.getOpcode(); 117959ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng const MCInstrDesc &Desc = MCII.get(Opcode); 118099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes uint64_t TSFlags = Desc.TSFlags; 118199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 1182757e8d6d2e18495a247d0ae90293889ab8093babChris Lattner // Pseudo instructions don't get encoded. 1183757e8d6d2e18495a247d0ae90293889ab8093babChris Lattner if ((TSFlags & X86II::FormMask) == X86II::Pseudo) 1184757e8d6d2e18495a247d0ae90293889ab8093babChris Lattner return; 118596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 1186834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner unsigned NumOps = Desc.getNumOperands(); 118715b64d0e28efc625bd740b19ad4138f48d5b98b0Preston Gurd unsigned CurOp = X86II::getOperandBias(Desc); 118896716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 118999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // Keep track of the current byte being emitted. 119099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned CurByte = 0; 119196716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 119236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Encoding type for this instruction. 119336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned char Encoding = (TSFlags & X86II::EncodingMask) >> 119436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines X86II::EncodingShift; 1195c3d57b179c33ef010ebbff003ce8c5d908cf9c01Bruno Cardoso Lopes 1196c3d57b179c33ef010ebbff003ce8c5d908cf9c01Bruno Cardoso Lopes // It uses the VEX.VVVV field? 1197b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper bool HasVEX_4V = (TSFlags >> X86II::VEXShift) & X86II::VEX_4V; 1198b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper bool HasVEX_4VOp3 = (TSFlags >> X86II::VEXShift) & X86II::VEX_4VOp3; 11995d1a38cbfac62f75ee22cc0c9195616ea5fe5553Craig Topper bool HasMemOp4 = (TSFlags >> X86II::VEXShift) & X86II::MemOp4; 12005d1a38cbfac62f75ee22cc0c9195616ea5fe5553Craig Topper const unsigned MemOp4_I8IMMOperand = 2; 120196716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 12020780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky // It uses the EVEX.aaa field? 120336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool HasEVEX_K = ((TSFlags >> X86II::VEXShift) & X86II::EVEX_K); 120436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool HasEVEX_RC = ((TSFlags >> X86II::VEXShift) & X86II::EVEX_RC); 120536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 1206834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner // Determine where the memory operand starts, if present. 120717730847d59c919d97f097d46a3fcba1888e5300Craig Topper int MemoryOperand = X86II::getMemoryOperandNo(TSFlags, Opcode); 1208834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner if (MemoryOperand != -1) MemoryOperand += CurOp; 120996716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 121036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Emit the lock opcode prefix as needed. 121136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (TSFlags & X86II::LOCK) 121236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(0xF0, CurByte, OS); 121336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 121436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Emit segment override opcode prefix as needed. 121536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (MemoryOperand >= 0) 121636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitSegmentOverridePrefix(CurByte, MemoryOperand+X86::AddrSegmentReg, 121736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MI, OS); 121836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 121936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Emit the repeat opcode prefix as needed. 122036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (TSFlags & X86II::REP) 122136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(0xF3, CurByte, OS); 122236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 122336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Emit the address size opcode prefix as needed. 122436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool need_address_override; 122536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // The AdSize prefix is only for 32-bit and 64-bit modes. Hm, perhaps we 122636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // should introduce an AdSize16 bit instead of having seven special cases? 122736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if ((!is16BitMode(STI) && TSFlags & X86II::AdSize) || 122836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (is16BitMode(STI) && (MI.getOpcode() == X86::JECXZ_32 || 122936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MI.getOpcode() == X86::MOV8o8a || 123036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MI.getOpcode() == X86::MOV16o16a || 123136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MI.getOpcode() == X86::MOV32o32a || 123236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MI.getOpcode() == X86::MOV8ao8 || 123336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MI.getOpcode() == X86::MOV16ao16 || 123436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MI.getOpcode() == X86::MOV32ao32))) { 123536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines need_address_override = true; 123636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } else if (MemoryOperand < 0) { 123736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines need_address_override = false; 123836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } else if (is64BitMode(STI)) { 123936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(!Is16BitMemOperand(MI, MemoryOperand, STI)); 124036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines need_address_override = Is32BitMemOperand(MI, MemoryOperand); 124136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } else if (is32BitMode(STI)) { 124236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(!Is64BitMemOperand(MI, MemoryOperand)); 124336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines need_address_override = Is16BitMemOperand(MI, MemoryOperand, STI); 124436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } else { 124536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(is16BitMode(STI)); 124636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(!Is64BitMemOperand(MI, MemoryOperand)); 124736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines need_address_override = !Is16BitMemOperand(MI, MemoryOperand, STI); 124836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 124936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 125036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (need_address_override) 125136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(0x67, CurByte, OS); 125236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 125336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Encoding == 0) 125436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitOpcodePrefix(TSFlags, CurByte, MemoryOperand, MI, Desc, STI, OS); 125599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes else 12561cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes EmitVEXOpcodePrefix(TSFlags, CurByte, MemoryOperand, MI, Desc, OS); 125796716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 125874a2151392a08e202f497ece7a3129663526d431Chris Lattner unsigned char BaseOpcode = X86II::getBaseOpcodeFor(TSFlags); 12594e423359721fa88cb50ccea51ccf1c520d765ad0Bruno Cardoso Lopes 1260229e4523f2f12929defa09ac4ef9f3652f21f1ecJoerg Sonnenberger if ((TSFlags >> X86II::VEXShift) & X86II::Has3DNow0F0FOpcode) 1261548abfcbd671b1144bf517b17643259dcae76f4fChris Lattner BaseOpcode = 0x0F; // Weird 3DNow! encoding. 12624e423359721fa88cb50ccea51ccf1c520d765ad0Bruno Cardoso Lopes 126399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned SrcRegNum = 0; 12641e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner switch (TSFlags & X86II::FormMask) { 12651ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner default: errs() << "FORM: " << (TSFlags & X86II::FormMask) << "\n"; 12666d1263acb9704b38a8d90fd6ce94f49193cd4ddeCraig Topper llvm_unreachable("Unknown FormMask value in X86MCCodeEmitter!"); 1267757e8d6d2e18495a247d0ae90293889ab8093babChris Lattner case X86II::Pseudo: 12686d1263acb9704b38a8d90fd6ce94f49193cd4ddeCraig Topper llvm_unreachable("Pseudo instruction shouldn't be emitted"); 126936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::RawFrmDstSrc: { 127036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned siReg = MI.getOperand(1).getReg(); 127136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(((siReg == X86::SI && MI.getOperand(0).getReg() == X86::DI) || 127236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (siReg == X86::ESI && MI.getOperand(0).getReg() == X86::EDI) || 127336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (siReg == X86::RSI && MI.getOperand(0).getReg() == X86::RDI)) && 127436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "SI and DI register sizes do not match"); 127536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Emit segment override opcode prefix as needed (not for %ds). 127636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (MI.getOperand(2).getReg() != X86::DS) 127736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitSegmentOverridePrefix(CurByte, 2, MI, OS); 127836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Emit AdSize prefix as needed. 127936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if ((!is32BitMode(STI) && siReg == X86::ESI) || 128036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (is32BitMode(STI) && siReg == X86::SI)) 128136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(0x67, CurByte, OS); 128236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines CurOp += 3; // Consume operands. 128336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(BaseOpcode, CurByte, OS); 128436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines break; 128536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 128636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::RawFrmSrc: { 128736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned siReg = MI.getOperand(0).getReg(); 128836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Emit segment override opcode prefix as needed (not for %ds). 128936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (MI.getOperand(1).getReg() != X86::DS) 129036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitSegmentOverridePrefix(CurByte, 1, MI, OS); 129136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Emit AdSize prefix as needed. 129236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if ((!is32BitMode(STI) && siReg == X86::ESI) || 129336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (is32BitMode(STI) && siReg == X86::SI)) 129436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(0x67, CurByte, OS); 129536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines CurOp += 2; // Consume operands. 129636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(BaseOpcode, CurByte, OS); 129736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines break; 129836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 129936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::RawFrmDst: { 130036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned siReg = MI.getOperand(0).getReg(); 130136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Emit AdSize prefix as needed. 130236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if ((!is32BitMode(STI) && siReg == X86::EDI) || 130336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (is32BitMode(STI) && siReg == X86::DI)) 130436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(0x67, CurByte, OS); 130536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ++CurOp; // Consume operand. 130636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(BaseOpcode, CurByte, OS); 130736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines break; 130836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 13098b0f7a7d8627392c8faae3801cc91689406960cfChris Lattner case X86II::RawFrm: 131037ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(BaseOpcode, CurByte, OS); 131128249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner break; 131236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::RawFrmMemOffs: 131336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Emit segment override opcode prefix as needed. 131436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitSegmentOverridePrefix(CurByte, 1, MI, OS); 131536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitByte(BaseOpcode, CurByte, OS); 131636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitImmediate(MI.getOperand(CurOp++), MI.getLoc(), 131736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines X86II::getSizeOfImm(TSFlags), getImmFixupKind(TSFlags), 131836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines CurByte, OS, Fixups); 131936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ++CurOp; // skip segment operand 132036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines break; 132140cc3f8783a4e426a0d439bb2b070b5c072b5947Chris Lattner case X86II::RawFrmImm8: 132240cc3f8783a4e426a0d439bb2b070b5c072b5947Chris Lattner EmitByte(BaseOpcode, CurByte, OS); 1323cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach EmitImmediate(MI.getOperand(CurOp++), MI.getLoc(), 132440cc3f8783a4e426a0d439bb2b070b5c072b5947Chris Lattner X86II::getSizeOfImm(TSFlags), getImmFixupKind(TSFlags), 132540cc3f8783a4e426a0d439bb2b070b5c072b5947Chris Lattner CurByte, OS, Fixups); 1326cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach EmitImmediate(MI.getOperand(CurOp++), MI.getLoc(), 1, FK_Data_1, CurByte, 1327cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach OS, Fixups); 132840cc3f8783a4e426a0d439bb2b070b5c072b5947Chris Lattner break; 132959f8a6a66621f7c6f45b838e48fbf210af9d1fb5Chris Lattner case X86II::RawFrmImm16: 133059f8a6a66621f7c6f45b838e48fbf210af9d1fb5Chris Lattner EmitByte(BaseOpcode, CurByte, OS); 1331cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach EmitImmediate(MI.getOperand(CurOp++), MI.getLoc(), 133259f8a6a66621f7c6f45b838e48fbf210af9d1fb5Chris Lattner X86II::getSizeOfImm(TSFlags), getImmFixupKind(TSFlags), 133359f8a6a66621f7c6f45b838e48fbf210af9d1fb5Chris Lattner CurByte, OS, Fixups); 1334cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach EmitImmediate(MI.getOperand(CurOp++), MI.getLoc(), 2, FK_Data_2, CurByte, 1335cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach OS, Fixups); 133659f8a6a66621f7c6f45b838e48fbf210af9d1fb5Chris Lattner break; 133796716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 13388b0f7a7d8627392c8faae3801cc91689406960cfChris Lattner case X86II::AddRegFrm: 133937ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(BaseOpcode + GetX86RegNum(MI.getOperand(CurOp++)), CurByte, OS); 13401e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner break; 134196716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 134228249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner case X86II::MRMDestReg: 134337ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(BaseOpcode, CurByte, OS); 13448647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper SrcRegNum = CurOp + 1; 13458647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper 13460780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasEVEX_K) // Skip writemask 13470780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky SrcRegNum++; 13480780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 13498647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper if (HasVEX_4V) // Skip 1st src (which is encoded in VEX_VVVV) 13508647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper ++SrcRegNum; 13518647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper 135228249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner EmitRegModRMByte(MI.getOperand(CurOp), 13538647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper GetX86RegNum(MI.getOperand(SrcRegNum)), CurByte, OS); 13548647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper CurOp = SrcRegNum + 1; 135528249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner break; 135696716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 13571ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner case X86II::MRMDestMem: 135837ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(BaseOpcode, CurByte, OS); 13594b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes SrcRegNum = CurOp + X86::AddrNumOperands; 13604b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes 13610780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasEVEX_K) // Skip writemask 13620780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky SrcRegNum++; 13630780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 13644b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes if (HasVEX_4V) // Skip 1st src (which is encoded in VEX_VVVV) 13655084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper ++SrcRegNum; 13664b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes 13671ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner EmitMemModRMByte(MI, CurOp, 13684b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes GetX86RegNum(MI.getOperand(SrcRegNum)), 136936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines TSFlags, CurByte, OS, Fixups, STI); 13704b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes CurOp = SrcRegNum + 1; 13711ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner break; 137296716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 1373daa45557931bb72e6b9f6b4725ac2cb1bd5168e9Chris Lattner case X86II::MRMSrcReg: 137437ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(BaseOpcode, CurByte, OS); 137599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes SrcRegNum = CurOp + 1; 137699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 13770780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasEVEX_K) // Skip writemask 13780780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky SrcRegNum++; 13790780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 1380b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper if (HasVEX_4V) // Skip 1st src (which is encoded in VEX_VVVV) 13815084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper ++SrcRegNum; 138299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 13835084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper if (HasMemOp4) // Skip 2nd src (which is encoded in I8IMM) 13845084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper ++SrcRegNum; 13851b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes 138699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes EmitRegModRMByte(MI.getOperand(SrcRegNum), 138799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes GetX86RegNum(MI.getOperand(CurOp)), CurByte, OS); 1388703420f50e458e2482e55c9a5b3cafa0b734f507Jan Sjödin 13895084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper // 2 operands skipped with HasMemOp4, compensate accordingly 13905d1a38cbfac62f75ee22cc0c9195616ea5fe5553Craig Topper CurOp = HasMemOp4 ? SrcRegNum : SrcRegNum + 1; 1391b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper if (HasVEX_4VOp3) 139217730847d59c919d97f097d46a3fcba1888e5300Craig Topper ++CurOp; 139336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // do not count the rounding control operand 139436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (HasEVEX_RC) 139536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines NumOps--; 1396daa45557931bb72e6b9f6b4725ac2cb1bd5168e9Chris Lattner break; 139796716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 1398daa45557931bb72e6b9f6b4725ac2cb1bd5168e9Chris Lattner case X86II::MRMSrcMem: { 1399ac0ed5dc082dff9ce359af5422f5b82047b4fe6bChris Lattner int AddrOperands = X86::AddrNumOperands; 14001cf44fc051e05c7cd96a4b071b654381338baae9Chris Lattner unsigned FirstMemOp = CurOp+1; 14010780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 14020780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky if (HasEVEX_K) { // Skip writemask 14030780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky ++AddrOperands; 14040780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky ++FirstMemOp; 14050780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky } 14060780179d532d20b6b01ba0f1434c93f81b7faea8Elena Demikhovsky 1407b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper if (HasVEX_4V) { 14081cf44fc051e05c7cd96a4b071b654381338baae9Chris Lattner ++AddrOperands; 14091cf44fc051e05c7cd96a4b071b654381338baae9Chris Lattner ++FirstMemOp; // Skip the register source (which is encoded in VEX_VVVV). 14101cf44fc051e05c7cd96a4b071b654381338baae9Chris Lattner } 14115084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper if (HasMemOp4) // Skip second register source (encoded in I8IMM) 14121b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes ++FirstMemOp; 1413daa45557931bb72e6b9f6b4725ac2cb1bd5168e9Chris Lattner 14141cf44fc051e05c7cd96a4b071b654381338baae9Chris Lattner EmitByte(BaseOpcode, CurByte, OS); 141596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 14161cf44fc051e05c7cd96a4b071b654381338baae9Chris Lattner EmitMemModRMByte(MI, FirstMemOp, GetX86RegNum(MI.getOperand(CurOp)), 141736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines TSFlags, CurByte, OS, Fixups, STI); 1418703420f50e458e2482e55c9a5b3cafa0b734f507Jan Sjödin CurOp += AddrOperands + 1; 1419703420f50e458e2482e55c9a5b3cafa0b734f507Jan Sjödin if (HasVEX_4VOp3) 1420703420f50e458e2482e55c9a5b3cafa0b734f507Jan Sjödin ++CurOp; 1421daa45557931bb72e6b9f6b4725ac2cb1bd5168e9Chris Lattner break; 1422daa45557931bb72e6b9f6b4725ac2cb1bd5168e9Chris Lattner } 142382ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner 142436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRMXr: 142582ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner case X86II::MRM0r: case X86II::MRM1r: 142682ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner case X86II::MRM2r: case X86II::MRM3r: 142782ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner case X86II::MRM4r: case X86II::MRM5r: 142836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM6r: case X86II::MRM7r: { 14295a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes if (HasVEX_4V) // Skip the register dst (which is encoded in VEX_VVVV). 14305084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper ++CurOp; 1431dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (HasEVEX_K) // Skip writemask 1432dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ++CurOp; 143337ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(BaseOpcode, CurByte, OS); 143436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines uint64_t Form = TSFlags & X86II::FormMask; 1435eaca5fa8e6a2cb0f84a635da5f1f0f670776d0a5Chris Lattner EmitRegModRMByte(MI.getOperand(CurOp++), 143636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (Form == X86II::MRMXr) ? 0 : Form-X86II::MRM0r, 1437eaca5fa8e6a2cb0f84a635da5f1f0f670776d0a5Chris Lattner CurByte, OS); 143882ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner break; 143936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 144036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 144136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRMXm: 144282ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner case X86II::MRM0m: case X86II::MRM1m: 144382ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner case X86II::MRM2m: case X86II::MRM3m: 144482ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner case X86II::MRM4m: case X86II::MRM5m: 144536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM6m: case X86II::MRM7m: { 1446566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper if (HasVEX_4V) // Skip the register dst (which is encoded in VEX_VVVV). 14475084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper ++CurOp; 1448dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (HasEVEX_K) // Skip writemask 1449dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ++CurOp; 145037ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(BaseOpcode, CurByte, OS); 145136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines uint64_t Form = TSFlags & X86II::FormMask; 145236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EmitMemModRMByte(MI, CurOp, (Form == X86II::MRMXm) ? 0 : Form-X86II::MRM0m, 145336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines TSFlags, CurByte, OS, Fixups, STI); 1454ac0ed5dc082dff9ce359af5422f5b82047b4fe6bChris Lattner CurOp += X86::AddrNumOperands; 145582ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner break; 145636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 145736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_C0: case X86II::MRM_C1: case X86II::MRM_C2: 145836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_C3: case X86II::MRM_C4: case X86II::MRM_C8: 145936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_C9: case X86II::MRM_CA: case X86II::MRM_CB: 146036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_D0: case X86II::MRM_D1: case X86II::MRM_D4: 146136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_D5: case X86II::MRM_D6: case X86II::MRM_D8: 146236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_D9: case X86II::MRM_DA: case X86II::MRM_DB: 146336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_DC: case X86II::MRM_DD: case X86II::MRM_DE: 146436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_DF: case X86II::MRM_E0: case X86II::MRM_E1: 146536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_E2: case X86II::MRM_E3: case X86II::MRM_E4: 146636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_E5: case X86II::MRM_E8: case X86II::MRM_E9: 146736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_EA: case X86II::MRM_EB: case X86II::MRM_EC: 146836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_ED: case X86II::MRM_EE: case X86II::MRM_F0: 146936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_F1: case X86II::MRM_F2: case X86II::MRM_F3: 147036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_F4: case X86II::MRM_F5: case X86II::MRM_F6: 147136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_F7: case X86II::MRM_F8: case X86II::MRM_F9: 147236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_FA: case X86II::MRM_FB: case X86II::MRM_FC: 147336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_FD: case X86II::MRM_FE: case X86II::MRM_FF: 14740d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner EmitByte(BaseOpcode, CurByte, OS); 14759e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper 14769e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper unsigned char MRM; 14779e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper switch (TSFlags & X86II::FormMask) { 14789e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper default: llvm_unreachable("Invalid Form"); 147936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_C0: MRM = 0xC0; break; 14809e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_C1: MRM = 0xC1; break; 14819e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_C2: MRM = 0xC2; break; 14829e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_C3: MRM = 0xC3; break; 14839e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_C4: MRM = 0xC4; break; 14849e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_C8: MRM = 0xC8; break; 14859e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_C9: MRM = 0xC9; break; 148602d2e612521954b5ff7c1ba6fd53e36bc51e1c48Michael Liao case X86II::MRM_CA: MRM = 0xCA; break; 148702d2e612521954b5ff7c1ba6fd53e36bc51e1c48Michael Liao case X86II::MRM_CB: MRM = 0xCB; break; 14889e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_D0: MRM = 0xD0; break; 14899e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_D1: MRM = 0xD1; break; 149028a713b20ad17f9a02d4677d8a2fea0edb208418Craig Topper case X86II::MRM_D4: MRM = 0xD4; break; 1491be02a90de17f857ba65bbd8a11653ca1bad30adcMichael Liao case X86II::MRM_D5: MRM = 0xD5; break; 14929b3939983fd0103b102c7aec0ed08d1e8bd28214Dave Zarzycki case X86II::MRM_D6: MRM = 0xD6; break; 14939e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_D8: MRM = 0xD8; break; 14949e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_D9: MRM = 0xD9; break; 14959e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_DA: MRM = 0xDA; break; 14969e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_DB: MRM = 0xDB; break; 14979e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_DC: MRM = 0xDC; break; 14989e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_DD: MRM = 0xDD; break; 14999e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_DE: MRM = 0xDE; break; 15009e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_DF: MRM = 0xDF; break; 150136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_E0: MRM = 0xE0; break; 150236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_E1: MRM = 0xE1; break; 150336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_E2: MRM = 0xE2; break; 150436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_E3: MRM = 0xE3; break; 150536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_E4: MRM = 0xE4; break; 150636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_E5: MRM = 0xE5; break; 15079e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_E8: MRM = 0xE8; break; 150836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_E9: MRM = 0xE9; break; 150936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_EA: MRM = 0xEA; break; 151036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_EB: MRM = 0xEB; break; 151136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_EC: MRM = 0xEC; break; 151236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_ED: MRM = 0xED; break; 151336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_EE: MRM = 0xEE; break; 15149e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_F0: MRM = 0xF0; break; 151536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_F1: MRM = 0xF1; break; 151636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_F2: MRM = 0xF2; break; 151736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_F3: MRM = 0xF3; break; 151836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_F4: MRM = 0xF4; break; 151936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_F5: MRM = 0xF5; break; 152036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_F6: MRM = 0xF6; break; 152136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_F7: MRM = 0xF7; break; 15229e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_F8: MRM = 0xF8; break; 15239e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper case X86II::MRM_F9: MRM = 0xF9; break; 152436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_FA: MRM = 0xFA; break; 152536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_FB: MRM = 0xFB; break; 152636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_FC: MRM = 0xFC; break; 152736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_FD: MRM = 0xFD; break; 152836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_FE: MRM = 0xFE; break; 152936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case X86II::MRM_FF: MRM = 0xFF; break; 15309e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper } 15319e3d0b335111b2df73984a6cfd9ef1cd5d323872Craig Topper EmitByte(MRM, CurByte, OS); 153287ca0e077d91b96a765b3b24cadfa8891026a33aRafael Espindola break; 153382ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner } 153496716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 15358b0f7a7d8627392c8faae3801cc91689406960cfChris Lattner // If there is a remaining operand, it must be a trailing immediate. Emit it 15361386e9b7b16a8138ae7060c2dbb8b029f7c4fce2Benjamin Kramer // according to the right size for the instruction. Some instructions 15371386e9b7b16a8138ae7060c2dbb8b029f7c4fce2Benjamin Kramer // (SSE4a extrq and insertq) have two trailing immediates. 15381386e9b7b16a8138ae7060c2dbb8b029f7c4fce2Benjamin Kramer while (CurOp != NumOps && NumOps - CurOp <= 2) { 153907de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes // The last source register of a 4 operand instruction in AVX is encoded 1540ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin // in bits[7:4] of a immediate byte. 1541229e4523f2f12929defa09ac4ef9f3652f21f1ecJoerg Sonnenberger if ((TSFlags >> X86II::VEXShift) & X86II::VEX_I8IMM) { 15425d1a38cbfac62f75ee22cc0c9195616ea5fe5553Craig Topper const MCOperand &MO = MI.getOperand(HasMemOp4 ? MemOp4_I8IMMOperand 15435084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper : CurOp); 15445084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper ++CurOp; 15455084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper unsigned RegNum = GetX86RegNum(MO) << 4; 15465084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper if (X86II::isX86_64ExtendedReg(MO.getReg())) 15475084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper RegNum |= 1 << 7; 1548ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin // If there is an additional 5th operand it must be an immediate, which 1549ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin // is encoded in bits[3:0] 15505084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper if (CurOp != NumOps) { 1551ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin const MCOperand &MIMM = MI.getOperand(CurOp++); 15525084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper if (MIMM.isImm()) { 1553ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin unsigned Val = MIMM.getImm(); 1554ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin assert(Val < 16 && "Immediate operand value out of range"); 1555ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin RegNum |= Val; 1556ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin } 1557ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin } 1558cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach EmitImmediate(MCOperand::CreateImm(RegNum), MI.getLoc(), 1, FK_Data_1, 1559cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach CurByte, OS, Fixups); 1560a8c02c3bdd68e65d14fb6b0d56989663754059b0Rafael Espindola } else { 1561cb5dca38157a48c734660746e7f7340d5db7c2dbJim Grosbach EmitImmediate(MI.getOperand(CurOp++), MI.getLoc(), 156236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines X86II::getSizeOfImm(TSFlags), getImmFixupKind(TSFlags), 156307de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes CurByte, OS, Fixups); 1564a8c02c3bdd68e65d14fb6b0d56989663754059b0Rafael Espindola } 156507de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes } 156607de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes 1567229e4523f2f12929defa09ac4ef9f3652f21f1ecJoerg Sonnenberger if ((TSFlags >> X86II::VEXShift) & X86II::Has3DNow0F0FOpcode) 1568548abfcbd671b1144bf517b17643259dcae76f4fChris Lattner EmitByte(X86II::getBaseOpcodeFor(TSFlags), CurByte, OS); 156907de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes 157028249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner#ifndef NDEBUG 157182ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner // FIXME: Verify. 157282ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner if (/*!Desc.isVariadic() &&*/ CurOp != NumOps) { 157328249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner errs() << "Cannot encode all operands of: "; 157428249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner MI.dump(); 157528249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner errs() << '\n'; 157628249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner abort(); 157728249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner } 157828249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner#endif 1579457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner} 1580