X86MCCodeEmitter.cpp revision ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5c
1457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner//===-- X86/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 142ac190238e88b21e716e2853900b5076c9013410Chris Lattner#define DEBUG_TYPE "mccodeemitter" 158c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng#include "MCTargetDesc/X86MCTargetDesc.h" 168c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng#include "MCTargetDesc/X86BaseInfo.h" 178c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng#include "MCTargetDesc/X86FixupKinds.h" 18457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner#include "llvm/MC/MCCodeEmitter.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 29457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattnernamespace { 30457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattnerclass X86MCCodeEmitter : public MCCodeEmitter { 318c8b9ee8c8646aa1a79c782d4da9abdf3eb4eefeArgyrios Kyrtzidis X86MCCodeEmitter(const X86MCCodeEmitter &); // DO NOT IMPLEMENT 328c8b9ee8c8646aa1a79c782d4da9abdf3eb4eefeArgyrios Kyrtzidis void operator=(const X86MCCodeEmitter &); // DO NOT IMPLEMENT 3359ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng const MCInstrInfo &MCII; 3459ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng const MCSubtargetInfo &STI; 354a2e5edb94c5d6ceb2f8f99ec031963e4c3862f9Chris Lattner MCContext &Ctx; 36457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattnerpublic: 3759ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng X86MCCodeEmitter(const MCInstrInfo &mcii, const MCSubtargetInfo &sti, 3859ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng MCContext &ctx) 3959ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng : MCII(mcii), STI(sti), Ctx(ctx) { 40457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner } 41457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner 42457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner ~X86MCCodeEmitter() {} 4373c557458c0e28899f37c557bcaf36c2b6701260Daniel Dunbar 4459ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng bool is64BitMode() const { 4559ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng // FIXME: Can tablegen auto-generate this? 4659ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng return (STI.getFeatureBits() & X86::Mode64Bit) != 0; 4759ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng } 4859ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng 4928249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner static unsigned GetX86RegNum(const MCOperand &MO) { 500e6a052331f674dd70e28af41f654a7874405eabEvan Cheng return X86_MC::getX86RegNum(MO.getReg()); 5128249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner } 525a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes 535a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // On regular x86, both XMM0-XMM7 and XMM8-XMM15 are encoded in the range 545a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // 0-7 and the difference between the 2 groups is given by the REX prefix. 555a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // In the VEX prefix, registers are seen sequencially from 0-15 and encoded 565a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // in 1's complement form, example: 575a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // 585a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // ModRM field => XMM9 => 1 595a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // VEX.VVVV => XMM9 => ~9 605a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // 615a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // See table 4-35 of Intel AVX Programming Reference for details. 625a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes static unsigned char getVEXRegisterEncoding(const MCInst &MI, 635a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes unsigned OpNum) { 645a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes unsigned SrcReg = MI.getOperand(OpNum).getReg(); 655a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes unsigned SrcRegNum = GetX86RegNum(MI.getOperand(OpNum)); 66566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper if (X86II::isX86_64ExtendedReg(SrcReg)) 67566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper SrcRegNum |= 8; 6896716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 695a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // The registers represented through VEX_VVVV should 705a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes // be encoded in 1's complement form. 715a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes return (~SrcRegNum) & 0xf; 725a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes } 7396716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 7437ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner void EmitByte(unsigned char C, unsigned &CurByte, raw_ostream &OS) const { 7592b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner OS << (char)C; 7637ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner ++CurByte; 77457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner } 7896716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 7937ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner void EmitConstant(uint64_t Val, unsigned Size, unsigned &CurByte, 8037ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner raw_ostream &OS) const { 8128249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner // Output the constant in little endian byte order. 8228249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner for (unsigned i = 0; i != Size; ++i) { 8337ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(Val & 255, CurByte, OS); 8428249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner Val >>= 8; 8528249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner } 8628249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner } 870e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner 8896716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes void EmitImmediate(const MCOperand &Disp, 89cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner unsigned ImmSize, MCFixupKind FixupKind, 90a38c707d8219a29f50564c826d2aa3154e214c66Chris Lattner unsigned &CurByte, raw_ostream &OS, 91835acabce13993e210b7cef0020a585125f9cb1eChris Lattner SmallVectorImpl<MCFixup> &Fixups, 92835acabce13993e210b7cef0020a585125f9cb1eChris Lattner int ImmOffset = 0) const; 9396716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 9428249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner inline static unsigned char ModRMByte(unsigned Mod, unsigned RegOpcode, 9528249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner unsigned RM) { 9628249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner assert(Mod < 4 && RegOpcode < 8 && RM < 8 && "ModRM Fields out of range!"); 9728249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner return RM | (RegOpcode << 3) | (Mod << 6); 9828249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner } 9996716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 10028249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner void EmitRegModRMByte(const MCOperand &ModRMReg, unsigned RegOpcodeFld, 10137ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner unsigned &CurByte, raw_ostream &OS) const { 10237ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(3, RegOpcodeFld, GetX86RegNum(ModRMReg)), CurByte, OS); 10328249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner } 10496716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 1050e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner void EmitSIBByte(unsigned SS, unsigned Index, unsigned Base, 10637ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner unsigned &CurByte, raw_ostream &OS) const { 10737ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner // SIB byte is in the same format as the ModRMByte. 10837ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(SS, Index, Base), CurByte, OS); 1090e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner } 11096716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 11196716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 1121ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner void EmitMemModRMByte(const MCInst &MI, unsigned Op, 11396716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes unsigned RegOpcodeField, 11499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes uint64_t TSFlags, unsigned &CurByte, raw_ostream &OS, 1155dccfadbf4f46a0a06240f3591f7500e75b1d8cdChris Lattner SmallVectorImpl<MCFixup> &Fixups) const; 11696716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 11773c557458c0e28899f37c557bcaf36c2b6701260Daniel Dunbar void EncodeInstruction(const MCInst &MI, raw_ostream &OS, 11873c557458c0e28899f37c557bcaf36c2b6701260Daniel Dunbar SmallVectorImpl<MCFixup> &Fixups) const; 11996716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 1201cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes void EmitVEXOpcodePrefix(uint64_t TSFlags, unsigned &CurByte, int MemOperand, 121e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInst &MI, const MCInstrDesc &Desc, 12299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes raw_ostream &OS) const; 12399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 1241cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes void EmitSegmentOverridePrefix(uint64_t TSFlags, unsigned &CurByte, 1251cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes int MemOperand, const MCInst &MI, 1261cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes raw_ostream &OS) const; 1271cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes 128834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner void EmitOpcodePrefix(uint64_t TSFlags, unsigned &CurByte, int MemOperand, 129e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInst &MI, const MCInstrDesc &Desc, 13099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes raw_ostream &OS) const; 131457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner}; 132457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner 133457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner} // end anonymous namespace 134457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner 135457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner 13659ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan ChengMCCodeEmitter *llvm::createX86MCCodeEmitter(const MCInstrInfo &MCII, 13759ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng const MCSubtargetInfo &STI, 13859ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng MCContext &Ctx) { 13959ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng return new X86MCCodeEmitter(MCII, STI, Ctx); 14092b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner} 14192b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner 14296716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes/// isDisp8 - Return true if this signed displacement fits in a 8-bit 14396716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes/// sign-extended field. 1441ac23b10384543fcc7343beeac542b2ab626eeecChris Lattnerstatic bool isDisp8(int Value) { 1451ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner return Value == (signed char)Value; 1461ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner} 1471ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner 148cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner/// getImmFixupKind - Return the appropriate fixup kind to use for an immediate 149cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner/// in an instruction with the specified TSFlags. 15099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopesstatic MCFixupKind getImmFixupKind(uint64_t TSFlags) { 151cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner unsigned Size = X86II::getSizeOfImm(TSFlags); 152cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner bool isPCRel = X86II::isImmPCRel(TSFlags); 15396716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 154e04ed7e45f194f14a7b28bbf3f55694d8e2bcf80Rafael Espindola return MCFixup::getKindForSize(Size, isPCRel); 155cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner} 156cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner 1578a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner/// Is32BitMemOperand - Return true if the specified instruction with a memory 1588a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner/// operand should emit the 0x67 prefix byte in 64-bit mode due to a 32-bit 1598a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner/// memory operand. Op specifies the operand # of the memoperand. 1608a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattnerstatic bool Is32BitMemOperand(const MCInst &MI, unsigned Op) { 1618a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner const MCOperand &BaseReg = MI.getOperand(Op+X86::AddrBaseReg); 1628a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner const MCOperand &IndexReg = MI.getOperand(Op+X86::AddrIndexReg); 1634e423359721fa88cb50ccea51ccf1c520d765ad0Bruno Cardoso Lopes 1648c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng if ((BaseReg.getReg() != 0 && 1658c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng X86MCRegisterClasses[X86::GR32RegClassID].contains(BaseReg.getReg())) || 1668c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng (IndexReg.getReg() != 0 && 1678c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng X86MCRegisterClasses[X86::GR32RegClassID].contains(IndexReg.getReg()))) 1688a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner return true; 1698a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner return false; 1708a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner} 171cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner 172f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola/// StartsWithGlobalOffsetTable - Check if this expression starts with 173f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola/// _GLOBAL_OFFSET_TABLE_ and if it is of the form 174f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola/// _GLOBAL_OFFSET_TABLE_-symbol. This is needed to support PIC on ELF 175f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola/// i386 as _GLOBAL_OFFSET_TABLE_ is magical. We check only simple case that 17664e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola/// are know to be used: _GLOBAL_OFFSET_TABLE_ by itself or at the start 17764e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola/// of a binary expression. 178f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindolaenum GlobalOffsetTableExprKind { 179f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola GOT_None, 180f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola GOT_Normal, 181f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola GOT_SymDiff 182f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola}; 183f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindolastatic GlobalOffsetTableExprKind 184f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael EspindolaStartsWithGlobalOffsetTable(const MCExpr *Expr) { 185f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola const MCExpr *RHS = 0; 18664e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola if (Expr->getKind() == MCExpr::Binary) { 18764e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola const MCBinaryExpr *BE = static_cast<const MCBinaryExpr *>(Expr); 18864e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola Expr = BE->getLHS(); 189f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola RHS = BE->getRHS(); 19064e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola } 19164e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola 19264e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola if (Expr->getKind() != MCExpr::SymbolRef) 193f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola return GOT_None; 19464e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola 19564e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola const MCSymbolRefExpr *Ref = static_cast<const MCSymbolRefExpr*>(Expr); 19664e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola const MCSymbol &S = Ref->getSymbol(); 197f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola if (S.getName() != "_GLOBAL_OFFSET_TABLE_") 198f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola return GOT_None; 199f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola if (RHS && RHS->getKind() == MCExpr::SymbolRef) 200f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola return GOT_SymDiff; 201f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola return GOT_Normal; 20264e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola} 20364e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola 2040e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattnervoid X86MCCodeEmitter:: 205cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris LattnerEmitImmediate(const MCOperand &DispOp, unsigned Size, MCFixupKind FixupKind, 206a38c707d8219a29f50564c826d2aa3154e214c66Chris Lattner unsigned &CurByte, raw_ostream &OS, 207835acabce13993e210b7cef0020a585125f9cb1eChris Lattner SmallVectorImpl<MCFixup> &Fixups, int ImmOffset) const { 208d93ceeb125c11a96eb85618bb9a8a7d664a1d8f4Rafael Espindola const MCExpr *Expr = NULL; 2098496a26113859288730d0d97637d032de53b2a7eChris Lattner if (DispOp.isImm()) { 21077169a919718b74f62ab6a577f65ac5ef9547abaBruno Cardoso Lopes // If this is a simple integer displacement that doesn't require a 21177169a919718b74f62ab6a577f65ac5ef9547abaBruno Cardoso Lopes // relocation, emit it now. 212e04ed7e45f194f14a7b28bbf3f55694d8e2bcf80Rafael Espindola if (FixupKind != FK_PCRel_1 && 21377169a919718b74f62ab6a577f65ac5ef9547abaBruno Cardoso Lopes FixupKind != FK_PCRel_2 && 2144e423359721fa88cb50ccea51ccf1c520d765ad0Bruno Cardoso Lopes FixupKind != FK_PCRel_4) { 215d93ceeb125c11a96eb85618bb9a8a7d664a1d8f4Rafael Espindola EmitConstant(DispOp.getImm()+ImmOffset, Size, CurByte, OS); 216d93ceeb125c11a96eb85618bb9a8a7d664a1d8f4Rafael Espindola return; 217d93ceeb125c11a96eb85618bb9a8a7d664a1d8f4Rafael Espindola } 218d93ceeb125c11a96eb85618bb9a8a7d664a1d8f4Rafael Espindola Expr = MCConstantExpr::Create(DispOp.getImm(), Ctx); 219d93ceeb125c11a96eb85618bb9a8a7d664a1d8f4Rafael Espindola } else { 220d93ceeb125c11a96eb85618bb9a8a7d664a1d8f4Rafael Espindola Expr = DispOp.getExpr(); 2210e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner } 22237ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner 223835acabce13993e210b7cef0020a585125f9cb1eChris Lattner // If we have an immoffset, add it to the expression. 224a4d0bd84f7bdc78784e44b623ded448988022e4bEli Friedman if ((FixupKind == FK_Data_4 || 225f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola FixupKind == MCFixupKind(X86::reloc_signed_4byte))) { 226f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola GlobalOffsetTableExprKind Kind = StartsWithGlobalOffsetTable(Expr); 227f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola if (Kind != GOT_None) { 228f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola assert(ImmOffset == 0); 229f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola 230f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola FixupKind = MCFixupKind(X86::reloc_global_offset_table); 231f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola if (Kind == GOT_Normal) 232f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola ImmOffset = CurByte; 233f3aefb56def210eb0c23ecb8f2e0bf7f4be78a37Rafael Espindola } 23464e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola } 23564e6719ee870f88db445feac0a1d5f597a7549e3Rafael Espindola 236a08b587494a09a94a72245dd9d7088564e511f4eChris Lattner // If the fixup is pc-relative, we need to bias the value to be relative to 237a08b587494a09a94a72245dd9d7088564e511f4eChris Lattner // the start of the field, not the end of the field. 238e04ed7e45f194f14a7b28bbf3f55694d8e2bcf80Rafael Espindola if (FixupKind == FK_PCRel_4 || 2399fdac902d4300f2b0b8f4830ff276cc8199864b5Daniel Dunbar FixupKind == MCFixupKind(X86::reloc_riprel_4byte) || 2409fdac902d4300f2b0b8f4830ff276cc8199864b5Daniel Dunbar FixupKind == MCFixupKind(X86::reloc_riprel_4byte_movq_load)) 241a08b587494a09a94a72245dd9d7088564e511f4eChris Lattner ImmOffset -= 4; 242e04ed7e45f194f14a7b28bbf3f55694d8e2bcf80Rafael Espindola if (FixupKind == FK_PCRel_2) 243da3051a17f586b069951931eeed9317cad41243bChris Lattner ImmOffset -= 2; 244e04ed7e45f194f14a7b28bbf3f55694d8e2bcf80Rafael Espindola if (FixupKind == FK_PCRel_1) 245a08b587494a09a94a72245dd9d7088564e511f4eChris Lattner ImmOffset -= 1; 24696716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 2474a2e5edb94c5d6ceb2f8f99ec031963e4c3862f9Chris Lattner if (ImmOffset) 248a08b587494a09a94a72245dd9d7088564e511f4eChris Lattner Expr = MCBinaryExpr::CreateAdd(Expr, MCConstantExpr::Create(ImmOffset, Ctx), 2494a2e5edb94c5d6ceb2f8f99ec031963e4c3862f9Chris Lattner Ctx); 25096716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 2515dccfadbf4f46a0a06240f3591f7500e75b1d8cdChris Lattner // Emit a symbolic constant as a fixup and 4 zeros. 252835acabce13993e210b7cef0020a585125f9cb1eChris Lattner Fixups.push_back(MCFixup::Create(CurByte, Expr, FixupKind)); 253a38c707d8219a29f50564c826d2aa3154e214c66Chris Lattner EmitConstant(0, Size, CurByte, OS); 2540e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner} 2550e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner 2561ac23b10384543fcc7343beeac542b2ab626eeecChris Lattnervoid X86MCCodeEmitter::EmitMemModRMByte(const MCInst &MI, unsigned Op, 2571ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner unsigned RegOpcodeField, 25899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes uint64_t TSFlags, unsigned &CurByte, 2595dccfadbf4f46a0a06240f3591f7500e75b1d8cdChris Lattner raw_ostream &OS, 2605dccfadbf4f46a0a06240f3591f7500e75b1d8cdChris Lattner SmallVectorImpl<MCFixup> &Fixups) const{ 2618a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner const MCOperand &Disp = MI.getOperand(Op+X86::AddrDisp); 2628a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner const MCOperand &Base = MI.getOperand(Op+X86::AddrBaseReg); 2638a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner const MCOperand &Scale = MI.getOperand(Op+X86::AddrScaleAmt); 2648a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner const MCOperand &IndexReg = MI.getOperand(Op+X86::AddrIndexReg); 2651ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner unsigned BaseReg = Base.getReg(); 26696716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 2671e35d0e9234836c4cea5ec9d1ec11dcc017911beChris Lattner // Handle %rip relative addressing. 2681e35d0e9234836c4cea5ec9d1ec11dcc017911beChris Lattner if (BaseReg == X86::RIP) { // [disp32+RIP] in X86-64 mode 26959ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng assert(is64BitMode() && "Rip-relative addressing requires 64-bit mode"); 270497f1eb2b89721e81b65237df90d23cb60de16b0Eric Christopher assert(IndexReg.getReg() == 0 && "Invalid rip-relative address"); 2711e35d0e9234836c4cea5ec9d1ec11dcc017911beChris Lattner EmitByte(ModRMByte(0, RegOpcodeField, 5), CurByte, OS); 27296716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 2730f53cf22361d89690dcf58409decb43d2a3ad60fChris Lattner unsigned FixupKind = X86::reloc_riprel_4byte; 27496716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 2750f53cf22361d89690dcf58409decb43d2a3ad60fChris Lattner // movq loads are handled with a special relocation form which allows the 2760f53cf22361d89690dcf58409decb43d2a3ad60fChris Lattner // linker to eliminate some loads for GOT references which end up in the 2770f53cf22361d89690dcf58409decb43d2a3ad60fChris Lattner // same linkage unit. 278d0eeeeb5580622d8700fd1009bbf2465789303a8Jakob Stoklund Olesen if (MI.getOpcode() == X86::MOV64rm) 2790f53cf22361d89690dcf58409decb43d2a3ad60fChris Lattner FixupKind = X86::reloc_riprel_4byte_movq_load; 28096716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 281835acabce13993e210b7cef0020a585125f9cb1eChris Lattner // rip-relative addressing is actually relative to the *next* instruction. 282835acabce13993e210b7cef0020a585125f9cb1eChris Lattner // Since an immediate can follow the mod/rm byte for an instruction, this 283835acabce13993e210b7cef0020a585125f9cb1eChris Lattner // means that we need to bias the immediate field of the instruction with 284835acabce13993e210b7cef0020a585125f9cb1eChris Lattner // the size of the immediate field. If we have this case, add it into the 285835acabce13993e210b7cef0020a585125f9cb1eChris Lattner // expression to emit. 286835acabce13993e210b7cef0020a585125f9cb1eChris Lattner int ImmSize = X86II::hasImm(TSFlags) ? X86II::getSizeOfImm(TSFlags) : 0; 28796716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 2880f53cf22361d89690dcf58409decb43d2a3ad60fChris Lattner EmitImmediate(Disp, 4, MCFixupKind(FixupKind), 289835acabce13993e210b7cef0020a585125f9cb1eChris Lattner CurByte, OS, Fixups, -ImmSize); 2901e35d0e9234836c4cea5ec9d1ec11dcc017911beChris Lattner return; 2911e35d0e9234836c4cea5ec9d1ec11dcc017911beChris Lattner } 29296716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 2931e35d0e9234836c4cea5ec9d1ec11dcc017911beChris Lattner unsigned BaseRegNo = BaseReg ? GetX86RegNum(Base) : -1U; 29496716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 295a8168ec732781813172f203f73956561a09f4a67Chris Lattner // Determine whether a SIB byte is needed. 29696716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes // If no BaseReg, issue a RIP relative instruction only if the MCE can 2971ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner // resolve addresses on-the-fly, otherwise use SIB (Intel Manual 2A, table 2981ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner // 2-7) and absolute references. 2995526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner 300a8168ec732781813172f203f73956561a09f4a67Chris Lattner if (// The SIB byte must be used if there is an index register. 30196716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes IndexReg.getReg() == 0 && 3025526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner // The SIB byte must be used if the base is ESP/RSP/R12, all of which 3035526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner // encode to an R/M value of 4, which indicates that a SIB byte is 3045526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner // present. 3055526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner BaseRegNo != N86::ESP && 306a8168ec732781813172f203f73956561a09f4a67Chris Lattner // If there is no base register and we're in 64-bit mode, we need a SIB 307a8168ec732781813172f203f73956561a09f4a67Chris Lattner // byte to emit an addr that is just 'disp32' (the non-RIP relative form). 30859ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng (!is64BitMode() || BaseReg != 0)) { 309a8168ec732781813172f203f73956561a09f4a67Chris Lattner 3101e35d0e9234836c4cea5ec9d1ec11dcc017911beChris Lattner if (BaseReg == 0) { // [disp32] in X86-32 mode 31137ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(0, RegOpcodeField, 5), CurByte, OS); 312cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner EmitImmediate(Disp, 4, FK_Data_4, CurByte, OS, Fixups); 313a8168ec732781813172f203f73956561a09f4a67Chris Lattner return; 314a8168ec732781813172f203f73956561a09f4a67Chris Lattner } 31596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 316a8168ec732781813172f203f73956561a09f4a67Chris Lattner // If the base is not EBP/ESP and there is no displacement, use simple 317a8168ec732781813172f203f73956561a09f4a67Chris Lattner // indirect register encoding, this handles addresses like [EAX]. The 318a8168ec732781813172f203f73956561a09f4a67Chris Lattner // encoding for [EBP] with no displacement means [disp32] so we handle it 319a8168ec732781813172f203f73956561a09f4a67Chris Lattner // by emitting a displacement of 0 below. 3208496a26113859288730d0d97637d032de53b2a7eChris Lattner if (Disp.isImm() && Disp.getImm() == 0 && BaseRegNo != N86::EBP) { 32137ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(0, RegOpcodeField, BaseRegNo), CurByte, OS); 322a8168ec732781813172f203f73956561a09f4a67Chris Lattner return; 3231ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner } 32496716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 325a8168ec732781813172f203f73956561a09f4a67Chris Lattner // Otherwise, if the displacement fits in a byte, encode as [REG+disp8]. 3268496a26113859288730d0d97637d032de53b2a7eChris Lattner if (Disp.isImm() && isDisp8(Disp.getImm())) { 32737ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(1, RegOpcodeField, BaseRegNo), CurByte, OS); 328cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner EmitImmediate(Disp, 1, FK_Data_1, CurByte, OS, Fixups); 329a8168ec732781813172f203f73956561a09f4a67Chris Lattner return; 330a8168ec732781813172f203f73956561a09f4a67Chris Lattner } 33196716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 332a8168ec732781813172f203f73956561a09f4a67Chris Lattner // Otherwise, emit the most general non-SIB encoding: [REG+disp32] 33337ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(2, RegOpcodeField, BaseRegNo), CurByte, OS); 334a8c02c3bdd68e65d14fb6b0d56989663754059b0Rafael Espindola EmitImmediate(Disp, 4, MCFixupKind(X86::reloc_signed_4byte), CurByte, OS, 335a8c02c3bdd68e65d14fb6b0d56989663754059b0Rafael Espindola Fixups); 3360e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner return; 3370e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner } 33896716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 3390e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // We need a SIB byte, so start by outputting the ModR/M byte first 3400e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner assert(IndexReg.getReg() != X86::ESP && 3410e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner IndexReg.getReg() != X86::RSP && "Cannot use ESP as index reg!"); 34296716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 3430e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner bool ForceDisp32 = false; 3440e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner bool ForceDisp8 = false; 3450e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner if (BaseReg == 0) { 3460e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // If there is no base register, we emit the special case SIB byte with 3470e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // MOD=0, BASE=5, to JUST get the index, scale, and displacement. 34837ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(0, RegOpcodeField, 4), CurByte, OS); 3490e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner ForceDisp32 = true; 3508496a26113859288730d0d97637d032de53b2a7eChris Lattner } else if (!Disp.isImm()) { 3510e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // Emit the normal disp32 encoding. 35237ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(2, RegOpcodeField, 4), CurByte, OS); 3530e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner ForceDisp32 = true; 354618d0ed4bc0b68d87f86eace0cd6b9c05329dfc7Chris Lattner } else if (Disp.getImm() == 0 && 355618d0ed4bc0b68d87f86eace0cd6b9c05329dfc7Chris Lattner // Base reg can't be anything that ends up with '5' as the base 356618d0ed4bc0b68d87f86eace0cd6b9c05329dfc7Chris Lattner // reg, it is the magic [*] nomenclature that indicates no base. 357618d0ed4bc0b68d87f86eace0cd6b9c05329dfc7Chris Lattner BaseRegNo != N86::EBP) { 3580e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // Emit no displacement ModR/M byte 35937ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(0, RegOpcodeField, 4), CurByte, OS); 3608496a26113859288730d0d97637d032de53b2a7eChris Lattner } else if (isDisp8(Disp.getImm())) { 3610e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // Emit the disp8 encoding. 36237ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(1, RegOpcodeField, 4), CurByte, OS); 3630e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner ForceDisp8 = true; // Make sure to force 8 bit disp if Base=EBP 3640e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner } else { 3650e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // Emit the normal disp32 encoding. 36637ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(ModRMByte(2, RegOpcodeField, 4), CurByte, OS); 3671ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner } 36896716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 3690e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // Calculate what the SS field value should be... 370a44defeb2208376ca3113ffdddc391570ba865b8Jeffrey Yasskin static const unsigned SSTable[] = { ~0U, 0, 1, ~0U, 2, ~0U, ~0U, ~0U, 3 }; 3710e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner unsigned SS = SSTable[Scale.getImm()]; 37296716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 3730e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner if (BaseReg == 0) { 37496716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes // Handle the SIB byte for the case where there is no base, see Intel 3750e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // Manual 2A, table 2-7. The displacement has already been output. 3760e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner unsigned IndexRegNo; 3770e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner if (IndexReg.getReg()) 3780e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner IndexRegNo = GetX86RegNum(IndexReg); 3790e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner else // Examples: [ESP+1*<noreg>+4] or [scaled idx]+disp32 (MOD=0,BASE=5) 3800e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner IndexRegNo = 4; 38137ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitSIBByte(SS, IndexRegNo, 5, CurByte, OS); 3820e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner } else { 3830e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner unsigned IndexRegNo; 3840e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner if (IndexReg.getReg()) 3850e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner IndexRegNo = GetX86RegNum(IndexReg); 3860e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner else 3870e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner IndexRegNo = 4; // For example [ESP+1*<noreg>+4] 38837ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitSIBByte(SS, IndexRegNo, GetX86RegNum(Base), CurByte, OS); 3890e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner } 39096716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 3910e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner // Do we need to output a displacement? 3920e73c39c70a00bf729cd58bd36e1c55afe565c6dChris Lattner if (ForceDisp8) 393cf65339b52e09be5d329e45d3847a8e3a2ee08bdChris Lattner EmitImmediate(Disp, 1, FK_Data_1, CurByte, OS, Fixups); 3948496a26113859288730d0d97637d032de53b2a7eChris Lattner else if (ForceDisp32 || Disp.getImm() != 0) 395a8c02c3bdd68e65d14fb6b0d56989663754059b0Rafael Espindola EmitImmediate(Disp, 4, MCFixupKind(X86::reloc_signed_4byte), CurByte, OS, 396a8c02c3bdd68e65d14fb6b0d56989663754059b0Rafael Espindola Fixups); 3971ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner} 3981ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner 39999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes/// EmitVEXOpcodePrefix - AVX instructions are encoded using a opcode prefix 40099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes/// called VEX. 40199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopesvoid X86MCCodeEmitter::EmitVEXOpcodePrefix(uint64_t TSFlags, unsigned &CurByte, 4021cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes int MemOperand, const MCInst &MI, 403e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &Desc, 4041cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes raw_ostream &OS) const { 405b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper bool HasVEX_4V = (TSFlags >> X86II::VEXShift) & X86II::VEX_4V; 406b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper bool HasVEX_4VOp3 = (TSFlags >> X86II::VEXShift) & X86II::VEX_4VOp3; 407788184365a4a949eb83b0036045e6793bc6c20f0Bruno Cardoso Lopes 40899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX_R: opcode externsion equivalent to REX.R in 40999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 1's complement (inverted) form 41099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 41199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 1: Same as REX_R=0 (must be 1 in 32-bit mode) 41299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0: Same as REX_R=1 (64 bit mode only) 41399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 41499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned char VEX_R = 0x1; 41599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 416c902a59f4c786a2a047f0b4c964a93108f248915Bruno Cardoso Lopes // VEX_X: equivalent to REX.X, only used when a 417c902a59f4c786a2a047f0b4c964a93108f248915Bruno Cardoso Lopes // register is used for index in SIB Byte. 418c902a59f4c786a2a047f0b4c964a93108f248915Bruno Cardoso Lopes // 419c902a59f4c786a2a047f0b4c964a93108f248915Bruno Cardoso Lopes // 1: Same as REX.X=0 (must be 1 in 32-bit mode) 420c902a59f4c786a2a047f0b4c964a93108f248915Bruno Cardoso Lopes // 0: Same as REX.X=1 (64-bit mode only) 421c902a59f4c786a2a047f0b4c964a93108f248915Bruno Cardoso Lopes unsigned char VEX_X = 0x1; 422c902a59f4c786a2a047f0b4c964a93108f248915Bruno Cardoso Lopes 42399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX_B: 42499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 42599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 1: Same as REX_B=0 (ignored in 32-bit mode) 42699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0: Same as REX_B=1 (64 bit mode only) 42799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 42899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned char VEX_B = 0x1; 42999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 43099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX_W: opcode specific (use like REX.W, or used for 43199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // opcode extension, or ignored, depending on the opcode byte) 43299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned char VEX_W = 0; 43399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 4341b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes // XOP_W: opcode specific, same bit as VEX_W, but used to 4351b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes // swap operand 3 and 4 for FMA4 and XOP instructions 4361b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes unsigned char XOP_W = 0; 4371b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes 438ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin // XOP: Use XOP prefix byte 0x8f instead of VEX. 439ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin unsigned char XOP = 0; 440ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin 44199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX_5M (VEX m-mmmmm field): 44299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 44399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b00000: Reserved for future use 44499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b00001: implied 0F leading opcode 44599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b00010: implied 0F 38 leading opcode bytes 44699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b00011: implied 0F 3A leading opcode bytes 44799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b00100-0b11111: Reserved for future use 448ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin // 0b01000: XOP map select - 08h instructions with imm byte 449ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin // 0b10001: XOP map select - 09h instructions with no imm byte 45099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned char VEX_5M = 0x1; 45199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 45299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX_4V (VEX vvvv field): a register specifier 45399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // (in 1's complement form) or 1111 if unused. 45499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned char VEX_4V = 0xf; 45599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 45699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX_L (Vector Length): 45799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 45899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0: scalar or 128-bit vector 45999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 1: 256-bit vector 46099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 46199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned char VEX_L = 0; 46299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 46399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX_PP: opcode extension providing equivalent 46499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // functionality of a SIMD prefix 46599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 46699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b00: None 4677be0d2c8e944d0f51db8abb0fb4c8fb7c1bfe8f8Bruno Cardoso Lopes // 0b01: 66 46899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b10: F3 46999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 0b11: F2 47099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 47199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned char VEX_PP = 0; 47299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 4737be0d2c8e944d0f51db8abb0fb4c8fb7c1bfe8f8Bruno Cardoso Lopes // Encode the operand size opcode prefix as needed. 4747be0d2c8e944d0f51db8abb0fb4c8fb7c1bfe8f8Bruno Cardoso Lopes if (TSFlags & X86II::OpSize) 4757be0d2c8e944d0f51db8abb0fb4c8fb7c1bfe8f8Bruno Cardoso Lopes VEX_PP = 0x01; 4767be0d2c8e944d0f51db8abb0fb4c8fb7c1bfe8f8Bruno Cardoso Lopes 477229e4523f2f12929defa09ac4ef9f3652f21f1ecJoerg Sonnenberger if ((TSFlags >> X86II::VEXShift) & X86II::VEX_W) 4786596a6207627ed59f568883924a21e642934c083Bruno Cardoso Lopes VEX_W = 1; 4796596a6207627ed59f568883924a21e642934c083Bruno Cardoso Lopes 4801b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes if ((TSFlags >> X86II::VEXShift) & X86II::XOP_W) 4811b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes XOP_W = 1; 4821b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes 483ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin if ((TSFlags >> X86II::VEXShift) & X86II::XOP) 484ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin XOP = 1; 485ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin 486229e4523f2f12929defa09ac4ef9f3652f21f1ecJoerg Sonnenberger if ((TSFlags >> X86II::VEXShift) & X86II::VEX_L) 48787a85c7ef0d1a96c73473de90d3b2b28d24538a5Bruno Cardoso Lopes VEX_L = 1; 48887a85c7ef0d1a96c73473de90d3b2b28d24538a5Bruno Cardoso Lopes 48999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes switch (TSFlags & X86II::Op0Mask) { 49099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes default: assert(0 && "Invalid prefix!"); 49199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes case X86II::T8: // 0F 38 49299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes VEX_5M = 0x2; 49399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes break; 49499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes case X86II::TA: // 0F 3A 49599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes VEX_5M = 0x3; 49699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes break; 497ee62e4f6d192ee31d1ad9dd0ba0c41db6663d3c7Craig Topper case X86II::T8XS: // F3 0F 38 498ee62e4f6d192ee31d1ad9dd0ba0c41db6663d3c7Craig Topper VEX_PP = 0x2; 499ee62e4f6d192ee31d1ad9dd0ba0c41db6663d3c7Craig Topper VEX_5M = 0x2; 500ee62e4f6d192ee31d1ad9dd0ba0c41db6663d3c7Craig Topper break; 501ee62e4f6d192ee31d1ad9dd0ba0c41db6663d3c7Craig Topper case X86II::T8XD: // F2 0F 38 50299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes VEX_PP = 0x3; 50399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes VEX_5M = 0x2; 50499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes break; 50575485d6746f8b5b23c17cf6d2364e7e1e0705992Craig Topper case X86II::TAXD: // F2 0F 3A 50675485d6746f8b5b23c17cf6d2364e7e1e0705992Craig Topper VEX_PP = 0x3; 50775485d6746f8b5b23c17cf6d2364e7e1e0705992Craig Topper VEX_5M = 0x3; 50875485d6746f8b5b23c17cf6d2364e7e1e0705992Craig Topper break; 50999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes case X86II::XS: // F3 0F 51099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes VEX_PP = 0x2; 51199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes break; 51299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes case X86II::XD: // F2 0F 51399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes VEX_PP = 0x3; 51499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes break; 515ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin case X86II::XOP8: 516ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin VEX_5M = 0x8; 517ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin break; 518ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin case X86II::XOP9: 519ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin VEX_5M = 0x9; 520ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin break; 5214a8ac8de1ddfeaadb9ff13ce361bfc6435f18028Joerg Sonnenberger case X86II::A6: // Bypass: Not used by VEX 5224a8ac8de1ddfeaadb9ff13ce361bfc6435f18028Joerg Sonnenberger case X86II::A7: // Bypass: Not used by VEX 523161476ec343161c6c6ab16df775d853fcecd77c3Bruno Cardoso Lopes case X86II::TB: // Bypass: Not used by VEX 524161476ec343161c6c6ab16df775d853fcecd77c3Bruno Cardoso Lopes case 0: 525161476ec343161c6c6ab16df775d853fcecd77c3Bruno Cardoso Lopes break; // No prefix! 52699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes } 52799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 528ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin 529e86b01c153ba52307ecb6e7513ec33f57caedfddBruno Cardoso Lopes // Set the vector length to 256-bit if YMM0-YMM15 is used 530e86b01c153ba52307ecb6e7513ec33f57caedfddBruno Cardoso Lopes for (unsigned i = 0; i != MI.getNumOperands(); ++i) { 531e86b01c153ba52307ecb6e7513ec33f57caedfddBruno Cardoso Lopes if (!MI.getOperand(i).isReg()) 532e86b01c153ba52307ecb6e7513ec33f57caedfddBruno Cardoso Lopes continue; 533e86b01c153ba52307ecb6e7513ec33f57caedfddBruno Cardoso Lopes unsigned SrcReg = MI.getOperand(i).getReg(); 534e86b01c153ba52307ecb6e7513ec33f57caedfddBruno Cardoso Lopes if (SrcReg >= X86::YMM0 && SrcReg <= X86::YMM15) 535e86b01c153ba52307ecb6e7513ec33f57caedfddBruno Cardoso Lopes VEX_L = 1; 536e86b01c153ba52307ecb6e7513ec33f57caedfddBruno Cardoso Lopes } 537e86b01c153ba52307ecb6e7513ec33f57caedfddBruno Cardoso Lopes 5380c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // Classify VEX_B, VEX_4V, VEX_R, VEX_X 539161476ec343161c6c6ab16df775d853fcecd77c3Bruno Cardoso Lopes unsigned CurOp = 0; 54099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes switch (TSFlags & X86II::FormMask) { 54199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes case X86II::MRMInitReg: assert(0 && "FIXME: Remove this!"); 5420c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes case X86II::MRMDestMem: { 5430c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MRMDestMem instructions forms: 5440c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MemAddr, src1(ModR/M) 5450c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MemAddr, src1(VEX_4V), src2(ModR/M) 5460c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MemAddr, src1(ModR/M), imm8 5470c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // 5480c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (X86II::isX86_64ExtendedReg(MI.getOperand(X86::AddrBaseReg).getReg())) 5490c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_B = 0x0; 5500c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (X86II::isX86_64ExtendedReg(MI.getOperand(X86::AddrIndexReg).getReg())) 5510c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_X = 0x0; 5520c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes 5530c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes CurOp = X86::AddrNumOperands; 5540c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (HasVEX_4V) 5550c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_4V = getVEXRegisterEncoding(MI, CurOp++); 5560c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes 5570c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes const MCOperand &MO = MI.getOperand(CurOp); 5580c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (MO.isReg() && X86II::isX86_64ExtendedReg(MO.getReg())) 5590c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_R = 0x0; 5600c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes break; 5610c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes } 562566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper case X86II::MRMSrcMem: 5630c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MRMSrcMem instructions forms: 5640c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // src1(ModR/M), MemAddr 5650c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // src1(ModR/M), src2(VEX_4V), MemAddr 5660c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // src1(ModR/M), MemAddr, imm8 5670c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // src1(ModR/M), MemAddr, src2(VEX_I8IMM) 5680c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // 5691b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes // FMA4: 5701b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes // dst(ModR/M.reg), src1(VEX_4V), src2(ModR/M), src3(VEX_I8IMM) 5711b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes // dst(ModR/M.reg), src1(VEX_4V), src2(VEX_I8IMM), src3(ModR/M), 5720c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (X86II::isX86_64ExtendedReg(MI.getOperand(0).getReg())) 5730c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_R = 0x0; 5740c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes 575b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper if (HasVEX_4V) 5760c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_4V = getVEXRegisterEncoding(MI, 1); 5770c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes 5780c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (X86II::isX86_64ExtendedReg( 579566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper MI.getOperand(MemOperand+X86::AddrBaseReg).getReg())) 5800c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_B = 0x0; 5810c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (X86II::isX86_64ExtendedReg( 582566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper MI.getOperand(MemOperand+X86::AddrIndexReg).getReg())) 5830c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_X = 0x0; 58417730847d59c919d97f097d46a3fcba1888e5300Craig Topper 585b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper if (HasVEX_4VOp3) 58617730847d59c919d97f097d46a3fcba1888e5300Craig Topper VEX_4V = getVEXRegisterEncoding(MI, X86::AddrNumOperands+1); 5870c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes break; 588147b7cad2fefa3260e2da8f7cfe31ac07f352cebBruno Cardoso Lopes case X86II::MRM0m: case X86II::MRM1m: 589147b7cad2fefa3260e2da8f7cfe31ac07f352cebBruno Cardoso Lopes case X86II::MRM2m: case X86II::MRM3m: 590147b7cad2fefa3260e2da8f7cfe31ac07f352cebBruno Cardoso Lopes case X86II::MRM4m: case X86II::MRM5m: 591566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper case X86II::MRM6m: case X86II::MRM7m: { 5920c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MRM[0-9]m instructions forms: 5930c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MemAddr 594566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper // src1(VEX_4V), MemAddr 595566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper if (HasVEX_4V) 596566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper VEX_4V = getVEXRegisterEncoding(MI, 0); 597566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper 598566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper if (X86II::isX86_64ExtendedReg( 599566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper MI.getOperand(MemOperand+X86::AddrBaseReg).getReg())) 6000c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_B = 0x0; 601566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper if (X86II::isX86_64ExtendedReg( 602566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper MI.getOperand(MemOperand+X86::AddrIndexReg).getReg())) 6030c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_X = 0x0; 6040c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes break; 605566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper } 60699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes case X86II::MRMSrcReg: 6070c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MRMSrcReg instructions forms: 6080c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // dst(ModR/M), src1(VEX_4V), src2(ModR/M), src3(VEX_I8IMM) 6090c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // dst(ModR/M), src1(ModR/M) 6100c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // dst(ModR/M), src1(ModR/M), imm8 6110c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // 6120c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (X86II::isX86_64ExtendedReg(MI.getOperand(CurOp).getReg())) 61399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes VEX_R = 0x0; 6144b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes CurOp++; 61599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 616b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper if (HasVEX_4V) 6170c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_4V = getVEXRegisterEncoding(MI, CurOp++); 6180c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (X86II::isX86_64ExtendedReg(MI.getOperand(CurOp).getReg())) 6190c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_B = 0x0; 62017730847d59c919d97f097d46a3fcba1888e5300Craig Topper CurOp++; 621b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper if (HasVEX_4VOp3) 62217730847d59c919d97f097d46a3fcba1888e5300Craig Topper VEX_4V = getVEXRegisterEncoding(MI, CurOp); 6230c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes break; 6240c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes case X86II::MRMDestReg: 6250c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MRMDestReg instructions forms: 6260c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // dst(ModR/M), src(ModR/M) 6270c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // dst(ModR/M), src(ModR/M), imm8 6280c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (X86II::isX86_64ExtendedReg(MI.getOperand(0).getReg())) 6290c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_B = 0x0; 6300c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (X86II::isX86_64ExtendedReg(MI.getOperand(1).getReg())) 6310c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_R = 0x0; 6320c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes break; 6330c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes case X86II::MRM0r: case X86II::MRM1r: 6340c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes case X86II::MRM2r: case X86II::MRM3r: 6350c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes case X86II::MRM4r: case X86II::MRM5r: 6360c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes case X86II::MRM6r: case X86II::MRM7r: 6370c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // MRM0r-MRM7r instructions forms: 6380c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes // dst(VEX_4V), src(ModR/M), imm8 6390c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_4V = getVEXRegisterEncoding(MI, 0); 6400c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes if (X86II::isX86_64ExtendedReg(MI.getOperand(1).getReg())) 6410c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes VEX_B = 0x0; 6420c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes break; 6430c9acfcb50a844eefe92556e59c81fc302f32d1cBruno Cardoso Lopes default: // RawFrm 6445a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes break; 64599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes } 64699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 6471cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes // Emit segment override opcode prefix as needed. 6481cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes EmitSegmentOverridePrefix(TSFlags, CurByte, MemOperand, MI, OS); 6491cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes 65099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // VEX opcode prefix can have 2 or 3 bytes 65199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 65299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 3 bytes: 65399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // +-----+ +--------------+ +-------------------+ 65499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // | C4h | | RXB | m-mmmm | | W | vvvv | L | pp | 65599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // +-----+ +--------------+ +-------------------+ 65699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 2 bytes: 65799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // +-----+ +-------------------+ 65899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // | C5h | | R | vvvv | L | pp | 65999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // +-----+ +-------------------+ 66099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 66199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned char LastByte = VEX_PP | (VEX_L << 2) | (VEX_4V << 3); 66299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 663ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin if (VEX_B && VEX_X && !VEX_W && !XOP && (VEX_5M == 1)) { // 2 byte VEX prefix 66499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes EmitByte(0xC5, CurByte, OS); 66599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes EmitByte(LastByte | (VEX_R << 7), CurByte, OS); 66699405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes return; 66799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes } 66899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 66999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // 3 byte VEX prefix 670ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin EmitByte(XOP ? 0x8F : 0xC4, CurByte, OS); 6716596a6207627ed59f568883924a21e642934c083Bruno Cardoso Lopes EmitByte(VEX_R << 7 | VEX_X << 6 | VEX_B << 5 | VEX_5M, CurByte, OS); 6721b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes EmitByte(LastByte | ((VEX_W | XOP_W) << 7), CurByte, OS); 67399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes} 67499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 67539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner/// DetermineREXPrefix - Determine if the MCInst has to be encoded with a X86-64 67639a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner/// REX prefix which specifies 1) 64-bit instructions, 2) non-default operand 67739a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner/// size, and 3) use of X86-64 extended registers. 67899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopesstatic unsigned DetermineREXPrefix(const MCInst &MI, uint64_t TSFlags, 679e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &Desc) { 6807e85180d15c4d5a451fbc078f7194a41c6230a57Chris Lattner unsigned REX = 0; 68139a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (TSFlags & X86II::REX_W) 682e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << 3; // set REX.W 68396716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 68439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (MI.getNumOperands() == 0) return REX; 68596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 68639a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner unsigned NumOps = MI.getNumOperands(); 68739a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner // FIXME: MCInst should explicitize the two-addrness. 68839a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner bool isTwoAddr = NumOps > 1 && 689e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng Desc.getOperandConstraint(1, MCOI::TIED_TO) != -1; 69096716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 69139a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner // If it accesses SPL, BPL, SIL, or DIL, then it requires a 0x40 REX prefix. 69239a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner unsigned i = isTwoAddr ? 1 : 0; 69339a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner for (; i != NumOps; ++i) { 69439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner const MCOperand &MO = MI.getOperand(i); 69539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (!MO.isReg()) continue; 69639a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner unsigned Reg = MO.getReg(); 6978c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng if (!X86II::isX86_64NonExtLowByteReg(Reg)) continue; 698faa75f6f6f2b37359a458fd9acd57c58ee26eea9Chris Lattner // FIXME: The caller of DetermineREXPrefix slaps this prefix onto anything 699faa75f6f6f2b37359a458fd9acd57c58ee26eea9Chris Lattner // that returns non-zero. 700e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 0x40; // REX fixed encoding prefix 70139a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner break; 70239a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 70396716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 70439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner switch (TSFlags & X86II::FormMask) { 70539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRMInitReg: assert(0 && "FIXME: Remove this!"); 70639a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRMSrcReg: 70739a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (MI.getOperand(0).isReg() && 7088c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng X86II::isX86_64ExtendedReg(MI.getOperand(0).getReg())) 709e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << 2; // set REX.R 71039a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner i = isTwoAddr ? 2 : 1; 71139a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner for (; i != NumOps; ++i) { 71239a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner const MCOperand &MO = MI.getOperand(i); 7138c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng if (MO.isReg() && X86II::isX86_64ExtendedReg(MO.getReg())) 714e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << 0; // set REX.B 71539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 71639a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner break; 71739a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRMSrcMem: { 71839a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (MI.getOperand(0).isReg() && 7198c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng X86II::isX86_64ExtendedReg(MI.getOperand(0).getReg())) 720e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << 2; // set REX.R 72139a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner unsigned Bit = 0; 72239a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner i = isTwoAddr ? 2 : 1; 72339a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner for (; i != NumOps; ++i) { 72439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner const MCOperand &MO = MI.getOperand(i); 72539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (MO.isReg()) { 7268c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng if (X86II::isX86_64ExtendedReg(MO.getReg())) 727e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << Bit; // set REX.B (Bit=0) and REX.X (Bit=1) 72839a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner Bit++; 72939a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 73039a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 73139a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner break; 73239a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 73339a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRM0m: case X86II::MRM1m: 73439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRM2m: case X86II::MRM3m: 73539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRM4m: case X86II::MRM5m: 73639a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRM6m: case X86II::MRM7m: 73739a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner case X86II::MRMDestMem: { 738ac0ed5dc082dff9ce359af5422f5b82047b4fe6bChris Lattner unsigned e = (isTwoAddr ? X86::AddrNumOperands+1 : X86::AddrNumOperands); 73939a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner i = isTwoAddr ? 1 : 0; 74039a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (NumOps > e && MI.getOperand(e).isReg() && 7418c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng X86II::isX86_64ExtendedReg(MI.getOperand(e).getReg())) 742e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << 2; // set REX.R 74339a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner unsigned Bit = 0; 74439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner for (; i != e; ++i) { 74539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner const MCOperand &MO = MI.getOperand(i); 74639a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (MO.isReg()) { 7478c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng if (X86II::isX86_64ExtendedReg(MO.getReg())) 748e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << Bit; // REX.B (Bit=0) and REX.X (Bit=1) 74939a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner Bit++; 75039a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 75139a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 75239a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner break; 75339a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 75439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner default: 75539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (MI.getOperand(0).isReg() && 7568c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng X86II::isX86_64ExtendedReg(MI.getOperand(0).getReg())) 757e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << 0; // set REX.B 75839a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner i = isTwoAddr ? 2 : 1; 75939a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner for (unsigned e = NumOps; i != e; ++i) { 76039a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner const MCOperand &MO = MI.getOperand(i); 7618c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng if (MO.isReg() && X86II::isX86_64ExtendedReg(MO.getReg())) 762e4f6907a7a38f73a18e5f193fbe5f5d86867b3b4Bruno Cardoso Lopes REX |= 1 << 2; // set REX.R 76339a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 76439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner break; 76539a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner } 76639a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner return REX; 76739a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner} 76892b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner 7691cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes/// EmitSegmentOverridePrefix - Emit segment override opcode prefix as needed 7701cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopesvoid X86MCCodeEmitter::EmitSegmentOverridePrefix(uint64_t TSFlags, 7711cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes unsigned &CurByte, int MemOperand, 7721cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes const MCInst &MI, 7739d19989fe36e4b1b0b6449f8e54e180220b8a90aChris Lattner raw_ostream &OS) const { 7741e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner switch (TSFlags & X86II::SegOvrMask) { 77592b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner default: assert(0 && "Invalid segment!"); 776834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner case 0: 777834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner // No segment override, check for explicit one on memory operand. 778599b531a960833719f607d66c97871f1f5ad12c0Chris Lattner if (MemOperand != -1) { // If the instruction has a memory operand. 779ac0ed5dc082dff9ce359af5422f5b82047b4fe6bChris Lattner switch (MI.getOperand(MemOperand+X86::AddrSegmentReg).getReg()) { 780834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner default: assert(0 && "Unknown segment register!"); 781834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner case 0: break; 782834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner case X86::CS: EmitByte(0x2E, CurByte, OS); break; 783834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner case X86::SS: EmitByte(0x36, CurByte, OS); break; 784834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner case X86::DS: EmitByte(0x3E, CurByte, OS); break; 785834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner case X86::ES: EmitByte(0x26, CurByte, OS); break; 786834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner case X86::FS: EmitByte(0x64, CurByte, OS); break; 787834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner case X86::GS: EmitByte(0x65, CurByte, OS); break; 788834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner } 789834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner } 790834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner break; 79192b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner case X86II::FS: 79237ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0x64, CurByte, OS); 79392b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner break; 79492b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner case X86II::GS: 79537ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0x65, CurByte, OS); 79692b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner break; 79792b1dfe5d8ce32b4389fccf94aa620682b2f5726Chris Lattner } 7981cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes} 7991cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes 8001cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes/// EmitOpcodePrefix - Emit all instruction prefixes prior to the opcode. 8011cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes/// 8021cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes/// MemOperand is the operand # of the start of a memory operand if present. If 8031cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes/// Not present, it is -1. 8041cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopesvoid X86MCCodeEmitter::EmitOpcodePrefix(uint64_t TSFlags, unsigned &CurByte, 8051cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes int MemOperand, const MCInst &MI, 806e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &Desc, 8071cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes raw_ostream &OS) const { 8081cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes 8091cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes // Emit the lock opcode prefix as needed. 8101cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes if (TSFlags & X86II::LOCK) 8111cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes EmitByte(0xF0, CurByte, OS); 8121cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes 8131cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes // Emit segment override opcode prefix as needed. 8141cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes EmitSegmentOverridePrefix(TSFlags, CurByte, MemOperand, MI, OS); 81596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 8161e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner // Emit the repeat opcode prefix as needed. 8171e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner if ((TSFlags & X86II::Op0Mask) == X86II::REP) 81837ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0xF3, CurByte, OS); 81996716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 8201e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner // Emit the address size opcode prefix as needed. 8218a5072903e2037da1cfdaffa5a26be00f3d76a22Chris Lattner if ((TSFlags & X86II::AdSize) || 82259ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng (MemOperand != -1 && is64BitMode() && Is32BitMemOperand(MI, MemOperand))) 82337ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0x67, CurByte, OS); 8244e423359721fa88cb50ccea51ccf1c520d765ad0Bruno Cardoso Lopes 82578a194693bb9bbfa1080454cded0166265b803e5Chris Lattner // Emit the operand size opcode prefix as needed. 82678a194693bb9bbfa1080454cded0166265b803e5Chris Lattner if (TSFlags & X86II::OpSize) 82778a194693bb9bbfa1080454cded0166265b803e5Chris Lattner EmitByte(0x66, CurByte, OS); 82896716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 8291e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner bool Need0FPrefix = false; 8301e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner switch (TSFlags & X86II::Op0Mask) { 8311e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner default: assert(0 && "Invalid prefix!"); 8321e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner case 0: break; // No prefix! 8331e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner case X86II::REP: break; // already handled. 8341e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner case X86II::TB: // Two-byte opcode prefix 8351e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner case X86II::T8: // 0F 38 8361e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner case X86II::TA: // 0F 3A 8374a8ac8de1ddfeaadb9ff13ce361bfc6435f18028Joerg Sonnenberger case X86II::A6: // 0F A6 8384a8ac8de1ddfeaadb9ff13ce361bfc6435f18028Joerg Sonnenberger case X86II::A7: // 0F A7 8391e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner Need0FPrefix = true; 8401e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner break; 841ee62e4f6d192ee31d1ad9dd0ba0c41db6663d3c7Craig Topper case X86II::T8XS: // F3 0F 38 842ee62e4f6d192ee31d1ad9dd0ba0c41db6663d3c7Craig Topper EmitByte(0xF3, CurByte, OS); 843ee62e4f6d192ee31d1ad9dd0ba0c41db6663d3c7Craig Topper Need0FPrefix = true; 844ee62e4f6d192ee31d1ad9dd0ba0c41db6663d3c7Craig Topper break; 845ee62e4f6d192ee31d1ad9dd0ba0c41db6663d3c7Craig Topper case X86II::T8XD: // F2 0F 38 84637ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0xF2, CurByte, OS); 8471e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner Need0FPrefix = true; 8481e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner break; 84975485d6746f8b5b23c17cf6d2364e7e1e0705992Craig Topper case X86II::TAXD: // F2 0F 3A 85075485d6746f8b5b23c17cf6d2364e7e1e0705992Craig Topper EmitByte(0xF2, CurByte, OS); 85175485d6746f8b5b23c17cf6d2364e7e1e0705992Craig Topper Need0FPrefix = true; 85275485d6746f8b5b23c17cf6d2364e7e1e0705992Craig Topper break; 8531e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner case X86II::XS: // F3 0F 85437ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0xF3, CurByte, OS); 8551e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner Need0FPrefix = true; 8561e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner break; 8571e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner case X86II::XD: // F2 0F 85837ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0xF2, CurByte, OS); 8591e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner Need0FPrefix = true; 8601e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner break; 86137ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner case X86II::D8: EmitByte(0xD8, CurByte, OS); break; 86237ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner case X86II::D9: EmitByte(0xD9, CurByte, OS); break; 86337ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner case X86II::DA: EmitByte(0xDA, CurByte, OS); break; 86437ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner case X86II::DB: EmitByte(0xDB, CurByte, OS); break; 86537ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner case X86II::DC: EmitByte(0xDC, CurByte, OS); break; 86637ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner case X86II::DD: EmitByte(0xDD, CurByte, OS); break; 86737ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner case X86II::DE: EmitByte(0xDE, CurByte, OS); break; 86837ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner case X86II::DF: EmitByte(0xDF, CurByte, OS); break; 8691e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner } 87096716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 8711e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner // Handle REX prefix. 87239a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner // FIXME: Can this come before F2 etc to simplify emission? 87359ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng if (is64BitMode()) { 87439a612e6f9e63806af410a0ab0d81895391e4c79Chris Lattner if (unsigned REX = DetermineREXPrefix(MI, TSFlags, Desc)) 87537ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0x40 | REX, CurByte, OS); 8761e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner } 87796716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 8781e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner // 0x0F escape code must be emitted just before the opcode. 8791e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner if (Need0FPrefix) 88037ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0x0F, CurByte, OS); 88196716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 8821e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner // FIXME: Pull this up into previous switch if REX can be moved earlier. 8831e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner switch (TSFlags & X86II::Op0Mask) { 884ee62e4f6d192ee31d1ad9dd0ba0c41db6663d3c7Craig Topper case X86II::T8XS: // F3 0F 38 885ee62e4f6d192ee31d1ad9dd0ba0c41db6663d3c7Craig Topper case X86II::T8XD: // F2 0F 38 8861e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner case X86II::T8: // 0F 38 88737ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0x38, CurByte, OS); 8881e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner break; 88975485d6746f8b5b23c17cf6d2364e7e1e0705992Craig Topper case X86II::TAXD: // F2 0F 3A 8901e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner case X86II::TA: // 0F 3A 89137ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(0x3A, CurByte, OS); 8921e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner break; 8934a8ac8de1ddfeaadb9ff13ce361bfc6435f18028Joerg Sonnenberger case X86II::A6: // 0F A6 8944a8ac8de1ddfeaadb9ff13ce361bfc6435f18028Joerg Sonnenberger EmitByte(0xA6, CurByte, OS); 8954a8ac8de1ddfeaadb9ff13ce361bfc6435f18028Joerg Sonnenberger break; 8964a8ac8de1ddfeaadb9ff13ce361bfc6435f18028Joerg Sonnenberger case X86II::A7: // 0F A7 8974a8ac8de1ddfeaadb9ff13ce361bfc6435f18028Joerg Sonnenberger EmitByte(0xA7, CurByte, OS); 8984a8ac8de1ddfeaadb9ff13ce361bfc6435f18028Joerg Sonnenberger break; 8991e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner } 90099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes} 90199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 90299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopesvoid X86MCCodeEmitter:: 90399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso LopesEncodeInstruction(const MCInst &MI, raw_ostream &OS, 90499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes SmallVectorImpl<MCFixup> &Fixups) const { 90599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned Opcode = MI.getOpcode(); 90659ee62d2418df8db499eca1ae17f5900dc2dcbbaEvan Cheng const MCInstrDesc &Desc = MCII.get(Opcode); 90799405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes uint64_t TSFlags = Desc.TSFlags; 90899405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 909757e8d6d2e18495a247d0ae90293889ab8093babChris Lattner // Pseudo instructions don't get encoded. 910757e8d6d2e18495a247d0ae90293889ab8093babChris Lattner if ((TSFlags & X86II::FormMask) == X86II::Pseudo) 911757e8d6d2e18495a247d0ae90293889ab8093babChris Lattner return; 91296716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 913834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner // If this is a two-address instruction, skip one of the register operands. 914834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner // FIXME: This should be handled during MCInst lowering. 915834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner unsigned NumOps = Desc.getNumOperands(); 916834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner unsigned CurOp = 0; 917e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (NumOps > 1 && Desc.getOperandConstraint(1, MCOI::TIED_TO) != -1) 918834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner ++CurOp; 919e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng else if (NumOps > 2 && Desc.getOperandConstraint(NumOps-1, MCOI::TIED_TO)== 0) 920834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner // Skip the last source operand that is tied_to the dest reg. e.g. LXADD32 921834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner --NumOps; 92296716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 92399405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes // Keep track of the current byte being emitted. 92499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned CurByte = 0; 92596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 926c3d57b179c33ef010ebbff003ce8c5d908cf9c01Bruno Cardoso Lopes // Is this instruction encoded using the AVX VEX prefix? 927b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper bool HasVEXPrefix = (TSFlags >> X86II::VEXShift) & X86II::VEX; 928c3d57b179c33ef010ebbff003ce8c5d908cf9c01Bruno Cardoso Lopes 929c3d57b179c33ef010ebbff003ce8c5d908cf9c01Bruno Cardoso Lopes // It uses the VEX.VVVV field? 930b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper bool HasVEX_4V = (TSFlags >> X86II::VEXShift) & X86II::VEX_4V; 931b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper bool HasVEX_4VOp3 = (TSFlags >> X86II::VEXShift) & X86II::VEX_4VOp3; 9321b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes bool HasXOP_W = (TSFlags >> X86II::VEXShift) & X86II::XOP_W; 9331b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes unsigned XOP_W_I8IMMOperand = 2; 93496716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 935834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner // Determine where the memory operand starts, if present. 93617730847d59c919d97f097d46a3fcba1888e5300Craig Topper int MemoryOperand = X86II::getMemoryOperandNo(TSFlags, Opcode); 937834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner if (MemoryOperand != -1) MemoryOperand += CurOp; 93896716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 939c3d57b179c33ef010ebbff003ce8c5d908cf9c01Bruno Cardoso Lopes if (!HasVEXPrefix) 940834df19452a551195ab012a8923b646b9a57a0d9Chris Lattner EmitOpcodePrefix(TSFlags, CurByte, MemoryOperand, MI, Desc, OS); 94199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes else 9421cd050931fb429e4e2eab0fa4fe5b29e2cf4b9a4Bruno Cardoso Lopes EmitVEXOpcodePrefix(TSFlags, CurByte, MemoryOperand, MI, Desc, OS); 94396716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 94474a2151392a08e202f497ece7a3129663526d431Chris Lattner unsigned char BaseOpcode = X86II::getBaseOpcodeFor(TSFlags); 9454e423359721fa88cb50ccea51ccf1c520d765ad0Bruno Cardoso Lopes 946229e4523f2f12929defa09ac4ef9f3652f21f1ecJoerg Sonnenberger if ((TSFlags >> X86II::VEXShift) & X86II::Has3DNow0F0FOpcode) 947548abfcbd671b1144bf517b17643259dcae76f4fChris Lattner BaseOpcode = 0x0F; // Weird 3DNow! encoding. 9484e423359721fa88cb50ccea51ccf1c520d765ad0Bruno Cardoso Lopes 94999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes unsigned SrcRegNum = 0; 9501e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner switch (TSFlags & X86II::FormMask) { 951be1778fea76e1f63b08f1f838fca88a0c8d9a883Chris Lattner case X86II::MRMInitReg: 952be1778fea76e1f63b08f1f838fca88a0c8d9a883Chris Lattner assert(0 && "FIXME: Remove this form when the JIT moves to MCCodeEmitter!"); 9531ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner default: errs() << "FORM: " << (TSFlags & X86II::FormMask) << "\n"; 9548b0f7a7d8627392c8faae3801cc91689406960cfChris Lattner assert(0 && "Unknown FormMask value in X86MCCodeEmitter!"); 955757e8d6d2e18495a247d0ae90293889ab8093babChris Lattner case X86II::Pseudo: 956757e8d6d2e18495a247d0ae90293889ab8093babChris Lattner assert(0 && "Pseudo instruction shouldn't be emitted"); 9578b0f7a7d8627392c8faae3801cc91689406960cfChris Lattner case X86II::RawFrm: 95837ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(BaseOpcode, CurByte, OS); 95928249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner break; 96040cc3f8783a4e426a0d439bb2b070b5c072b5947Chris Lattner case X86II::RawFrmImm8: 96140cc3f8783a4e426a0d439bb2b070b5c072b5947Chris Lattner EmitByte(BaseOpcode, CurByte, OS); 96240cc3f8783a4e426a0d439bb2b070b5c072b5947Chris Lattner EmitImmediate(MI.getOperand(CurOp++), 96340cc3f8783a4e426a0d439bb2b070b5c072b5947Chris Lattner X86II::getSizeOfImm(TSFlags), getImmFixupKind(TSFlags), 96440cc3f8783a4e426a0d439bb2b070b5c072b5947Chris Lattner CurByte, OS, Fixups); 96540cc3f8783a4e426a0d439bb2b070b5c072b5947Chris Lattner EmitImmediate(MI.getOperand(CurOp++), 1, FK_Data_1, CurByte, OS, Fixups); 96640cc3f8783a4e426a0d439bb2b070b5c072b5947Chris Lattner break; 96759f8a6a66621f7c6f45b838e48fbf210af9d1fb5Chris Lattner case X86II::RawFrmImm16: 96859f8a6a66621f7c6f45b838e48fbf210af9d1fb5Chris Lattner EmitByte(BaseOpcode, CurByte, OS); 96959f8a6a66621f7c6f45b838e48fbf210af9d1fb5Chris Lattner EmitImmediate(MI.getOperand(CurOp++), 97059f8a6a66621f7c6f45b838e48fbf210af9d1fb5Chris Lattner X86II::getSizeOfImm(TSFlags), getImmFixupKind(TSFlags), 97159f8a6a66621f7c6f45b838e48fbf210af9d1fb5Chris Lattner CurByte, OS, Fixups); 97259f8a6a66621f7c6f45b838e48fbf210af9d1fb5Chris Lattner EmitImmediate(MI.getOperand(CurOp++), 2, FK_Data_2, CurByte, OS, Fixups); 97359f8a6a66621f7c6f45b838e48fbf210af9d1fb5Chris Lattner break; 97496716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 9758b0f7a7d8627392c8faae3801cc91689406960cfChris Lattner case X86II::AddRegFrm: 97637ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(BaseOpcode + GetX86RegNum(MI.getOperand(CurOp++)), CurByte, OS); 9771e80f403e225a72016581e34b05dca9b5ebd9445Chris Lattner break; 97896716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 97928249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner case X86II::MRMDestReg: 98037ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(BaseOpcode, CurByte, OS); 98128249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner EmitRegModRMByte(MI.getOperand(CurOp), 98237ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner GetX86RegNum(MI.getOperand(CurOp+1)), CurByte, OS); 98328249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner CurOp += 2; 98428249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner break; 98596716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 9861ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner case X86II::MRMDestMem: 98737ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(BaseOpcode, CurByte, OS); 9884b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes SrcRegNum = CurOp + X86::AddrNumOperands; 9894b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes 9904b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes if (HasVEX_4V) // Skip 1st src (which is encoded in VEX_VVVV) 9914b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes SrcRegNum++; 9924b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes 9931ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner EmitMemModRMByte(MI, CurOp, 9944b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes GetX86RegNum(MI.getOperand(SrcRegNum)), 995835acabce13993e210b7cef0020a585125f9cb1eChris Lattner TSFlags, CurByte, OS, Fixups); 9964b13f3cf3d44219371ca8cdfe699ebdc5e12f7f8Bruno Cardoso Lopes CurOp = SrcRegNum + 1; 9971ac23b10384543fcc7343beeac542b2ab626eeecChris Lattner break; 99896716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 999daa45557931bb72e6b9f6b4725ac2cb1bd5168e9Chris Lattner case X86II::MRMSrcReg: 100037ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(BaseOpcode, CurByte, OS); 100199405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes SrcRegNum = CurOp + 1; 100299405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 1003b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper if (HasVEX_4V) // Skip 1st src (which is encoded in VEX_VVVV) 100499405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes SrcRegNum++; 100599405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes 1006703420f50e458e2482e55c9a5b3cafa0b734f507Jan Sjödin if(HasXOP_W) // Skip 2nd src (which is encoded in I8IMM) 1007703420f50e458e2482e55c9a5b3cafa0b734f507Jan Sjödin SrcRegNum++; 10081b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes 100999405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes EmitRegModRMByte(MI.getOperand(SrcRegNum), 101099405df044f2c584242e711cc9023ec90356da82Bruno Cardoso Lopes GetX86RegNum(MI.getOperand(CurOp)), CurByte, OS); 1011703420f50e458e2482e55c9a5b3cafa0b734f507Jan Sjödin 1012703420f50e458e2482e55c9a5b3cafa0b734f507Jan Sjödin // 2 operands skipped with HasXOP_W, comensate accordingly 1013703420f50e458e2482e55c9a5b3cafa0b734f507Jan Sjödin CurOp = HasXOP_W ? SrcRegNum : SrcRegNum + 1; 1014b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper if (HasVEX_4VOp3) 101517730847d59c919d97f097d46a3fcba1888e5300Craig Topper ++CurOp; 1016daa45557931bb72e6b9f6b4725ac2cb1bd5168e9Chris Lattner break; 101796716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 1018daa45557931bb72e6b9f6b4725ac2cb1bd5168e9Chris Lattner case X86II::MRMSrcMem: { 1019ac0ed5dc082dff9ce359af5422f5b82047b4fe6bChris Lattner int AddrOperands = X86::AddrNumOperands; 10201cf44fc051e05c7cd96a4b071b654381338baae9Chris Lattner unsigned FirstMemOp = CurOp+1; 1021b53fa8bf19a51f0c49a9f8b6ede3e2ff3bdfb961Craig Topper if (HasVEX_4V) { 10221cf44fc051e05c7cd96a4b071b654381338baae9Chris Lattner ++AddrOperands; 10231cf44fc051e05c7cd96a4b071b654381338baae9Chris Lattner ++FirstMemOp; // Skip the register source (which is encoded in VEX_VVVV). 10241cf44fc051e05c7cd96a4b071b654381338baae9Chris Lattner } 10251b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes if(HasXOP_W) // Skip second register source (encoded in I8IMM) 10261b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes ++FirstMemOp; 1027daa45557931bb72e6b9f6b4725ac2cb1bd5168e9Chris Lattner 10281cf44fc051e05c7cd96a4b071b654381338baae9Chris Lattner EmitByte(BaseOpcode, CurByte, OS); 102996716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 10301cf44fc051e05c7cd96a4b071b654381338baae9Chris Lattner EmitMemModRMByte(MI, FirstMemOp, GetX86RegNum(MI.getOperand(CurOp)), 1031835acabce13993e210b7cef0020a585125f9cb1eChris Lattner TSFlags, CurByte, OS, Fixups); 1032703420f50e458e2482e55c9a5b3cafa0b734f507Jan Sjödin CurOp += AddrOperands + 1; 1033703420f50e458e2482e55c9a5b3cafa0b734f507Jan Sjödin if (HasVEX_4VOp3) 1034703420f50e458e2482e55c9a5b3cafa0b734f507Jan Sjödin ++CurOp; 1035daa45557931bb72e6b9f6b4725ac2cb1bd5168e9Chris Lattner break; 1036daa45557931bb72e6b9f6b4725ac2cb1bd5168e9Chris Lattner } 103782ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner 103882ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner case X86II::MRM0r: case X86II::MRM1r: 103982ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner case X86II::MRM2r: case X86II::MRM3r: 104082ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner case X86II::MRM4r: case X86II::MRM5r: 10418b0f7a7d8627392c8faae3801cc91689406960cfChris Lattner case X86II::MRM6r: case X86II::MRM7r: 10425a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes if (HasVEX_4V) // Skip the register dst (which is encoded in VEX_VVVV). 10435a3a4767502341f304a8015580ab05ed74161ab0Bruno Cardoso Lopes CurOp++; 104437ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(BaseOpcode, CurByte, OS); 1045eaca5fa8e6a2cb0f84a635da5f1f0f670776d0a5Chris Lattner EmitRegModRMByte(MI.getOperand(CurOp++), 1046eaca5fa8e6a2cb0f84a635da5f1f0f670776d0a5Chris Lattner (TSFlags & X86II::FormMask)-X86II::MRM0r, 1047eaca5fa8e6a2cb0f84a635da5f1f0f670776d0a5Chris Lattner CurByte, OS); 104882ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner break; 104982ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner case X86II::MRM0m: case X86II::MRM1m: 105082ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner case X86II::MRM2m: case X86II::MRM3m: 105182ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner case X86II::MRM4m: case X86II::MRM5m: 10528b0f7a7d8627392c8faae3801cc91689406960cfChris Lattner case X86II::MRM6m: case X86II::MRM7m: 1053566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper if (HasVEX_4V) // Skip the register dst (which is encoded in VEX_VVVV). 1054566f233ba64c0bb2773b5717cb18753c7564f4b7Craig Topper CurOp++; 105537ce80eca3159b3a7654cc34ea9c1202f38335caChris Lattner EmitByte(BaseOpcode, CurByte, OS); 105682ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner EmitMemModRMByte(MI, CurOp, (TSFlags & X86II::FormMask)-X86II::MRM0m, 1057835acabce13993e210b7cef0020a585125f9cb1eChris Lattner TSFlags, CurByte, OS, Fixups); 1058ac0ed5dc082dff9ce359af5422f5b82047b4fe6bChris Lattner CurOp += X86::AddrNumOperands; 105982ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner break; 10600d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner case X86II::MRM_C1: 10610d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner EmitByte(BaseOpcode, CurByte, OS); 10620d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner EmitByte(0xC1, CurByte, OS); 10630d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner break; 1064a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner case X86II::MRM_C2: 1065a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner EmitByte(BaseOpcode, CurByte, OS); 1066a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner EmitByte(0xC2, CurByte, OS); 1067a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner break; 1068a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner case X86II::MRM_C3: 1069a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner EmitByte(BaseOpcode, CurByte, OS); 1070a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner EmitByte(0xC3, CurByte, OS); 1071a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner break; 1072a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner case X86II::MRM_C4: 1073a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner EmitByte(BaseOpcode, CurByte, OS); 1074a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner EmitByte(0xC4, CurByte, OS); 1075a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner break; 10760d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner case X86II::MRM_C8: 10770d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner EmitByte(BaseOpcode, CurByte, OS); 10780d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner EmitByte(0xC8, CurByte, OS); 10790d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner break; 10800d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner case X86II::MRM_C9: 10810d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner EmitByte(BaseOpcode, CurByte, OS); 10820d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner EmitByte(0xC9, CurByte, OS); 10830d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner break; 10840d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner case X86II::MRM_E8: 10850d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner EmitByte(BaseOpcode, CurByte, OS); 10860d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner EmitByte(0xE8, CurByte, OS); 10870d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner break; 10880d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner case X86II::MRM_F0: 10890d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner EmitByte(BaseOpcode, CurByte, OS); 10900d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner EmitByte(0xF0, CurByte, OS); 10910d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner break; 1092a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner case X86II::MRM_F8: 1093a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner EmitByte(BaseOpcode, CurByte, OS); 1094a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner EmitByte(0xF8, CurByte, OS); 1095a599de241041eebc84867ac8e4cb76668cabd236Chris Lattner break; 1096b779033a23c49c2e5e02b15a87bbae42973287b3Chris Lattner case X86II::MRM_F9: 1097b779033a23c49c2e5e02b15a87bbae42973287b3Chris Lattner EmitByte(BaseOpcode, CurByte, OS); 1098b779033a23c49c2e5e02b15a87bbae42973287b3Chris Lattner EmitByte(0xF9, CurByte, OS); 1099b779033a23c49c2e5e02b15a87bbae42973287b3Chris Lattner break; 110087ca0e077d91b96a765b3b24cadfa8891026a33aRafael Espindola case X86II::MRM_D0: 110187ca0e077d91b96a765b3b24cadfa8891026a33aRafael Espindola EmitByte(BaseOpcode, CurByte, OS); 110287ca0e077d91b96a765b3b24cadfa8891026a33aRafael Espindola EmitByte(0xD0, CurByte, OS); 110387ca0e077d91b96a765b3b24cadfa8891026a33aRafael Espindola break; 110487ca0e077d91b96a765b3b24cadfa8891026a33aRafael Espindola case X86II::MRM_D1: 110587ca0e077d91b96a765b3b24cadfa8891026a33aRafael Espindola EmitByte(BaseOpcode, CurByte, OS); 110687ca0e077d91b96a765b3b24cadfa8891026a33aRafael Espindola EmitByte(0xD1, CurByte, OS); 110787ca0e077d91b96a765b3b24cadfa8891026a33aRafael Espindola break; 110882ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner } 110996716c7b92cfdbc433836e8911335a4832b72b5bBruno Cardoso Lopes 11108b0f7a7d8627392c8faae3801cc91689406960cfChris Lattner // If there is a remaining operand, it must be a trailing immediate. Emit it 11118b0f7a7d8627392c8faae3801cc91689406960cfChris Lattner // according to the right size for the instruction. 111207de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes if (CurOp != NumOps) { 111307de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes // The last source register of a 4 operand instruction in AVX is encoded 1114ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin // in bits[7:4] of a immediate byte. 1115229e4523f2f12929defa09ac4ef9f3652f21f1ecJoerg Sonnenberger if ((TSFlags >> X86II::VEXShift) & X86II::VEX_I8IMM) { 11161b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes const MCOperand &MO = MI.getOperand(HasXOP_W ? XOP_W_I8IMMOperand 11171b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes : CurOp); 11181b9b377975b3f437acef8c2ba90de582add52f65Bruno Cardoso Lopes CurOp++; 111977169a919718b74f62ab6a577f65ac5ef9547abaBruno Cardoso Lopes bool IsExtReg = X86II::isX86_64ExtendedReg(MO.getReg()); 112007de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes unsigned RegNum = (IsExtReg ? (1 << 7) : 0); 112107de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes RegNum |= GetX86RegNum(MO) << 4; 1122ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin // If there is an additional 5th operand it must be an immediate, which 1123ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin // is encoded in bits[3:0] 1124ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin if(CurOp != NumOps) { 1125ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin const MCOperand &MIMM = MI.getOperand(CurOp++); 1126ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin if(MIMM.isImm()) { 1127ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin unsigned Val = MIMM.getImm(); 1128ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin assert(Val < 16 && "Immediate operand value out of range"); 1129ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin RegNum |= Val; 1130ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin } 1131ebebe35d1c5ad689caf31cdc4da5b7a9539ffa5cJan Sjödin } 113207de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes EmitImmediate(MCOperand::CreateImm(RegNum), 1, FK_Data_1, CurByte, OS, 113307de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes Fixups); 1134a8c02c3bdd68e65d14fb6b0d56989663754059b0Rafael Espindola } else { 1135a8c02c3bdd68e65d14fb6b0d56989663754059b0Rafael Espindola unsigned FixupKind; 11363ee33aa6f9b961e1c7b6dbb57df6fd53b68fbac4Rafael Espindola // FIXME: Is there a better way to know that we need a signed relocation? 1137a3bff99f0a325092dc1227c036f5def4aa1b9bb5Rafael Espindola if (MI.getOpcode() == X86::ADD64ri32 || 1138a3bff99f0a325092dc1227c036f5def4aa1b9bb5Rafael Espindola MI.getOpcode() == X86::MOV64ri32 || 11393ee33aa6f9b961e1c7b6dbb57df6fd53b68fbac4Rafael Espindola MI.getOpcode() == X86::MOV64mi32 || 11403ee33aa6f9b961e1c7b6dbb57df6fd53b68fbac4Rafael Espindola MI.getOpcode() == X86::PUSH64i32) 1141a8c02c3bdd68e65d14fb6b0d56989663754059b0Rafael Espindola FixupKind = X86::reloc_signed_4byte; 1142a8c02c3bdd68e65d14fb6b0d56989663754059b0Rafael Espindola else 1143a8c02c3bdd68e65d14fb6b0d56989663754059b0Rafael Espindola FixupKind = getImmFixupKind(TSFlags); 114407de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes EmitImmediate(MI.getOperand(CurOp++), 1145a8c02c3bdd68e65d14fb6b0d56989663754059b0Rafael Espindola X86II::getSizeOfImm(TSFlags), MCFixupKind(FixupKind), 114607de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes CurByte, OS, Fixups); 1147a8c02c3bdd68e65d14fb6b0d56989663754059b0Rafael Espindola } 114807de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes } 114907de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes 1150229e4523f2f12929defa09ac4ef9f3652f21f1ecJoerg Sonnenberger if ((TSFlags >> X86II::VEXShift) & X86II::Has3DNow0F0FOpcode) 1151548abfcbd671b1144bf517b17643259dcae76f4fChris Lattner EmitByte(X86II::getBaseOpcodeFor(TSFlags), CurByte, OS); 115207de40629f73fb018a2a7f0a5bbd1ee4defe95fdBruno Cardoso Lopes 115328249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner#ifndef NDEBUG 115482ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner // FIXME: Verify. 115582ed17eb472102cb6711b832183ee4816ad9a656Chris Lattner if (/*!Desc.isVariadic() &&*/ CurOp != NumOps) { 115628249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner errs() << "Cannot encode all operands of: "; 115728249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner MI.dump(); 115828249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner errs() << '\n'; 115928249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner abort(); 116028249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner } 116128249d98e195f7e04709b959e9f8ffe0d8080bf2Chris Lattner#endif 1162457624792803e26136889b8cf17e8aa7b84e58b4Chris Lattner} 1163