6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-02-22 13:29:44 +00:00
Code Issues Projects Releases Wiki Activity

Remove trailing whitespaces from file

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@107937 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bruno Cardoso Lopes 2010-07-09 00:07:19 +00:00
parent 599b531a96
commit 96716c7b92
1 changed files with 66 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
lib/Target/X86/X86MCCodeEmitter.cpp
View File

@ -30,7 +30,7 @@ class X86MCCodeEmitter : public MCCodeEmitter {
MCContext &Ctx; MCContext &Ctx;
bool Is64BitMode; bool Is64BitMode;
public: public:
X86MCCodeEmitter(TargetMachine &tm, MCContext &ctx, bool is64Bit) X86MCCodeEmitter(TargetMachine &tm, MCContext &ctx, bool is64Bit)
: TM(tm), TII(*TM.getInstrInfo()), Ctx(ctx) { : TM(tm), TII(*TM.getInstrInfo()), Ctx(ctx) {
Is64BitMode = is64Bit; Is64BitMode = is64Bit;
} }
@ -49,7 +49,7 @@ public:
{ "reloc_riprel_4byte", 0, 4 * 8, MCFixupKindInfo::FKF_IsPCRel }, { "reloc_riprel_4byte", 0, 4 * 8, MCFixupKindInfo::FKF_IsPCRel },
{ "reloc_riprel_4byte_movq_load", 0, 4 * 8, MCFixupKindInfo::FKF_IsPCRel } { "reloc_riprel_4byte_movq_load", 0, 4 * 8, MCFixupKindInfo::FKF_IsPCRel }
}; };
if (Kind < FirstTargetFixupKind) if (Kind < FirstTargetFixupKind)
return MCCodeEmitter::getFixupKindInfo(Kind); return MCCodeEmitter::getFixupKindInfo(Kind);
@ -57,7 +57,7 @@ public:
"Invalid kind!"); "Invalid kind!");
return Infos[Kind - FirstTargetFixupKind]; return Infos[Kind - FirstTargetFixupKind];
} }
static unsigned GetX86RegNum(const MCOperand &MO) { static unsigned GetX86RegNum(const MCOperand &MO) {
return X86RegisterInfo::getX86RegNum(MO.getReg()); return X86RegisterInfo::getX86RegNum(MO.getReg());
} }
@ -77,17 +77,17 @@ public:
unsigned SrcRegNum = GetX86RegNum(MI.getOperand(OpNum)); unsigned SrcRegNum = GetX86RegNum(MI.getOperand(OpNum));
if (SrcReg >= X86::XMM8 && SrcReg <= X86::XMM15) if (SrcReg >= X86::XMM8 && SrcReg <= X86::XMM15)
SrcRegNum += 8; SrcRegNum += 8;
// The registers represented through VEX_VVVV should // The registers represented through VEX_VVVV should
// be encoded in 1's complement form. // be encoded in 1's complement form.
return (~SrcRegNum) & 0xf; return (~SrcRegNum) & 0xf;
} }
void EmitByte(unsigned char C, unsigned &CurByte, raw_ostream &OS) const { void EmitByte(unsigned char C, unsigned &CurByte, raw_ostream &OS) const {
OS << (char)C; OS << (char)C;
++CurByte; ++CurByte;
} }
void EmitConstant(uint64_t Val, unsigned Size, unsigned &CurByte, void EmitConstant(uint64_t Val, unsigned Size, unsigned &CurByte,
raw_ostream &OS) const { raw_ostream &OS) const {
// Output the constant in little endian byte order. // Output the constant in little endian byte order.
@ -97,38 +97,38 @@ public:
} }
} }
void EmitImmediate(const MCOperand &Disp, void EmitImmediate(const MCOperand &Disp,
unsigned ImmSize, MCFixupKind FixupKind, unsigned ImmSize, MCFixupKind FixupKind,
unsigned &CurByte, raw_ostream &OS, unsigned &CurByte, raw_ostream &OS,
SmallVectorImpl<MCFixup> &Fixups, SmallVectorImpl<MCFixup> &Fixups,
int ImmOffset = 0) const; int ImmOffset = 0) const;
inline static unsigned char ModRMByte(unsigned Mod, unsigned RegOpcode, inline static unsigned char ModRMByte(unsigned Mod, unsigned RegOpcode,
unsigned RM) { unsigned RM) {
assert(Mod < 4 && RegOpcode < 8 && RM < 8 && "ModRM Fields out of range!"); assert(Mod < 4 && RegOpcode < 8 && RM < 8 && "ModRM Fields out of range!");
return RM | (RegOpcode << 3) | (Mod << 6); return RM | (RegOpcode << 3) | (Mod << 6);
} }
void EmitRegModRMByte(const MCOperand &ModRMReg, unsigned RegOpcodeFld, void EmitRegModRMByte(const MCOperand &ModRMReg, unsigned RegOpcodeFld,
unsigned &CurByte, raw_ostream &OS) const { unsigned &CurByte, raw_ostream &OS) const {
EmitByte(ModRMByte(3, RegOpcodeFld, GetX86RegNum(ModRMReg)), CurByte, OS); EmitByte(ModRMByte(3, RegOpcodeFld, GetX86RegNum(ModRMReg)), CurByte, OS);
} }
void EmitSIBByte(unsigned SS, unsigned Index, unsigned Base, void EmitSIBByte(unsigned SS, unsigned Index, unsigned Base,
unsigned &CurByte, raw_ostream &OS) const { unsigned &CurByte, raw_ostream &OS) const {
// SIB byte is in the same format as the ModRMByte. // SIB byte is in the same format as the ModRMByte.
EmitByte(ModRMByte(SS, Index, Base), CurByte, OS); EmitByte(ModRMByte(SS, Index, Base), CurByte, OS);
} }
void EmitMemModRMByte(const MCInst &MI, unsigned Op, void EmitMemModRMByte(const MCInst &MI, unsigned Op,
unsigned RegOpcodeField, unsigned RegOpcodeField,
uint64_t TSFlags, unsigned &CurByte, raw_ostream &OS, uint64_t TSFlags, unsigned &CurByte, raw_ostream &OS,
SmallVectorImpl<MCFixup> &Fixups) const; SmallVectorImpl<MCFixup> &Fixups) const;
void EncodeInstruction(const MCInst &MI, raw_ostream &OS, void EncodeInstruction(const MCInst &MI, raw_ostream &OS,
SmallVectorImpl<MCFixup> &Fixups) const; SmallVectorImpl<MCFixup> &Fixups) const;
void EmitVEXOpcodePrefix(uint64_t TSFlags, unsigned &CurByte, void EmitVEXOpcodePrefix(uint64_t TSFlags, unsigned &CurByte,
const MCInst &MI, const TargetInstrDesc &Desc, const MCInst &MI, const TargetInstrDesc &Desc,
raw_ostream &OS) const; raw_ostream &OS) const;
@ -153,8 +153,8 @@ MCCodeEmitter *llvm::createX86_64MCCodeEmitter(const Target &,
return new X86MCCodeEmitter(TM, Ctx, true); return new X86MCCodeEmitter(TM, Ctx, true);
} }
/// isDisp8 - Return true if this signed displacement fits in a 8-bit /// isDisp8 - Return true if this signed displacement fits in a 8-bit
/// sign-extended field. /// sign-extended field.
static bool isDisp8(int Value) { static bool isDisp8(int Value) {
return Value == (signed char)Value; return Value == (signed char)Value;
} }
@ -164,7 +164,7 @@ static bool isDisp8(int Value) {
static MCFixupKind getImmFixupKind(uint64_t TSFlags) { static MCFixupKind getImmFixupKind(uint64_t TSFlags) {
unsigned Size = X86II::getSizeOfImm(TSFlags); unsigned Size = X86II::getSizeOfImm(TSFlags);
bool isPCRel = X86II::isImmPCRel(TSFlags); bool isPCRel = X86II::isImmPCRel(TSFlags);
switch (Size) { switch (Size) {
default: assert(0 && "Unknown immediate size"); default: assert(0 && "Unknown immediate size");
case 1: return isPCRel ? MCFixupKind(X86::reloc_pcrel_1byte) : FK_Data_1; case 1: return isPCRel ? MCFixupKind(X86::reloc_pcrel_1byte) : FK_Data_1;
@ -190,7 +190,7 @@ EmitImmediate(const MCOperand &DispOp, unsigned Size, MCFixupKind FixupKind,
// If we have an immoffset, add it to the expression. // If we have an immoffset, add it to the expression.
const MCExpr *Expr = DispOp.getExpr(); const MCExpr *Expr = DispOp.getExpr();
// If the fixup is pc-relative, we need to bias the value to be relative to // If the fixup is pc-relative, we need to bias the value to be relative to
// the start of the field, not the end of the field. // the start of the field, not the end of the field.
if (FixupKind == MCFixupKind(X86::reloc_pcrel_4byte) || if (FixupKind == MCFixupKind(X86::reloc_pcrel_4byte) ||
@ -201,11 +201,11 @@ EmitImmediate(const MCOperand &DispOp, unsigned Size, MCFixupKind FixupKind,
ImmOffset -= 2; ImmOffset -= 2;
if (FixupKind == MCFixupKind(X86::reloc_pcrel_1byte)) if (FixupKind == MCFixupKind(X86::reloc_pcrel_1byte))
ImmOffset -= 1; ImmOffset -= 1;
if (ImmOffset) if (ImmOffset)
Expr = MCBinaryExpr::CreateAdd(Expr, MCConstantExpr::Create(ImmOffset, Ctx), Expr = MCBinaryExpr::CreateAdd(Expr, MCConstantExpr::Create(ImmOffset, Ctx),
Ctx); Ctx);
// Emit a symbolic constant as a fixup and 4 zeros. // Emit a symbolic constant as a fixup and 4 zeros.
Fixups.push_back(MCFixup::Create(CurByte, Expr, FixupKind)); Fixups.push_back(MCFixup::Create(CurByte, Expr, FixupKind));
EmitConstant(0, Size, CurByte, OS); EmitConstant(0, Size, CurByte, OS);
@ -221,43 +221,43 @@ void X86MCCodeEmitter::EmitMemModRMByte(const MCInst &MI, unsigned Op,
const MCOperand &Scale = MI.getOperand(Op+1); const MCOperand &Scale = MI.getOperand(Op+1);
const MCOperand &IndexReg = MI.getOperand(Op+2); const MCOperand &IndexReg = MI.getOperand(Op+2);
unsigned BaseReg = Base.getReg(); unsigned BaseReg = Base.getReg();
// Handle %rip relative addressing. // Handle %rip relative addressing.
if (BaseReg == X86::RIP) { // [disp32+RIP] in X86-64 mode if (BaseReg == X86::RIP) { // [disp32+RIP] in X86-64 mode
assert(Is64BitMode && "Rip-relative addressing requires 64-bit mode"); assert(Is64BitMode && "Rip-relative addressing requires 64-bit mode");
assert(IndexReg.getReg() == 0 && "Invalid rip-relative address"); assert(IndexReg.getReg() == 0 && "Invalid rip-relative address");
EmitByte(ModRMByte(0, RegOpcodeField, 5), CurByte, OS); EmitByte(ModRMByte(0, RegOpcodeField, 5), CurByte, OS);
unsigned FixupKind = X86::reloc_riprel_4byte; unsigned FixupKind = X86::reloc_riprel_4byte;
// movq loads are handled with a special relocation form which allows the // movq loads are handled with a special relocation form which allows the
// linker to eliminate some loads for GOT references which end up in the // linker to eliminate some loads for GOT references which end up in the
// same linkage unit. // same linkage unit.
if (MI.getOpcode() == X86::MOV64rm || if (MI.getOpcode() == X86::MOV64rm ||
MI.getOpcode() == X86::MOV64rm_TC) MI.getOpcode() == X86::MOV64rm_TC)
FixupKind = X86::reloc_riprel_4byte_movq_load; FixupKind = X86::reloc_riprel_4byte_movq_load;
// rip-relative addressing is actually relative to the *next* instruction. // rip-relative addressing is actually relative to the *next* instruction.
// Since an immediate can follow the mod/rm byte for an instruction, this // Since an immediate can follow the mod/rm byte for an instruction, this
// means that we need to bias the immediate field of the instruction with // means that we need to bias the immediate field of the instruction with
// the size of the immediate field. If we have this case, add it into the // the size of the immediate field. If we have this case, add it into the
// expression to emit. // expression to emit.
int ImmSize = X86II::hasImm(TSFlags) ? X86II::getSizeOfImm(TSFlags) : 0; int ImmSize = X86II::hasImm(TSFlags) ? X86II::getSizeOfImm(TSFlags) : 0;
EmitImmediate(Disp, 4, MCFixupKind(FixupKind), EmitImmediate(Disp, 4, MCFixupKind(FixupKind),
CurByte, OS, Fixups, -ImmSize); CurByte, OS, Fixups, -ImmSize);
return; return;
} }
unsigned BaseRegNo = BaseReg ? GetX86RegNum(Base) : -1U; unsigned BaseRegNo = BaseReg ? GetX86RegNum(Base) : -1U;
// Determine whether a SIB byte is needed. // Determine whether a SIB byte is needed.
// If no BaseReg, issue a RIP relative instruction only if the MCE can // If no BaseReg, issue a RIP relative instruction only if the MCE can
// resolve addresses on-the-fly, otherwise use SIB (Intel Manual 2A, table // resolve addresses on-the-fly, otherwise use SIB (Intel Manual 2A, table
// 2-7) and absolute references. // 2-7) and absolute references.
if (// The SIB byte must be used if there is an index register. if (// The SIB byte must be used if there is an index register.
IndexReg.getReg() == 0 && IndexReg.getReg() == 0 &&
// The SIB byte must be used if the base is ESP/RSP/R12, all of which // The SIB byte must be used if the base is ESP/RSP/R12, all of which
// encode to an R/M value of 4, which indicates that a SIB byte is // encode to an R/M value of 4, which indicates that a SIB byte is
// present. // present.
@ -271,7 +271,7 @@ void X86MCCodeEmitter::EmitMemModRMByte(const MCInst &MI, unsigned Op,
EmitImmediate(Disp, 4, FK_Data_4, CurByte, OS, Fixups); EmitImmediate(Disp, 4, FK_Data_4, CurByte, OS, Fixups);
return; return;
} }
// If the base is not EBP/ESP and there is no displacement, use simple // If the base is not EBP/ESP and there is no displacement, use simple
// indirect register encoding, this handles addresses like [EAX]. The // indirect register encoding, this handles addresses like [EAX]. The
// encoding for [EBP] with no displacement means [disp32] so we handle it // encoding for [EBP] with no displacement means [disp32] so we handle it
@ -280,24 +280,24 @@ void X86MCCodeEmitter::EmitMemModRMByte(const MCInst &MI, unsigned Op,
EmitByte(ModRMByte(0, RegOpcodeField, BaseRegNo), CurByte, OS); EmitByte(ModRMByte(0, RegOpcodeField, BaseRegNo), CurByte, OS);
return; return;
} }
// Otherwise, if the displacement fits in a byte, encode as [REG+disp8]. // Otherwise, if the displacement fits in a byte, encode as [REG+disp8].
if (Disp.isImm() && isDisp8(Disp.getImm())) { if (Disp.isImm() && isDisp8(Disp.getImm())) {
EmitByte(ModRMByte(1, RegOpcodeField, BaseRegNo), CurByte, OS); EmitByte(ModRMByte(1, RegOpcodeField, BaseRegNo), CurByte, OS);
EmitImmediate(Disp, 1, FK_Data_1, CurByte, OS, Fixups); EmitImmediate(Disp, 1, FK_Data_1, CurByte, OS, Fixups);
return; return;
} }
// Otherwise, emit the most general non-SIB encoding: [REG+disp32] // Otherwise, emit the most general non-SIB encoding: [REG+disp32]
EmitByte(ModRMByte(2, RegOpcodeField, BaseRegNo), CurByte, OS); EmitByte(ModRMByte(2, RegOpcodeField, BaseRegNo), CurByte, OS);
EmitImmediate(Disp, 4, FK_Data_4, CurByte, OS, Fixups); EmitImmediate(Disp, 4, FK_Data_4, CurByte, OS, Fixups);
return; return;
} }
// We need a SIB byte, so start by outputting the ModR/M byte first // We need a SIB byte, so start by outputting the ModR/M byte first
assert(IndexReg.getReg() != X86::ESP && assert(IndexReg.getReg() != X86::ESP &&
IndexReg.getReg() != X86::RSP && "Cannot use ESP as index reg!"); IndexReg.getReg() != X86::RSP && "Cannot use ESP as index reg!");
bool ForceDisp32 = false; bool ForceDisp32 = false;
bool ForceDisp8 = false; bool ForceDisp8 = false;
if (BaseReg == 0) { if (BaseReg == 0) {
@ -323,13 +323,13 @@ void X86MCCodeEmitter::EmitMemModRMByte(const MCInst &MI, unsigned Op,
// Emit the normal disp32 encoding. // Emit the normal disp32 encoding.
EmitByte(ModRMByte(2, RegOpcodeField, 4), CurByte, OS); EmitByte(ModRMByte(2, RegOpcodeField, 4), CurByte, OS);
} }
// Calculate what the SS field value should be... // Calculate what the SS field value should be...
static const unsigned SSTable[] = { ~0, 0, 1, ~0, 2, ~0, ~0, ~0, 3 }; static const unsigned SSTable[] = { ~0, 0, 1, ~0, 2, ~0, ~0, ~0, 3 };
unsigned SS = SSTable[Scale.getImm()]; unsigned SS = SSTable[Scale.getImm()];
if (BaseReg == 0) { if (BaseReg == 0) {
// Handle the SIB byte for the case where there is no base, see Intel // Handle the SIB byte for the case where there is no base, see Intel
// Manual 2A, table 2-7. The displacement has already been output. // Manual 2A, table 2-7. The displacement has already been output.
unsigned IndexRegNo; unsigned IndexRegNo;
if (IndexReg.getReg()) if (IndexReg.getReg())
@ -345,7 +345,7 @@ void X86MCCodeEmitter::EmitMemModRMByte(const MCInst &MI, unsigned Op,
IndexRegNo = 4; // For example [ESP+1*<noreg>+4] IndexRegNo = 4; // For example [ESP+1*<noreg>+4]
EmitSIBByte(SS, IndexRegNo, GetX86RegNum(Base), CurByte, OS); EmitSIBByte(SS, IndexRegNo, GetX86RegNum(Base), CurByte, OS);
} }
// Do we need to output a displacement? // Do we need to output a displacement?
if (ForceDisp8) if (ForceDisp8)
EmitImmediate(Disp, 1, FK_Data_1, CurByte, OS, Fixups); EmitImmediate(Disp, 1, FK_Data_1, CurByte, OS, Fixups);
@ -547,18 +547,18 @@ static unsigned DetermineREXPrefix(const MCInst &MI, uint64_t TSFlags,
// Pseudo instructions never have a rex byte. // Pseudo instructions never have a rex byte.
if ((TSFlags & X86II::FormMask) == X86II::Pseudo) if ((TSFlags & X86II::FormMask) == X86II::Pseudo)
return 0; return 0;
unsigned REX = 0; unsigned REX = 0;
if (TSFlags & X86II::REX_W) if (TSFlags & X86II::REX_W)
REX |= 1 << 3; // set REX.W REX |= 1 << 3; // set REX.W
if (MI.getNumOperands() == 0) return REX; if (MI.getNumOperands() == 0) return REX;
unsigned NumOps = MI.getNumOperands(); unsigned NumOps = MI.getNumOperands();
// FIXME: MCInst should explicitize the two-addrness. // FIXME: MCInst should explicitize the two-addrness.
bool isTwoAddr = NumOps > 1 && bool isTwoAddr = NumOps > 1 &&
Desc.getOperandConstraint(1, TOI::TIED_TO) != -1; Desc.getOperandConstraint(1, TOI::TIED_TO) != -1;
// If it accesses SPL, BPL, SIL, or DIL, then it requires a 0x40 REX prefix. // If it accesses SPL, BPL, SIL, or DIL, then it requires a 0x40 REX prefix.
unsigned i = isTwoAddr ? 1 : 0; unsigned i = isTwoAddr ? 1 : 0;
for (; i != NumOps; ++i) { for (; i != NumOps; ++i) {
@ -571,7 +571,7 @@ static unsigned DetermineREXPrefix(const MCInst &MI, uint64_t TSFlags,
REX |= 0x40; // REX fixed encoding prefix REX |= 0x40; // REX fixed encoding prefix
break; break;
} }
switch (TSFlags & X86II::FormMask) { switch (TSFlags & X86II::FormMask) {
case X86II::MRMInitReg: assert(0 && "FIXME: Remove this!"); case X86II::MRMInitReg: assert(0 && "FIXME: Remove this!");
case X86II::MRMSrcReg: case X86II::MRMSrcReg:
@ -642,14 +642,14 @@ static unsigned DetermineREXPrefix(const MCInst &MI, uint64_t TSFlags,
/// MemOperand is the operand # of the start of a memory operand if present. If /// MemOperand is the operand # of the start of a memory operand if present. If
/// Not present, it is -1. /// Not present, it is -1.
void X86MCCodeEmitter::EmitOpcodePrefix(uint64_t TSFlags, unsigned &CurByte, void X86MCCodeEmitter::EmitOpcodePrefix(uint64_t TSFlags, unsigned &CurByte,
int MemOperand, const MCInst &MI, int MemOperand, const MCInst &MI,
const TargetInstrDesc &Desc, const TargetInstrDesc &Desc,
raw_ostream &OS) const { raw_ostream &OS) const {
// Emit the lock opcode prefix as needed. // Emit the lock opcode prefix as needed.
if (TSFlags & X86II::LOCK) if (TSFlags & X86II::LOCK)
EmitByte(0xF0, CurByte, OS); EmitByte(0xF0, CurByte, OS);
// Emit segment override opcode prefix as needed. // Emit segment override opcode prefix as needed.
switch (TSFlags & X86II::SegOvrMask) { switch (TSFlags & X86II::SegOvrMask) {
default: assert(0 && "Invalid segment!"); default: assert(0 && "Invalid segment!");
@ -675,19 +675,19 @@ void X86MCCodeEmitter::EmitOpcodePrefix(uint64_t TSFlags, unsigned &CurByte,
EmitByte(0x65, CurByte, OS); EmitByte(0x65, CurByte, OS);
break; break;
} }
// Emit the repeat opcode prefix as needed. // Emit the repeat opcode prefix as needed.
if ((TSFlags & X86II::Op0Mask) == X86II::REP) if ((TSFlags & X86II::Op0Mask) == X86II::REP)
EmitByte(0xF3, CurByte, OS); EmitByte(0xF3, CurByte, OS);
// Emit the operand size opcode prefix as needed. // Emit the operand size opcode prefix as needed.
if (TSFlags & X86II::OpSize) if (TSFlags & X86II::OpSize)
EmitByte(0x66, CurByte, OS); EmitByte(0x66, CurByte, OS);
// Emit the address size opcode prefix as needed. // Emit the address size opcode prefix as needed.
if (TSFlags & X86II::AdSize) if (TSFlags & X86II::AdSize)
EmitByte(0x67, CurByte, OS); EmitByte(0x67, CurByte, OS);
bool Need0FPrefix = false; bool Need0FPrefix = false;
switch (TSFlags & X86II::Op0Mask) { switch (TSFlags & X86II::Op0Mask) {
default: assert(0 && "Invalid prefix!"); default: assert(0 && "Invalid prefix!");
@ -719,18 +719,18 @@ void X86MCCodeEmitter::EmitOpcodePrefix(uint64_t TSFlags, unsigned &CurByte,
case X86II::DE: EmitByte(0xDE, CurByte, OS); break; case X86II::DE: EmitByte(0xDE, CurByte, OS); break;
case X86II::DF: EmitByte(0xDF, CurByte, OS); break; case X86II::DF: EmitByte(0xDF, CurByte, OS); break;
} }
// Handle REX prefix. // Handle REX prefix.
// FIXME: Can this come before F2 etc to simplify emission? // FIXME: Can this come before F2 etc to simplify emission?
if (Is64BitMode) { if (Is64BitMode) {
if (unsigned REX = DetermineREXPrefix(MI, TSFlags, Desc)) if (unsigned REX = DetermineREXPrefix(MI, TSFlags, Desc))
EmitByte(0x40 | REX, CurByte, OS); EmitByte(0x40 | REX, CurByte, OS);
} }
// 0x0F escape code must be emitted just before the opcode. // 0x0F escape code must be emitted just before the opcode.
if (Need0FPrefix) if (Need0FPrefix)
EmitByte(0x0F, CurByte, OS); EmitByte(0x0F, CurByte, OS);
// FIXME: Pull this up into previous switch if REX can be moved earlier. // FIXME: Pull this up into previous switch if REX can be moved earlier.
switch (TSFlags & X86II::Op0Mask) { switch (TSFlags & X86II::Op0Mask) {
case X86II::TF: // F2 0F 38 case X86II::TF: // F2 0F 38
@ -750,7 +750,7 @@ EncodeInstruction(const MCInst &MI, raw_ostream &OS,
const TargetInstrDesc &Desc = TII.get(Opcode); const TargetInstrDesc &Desc = TII.get(Opcode);
uint64_t TSFlags = Desc.TSFlags; uint64_t TSFlags = Desc.TSFlags;
// If this is a two-address instruction, skip one of the register operands. // If this is a two-address instruction, skip one of the register operands.
// FIXME: This should be handled during MCInst lowering. // FIXME: This should be handled during MCInst lowering.
unsigned NumOps = Desc.getNumOperands(); unsigned NumOps = Desc.getNumOperands();
@ -760,10 +760,10 @@ EncodeInstruction(const MCInst &MI, raw_ostream &OS,
else if (NumOps > 2 && Desc.getOperandConstraint(NumOps-1, TOI::TIED_TO)== 0) else if (NumOps > 2 && Desc.getOperandConstraint(NumOps-1, TOI::TIED_TO)== 0)
// Skip the last source operand that is tied_to the dest reg. e.g. LXADD32 // Skip the last source operand that is tied_to the dest reg. e.g. LXADD32
--NumOps; --NumOps;
// Keep track of the current byte being emitted. // Keep track of the current byte being emitted.
unsigned CurByte = 0; unsigned CurByte = 0;
// Is this instruction encoded using the AVX VEX prefix? // Is this instruction encoded using the AVX VEX prefix?
bool HasVEXPrefix = false; bool HasVEXPrefix = false;
@ -774,17 +774,17 @@ EncodeInstruction(const MCInst &MI, raw_ostream &OS,
HasVEXPrefix = true; HasVEXPrefix = true;
if ((TSFlags >> 32) & X86II::VEX_4V) if ((TSFlags >> 32) & X86II::VEX_4V)
HasVEX_4V = true; HasVEX_4V = true;
// Determine where the memory operand starts, if present. // Determine where the memory operand starts, if present.
int MemoryOperand = X86II::getMemoryOperandNo(TSFlags); int MemoryOperand = X86II::getMemoryOperandNo(TSFlags);
if (MemoryOperand != -1) MemoryOperand += CurOp; if (MemoryOperand != -1) MemoryOperand += CurOp;
if (!HasVEXPrefix) if (!HasVEXPrefix)
EmitOpcodePrefix(TSFlags, CurByte, MemoryOperand, MI, Desc, OS); EmitOpcodePrefix(TSFlags, CurByte, MemoryOperand, MI, Desc, OS);
else else
// FIXME: Segment overrides?? // FIXME: Segment overrides??
EmitVEXOpcodePrefix(TSFlags, CurByte, MI, Desc, OS); EmitVEXOpcodePrefix(TSFlags, CurByte, MI, Desc, OS);
unsigned char BaseOpcode = X86II::getBaseOpcodeFor(TSFlags); unsigned char BaseOpcode = X86II::getBaseOpcodeFor(TSFlags);
unsigned SrcRegNum = 0; unsigned SrcRegNum = 0;
switch (TSFlags & X86II::FormMask) { switch (TSFlags & X86II::FormMask) {
@ -796,18 +796,18 @@ EncodeInstruction(const MCInst &MI, raw_ostream &OS,
case X86II::RawFrm: case X86II::RawFrm:
EmitByte(BaseOpcode, CurByte, OS); EmitByte(BaseOpcode, CurByte, OS);
break; break;
case X86II::AddRegFrm: case X86II::AddRegFrm:
EmitByte(BaseOpcode + GetX86RegNum(MI.getOperand(CurOp++)), CurByte, OS); EmitByte(BaseOpcode + GetX86RegNum(MI.getOperand(CurOp++)), CurByte, OS);
break; break;
case X86II::MRMDestReg: case X86II::MRMDestReg:
EmitByte(BaseOpcode, CurByte, OS); EmitByte(BaseOpcode, CurByte, OS);
EmitRegModRMByte(MI.getOperand(CurOp), EmitRegModRMByte(MI.getOperand(CurOp),
GetX86RegNum(MI.getOperand(CurOp+1)), CurByte, OS); GetX86RegNum(MI.getOperand(CurOp+1)), CurByte, OS);
CurOp += 2; CurOp += 2;
break; break;
case X86II::MRMDestMem: case X86II::MRMDestMem:
EmitByte(BaseOpcode, CurByte, OS); EmitByte(BaseOpcode, CurByte, OS);
EmitMemModRMByte(MI, CurOp, EmitMemModRMByte(MI, CurOp,
@ -815,7 +815,7 @@ EncodeInstruction(const MCInst &MI, raw_ostream &OS,
TSFlags, CurByte, OS, Fixups); TSFlags, CurByte, OS, Fixups);
CurOp += X86::AddrNumOperands + 1; CurOp += X86::AddrNumOperands + 1;
break; break;
case X86II::MRMSrcReg: case X86II::MRMSrcReg:
EmitByte(BaseOpcode, CurByte, OS); EmitByte(BaseOpcode, CurByte, OS);
SrcRegNum = CurOp + 1; SrcRegNum = CurOp + 1;
@ -827,7 +827,7 @@ EncodeInstruction(const MCInst &MI, raw_ostream &OS,
GetX86RegNum(MI.getOperand(CurOp)), CurByte, OS); GetX86RegNum(MI.getOperand(CurOp)), CurByte, OS);
CurOp = SrcRegNum + 1; CurOp = SrcRegNum + 1;
break; break;
case X86II::MRMSrcMem: { case X86II::MRMSrcMem: {
int AddrOperands = X86::AddrNumOperands; int AddrOperands = X86::AddrNumOperands;
unsigned FirstMemOp = CurOp+1; unsigned FirstMemOp = CurOp+1;
@ -837,7 +837,7 @@ EncodeInstruction(const MCInst &MI, raw_ostream &OS,
} }
EmitByte(BaseOpcode, CurByte, OS); EmitByte(BaseOpcode, CurByte, OS);
EmitMemModRMByte(MI, FirstMemOp, GetX86RegNum(MI.getOperand(CurOp)), EmitMemModRMByte(MI, FirstMemOp, GetX86RegNum(MI.getOperand(CurOp)),
TSFlags, CurByte, OS, Fixups); TSFlags, CurByte, OS, Fixups);
CurOp += AddrOperands + 1; CurOp += AddrOperands + 1;
@ -905,7 +905,7 @@ EncodeInstruction(const MCInst &MI, raw_ostream &OS,
EmitByte(0xF9, CurByte, OS); EmitByte(0xF9, CurByte, OS);
break; break;
} }
// If there is a remaining operand, it must be a trailing immediate. Emit it // If there is a remaining operand, it must be a trailing immediate. Emit it
// according to the right size for the instruction. // according to the right size for the instruction.
if (CurOp != NumOps) { if (CurOp != NumOps) {