131d157ae1ac2cd9c787dc3c1d28e64c682803844Jia Liu//===-- X86CodeEmitter.cpp - Convert X86 code to machine code -------------===// 20e0a7a45d3d0a8c865a078459d2e1c6d8967a100Misha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 70e0a7a45d3d0a8c865a078459d2e1c6d8967a100Misha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 940ead9592888c345d6514dff427ae67dfcf23805Chris Lattner// 1040ead9592888c345d6514dff427ae67dfcf23805Chris Lattner// This file contains the pass that transforms the X86 machine instructions into 11e72e445ed574c684ddef1aa15e0e245a43c6a2beChris Lattner// relocatable machine code. 1240ead9592888c345d6514dff427ae67dfcf23805Chris Lattner// 1340ead9592888c345d6514dff427ae67dfcf23805Chris Lattner//===----------------------------------------------------------------------===// 1440ead9592888c345d6514dff427ae67dfcf23805Chris Lattner 1595b2c7da5e83670881270c1cd231a240be0556d9Chris Lattner#define DEBUG_TYPE "x86-emitter" 16d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "X86.h" 1725ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng#include "X86InstrInfo.h" 182a3e08b5961353fa3faeadf81f481ae9f5463427Evan Cheng#include "X86JITInfo.h" 19d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "X86Relocations.h" 2025ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng#include "X86Subtarget.h" 2140ead9592888c345d6514dff427ae67dfcf23805Chris Lattner#include "X86TargetMachine.h" 22d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/Statistic.h" 23a3f99f90338d89354384ca25f53ca4450a1a9d18Bruno Cardoso Lopes#include "llvm/CodeGen/JITCodeEmitter.h" 245ae99fe3bf7904823d2745beaa8ee8e404e836a4Chris Lattner#include "llvm/CodeGen/MachineFunctionPass.h" 2576041ce5155ca4aab443d139d7ad820ae06cbe09Chris Lattner#include "llvm/CodeGen/MachineInstr.h" 26afe6c2b001a924cd74bd0aacfed5984d9af004b0Nicolas Geoffray#include "llvm/CodeGen/MachineModuleInfo.h" 27655239cc6b7a3045df386b91b14b89e3f0adf434Chris Lattner#include "llvm/CodeGen/Passes.h" 280b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/LLVMContext.h" 297168a7dc6dd3b6a502372f34c2ed4ed91c85c090Daniel Dunbar#include "llvm/MC/MCCodeEmitter.h" 308c2eebe4074ef218b30d94358f6b2e45c079605cDaniel Dunbar#include "llvm/MC/MCExpr.h" 317168a7dc6dd3b6a502372f34c2ed4ed91c85c090Daniel Dunbar#include "llvm/MC/MCInst.h" 32d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/PassManager.h" 3317ed8fa63d57bbac2aa0533e510969fe5155b22aEvan Cheng#include "llvm/Support/Debug.h" 34ab7c09b6b6f4516a631fd6788918c237c83939afTorok Edwin#include "llvm/Support/ErrorHandling.h" 35ce63ffb52f249b62cdf2d250c128007b13f27e71Daniel Dunbar#include "llvm/Support/raw_ostream.h" 365e8b5558f7939cde1f6de2e18d7616903e86e7ebEvan Cheng#include "llvm/Target/TargetOptions.h" 3765b05ce02229b8e0cc270e4b4d3f1dd612300519Chris Lattnerusing namespace llvm; 38d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 3995b2c7da5e83670881270c1cd231a240be0556d9Chris LattnerSTATISTIC(NumEmitted, "Number of machine instructions emitted"); 4004b0b309c4d6e3a381edbb2db6a23a0009661dd8Chris Lattner 4104b0b309c4d6e3a381edbb2db6a23a0009661dd8Chris Lattnernamespace { 42f5af556c18fa44f073367e0ce7093df507810adaChris Lattner template<class CodeEmitter> 436726b6d75a8b679068a58cb954ba97cf9d1690baNick Lewycky class Emitter : public MachineFunctionPass { 445ae99fe3bf7904823d2745beaa8ee8e404e836a4Chris Lattner const X86InstrInfo *II; 453574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD; 46c9f5f3f64f896d0a8c8fa35a1dd98bc57b8960f6Dan Gohman X86TargetMachine &TM; 47434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopes CodeEmitter &MCE; 481611273351d75b5cbe2a67485bb9831d5916fe26Chris Lattner MachineModuleInfo *MMI; 492a3e08b5961353fa3faeadf81f481ae9f5463427Evan Cheng intptr_t PICBaseOffset; 5025ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng bool Is64BitMode; 51aabe38bf0c773dffed5c12a35e894915418af512Evan Cheng bool IsPIC; 52ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner public: 531997473cf72957d0e70322e2fe6fe2ab141c58a6Devang Patel static char ID; 54434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopes explicit Emitter(X86TargetMachine &tm, CodeEmitter &mce) 55bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak : MachineFunctionPass(ID), II(0), TD(0), TM(tm), 562a3e08b5961353fa3faeadf81f481ae9f5463427Evan Cheng MCE(mce), PICBaseOffset(0), Is64BitMode(false), 57be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng IsPIC(TM.getRelocationModel() == Reloc::PIC_) {} 58434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopes Emitter(X86TargetMachine &tm, CodeEmitter &mce, 593574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const X86InstrInfo &ii, const DataLayout &td, bool is64) 60bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak : MachineFunctionPass(ID), II(&ii), TD(&td), TM(tm), 612a3e08b5961353fa3faeadf81f481ae9f5463427Evan Cheng MCE(mce), PICBaseOffset(0), Is64BitMode(is64), 62be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng IsPIC(TM.getRelocationModel() == Reloc::PIC_) {} 6340ead9592888c345d6514dff427ae67dfcf23805Chris Lattner 645ae99fe3bf7904823d2745beaa8ee8e404e836a4Chris Lattner bool runOnMachineFunction(MachineFunction &MF); 6576041ce5155ca4aab443d139d7ad820ae06cbe09Chris Lattner 66f0eb7beb66d7402ba7ef32466aa6d9a53c33da01Chris Lattner virtual const char *getPassName() const { 67f0eb7beb66d7402ba7ef32466aa6d9a53c33da01Chris Lattner return "X86 Machine Code Emitter"; 68f0eb7beb66d7402ba7ef32466aa6d9a53c33da01Chris Lattner } 69f0eb7beb66d7402ba7ef32466aa6d9a53c33da01Chris Lattner 706942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper void emitOpcodePrefix(uint64_t TSFlags, int MemOperand, 716942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MachineInstr &MI, 726942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MCInstrDesc *Desc) const; 736942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 746942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper void emitVEXOpcodePrefix(uint64_t TSFlags, int MemOperand, 756942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MachineInstr &MI, 766942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MCInstrDesc *Desc) const; 776942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 786942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper void emitSegmentOverridePrefix(uint64_t TSFlags, 796942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper int MemOperand, 806942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MachineInstr &MI) const; 816942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 82e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng void emitInstruction(MachineInstr &MI, const MCInstrDesc *Desc); 83bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 84afe6c2b001a924cd74bd0aacfed5984d9af004b0Nicolas Geoffray void getAnalysisUsage(AnalysisUsage &AU) const { 85675fb65bf436b398f2ab3861b0fa05e3028a83d1Dan Gohman AU.setPreservesAll(); 86afe6c2b001a924cd74bd0aacfed5984d9af004b0Nicolas Geoffray AU.addRequired<MachineModuleInfo>(); 87afe6c2b001a924cd74bd0aacfed5984d9af004b0Nicolas Geoffray MachineFunctionPass::getAnalysisUsage(AU); 88afe6c2b001a924cd74bd0aacfed5984d9af004b0Nicolas Geoffray } 8939c2005b7082367457a1e6b833bf7e39a03a3b71Alkis Evlogimenos 90ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner private: 9137efe6764568a3829fee26aba532283131d1a104Nate Begeman void emitPCRelativeBlockAddress(MachineBasicBlock *MBB); 9246510a73e977273ec67747eb34cbdb43f815e451Dan Gohman void emitGlobalAddress(const GlobalValue *GV, unsigned Reloc, 93c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman intptr_t Disp = 0, intptr_t PCAdj = 0, 94d1ba06bf131a9d217426529d2e28af1f2eeed47aJeffrey Yasskin bool Indirect = false); 9502aabbf96b1f22144afe2bec8ad480a9b803f6b8Evan Cheng void emitExternalSymbolAddress(const char *ES, unsigned Reloc); 96c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman void emitConstPoolAddress(unsigned CPI, unsigned Reloc, intptr_t Disp = 0, 9702aabbf96b1f22144afe2bec8ad480a9b803f6b8Evan Cheng intptr_t PCAdj = 0); 98aabe38bf0c773dffed5c12a35e894915418af512Evan Cheng void emitJumpTableAddress(unsigned JTI, unsigned Reloc, 9902aabbf96b1f22144afe2bec8ad480a9b803f6b8Evan Cheng intptr_t PCAdj = 0); 10004b0b309c4d6e3a381edbb2db6a23a0009661dd8Chris Lattner 10125ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng void emitDisplacementField(const MachineOperand *RelocOp, int DispVal, 102e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes intptr_t Adj = 0, bool IsPCRel = true); 1030e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner 104ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner void emitRegModRMByte(unsigned ModRMReg, unsigned RegOpcodeField); 1054b299d4ebdf57c56ca336d9aca6f2ad7d8175995Evan Cheng void emitRegModRMByte(unsigned RegOpcodeField); 106ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner void emitSIBByte(unsigned SS, unsigned Index, unsigned Base); 10725ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng void emitConstant(uint64_t Val, unsigned Size); 108ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner 109ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner void emitMemModRMByte(const MachineInstr &MI, 11025ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng unsigned Op, unsigned RegOpcodeField, 111aabe38bf0c773dffed5c12a35e894915418af512Evan Cheng intptr_t PCAdj = 0); 1127abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao 1137abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao unsigned getX86RegNum(unsigned RegNo) const { 1147abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao const TargetRegisterInfo *TRI = TM.getRegisterInfo(); 1157abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao return TRI->getEncodingValue(RegNo) & 0x7; 1167abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao } 1177abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao 1187abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao unsigned char getVEXRegisterEncoding(const MachineInstr &MI, 1197abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao unsigned OpNum) const; 12040ead9592888c345d6514dff427ae67dfcf23805Chris Lattner }; 121a3f99f90338d89354384ca25f53ca4450a1a9d18Bruno Cardoso Lopes 122434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopestemplate<class CodeEmitter> 123434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopes char Emitter<CodeEmitter>::ID = 0; 124f5af556c18fa44f073367e0ce7093df507810adaChris Lattner} // end anonymous namespace. 12540ead9592888c345d6514dff427ae67dfcf23805Chris Lattner 12681b6ed7ed1dbf1e5cc001aaff2dee5bdd8d1122eChris Lattner/// createX86CodeEmitterPass - Return a pass that emits the collected X86 code 127d07c2a5fa1fd3bee45104953714a128cf5e19158Eli Bendersky/// to the specified JITCodeEmitter object. 128ac57e6e498abccb117e0d61c2fa0f733845e50cbBruno Cardoso LopesFunctionPass *llvm::createX86JITCodeEmitterPass(X86TargetMachine &TM, 129ac57e6e498abccb117e0d61c2fa0f733845e50cbBruno Cardoso Lopes JITCodeEmitter &JCE) { 130a3f99f90338d89354384ca25f53ca4450a1a9d18Bruno Cardoso Lopes return new Emitter<JITCodeEmitter>(TM, JCE); 13140ead9592888c345d6514dff427ae67dfcf23805Chris Lattner} 132a3f99f90338d89354384ca25f53ca4450a1a9d18Bruno Cardoso Lopes 133434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopestemplate<class CodeEmitter> 134434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopesbool Emitter<CodeEmitter>::runOnMachineFunction(MachineFunction &MF) { 1351611273351d75b5cbe2a67485bb9831d5916fe26Chris Lattner MMI = &getAnalysis<MachineModuleInfo>(); 1361611273351d75b5cbe2a67485bb9831d5916fe26Chris Lattner MCE.setModuleInfo(MMI); 137bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 138c9f5f3f64f896d0a8c8fa35a1dd98bc57b8960f6Dan Gohman II = TM.getInstrInfo(); 1393574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow TD = TM.getDataLayout(); 140be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng Is64BitMode = TM.getSubtarget<X86Subtarget>().is64Bit(); 141a125e62117011f9361b0e8a7b76d1089173f97f4Evan Cheng IsPIC = TM.getRelocationModel() == Reloc::PIC_; 142bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 14343b429b05989075b60693d57395c99b0ad789f8dChris Lattner do { 14496601ca332ab388754ca4673be8973396fea2dddCraig Topper DEBUG(dbgs() << "JITTing function '" << MF.getName() << "'\n"); 14543b429b05989075b60693d57395c99b0ad789f8dChris Lattner MCE.startFunction(MF); 146bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak for (MachineFunction::iterator MBB = MF.begin(), E = MF.end(); 14793e5c284d7db810078b3cc0ca59cfabb680f7d6eChris Lattner MBB != E; ++MBB) { 14893e5c284d7db810078b3cc0ca59cfabb680f7d6eChris Lattner MCE.StartMachineBasicBlock(MBB); 1498dae787db4ad6d847aceb7c4b28516649ab78036Chris Lattner for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end(); 1500475ab58b8e92fa8e8b90ddbf023bc60587c5e25Evan Cheng I != E; ++I) { 151e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &Desc = I->getDesc(); 152749c6f6b5ed301c84aac562e414486549d7b98ebChris Lattner emitInstruction(*I, &Desc); 1530475ab58b8e92fa8e8b90ddbf023bc60587c5e25Evan Cheng // MOVPC32r is basically a call plus a pop instruction. 154749c6f6b5ed301c84aac562e414486549d7b98ebChris Lattner if (Desc.getOpcode() == X86::MOVPC32r) 1550475ab58b8e92fa8e8b90ddbf023bc60587c5e25Evan Cheng emitInstruction(*I, &II->get(X86::POP32r)); 156fe60104ac97f3a8736dcfbfdf9547c7b7cc7b951Dan Gohman ++NumEmitted; // Keep track of the # of mi's emitted 1570475ab58b8e92fa8e8b90ddbf023bc60587c5e25Evan Cheng } 15893e5c284d7db810078b3cc0ca59cfabb680f7d6eChris Lattner } 15943b429b05989075b60693d57395c99b0ad789f8dChris Lattner } while (MCE.finishFunction(MF)); 16004b0b309c4d6e3a381edbb2db6a23a0009661dd8Chris Lattner 16176041ce5155ca4aab443d139d7ad820ae06cbe09Chris Lattner return false; 16276041ce5155ca4aab443d139d7ad820ae06cbe09Chris Lattner} 16376041ce5155ca4aab443d139d7ad820ae06cbe09Chris Lattner 164456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner/// determineREX - Determine if the MachineInstr has to be encoded with a X86-64 165456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner/// REX prefix which specifies 1) 64-bit instructions, 2) non-default operand 166456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner/// size, and 3) use of X86-64 extended registers. 167456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattnerstatic unsigned determineREX(const MachineInstr &MI) { 168456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner unsigned REX = 0; 169e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &Desc = MI.getDesc(); 170bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 171456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner // Pseudo instructions do not need REX prefix byte. 172456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if ((Desc.TSFlags & X86II::FormMask) == X86II::Pseudo) 173456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner return 0; 174456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (Desc.TSFlags & X86II::REX_W) 175456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner REX |= 1 << 3; 176bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 177456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner unsigned NumOps = Desc.getNumOperands(); 178456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (NumOps) { 179456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner bool isTwoAddr = NumOps > 1 && 18082dd67a1c8edfacac45e31a868ef074248bccb12Craig Topper Desc.getOperandConstraint(1, MCOI::TIED_TO) != -1; 181bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 182456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner // If it accesses SPL, BPL, SIL, or DIL, then it requires a 0x40 REX prefix. 183456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner unsigned i = isTwoAddr ? 1 : 0; 184456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner for (unsigned e = NumOps; i != e; ++i) { 185456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner const MachineOperand& MO = MI.getOperand(i); 186456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (MO.isReg()) { 187456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner unsigned Reg = MO.getReg(); 1888c3fee59038d8fd98db2a01b6a309a8941a16a3fEvan Cheng if (X86II::isX86_64NonExtLowByteReg(Reg)) 189456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner REX |= 0x40; 190456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner } 191456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner } 192bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 193456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner switch (Desc.TSFlags & X86II::FormMask) { 194456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner case X86II::MRMInitReg: 195456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (X86InstrInfo::isX86_64ExtendedReg(MI.getOperand(0))) 196456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner REX |= (1 << 0) | (1 << 2); 197456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner break; 198456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner case X86II::MRMSrcReg: { 199456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (X86InstrInfo::isX86_64ExtendedReg(MI.getOperand(0))) 200456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner REX |= 1 << 2; 201456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner i = isTwoAddr ? 2 : 1; 202456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner for (unsigned e = NumOps; i != e; ++i) { 203456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner const MachineOperand& MO = MI.getOperand(i); 204456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (X86InstrInfo::isX86_64ExtendedReg(MO)) 205456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner REX |= 1 << 0; 206456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner } 207456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner break; 208456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner } 209456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner case X86II::MRMSrcMem: { 210456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (X86InstrInfo::isX86_64ExtendedReg(MI.getOperand(0))) 211456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner REX |= 1 << 2; 212456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner unsigned Bit = 0; 213456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner i = isTwoAddr ? 2 : 1; 214456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner for (; i != NumOps; ++i) { 215456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner const MachineOperand& MO = MI.getOperand(i); 216456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (MO.isReg()) { 217456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (X86InstrInfo::isX86_64ExtendedReg(MO)) 218456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner REX |= 1 << Bit; 219456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner Bit++; 220456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner } 221456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner } 222456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner break; 223456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner } 224456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner case X86II::MRM0m: case X86II::MRM1m: 225456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner case X86II::MRM2m: case X86II::MRM3m: 226456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner case X86II::MRM4m: case X86II::MRM5m: 227456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner case X86II::MRM6m: case X86II::MRM7m: 228456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner case X86II::MRMDestMem: { 229456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner unsigned e = (isTwoAddr ? X86::AddrNumOperands+1 : X86::AddrNumOperands); 230456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner i = isTwoAddr ? 1 : 0; 231456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (NumOps > e && X86InstrInfo::isX86_64ExtendedReg(MI.getOperand(e))) 232456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner REX |= 1 << 2; 233456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner unsigned Bit = 0; 234456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner for (; i != e; ++i) { 235456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner const MachineOperand& MO = MI.getOperand(i); 236456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (MO.isReg()) { 237456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (X86InstrInfo::isX86_64ExtendedReg(MO)) 238456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner REX |= 1 << Bit; 239456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner Bit++; 240456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner } 241456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner } 242456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner break; 243456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner } 244456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner default: { 245456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (X86InstrInfo::isX86_64ExtendedReg(MI.getOperand(0))) 246456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner REX |= 1 << 0; 247456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner i = isTwoAddr ? 2 : 1; 248456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner for (unsigned e = NumOps; i != e; ++i) { 249456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner const MachineOperand& MO = MI.getOperand(i); 250456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (X86InstrInfo::isX86_64ExtendedReg(MO)) 251456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner REX |= 1 << 2; 252456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner } 253456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner break; 254456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner } 255456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner } 256456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner } 257456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner return REX; 258456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner} 259456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner 260456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner 261b4432f3d4754e16c918428d34a9d8ec18ab79204Chris Lattner/// emitPCRelativeBlockAddress - This method keeps track of the information 262b4432f3d4754e16c918428d34a9d8ec18ab79204Chris Lattner/// necessary to resolve the address of this block later and emits a dummy 263b4432f3d4754e16c918428d34a9d8ec18ab79204Chris Lattner/// value. 26404b0b309c4d6e3a381edbb2db6a23a0009661dd8Chris Lattner/// 265434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopestemplate<class CodeEmitter> 266434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopesvoid Emitter<CodeEmitter>::emitPCRelativeBlockAddress(MachineBasicBlock *MBB) { 267b4432f3d4754e16c918428d34a9d8ec18ab79204Chris Lattner // Remember where this reference was and where it is to so we can 268b4432f3d4754e16c918428d34a9d8ec18ab79204Chris Lattner // deal with it later. 269f141cc46faf6f0525f0baa10b6a6c976301874a5Evan Cheng MCE.addRelocation(MachineRelocation::getBB(MCE.getCurrentPCOffset(), 270f141cc46faf6f0525f0baa10b6a6c976301874a5Evan Cheng X86::reloc_pcrel_word, MBB)); 271b4432f3d4754e16c918428d34a9d8ec18ab79204Chris Lattner MCE.emitWordLE(0); 27204b0b309c4d6e3a381edbb2db6a23a0009661dd8Chris Lattner} 27304b0b309c4d6e3a381edbb2db6a23a0009661dd8Chris Lattner 27404b0b309c4d6e3a381edbb2db6a23a0009661dd8Chris Lattner/// emitGlobalAddress - Emit the specified address to the code stream assuming 27525ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng/// this is part of a "take the address of a global" instruction. 27604b0b309c4d6e3a381edbb2db6a23a0009661dd8Chris Lattner/// 277434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopestemplate<class CodeEmitter> 27846510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanvoid Emitter<CodeEmitter>::emitGlobalAddress(const GlobalValue *GV, 27946510a73e977273ec67747eb34cbdb43f815e451Dan Gohman unsigned Reloc, 280c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman intptr_t Disp /* = 0 */, 281c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman intptr_t PCAdj /* = 0 */, 2829ed2f80910160bbf8051d91cd74c82d4619885b4Evan Cheng bool Indirect /* = false */) { 283e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes intptr_t RelocCST = Disp; 28402aabbf96b1f22144afe2bec8ad480a9b803f6b8Evan Cheng if (Reloc == X86::reloc_picrel_word) 2852a3e08b5961353fa3faeadf81f481ae9f5463427Evan Cheng RelocCST = PICBaseOffset; 286be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng else if (Reloc == X86::reloc_pcrel_word) 287be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng RelocCST = PCAdj; 2889ed2f80910160bbf8051d91cd74c82d4619885b4Evan Cheng MachineRelocation MR = Indirect 2899ed2f80910160bbf8051d91cd74c82d4619885b4Evan Cheng ? MachineRelocation::getIndirectSymbol(MCE.getCurrentPCOffset(), Reloc, 29046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const_cast<GlobalValue *>(GV), 29146510a73e977273ec67747eb34cbdb43f815e451Dan Gohman RelocCST, false) 292be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng : MachineRelocation::getGV(MCE.getCurrentPCOffset(), Reloc, 29346510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const_cast<GlobalValue *>(GV), RelocCST, false); 294be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng MCE.addRelocation(MR); 295c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman // The relocated value will be added to the displacement 29619f2ffce4598c4c70f32eed7c6740b43185200b1Evan Cheng if (Reloc == X86::reloc_absolute_dword) 297c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman MCE.emitDWordLE(Disp); 298c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman else 299c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman MCE.emitWordLE((int32_t)Disp); 30004b0b309c4d6e3a381edbb2db6a23a0009661dd8Chris Lattner} 30104b0b309c4d6e3a381edbb2db6a23a0009661dd8Chris Lattner 302e72e445ed574c684ddef1aa15e0e245a43c6a2beChris Lattner/// emitExternalSymbolAddress - Arrange for the address of an external symbol to 303e72e445ed574c684ddef1aa15e0e245a43c6a2beChris Lattner/// be emitted to the current location in the function, and allow it to be PC 304e72e445ed574c684ddef1aa15e0e245a43c6a2beChris Lattner/// relative. 305434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopestemplate<class CodeEmitter> 306434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopesvoid Emitter<CodeEmitter>::emitExternalSymbolAddress(const char *ES, 307434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopes unsigned Reloc) { 3082a3e08b5961353fa3faeadf81f481ae9f5463427Evan Cheng intptr_t RelocCST = (Reloc == X86::reloc_picrel_word) ? PICBaseOffset : 0; 30985bb54f96421461aaafcde83b6302530179337e9Evan Phoenix 31085bb54f96421461aaafcde83b6302530179337e9Evan Phoenix // X86 never needs stubs because instruction selection will always pick 31185bb54f96421461aaafcde83b6302530179337e9Evan Phoenix // an instruction sequence that is large enough to hold any address 31285bb54f96421461aaafcde83b6302530179337e9Evan Phoenix // to a symbol. 31385bb54f96421461aaafcde83b6302530179337e9Evan Phoenix // (see X86ISelLowering.cpp, near 2039: X86TargetLowering::LowerCall) 31485bb54f96421461aaafcde83b6302530179337e9Evan Phoenix bool NeedStub = false; 3155a032de387831b9de3a707292eade95934938da9Chris Lattner MCE.addRelocation(MachineRelocation::getExtSym(MCE.getCurrentPCOffset(), 31685bb54f96421461aaafcde83b6302530179337e9Evan Phoenix Reloc, ES, RelocCST, 31785bb54f96421461aaafcde83b6302530179337e9Evan Phoenix 0, NeedStub)); 31819f2ffce4598c4c70f32eed7c6740b43185200b1Evan Cheng if (Reloc == X86::reloc_absolute_dword) 319c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman MCE.emitDWordLE(0); 320c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman else 32119f2ffce4598c4c70f32eed7c6740b43185200b1Evan Cheng MCE.emitWordLE(0); 322e72e445ed574c684ddef1aa15e0e245a43c6a2beChris Lattner} 32304b0b309c4d6e3a381edbb2db6a23a0009661dd8Chris Lattner 32419f2ffce4598c4c70f32eed7c6740b43185200b1Evan Cheng/// emitConstPoolAddress - Arrange for the address of an constant pool 32525ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng/// to be emitted to the current location in the function, and allow it to be PC 32625ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng/// relative. 327434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopestemplate<class CodeEmitter> 328434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopesvoid Emitter<CodeEmitter>::emitConstPoolAddress(unsigned CPI, unsigned Reloc, 329c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman intptr_t Disp /* = 0 */, 33002aabbf96b1f22144afe2bec8ad480a9b803f6b8Evan Cheng intptr_t PCAdj /* = 0 */) { 331be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng intptr_t RelocCST = 0; 33202aabbf96b1f22144afe2bec8ad480a9b803f6b8Evan Cheng if (Reloc == X86::reloc_picrel_word) 3332a3e08b5961353fa3faeadf81f481ae9f5463427Evan Cheng RelocCST = PICBaseOffset; 334be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng else if (Reloc == X86::reloc_pcrel_word) 335be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng RelocCST = PCAdj; 33625ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng MCE.addRelocation(MachineRelocation::getConstPool(MCE.getCurrentPCOffset(), 337be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng Reloc, CPI, RelocCST)); 338c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman // The relocated value will be added to the displacement 339fd00debde0353b9e567ca4f68d62ad8aae5bf512Evan Cheng if (Reloc == X86::reloc_absolute_dword) 340c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman MCE.emitDWordLE(Disp); 341c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman else 342c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman MCE.emitWordLE((int32_t)Disp); 34325ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng} 34425ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng 34519f2ffce4598c4c70f32eed7c6740b43185200b1Evan Cheng/// emitJumpTableAddress - Arrange for the address of a jump table to 34625ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng/// be emitted to the current location in the function, and allow it to be PC 34725ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng/// relative. 348434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopestemplate<class CodeEmitter> 349434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopesvoid Emitter<CodeEmitter>::emitJumpTableAddress(unsigned JTI, unsigned Reloc, 35002aabbf96b1f22144afe2bec8ad480a9b803f6b8Evan Cheng intptr_t PCAdj /* = 0 */) { 351be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng intptr_t RelocCST = 0; 35202aabbf96b1f22144afe2bec8ad480a9b803f6b8Evan Cheng if (Reloc == X86::reloc_picrel_word) 3532a3e08b5961353fa3faeadf81f481ae9f5463427Evan Cheng RelocCST = PICBaseOffset; 354be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng else if (Reloc == X86::reloc_pcrel_word) 355be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng RelocCST = PCAdj; 35625ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng MCE.addRelocation(MachineRelocation::getJumpTable(MCE.getCurrentPCOffset(), 357be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng Reloc, JTI, RelocCST)); 358c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman // The relocated value will be added to the displacement 359fd00debde0353b9e567ca4f68d62ad8aae5bf512Evan Cheng if (Reloc == X86::reloc_absolute_dword) 360c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman MCE.emitDWordLE(0); 361c9f3cc3bdaf1ec134dec1f718e7f2e735b34b17bDan Gohman else 362fd00debde0353b9e567ca4f68d62ad8aae5bf512Evan Cheng MCE.emitWordLE(0); 36325ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng} 36425ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng 365ea1ddab58e9db323294012628a56275da0e930a7Chris Lattnerinline static unsigned char ModRMByte(unsigned Mod, unsigned RegOpcode, 366ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner unsigned RM) { 367ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner assert(Mod < 4 && RegOpcode < 8 && RM < 8 && "ModRM Fields out of range!"); 368ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner return RM | (RegOpcode << 3) | (Mod << 6); 369ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner} 370ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner 371434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopestemplate<class CodeEmitter> 372434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopesvoid Emitter<CodeEmitter>::emitRegModRMByte(unsigned ModRMReg, 373434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopes unsigned RegOpcodeFld){ 3747abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao MCE.emitByte(ModRMByte(3, RegOpcodeFld, getX86RegNum(ModRMReg))); 375ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner} 376ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner 377434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopestemplate<class CodeEmitter> 378434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopesvoid Emitter<CodeEmitter>::emitRegModRMByte(unsigned RegOpcodeFld) { 3794b299d4ebdf57c56ca336d9aca6f2ad7d8175995Evan Cheng MCE.emitByte(ModRMByte(3, RegOpcodeFld, 0)); 3804b299d4ebdf57c56ca336d9aca6f2ad7d8175995Evan Cheng} 3814b299d4ebdf57c56ca336d9aca6f2ad7d8175995Evan Cheng 382434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopestemplate<class CodeEmitter> 383bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszakvoid Emitter<CodeEmitter>::emitSIBByte(unsigned SS, 384434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopes unsigned Index, 385434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopes unsigned Base) { 386ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner // SIB byte is in the same format as the ModRMByte... 387ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner MCE.emitByte(ModRMByte(SS, Index, Base)); 388ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner} 389ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner 390434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopestemplate<class CodeEmitter> 391434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopesvoid Emitter<CodeEmitter>::emitConstant(uint64_t Val, unsigned Size) { 392ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner // Output the constant in little endian byte order... 393ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner for (unsigned i = 0; i != Size; ++i) { 394ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner MCE.emitByte(Val & 255); 395ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner Val >>= 8; 396ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner } 397ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner} 398ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner 399bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak/// isDisp8 - Return true if this signed displacement fits in a 8-bit 400bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak/// sign-extended field. 401ea1ddab58e9db323294012628a56275da0e930a7Chris Lattnerstatic bool isDisp8(int Value) { 402ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner return Value == (signed char)Value; 403ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner} 404ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner 4058a537121cbb3087294ca9d3891b8e2eef53a54abChris Lattnerstatic bool gvNeedsNonLazyPtr(const MachineOperand &GVOp, 4068a537121cbb3087294ca9d3891b8e2eef53a54abChris Lattner const TargetMachine &TM) { 4078a537121cbb3087294ca9d3891b8e2eef53a54abChris Lattner // For Darwin-64, simulate the linktime GOT by using the same non-lazy-pointer 408ec867a22b3b3e131187e105b3639bcf5eb101590Dale Johannesen // mechanism as 32-bit mode. 409bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak if (TM.getSubtarget<X86Subtarget>().is64Bit() && 4108a537121cbb3087294ca9d3891b8e2eef53a54abChris Lattner !TM.getSubtarget<X86Subtarget>().isTargetDarwin()) 4118a537121cbb3087294ca9d3891b8e2eef53a54abChris Lattner return false; 412bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 41307406346ebbf8a958a956eb05c1e04faedfe1e63Chris Lattner // Return true if this is a reference to a stub containing the address of the 41407406346ebbf8a958a956eb05c1e04faedfe1e63Chris Lattner // global, not the global itself. 4153b6b36d6f54e780a2947cb1b9efe4eed7c40dc11Chris Lattner return isGlobalStubReference(GVOp.getTargetFlags()); 416be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng} 417be8c03fc66b75fa775e1f47d62a1b0d803fced1cEvan Cheng 418434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopestemplate<class CodeEmitter> 419434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopesvoid Emitter<CodeEmitter>::emitDisplacementField(const MachineOperand *RelocOp, 420e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes int DispVal, 421e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes intptr_t Adj /* = 0 */, 422e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes bool IsPCRel /* = true */) { 4230e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner // If this is a simple integer displacement that doesn't require a relocation, 4240e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner // emit it now. 4250e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner if (!RelocOp) { 4260e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner emitConstant(DispVal, 4); 4270e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner return; 4280e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner } 429e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes 4300e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner // Otherwise, this is something that requires a relocation. Emit it as such 4310e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner // now. 4320378b72609c1a257fa1666d7b4a546b423daadfbDaniel Dunbar unsigned RelocType = Is64BitMode ? 4330378b72609c1a257fa1666d7b4a546b423daadfbDaniel Dunbar (IsPCRel ? X86::reloc_pcrel_word : X86::reloc_absolute_word_sext) 4340378b72609c1a257fa1666d7b4a546b423daadfbDaniel Dunbar : (IsPIC ? X86::reloc_picrel_word : X86::reloc_absolute_word); 435d735b8019b0f297d7c14b55adcd887af24d8e602Dan Gohman if (RelocOp->isGlobal()) { 43625ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng // In 64-bit static small code model, we could potentially emit absolute. 437e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes // But it's probably not beneficial. If the MCE supports using RIP directly 438bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak // do it, otherwise fallback to absolute (this is determined by IsPCRel). 43985db3a96b49e4fdb130b55f27e1d5596e771795aBill Wendling // 89 05 00 00 00 00 mov %eax,0(%rip) # PC-relative 44085db3a96b49e4fdb130b55f27e1d5596e771795aBill Wendling // 89 04 25 00 00 00 00 mov %eax,0x0 # Absolute 4418a537121cbb3087294ca9d3891b8e2eef53a54abChris Lattner bool Indirect = gvNeedsNonLazyPtr(*RelocOp, TM); 4420378b72609c1a257fa1666d7b4a546b423daadfbDaniel Dunbar emitGlobalAddress(RelocOp->getGlobal(), RelocType, RelocOp->getOffset(), 443d1ba06bf131a9d217426529d2e28af1f2eeed47aJeffrey Yasskin Adj, Indirect); 4444e8d5fe51021e32450b35c7003f185dd1f56e11aDaniel Dunbar } else if (RelocOp->isSymbol()) { 4450378b72609c1a257fa1666d7b4a546b423daadfbDaniel Dunbar emitExternalSymbolAddress(RelocOp->getSymbolName(), RelocType); 446d735b8019b0f297d7c14b55adcd887af24d8e602Dan Gohman } else if (RelocOp->isCPI()) { 4470378b72609c1a257fa1666d7b4a546b423daadfbDaniel Dunbar emitConstPoolAddress(RelocOp->getIndex(), RelocType, 448e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes RelocOp->getOffset(), Adj); 4490e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner } else { 4500378b72609c1a257fa1666d7b4a546b423daadfbDaniel Dunbar assert(RelocOp->isJTI() && "Unexpected machine operand!"); 4510378b72609c1a257fa1666d7b4a546b423daadfbDaniel Dunbar emitJumpTableAddress(RelocOp->getIndex(), RelocType, Adj); 4520e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner } 4530e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner} 4540e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner 455434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopestemplate<class CodeEmitter> 456434dd4fd94f5f248492c675e4285e7d67342d4c4Bruno Cardoso Lopesvoid Emitter<CodeEmitter>::emitMemModRMByte(const MachineInstr &MI, 457f5af556c18fa44f073367e0ce7093df507810adaChris Lattner unsigned Op,unsigned RegOpcodeField, 458f5af556c18fa44f073367e0ce7093df507810adaChris Lattner intptr_t PCAdj) { 4598cce7cd0aebda3f286b322d8c4dc034bb2ee129cChris Lattner const MachineOperand &Op3 = MI.getOperand(Op+3); 4608cce7cd0aebda3f286b322d8c4dc034bb2ee129cChris Lattner int DispVal = 0; 4610e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner const MachineOperand *DispForReloc = 0; 462bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 4630e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner // Figure out what sort of displacement we have to handle here. 464d735b8019b0f297d7c14b55adcd887af24d8e602Dan Gohman if (Op3.isGlobal()) { 4650e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner DispForReloc = &Op3; 4664e8d5fe51021e32450b35c7003f185dd1f56e11aDaniel Dunbar } else if (Op3.isSymbol()) { 4674e8d5fe51021e32450b35c7003f185dd1f56e11aDaniel Dunbar DispForReloc = &Op3; 468d735b8019b0f297d7c14b55adcd887af24d8e602Dan Gohman } else if (Op3.isCPI()) { 469e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes if (!MCE.earlyResolveAddresses() || Is64BitMode || IsPIC) { 47025ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng DispForReloc = &Op3; 47125ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng } else { 4728aa797aa51cd4ea1ec6f46f4891a6897944b75b2Chris Lattner DispVal += MCE.getConstantPoolEntryAddress(Op3.getIndex()); 47325ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng DispVal += Op3.getOffset(); 47425ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng } 475d735b8019b0f297d7c14b55adcd887af24d8e602Dan Gohman } else if (Op3.isJTI()) { 476e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes if (!MCE.earlyResolveAddresses() || Is64BitMode || IsPIC) { 47725ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng DispForReloc = &Op3; 47825ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng } else { 4798aa797aa51cd4ea1ec6f46f4891a6897944b75b2Chris Lattner DispVal += MCE.getJumpTableEntryAddress(Op3.getIndex()); 48025ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng } 4818cce7cd0aebda3f286b322d8c4dc034bb2ee129cChris Lattner } else { 4820e42d81a838bcccd3ed6aacd011a172633ce6606Chris Lattner DispVal = Op3.getImm(); 4838cce7cd0aebda3f286b322d8c4dc034bb2ee129cChris Lattner } 4848cce7cd0aebda3f286b322d8c4dc034bb2ee129cChris Lattner 48507306de06ec1bdc09bc09046ac868291523fbf63Chris Lattner const MachineOperand &Base = MI.getOperand(Op); 48607306de06ec1bdc09bc09046ac868291523fbf63Chris Lattner const MachineOperand &Scale = MI.getOperand(Op+1); 48707306de06ec1bdc09bc09046ac868291523fbf63Chris Lattner const MachineOperand &IndexReg = MI.getOperand(Op+2); 48807306de06ec1bdc09bc09046ac868291523fbf63Chris Lattner 489140a4c486829e1ade130ca1ce5ca5c934a79523eEvan Cheng unsigned BaseReg = Base.getReg(); 490bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 491a040fffefbc7f653d68154b16b8d3c2ee2a6a639Bill Wendling // Handle %rip relative addressing. 492a040fffefbc7f653d68154b16b8d3c2ee2a6a639Bill Wendling if (BaseReg == X86::RIP || 493a040fffefbc7f653d68154b16b8d3c2ee2a6a639Bill Wendling (Is64BitMode && DispForReloc)) { // [disp32+RIP] in X86-64 mode 494a040fffefbc7f653d68154b16b8d3c2ee2a6a639Bill Wendling assert(IndexReg.getReg() == 0 && Is64BitMode && 495a040fffefbc7f653d68154b16b8d3c2ee2a6a639Bill Wendling "Invalid rip-relative address"); 496a040fffefbc7f653d68154b16b8d3c2ee2a6a639Bill Wendling MCE.emitByte(ModRMByte(0, RegOpcodeField, 5)); 497a040fffefbc7f653d68154b16b8d3c2ee2a6a639Bill Wendling emitDisplacementField(DispForReloc, DispVal, PCAdj, true); 498a040fffefbc7f653d68154b16b8d3c2ee2a6a639Bill Wendling return; 499a040fffefbc7f653d68154b16b8d3c2ee2a6a639Bill Wendling } 500e831b6b802c3c95227dcd8baa7614e1befd026c0Chris Lattner 501e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes // Indicate that the displacement will use an pcrel or absolute reference 502e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes // by default. MCEs able to resolve addresses on-the-fly use pcrel by default 503e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes // while others, unless explicit asked to use RIP, use absolute references. 504e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes bool IsPCRel = MCE.earlyResolveAddresses() ? true : false; 505e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes 506ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner // Is a SIB byte needed? 507bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak // If no BaseReg, issue a RIP relative instruction only if the MCE can 508e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes // resolve addresses on-the-fly, otherwise use SIB (Intel Manual 2A, table 509e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes // 2-7) and absolute references. 510ecfb3c3d665480e04c051b4b229607768612d28dChris Lattner unsigned BaseRegNo = -1U; 511ecfb3c3d665480e04c051b4b229607768612d28dChris Lattner if (BaseReg != 0 && BaseReg != X86::RIP) 5127abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao BaseRegNo = getX86RegNum(BaseReg); 5135526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner 5149e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner if (// The SIB byte must be used if there is an index register. 515bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak IndexReg.getReg() == 0 && 5165526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner // The SIB byte must be used if the base is ESP/RSP/R12, all of which 5175526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner // encode to an R/M value of 4, which indicates that a SIB byte is 5185526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner // present. 5195526b699014b0b58e08d7d43e28084589eda26f2Chris Lattner BaseRegNo != N86::ESP && 5209e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // If there is no base register and we're in 64-bit mode, we need a SIB 5219e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // byte to emit an addr that is just 'disp32' (the non-RIP relative form). 5229e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner (!Is64BitMode || BaseReg != 0)) { 5239e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner if (BaseReg == 0 || // [disp32] in X86-32 mode 5249e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner BaseReg == X86::RIP) { // [disp32+RIP] in X86-64 mode 525ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner MCE.emitByte(ModRMByte(0, RegOpcodeField, 5)); 526e55fef36a93badf6c4925ea2455a1ca6b361357eBruno Cardoso Lopes emitDisplacementField(DispForReloc, DispVal, PCAdj, true); 5279e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner return; 528ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner } 529bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 5309e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // If the base is not EBP/ESP and there is no displacement, use simple 5319e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // indirect register encoding, this handles addresses like [EAX]. The 5329e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // encoding for [EBP] with no displacement means [disp32] so we handle it 5339e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // by emitting a displacement of 0 below. 5349e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner if (!DispForReloc && DispVal == 0 && BaseRegNo != N86::EBP) { 5359e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner MCE.emitByte(ModRMByte(0, RegOpcodeField, BaseRegNo)); 5369e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner return; 537ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner } 538bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 5399e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // Otherwise, if the displacement fits in a byte, encode as [REG+disp8]. 5409e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner if (!DispForReloc && isDisp8(DispVal)) { 5419e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner MCE.emitByte(ModRMByte(1, RegOpcodeField, BaseRegNo)); 5420e57629a933a43d8adcba8368c4e3f90fe0f4e49Chris Lattner emitConstant(DispVal, 1); 5439e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner return; 544ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner } 545bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 5469e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // Otherwise, emit the most general non-SIB encoding: [REG+disp32] 5479e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner MCE.emitByte(ModRMByte(2, RegOpcodeField, BaseRegNo)); 5489e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner emitDisplacementField(DispForReloc, DispVal, PCAdj, IsPCRel); 5499e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner return; 5509e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner } 551bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 5529e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // Otherwise we need a SIB byte, so start by outputting the ModR/M byte first. 5539e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner assert(IndexReg.getReg() != X86::ESP && 5549e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner IndexReg.getReg() != X86::RSP && "Cannot use ESP as index reg!"); 5559e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner 5569e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner bool ForceDisp32 = false; 5579e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner bool ForceDisp8 = false; 5589e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner if (BaseReg == 0) { 5599e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // If there is no base register, we emit the special case SIB byte with 5609e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // MOD=0, BASE=4, to JUST get the index, scale, and displacement. 5619e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner MCE.emitByte(ModRMByte(0, RegOpcodeField, 4)); 5629e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner ForceDisp32 = true; 5639e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner } else if (DispForReloc) { 5649e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // Emit the normal disp32 encoding. 5659e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner MCE.emitByte(ModRMByte(2, RegOpcodeField, 4)); 5669e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner ForceDisp32 = true; 567a040fffefbc7f653d68154b16b8d3c2ee2a6a639Bill Wendling } else if (DispVal == 0 && BaseRegNo != N86::EBP) { 5689e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // Emit no displacement ModR/M byte 5699e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner MCE.emitByte(ModRMByte(0, RegOpcodeField, 4)); 5709e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner } else if (isDisp8(DispVal)) { 5719e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // Emit the disp8 encoding... 5729e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner MCE.emitByte(ModRMByte(1, RegOpcodeField, 4)); 5739e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner ForceDisp8 = true; // Make sure to force 8 bit disp if Base=EBP 5749e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner } else { 5759e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // Emit the normal disp32 encoding... 5769e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner MCE.emitByte(ModRMByte(2, RegOpcodeField, 4)); 5779e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner } 5789e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner 5799e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // Calculate what the SS field value should be... 580a44defeb2208376ca3113ffdddc391570ba865b8Jeffrey Yasskin static const unsigned SSTable[] = { ~0U, 0, 1, ~0U, 2, ~0U, ~0U, ~0U, 3 }; 5819e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner unsigned SS = SSTable[Scale.getImm()]; 5829e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner 5839e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner if (BaseReg == 0) { 584bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak // Handle the SIB byte for the case where there is no base, see Intel 5859e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // Manual 2A, table 2-7. The displacement has already been output. 5869e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner unsigned IndexRegNo; 5879e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner if (IndexReg.getReg()) 5887abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao IndexRegNo = getX86RegNum(IndexReg.getReg()); 5899e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner else // Examples: [ESP+1*<noreg>+4] or [scaled idx]+disp32 (MOD=0,BASE=5) 5909e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner IndexRegNo = 4; 5919e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner emitSIBByte(SS, IndexRegNo, 5); 5929e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner } else { 5937abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao unsigned BaseRegNo = getX86RegNum(BaseReg); 5949e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner unsigned IndexRegNo; 5959e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner if (IndexReg.getReg()) 5967abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao IndexRegNo = getX86RegNum(IndexReg.getReg()); 5979e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner else 5989e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner IndexRegNo = 4; // For example [ESP+1*<noreg>+4] 5999e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner emitSIBByte(SS, IndexRegNo, BaseRegNo); 6009e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner } 6019e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner 6029e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner // Do we need to output a displacement? 6039e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner if (ForceDisp8) { 6049e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner emitConstant(DispVal, 1); 6059e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner } else if (DispVal != 0 || ForceDisp32) { 6069e8528fc5cd7426884c1708d921d4608ac3878b7Chris Lattner emitDisplacementField(DispForReloc, DispVal, PCAdj, IsPCRel); 607ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner } 608ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner} 609ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner 6103f3f6b067c62d512e4e0b0c54bfc331bd34be338Eli Friedmanstatic const MCInstrDesc *UpdateOp(MachineInstr &MI, const X86InstrInfo *II, 6113f3f6b067c62d512e4e0b0c54bfc331bd34be338Eli Friedman unsigned Opcode) { 6123f3f6b067c62d512e4e0b0c54bfc331bd34be338Eli Friedman const MCInstrDesc *Desc = &II->get(Opcode); 6133f3f6b067c62d512e4e0b0c54bfc331bd34be338Eli Friedman MI.setDesc(*Desc); 6143f3f6b067c62d512e4e0b0c54bfc331bd34be338Eli Friedman return Desc; 6153f3f6b067c62d512e4e0b0c54bfc331bd34be338Eli Friedman} 6163f3f6b067c62d512e4e0b0c54bfc331bd34be338Eli Friedman 6176942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper/// Is16BitMemOperand - Return true if the specified instruction has 6186942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper/// a 16-bit memory operand. Op specifies the operand # of the memoperand. 6196942f706aad24c45b55d30256250e4ae472b3b07Pete Cooperstatic bool Is16BitMemOperand(const MachineInstr &MI, unsigned Op) { 6206942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MachineOperand &BaseReg = MI.getOperand(Op+X86::AddrBaseReg); 6216942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MachineOperand &IndexReg = MI.getOperand(Op+X86::AddrIndexReg); 6226942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 6236942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if ((BaseReg.getReg() != 0 && 6246942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper X86MCRegisterClasses[X86::GR16RegClassID].contains(BaseReg.getReg())) || 6256942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper (IndexReg.getReg() != 0 && 6266942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper X86MCRegisterClasses[X86::GR16RegClassID].contains(IndexReg.getReg()))) 6276942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper return true; 6286942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper return false; 6296942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper} 63017ed8fa63d57bbac2aa0533e510969fe5155b22aEvan Cheng 6316942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper/// Is32BitMemOperand - Return true if the specified instruction has 6326942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper/// a 32-bit memory operand. Op specifies the operand # of the memoperand. 6336942f706aad24c45b55d30256250e4ae472b3b07Pete Cooperstatic bool Is32BitMemOperand(const MachineInstr &MI, unsigned Op) { 6346942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MachineOperand &BaseReg = MI.getOperand(Op+X86::AddrBaseReg); 6356942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MachineOperand &IndexReg = MI.getOperand(Op+X86::AddrIndexReg); 6366942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 6376942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if ((BaseReg.getReg() != 0 && 6386942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper X86MCRegisterClasses[X86::GR32RegClassID].contains(BaseReg.getReg())) || 6396942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper (IndexReg.getReg() != 0 && 6406942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper X86MCRegisterClasses[X86::GR32RegClassID].contains(IndexReg.getReg()))) 6416942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper return true; 6426942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper return false; 6436942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper} 64432360a7e21a4454aa7014992213823fb4319905aJeffrey Yasskin 6456942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper/// Is64BitMemOperand - Return true if the specified instruction has 6466942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper/// a 64-bit memory operand. Op specifies the operand # of the memoperand. 6476942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper#ifndef NDEBUG 6486942f706aad24c45b55d30256250e4ae472b3b07Pete Cooperstatic bool Is64BitMemOperand(const MachineInstr &MI, unsigned Op) { 6496942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MachineOperand &BaseReg = MI.getOperand(Op+X86::AddrBaseReg); 6506942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MachineOperand &IndexReg = MI.getOperand(Op+X86::AddrIndexReg); 6516942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 6526942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if ((BaseReg.getReg() != 0 && 6536942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper X86MCRegisterClasses[X86::GR64RegClassID].contains(BaseReg.getReg())) || 6546942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper (IndexReg.getReg() != 0 && 6556942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper X86MCRegisterClasses[X86::GR64RegClassID].contains(IndexReg.getReg()))) 6566942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper return true; 6576942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper return false; 6586942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper} 6596942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper#endif 66076041ce5155ca4aab443d139d7ad820ae06cbe09Chris Lattner 6616942f706aad24c45b55d30256250e4ae472b3b07Pete Coopertemplate<class CodeEmitter> 6626942f706aad24c45b55d30256250e4ae472b3b07Pete Coopervoid Emitter<CodeEmitter>::emitOpcodePrefix(uint64_t TSFlags, 6636942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper int MemOperand, 6646942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MachineInstr &MI, 6656942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MCInstrDesc *Desc) const { 666ea7da50e5a7f291295c10d91fc3fdba76d339579Andrew Lenharth // Emit the lock opcode prefix as needed. 667f5af556c18fa44f073367e0ce7093df507810adaChris Lattner if (Desc->TSFlags & X86II::LOCK) 668f5af556c18fa44f073367e0ce7093df507810adaChris Lattner MCE.emitByte(0xF0); 669ea7da50e5a7f291295c10d91fc3fdba76d339579Andrew Lenharth 670a4bb48adc39eb6ae7a502433397ba3476efc0454Duncan Sands // Emit segment override opcode prefix as needed. 6716942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper emitSegmentOverridePrefix(TSFlags, MemOperand, MI); 672ef93cecd80ebdecb0ea2b2c316370998151308e2Anton Korobeynikov 673915e5e56d7cc8e140d33202eed6244ed0356ed1fChris Lattner // Emit the repeat opcode prefix as needed. 674f5af556c18fa44f073367e0ce7093df507810adaChris Lattner if ((Desc->TSFlags & X86II::Op0Mask) == X86II::REP) 675f5af556c18fa44f073367e0ce7093df507810adaChris Lattner MCE.emitByte(0xF3); 676915e5e56d7cc8e140d33202eed6244ed0356ed1fChris Lattner 67725ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng // Emit the address size opcode prefix as needed. 6786942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper bool need_address_override; 6796942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (TSFlags & X86II::AdSize) { 6806942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper need_address_override = true; 6816942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } else if (MemOperand == -1) { 6826942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper need_address_override = false; 6836942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } else if (Is64BitMode) { 6846942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper assert(!Is16BitMemOperand(MI, MemOperand)); 6856942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper need_address_override = Is32BitMemOperand(MI, MemOperand); 6866942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } else { 6876942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper assert(!Is64BitMemOperand(MI, MemOperand)); 6886942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper need_address_override = Is16BitMemOperand(MI, MemOperand); 6896942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } 6906942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 6916942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (need_address_override) 692f5af556c18fa44f073367e0ce7093df507810adaChris Lattner MCE.emitByte(0x67); 69325ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng 6946942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // Emit the operand size opcode prefix as needed. 6956942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (TSFlags & X86II::OpSize) 6966942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(0x66); 6976942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 69825ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng bool Need0FPrefix = false; 69919f2ffce4598c4c70f32eed7c6740b43185200b1Evan Cheng switch (Desc->TSFlags & X86II::Op0Mask) { 7006942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::TB: // Two-byte opcode prefix 7016942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::T8: // 0F 38 7026942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::TA: // 0F 3A 7036942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::A6: // 0F A6 7046942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::A7: // 0F A7 7056942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper Need0FPrefix = true; 7066942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 7076942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::REP: break; // already handled. 7086942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::T8XS: // F3 0F 38 7096942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::XS: // F3 0F 7106942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(0xF3); 7116942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper Need0FPrefix = true; 7126942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 7136942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::T8XD: // F2 0F 38 7146942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::TAXD: // F2 0F 3A 7156942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::XD: // F2 0F 7166942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(0xF2); 7176942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper Need0FPrefix = true; 7186942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 7196942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::D8: case X86II::D9: case X86II::DA: case X86II::DB: 7206942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::DC: case X86II::DD: case X86II::DE: case X86II::DF: 7216942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(0xD8+ 7226942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper (((Desc->TSFlags & X86II::Op0Mask)-X86II::D8) 7236942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper >> X86II::Op0Shift)); 7246942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; // Two-byte opcode prefix 7256942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper default: llvm_unreachable("Invalid prefix!"); 7266942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case 0: break; // No prefix! 7275ada8df4882b2a0800157c07530adb0feeddf4f1Chris Lattner } 72876041ce5155ca4aab443d139d7ad820ae06cbe09Chris Lattner 729f5af556c18fa44f073367e0ce7093df507810adaChris Lattner // Handle REX prefix. 73025ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng if (Is64BitMode) { 731456fdaf0cea4bd195eacc9796fedb71b62290cfeChris Lattner if (unsigned REX = determineREX(MI)) 73225ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng MCE.emitByte(0x40 | REX); 73325ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng } 73425ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng 73525ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng // 0x0F escape code must be emitted just before the opcode. 73625ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng if (Need0FPrefix) 73725ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng MCE.emitByte(0x0F); 73825ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng 739ab394bdcc0e89ce6dafae45fb7dd7420e77f14d7Evan Cheng switch (Desc->TSFlags & X86II::Op0Mask) { 7406942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::T8XD: // F2 0F 38 7416942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::T8XS: // F3 0F 38 7426942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::T8: // 0F 38 7436942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(0x38); 7446942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 7456942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::TAXD: // F2 0F 38 7466942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::TA: // 0F 3A 7476942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(0x3A); 7486942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 7496942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::A6: // 0F A6 7506942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(0xA6); 7516942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 7526942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::A7: // 0F A7 7536942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(0xA7); 7546942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 7556942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } 7566942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper} 7576942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 7586942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper// On regular x86, both XMM0-XMM7 and XMM8-XMM15 are encoded in the range 7596942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper// 0-7 and the difference between the 2 groups is given by the REX prefix. 7606942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper// In the VEX prefix, registers are seen sequencially from 0-15 and encoded 7616942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper// in 1's complement form, example: 7626942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper// 7636942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper// ModRM field => XMM9 => 1 7646942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper// VEX.VVVV => XMM9 => ~9 7656942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper// 7666942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper// See table 4-35 of Intel AVX Programming Reference for details. 7677abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liaotemplate<class CodeEmitter> 7687abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liaounsigned char 7697abf67a092c0a75d6d1631766d6a8ef14e38d526Michael LiaoEmitter<CodeEmitter>::getVEXRegisterEncoding(const MachineInstr &MI, 7707abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao unsigned OpNum) const { 7716942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned SrcReg = MI.getOperand(OpNum).getReg(); 7727abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao unsigned SrcRegNum = getX86RegNum(MI.getOperand(OpNum).getReg()); 7736942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (X86II::isX86_64ExtendedReg(SrcReg)) 7746942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper SrcRegNum |= 8; 7756942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 7766942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // The registers represented through VEX_VVVV should 7776942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // be encoded in 1's complement form. 7786942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper return (~SrcRegNum) & 0xf; 7796942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper} 7806942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 7816942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper/// EmitSegmentOverridePrefix - Emit segment override opcode prefix as needed 7826942f706aad24c45b55d30256250e4ae472b3b07Pete Coopertemplate<class CodeEmitter> 7836942f706aad24c45b55d30256250e4ae472b3b07Pete Coopervoid Emitter<CodeEmitter>::emitSegmentOverridePrefix(uint64_t TSFlags, 7846942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper int MemOperand, 7856942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MachineInstr &MI) const { 7866942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper switch (TSFlags & X86II::SegOvrMask) { 7876942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper default: llvm_unreachable("Invalid segment!"); 7886942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case 0: 7896942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // No segment override, check for explicit one on memory operand. 7906942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (MemOperand != -1) { // If the instruction has a memory operand. 7916942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper switch (MI.getOperand(MemOperand+X86::AddrSegmentReg).getReg()) { 7926942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper default: llvm_unreachable("Unknown segment register!"); 7936942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case 0: break; 7946942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::CS: MCE.emitByte(0x2E); break; 7956942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::SS: MCE.emitByte(0x36); break; 7966942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::DS: MCE.emitByte(0x3E); break; 7976942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::ES: MCE.emitByte(0x26); break; 7986942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::FS: MCE.emitByte(0x64); break; 7996942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::GS: MCE.emitByte(0x65); break; 8006942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } 8016942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } 8026942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 8036942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::FS: 8046942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(0x64); 8056942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 8066942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::GS: 8076942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(0x65); 8086942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 8096942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } 8106942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper} 8116942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8126942f706aad24c45b55d30256250e4ae472b3b07Pete Coopertemplate<class CodeEmitter> 8136942f706aad24c45b55d30256250e4ae472b3b07Pete Coopervoid Emitter<CodeEmitter>::emitVEXOpcodePrefix(uint64_t TSFlags, 8146942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper int MemOperand, 8156942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MachineInstr &MI, 8166942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MCInstrDesc *Desc) const { 8176942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper bool HasVEX_4V = (TSFlags >> X86II::VEXShift) & X86II::VEX_4V; 8186942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper bool HasVEX_4VOp3 = (TSFlags >> X86II::VEXShift) & X86II::VEX_4VOp3; 8199d3f3c5f400578855f6f7b71670cb8514b4fac0fCraig Topper bool HasMemOp4 = (TSFlags >> X86II::VEXShift) & X86II::MemOp4; 8206942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8216942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // VEX_R: opcode externsion equivalent to REX.R in 8226942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 1's complement (inverted) form 8236942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 8246942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 1: Same as REX_R=0 (must be 1 in 32-bit mode) 8256942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0: Same as REX_R=1 (64 bit mode only) 8266942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 8276942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned char VEX_R = 0x1; 8286942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8296942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // VEX_X: equivalent to REX.X, only used when a 8306942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // register is used for index in SIB Byte. 8316942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 8326942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 1: Same as REX.X=0 (must be 1 in 32-bit mode) 8336942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0: Same as REX.X=1 (64-bit mode only) 8346942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned char VEX_X = 0x1; 8356942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8366942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // VEX_B: 8376942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 8386942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 1: Same as REX_B=0 (ignored in 32-bit mode) 8396942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0: Same as REX_B=1 (64 bit mode only) 8406942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 8416942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned char VEX_B = 0x1; 8426942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8436942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // VEX_W: opcode specific (use like REX.W, or used for 8446942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // opcode extension, or ignored, depending on the opcode byte) 8456942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned char VEX_W = 0; 8466942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8476942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // XOP: Use XOP prefix byte 0x8f instead of VEX. 8486942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned char XOP = 0; 8496942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8506942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // VEX_5M (VEX m-mmmmm field): 8516942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 8526942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0b00000: Reserved for future use 8536942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0b00001: implied 0F leading opcode 8546942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0b00010: implied 0F 38 leading opcode bytes 8556942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0b00011: implied 0F 3A leading opcode bytes 8566942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0b00100-0b11111: Reserved for future use 8576942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0b01000: XOP map select - 08h instructions with imm byte 8586942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0b10001: XOP map select - 09h instructions with no imm byte 8596942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned char VEX_5M = 0x1; 8606942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8616942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // VEX_4V (VEX vvvv field): a register specifier 8626942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // (in 1's complement form) or 1111 if unused. 8636942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned char VEX_4V = 0xf; 8646942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8656942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // VEX_L (Vector Length): 8666942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 8676942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0: scalar or 128-bit vector 8686942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 1: 256-bit vector 8696942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 8706942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned char VEX_L = 0; 8716942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8726942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // VEX_PP: opcode extension providing equivalent 8736942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // functionality of a SIMD prefix 8746942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 8756942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0b00: None 8766942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0b01: 66 8776942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0b10: F3 8786942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 0b11: F2 8796942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 8806942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned char VEX_PP = 0; 8816942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8826942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // Encode the operand size opcode prefix as needed. 8836942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (TSFlags & X86II::OpSize) 8846942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_PP = 0x01; 8856942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8866942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if ((TSFlags >> X86II::VEXShift) & X86II::VEX_W) 8876942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_W = 1; 8886942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8896942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if ((TSFlags >> X86II::VEXShift) & X86II::XOP) 8906942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper XOP = 1; 8916942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8926942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if ((TSFlags >> X86II::VEXShift) & X86II::VEX_L) 8936942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_L = 1; 8946942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 8956942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper switch (TSFlags & X86II::Op0Mask) { 8966942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper default: llvm_unreachable("Invalid prefix!"); 8976942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::T8: // 0F 38 8986942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_5M = 0x2; 8996942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 9006942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::TA: // 0F 3A 9016942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_5M = 0x3; 9026942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 9036942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::T8XS: // F3 0F 38 9046942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_PP = 0x2; 9056942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_5M = 0x2; 9066942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 9076942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::T8XD: // F2 0F 38 9086942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_PP = 0x3; 9096942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_5M = 0x2; 9106942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 9116942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::TAXD: // F2 0F 3A 9126942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_PP = 0x3; 9136942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_5M = 0x3; 9146942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 9156942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::XS: // F3 0F 9166942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_PP = 0x2; 9176942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 9186942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::XD: // F2 0F 9196942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_PP = 0x3; 9206942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 9216942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::XOP8: 9226942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_5M = 0x8; 9236942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 9246942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::XOP9: 9256942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_5M = 0x9; 9266942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 9276942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::A6: // Bypass: Not used by VEX 9286942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::A7: // Bypass: Not used by VEX 9296942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::TB: // Bypass: Not used by VEX 9306942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case 0: 9316942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; // No prefix! 932ab394bdcc0e89ce6dafae45fb7dd7420e77f14d7Evan Cheng } 933ab394bdcc0e89ce6dafae45fb7dd7420e77f14d7Evan Cheng 9346942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 9356942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // Classify VEX_B, VEX_4V, VEX_R, VEX_X 936177cf1e1a3685209ab805f82897902a8d2b61661Elena Demikhovsky unsigned NumOps = Desc->getNumOperands(); 9376942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned CurOp = 0; 9385aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper if (NumOps > 1 && Desc->getOperandConstraint(1, MCOI::TIED_TO) == 0) 939177cf1e1a3685209ab805f82897902a8d2b61661Elena Demikhovsky ++CurOp; 9405aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper else if (NumOps > 3 && Desc->getOperandConstraint(2, MCOI::TIED_TO) == 0) { 9415aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper assert(Desc->getOperandConstraint(NumOps - 1, MCOI::TIED_TO) == 1); 9425aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper // Special case for GATHER with 2 TIED_TO operands 9435aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper // Skip the first 2 operands: dst, mask_wb 9445aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper CurOp += 2; 9455aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper } 9465aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper 9476942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper switch (TSFlags & X86II::FormMask) { 948ff72e74d34197cd8775ed32c6e06054b936a1cadCraig Topper case X86II::MRMInitReg: 949ff72e74d34197cd8775ed32c6e06054b936a1cadCraig Topper // Duplicate register. 950ff72e74d34197cd8775ed32c6e06054b936a1cadCraig Topper if (X86II::isX86_64ExtendedReg(MI.getOperand(CurOp).getReg())) 951ff72e74d34197cd8775ed32c6e06054b936a1cadCraig Topper VEX_R = 0x0; 952ff72e74d34197cd8775ed32c6e06054b936a1cadCraig Topper 953ff72e74d34197cd8775ed32c6e06054b936a1cadCraig Topper if (HasVEX_4V) 954ff72e74d34197cd8775ed32c6e06054b936a1cadCraig Topper VEX_4V = getVEXRegisterEncoding(MI, CurOp); 955ff72e74d34197cd8775ed32c6e06054b936a1cadCraig Topper if (X86II::isX86_64ExtendedReg(MI.getOperand(CurOp).getReg())) 956ff72e74d34197cd8775ed32c6e06054b936a1cadCraig Topper VEX_B = 0x0; 957ff72e74d34197cd8775ed32c6e06054b936a1cadCraig Topper if (HasVEX_4VOp3) 958ff72e74d34197cd8775ed32c6e06054b936a1cadCraig Topper VEX_4V = getVEXRegisterEncoding(MI, CurOp); 959ff72e74d34197cd8775ed32c6e06054b936a1cadCraig Topper break; 9606942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::MRMDestMem: { 9616942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // MRMDestMem instructions forms: 9626942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // MemAddr, src1(ModR/M) 9636942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // MemAddr, src1(VEX_4V), src2(ModR/M) 9646942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // MemAddr, src1(ModR/M), imm8 9656942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 9666942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (X86II::isX86_64ExtendedReg(MI.getOperand(X86::AddrBaseReg).getReg())) 9676942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_B = 0x0; 9686942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (X86II::isX86_64ExtendedReg(MI.getOperand(X86::AddrIndexReg).getReg())) 9696942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_X = 0x0; 9706942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 9716942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper CurOp = X86::AddrNumOperands; 9726942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (HasVEX_4V) 9736942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_4V = getVEXRegisterEncoding(MI, CurOp++); 9746942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 9756942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MachineOperand &MO = MI.getOperand(CurOp); 9766942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (MO.isReg() && X86II::isX86_64ExtendedReg(MO.getReg())) 9776942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_R = 0x0; 9786942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 9796942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } 9806942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::MRMSrcMem: 9816942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // MRMSrcMem instructions forms: 9826942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // src1(ModR/M), MemAddr 9836942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // src1(ModR/M), src2(VEX_4V), MemAddr 9846942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // src1(ModR/M), MemAddr, imm8 9856942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // src1(ModR/M), MemAddr, src2(VEX_I8IMM) 9866942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 9876942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // FMA4: 9886942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // dst(ModR/M.reg), src1(VEX_4V), src2(ModR/M), src3(VEX_I8IMM) 9896942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // dst(ModR/M.reg), src1(VEX_4V), src2(VEX_I8IMM), src3(ModR/M), 9906942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (X86II::isX86_64ExtendedReg(MI.getOperand(0).getReg())) 9916942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_R = 0x0; 9926942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 9936942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (HasVEX_4V) 9946942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_4V = getVEXRegisterEncoding(MI, 1); 9956942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 9966942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (X86II::isX86_64ExtendedReg( 9976942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MI.getOperand(MemOperand+X86::AddrBaseReg).getReg())) 9986942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_B = 0x0; 9996942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (X86II::isX86_64ExtendedReg( 10006942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MI.getOperand(MemOperand+X86::AddrIndexReg).getReg())) 10016942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_X = 0x0; 10026942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 10036942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (HasVEX_4VOp3) 10046942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_4V = getVEXRegisterEncoding(MI, X86::AddrNumOperands+1); 10056942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 10066942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::MRM0m: case X86II::MRM1m: 10076942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::MRM2m: case X86II::MRM3m: 10086942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::MRM4m: case X86II::MRM5m: 10096942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::MRM6m: case X86II::MRM7m: { 10106942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // MRM[0-9]m instructions forms: 10116942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // MemAddr 10126942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // src1(VEX_4V), MemAddr 10136942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (HasVEX_4V) 10146942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_4V = getVEXRegisterEncoding(MI, 0); 10156942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 10166942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (X86II::isX86_64ExtendedReg( 10176942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MI.getOperand(MemOperand+X86::AddrBaseReg).getReg())) 10186942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_B = 0x0; 10196942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (X86II::isX86_64ExtendedReg( 10206942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MI.getOperand(MemOperand+X86::AddrIndexReg).getReg())) 10216942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_X = 0x0; 10226942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 10236942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } 10246942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::MRMSrcReg: 10256942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // MRMSrcReg instructions forms: 10266942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // dst(ModR/M), src1(VEX_4V), src2(ModR/M), src3(VEX_I8IMM) 10276942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // dst(ModR/M), src1(ModR/M) 10286942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // dst(ModR/M), src1(ModR/M), imm8 10296942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 10306942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (X86II::isX86_64ExtendedReg(MI.getOperand(CurOp).getReg())) 10316942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_R = 0x0; 10326942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper CurOp++; 10336942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 10346942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (HasVEX_4V) 10356942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_4V = getVEXRegisterEncoding(MI, CurOp++); 10369d3f3c5f400578855f6f7b71670cb8514b4fac0fCraig Topper 1037fdf168fbc415a4d2e3cfec36f328979f11a3186fCraig Topper if (HasMemOp4) // Skip second register source (encoded in I8IMM) 10389d3f3c5f400578855f6f7b71670cb8514b4fac0fCraig Topper CurOp++; 10399d3f3c5f400578855f6f7b71670cb8514b4fac0fCraig Topper 10406942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (X86II::isX86_64ExtendedReg(MI.getOperand(CurOp).getReg())) 10416942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_B = 0x0; 10426942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper CurOp++; 10436942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (HasVEX_4VOp3) 10446942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_4V = getVEXRegisterEncoding(MI, CurOp); 10456942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 10466942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::MRMDestReg: 10476942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // MRMDestReg instructions forms: 10486942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // dst(ModR/M), src(ModR/M) 10496942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // dst(ModR/M), src(ModR/M), imm8 10508647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper // dst(ModR/M), src1(VEX_4V), src2(ModR/M) 10518647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper if (X86II::isX86_64ExtendedReg(MI.getOperand(CurOp).getReg())) 10526942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_B = 0x0; 10538647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper CurOp++; 10548647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper 10558647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper if (HasVEX_4V) 10568647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper VEX_4V = getVEXRegisterEncoding(MI, CurOp++); 10578647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper 10588647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper if (X86II::isX86_64ExtendedReg(MI.getOperand(CurOp).getReg())) 10596942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_R = 0x0; 10606942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 10616942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::MRM0r: case X86II::MRM1r: 10626942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::MRM2r: case X86II::MRM3r: 10636942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::MRM4r: case X86II::MRM5r: 10646942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::MRM6r: case X86II::MRM7r: 10656942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // MRM0r-MRM7r instructions forms: 10666942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // dst(VEX_4V), src(ModR/M), imm8 10676942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_4V = getVEXRegisterEncoding(MI, 0); 10686942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (X86II::isX86_64ExtendedReg(MI.getOperand(1).getReg())) 10696942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper VEX_B = 0x0; 10706942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 10716942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper default: // RawFrm 10726942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper break; 10736942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } 10746942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 10756942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // Emit segment override opcode prefix as needed. 10766942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper emitSegmentOverridePrefix(TSFlags, MemOperand, MI); 10776942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 10786942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // VEX opcode prefix can have 2 or 3 bytes 10796942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 10806942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 3 bytes: 10816942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // +-----+ +--------------+ +-------------------+ 10826942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // | C4h | | RXB | m-mmmm | | W | vvvv | L | pp | 10836942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // +-----+ +--------------+ +-------------------+ 10846942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 2 bytes: 10856942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // +-----+ +-------------------+ 10866942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // | C5h | | R | vvvv | L | pp | 10876942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // +-----+ +-------------------+ 10886942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 10896942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned char LastByte = VEX_PP | (VEX_L << 2) | (VEX_4V << 3); 10906942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 10916942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (VEX_B && VEX_X && !VEX_W && !XOP && (VEX_5M == 1)) { // 2 byte VEX prefix 10926942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(0xC5); 10936942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(LastByte | (VEX_R << 7)); 10946942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper return; 10956942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } 10966942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 10976942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // 3 byte VEX prefix 10986942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(XOP ? 0x8F : 0xC4); 10996942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(VEX_R << 7 | VEX_X << 6 | VEX_B << 5 | VEX_5M); 11006942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(LastByte | (VEX_W << 7)); 11016942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper} 11026942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 11036942f706aad24c45b55d30256250e4ae472b3b07Pete Coopertemplate<class CodeEmitter> 11046942f706aad24c45b55d30256250e4ae472b3b07Pete Coopervoid Emitter<CodeEmitter>::emitInstruction(MachineInstr &MI, 11056942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper const MCInstrDesc *Desc) { 11066942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper DEBUG(dbgs() << MI); 11076942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 11086942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // If this is a pseudo instruction, lower it. 11096942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper switch (Desc->getOpcode()) { 11106942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::ADD16rr_DB: Desc = UpdateOp(MI, II, X86::OR16rr); break; 11116942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::ADD32rr_DB: Desc = UpdateOp(MI, II, X86::OR32rr); break; 11126942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::ADD64rr_DB: Desc = UpdateOp(MI, II, X86::OR64rr); break; 11136942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::ADD16ri_DB: Desc = UpdateOp(MI, II, X86::OR16ri); break; 11146942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::ADD32ri_DB: Desc = UpdateOp(MI, II, X86::OR32ri); break; 11156942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::ADD64ri32_DB: Desc = UpdateOp(MI, II, X86::OR64ri32); break; 11166942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::ADD16ri8_DB: Desc = UpdateOp(MI, II, X86::OR16ri8); break; 11176942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::ADD32ri8_DB: Desc = UpdateOp(MI, II, X86::OR32ri8); break; 11186942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::ADD64ri8_DB: Desc = UpdateOp(MI, II, X86::OR64ri8); break; 11196942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::ACQUIRE_MOV8rm: Desc = UpdateOp(MI, II, X86::MOV8rm); break; 11206942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::ACQUIRE_MOV16rm: Desc = UpdateOp(MI, II, X86::MOV16rm); break; 11216942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::ACQUIRE_MOV32rm: Desc = UpdateOp(MI, II, X86::MOV32rm); break; 11226942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::ACQUIRE_MOV64rm: Desc = UpdateOp(MI, II, X86::MOV64rm); break; 11236942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::RELEASE_MOV8mr: Desc = UpdateOp(MI, II, X86::MOV8mr); break; 11246942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::RELEASE_MOV16mr: Desc = UpdateOp(MI, II, X86::MOV16mr); break; 11256942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::RELEASE_MOV32mr: Desc = UpdateOp(MI, II, X86::MOV32mr); break; 11266942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86::RELEASE_MOV64mr: Desc = UpdateOp(MI, II, X86::MOV64mr); break; 11276942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } 11286942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 11296942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 11306942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.processDebugLoc(MI.getDebugLoc(), true); 11316942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 11326942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned Opcode = Desc->Opcode; 11336942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 11340e42d81a838bcccd3ed6aacd011a172633ce6606Chris Lattner // If this is a two-address instruction, skip one of the register operands. 1135349c4952009525b27383e2120a6b3c998f39bd09Chris Lattner unsigned NumOps = Desc->getNumOperands(); 11360e42d81a838bcccd3ed6aacd011a172633ce6606Chris Lattner unsigned CurOp = 0; 11375aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper if (NumOps > 1 && Desc->getOperandConstraint(1, MCOI::TIED_TO) == 0) 11387e03280b535242c1f394348702a1d1840b75774cEvan Cheng ++CurOp; 11395aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper else if (NumOps > 3 && Desc->getOperandConstraint(2, MCOI::TIED_TO) == 0) { 11405aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper assert(Desc->getOperandConstraint(NumOps - 1, MCOI::TIED_TO) == 1); 11415aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper // Special case for GATHER with 2 TIED_TO operands 11425aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper // Skip the first 2 operands: dst, mask_wb 11435aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper CurOp += 2; 11445aba78bd8056dc407bcbce4080ffcd12b13c7342Craig Topper } 1145fd00debde0353b9e567ca4f68d62ad8aae5bf512Evan Cheng 11466942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper uint64_t TSFlags = Desc->TSFlags; 11476942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 11486942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // Is this instruction encoded using the AVX VEX prefix? 11496942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper bool HasVEXPrefix = (TSFlags >> X86II::VEXShift) & X86II::VEX; 11506942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // It uses the VEX.VVVV field? 11516942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper bool HasVEX_4V = (TSFlags >> X86II::VEXShift) & X86II::VEX_4V; 11526942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper bool HasVEX_4VOp3 = (TSFlags >> X86II::VEXShift) & X86II::VEX_4VOp3; 11536942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper bool HasMemOp4 = (TSFlags >> X86II::VEXShift) & X86II::MemOp4; 1154769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper const unsigned MemOp4_I8IMMOperand = 2; 11556942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 11566942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper // Determine where the memory operand starts, if present. 11576942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper int MemoryOperand = X86II::getMemoryOperandNo(TSFlags, Opcode); 11586942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (MemoryOperand != -1) MemoryOperand += CurOp; 11596942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 11606942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (!HasVEXPrefix) 11616942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper emitOpcodePrefix(TSFlags, MemoryOperand, MI, Desc); 11626942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper else 11636942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper emitVEXOpcodePrefix(TSFlags, MemoryOperand, MI, Desc); 11646942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 116574a2151392a08e202f497ece7a3129663526d431Chris Lattner unsigned char BaseOpcode = X86II::getBaseOpcodeFor(Desc->TSFlags); 11666942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper switch (TSFlags & X86II::FormMask) { 1167d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner default: 1168d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner llvm_unreachable("Unknown FormMask value in X86 MachineCodeEmitter!"); 11695ada8df4882b2a0800157c07530adb0feeddf4f1Chris Lattner case X86II::Pseudo: 11700475ab58b8e92fa8e8b90ddbf023bc60587c5e25Evan Cheng // Remember the current PC offset, this is the PIC relocation 11710475ab58b8e92fa8e8b90ddbf023bc60587c5e25Evan Cheng // base address. 1172dabbc983966594a004b99c257fe2a776bef0bd18Chris Lattner switch (Opcode) { 1173bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak default: 117411bc1652c9447d85204dc6f7c878b9c95e668a96Gabor Greif llvm_unreachable("pseudo instructions should be removed before code" 1175d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner " emission"); 1176505656c6a2be361b9ae8ff230020fdea38886a7eEric Christopher // Do nothing for Int_MemBarrier - it's just a comment. Add a debug 1177505656c6a2be361b9ae8ff230020fdea38886a7eEric Christopher // to make it slightly easier to see. 1178505656c6a2be361b9ae8ff230020fdea38886a7eEric Christopher case X86::Int_MemBarrier: 1179505656c6a2be361b9ae8ff230020fdea38886a7eEric Christopher DEBUG(dbgs() << "#MEMBARRIER\n"); 1180505656c6a2be361b9ae8ff230020fdea38886a7eEric Christopher break; 1181bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 1182518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner case TargetOpcode::INLINEASM: 1183eda60a8364889a336339571fa4810e439ce895f6Evan Cheng // We allow inline assembler nodes with empty bodies - they can 1184eda60a8364889a336339571fa4810e439ce895f6Evan Cheng // implicitly define registers, which is ok for JIT. 1185f5e16139f28d650536024280a16dcf73513baf46Chris Lattner if (MI.getOperand(0).getSymbolName()[0]) 118675361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("JIT does not support inline asm!"); 1187b7664c617373bbb62b8cf281e0fbc3802a95f9d1Evan Cheng break; 11887431beaba2a01c3fe299c861b2ec85cbf1dc81c4Bill Wendling case TargetOpcode::PROLOG_LABEL: 1189aba9bcb9b60edbad3646b2f3088c120d06549cc7Chris Lattner case TargetOpcode::GC_LABEL: 11907561d480953e0a2faa4af9be0a00b1180097c4bdChris Lattner case TargetOpcode::EH_LABEL: 11917561d480953e0a2faa4af9be0a00b1180097c4bdChris Lattner MCE.emitLabel(MI.getOperand(0).getMCSymbol()); 11927561d480953e0a2faa4af9be0a00b1180097c4bdChris Lattner break; 1193bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 1194518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner case TargetOpcode::IMPLICIT_DEF: 1195518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner case TargetOpcode::KILL: 1196dabbc983966594a004b99c257fe2a776bef0bd18Chris Lattner break; 11972a3e08b5961353fa3faeadf81f481ae9f5463427Evan Cheng case X86::MOVPC32r: { 11980475ab58b8e92fa8e8b90ddbf023bc60587c5e25Evan Cheng // This emits the "call" portion of this pseudo instruction. 11990475ab58b8e92fa8e8b90ddbf023bc60587c5e25Evan Cheng MCE.emitByte(BaseOpcode); 120074a2151392a08e202f497ece7a3129663526d431Chris Lattner emitConstant(0, X86II::getSizeOfImm(Desc->TSFlags)); 12012a3e08b5961353fa3faeadf81f481ae9f5463427Evan Cheng // Remember PIC base. 12025788d1a169db3346a612a13113348d2709bdd15bEvan Cheng PICBaseOffset = (intptr_t) MCE.getCurrentPCOffset(); 1203c9f5f3f64f896d0a8c8fa35a1dd98bc57b8960f6Dan Gohman X86JITInfo *JTI = TM.getJITInfo(); 12042a3e08b5961353fa3faeadf81f481ae9f5463427Evan Cheng JTI->setPICBase(MCE.getCurrentPCValue()); 12050475ab58b8e92fa8e8b90ddbf023bc60587c5e25Evan Cheng break; 12060475ab58b8e92fa8e8b90ddbf023bc60587c5e25Evan Cheng } 12072a3e08b5961353fa3faeadf81f481ae9f5463427Evan Cheng } 1208171d09ea537ac272091a1a2560302074b144fccaEvan Cheng CurOp = NumOps; 12095ada8df4882b2a0800157c07530adb0feeddf4f1Chris Lattner break; 1210f5af556c18fa44f073367e0ce7093df507810adaChris Lattner case X86II::RawFrm: { 1211ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner MCE.emitByte(BaseOpcode); 12120475ab58b8e92fa8e8b90ddbf023bc60587c5e25Evan Cheng 1213f5af556c18fa44f073367e0ce7093df507810adaChris Lattner if (CurOp == NumOps) 1214f5af556c18fa44f073367e0ce7093df507810adaChris Lattner break; 1215bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 1216f5af556c18fa44f073367e0ce7093df507810adaChris Lattner const MachineOperand &MO = MI.getOperand(CurOp++); 1217f5af556c18fa44f073367e0ce7093df507810adaChris Lattner 1218c719d5f6216270fb29e880669d0351e8316d3577David Greene DEBUG(dbgs() << "RawFrm CurOp " << CurOp << "\n"); 1219c719d5f6216270fb29e880669d0351e8316d3577David Greene DEBUG(dbgs() << "isMBB " << MO.isMBB() << "\n"); 1220c719d5f6216270fb29e880669d0351e8316d3577David Greene DEBUG(dbgs() << "isGlobal " << MO.isGlobal() << "\n"); 1221c719d5f6216270fb29e880669d0351e8316d3577David Greene DEBUG(dbgs() << "isSymbol " << MO.isSymbol() << "\n"); 1222c719d5f6216270fb29e880669d0351e8316d3577David Greene DEBUG(dbgs() << "isImm " << MO.isImm() << "\n"); 1223f5af556c18fa44f073367e0ce7093df507810adaChris Lattner 1224f5af556c18fa44f073367e0ce7093df507810adaChris Lattner if (MO.isMBB()) { 1225f5af556c18fa44f073367e0ce7093df507810adaChris Lattner emitPCRelativeBlockAddress(MO.getMBB()); 1226f5af556c18fa44f073367e0ce7093df507810adaChris Lattner break; 12278f04b0981fd8cd54ab89348cd8f29ac230816854Chris Lattner } 1228bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 1229f5af556c18fa44f073367e0ce7093df507810adaChris Lattner if (MO.isGlobal()) { 1230f5af556c18fa44f073367e0ce7093df507810adaChris Lattner emitGlobalAddress(MO.getGlobal(), X86::reloc_pcrel_word, 1231d1ba06bf131a9d217426529d2e28af1f2eeed47aJeffrey Yasskin MO.getOffset(), 0); 1232f5af556c18fa44f073367e0ce7093df507810adaChris Lattner break; 1233f5af556c18fa44f073367e0ce7093df507810adaChris Lattner } 1234bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 1235f5af556c18fa44f073367e0ce7093df507810adaChris Lattner if (MO.isSymbol()) { 1236f5af556c18fa44f073367e0ce7093df507810adaChris Lattner emitExternalSymbolAddress(MO.getSymbolName(), X86::reloc_pcrel_word); 1237f5af556c18fa44f073367e0ce7093df507810adaChris Lattner break; 1238f5af556c18fa44f073367e0ce7093df507810adaChris Lattner } 1239869fe12cc0769ab5005498bab942e85a6f5e3798Daniel Dunbar 1240869fe12cc0769ab5005498bab942e85a6f5e3798Daniel Dunbar // FIXME: Only used by hackish MCCodeEmitter, remove when dead. 1241869fe12cc0769ab5005498bab942e85a6f5e3798Daniel Dunbar if (MO.isJTI()) { 1242869fe12cc0769ab5005498bab942e85a6f5e3798Daniel Dunbar emitJumpTableAddress(MO.getIndex(), X86::reloc_pcrel_word); 1243869fe12cc0769ab5005498bab942e85a6f5e3798Daniel Dunbar break; 1244869fe12cc0769ab5005498bab942e85a6f5e3798Daniel Dunbar } 1245bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 1246f5af556c18fa44f073367e0ce7093df507810adaChris Lattner assert(MO.isImm() && "Unknown RawFrm operand!"); 1247527a08b253795cf09de41c289c9dc071f00b1d4aJakob Stoklund Olesen if (Opcode == X86::CALLpcrel32 || Opcode == X86::CALL64pcrel32) { 1248f5af556c18fa44f073367e0ce7093df507810adaChris Lattner // Fix up immediate operand for pc relative calls. 1249f5af556c18fa44f073367e0ce7093df507810adaChris Lattner intptr_t Imm = (intptr_t)MO.getImm(); 1250f5af556c18fa44f073367e0ce7093df507810adaChris Lattner Imm = Imm - MCE.getCurrentPCValue() - 4; 125174a2151392a08e202f497ece7a3129663526d431Chris Lattner emitConstant(Imm, X86II::getSizeOfImm(Desc->TSFlags)); 1252f5af556c18fa44f073367e0ce7093df507810adaChris Lattner } else 125374a2151392a08e202f497ece7a3129663526d431Chris Lattner emitConstant(MO.getImm(), X86II::getSizeOfImm(Desc->TSFlags)); 1254ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner break; 1255f5af556c18fa44f073367e0ce7093df507810adaChris Lattner } 1256bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 1257d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner case X86II::AddRegFrm: { 12580e6a052331f674dd70e28af41f654a7874405eabEvan Cheng MCE.emitByte(BaseOpcode + 12597abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao getX86RegNum(MI.getOperand(CurOp++).getReg())); 1260bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 1261d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner if (CurOp == NumOps) 1262d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner break; 1263bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 1264d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner const MachineOperand &MO1 = MI.getOperand(CurOp++); 126574a2151392a08e202f497ece7a3129663526d431Chris Lattner unsigned Size = X86II::getSizeOfImm(Desc->TSFlags); 1266d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner if (MO1.isImm()) { 1267d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitConstant(MO1.getImm(), Size); 1268d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner break; 1269ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner } 1270bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 1271d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner unsigned rt = Is64BitMode ? X86::reloc_pcrel_word 1272d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner : (IsPIC ? X86::reloc_picrel_word : X86::reloc_absolute_word); 1273d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner if (Opcode == X86::MOV64ri64i32) 1274d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner rt = X86::reloc_absolute_word; // FIXME: add X86II flag? 1275d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner // This should not occur on Darwin for relocatable objects. 1276d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner if (Opcode == X86::MOV64ri) 1277d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner rt = X86::reloc_absolute_dword; // FIXME: add X86II flag? 1278d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner if (MO1.isGlobal()) { 1279d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner bool Indirect = gvNeedsNonLazyPtr(MO1, TM); 1280d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitGlobalAddress(MO1.getGlobal(), rt, MO1.getOffset(), 0, 1281d1ba06bf131a9d217426529d2e28af1f2eeed47aJeffrey Yasskin Indirect); 1282d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner } else if (MO1.isSymbol()) 1283d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitExternalSymbolAddress(MO1.getSymbolName(), rt); 1284d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner else if (MO1.isCPI()) 1285d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitConstPoolAddress(MO1.getIndex(), rt); 1286d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner else if (MO1.isJTI()) 1287d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitJumpTableAddress(MO1.getIndex(), rt); 1288ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner break; 1289d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner } 1290e831b6b802c3c95227dcd8baa7614e1befd026c0Chris Lattner 1291e831b6b802c3c95227dcd8baa7614e1befd026c0Chris Lattner case X86II::MRMDestReg: { 1292ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner MCE.emitByte(BaseOpcode); 12938647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper 12948647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper unsigned SrcRegNum = CurOp+1; 12958647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper if (HasVEX_4V) // Skip 1st src (which is encoded in VEX_VVVV) 12968647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper SrcRegNum++; 12978647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper 12980e42d81a838bcccd3ed6aacd011a172633ce6606Chris Lattner emitRegModRMByte(MI.getOperand(CurOp).getReg(), 12998647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper getX86RegNum(MI.getOperand(SrcRegNum).getReg())); 13008647750dfbae36a7a49767202a2e363ffc861e5aCraig Topper CurOp = SrcRegNum + 1; 13019dedbcc3d5d30bfe4eab24483f2a2db5a541ea7aChris Lattner break; 1302e831b6b802c3c95227dcd8baa7614e1befd026c0Chris Lattner } 130325ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng case X86II::MRMDestMem: { 1304ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner MCE.emitByte(BaseOpcode); 13056942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 13066942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned SrcRegNum = CurOp + X86::AddrNumOperands; 13076942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (HasVEX_4V) // Skip 1st src (which is encoded in VEX_VVVV) 13086942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper SrcRegNum++; 1309b449a68146c7188a20bba11db19229a5cb46938aRafael Espindola emitMemModRMByte(MI, CurOp, 13107abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao getX86RegNum(MI.getOperand(SrcRegNum).getReg())); 13116942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper CurOp = SrcRegNum + 1; 1312ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner break; 131325ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng } 1314e831b6b802c3c95227dcd8baa7614e1befd026c0Chris Lattner 13156942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper case X86II::MRMSrcReg: { 1316ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner MCE.emitByte(BaseOpcode); 13176942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 13186942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned SrcRegNum = CurOp+1; 13196942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (HasVEX_4V) // Skip 1st src (which is encoded in VEX_VVVV) 13205084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper ++SrcRegNum; 13216942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 13225084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper if (HasMemOp4) // Skip 2nd src (which is encoded in I8IMM) 13235084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper ++SrcRegNum; 13246942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 13256942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper emitRegModRMByte(MI.getOperand(SrcRegNum).getReg(), 13267abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao getX86RegNum(MI.getOperand(CurOp).getReg())); 13275084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper // 2 operands skipped with HasMemOp4, compensate accordingly 13286942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper CurOp = HasMemOp4 ? SrcRegNum : SrcRegNum + 1; 13296942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (HasVEX_4VOp3) 13306942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper ++CurOp; 1331ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner break; 13326942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } 133325ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng case X86II::MRMSrcMem: { 1334599b531a960833719f607d66c97871f1f5ad12c0Chris Lattner int AddrOperands = X86::AddrNumOperands; 13356942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper unsigned FirstMemOp = CurOp+1; 13366942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (HasVEX_4V) { 13376942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper ++AddrOperands; 13386942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper ++FirstMemOp; // Skip the register source (which is encoded in VEX_VVVV). 13396942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper } 13405084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper if (HasMemOp4) // Skip second register source (encoded in I8IMM) 13416942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper ++FirstMemOp; 13426942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper 13436942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper MCE.emitByte(BaseOpcode); 1344094fad37b90946c91a09eb9270a0dbe800f49d87Rafael Espindola 1345094fad37b90946c91a09eb9270a0dbe800f49d87Rafael Espindola intptr_t PCAdj = (CurOp + AddrOperands + 1 != NumOps) ? 134674a2151392a08e202f497ece7a3129663526d431Chris Lattner X86II::getSizeOfImm(Desc->TSFlags) : 0; 13476942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper emitMemModRMByte(MI, FirstMemOp, 13487abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao getX86RegNum(MI.getOperand(CurOp).getReg()),PCAdj); 1349094fad37b90946c91a09eb9270a0dbe800f49d87Rafael Espindola CurOp += AddrOperands + 1; 13506942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (HasVEX_4VOp3) 13516942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper ++CurOp; 1352ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner break; 135325ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng } 13548f04b0981fd8cd54ab89348cd8f29ac230816854Chris Lattner 1355169584ed45f62f91599bed3d019640e168d815eaAlkis Evlogimenos case X86II::MRM0r: case X86II::MRM1r: 1356169584ed45f62f91599bed3d019640e168d815eaAlkis Evlogimenos case X86II::MRM2r: case X86II::MRM3r: 1357169584ed45f62f91599bed3d019640e168d815eaAlkis Evlogimenos case X86II::MRM4r: case X86II::MRM5r: 13584b299d4ebdf57c56ca336d9aca6f2ad7d8175995Evan Cheng case X86II::MRM6r: case X86II::MRM7r: { 13596942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (HasVEX_4V) // Skip the register dst (which is encoded in VEX_VVVV). 13605084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper ++CurOp; 1361ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner MCE.emitByte(BaseOpcode); 1362eaca5fa8e6a2cb0f84a635da5f1f0f670776d0a5Chris Lattner emitRegModRMByte(MI.getOperand(CurOp++).getReg(), 1363eaca5fa8e6a2cb0f84a635da5f1f0f670776d0a5Chris Lattner (Desc->TSFlags & X86II::FormMask)-X86II::MRM0r); 1364ea1ddab58e9db323294012628a56275da0e930a7Chris Lattner 1365d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner if (CurOp == NumOps) 1366d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner break; 1367bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 1368d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner const MachineOperand &MO1 = MI.getOperand(CurOp++); 136974a2151392a08e202f497ece7a3129663526d431Chris Lattner unsigned Size = X86II::getSizeOfImm(Desc->TSFlags); 1370d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner if (MO1.isImm()) { 1371d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitConstant(MO1.getImm(), Size); 1372d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner break; 137319f2ffce4598c4c70f32eed7c6740b43185200b1Evan Cheng } 1374bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 1375d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner unsigned rt = Is64BitMode ? X86::reloc_pcrel_word 1376d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner : (IsPIC ? X86::reloc_picrel_word : X86::reloc_absolute_word); 1377d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner if (Opcode == X86::MOV64ri32) 1378d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner rt = X86::reloc_absolute_word_sext; // FIXME: add X86II flag? 1379d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner if (MO1.isGlobal()) { 1380d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner bool Indirect = gvNeedsNonLazyPtr(MO1, TM); 1381d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitGlobalAddress(MO1.getGlobal(), rt, MO1.getOffset(), 0, 1382d1ba06bf131a9d217426529d2e28af1f2eeed47aJeffrey Yasskin Indirect); 1383d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner } else if (MO1.isSymbol()) 1384d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitExternalSymbolAddress(MO1.getSymbolName(), rt); 1385d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner else if (MO1.isCPI()) 1386d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitConstPoolAddress(MO1.getIndex(), rt); 1387d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner else if (MO1.isJTI()) 1388d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitJumpTableAddress(MO1.getIndex(), rt); 13898f04b0981fd8cd54ab89348cd8f29ac230816854Chris Lattner break; 13904b299d4ebdf57c56ca336d9aca6f2ad7d8175995Evan Cheng } 1391e831b6b802c3c95227dcd8baa7614e1befd026c0Chris Lattner 1392169584ed45f62f91599bed3d019640e168d815eaAlkis Evlogimenos case X86II::MRM0m: case X86II::MRM1m: 1393169584ed45f62f91599bed3d019640e168d815eaAlkis Evlogimenos case X86II::MRM2m: case X86II::MRM3m: 1394169584ed45f62f91599bed3d019640e168d815eaAlkis Evlogimenos case X86II::MRM4m: case X86II::MRM5m: 139525ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng case X86II::MRM6m: case X86II::MRM7m: { 13966942f706aad24c45b55d30256250e4ae472b3b07Pete Cooper if (HasVEX_4V) // Skip the register dst (which is encoded in VEX_VVVV). 13975084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper ++CurOp; 1398ac0ed5dc082dff9ce359af5422f5b82047b4fe6bChris Lattner intptr_t PCAdj = (CurOp + X86::AddrNumOperands != NumOps) ? 1399bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak (MI.getOperand(CurOp+X86::AddrNumOperands).isImm() ? 140074a2151392a08e202f497ece7a3129663526d431Chris Lattner X86II::getSizeOfImm(Desc->TSFlags) : 4) : 0; 140125ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng 1402e831b6b802c3c95227dcd8baa7614e1befd026c0Chris Lattner MCE.emitByte(BaseOpcode); 140319f2ffce4598c4c70f32eed7c6740b43185200b1Evan Cheng emitMemModRMByte(MI, CurOp, (Desc->TSFlags & X86II::FormMask)-X86II::MRM0m, 140425ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng PCAdj); 1405ac0ed5dc082dff9ce359af5422f5b82047b4fe6bChris Lattner CurOp += X86::AddrNumOperands; 14060e42d81a838bcccd3ed6aacd011a172633ce6606Chris Lattner 1407d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner if (CurOp == NumOps) 1408d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner break; 1409bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 1410d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner const MachineOperand &MO = MI.getOperand(CurOp++); 141174a2151392a08e202f497ece7a3129663526d431Chris Lattner unsigned Size = X86II::getSizeOfImm(Desc->TSFlags); 1412d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner if (MO.isImm()) { 1413d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitConstant(MO.getImm(), Size); 1414d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner break; 1415e831b6b802c3c95227dcd8baa7614e1befd026c0Chris Lattner } 1416bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 1417d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner unsigned rt = Is64BitMode ? X86::reloc_pcrel_word 1418d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner : (IsPIC ? X86::reloc_picrel_word : X86::reloc_absolute_word); 1419d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner if (Opcode == X86::MOV64mi32) 1420d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner rt = X86::reloc_absolute_word_sext; // FIXME: add X86II flag? 1421d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner if (MO.isGlobal()) { 1422d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner bool Indirect = gvNeedsNonLazyPtr(MO, TM); 1423d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitGlobalAddress(MO.getGlobal(), rt, MO.getOffset(), 0, 1424d1ba06bf131a9d217426529d2e28af1f2eeed47aJeffrey Yasskin Indirect); 1425d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner } else if (MO.isSymbol()) 1426d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitExternalSymbolAddress(MO.getSymbolName(), rt); 1427d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner else if (MO.isCPI()) 1428d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitConstPoolAddress(MO.getIndex(), rt); 1429d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner else if (MO.isJTI()) 1430d8638babf9936a47ce3450bbb184cf42d13af6d5Chris Lattner emitJumpTableAddress(MO.getIndex(), rt); 1431e831b6b802c3c95227dcd8baa7614e1befd026c0Chris Lattner break; 143225ab690a43cbbb591b76d49e3595b019c32f4b3fEvan Cheng } 14333c55c54a877b3e5a79053df8f6080f505c9d1ff4Evan Cheng 14343c55c54a877b3e5a79053df8f6080f505c9d1ff4Evan Cheng case X86II::MRMInitReg: 14353c55c54a877b3e5a79053df8f6080f505c9d1ff4Evan Cheng MCE.emitByte(BaseOpcode); 14360e42d81a838bcccd3ed6aacd011a172633ce6606Chris Lattner // Duplicate register, used by things like MOV8r0 (aka xor reg,reg). 14370e42d81a838bcccd3ed6aacd011a172633ce6606Chris Lattner emitRegModRMByte(MI.getOperand(CurOp).getReg(), 14387abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao getX86RegNum(MI.getOperand(CurOp).getReg())); 14390e42d81a838bcccd3ed6aacd011a172633ce6606Chris Lattner ++CurOp; 14403c55c54a877b3e5a79053df8f6080f505c9d1ff4Evan Cheng break; 1441bf1486057239895198b3e8fdfa994a6daedd3579Jakub Staszak 14420d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner case X86II::MRM_C1: 14430d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner MCE.emitByte(BaseOpcode); 14440d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner MCE.emitByte(0xC1); 14450d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner break; 14460d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner case X86II::MRM_C8: 14470d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner MCE.emitByte(BaseOpcode); 14480d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner MCE.emitByte(0xC8); 14490d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner break; 14500d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner case X86II::MRM_C9: 14510d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner MCE.emitByte(BaseOpcode); 14520d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner MCE.emitByte(0xC9); 14530d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner break; 14540d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner case X86II::MRM_E8: 14550d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner MCE.emitByte(BaseOpcode); 14560d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner MCE.emitByte(0xE8); 14570d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner break; 14580d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner case X86II::MRM_F0: 14590d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner MCE.emitByte(BaseOpcode); 14600d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner MCE.emitByte(0xF0); 14610d8db8e0a8492ab2d4bef725ec61b519471b97ecChris Lattner break; 146276041ce5155ca4aab443d139d7ad820ae06cbe09Chris Lattner } 14633530bafe00a46efe5e164eb66bd229ed2d321dacEvan Cheng 146477fc4b297aadf842c234f9de478226f6f71beee5Benjamin Kramer while (CurOp != NumOps && NumOps - CurOp <= 2) { 1465769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper // The last source register of a 4 operand instruction in AVX is encoded 1466769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper // in bits[7:4] of a immediate byte. 1467769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper if ((TSFlags >> X86II::VEXShift) & X86II::VEX_I8IMM) { 1468769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper const MachineOperand &MO = MI.getOperand(HasMemOp4 ? MemOp4_I8IMMOperand 1469769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper : CurOp); 14705084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper ++CurOp; 14717abf67a092c0a75d6d1631766d6a8ef14e38d526Michael Liao unsigned RegNum = getX86RegNum(MO.getReg()) << 4; 14725084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper if (X86II::isX86_64ExtendedReg(MO.getReg())) 14735084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper RegNum |= 1 << 7; 1474769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper // If there is an additional 5th operand it must be an immediate, which 1475769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper // is encoded in bits[3:0] 14765084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper if (CurOp != NumOps) { 1477769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper const MachineOperand &MIMM = MI.getOperand(CurOp++); 14785084c6b0a29ed409092bd31cd75849312a73bee5Craig Topper if (MIMM.isImm()) { 1479769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper unsigned Val = MIMM.getImm(); 1480769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper assert(Val < 16 && "Immediate operand value out of range"); 1481769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper RegNum |= Val; 1482769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper } 1483769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper } 1484769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper emitConstant(RegNum, 1); 1485769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper } else { 1486769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper emitConstant(MI.getOperand(CurOp++).getImm(), 1487769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper X86II::getSizeOfImm(Desc->TSFlags)); 1488769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper } 1489769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper } 1490769237bb92515cc8680538f95dfb2eef76ecadd2Craig Topper 14915a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (!MI.isVariadic() && CurOp != NumOps) { 1492dac237e18209b697a8ba122d0ddd9cad4dfba1f8Torok Edwin#ifndef NDEBUG 1493c719d5f6216270fb29e880669d0351e8316d3577David Greene dbgs() << "Cannot encode all operands of: " << MI << "\n"; 1494dac237e18209b697a8ba122d0ddd9cad4dfba1f8Torok Edwin#endif 1495c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 14960b21390a860c480095fe8a823ac0ccc285a33d48Evan Cheng } 1497af0e2726835e096e32c30c1b88cc7a6232a6ef69Devang Patel 1498af0e2726835e096e32c30c1b88cc7a6232a6ef69Devang Patel MCE.processDebugLoc(MI.getDebugLoc(), false); 149976041ce5155ca4aab443d139d7ad820ae06cbe09Chris Lattner} 1500