2012-02-18 12:03:15 +00:00
|
|
|
//===-- X86InstrInfo.td - Main X86 Instruction Definition --*- tablegen -*-===//
|
2010-10-20 23:40:27 +00:00
|
|
|
//
|
2003-10-21 15:17:13 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2010-10-20 23:40:27 +00:00
|
|
|
//
|
2003-10-21 15:17:13 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2003-08-03 21:54:21 +00:00
|
|
|
//
|
|
|
|
// This file describes the X86 instruction set, defining the instructions, and
|
|
|
|
// properties of the instructions which are needed for code generation, machine
|
|
|
|
// code emission, and analysis.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2005-12-17 01:24:02 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// X86 specific DAG Nodes.
|
|
|
|
//
|
|
|
|
|
2006-01-09 18:33:28 +00:00
|
|
|
def SDTIntShiftDOp: SDTypeProfile<1, 3,
|
|
|
|
[SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>,
|
|
|
|
SDTCisInt<0>, SDTCisInt<3>]>;
|
|
|
|
|
Now that tblgen can handle matching implicit defs of instructions
to input patterns, we can fix X86ISD::CMP and X86ISD::BT as taking
two inputs (which have to be the same type) and *returning an i32*.
This is how the SDNodes get made in the graph, but we weren't able
to model it this way due to deficiencies in the pattern language.
Now we can change things like this:
def UCOM_FpIr80: FpI_<(outs), (ins RFP80:$lhs, RFP80:$rhs), CompareFP,
- [(X86cmp RFP80:$lhs, RFP80:$rhs),
- (implicit EFLAGS)]>; // CC = ST(0) cmp ST(i)
+ [(set EFLAGS, (X86cmp RFP80:$lhs, RFP80:$rhs))]>;
and fix terrible crimes like this:
-def : Pat<(parallel (X86cmp GR8:$src1, 0), (implicit EFLAGS)),
+def : Pat<(X86cmp GR8:$src1, 0),
(TEST8rr GR8:$src1, GR8:$src1)>;
This relies on matching the result of TEST8rr (which is EFLAGS, which is
an implicit def) to the result of X86cmp, an i32.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@98903 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-19 00:01:11 +00:00
|
|
|
def SDTX86CmpTest : SDTypeProfile<1, 2, [SDTCisVT<0, i32>, SDTCisSameAs<1, 2>]>;
|
2005-12-17 01:24:02 +00:00
|
|
|
|
2013-12-16 13:52:35 +00:00
|
|
|
def SDTX86Cmps : SDTypeProfile<1, 3, [SDTCisFP<0>, SDTCisSameAs<1, 2>, SDTCisVT<3, i8>]>;
|
|
|
|
//def SDTX86Cmpss : SDTypeProfile<1, 3, [SDTCisVT<0, f32>, SDTCisSameAs<1, 2>, SDTCisVT<3, i8>]>;
|
2011-06-03 23:53:54 +00:00
|
|
|
|
2007-09-29 00:00:36 +00:00
|
|
|
def SDTX86Cmov : SDTypeProfile<1, 4,
|
2007-09-25 01:57:46 +00:00
|
|
|
[SDTCisSameAs<0, 1>, SDTCisSameAs<1, 2>,
|
|
|
|
SDTCisVT<3, i8>, SDTCisVT<4, i32>]>;
|
2005-12-17 01:24:02 +00:00
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Unary and binary operator instructions that set EFLAGS as a side-effect.
|
2010-03-24 00:47:47 +00:00
|
|
|
def SDTUnaryArithWithFlags : SDTypeProfile<2, 1,
|
|
|
|
[SDTCisInt<0>, SDTCisVT<1, i32>]>;
|
|
|
|
|
2010-03-24 00:49:29 +00:00
|
|
|
def SDTBinaryArithWithFlags : SDTypeProfile<2, 2,
|
|
|
|
[SDTCisSameAs<0, 2>,
|
|
|
|
SDTCisSameAs<0, 3>,
|
|
|
|
SDTCisInt<0>, SDTCisVT<1, i32>]>;
|
2010-12-20 00:59:46 +00:00
|
|
|
|
2011-01-26 02:03:37 +00:00
|
|
|
// SDTBinaryArithWithFlagsInOut - RES1, EFLAGS = op LHS, RHS, EFLAGS
|
2010-12-20 00:59:46 +00:00
|
|
|
def SDTBinaryArithWithFlagsInOut : SDTypeProfile<2, 3,
|
|
|
|
[SDTCisSameAs<0, 2>,
|
|
|
|
SDTCisSameAs<0, 3>,
|
|
|
|
SDTCisInt<0>,
|
|
|
|
SDTCisVT<1, i32>,
|
|
|
|
SDTCisVT<4, i32>]>;
|
it turns out that when ".with.overflow" intrinsics were added to the X86
backend that they were all implemented except umul. This one fell back
to the default implementation that did a hi/lo multiply and compared the
top. Fix this to check the overflow flag that the 'mul' instruction
sets, so we can avoid an explicit test. Now we compile:
void *func(long count) {
return new int[count];
}
into:
__Z4funcl: ## @_Z4funcl
movl $4, %ecx ## encoding: [0xb9,0x04,0x00,0x00,0x00]
movq %rdi, %rax ## encoding: [0x48,0x89,0xf8]
mulq %rcx ## encoding: [0x48,0xf7,0xe1]
seto %cl ## encoding: [0x0f,0x90,0xc1]
testb %cl, %cl ## encoding: [0x84,0xc9]
movq $-1, %rdi ## encoding: [0x48,0xc7,0xc7,0xff,0xff,0xff,0xff]
cmoveq %rax, %rdi ## encoding: [0x48,0x0f,0x44,0xf8]
jmp __Znam ## TAILCALL
instead of:
__Z4funcl: ## @_Z4funcl
movl $4, %ecx ## encoding: [0xb9,0x04,0x00,0x00,0x00]
movq %rdi, %rax ## encoding: [0x48,0x89,0xf8]
mulq %rcx ## encoding: [0x48,0xf7,0xe1]
testq %rdx, %rdx ## encoding: [0x48,0x85,0xd2]
movq $-1, %rdi ## encoding: [0x48,0xc7,0xc7,0xff,0xff,0xff,0xff]
cmoveq %rax, %rdi ## encoding: [0x48,0x0f,0x44,0xf8]
jmp __Znam ## TAILCALL
Other than the silly seto+test, this is using the o bit directly, so it's going in the right
direction.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@120935 91177308-0d34-0410-b5e6-96231b3b80d8
2010-12-05 07:30:36 +00:00
|
|
|
// RES1, RES2, FLAGS = op LHS, RHS
|
|
|
|
def SDT2ResultBinaryArithWithFlags : SDTypeProfile<3, 2,
|
|
|
|
[SDTCisSameAs<0, 1>,
|
|
|
|
SDTCisSameAs<0, 2>,
|
|
|
|
SDTCisSameAs<0, 3>,
|
|
|
|
SDTCisInt<0>, SDTCisVT<1, i32>]>;
|
2007-09-29 00:00:36 +00:00
|
|
|
def SDTX86BrCond : SDTypeProfile<0, 3,
|
2007-09-25 01:57:46 +00:00
|
|
|
[SDTCisVT<0, OtherVT>,
|
|
|
|
SDTCisVT<1, i8>, SDTCisVT<2, i32>]>;
|
2005-12-17 01:24:02 +00:00
|
|
|
|
2007-09-29 00:00:36 +00:00
|
|
|
def SDTX86SetCC : SDTypeProfile<1, 2,
|
2007-09-25 01:57:46 +00:00
|
|
|
[SDTCisVT<0, i8>,
|
|
|
|
SDTCisVT<1, i8>, SDTCisVT<2, i32>]>;
|
2009-12-16 00:53:11 +00:00
|
|
|
def SDTX86SetCC_C : SDTypeProfile<1, 2,
|
|
|
|
[SDTCisInt<0>,
|
|
|
|
SDTCisVT<1, i8>, SDTCisVT<2, i32>]>;
|
2005-12-21 20:21:51 +00:00
|
|
|
|
2012-04-27 12:07:43 +00:00
|
|
|
def SDTX86sahf : SDTypeProfile<1, 1, [SDTCisVT<0, i32>, SDTCisVT<1, i8>]>;
|
|
|
|
|
2012-07-12 09:31:43 +00:00
|
|
|
def SDTX86rdrand : SDTypeProfile<2, 0, [SDTCisInt<0>, SDTCisVT<1, i32>]>;
|
|
|
|
|
2010-10-20 23:40:27 +00:00
|
|
|
def SDTX86cas : SDTypeProfile<0, 3, [SDTCisPtrTy<0>, SDTCisInt<1>,
|
2008-03-01 21:52:34 +00:00
|
|
|
SDTCisVT<2, i8>]>;
|
2011-08-26 21:21:21 +00:00
|
|
|
def SDTX86caspair : SDTypeProfile<0, 1, [SDTCisPtrTy<0>]>;
|
2008-03-01 21:52:34 +00:00
|
|
|
|
2008-10-02 18:53:47 +00:00
|
|
|
def SDTX86atomicBinary : SDTypeProfile<2, 3, [SDTCisInt<0>, SDTCisInt<1>,
|
|
|
|
SDTCisPtrTy<2>, SDTCisInt<3>,SDTCisInt<4>]>;
|
2008-03-11 03:23:40 +00:00
|
|
|
def SDTX86Ret : SDTypeProfile<0, -1, [SDTCisVT<0, i16>]>;
|
2005-12-19 23:12:38 +00:00
|
|
|
|
2009-06-23 23:25:37 +00:00
|
|
|
def SDT_X86CallSeqStart : SDCallSeqStart<[SDTCisVT<0, i32>]>;
|
|
|
|
def SDT_X86CallSeqEnd : SDCallSeqEnd<[SDTCisVT<0, i32>,
|
|
|
|
SDTCisVT<1, i32>]>;
|
2006-01-09 18:33:28 +00:00
|
|
|
|
2008-05-29 19:57:41 +00:00
|
|
|
def SDT_X86Call : SDTypeProfile<0, -1, [SDTCisVT<0, iPTR>]>;
|
2006-01-09 18:33:28 +00:00
|
|
|
|
2009-08-15 01:38:56 +00:00
|
|
|
def SDT_X86VASTART_SAVE_XMM_REGS : SDTypeProfile<0, -1, [SDTCisVT<0, i8>,
|
|
|
|
SDTCisVT<1, iPTR>,
|
|
|
|
SDTCisVT<2, iPTR>]>;
|
|
|
|
|
2010-10-12 18:00:49 +00:00
|
|
|
def SDT_X86VAARG_64 : SDTypeProfile<1, -1, [SDTCisPtrTy<0>,
|
|
|
|
SDTCisPtrTy<1>,
|
|
|
|
SDTCisVT<2, i32>,
|
|
|
|
SDTCisVT<3, i8>,
|
|
|
|
SDTCisVT<4, i32>]>;
|
|
|
|
|
2010-03-28 07:38:39 +00:00
|
|
|
def SDTX86RepStr : SDTypeProfile<0, 1, [SDTCisVT<0, OtherVT>]>;
|
|
|
|
|
2010-03-06 19:32:29 +00:00
|
|
|
def SDTX86Void : SDTypeProfile<0, 0, []>;
|
2005-12-21 02:39:21 +00:00
|
|
|
|
2006-02-25 10:02:21 +00:00
|
|
|
def SDTX86Wrapper : SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>, SDTCisPtrTy<0>]>;
|
|
|
|
|
2009-04-17 14:35:58 +00:00
|
|
|
def SDT_X86TLSADDR : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
|
2007-04-20 21:38:10 +00:00
|
|
|
|
2012-06-01 16:27:21 +00:00
|
|
|
def SDT_X86TLSBASEADDR : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
|
|
|
|
|
2010-12-09 06:25:53 +00:00
|
|
|
def SDT_X86TLSCALL : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
|
2010-06-03 04:07:48 +00:00
|
|
|
|
2011-08-30 19:43:21 +00:00
|
|
|
def SDT_X86SEG_ALLOCA : SDTypeProfile<1, 1, [SDTCisVT<0, iPTR>, SDTCisVT<1, iPTR>]>;
|
|
|
|
|
2012-02-24 19:01:22 +00:00
|
|
|
def SDT_X86WIN_FTOL : SDTypeProfile<0, 1, [SDTCisFP<0>]>;
|
|
|
|
|
2007-07-14 14:06:15 +00:00
|
|
|
def SDT_X86EHRET : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
|
|
|
|
|
2007-10-11 19:40:01 +00:00
|
|
|
def SDT_X86TCRET : SDTypeProfile<0, 2, [SDTCisPtrTy<0>, SDTCisVT<1, i32>]>;
|
|
|
|
|
2010-07-22 02:48:34 +00:00
|
|
|
def SDT_X86MEMBARRIER : SDTypeProfile<0, 0, []>;
|
|
|
|
|
|
|
|
def X86MemBarrier : SDNode<"X86ISD::MEMBARRIER", SDT_X86MEMBARRIER,
|
2012-08-24 00:31:10 +00:00
|
|
|
[SDNPHasChain,SDNPSideEffect]>;
|
2010-07-22 02:48:34 +00:00
|
|
|
def X86MFence : SDNode<"X86ISD::MFENCE", SDT_X86MEMBARRIER,
|
|
|
|
[SDNPHasChain]>;
|
|
|
|
def X86SFence : SDNode<"X86ISD::SFENCE", SDT_X86MEMBARRIER,
|
|
|
|
[SDNPHasChain]>;
|
|
|
|
def X86LFence : SDNode<"X86ISD::LFENCE", SDT_X86MEMBARRIER,
|
|
|
|
[SDNPHasChain]>;
|
|
|
|
|
|
|
|
|
2010-03-28 05:07:17 +00:00
|
|
|
def X86bsf : SDNode<"X86ISD::BSF", SDTUnaryArithWithFlags>;
|
|
|
|
def X86bsr : SDNode<"X86ISD::BSR", SDTUnaryArithWithFlags>;
|
2006-01-09 18:33:28 +00:00
|
|
|
def X86shld : SDNode<"X86ISD::SHLD", SDTIntShiftDOp>;
|
|
|
|
def X86shrd : SDNode<"X86ISD::SHRD", SDTIntShiftDOp>;
|
2005-12-21 02:39:21 +00:00
|
|
|
|
2007-09-29 00:00:36 +00:00
|
|
|
def X86cmp : SDNode<"X86ISD::CMP" , SDTX86CmpTest>;
|
2008-12-23 22:45:23 +00:00
|
|
|
def X86bt : SDNode<"X86ISD::BT", SDTX86CmpTest>;
|
|
|
|
|
2007-09-29 00:00:36 +00:00
|
|
|
def X86cmov : SDNode<"X86ISD::CMOV", SDTX86Cmov>;
|
2006-01-09 18:33:28 +00:00
|
|
|
def X86brcond : SDNode<"X86ISD::BRCOND", SDTX86BrCond,
|
2007-09-25 01:57:46 +00:00
|
|
|
[SDNPHasChain]>;
|
2007-09-29 00:00:36 +00:00
|
|
|
def X86setcc : SDNode<"X86ISD::SETCC", SDTX86SetCC>;
|
2009-12-16 00:53:11 +00:00
|
|
|
def X86setcc_c : SDNode<"X86ISD::SETCC_CARRY", SDTX86SetCC_C>;
|
2005-12-21 02:39:21 +00:00
|
|
|
|
2012-04-27 12:07:43 +00:00
|
|
|
def X86sahf : SDNode<"X86ISD::SAHF", SDTX86sahf>;
|
|
|
|
|
2012-07-12 18:14:57 +00:00
|
|
|
def X86rdrand : SDNode<"X86ISD::RDRAND", SDTX86rdrand,
|
|
|
|
[SDNPHasChain, SDNPSideEffect]>;
|
2012-07-12 09:31:43 +00:00
|
|
|
|
2013-03-28 23:41:26 +00:00
|
|
|
def X86rdseed : SDNode<"X86ISD::RDSEED", SDTX86rdrand,
|
|
|
|
[SDNPHasChain, SDNPSideEffect]>;
|
|
|
|
|
2008-03-01 21:52:34 +00:00
|
|
|
def X86cas : SDNode<"X86ISD::LCMPXCHG_DAG", SDTX86cas,
|
2010-12-23 18:28:41 +00:00
|
|
|
[SDNPHasChain, SDNPInGlue, SDNPOutGlue, SDNPMayStore,
|
2010-09-22 00:34:38 +00:00
|
|
|
SDNPMayLoad, SDNPMemOperand]>;
|
2011-08-26 21:21:21 +00:00
|
|
|
def X86cas8 : SDNode<"X86ISD::LCMPXCHG8_DAG", SDTX86caspair,
|
2010-12-23 18:28:41 +00:00
|
|
|
[SDNPHasChain, SDNPInGlue, SDNPOutGlue, SDNPMayStore,
|
2010-09-22 00:34:38 +00:00
|
|
|
SDNPMayLoad, SDNPMemOperand]>;
|
2011-08-26 21:21:21 +00:00
|
|
|
def X86cas16 : SDNode<"X86ISD::LCMPXCHG16_DAG", SDTX86caspair,
|
|
|
|
[SDNPHasChain, SDNPInGlue, SDNPOutGlue, SDNPMayStore,
|
|
|
|
SDNPMayLoad, SDNPMemOperand]>;
|
|
|
|
|
2006-01-09 18:33:28 +00:00
|
|
|
def X86retflag : SDNode<"X86ISD::RET_FLAG", SDTX86Ret,
|
2010-12-23 18:28:41 +00:00
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>;
|
2005-12-21 02:39:21 +00:00
|
|
|
|
2009-08-15 01:38:56 +00:00
|
|
|
def X86vastart_save_xmm_regs :
|
|
|
|
SDNode<"X86ISD::VASTART_SAVE_XMM_REGS",
|
|
|
|
SDT_X86VASTART_SAVE_XMM_REGS,
|
2010-03-19 05:07:09 +00:00
|
|
|
[SDNPHasChain, SDNPVariadic]>;
|
2010-10-12 18:00:49 +00:00
|
|
|
def X86vaarg64 :
|
|
|
|
SDNode<"X86ISD::VAARG_64", SDT_X86VAARG_64,
|
|
|
|
[SDNPHasChain, SDNPMayLoad, SDNPMayStore,
|
|
|
|
SDNPMemOperand]>;
|
2006-01-09 18:33:28 +00:00
|
|
|
def X86callseq_start :
|
|
|
|
SDNode<"ISD::CALLSEQ_START", SDT_X86CallSeqStart,
|
2010-12-23 18:28:41 +00:00
|
|
|
[SDNPHasChain, SDNPOutGlue]>;
|
2006-01-09 18:33:28 +00:00
|
|
|
def X86callseq_end :
|
|
|
|
SDNode<"ISD::CALLSEQ_END", SDT_X86CallSeqEnd,
|
2010-12-23 18:28:41 +00:00
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
|
2005-12-21 02:39:21 +00:00
|
|
|
|
2006-01-09 18:33:28 +00:00
|
|
|
def X86call : SDNode<"X86ISD::CALL", SDT_X86Call,
|
2010-12-23 18:28:41 +00:00
|
|
|
[SDNPHasChain, SDNPOutGlue, SDNPOptInGlue,
|
2010-03-19 05:07:09 +00:00
|
|
|
SDNPVariadic]>;
|
2005-12-17 01:24:02 +00:00
|
|
|
|
2010-03-28 07:38:39 +00:00
|
|
|
def X86rep_stos: SDNode<"X86ISD::REP_STOS", SDTX86RepStr,
|
2010-12-23 18:28:41 +00:00
|
|
|
[SDNPHasChain, SDNPInGlue, SDNPOutGlue, SDNPMayStore]>;
|
2010-03-28 07:38:39 +00:00
|
|
|
def X86rep_movs: SDNode<"X86ISD::REP_MOVS", SDTX86RepStr,
|
2010-12-23 18:28:41 +00:00
|
|
|
[SDNPHasChain, SDNPInGlue, SDNPOutGlue, SDNPMayStore,
|
2008-01-10 05:12:37 +00:00
|
|
|
SDNPMayLoad]>;
|
2006-01-11 22:15:48 +00:00
|
|
|
|
2010-03-06 19:32:29 +00:00
|
|
|
def X86rdtsc : SDNode<"X86ISD::RDTSC_DAG", SDTX86Void,
|
2010-12-23 18:28:41 +00:00
|
|
|
[SDNPHasChain, SDNPOutGlue, SDNPSideEffect]>;
|
2014-04-24 17:18:27 +00:00
|
|
|
def X86rdtscp : SDNode<"X86ISD::RDTSCP_DAG", SDTX86Void,
|
|
|
|
[SDNPHasChain, SDNPOutGlue, SDNPSideEffect]>;
|
2014-06-30 17:14:21 +00:00
|
|
|
def X86rdpmc : SDNode<"X86ISD::RDPMC_DAG", SDTX86Void,
|
2014-12-04 05:20:33 +00:00
|
|
|
[SDNPHasChain, SDNPOutGlue, SDNPSideEffect]>;
|
2006-01-05 00:27:02 +00:00
|
|
|
|
2006-11-30 21:55:46 +00:00
|
|
|
def X86Wrapper : SDNode<"X86ISD::Wrapper", SDTX86Wrapper>;
|
|
|
|
def X86WrapperRIP : SDNode<"X86ISD::WrapperRIP", SDTX86Wrapper>;
|
2006-02-25 10:02:21 +00:00
|
|
|
|
2007-04-20 21:38:10 +00:00
|
|
|
def X86tlsaddr : SDNode<"X86ISD::TLSADDR", SDT_X86TLSADDR,
|
2010-12-23 18:28:41 +00:00
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
|
2007-04-20 21:38:10 +00:00
|
|
|
|
2012-06-01 16:27:21 +00:00
|
|
|
def X86tlsbaseaddr : SDNode<"X86ISD::TLSBASEADDR", SDT_X86TLSBASEADDR,
|
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
|
|
|
|
|
2007-07-14 14:06:15 +00:00
|
|
|
def X86ehret : SDNode<"X86ISD::EH_RETURN", SDT_X86EHRET,
|
|
|
|
[SDNPHasChain]>;
|
|
|
|
|
2012-10-15 22:39:43 +00:00
|
|
|
def X86eh_sjlj_setjmp : SDNode<"X86ISD::EH_SJLJ_SETJMP",
|
|
|
|
SDTypeProfile<1, 1, [SDTCisInt<0>,
|
|
|
|
SDTCisPtrTy<1>]>,
|
|
|
|
[SDNPHasChain, SDNPSideEffect]>;
|
|
|
|
def X86eh_sjlj_longjmp : SDNode<"X86ISD::EH_SJLJ_LONGJMP",
|
|
|
|
SDTypeProfile<0, 1, [SDTCisPtrTy<0>]>,
|
|
|
|
[SDNPHasChain, SDNPSideEffect]>;
|
|
|
|
|
2010-10-20 23:40:27 +00:00
|
|
|
def X86tcret : SDNode<"X86ISD::TC_RETURN", SDT_X86TCRET,
|
2010-12-23 18:28:41 +00:00
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>;
|
2007-04-20 21:38:10 +00:00
|
|
|
|
2010-01-04 20:51:05 +00:00
|
|
|
def X86add_flag : SDNode<"X86ISD::ADD", SDTBinaryArithWithFlags,
|
2010-01-05 00:44:20 +00:00
|
|
|
[SDNPCommutative]>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def X86sub_flag : SDNode<"X86ISD::SUB", SDTBinaryArithWithFlags>;
|
2010-01-04 20:51:05 +00:00
|
|
|
def X86smul_flag : SDNode<"X86ISD::SMUL", SDTBinaryArithWithFlags,
|
2010-01-05 00:44:20 +00:00
|
|
|
[SDNPCommutative]>;
|
it turns out that when ".with.overflow" intrinsics were added to the X86
backend that they were all implemented except umul. This one fell back
to the default implementation that did a hi/lo multiply and compared the
top. Fix this to check the overflow flag that the 'mul' instruction
sets, so we can avoid an explicit test. Now we compile:
void *func(long count) {
return new int[count];
}
into:
__Z4funcl: ## @_Z4funcl
movl $4, %ecx ## encoding: [0xb9,0x04,0x00,0x00,0x00]
movq %rdi, %rax ## encoding: [0x48,0x89,0xf8]
mulq %rcx ## encoding: [0x48,0xf7,0xe1]
seto %cl ## encoding: [0x0f,0x90,0xc1]
testb %cl, %cl ## encoding: [0x84,0xc9]
movq $-1, %rdi ## encoding: [0x48,0xc7,0xc7,0xff,0xff,0xff,0xff]
cmoveq %rax, %rdi ## encoding: [0x48,0x0f,0x44,0xf8]
jmp __Znam ## TAILCALL
instead of:
__Z4funcl: ## @_Z4funcl
movl $4, %ecx ## encoding: [0xb9,0x04,0x00,0x00,0x00]
movq %rdi, %rax ## encoding: [0x48,0x89,0xf8]
mulq %rcx ## encoding: [0x48,0xf7,0xe1]
testq %rdx, %rdx ## encoding: [0x48,0x85,0xd2]
movq $-1, %rdi ## encoding: [0x48,0xc7,0xc7,0xff,0xff,0xff,0xff]
cmoveq %rax, %rdi ## encoding: [0x48,0x0f,0x44,0xf8]
jmp __Znam ## TAILCALL
Other than the silly seto+test, this is using the o bit directly, so it's going in the right
direction.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@120935 91177308-0d34-0410-b5e6-96231b3b80d8
2010-12-05 07:30:36 +00:00
|
|
|
def X86umul_flag : SDNode<"X86ISD::UMUL", SDT2ResultBinaryArithWithFlags,
|
2010-01-05 00:44:20 +00:00
|
|
|
[SDNPCommutative]>;
|
2010-12-20 00:59:46 +00:00
|
|
|
def X86adc_flag : SDNode<"X86ISD::ADC", SDTBinaryArithWithFlagsInOut>;
|
|
|
|
def X86sbb_flag : SDNode<"X86ISD::SBB", SDTBinaryArithWithFlagsInOut>;
|
2010-10-20 23:40:27 +00:00
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
def X86inc_flag : SDNode<"X86ISD::INC", SDTUnaryArithWithFlags>;
|
|
|
|
def X86dec_flag : SDNode<"X86ISD::DEC", SDTUnaryArithWithFlags>;
|
2010-01-04 20:51:05 +00:00
|
|
|
def X86or_flag : SDNode<"X86ISD::OR", SDTBinaryArithWithFlags,
|
2010-01-05 00:44:20 +00:00
|
|
|
[SDNPCommutative]>;
|
2010-01-04 20:51:05 +00:00
|
|
|
def X86xor_flag : SDNode<"X86ISD::XOR", SDTBinaryArithWithFlags,
|
2010-01-05 00:44:20 +00:00
|
|
|
[SDNPCommutative]>;
|
2010-01-04 20:51:05 +00:00
|
|
|
def X86and_flag : SDNode<"X86ISD::AND", SDTBinaryArithWithFlags,
|
2010-01-05 00:44:20 +00:00
|
|
|
[SDNPCommutative]>;
|
2008-12-12 00:56:36 +00:00
|
|
|
|
2013-10-01 03:48:26 +00:00
|
|
|
def X86bextr : SDNode<"X86ISD::BEXTR", SDTIntBinOp>;
|
2011-10-21 06:55:01 +00:00
|
|
|
|
2009-03-30 21:36:47 +00:00
|
|
|
def X86mul_imm : SDNode<"X86ISD::MUL_IMM", SDTIntBinOp>;
|
|
|
|
|
2010-10-21 01:41:01 +00:00
|
|
|
def X86WinAlloca : SDNode<"X86ISD::WIN_ALLOCA", SDTX86Void,
|
2010-12-23 18:28:41 +00:00
|
|
|
[SDNPHasChain, SDNPInGlue, SDNPOutGlue]>;
|
2010-10-21 01:41:01 +00:00
|
|
|
|
2011-08-30 19:43:21 +00:00
|
|
|
def X86SegAlloca : SDNode<"X86ISD::SEG_ALLOCA", SDT_X86SEG_ALLOCA,
|
|
|
|
[SDNPHasChain]>;
|
|
|
|
|
2010-06-03 04:07:48 +00:00
|
|
|
def X86TLSCall : SDNode<"X86ISD::TLSCALL", SDT_X86TLSCALL,
|
2010-12-23 18:28:41 +00:00
|
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
|
2010-03-06 19:32:29 +00:00
|
|
|
|
2012-02-24 19:01:22 +00:00
|
|
|
def X86WinFTOL : SDNode<"X86ISD::WIN_FTOL", SDT_X86WIN_FTOL,
|
|
|
|
[SDNPHasChain, SDNPOutGlue]>;
|
|
|
|
|
2005-12-17 01:24:02 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// X86 Operand Definitions.
|
|
|
|
//
|
|
|
|
|
2009-07-30 01:56:29 +00:00
|
|
|
// A version of ptr_rc which excludes SP, ESP, and RSP. This is used for
|
|
|
|
// the index operand of an address, to conform to x86 encoding restrictions.
|
|
|
|
def ptr_rc_nosp : PointerLikeRegClass<1>;
|
2009-06-20 19:34:09 +00:00
|
|
|
|
2004-08-11 02:25:00 +00:00
|
|
|
// *mem - Operand definitions for the funky X86 addressing mode operands.
|
|
|
|
//
|
2013-08-24 19:50:11 +00:00
|
|
|
def X86MemAsmOperand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "Mem";
|
2009-08-10 18:41:10 +00:00
|
|
|
}
|
2013-08-24 19:50:11 +00:00
|
|
|
def X86Mem8AsmOperand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "Mem8"; let RenderMethod = "addMemOperands";
|
2012-01-12 01:51:42 +00:00
|
|
|
}
|
2013-08-24 19:50:11 +00:00
|
|
|
def X86Mem16AsmOperand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "Mem16"; let RenderMethod = "addMemOperands";
|
2012-01-12 01:51:42 +00:00
|
|
|
}
|
2013-08-24 19:50:11 +00:00
|
|
|
def X86Mem32AsmOperand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "Mem32"; let RenderMethod = "addMemOperands";
|
2012-01-12 01:51:42 +00:00
|
|
|
}
|
2013-08-24 19:50:11 +00:00
|
|
|
def X86Mem64AsmOperand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "Mem64"; let RenderMethod = "addMemOperands";
|
2012-01-12 01:51:42 +00:00
|
|
|
}
|
2013-08-24 19:50:11 +00:00
|
|
|
def X86Mem80AsmOperand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "Mem80"; let RenderMethod = "addMemOperands";
|
2012-01-12 01:51:42 +00:00
|
|
|
}
|
2013-08-24 19:50:11 +00:00
|
|
|
def X86Mem128AsmOperand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "Mem128"; let RenderMethod = "addMemOperands";
|
2012-01-12 01:51:42 +00:00
|
|
|
}
|
2013-08-24 19:50:11 +00:00
|
|
|
def X86Mem256AsmOperand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "Mem256"; let RenderMethod = "addMemOperands";
|
2012-01-12 01:51:42 +00:00
|
|
|
}
|
2013-08-25 23:18:05 +00:00
|
|
|
def X86Mem512AsmOperand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "Mem512"; let RenderMethod = "addMemOperands";
|
2013-08-25 23:18:05 +00:00
|
|
|
}
|
2012-01-12 01:51:42 +00:00
|
|
|
|
2012-07-18 04:11:12 +00:00
|
|
|
// Gather mem operands
|
|
|
|
def X86MemVX32Operand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "MemVX32"; let RenderMethod = "addMemOperands";
|
2012-07-18 04:11:12 +00:00
|
|
|
}
|
|
|
|
def X86MemVY32Operand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "MemVY32"; let RenderMethod = "addMemOperands";
|
2012-07-18 04:11:12 +00:00
|
|
|
}
|
2013-08-25 23:18:05 +00:00
|
|
|
def X86MemVZ32Operand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "MemVZ32"; let RenderMethod = "addMemOperands";
|
2013-08-25 23:18:05 +00:00
|
|
|
}
|
2012-07-18 04:11:12 +00:00
|
|
|
def X86MemVX64Operand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "MemVX64"; let RenderMethod = "addMemOperands";
|
2012-07-18 04:11:12 +00:00
|
|
|
}
|
|
|
|
def X86MemVY64Operand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "MemVY64"; let RenderMethod = "addMemOperands";
|
2012-07-18 04:11:12 +00:00
|
|
|
}
|
2013-07-28 08:28:38 +00:00
|
|
|
def X86MemVZ64Operand : AsmOperandClass {
|
2013-08-26 00:13:09 +00:00
|
|
|
let Name = "MemVZ64"; let RenderMethod = "addMemOperands";
|
2013-07-28 08:28:38 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 22:39:14 +00:00
|
|
|
def X86AbsMemAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "AbsMem";
|
2010-07-08 23:46:44 +00:00
|
|
|
let SuperClasses = [X86MemAsmOperand];
|
2010-05-06 22:39:14 +00:00
|
|
|
}
|
2006-05-17 21:21:41 +00:00
|
|
|
class X86MemOperand<string printMethod> : Operand<iPTR> {
|
2005-11-30 18:54:35 +00:00
|
|
|
let PrintMethod = printMethod;
|
2009-07-30 01:56:29 +00:00
|
|
|
let MIOperandInfo = (ops ptr_rc, i8imm, ptr_rc_nosp, i32imm, i8imm);
|
2009-08-10 18:41:10 +00:00
|
|
|
let ParserMatchClass = X86MemAsmOperand;
|
2004-08-11 02:25:00 +00:00
|
|
|
}
|
2005-11-30 18:54:35 +00:00
|
|
|
|
2011-07-14 21:47:22 +00:00
|
|
|
let OperandType = "OPERAND_MEMORY" in {
|
2009-09-03 00:04:47 +00:00
|
|
|
def opaque32mem : X86MemOperand<"printopaquemem">;
|
|
|
|
def opaque48mem : X86MemOperand<"printopaquemem">;
|
|
|
|
def opaque80mem : X86MemOperand<"printopaquemem">;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def opaque512mem : X86MemOperand<"printopaquemem">;
|
|
|
|
|
2013-08-24 19:50:11 +00:00
|
|
|
def i8mem : X86MemOperand<"printi8mem"> {
|
2012-01-12 01:51:42 +00:00
|
|
|
let ParserMatchClass = X86Mem8AsmOperand; }
|
2013-08-24 19:50:11 +00:00
|
|
|
def i16mem : X86MemOperand<"printi16mem"> {
|
2012-01-12 01:51:42 +00:00
|
|
|
let ParserMatchClass = X86Mem16AsmOperand; }
|
2013-08-24 19:50:11 +00:00
|
|
|
def i32mem : X86MemOperand<"printi32mem"> {
|
2012-01-12 01:51:42 +00:00
|
|
|
let ParserMatchClass = X86Mem32AsmOperand; }
|
2013-08-24 19:50:11 +00:00
|
|
|
def i64mem : X86MemOperand<"printi64mem"> {
|
2012-01-12 01:51:42 +00:00
|
|
|
let ParserMatchClass = X86Mem64AsmOperand; }
|
2013-08-24 19:50:11 +00:00
|
|
|
def i128mem : X86MemOperand<"printi128mem"> {
|
2012-01-12 01:51:42 +00:00
|
|
|
let ParserMatchClass = X86Mem128AsmOperand; }
|
2013-08-24 19:50:11 +00:00
|
|
|
def i256mem : X86MemOperand<"printi256mem"> {
|
2012-01-12 01:51:42 +00:00
|
|
|
let ParserMatchClass = X86Mem256AsmOperand; }
|
2013-08-24 19:50:11 +00:00
|
|
|
def i512mem : X86MemOperand<"printi512mem"> {
|
2013-07-28 08:28:38 +00:00
|
|
|
let ParserMatchClass = X86Mem512AsmOperand; }
|
2013-08-24 19:50:11 +00:00
|
|
|
def f32mem : X86MemOperand<"printf32mem"> {
|
2012-01-12 01:51:42 +00:00
|
|
|
let ParserMatchClass = X86Mem32AsmOperand; }
|
2013-08-24 19:50:11 +00:00
|
|
|
def f64mem : X86MemOperand<"printf64mem"> {
|
2012-01-12 01:51:42 +00:00
|
|
|
let ParserMatchClass = X86Mem64AsmOperand; }
|
2013-08-24 19:50:11 +00:00
|
|
|
def f80mem : X86MemOperand<"printf80mem"> {
|
2012-01-12 01:51:42 +00:00
|
|
|
let ParserMatchClass = X86Mem80AsmOperand; }
|
2013-08-24 19:50:11 +00:00
|
|
|
def f128mem : X86MemOperand<"printf128mem"> {
|
2012-01-12 01:51:42 +00:00
|
|
|
let ParserMatchClass = X86Mem128AsmOperand; }
|
2013-08-24 19:50:11 +00:00
|
|
|
def f256mem : X86MemOperand<"printf256mem">{
|
2012-01-12 01:51:42 +00:00
|
|
|
let ParserMatchClass = X86Mem256AsmOperand; }
|
2013-07-28 08:28:38 +00:00
|
|
|
def f512mem : X86MemOperand<"printf512mem">{
|
|
|
|
let ParserMatchClass = X86Mem512AsmOperand; }
|
|
|
|
def v512mem : Operand<iPTR> {
|
|
|
|
let PrintMethod = "printf512mem";
|
|
|
|
let MIOperandInfo = (ops ptr_rc, i8imm, VR512, i32imm, i8imm);
|
|
|
|
let ParserMatchClass = X86Mem512AsmOperand; }
|
2012-07-18 04:11:12 +00:00
|
|
|
|
|
|
|
// Gather mem operands
|
|
|
|
def vx32mem : X86MemOperand<"printi32mem">{
|
2012-06-26 19:47:59 +00:00
|
|
|
let MIOperandInfo = (ops ptr_rc, i8imm, VR128, i32imm, i8imm);
|
2012-07-18 04:11:12 +00:00
|
|
|
let ParserMatchClass = X86MemVX32Operand; }
|
|
|
|
def vy32mem : X86MemOperand<"printi32mem">{
|
2012-06-26 19:47:59 +00:00
|
|
|
let MIOperandInfo = (ops ptr_rc, i8imm, VR256, i32imm, i8imm);
|
2012-07-18 04:11:12 +00:00
|
|
|
let ParserMatchClass = X86MemVY32Operand; }
|
|
|
|
def vx64mem : X86MemOperand<"printi64mem">{
|
|
|
|
let MIOperandInfo = (ops ptr_rc, i8imm, VR128, i32imm, i8imm);
|
|
|
|
let ParserMatchClass = X86MemVX64Operand; }
|
|
|
|
def vy64mem : X86MemOperand<"printi64mem">{
|
|
|
|
let MIOperandInfo = (ops ptr_rc, i8imm, VR256, i32imm, i8imm);
|
|
|
|
let ParserMatchClass = X86MemVY64Operand; }
|
2013-07-28 08:28:38 +00:00
|
|
|
def vy64xmem : X86MemOperand<"printi64mem">{
|
|
|
|
let MIOperandInfo = (ops ptr_rc, i8imm, VR256X, i32imm, i8imm);
|
|
|
|
let ParserMatchClass = X86MemVY64Operand; }
|
|
|
|
def vz32mem : X86MemOperand<"printi32mem">{
|
|
|
|
let MIOperandInfo = (ops ptr_rc, i16imm, VR512, i32imm, i8imm);
|
|
|
|
let ParserMatchClass = X86MemVZ32Operand; }
|
|
|
|
def vz64mem : X86MemOperand<"printi64mem">{
|
|
|
|
let MIOperandInfo = (ops ptr_rc, i8imm, VR512, i32imm, i8imm);
|
|
|
|
let ParserMatchClass = X86MemVZ64Operand; }
|
2011-07-14 21:47:22 +00:00
|
|
|
}
|
2005-11-30 18:54:35 +00:00
|
|
|
|
Implement x86 h-register extract support.
- Add patterns for h-register extract, which avoids a shift and mask,
and in some cases a temporary register.
- Add address-mode matching for turning (X>>(8-n))&(255<<n), where
n is a valid address-mode scale value, into an h-register extract
and a scaled-offset address.
- Replace X86's MOV32to32_ and related instructions with the new
target-independent COPY_TO_SUBREG instruction.
On x86-64 there are complicated constraints on h registers, and
CodeGen doesn't currently provide a high-level way to express all of them,
so they are handled with a bunch of special code. This code currently only
supports extracts where the result is used by a zero-extend or a store,
though these are fairly common.
These transformations are not always beneficial; since there are only
4 h registers, they sometimes require extra move instructions, and
this sometimes increases register pressure because it can force out
values that would otherwise be in one of those registers. However,
this appears to be relatively uncommon.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@68962 91177308-0d34-0410-b5e6-96231b3b80d8
2009-04-13 16:09:41 +00:00
|
|
|
// A version of i8mem for use on x86-64 that uses GR64_NOREX instead of
|
|
|
|
// plain GR64, so that it doesn't potentially require a REX prefix.
|
|
|
|
def i8mem_NOREX : Operand<i64> {
|
|
|
|
let PrintMethod = "printi8mem";
|
2009-07-30 01:56:29 +00:00
|
|
|
let MIOperandInfo = (ops GR64_NOREX, i8imm, GR64_NOREX_NOSP, i32imm, i8imm);
|
2012-01-17 21:48:03 +00:00
|
|
|
let ParserMatchClass = X86Mem8AsmOperand;
|
2011-07-14 21:47:22 +00:00
|
|
|
let OperandType = "OPERAND_MEMORY";
|
Implement x86 h-register extract support.
- Add patterns for h-register extract, which avoids a shift and mask,
and in some cases a temporary register.
- Add address-mode matching for turning (X>>(8-n))&(255<<n), where
n is a valid address-mode scale value, into an h-register extract
and a scaled-offset address.
- Replace X86's MOV32to32_ and related instructions with the new
target-independent COPY_TO_SUBREG instruction.
On x86-64 there are complicated constraints on h registers, and
CodeGen doesn't currently provide a high-level way to express all of them,
so they are handled with a bunch of special code. This code currently only
supports extracts where the result is used by a zero-extend or a store,
though these are fairly common.
These transformations are not always beneficial; since there are only
4 h registers, they sometimes require extra move instructions, and
this sometimes increases register pressure because it can force out
values that would otherwise be in one of those registers. However,
this appears to be relatively uncommon.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@68962 91177308-0d34-0410-b5e6-96231b3b80d8
2009-04-13 16:09:41 +00:00
|
|
|
}
|
|
|
|
|
2011-01-26 02:04:09 +00:00
|
|
|
// GPRs available for tailcall.
|
2012-05-09 01:50:09 +00:00
|
|
|
// It represents GR32_TC, GR64_TC or GR64_TCW64.
|
2011-01-26 02:04:09 +00:00
|
|
|
def ptr_rc_tailcall : PointerLikeRegClass<2>;
|
|
|
|
|
2010-03-14 03:48:46 +00:00
|
|
|
// Special i32mem for addresses of load folding tail calls. These are not
|
|
|
|
// allowed to use callee-saved registers since they must be scheduled
|
|
|
|
// after callee-saved register are popped.
|
|
|
|
def i32mem_TC : Operand<i32> {
|
|
|
|
let PrintMethod = "printi32mem";
|
2012-05-09 01:50:09 +00:00
|
|
|
let MIOperandInfo = (ops ptr_rc_tailcall, i8imm, ptr_rc_tailcall,
|
|
|
|
i32imm, i8imm);
|
2012-01-17 21:48:03 +00:00
|
|
|
let ParserMatchClass = X86Mem32AsmOperand;
|
2011-07-14 21:47:22 +00:00
|
|
|
let OperandType = "OPERAND_MEMORY";
|
2010-03-14 03:48:46 +00:00
|
|
|
}
|
|
|
|
|
2010-10-05 06:37:31 +00:00
|
|
|
// Special i64mem for addresses of load folding tail calls. These are not
|
|
|
|
// allowed to use callee-saved registers since they must be scheduled
|
|
|
|
// after callee-saved register are popped.
|
|
|
|
def i64mem_TC : Operand<i64> {
|
|
|
|
let PrintMethod = "printi64mem";
|
2011-01-26 02:04:09 +00:00
|
|
|
let MIOperandInfo = (ops ptr_rc_tailcall, i8imm,
|
|
|
|
ptr_rc_tailcall, i32imm, i8imm);
|
2012-01-17 21:48:03 +00:00
|
|
|
let ParserMatchClass = X86Mem64AsmOperand;
|
2011-07-14 21:47:22 +00:00
|
|
|
let OperandType = "OPERAND_MEMORY";
|
2010-10-05 06:37:31 +00:00
|
|
|
}
|
2006-09-08 06:48:29 +00:00
|
|
|
|
2011-07-14 21:47:22 +00:00
|
|
|
let OperandType = "OPERAND_PCREL",
|
|
|
|
ParserMatchClass = X86AbsMemAsmOperand,
|
2012-09-10 22:50:57 +00:00
|
|
|
PrintMethod = "printPCRelImm" in {
|
2010-01-30 00:24:12 +00:00
|
|
|
def i32imm_pcrel : Operand<i32>;
|
2010-07-07 22:27:31 +00:00
|
|
|
def i16imm_pcrel : Operand<i16>;
|
2010-01-30 00:24:12 +00:00
|
|
|
|
|
|
|
// Branch targets have OtherVT type and print as pc-relative values.
|
|
|
|
def brtarget : Operand<OtherVT>;
|
|
|
|
def brtarget8 : Operand<OtherVT>;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2014-01-22 15:08:08 +00:00
|
|
|
def X86SrcIdx8Operand : AsmOperandClass {
|
|
|
|
let Name = "SrcIdx8";
|
|
|
|
let RenderMethod = "addSrcIdxOperands";
|
|
|
|
let SuperClasses = [X86Mem8AsmOperand];
|
|
|
|
}
|
|
|
|
def X86SrcIdx16Operand : AsmOperandClass {
|
|
|
|
let Name = "SrcIdx16";
|
|
|
|
let RenderMethod = "addSrcIdxOperands";
|
|
|
|
let SuperClasses = [X86Mem16AsmOperand];
|
|
|
|
}
|
|
|
|
def X86SrcIdx32Operand : AsmOperandClass {
|
|
|
|
let Name = "SrcIdx32";
|
|
|
|
let RenderMethod = "addSrcIdxOperands";
|
|
|
|
let SuperClasses = [X86Mem32AsmOperand];
|
|
|
|
}
|
|
|
|
def X86SrcIdx64Operand : AsmOperandClass {
|
|
|
|
let Name = "SrcIdx64";
|
|
|
|
let RenderMethod = "addSrcIdxOperands";
|
|
|
|
let SuperClasses = [X86Mem64AsmOperand];
|
|
|
|
}
|
2014-01-22 15:08:21 +00:00
|
|
|
def X86DstIdx8Operand : AsmOperandClass {
|
|
|
|
let Name = "DstIdx8";
|
|
|
|
let RenderMethod = "addDstIdxOperands";
|
|
|
|
let SuperClasses = [X86Mem8AsmOperand];
|
|
|
|
}
|
|
|
|
def X86DstIdx16Operand : AsmOperandClass {
|
|
|
|
let Name = "DstIdx16";
|
|
|
|
let RenderMethod = "addDstIdxOperands";
|
|
|
|
let SuperClasses = [X86Mem16AsmOperand];
|
|
|
|
}
|
|
|
|
def X86DstIdx32Operand : AsmOperandClass {
|
|
|
|
let Name = "DstIdx32";
|
|
|
|
let RenderMethod = "addDstIdxOperands";
|
|
|
|
let SuperClasses = [X86Mem32AsmOperand];
|
|
|
|
}
|
|
|
|
def X86DstIdx64Operand : AsmOperandClass {
|
|
|
|
let Name = "DstIdx64";
|
|
|
|
let RenderMethod = "addDstIdxOperands";
|
|
|
|
let SuperClasses = [X86Mem64AsmOperand];
|
|
|
|
}
|
2013-08-25 22:23:38 +00:00
|
|
|
def X86MemOffs8AsmOperand : AsmOperandClass {
|
|
|
|
let Name = "MemOffs8";
|
2013-08-26 00:13:09 +00:00
|
|
|
let RenderMethod = "addMemOffsOperands";
|
2013-08-25 22:23:38 +00:00
|
|
|
let SuperClasses = [X86Mem8AsmOperand];
|
|
|
|
}
|
|
|
|
def X86MemOffs16AsmOperand : AsmOperandClass {
|
|
|
|
let Name = "MemOffs16";
|
2013-08-26 00:13:09 +00:00
|
|
|
let RenderMethod = "addMemOffsOperands";
|
2013-08-25 22:23:38 +00:00
|
|
|
let SuperClasses = [X86Mem16AsmOperand];
|
|
|
|
}
|
|
|
|
def X86MemOffs32AsmOperand : AsmOperandClass {
|
|
|
|
let Name = "MemOffs32";
|
2013-08-26 00:13:09 +00:00
|
|
|
let RenderMethod = "addMemOffsOperands";
|
2013-08-25 22:23:38 +00:00
|
|
|
let SuperClasses = [X86Mem32AsmOperand];
|
|
|
|
}
|
|
|
|
def X86MemOffs64AsmOperand : AsmOperandClass {
|
|
|
|
let Name = "MemOffs64";
|
2013-08-26 00:13:09 +00:00
|
|
|
let RenderMethod = "addMemOffsOperands";
|
2013-08-25 22:23:38 +00:00
|
|
|
let SuperClasses = [X86Mem64AsmOperand];
|
|
|
|
}
|
|
|
|
let OperandType = "OPERAND_MEMORY" in {
|
2014-01-22 15:08:08 +00:00
|
|
|
def srcidx8 : Operand<iPTR> {
|
|
|
|
let ParserMatchClass = X86SrcIdx8Operand;
|
|
|
|
let MIOperandInfo = (ops ptr_rc, i8imm);
|
|
|
|
let PrintMethod = "printSrcIdx8"; }
|
|
|
|
def srcidx16 : Operand<iPTR> {
|
|
|
|
let ParserMatchClass = X86SrcIdx16Operand;
|
|
|
|
let MIOperandInfo = (ops ptr_rc, i8imm);
|
|
|
|
let PrintMethod = "printSrcIdx16"; }
|
|
|
|
def srcidx32 : Operand<iPTR> {
|
|
|
|
let ParserMatchClass = X86SrcIdx32Operand;
|
|
|
|
let MIOperandInfo = (ops ptr_rc, i8imm);
|
|
|
|
let PrintMethod = "printSrcIdx32"; }
|
|
|
|
def srcidx64 : Operand<iPTR> {
|
|
|
|
let ParserMatchClass = X86SrcIdx64Operand;
|
|
|
|
let MIOperandInfo = (ops ptr_rc, i8imm);
|
|
|
|
let PrintMethod = "printSrcIdx64"; }
|
2014-01-22 15:08:21 +00:00
|
|
|
def dstidx8 : Operand<iPTR> {
|
|
|
|
let ParserMatchClass = X86DstIdx8Operand;
|
|
|
|
let MIOperandInfo = (ops ptr_rc);
|
|
|
|
let PrintMethod = "printDstIdx8"; }
|
|
|
|
def dstidx16 : Operand<iPTR> {
|
|
|
|
let ParserMatchClass = X86DstIdx16Operand;
|
|
|
|
let MIOperandInfo = (ops ptr_rc);
|
|
|
|
let PrintMethod = "printDstIdx16"; }
|
|
|
|
def dstidx32 : Operand<iPTR> {
|
|
|
|
let ParserMatchClass = X86DstIdx32Operand;
|
|
|
|
let MIOperandInfo = (ops ptr_rc);
|
|
|
|
let PrintMethod = "printDstIdx32"; }
|
|
|
|
def dstidx64 : Operand<iPTR> {
|
|
|
|
let ParserMatchClass = X86DstIdx64Operand;
|
|
|
|
let MIOperandInfo = (ops ptr_rc);
|
|
|
|
let PrintMethod = "printDstIdx64"; }
|
2014-01-16 07:36:58 +00:00
|
|
|
def offset8 : Operand<iPTR> {
|
2013-08-25 22:23:38 +00:00
|
|
|
let ParserMatchClass = X86MemOffs8AsmOperand;
|
2014-01-16 07:36:58 +00:00
|
|
|
let MIOperandInfo = (ops i64imm, i8imm);
|
2013-08-25 22:23:38 +00:00
|
|
|
let PrintMethod = "printMemOffs8"; }
|
2014-01-16 07:36:58 +00:00
|
|
|
def offset16 : Operand<iPTR> {
|
2013-08-25 22:23:38 +00:00
|
|
|
let ParserMatchClass = X86MemOffs16AsmOperand;
|
2014-01-16 07:36:58 +00:00
|
|
|
let MIOperandInfo = (ops i64imm, i8imm);
|
2013-08-25 22:23:38 +00:00
|
|
|
let PrintMethod = "printMemOffs16"; }
|
2014-01-16 07:36:58 +00:00
|
|
|
def offset32 : Operand<iPTR> {
|
2013-08-25 22:23:38 +00:00
|
|
|
let ParserMatchClass = X86MemOffs32AsmOperand;
|
2014-01-16 07:36:58 +00:00
|
|
|
let MIOperandInfo = (ops i64imm, i8imm);
|
2013-08-25 22:23:38 +00:00
|
|
|
let PrintMethod = "printMemOffs32"; }
|
2014-01-16 07:36:58 +00:00
|
|
|
def offset64 : Operand<iPTR> {
|
2013-08-25 22:23:38 +00:00
|
|
|
let ParserMatchClass = X86MemOffs64AsmOperand;
|
2014-01-16 07:36:58 +00:00
|
|
|
let MIOperandInfo = (ops i64imm, i8imm);
|
2013-08-25 22:23:38 +00:00
|
|
|
let PrintMethod = "printMemOffs64"; }
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-07-15 00:38:55 +00:00
|
|
|
def SSECC : Operand<i8> {
|
|
|
|
let PrintMethod = "printSSECC";
|
2011-07-14 21:47:22 +00:00
|
|
|
let OperandType = "OPERAND_IMMEDIATE";
|
2005-07-15 00:38:55 +00:00
|
|
|
}
|
2004-08-11 02:25:00 +00:00
|
|
|
|
2012-04-03 05:20:24 +00:00
|
|
|
def AVXCC : Operand<i8> {
|
2012-10-09 05:26:13 +00:00
|
|
|
let PrintMethod = "printAVXCC";
|
2012-04-03 05:20:24 +00:00
|
|
|
let OperandType = "OPERAND_IMMEDIATE";
|
|
|
|
}
|
|
|
|
|
2010-05-22 21:02:33 +00:00
|
|
|
class ImmSExtAsmOperandClass : AsmOperandClass {
|
2010-05-22 21:02:29 +00:00
|
|
|
let SuperClasses = [ImmAsmOperand];
|
2010-05-22 21:02:33 +00:00
|
|
|
let RenderMethod = "addImmOperands";
|
2010-05-20 20:20:39 +00:00
|
|
|
}
|
|
|
|
|
2013-10-14 04:55:01 +00:00
|
|
|
def X86GR32orGR64AsmOperand : AsmOperandClass {
|
|
|
|
let Name = "GR32orGR64";
|
|
|
|
}
|
|
|
|
|
|
|
|
def GR32orGR64 : RegisterOperand<GR32> {
|
|
|
|
let ParserMatchClass = X86GR32orGR64AsmOperand;
|
|
|
|
}
|
|
|
|
|
2014-01-01 15:12:34 +00:00
|
|
|
def AVX512RC : Operand<i32> {
|
|
|
|
let PrintMethod = "printRoundingControl";
|
|
|
|
let OperandType = "OPERAND_IMMEDIATE";
|
|
|
|
}
|
[x86] Fix a pretty horrible bug and inconsistency in the x86 asm
parsing (and latent bug in the instruction definitions).
This is effectively a revert of r136287 which tried to address
a specific and narrow case of immediate operands failing to be accepted
by x86 instructions with a pretty heavy hammer: it introduced a new kind
of operand that behaved differently. All of that is removed with this
commit, but the test cases are both preserved and enhanced.
The core problem that r136287 and this commit are trying to handle is
that gas accepts both of the following instructions:
insertps $192, %xmm0, %xmm1
insertps $-64, %xmm0, %xmm1
These will encode to the same byte sequence, with the immediate
occupying an 8-bit entry. The first form was fixed by r136287 but that
broke the prior handling of the second form! =[ Ironically, we would
still emit the second form in some cases and then be unable to
re-assemble the output.
The reason why the first instruction failed to be handled is because
prior to r136287 the operands ere marked 'i32i8imm' which forces them to
be sign-extenable. Clearly, that won't work for 192 in a single byte.
However, making thim zero-extended or "unsigned" doesn't really address
the core issue either because it breaks negative immediates. The correct
fix is to make these operands 'i8imm' reflecting that they can be either
signed or unsigned but must be 8-bit immediates. This patch backs out
r136287 and then changes those places as well as some others to use
'i8imm' rather than one of the extended variants.
Naturally, this broke something else. The custom DAG nodes had to be
updated to have a much more accurate type constraint of an i8 node, and
a bunch of Pat immediates needed to be specified as i8 values.
The fallout didn't end there though. We also then ceased to be able to
match the instruction-specific intrinsics to the instructions so
modified. Digging, this is because they too used i32 rather than i8 in
their signature. So I've also switched those intrinsics to i8 arguments
in line with the instructions.
In order to make the intrinsic adjustments of course, I also had to add
auto upgrading for the intrinsics.
I suspect that the intrinsic argument types may have led everything down
this rabbit hole. Pretty happy with the result.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@217310 91177308-0d34-0410-b5e6-96231b3b80d8
2014-09-06 10:00:01 +00:00
|
|
|
|
2010-05-22 21:02:33 +00:00
|
|
|
// Sign-extended immediate classes. We don't need to define the full lattice
|
|
|
|
// here because there is no instruction with an ambiguity between ImmSExti64i32
|
|
|
|
// and ImmSExti32i8.
|
|
|
|
//
|
|
|
|
// The strange ranges come from the fact that the assembler always works with
|
|
|
|
// 64-bit immediates, but for a 16-bit target value we want to accept both "-1"
|
|
|
|
// (which will be a -1ULL), and "0xFF" (-1 in 16-bits).
|
|
|
|
|
2010-07-08 23:46:44 +00:00
|
|
|
// [0, 0x7FFFFFFF] |
|
|
|
|
// [0xFFFFFFFF80000000, 0xFFFFFFFFFFFFFFFF]
|
2010-05-22 21:02:33 +00:00
|
|
|
def ImmSExti64i32AsmOperand : ImmSExtAsmOperandClass {
|
|
|
|
let Name = "ImmSExti64i32";
|
|
|
|
}
|
|
|
|
|
2010-07-08 23:46:44 +00:00
|
|
|
// [0, 0x0000007F] | [0x000000000000FF80, 0x000000000000FFFF] |
|
|
|
|
// [0xFFFFFFFFFFFFFF80, 0xFFFFFFFFFFFFFFFF]
|
2010-05-22 21:02:33 +00:00
|
|
|
def ImmSExti16i8AsmOperand : ImmSExtAsmOperandClass {
|
|
|
|
let Name = "ImmSExti16i8";
|
|
|
|
let SuperClasses = [ImmSExti64i32AsmOperand];
|
|
|
|
}
|
|
|
|
|
2010-07-08 23:46:44 +00:00
|
|
|
// [0, 0x0000007F] | [0x00000000FFFFFF80, 0x00000000FFFFFFFF] |
|
|
|
|
// [0xFFFFFFFFFFFFFF80, 0xFFFFFFFFFFFFFFFF]
|
2010-05-22 21:02:33 +00:00
|
|
|
def ImmSExti32i8AsmOperand : ImmSExtAsmOperandClass {
|
|
|
|
let Name = "ImmSExti32i8";
|
|
|
|
}
|
|
|
|
|
2010-07-08 23:46:44 +00:00
|
|
|
// [0, 0x0000007F] |
|
|
|
|
// [0xFFFFFFFFFFFFFF80, 0xFFFFFFFFFFFFFFFF]
|
2010-05-22 21:02:33 +00:00
|
|
|
def ImmSExti64i8AsmOperand : ImmSExtAsmOperandClass {
|
|
|
|
let Name = "ImmSExti64i8";
|
2010-07-08 23:46:44 +00:00
|
|
|
let SuperClasses = [ImmSExti16i8AsmOperand, ImmSExti32i8AsmOperand,
|
|
|
|
ImmSExti64i32AsmOperand];
|
2009-08-10 18:41:10 +00:00
|
|
|
}
|
|
|
|
|
2005-11-18 01:04:42 +00:00
|
|
|
// A couple of more descriptive operand definitions.
|
|
|
|
// 16-bits but only 8 bits are significant.
|
2009-08-09 07:20:21 +00:00
|
|
|
def i16i8imm : Operand<i16> {
|
2010-05-22 21:02:33 +00:00
|
|
|
let ParserMatchClass = ImmSExti16i8AsmOperand;
|
2011-07-14 21:47:22 +00:00
|
|
|
let OperandType = "OPERAND_IMMEDIATE";
|
2009-08-09 07:20:21 +00:00
|
|
|
}
|
2005-11-18 01:04:42 +00:00
|
|
|
// 32-bits but only 8 bits are significant.
|
2009-08-09 07:20:21 +00:00
|
|
|
def i32i8imm : Operand<i32> {
|
2010-05-22 21:02:33 +00:00
|
|
|
let ParserMatchClass = ImmSExti32i8AsmOperand;
|
2011-07-14 21:47:22 +00:00
|
|
|
let OperandType = "OPERAND_IMMEDIATE";
|
2009-08-09 07:20:21 +00:00
|
|
|
}
|
2005-11-18 01:04:42 +00:00
|
|
|
|
2010-10-05 06:37:31 +00:00
|
|
|
// 64-bits but only 32 bits are significant.
|
|
|
|
def i64i32imm : Operand<i64> {
|
|
|
|
let ParserMatchClass = ImmSExti64i32AsmOperand;
|
2011-07-14 21:47:22 +00:00
|
|
|
let OperandType = "OPERAND_IMMEDIATE";
|
2010-10-05 06:37:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// 64-bits but only 32 bits are significant, and those bits are treated as being
|
|
|
|
// pc relative.
|
|
|
|
def i64i32imm_pcrel : Operand<i64> {
|
2012-09-10 22:50:57 +00:00
|
|
|
let PrintMethod = "printPCRelImm";
|
2010-10-05 06:37:31 +00:00
|
|
|
let ParserMatchClass = X86AbsMemAsmOperand;
|
2011-08-22 22:55:32 +00:00
|
|
|
let OperandType = "OPERAND_PCREL";
|
2010-10-05 06:37:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// 64-bits but only 8 bits are significant.
|
|
|
|
def i64i8imm : Operand<i64> {
|
|
|
|
let ParserMatchClass = ImmSExti64i8AsmOperand;
|
2011-08-22 22:55:32 +00:00
|
|
|
let OperandType = "OPERAND_IMMEDIATE";
|
2010-10-05 06:37:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
def lea64_32mem : Operand<i32> {
|
|
|
|
let PrintMethod = "printi32mem";
|
2013-06-10 20:43:49 +00:00
|
|
|
let MIOperandInfo = (ops GR64, i8imm, GR64_NOSP, i32imm, i8imm);
|
2010-10-05 06:37:31 +00:00
|
|
|
let ParserMatchClass = X86MemAsmOperand;
|
|
|
|
}
|
|
|
|
|
2013-02-01 19:28:09 +00:00
|
|
|
// Memory operands that use 64-bit pointers in both ILP32 and LP64.
|
|
|
|
def lea64mem : Operand<i64> {
|
|
|
|
let PrintMethod = "printi64mem";
|
|
|
|
let MIOperandInfo = (ops GR64, i8imm, GR64_NOSP, i32imm, i8imm);
|
|
|
|
let ParserMatchClass = X86MemAsmOperand;
|
|
|
|
}
|
|
|
|
|
2010-10-05 06:37:31 +00:00
|
|
|
|
2005-12-17 01:24:02 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// X86 Complex Pattern Definitions.
|
|
|
|
//
|
|
|
|
|
2005-12-08 02:01:35 +00:00
|
|
|
// Define X86 specific addressing mode.
|
2010-09-21 22:07:31 +00:00
|
|
|
def addr : ComplexPattern<iPTR, 5, "SelectAddr", [], [SDNPWantParent]>;
|
2010-07-08 23:46:44 +00:00
|
|
|
def lea32addr : ComplexPattern<i32, 5, "SelectLEAAddr",
|
2009-08-02 16:09:17 +00:00
|
|
|
[add, sub, mul, X86mul_imm, shl, or, frameindex],
|
|
|
|
[]>;
|
2013-02-01 19:28:09 +00:00
|
|
|
// In 64-bit mode 32-bit LEAs can use RIP-relative addressing.
|
2013-06-10 20:43:49 +00:00
|
|
|
def lea64_32addr : ComplexPattern<i32, 5, "SelectLEA64_32Addr",
|
2013-02-01 19:28:09 +00:00
|
|
|
[add, sub, mul, X86mul_imm, shl, or,
|
|
|
|
frameindex, X86WrapperRIP],
|
|
|
|
[]>;
|
|
|
|
|
2010-07-08 23:46:44 +00:00
|
|
|
def tls32addr : ComplexPattern<i32, 5, "SelectTLSADDRAddr",
|
2009-06-20 20:38:48 +00:00
|
|
|
[tglobaltlsaddr], []>;
|
2005-12-08 02:01:35 +00:00
|
|
|
|
2012-06-01 16:27:21 +00:00
|
|
|
def tls32baseaddr : ComplexPattern<i32, 5, "SelectTLSADDRAddr",
|
|
|
|
[tglobaltlsaddr], []>;
|
|
|
|
|
2010-10-05 06:37:31 +00:00
|
|
|
def lea64addr : ComplexPattern<i64, 5, "SelectLEAAddr",
|
|
|
|
[add, sub, mul, X86mul_imm, shl, or, frameindex,
|
|
|
|
X86WrapperRIP], []>;
|
|
|
|
|
|
|
|
def tls64addr : ComplexPattern<i64, 5, "SelectTLSADDRAddr",
|
|
|
|
[tglobaltlsaddr], []>;
|
|
|
|
|
2012-06-01 16:27:21 +00:00
|
|
|
def tls64baseaddr : ComplexPattern<i64, 5, "SelectTLSADDRAddr",
|
|
|
|
[tglobaltlsaddr], []>;
|
|
|
|
|
2005-12-20 22:59:51 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// X86 Instruction Predicate Definitions.
|
2010-03-14 18:31:44 +00:00
|
|
|
def HasCMov : Predicate<"Subtarget->hasCMov()">;
|
|
|
|
def NoCMov : Predicate<"!Subtarget->hasCMov()">;
|
2010-12-03 22:29:15 +00:00
|
|
|
|
2010-12-10 00:26:57 +00:00
|
|
|
def HasMMX : Predicate<"Subtarget->hasMMX()">;
|
2010-10-03 18:08:05 +00:00
|
|
|
def Has3DNow : Predicate<"Subtarget->has3DNow()">;
|
|
|
|
def Has3DNowA : Predicate<"Subtarget->has3DNowA()">;
|
2010-12-10 00:26:57 +00:00
|
|
|
def HasSSE1 : Predicate<"Subtarget->hasSSE1()">;
|
2012-09-26 06:29:37 +00:00
|
|
|
def UseSSE1 : Predicate<"Subtarget->hasSSE1() && !Subtarget->hasAVX()">;
|
2010-12-10 00:26:57 +00:00
|
|
|
def HasSSE2 : Predicate<"Subtarget->hasSSE2()">;
|
2012-09-26 06:29:37 +00:00
|
|
|
def UseSSE2 : Predicate<"Subtarget->hasSSE2() && !Subtarget->hasAVX()">;
|
2010-12-10 00:26:57 +00:00
|
|
|
def HasSSE3 : Predicate<"Subtarget->hasSSE3()">;
|
2012-09-26 06:29:37 +00:00
|
|
|
def UseSSE3 : Predicate<"Subtarget->hasSSE3() && !Subtarget->hasAVX()">;
|
2010-12-10 00:26:57 +00:00
|
|
|
def HasSSSE3 : Predicate<"Subtarget->hasSSSE3()">;
|
2012-09-26 06:29:37 +00:00
|
|
|
def UseSSSE3 : Predicate<"Subtarget->hasSSSE3() && !Subtarget->hasAVX()">;
|
2010-12-10 00:26:57 +00:00
|
|
|
def HasSSE41 : Predicate<"Subtarget->hasSSE41()">;
|
2014-10-03 21:38:49 +00:00
|
|
|
def NoSSE41 : Predicate<"!Subtarget->hasSSE41()">;
|
2012-09-26 06:29:37 +00:00
|
|
|
def UseSSE41 : Predicate<"Subtarget->hasSSE41() && !Subtarget->hasAVX()">;
|
2010-12-10 00:26:57 +00:00
|
|
|
def HasSSE42 : Predicate<"Subtarget->hasSSE42()">;
|
2012-09-26 06:29:37 +00:00
|
|
|
def UseSSE42 : Predicate<"Subtarget->hasSSE42() && !Subtarget->hasAVX()">;
|
2010-12-10 00:26:57 +00:00
|
|
|
def HasSSE4A : Predicate<"Subtarget->hasSSE4A()">;
|
2009-06-26 22:46:54 +00:00
|
|
|
def HasAVX : Predicate<"Subtarget->hasAVX()">;
|
2011-10-30 19:57:21 +00:00
|
|
|
def HasAVX2 : Predicate<"Subtarget->hasAVX2()">;
|
2012-08-27 06:08:57 +00:00
|
|
|
def HasAVX1Only : Predicate<"Subtarget->hasAVX() && !Subtarget->hasAVX2()">;
|
2013-12-11 14:31:04 +00:00
|
|
|
def HasAVX512 : Predicate<"Subtarget->hasAVX512()">,
|
|
|
|
AssemblerPredicate<"FeatureAVX512", "AVX-512 ISA">;
|
2013-07-28 08:28:38 +00:00
|
|
|
def UseAVX : Predicate<"Subtarget->hasAVX() && !Subtarget->hasAVX512()">;
|
|
|
|
def UseAVX2 : Predicate<"Subtarget->hasAVX2() && !Subtarget->hasAVX512()">;
|
2014-07-21 14:54:21 +00:00
|
|
|
def NoAVX512 : Predicate<"!Subtarget->hasAVX512()">;
|
2013-07-28 08:28:38 +00:00
|
|
|
def HasCDI : Predicate<"Subtarget->hasCDI()">;
|
|
|
|
def HasPFI : Predicate<"Subtarget->hasPFI()">;
|
2013-10-09 08:16:14 +00:00
|
|
|
def HasERI : Predicate<"Subtarget->hasERI()">;
|
2014-07-21 14:54:21 +00:00
|
|
|
def HasDQI : Predicate<"Subtarget->hasDQI()">;
|
2014-10-15 23:42:17 +00:00
|
|
|
def NoDQI : Predicate<"!Subtarget->hasDQI()">;
|
2014-07-21 14:54:21 +00:00
|
|
|
def HasBWI : Predicate<"Subtarget->hasBWI()">;
|
|
|
|
def HasVLX : Predicate<"Subtarget->hasVLX()">,
|
|
|
|
AssemblerPredicate<"FeatureVLX", "AVX-512 VLX ISA">;
|
2014-08-13 10:46:00 +00:00
|
|
|
def NoVLX : Predicate<"!Subtarget->hasVLX()">;
|
2010-12-10 00:26:57 +00:00
|
|
|
|
2011-10-11 07:13:09 +00:00
|
|
|
def HasPOPCNT : Predicate<"Subtarget->hasPOPCNT()">;
|
2010-12-10 00:26:57 +00:00
|
|
|
def HasAES : Predicate<"Subtarget->hasAES()">;
|
2012-05-31 14:34:17 +00:00
|
|
|
def HasPCLMUL : Predicate<"Subtarget->hasPCLMUL()">;
|
2012-06-03 18:58:46 +00:00
|
|
|
def HasFMA : Predicate<"Subtarget->hasFMA()">;
|
2013-07-28 08:28:38 +00:00
|
|
|
def UseFMAOnAVX : Predicate<"Subtarget->hasFMA() && !Subtarget->hasAVX512()">;
|
2009-06-26 22:46:54 +00:00
|
|
|
def HasFMA4 : Predicate<"Subtarget->hasFMA4()">;
|
2011-12-12 19:37:49 +00:00
|
|
|
def HasXOP : Predicate<"Subtarget->hasXOP()">;
|
2013-09-27 18:38:42 +00:00
|
|
|
def HasTBM : Predicate<"Subtarget->hasTBM()">;
|
2011-10-03 17:28:23 +00:00
|
|
|
def HasMOVBE : Predicate<"Subtarget->hasMOVBE()">;
|
|
|
|
def HasRDRAND : Predicate<"Subtarget->hasRDRAND()">;
|
2011-10-09 07:31:39 +00:00
|
|
|
def HasF16C : Predicate<"Subtarget->hasF16C()">;
|
2011-10-30 19:57:21 +00:00
|
|
|
def HasFSGSBase : Predicate<"Subtarget->hasFSGSBase()">;
|
2011-10-11 06:44:02 +00:00
|
|
|
def HasLZCNT : Predicate<"Subtarget->hasLZCNT()">;
|
2011-10-14 03:21:46 +00:00
|
|
|
def HasBMI : Predicate<"Subtarget->hasBMI()">;
|
2011-10-16 07:55:05 +00:00
|
|
|
def HasBMI2 : Predicate<"Subtarget->hasBMI2()">;
|
2012-11-08 07:28:54 +00:00
|
|
|
def HasRTM : Predicate<"Subtarget->hasRTM()">;
|
2013-03-26 22:46:02 +00:00
|
|
|
def HasHLE : Predicate<"Subtarget->hasHLE()">;
|
2013-03-26 22:47:01 +00:00
|
|
|
def HasTSX : Predicate<"Subtarget->hasRTM() || Subtarget->hasHLE()">;
|
2013-02-14 19:08:21 +00:00
|
|
|
def HasADX : Predicate<"Subtarget->hasADX()">;
|
2013-09-12 15:51:31 +00:00
|
|
|
def HasSHA : Predicate<"Subtarget->hasSHA()">;
|
2014-07-31 23:57:38 +00:00
|
|
|
def HasSGX : Predicate<"Subtarget->hasSGX()">;
|
2013-03-26 17:47:11 +00:00
|
|
|
def HasPRFCHW : Predicate<"Subtarget->hasPRFCHW()">;
|
2013-03-28 23:41:26 +00:00
|
|
|
def HasRDSEED : Predicate<"Subtarget->hasRDSEED()">;
|
2014-08-21 09:16:12 +00:00
|
|
|
def HasSMAP : Predicate<"Subtarget->hasSMAP()">;
|
2013-10-16 19:04:11 +00:00
|
|
|
def HasPrefetchW : Predicate<"Subtarget->hasPRFCHW()">;
|
2012-01-10 06:30:56 +00:00
|
|
|
def FPStackf32 : Predicate<"!Subtarget->hasSSE1()">;
|
|
|
|
def FPStackf64 : Predicate<"!Subtarget->hasSSE2()">;
|
2011-08-26 21:21:21 +00:00
|
|
|
def HasCmpxchg16b: Predicate<"Subtarget->hasCmpxchg16b()">;
|
2013-12-20 02:04:49 +00:00
|
|
|
def Not64BitMode : Predicate<"!Subtarget->is64Bit()">,
|
|
|
|
AssemblerPredicate<"!Mode64Bit", "Not 64-bit mode">;
|
2011-07-08 01:53:10 +00:00
|
|
|
def In64BitMode : Predicate<"Subtarget->is64Bit()">,
|
2012-11-14 18:04:47 +00:00
|
|
|
AssemblerPredicate<"Mode64Bit", "64-bit mode">;
|
2014-09-22 13:11:35 +00:00
|
|
|
def IsLP64 : Predicate<"Subtarget->isTarget64BitLP64()">;
|
|
|
|
def NotLP64 : Predicate<"!Subtarget->isTarget64BitLP64()">;
|
2014-01-06 04:55:54 +00:00
|
|
|
def In16BitMode : Predicate<"Subtarget->is16Bit()">,
|
|
|
|
AssemblerPredicate<"Mode16Bit", "16-bit mode">;
|
|
|
|
def Not16BitMode : Predicate<"!Subtarget->is16Bit()">,
|
|
|
|
AssemblerPredicate<"!Mode16Bit", "Not 16-bit mode">;
|
|
|
|
def In32BitMode : Predicate<"Subtarget->is32Bit()">,
|
|
|
|
AssemblerPredicate<"Mode32Bit", "32-bit mode">;
|
2009-08-03 08:12:53 +00:00
|
|
|
def IsWin64 : Predicate<"Subtarget->isTargetWin64()">;
|
2011-10-18 05:29:23 +00:00
|
|
|
def IsNaCl : Predicate<"Subtarget->isTargetNaCl()">;
|
|
|
|
def NotNaCl : Predicate<"!Subtarget->isTargetNaCl()">;
|
2009-08-06 11:23:24 +00:00
|
|
|
def SmallCode : Predicate<"TM.getCodeModel() == CodeModel::Small">;
|
|
|
|
def KernelCode : Predicate<"TM.getCodeModel() == CodeModel::Kernel">;
|
|
|
|
def FarData : Predicate<"TM.getCodeModel() != CodeModel::Small &&"
|
2009-08-06 09:11:19 +00:00
|
|
|
"TM.getCodeModel() != CodeModel::Kernel">;
|
2009-08-06 11:23:24 +00:00
|
|
|
def NearData : Predicate<"TM.getCodeModel() == CodeModel::Small ||"
|
|
|
|
"TM.getCodeModel() == CodeModel::Kernel">;
|
2006-12-05 19:50:18 +00:00
|
|
|
def IsStatic : Predicate<"TM.getRelocationModel() == Reloc::Static">;
|
2010-03-25 00:10:31 +00:00
|
|
|
def IsNotPIC : Predicate<"TM.getRelocationModel() != Reloc::PIC_">;
|
2009-12-22 17:47:23 +00:00
|
|
|
def OptForSize : Predicate<"OptForSize">;
|
2008-09-26 23:41:32 +00:00
|
|
|
def OptForSpeed : Predicate<"!OptForSize">;
|
2009-01-02 05:35:45 +00:00
|
|
|
def FastBTMem : Predicate<"!Subtarget->isBTMemSlow()">;
|
2009-05-20 04:53:57 +00:00
|
|
|
def CallImmAddr : Predicate<"Subtarget->IsLegalToCallImmediateAddr(TM)">;
|
2013-03-28 23:13:21 +00:00
|
|
|
def FavorMemIndirectCall : Predicate<"!Subtarget->callRegIndirect()">;
|
2014-06-09 11:40:41 +00:00
|
|
|
def NotSlowIncDec : Predicate<"!Subtarget->slowIncDec()">;
|
2014-12-16 16:30:01 +00:00
|
|
|
def HasFastMem32 : Predicate<"!Subtarget->isUnalignedMem32Slow()">;
|
2005-12-20 22:59:51 +00:00
|
|
|
|
2005-12-17 01:24:02 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-07-31 08:04:03 +00:00
|
|
|
// X86 Instruction Format Definitions.
|
2005-12-17 01:24:02 +00:00
|
|
|
//
|
|
|
|
|
2007-07-31 08:04:03 +00:00
|
|
|
include "X86InstrFormats.td"
|
2003-08-03 21:54:21 +00:00
|
|
|
|
2005-11-18 01:04:42 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2011-04-17 21:38:24 +00:00
|
|
|
// Pattern fragments.
|
2005-11-18 01:04:42 +00:00
|
|
|
//
|
2006-01-06 00:43:03 +00:00
|
|
|
|
|
|
|
// X86 specific condition code. These correspond to CondCode in
|
2007-05-06 04:00:55 +00:00
|
|
|
// X86InstrInfo.h. They must be kept in synch.
|
2009-01-07 00:15:08 +00:00
|
|
|
def X86_COND_A : PatLeaf<(i8 0)>; // alt. COND_NBE
|
|
|
|
def X86_COND_AE : PatLeaf<(i8 1)>; // alt. COND_NC
|
|
|
|
def X86_COND_B : PatLeaf<(i8 2)>; // alt. COND_C
|
|
|
|
def X86_COND_BE : PatLeaf<(i8 3)>; // alt. COND_NA
|
|
|
|
def X86_COND_E : PatLeaf<(i8 4)>; // alt. COND_Z
|
|
|
|
def X86_COND_G : PatLeaf<(i8 5)>; // alt. COND_NLE
|
|
|
|
def X86_COND_GE : PatLeaf<(i8 6)>; // alt. COND_NL
|
|
|
|
def X86_COND_L : PatLeaf<(i8 7)>; // alt. COND_NGE
|
|
|
|
def X86_COND_LE : PatLeaf<(i8 8)>; // alt. COND_NG
|
|
|
|
def X86_COND_NE : PatLeaf<(i8 9)>; // alt. COND_NZ
|
2006-01-06 00:43:03 +00:00
|
|
|
def X86_COND_NO : PatLeaf<(i8 10)>;
|
2009-01-07 00:15:08 +00:00
|
|
|
def X86_COND_NP : PatLeaf<(i8 11)>; // alt. COND_PO
|
2006-01-06 00:43:03 +00:00
|
|
|
def X86_COND_NS : PatLeaf<(i8 12)>;
|
2009-01-07 00:15:08 +00:00
|
|
|
def X86_COND_O : PatLeaf<(i8 13)>;
|
|
|
|
def X86_COND_P : PatLeaf<(i8 14)>; // alt. COND_PE
|
|
|
|
def X86_COND_S : PatLeaf<(i8 15)>;
|
2006-01-06 00:43:03 +00:00
|
|
|
|
2014-12-08 17:47:18 +00:00
|
|
|
// Predicate used to help when pattern matching LZCNT/TZCNT.
|
|
|
|
def X86_COND_E_OR_NE : ImmLeaf<i8, [{
|
|
|
|
return (Imm == X86::COND_E) || (Imm == X86::COND_NE);
|
|
|
|
}]>;
|
|
|
|
|
2011-04-18 06:36:55 +00:00
|
|
|
let FastIselShouldIgnore = 1 in { // FastIsel should ignore all simm8 instrs.
|
2011-04-20 03:19:42 +00:00
|
|
|
def i16immSExt8 : ImmLeaf<i16, [{ return Imm == (int8_t)Imm; }]>;
|
|
|
|
def i32immSExt8 : ImmLeaf<i32, [{ return Imm == (int8_t)Imm; }]>;
|
|
|
|
def i64immSExt8 : ImmLeaf<i64, [{ return Imm == (int8_t)Imm; }]>;
|
2011-04-18 06:36:55 +00:00
|
|
|
}
|
|
|
|
|
2011-04-17 22:12:55 +00:00
|
|
|
def i64immSExt32 : ImmLeaf<i64, [{ return Imm == (int32_t)Imm; }]>;
|
2005-11-18 01:04:42 +00:00
|
|
|
|
2011-04-17 22:05:17 +00:00
|
|
|
|
2011-04-17 22:12:55 +00:00
|
|
|
// i64immZExt32 predicate - True if the 64-bit immediate fits in a 32-bit
|
|
|
|
// unsigned field.
|
|
|
|
def i64immZExt32 : ImmLeaf<i64, [{ return (uint64_t)Imm == (uint32_t)Imm; }]>;
|
2011-04-17 22:05:17 +00:00
|
|
|
|
2011-04-17 22:12:55 +00:00
|
|
|
def i64immZExt32SExt8 : ImmLeaf<i64, [{
|
|
|
|
return (uint64_t)Imm == (uint32_t)Imm && (int32_t)Imm == (int8_t)Imm;
|
2010-10-13 13:31:20 +00:00
|
|
|
}]>;
|
|
|
|
|
2005-12-13 01:57:51 +00:00
|
|
|
// Helper fragments for loads.
|
2008-05-13 18:59:59 +00:00
|
|
|
// It's always safe to treat a anyext i16 load as a i32 load if the i16 is
|
|
|
|
// known to be 32-bit aligned or better. Ditto for i8 to i16.
|
2008-10-15 06:50:19 +00:00
|
|
|
def loadi16 : PatFrag<(ops node:$ptr), (i16 (unindexedload node:$ptr)), [{
|
2008-08-20 15:24:22 +00:00
|
|
|
LoadSDNode *LD = cast<LoadSDNode>(N);
|
|
|
|
ISD::LoadExtType ExtType = LD->getExtensionType();
|
|
|
|
if (ExtType == ISD::NON_EXTLOAD)
|
|
|
|
return true;
|
|
|
|
if (ExtType == ISD::EXTLOAD)
|
|
|
|
return LD->getAlignment() >= 2 && !LD->isVolatile();
|
2008-05-13 00:54:02 +00:00
|
|
|
return false;
|
|
|
|
}]>;
|
|
|
|
|
2010-03-03 01:52:59 +00:00
|
|
|
def loadi16_anyext : PatFrag<(ops node:$ptr), (i32 (unindexedload node:$ptr)),[{
|
2008-09-24 23:27:55 +00:00
|
|
|
LoadSDNode *LD = cast<LoadSDNode>(N);
|
|
|
|
ISD::LoadExtType ExtType = LD->getExtensionType();
|
|
|
|
if (ExtType == ISD::EXTLOAD)
|
|
|
|
return LD->getAlignment() >= 2 && !LD->isVolatile();
|
|
|
|
return false;
|
|
|
|
}]>;
|
|
|
|
|
2008-10-15 06:50:19 +00:00
|
|
|
def loadi32 : PatFrag<(ops node:$ptr), (i32 (unindexedload node:$ptr)), [{
|
2008-08-20 15:24:22 +00:00
|
|
|
LoadSDNode *LD = cast<LoadSDNode>(N);
|
|
|
|
ISD::LoadExtType ExtType = LD->getExtensionType();
|
|
|
|
if (ExtType == ISD::NON_EXTLOAD)
|
|
|
|
return true;
|
|
|
|
if (ExtType == ISD::EXTLOAD)
|
|
|
|
return LD->getAlignment() >= 4 && !LD->isVolatile();
|
2008-05-13 00:54:02 +00:00
|
|
|
return false;
|
|
|
|
}]>;
|
|
|
|
|
2010-09-21 22:07:31 +00:00
|
|
|
def loadi8 : PatFrag<(ops node:$ptr), (i8 (load node:$ptr))>;
|
|
|
|
def loadi64 : PatFrag<(ops node:$ptr), (i64 (load node:$ptr))>;
|
|
|
|
def loadf32 : PatFrag<(ops node:$ptr), (f32 (load node:$ptr))>;
|
|
|
|
def loadf64 : PatFrag<(ops node:$ptr), (f64 (load node:$ptr))>;
|
|
|
|
def loadf80 : PatFrag<(ops node:$ptr), (f80 (load node:$ptr))>;
|
2005-12-14 02:22:27 +00:00
|
|
|
|
2006-10-09 20:57:25 +00:00
|
|
|
def sextloadi16i8 : PatFrag<(ops node:$ptr), (i16 (sextloadi8 node:$ptr))>;
|
|
|
|
def sextloadi32i8 : PatFrag<(ops node:$ptr), (i32 (sextloadi8 node:$ptr))>;
|
|
|
|
def sextloadi32i16 : PatFrag<(ops node:$ptr), (i32 (sextloadi16 node:$ptr))>;
|
2010-10-05 06:37:31 +00:00
|
|
|
def sextloadi64i8 : PatFrag<(ops node:$ptr), (i64 (sextloadi8 node:$ptr))>;
|
|
|
|
def sextloadi64i16 : PatFrag<(ops node:$ptr), (i64 (sextloadi16 node:$ptr))>;
|
|
|
|
def sextloadi64i32 : PatFrag<(ops node:$ptr), (i64 (sextloadi32 node:$ptr))>;
|
2006-10-09 20:57:25 +00:00
|
|
|
|
|
|
|
def zextloadi8i1 : PatFrag<(ops node:$ptr), (i8 (zextloadi1 node:$ptr))>;
|
|
|
|
def zextloadi16i1 : PatFrag<(ops node:$ptr), (i16 (zextloadi1 node:$ptr))>;
|
|
|
|
def zextloadi32i1 : PatFrag<(ops node:$ptr), (i32 (zextloadi1 node:$ptr))>;
|
|
|
|
def zextloadi16i8 : PatFrag<(ops node:$ptr), (i16 (zextloadi8 node:$ptr))>;
|
|
|
|
def zextloadi32i8 : PatFrag<(ops node:$ptr), (i32 (zextloadi8 node:$ptr))>;
|
|
|
|
def zextloadi32i16 : PatFrag<(ops node:$ptr), (i32 (zextloadi16 node:$ptr))>;
|
2010-10-05 06:37:31 +00:00
|
|
|
def zextloadi64i1 : PatFrag<(ops node:$ptr), (i64 (zextloadi1 node:$ptr))>;
|
|
|
|
def zextloadi64i8 : PatFrag<(ops node:$ptr), (i64 (zextloadi8 node:$ptr))>;
|
|
|
|
def zextloadi64i16 : PatFrag<(ops node:$ptr), (i64 (zextloadi16 node:$ptr))>;
|
|
|
|
def zextloadi64i32 : PatFrag<(ops node:$ptr), (i64 (zextloadi32 node:$ptr))>;
|
2006-10-09 20:57:25 +00:00
|
|
|
|
|
|
|
def extloadi8i1 : PatFrag<(ops node:$ptr), (i8 (extloadi1 node:$ptr))>;
|
|
|
|
def extloadi16i1 : PatFrag<(ops node:$ptr), (i16 (extloadi1 node:$ptr))>;
|
|
|
|
def extloadi32i1 : PatFrag<(ops node:$ptr), (i32 (extloadi1 node:$ptr))>;
|
|
|
|
def extloadi16i8 : PatFrag<(ops node:$ptr), (i16 (extloadi8 node:$ptr))>;
|
|
|
|
def extloadi32i8 : PatFrag<(ops node:$ptr), (i32 (extloadi8 node:$ptr))>;
|
|
|
|
def extloadi32i16 : PatFrag<(ops node:$ptr), (i32 (extloadi16 node:$ptr))>;
|
2010-10-05 06:37:31 +00:00
|
|
|
def extloadi64i1 : PatFrag<(ops node:$ptr), (i64 (extloadi1 node:$ptr))>;
|
|
|
|
def extloadi64i8 : PatFrag<(ops node:$ptr), (i64 (extloadi8 node:$ptr))>;
|
|
|
|
def extloadi64i16 : PatFrag<(ops node:$ptr), (i64 (extloadi16 node:$ptr))>;
|
|
|
|
def extloadi64i32 : PatFrag<(ops node:$ptr), (i64 (extloadi32 node:$ptr))>;
|
2006-02-21 02:24:38 +00:00
|
|
|
|
Don't fold and's into test instructions if they have multiple uses.
This compiles test-nofold.ll into:
_test:
movl $15, %ecx
andl 4(%esp), %ecx
testl %ecx, %ecx
movl $42, %eax
cmove %ecx, %eax
ret
instead of:
_test:
movl 4(%esp), %eax
movl %eax, %ecx
andl $15, %ecx
testl $15, %eax
movl $42, %eax
cmove %ecx, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47330 91177308-0d34-0410-b5e6-96231b3b80d8
2008-02-19 17:37:35 +00:00
|
|
|
|
|
|
|
// An 'and' node with a single use.
|
|
|
|
def and_su : PatFrag<(ops node:$lhs, node:$rhs), (and node:$lhs, node:$rhs), [{
|
2008-03-04 00:40:35 +00:00
|
|
|
return N->hasOneUse();
|
Don't fold and's into test instructions if they have multiple uses.
This compiles test-nofold.ll into:
_test:
movl $15, %ecx
andl 4(%esp), %ecx
testl %ecx, %ecx
movl $42, %eax
cmove %ecx, %eax
ret
instead of:
_test:
movl 4(%esp), %eax
movl %eax, %ecx
andl $15, %ecx
testl $15, %eax
movl $42, %eax
cmove %ecx, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47330 91177308-0d34-0410-b5e6-96231b3b80d8
2008-02-19 17:37:35 +00:00
|
|
|
}]>;
|
Implement x86 h-register extract support.
- Add patterns for h-register extract, which avoids a shift and mask,
and in some cases a temporary register.
- Add address-mode matching for turning (X>>(8-n))&(255<<n), where
n is a valid address-mode scale value, into an h-register extract
and a scaled-offset address.
- Replace X86's MOV32to32_ and related instructions with the new
target-independent COPY_TO_SUBREG instruction.
On x86-64 there are complicated constraints on h registers, and
CodeGen doesn't currently provide a high-level way to express all of them,
so they are handled with a bunch of special code. This code currently only
supports extracts where the result is used by a zero-extend or a store,
though these are fairly common.
These transformations are not always beneficial; since there are only
4 h registers, they sometimes require extra move instructions, and
this sometimes increases register pressure because it can force out
values that would otherwise be in one of those registers. However,
this appears to be relatively uncommon.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@68962 91177308-0d34-0410-b5e6-96231b3b80d8
2009-04-13 16:09:41 +00:00
|
|
|
// An 'srl' node with a single use.
|
|
|
|
def srl_su : PatFrag<(ops node:$lhs, node:$rhs), (srl node:$lhs, node:$rhs), [{
|
|
|
|
return N->hasOneUse();
|
|
|
|
}]>;
|
|
|
|
// An 'trunc' node with a single use.
|
|
|
|
def trunc_su : PatFrag<(ops node:$src), (trunc node:$src), [{
|
|
|
|
return N->hasOneUse();
|
|
|
|
}]>;
|
Don't fold and's into test instructions if they have multiple uses.
This compiles test-nofold.ll into:
_test:
movl $15, %ecx
andl 4(%esp), %ecx
testl %ecx, %ecx
movl $42, %eax
cmove %ecx, %eax
ret
instead of:
_test:
movl 4(%esp), %eax
movl %eax, %ecx
andl $15, %ecx
testl $15, %eax
movl $42, %eax
cmove %ecx, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47330 91177308-0d34-0410-b5e6-96231b3b80d8
2008-02-19 17:37:35 +00:00
|
|
|
|
2003-08-03 21:54:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2010-10-05 05:32:15 +00:00
|
|
|
// Instruction list.
|
2003-08-03 21:54:21 +00:00
|
|
|
//
|
|
|
|
|
2006-01-11 00:33:36 +00:00
|
|
|
// Nop
|
2014-11-26 00:46:26 +00:00
|
|
|
let hasSideEffects = 0, SchedRW = [WriteZero] in {
|
2012-05-10 21:58:35 +00:00
|
|
|
def NOOP : I<0x90, RawFrm, (outs), (ins), "nop", [], IIC_NOP>;
|
2014-02-10 06:55:41 +00:00
|
|
|
def NOOPW : I<0x1f, MRMXm, (outs), (ins i16mem:$zero),
|
2014-02-02 09:25:09 +00:00
|
|
|
"nop{w}\t$zero", [], IIC_NOP>, TB, OpSize16;
|
2014-02-10 06:55:41 +00:00
|
|
|
def NOOPL : I<0x1f, MRMXm, (outs), (ins i32mem:$zero),
|
2014-02-02 09:25:09 +00:00
|
|
|
"nop{l}\t$zero", [], IIC_NOP>, TB, OpSize32;
|
2009-07-23 23:39:34 +00:00
|
|
|
}
|
2006-01-11 00:33:36 +00:00
|
|
|
|
2003-08-03 21:54:21 +00:00
|
|
|
|
2009-09-16 02:57:13 +00:00
|
|
|
// Constructing a stack frame.
|
2010-09-17 18:02:29 +00:00
|
|
|
def ENTER : Ii16<0xC8, RawFrmImm8, (outs), (ins i16imm:$len, i8imm:$lvl),
|
2013-03-26 18:24:15 +00:00
|
|
|
"enter\t$len, $lvl", [], IIC_ENTER>, Sched<[WriteMicrocoded]>;
|
2009-09-16 02:57:13 +00:00
|
|
|
|
2013-03-26 18:24:15 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
2014-11-26 00:46:26 +00:00
|
|
|
let Defs = [EBP, ESP], Uses = [EBP, ESP], mayLoad = 1, hasSideEffects=0 in
|
2004-08-10 20:17:41 +00:00
|
|
|
def LEAVE : I<0xC9, RawFrm,
|
2012-05-10 21:58:35 +00:00
|
|
|
(outs), (ins), "leave", [], IIC_LEAVE>,
|
2013-12-20 02:04:49 +00:00
|
|
|
Requires<[Not64BitMode]>;
|
2007-09-11 19:55:27 +00:00
|
|
|
|
2014-11-26 00:46:26 +00:00
|
|
|
let Defs = [RBP,RSP], Uses = [RBP,RSP], mayLoad = 1, hasSideEffects = 0 in
|
2010-10-05 06:41:40 +00:00
|
|
|
def LEAVE64 : I<0xC9, RawFrm,
|
2012-05-10 21:58:35 +00:00
|
|
|
(outs), (ins), "leave", [], IIC_LEAVE>,
|
|
|
|
Requires<[In64BitMode]>;
|
2013-03-26 18:24:15 +00:00
|
|
|
} // SchedRW
|
2010-10-05 06:41:40 +00:00
|
|
|
|
2010-10-05 06:04:14 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2010-10-05 06:41:40 +00:00
|
|
|
// Miscellaneous Instructions.
|
2010-10-05 06:04:14 +00:00
|
|
|
//
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2014-11-26 00:46:26 +00:00
|
|
|
let Defs = [ESP], Uses = [ESP], hasSideEffects=0 in {
|
2013-03-19 18:03:55 +00:00
|
|
|
let mayLoad = 1, SchedRW = [WriteLoad] in {
|
2012-05-10 21:58:35 +00:00
|
|
|
def POP16r : I<0x58, AddRegFrm, (outs GR16:$reg), (ins), "pop{w}\t$reg", [],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_POP_REG16>, OpSize16;
|
2012-05-10 21:58:35 +00:00
|
|
|
def POP32r : I<0x58, AddRegFrm, (outs GR32:$reg), (ins), "pop{l}\t$reg", [],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_POP_REG>, OpSize32, Requires<[Not64BitMode]>;
|
2012-05-10 21:58:35 +00:00
|
|
|
def POP16rmr: I<0x8F, MRM0r, (outs GR16:$reg), (ins), "pop{w}\t$reg", [],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_POP_REG>, OpSize16;
|
2013-06-30 20:44:50 +00:00
|
|
|
def POP16rmm: I<0x8F, MRM0m, (outs), (ins i16mem:$dst), "pop{w}\t$dst", [],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_POP_MEM>, OpSize16;
|
2012-05-10 21:58:35 +00:00
|
|
|
def POP32rmr: I<0x8F, MRM0r, (outs GR32:$reg), (ins), "pop{l}\t$reg", [],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_POP_REG>, OpSize32, Requires<[Not64BitMode]>;
|
2013-06-30 20:44:50 +00:00
|
|
|
def POP32rmm: I<0x8F, MRM0m, (outs), (ins i32mem:$dst), "pop{l}\t$dst", [],
|
2014-02-18 08:18:29 +00:00
|
|
|
IIC_POP_MEM>, OpSize32, Requires<[Not64BitMode]>;
|
2012-05-10 21:58:35 +00:00
|
|
|
|
2014-02-02 09:25:09 +00:00
|
|
|
def POPF16 : I<0x9D, RawFrm, (outs), (ins), "popf{w}", [], IIC_POP_F>,
|
|
|
|
OpSize16;
|
2012-05-10 21:58:35 +00:00
|
|
|
def POPF32 : I<0x9D, RawFrm, (outs), (ins), "popf{l|d}", [], IIC_POP_FD>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, Requires<[Not64BitMode]>;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // mayLoad, SchedRW
|
2003-08-03 21:54:21 +00:00
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let mayStore = 1, SchedRW = [WriteStore] in {
|
2012-05-10 21:58:35 +00:00
|
|
|
def PUSH16r : I<0x50, AddRegFrm, (outs), (ins GR16:$reg), "push{w}\t$reg",[],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_PUSH_REG>, OpSize16;
|
2012-05-10 21:58:35 +00:00
|
|
|
def PUSH32r : I<0x50, AddRegFrm, (outs), (ins GR32:$reg), "push{l}\t$reg",[],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_PUSH_REG>, OpSize32, Requires<[Not64BitMode]>;
|
2012-05-10 21:58:35 +00:00
|
|
|
def PUSH16rmr: I<0xFF, MRM6r, (outs), (ins GR16:$reg), "push{w}\t$reg",[],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_PUSH_REG>, OpSize16;
|
2012-05-10 21:58:35 +00:00
|
|
|
def PUSH16rmm: I<0xFF, MRM6m, (outs), (ins i16mem:$src), "push{w}\t$src",[],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_PUSH_MEM>, OpSize16;
|
2012-05-10 21:58:35 +00:00
|
|
|
def PUSH32rmr: I<0xFF, MRM6r, (outs), (ins GR32:$reg), "push{l}\t$reg",[],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_PUSH_REG>, OpSize32, Requires<[Not64BitMode]>;
|
2012-05-10 21:58:35 +00:00
|
|
|
def PUSH32rmm: I<0xFF, MRM6m, (outs), (ins i32mem:$src), "push{l}\t$src",[],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_PUSH_MEM>, OpSize32, Requires<[Not64BitMode]>;
|
2007-04-17 09:20:00 +00:00
|
|
|
|
2014-01-08 12:58:32 +00:00
|
|
|
def PUSH16i8 : Ii8<0x6a, RawFrm, (outs), (ins i16i8imm:$imm),
|
2014-02-02 09:25:09 +00:00
|
|
|
"push{w}\t$imm", [], IIC_PUSH_IMM>, OpSize16,
|
2014-01-08 12:58:32 +00:00
|
|
|
Requires<[Not64BitMode]>;
|
|
|
|
def PUSH32i8 : Ii8<0x6a, RawFrm, (outs), (ins i32i8imm:$imm),
|
2014-02-02 09:25:09 +00:00
|
|
|
"push{l}\t$imm", [], IIC_PUSH_IMM>, OpSize32,
|
2014-01-08 12:57:40 +00:00
|
|
|
Requires<[Not64BitMode]>;
|
2010-10-20 23:40:27 +00:00
|
|
|
def PUSHi16 : Ii16<0x68, RawFrm, (outs), (ins i16imm:$imm),
|
2014-02-02 09:25:09 +00:00
|
|
|
"push{w}\t$imm", [], IIC_PUSH_IMM>, OpSize16,
|
2014-01-05 05:46:38 +00:00
|
|
|
Requires<[Not64BitMode]>;
|
2010-10-20 23:40:27 +00:00
|
|
|
def PUSHi32 : Ii32<0x68, RawFrm, (outs), (ins i32imm:$imm),
|
2014-02-02 09:25:09 +00:00
|
|
|
"push{l}\t$imm", [], IIC_PUSH_IMM>, OpSize32,
|
2014-01-08 12:57:40 +00:00
|
|
|
Requires<[Not64BitMode]>;
|
2010-10-20 23:40:27 +00:00
|
|
|
|
2012-05-10 21:58:35 +00:00
|
|
|
def PUSHF16 : I<0x9C, RawFrm, (outs), (ins), "pushf{w}", [], IIC_PUSH_F>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16;
|
2012-05-10 21:58:35 +00:00
|
|
|
def PUSHF32 : I<0x9C, RawFrm, (outs), (ins), "pushf{l|d}", [], IIC_PUSH_F>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, Requires<[Not64BitMode]>;
|
2010-10-05 06:47:35 +00:00
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
} // mayStore, SchedRW
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
}
|
2007-09-26 01:29:06 +00:00
|
|
|
|
2014-11-26 00:46:26 +00:00
|
|
|
let Defs = [RSP], Uses = [RSP], hasSideEffects=0 in {
|
2013-03-19 18:03:55 +00:00
|
|
|
let mayLoad = 1, SchedRW = [WriteLoad] in {
|
2014-01-05 01:35:51 +00:00
|
|
|
def POP64r : I<0x58, AddRegFrm, (outs GR64:$reg), (ins), "pop{q}\t$reg", [],
|
2014-02-18 08:18:29 +00:00
|
|
|
IIC_POP_REG>, OpSize32, Requires<[In64BitMode]>;
|
2012-05-10 21:58:35 +00:00
|
|
|
def POP64rmr: I<0x8F, MRM0r, (outs GR64:$reg), (ins), "pop{q}\t$reg", [],
|
2014-02-18 08:18:29 +00:00
|
|
|
IIC_POP_REG>, OpSize32, Requires<[In64BitMode]>;
|
2013-06-30 20:44:50 +00:00
|
|
|
def POP64rmm: I<0x8F, MRM0m, (outs), (ins i64mem:$dst), "pop{q}\t$dst", [],
|
2014-02-18 08:18:29 +00:00
|
|
|
IIC_POP_MEM>, OpSize32, Requires<[In64BitMode]>;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // mayLoad, SchedRW
|
|
|
|
let mayStore = 1, SchedRW = [WriteStore] in {
|
2014-01-05 01:35:51 +00:00
|
|
|
def PUSH64r : I<0x50, AddRegFrm, (outs), (ins GR64:$reg), "push{q}\t$reg", [],
|
2014-02-18 08:18:29 +00:00
|
|
|
IIC_PUSH_REG>, OpSize32, Requires<[In64BitMode]>;
|
2012-05-10 21:58:35 +00:00
|
|
|
def PUSH64rmr: I<0xFF, MRM6r, (outs), (ins GR64:$reg), "push{q}\t$reg", [],
|
2014-02-18 08:18:29 +00:00
|
|
|
IIC_PUSH_REG>, OpSize32, Requires<[In64BitMode]>;
|
2012-05-10 21:58:35 +00:00
|
|
|
def PUSH64rmm: I<0xFF, MRM6m, (outs), (ins i64mem:$src), "push{q}\t$src", [],
|
2014-02-18 08:18:29 +00:00
|
|
|
IIC_PUSH_MEM>, OpSize32, Requires<[In64BitMode]>;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // mayStore, SchedRW
|
2010-10-05 06:47:35 +00:00
|
|
|
}
|
|
|
|
|
2014-11-26 00:46:26 +00:00
|
|
|
let Defs = [RSP], Uses = [RSP], hasSideEffects = 0, mayStore = 1,
|
2013-03-19 18:03:55 +00:00
|
|
|
SchedRW = [WriteStore] in {
|
2011-07-06 17:23:46 +00:00
|
|
|
def PUSH64i8 : Ii8<0x6a, RawFrm, (outs), (ins i64i8imm:$imm),
|
2014-01-05 01:35:51 +00:00
|
|
|
"push{q}\t$imm", [], IIC_PUSH_IMM>, Requires<[In64BitMode]>;
|
2010-10-20 23:40:27 +00:00
|
|
|
def PUSH64i16 : Ii16<0x68, RawFrm, (outs), (ins i16imm:$imm),
|
2014-02-02 09:25:09 +00:00
|
|
|
"push{w}\t$imm", [], IIC_PUSH_IMM>, OpSize16,
|
2014-01-05 05:46:38 +00:00
|
|
|
Requires<[In64BitMode]>;
|
2014-01-30 22:20:41 +00:00
|
|
|
def PUSH64i32 : Ii32S<0x68, RawFrm, (outs), (ins i64i32imm:$imm),
|
2014-02-18 08:18:29 +00:00
|
|
|
"push{q}\t$imm", [], IIC_PUSH_IMM>, OpSize32,
|
|
|
|
Requires<[In64BitMode]>;
|
2010-10-05 06:47:35 +00:00
|
|
|
}
|
|
|
|
|
2014-11-26 00:46:26 +00:00
|
|
|
let Defs = [RSP, EFLAGS], Uses = [RSP], mayLoad = 1, hasSideEffects=0 in
|
2012-05-10 21:58:35 +00:00
|
|
|
def POPF64 : I<0x9D, RawFrm, (outs), (ins), "popfq", [], IIC_POP_FD>,
|
2014-02-18 08:18:29 +00:00
|
|
|
OpSize32, Requires<[In64BitMode]>, Sched<[WriteLoad]>;
|
2014-11-26 00:46:26 +00:00
|
|
|
let Defs = [RSP], Uses = [RSP, EFLAGS], mayStore = 1, hasSideEffects=0 in
|
2012-05-10 21:58:35 +00:00
|
|
|
def PUSHF64 : I<0x9C, RawFrm, (outs), (ins), "pushfq", [], IIC_PUSH_F>,
|
2014-02-18 08:18:29 +00:00
|
|
|
OpSize32, Requires<[In64BitMode]>, Sched<[WriteStore]>;
|
2010-10-05 06:47:35 +00:00
|
|
|
|
2010-06-23 20:00:58 +00:00
|
|
|
let Defs = [EDI, ESI, EBP, EBX, EDX, ECX, EAX, ESP], Uses = [ESP],
|
2014-11-26 00:46:26 +00:00
|
|
|
mayLoad = 1, hasSideEffects = 0, SchedRW = [WriteLoad] in {
|
2014-01-08 12:57:45 +00:00
|
|
|
def POPA32 : I<0x61, RawFrm, (outs), (ins), "popal", [], IIC_POP_A>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, Requires<[Not64BitMode]>;
|
2014-01-08 12:57:45 +00:00
|
|
|
def POPA16 : I<0x61, RawFrm, (outs), (ins), "popaw", [], IIC_POP_A>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16, Requires<[Not64BitMode]>;
|
2010-06-23 20:00:58 +00:00
|
|
|
}
|
|
|
|
let Defs = [ESP], Uses = [EDI, ESI, EBP, EBX, EDX, ECX, EAX, ESP],
|
2014-11-26 00:46:26 +00:00
|
|
|
mayStore = 1, hasSideEffects = 0, SchedRW = [WriteStore] in {
|
2014-01-08 12:57:45 +00:00
|
|
|
def PUSHA32 : I<0x60, RawFrm, (outs), (ins), "pushal", [], IIC_PUSH_A>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, Requires<[Not64BitMode]>;
|
2014-01-08 12:57:45 +00:00
|
|
|
def PUSHA16 : I<0x60, RawFrm, (outs), (ins), "pushaw", [], IIC_PUSH_A>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16, Requires<[Not64BitMode]>;
|
2010-06-23 20:00:58 +00:00
|
|
|
}
|
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let Constraints = "$src = $dst", SchedRW = [WriteALU] in {
|
|
|
|
// GR32 = bswap GR32
|
2010-10-05 06:52:26 +00:00
|
|
|
def BSWAP32r : I<0xC8, AddRegFrm,
|
|
|
|
(outs GR32:$dst), (ins GR32:$src),
|
2010-10-20 23:40:27 +00:00
|
|
|
"bswap{l}\t$dst",
|
2014-02-02 09:25:09 +00:00
|
|
|
[(set GR32:$dst, (bswap GR32:$src))], IIC_BSWAP>, OpSize32, TB;
|
2010-10-20 23:40:27 +00:00
|
|
|
|
2010-10-05 06:47:35 +00:00
|
|
|
def BSWAP64r : RI<0xC8, AddRegFrm, (outs GR64:$dst), (ins GR64:$src),
|
2010-10-20 23:40:27 +00:00
|
|
|
"bswap{q}\t$dst",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR64:$dst, (bswap GR64:$src))], IIC_BSWAP>, TB;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // Constraints = "$src = $dst", SchedRW
|
2004-10-03 20:35:00 +00:00
|
|
|
|
2007-12-14 02:13:44 +00:00
|
|
|
// Bit scan instructions.
|
|
|
|
let Defs = [EFLAGS] in {
|
2007-12-14 18:49:43 +00:00
|
|
|
def BSF16rr : I<0xBC, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src),
|
2007-12-14 15:10:00 +00:00
|
|
|
"bsf{w}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR16:$dst, EFLAGS, (X86bsf GR16:$src))],
|
2014-02-18 00:21:49 +00:00
|
|
|
IIC_BIT_SCAN_REG>, PS, OpSize16, Sched<[WriteShift]>;
|
2007-12-14 02:13:44 +00:00
|
|
|
def BSF16rm : I<0xBC, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
|
2007-12-14 15:10:00 +00:00
|
|
|
"bsf{w}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR16:$dst, EFLAGS, (X86bsf (loadi16 addr:$src)))],
|
2014-02-18 00:21:49 +00:00
|
|
|
IIC_BIT_SCAN_MEM>, PS, OpSize16, Sched<[WriteShiftLd]>;
|
2007-12-14 18:49:43 +00:00
|
|
|
def BSF32rr : I<0xBC, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src),
|
2007-12-14 15:10:00 +00:00
|
|
|
"bsf{l}\t{$src, $dst|$dst, $src}",
|
2013-09-13 19:23:28 +00:00
|
|
|
[(set GR32:$dst, EFLAGS, (X86bsf GR32:$src))],
|
2014-02-18 00:21:49 +00:00
|
|
|
IIC_BIT_SCAN_REG>, PS, OpSize32, Sched<[WriteShift]>;
|
2007-12-14 02:13:44 +00:00
|
|
|
def BSF32rm : I<0xBC, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
|
2007-12-14 15:10:00 +00:00
|
|
|
"bsf{l}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR32:$dst, EFLAGS, (X86bsf (loadi32 addr:$src)))],
|
2014-02-18 00:21:49 +00:00
|
|
|
IIC_BIT_SCAN_MEM>, PS, OpSize32, Sched<[WriteShiftLd]>;
|
2010-10-05 06:47:35 +00:00
|
|
|
def BSF64rr : RI<0xBC, MRMSrcReg, (outs GR64:$dst), (ins GR64:$src),
|
|
|
|
"bsf{q}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR64:$dst, EFLAGS, (X86bsf GR64:$src))],
|
2014-02-18 00:21:49 +00:00
|
|
|
IIC_BIT_SCAN_REG>, PS, Sched<[WriteShift]>;
|
2010-10-05 06:47:35 +00:00
|
|
|
def BSF64rm : RI<0xBC, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
|
|
|
|
"bsf{q}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR64:$dst, EFLAGS, (X86bsf (loadi64 addr:$src)))],
|
2014-02-18 00:21:49 +00:00
|
|
|
IIC_BIT_SCAN_MEM>, PS, Sched<[WriteShiftLd]>;
|
2007-12-14 02:13:44 +00:00
|
|
|
|
2007-12-14 18:49:43 +00:00
|
|
|
def BSR16rr : I<0xBD, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src),
|
2007-12-14 15:10:00 +00:00
|
|
|
"bsr{w}\t{$src, $dst|$dst, $src}",
|
2013-09-13 19:23:28 +00:00
|
|
|
[(set GR16:$dst, EFLAGS, (X86bsr GR16:$src))],
|
2014-02-18 00:21:49 +00:00
|
|
|
IIC_BIT_SCAN_REG>, PS, OpSize16, Sched<[WriteShift]>;
|
2007-12-14 02:13:44 +00:00
|
|
|
def BSR16rm : I<0xBD, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
|
2007-12-14 15:10:00 +00:00
|
|
|
"bsr{w}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR16:$dst, EFLAGS, (X86bsr (loadi16 addr:$src)))],
|
2014-02-18 00:21:49 +00:00
|
|
|
IIC_BIT_SCAN_MEM>, PS, OpSize16, Sched<[WriteShiftLd]>;
|
2007-12-14 18:49:43 +00:00
|
|
|
def BSR32rr : I<0xBD, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src),
|
2007-12-14 15:10:00 +00:00
|
|
|
"bsr{l}\t{$src, $dst|$dst, $src}",
|
2013-09-13 19:23:28 +00:00
|
|
|
[(set GR32:$dst, EFLAGS, (X86bsr GR32:$src))],
|
2014-02-18 00:21:49 +00:00
|
|
|
IIC_BIT_SCAN_REG>, PS, OpSize32, Sched<[WriteShift]>;
|
2007-12-14 02:13:44 +00:00
|
|
|
def BSR32rm : I<0xBD, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
|
2007-12-14 15:10:00 +00:00
|
|
|
"bsr{l}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR32:$dst, EFLAGS, (X86bsr (loadi32 addr:$src)))],
|
2014-02-18 00:21:49 +00:00
|
|
|
IIC_BIT_SCAN_MEM>, PS, OpSize32, Sched<[WriteShiftLd]>;
|
2010-10-05 06:47:35 +00:00
|
|
|
def BSR64rr : RI<0xBD, MRMSrcReg, (outs GR64:$dst), (ins GR64:$src),
|
|
|
|
"bsr{q}\t{$src, $dst|$dst, $src}",
|
2014-02-18 00:21:49 +00:00
|
|
|
[(set GR64:$dst, EFLAGS, (X86bsr GR64:$src))],
|
|
|
|
IIC_BIT_SCAN_REG>, PS, Sched<[WriteShift]>;
|
2010-10-05 06:47:35 +00:00
|
|
|
def BSR64rm : RI<0xBD, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
|
|
|
|
"bsr{q}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR64:$dst, EFLAGS, (X86bsr (loadi64 addr:$src)))],
|
2014-02-18 00:21:49 +00:00
|
|
|
IIC_BIT_SCAN_MEM>, PS, Sched<[WriteShiftLd]>;
|
2007-12-14 02:13:44 +00:00
|
|
|
} // Defs = [EFLAGS]
|
|
|
|
|
2013-03-26 18:24:15 +00:00
|
|
|
let SchedRW = [WriteMicrocoded] in {
|
2010-02-03 21:04:42 +00:00
|
|
|
// These uses the DF flag in the EFLAGS register to inc or dec EDI and ESI
|
|
|
|
let Defs = [EDI,ESI], Uses = [EDI,ESI,EFLAGS] in {
|
2014-01-22 15:08:42 +00:00
|
|
|
def MOVSB : I<0xA4, RawFrmDstSrc, (outs dstidx8:$dst), (ins srcidx8:$src),
|
|
|
|
"movsb\t{$src, $dst|$dst, $src}", [], IIC_MOVS>;
|
|
|
|
def MOVSW : I<0xA5, RawFrmDstSrc, (outs dstidx16:$dst), (ins srcidx16:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"movsw\t{$src, $dst|$dst, $src}", [], IIC_MOVS>, OpSize16;
|
2014-01-22 15:08:42 +00:00
|
|
|
def MOVSL : I<0xA5, RawFrmDstSrc, (outs dstidx32:$dst), (ins srcidx32:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"movs{l|d}\t{$src, $dst|$dst, $src}", [], IIC_MOVS>, OpSize32;
|
2014-01-22 15:08:42 +00:00
|
|
|
def MOVSQ : RI<0xA5, RawFrmDstSrc, (outs dstidx64:$dst), (ins srcidx64:$src),
|
|
|
|
"movsq\t{$src, $dst|$dst, $src}", [], IIC_MOVS>;
|
2010-02-03 21:04:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// These uses the DF flag in the EFLAGS register to inc or dec EDI and ESI
|
|
|
|
let Defs = [EDI], Uses = [AL,EDI,EFLAGS] in
|
2014-01-22 15:08:21 +00:00
|
|
|
def STOSB : I<0xAA, RawFrmDst, (outs dstidx8:$dst), (ins),
|
|
|
|
"stosb\t{%al, $dst|$dst, al}", [], IIC_STOS>;
|
2010-02-03 21:04:42 +00:00
|
|
|
let Defs = [EDI], Uses = [AX,EDI,EFLAGS] in
|
2014-01-22 15:08:21 +00:00
|
|
|
def STOSW : I<0xAB, RawFrmDst, (outs dstidx16:$dst), (ins),
|
2014-02-02 09:25:09 +00:00
|
|
|
"stosw\t{%ax, $dst|$dst, ax}", [], IIC_STOS>, OpSize16;
|
2010-02-03 21:04:42 +00:00
|
|
|
let Defs = [EDI], Uses = [EAX,EDI,EFLAGS] in
|
2014-01-22 15:08:21 +00:00
|
|
|
def STOSL : I<0xAB, RawFrmDst, (outs dstidx32:$dst), (ins),
|
2014-02-02 09:25:09 +00:00
|
|
|
"stos{l|d}\t{%eax, $dst|$dst, eax}", [], IIC_STOS>, OpSize32;
|
2010-10-05 06:27:48 +00:00
|
|
|
let Defs = [RCX,RDI], Uses = [RAX,RCX,RDI,EFLAGS] in
|
2014-01-22 15:08:21 +00:00
|
|
|
def STOSQ : RI<0xAB, RawFrmDst, (outs dstidx64:$dst), (ins),
|
|
|
|
"stosq\t{%rax, $dst|$dst, rax}", [], IIC_STOS>;
|
2010-02-03 21:04:42 +00:00
|
|
|
|
2014-02-27 05:08:25 +00:00
|
|
|
// These uses the DF flag in the EFLAGS register to inc or dec EDI and ESI
|
|
|
|
let Defs = [EDI,EFLAGS], Uses = [AL,EDI,EFLAGS] in
|
|
|
|
def SCASB : I<0xAE, RawFrmDst, (outs), (ins dstidx8:$dst),
|
2014-01-22 15:08:27 +00:00
|
|
|
"scasb\t{$dst, %al|al, $dst}", [], IIC_SCAS>;
|
2014-02-27 05:08:25 +00:00
|
|
|
let Defs = [EDI,EFLAGS], Uses = [AX,EDI,EFLAGS] in
|
|
|
|
def SCASW : I<0xAF, RawFrmDst, (outs), (ins dstidx16:$dst),
|
|
|
|
"scasw\t{$dst, %ax|ax, $dst}", [], IIC_SCAS>, OpSize16;
|
|
|
|
let Defs = [EDI,EFLAGS], Uses = [EAX,EDI,EFLAGS] in
|
|
|
|
def SCASL : I<0xAF, RawFrmDst, (outs), (ins dstidx32:$dst),
|
|
|
|
"scas{l|d}\t{$dst, %eax|eax, $dst}", [], IIC_SCAS>, OpSize32;
|
|
|
|
let Defs = [EDI,EFLAGS], Uses = [RAX,EDI,EFLAGS] in
|
|
|
|
def SCASQ : RI<0xAF, RawFrmDst, (outs), (ins dstidx64:$dst),
|
|
|
|
"scasq\t{$dst, %rax|rax, $dst}", [], IIC_SCAS>;
|
|
|
|
|
|
|
|
// These uses the DF flag in the EFLAGS register to inc or dec EDI and ESI
|
|
|
|
let Defs = [EDI,ESI,EFLAGS], Uses = [EDI,ESI,EFLAGS] in {
|
|
|
|
def CMPSB : I<0xA6, RawFrmDstSrc, (outs), (ins dstidx8:$dst, srcidx8:$src),
|
2014-01-22 15:08:36 +00:00
|
|
|
"cmpsb\t{$dst, $src|$src, $dst}", [], IIC_CMPS>;
|
2014-02-27 05:08:25 +00:00
|
|
|
def CMPSW : I<0xA7, RawFrmDstSrc, (outs), (ins dstidx16:$dst, srcidx16:$src),
|
|
|
|
"cmpsw\t{$dst, $src|$src, $dst}", [], IIC_CMPS>, OpSize16;
|
|
|
|
def CMPSL : I<0xA7, RawFrmDstSrc, (outs), (ins dstidx32:$dst, srcidx32:$src),
|
|
|
|
"cmps{l|d}\t{$dst, $src|$src, $dst}", [], IIC_CMPS>, OpSize32;
|
|
|
|
def CMPSQ : RI<0xA7, RawFrmDstSrc, (outs), (ins dstidx64:$dst, srcidx64:$src),
|
|
|
|
"cmpsq\t{$dst, $src|$src, $dst}", [], IIC_CMPS>;
|
|
|
|
}
|
2013-03-26 18:24:15 +00:00
|
|
|
} // SchedRW
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2003-08-03 21:54:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2010-10-05 05:32:15 +00:00
|
|
|
// Move Instructions.
|
2003-08-03 21:54:21 +00:00
|
|
|
//
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteMove] in {
|
2014-11-26 00:46:26 +00:00
|
|
|
let hasSideEffects = 0 in {
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV8rr : I<0x88, MRMDestReg, (outs GR8 :$dst), (ins GR8 :$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"mov{b}\t{$src, $dst|$dst, $src}", [], IIC_MOV>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV16rr : I<0x89, MRMDestReg, (outs GR16:$dst), (ins GR16:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"mov{w}\t{$src, $dst|$dst, $src}", [], IIC_MOV>, OpSize16;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV32rr : I<0x89, MRMDestReg, (outs GR32:$dst), (ins GR32:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"mov{l}\t{$src, $dst|$dst, $src}", [], IIC_MOV>, OpSize32;
|
2010-10-05 20:49:15 +00:00
|
|
|
def MOV64rr : RI<0x89, MRMDestReg, (outs GR64:$dst), (ins GR64:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"mov{q}\t{$src, $dst|$dst, $src}", [], IIC_MOV>;
|
2008-01-10 07:59:24 +00:00
|
|
|
}
|
2013-03-19 18:03:55 +00:00
|
|
|
|
2008-06-18 08:13:07 +00:00
|
|
|
let isReMaterializable = 1, isAsCheapAsAMove = 1 in {
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV8ri : Ii8 <0xB0, AddRegFrm, (outs GR8 :$dst), (ins i8imm :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{b}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR8:$dst, imm:$src)], IIC_MOV>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV16ri : Ii16<0xB8, AddRegFrm, (outs GR16:$dst), (ins i16imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{w}\t{$src, $dst|$dst, $src}",
|
2014-02-02 09:25:09 +00:00
|
|
|
[(set GR16:$dst, imm:$src)], IIC_MOV>, OpSize16;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV32ri : Ii32<0xB8, AddRegFrm, (outs GR32:$dst), (ins i32imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{l}\t{$src, $dst|$dst, $src}",
|
2014-02-02 09:25:09 +00:00
|
|
|
[(set GR32:$dst, imm:$src)], IIC_MOV>, OpSize32;
|
2014-01-30 22:20:41 +00:00
|
|
|
def MOV64ri32 : RIi32S<0xC7, MRM0r, (outs GR64:$dst), (ins i64i32imm:$src),
|
|
|
|
"mov{q}\t{$src, $dst|$dst, $src}",
|
|
|
|
[(set GR64:$dst, i64immSExt32:$src)], IIC_MOV>;
|
2007-06-26 00:48:07 +00:00
|
|
|
}
|
2014-02-14 00:51:13 +00:00
|
|
|
let isReMaterializable = 1 in {
|
|
|
|
def MOV64ri : RIi64<0xB8, AddRegFrm, (outs GR64:$dst), (ins i64imm:$src),
|
|
|
|
"movabs{q}\t{$src, $dst|$dst, $src}",
|
|
|
|
[(set GR64:$dst, imm:$src)], IIC_MOV>;
|
|
|
|
}
|
2014-02-15 07:29:18 +00:00
|
|
|
|
|
|
|
// Longer forms that use a ModR/M byte. Needed for disassembler
|
|
|
|
let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0 in {
|
|
|
|
def MOV8ri_alt : Ii8 <0xC6, MRM0r, (outs GR8 :$dst), (ins i8imm :$src),
|
|
|
|
"mov{b}\t{$src, $dst|$dst, $src}", [], IIC_MOV>;
|
|
|
|
def MOV16ri_alt : Ii16<0xC7, MRM0r, (outs GR16:$dst), (ins i16imm:$src),
|
|
|
|
"mov{w}\t{$src, $dst|$dst, $src}", [], IIC_MOV>, OpSize16;
|
|
|
|
def MOV32ri_alt : Ii32<0xC7, MRM0r, (outs GR32:$dst), (ins i32imm:$src),
|
|
|
|
"mov{l}\t{$src, $dst|$dst, $src}", [], IIC_MOV>, OpSize32;
|
|
|
|
}
|
2013-03-19 18:03:55 +00:00
|
|
|
} // SchedRW
|
2010-02-03 21:04:42 +00:00
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteStore] in {
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV8mi : Ii8 <0xC6, MRM0m, (outs), (ins i8mem :$dst, i8imm :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{b}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(store (i8 imm:$src), addr:$dst)], IIC_MOV_MEM>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV16mi : Ii16<0xC7, MRM0m, (outs), (ins i16mem:$dst, i16imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{w}\t{$src, $dst|$dst, $src}",
|
2014-02-02 09:25:09 +00:00
|
|
|
[(store (i16 imm:$src), addr:$dst)], IIC_MOV_MEM>, OpSize16;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV32mi : Ii32<0xC7, MRM0m, (outs), (ins i32mem:$dst, i32imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{l}\t{$src, $dst|$dst, $src}",
|
2014-02-02 09:25:09 +00:00
|
|
|
[(store (i32 imm:$src), addr:$dst)], IIC_MOV_MEM>, OpSize32;
|
2014-01-30 22:20:41 +00:00
|
|
|
def MOV64mi32 : RIi32S<0xC7, MRM0m, (outs), (ins i64mem:$dst, i64i32imm:$src),
|
|
|
|
"mov{q}\t{$src, $dst|$dst, $src}",
|
|
|
|
[(store i64immSExt32:$src, addr:$dst)], IIC_MOV_MEM>;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // SchedRW
|
2004-10-03 20:35:00 +00:00
|
|
|
|
2013-08-24 20:31:14 +00:00
|
|
|
let hasSideEffects = 0 in {
|
|
|
|
|
2010-05-13 00:02:47 +00:00
|
|
|
/// moffs8, moffs16 and moffs32 versions of moves. The immediate is a
|
2014-01-08 12:58:24 +00:00
|
|
|
/// 32-bit offset from the segment base. These are only valid in x86-32 mode.
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
2013-08-24 20:31:14 +00:00
|
|
|
let mayLoad = 1 in {
|
2014-02-27 04:07:57 +00:00
|
|
|
let Defs = [AL] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV8o8a : Ii32 <0xA0, RawFrmMemOffs, (outs), (ins offset8:$src),
|
2013-07-31 02:47:52 +00:00
|
|
|
"mov{b}\t{$src, %al|al, $src}", [], IIC_MOV_MEM>,
|
2014-01-08 12:58:24 +00:00
|
|
|
Requires<[In32BitMode]>;
|
2014-02-27 04:07:57 +00:00
|
|
|
let Defs = [AX] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV16o16a : Ii32 <0xA1, RawFrmMemOffs, (outs), (ins offset16:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"mov{w}\t{$src, %ax|ax, $src}", [], IIC_MOV_MEM>,
|
|
|
|
OpSize16, Requires<[In32BitMode]>;
|
2014-02-27 04:07:57 +00:00
|
|
|
let Defs = [EAX] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV32o32a : Ii32 <0xA1, RawFrmMemOffs, (outs), (ins offset32:$src),
|
2013-07-31 02:47:52 +00:00
|
|
|
"mov{l}\t{$src, %eax|eax, $src}", [], IIC_MOV_MEM>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, Requires<[In32BitMode]>;
|
2014-01-08 12:58:24 +00:00
|
|
|
|
2014-02-27 04:07:57 +00:00
|
|
|
let Defs = [AL] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV8o8a_16 : Ii16 <0xA0, RawFrmMemOffs, (outs), (ins offset8:$src),
|
2014-01-08 12:58:24 +00:00
|
|
|
"mov{b}\t{$src, %al|al, $src}", [], IIC_MOV_MEM>,
|
|
|
|
AdSize, Requires<[In16BitMode]>;
|
2014-02-27 04:07:57 +00:00
|
|
|
let Defs = [AX] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV16o16a_16 : Ii16 <0xA1, RawFrmMemOffs, (outs), (ins offset16:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"mov{w}\t{$src, %ax|ax, $src}", [], IIC_MOV_MEM>,
|
|
|
|
OpSize16, AdSize, Requires<[In16BitMode]>;
|
2014-02-27 04:07:57 +00:00
|
|
|
let Defs = [EAX] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV32o32a_16 : Ii16 <0xA1, RawFrmMemOffs, (outs), (ins offset32:$src),
|
2014-01-08 12:58:24 +00:00
|
|
|
"mov{l}\t{$src, %eax|eax, $src}", [], IIC_MOV_MEM>,
|
2014-02-02 09:25:09 +00:00
|
|
|
AdSize, OpSize32, Requires<[In16BitMode]>;
|
2013-08-24 20:31:14 +00:00
|
|
|
}
|
|
|
|
let mayStore = 1 in {
|
2014-02-27 04:07:57 +00:00
|
|
|
let Uses = [AL] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV8ao8 : Ii32 <0xA2, RawFrmMemOffs, (outs offset8:$dst), (ins),
|
2013-07-31 02:47:52 +00:00
|
|
|
"mov{b}\t{%al, $dst|$dst, al}", [], IIC_MOV_MEM>,
|
2014-01-08 12:58:24 +00:00
|
|
|
Requires<[In32BitMode]>;
|
2014-02-27 04:07:57 +00:00
|
|
|
let Uses = [AX] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV16ao16 : Ii32 <0xA3, RawFrmMemOffs, (outs offset16:$dst), (ins),
|
2014-02-02 09:25:09 +00:00
|
|
|
"mov{w}\t{%ax, $dst|$dst, ax}", [], IIC_MOV_MEM>,
|
|
|
|
OpSize16, Requires<[In32BitMode]>;
|
2014-02-27 04:07:57 +00:00
|
|
|
let Uses = [EAX] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV32ao32 : Ii32 <0xA3, RawFrmMemOffs, (outs offset32:$dst), (ins),
|
2013-07-31 02:47:52 +00:00
|
|
|
"mov{l}\t{%eax, $dst|$dst, eax}", [], IIC_MOV_MEM>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, Requires<[In32BitMode]>;
|
2014-01-08 12:58:24 +00:00
|
|
|
|
2014-02-27 04:07:57 +00:00
|
|
|
let Uses = [AL] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV8ao8_16 : Ii16 <0xA2, RawFrmMemOffs, (outs offset8:$dst), (ins),
|
2014-01-08 12:58:24 +00:00
|
|
|
"mov{b}\t{%al, $dst|$dst, al}", [], IIC_MOV_MEM>,
|
|
|
|
AdSize, Requires<[In16BitMode]>;
|
2014-02-27 04:07:57 +00:00
|
|
|
let Uses = [AX] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV16ao16_16 : Ii16 <0xA3, RawFrmMemOffs, (outs offset16:$dst), (ins),
|
2014-02-02 09:25:09 +00:00
|
|
|
"mov{w}\t{%ax, $dst|$dst, ax}", [], IIC_MOV_MEM>,
|
|
|
|
OpSize16, AdSize, Requires<[In16BitMode]>;
|
2014-02-27 04:07:57 +00:00
|
|
|
let Uses = [EAX] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV32ao32_16 : Ii16 <0xA3, RawFrmMemOffs, (outs offset32:$dst), (ins),
|
2014-01-08 12:58:24 +00:00
|
|
|
"mov{l}\t{%eax, $dst|$dst, eax}", [], IIC_MOV_MEM>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, AdSize, Requires<[In16BitMode]>;
|
2013-03-19 18:03:55 +00:00
|
|
|
}
|
2013-08-24 20:31:14 +00:00
|
|
|
}
|
2010-10-20 23:40:27 +00:00
|
|
|
|
2013-07-22 21:25:31 +00:00
|
|
|
// These forms all have full 64-bit absolute addresses in their instructions
|
|
|
|
// and use the movabs mnemonic to indicate this specific form.
|
2013-08-24 20:31:14 +00:00
|
|
|
let mayLoad = 1 in {
|
2014-02-27 04:07:57 +00:00
|
|
|
let Defs = [AL] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV64o8a : RIi64_NOREX<0xA0, RawFrmMemOffs, (outs), (ins offset8:$src),
|
2013-07-31 02:47:52 +00:00
|
|
|
"movabs{b}\t{$src, %al|al, $src}", []>,
|
2013-07-22 21:25:31 +00:00
|
|
|
Requires<[In64BitMode]>;
|
2014-02-27 04:07:57 +00:00
|
|
|
let Defs = [AX] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV64o16a : RIi64_NOREX<0xA1, RawFrmMemOffs, (outs), (ins offset16:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"movabs{w}\t{$src, %ax|ax, $src}", []>, OpSize16,
|
2013-07-22 21:25:31 +00:00
|
|
|
Requires<[In64BitMode]>;
|
2014-02-27 04:07:57 +00:00
|
|
|
let Defs = [EAX] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV64o32a : RIi64_NOREX<0xA1, RawFrmMemOffs, (outs), (ins offset32:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"movabs{l}\t{$src, %eax|eax, $src}", []>, OpSize32,
|
2013-07-22 21:25:31 +00:00
|
|
|
Requires<[In64BitMode]>;
|
2014-02-27 04:07:57 +00:00
|
|
|
let Defs = [RAX] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV64o64a : RIi64<0xA1, RawFrmMemOffs, (outs), (ins offset64:$src),
|
2013-07-31 02:47:52 +00:00
|
|
|
"movabs{q}\t{$src, %rax|rax, $src}", []>,
|
2013-07-22 21:25:31 +00:00
|
|
|
Requires<[In64BitMode]>;
|
2013-08-24 20:31:14 +00:00
|
|
|
}
|
2013-07-22 21:25:31 +00:00
|
|
|
|
2013-08-24 20:31:14 +00:00
|
|
|
let mayStore = 1 in {
|
2014-02-27 04:07:57 +00:00
|
|
|
let Uses = [AL] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV64ao8 : RIi64_NOREX<0xA2, RawFrmMemOffs, (outs offset8:$dst), (ins),
|
2013-07-31 02:47:52 +00:00
|
|
|
"movabs{b}\t{%al, $dst|$dst, al}", []>,
|
2013-07-22 21:25:31 +00:00
|
|
|
Requires<[In64BitMode]>;
|
2014-02-27 04:07:57 +00:00
|
|
|
let Uses = [AX] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV64ao16 : RIi64_NOREX<0xA3, RawFrmMemOffs, (outs offset16:$dst), (ins),
|
2014-02-02 09:25:09 +00:00
|
|
|
"movabs{w}\t{%ax, $dst|$dst, ax}", []>, OpSize16,
|
2013-07-22 21:25:31 +00:00
|
|
|
Requires<[In64BitMode]>;
|
2014-02-27 04:07:57 +00:00
|
|
|
let Uses = [EAX] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV64ao32 : RIi64_NOREX<0xA3, RawFrmMemOffs, (outs offset32:$dst), (ins),
|
2014-02-02 09:25:09 +00:00
|
|
|
"movabs{l}\t{%eax, $dst|$dst, eax}", []>, OpSize32,
|
2013-07-22 21:25:31 +00:00
|
|
|
Requires<[In64BitMode]>;
|
2014-02-27 04:07:57 +00:00
|
|
|
let Uses = [RAX] in
|
2014-01-16 07:36:58 +00:00
|
|
|
def MOV64ao64 : RIi64<0xA3, RawFrmMemOffs, (outs offset64:$dst), (ins),
|
2013-07-31 02:47:52 +00:00
|
|
|
"movabs{q}\t{%rax, $dst|$dst, rax}", []>,
|
2013-07-22 21:25:31 +00:00
|
|
|
Requires<[In64BitMode]>;
|
2013-08-24 20:31:14 +00:00
|
|
|
}
|
|
|
|
} // hasSideEffects = 0
|
2009-09-15 18:47:29 +00:00
|
|
|
|
2014-01-05 04:17:28 +00:00
|
|
|
let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0,
|
|
|
|
SchedRW = [WriteMove] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def MOV8rr_REV : I<0x8A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"mov{b}\t{$src, $dst|$dst, $src}", [], IIC_MOV>;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def MOV16rr_REV : I<0x8B, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"mov{w}\t{$src, $dst|$dst, $src}", [], IIC_MOV>, OpSize16;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def MOV32rr_REV : I<0x8B, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"mov{l}\t{$src, $dst|$dst, $src}", [], IIC_MOV>, OpSize32;
|
2010-10-05 20:49:15 +00:00
|
|
|
def MOV64rr_REV : RI<0x8B, MRMSrcReg, (outs GR64:$dst), (ins GR64:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"mov{q}\t{$src, $dst|$dst, $src}", [], IIC_MOV>;
|
2010-05-26 22:21:28 +00:00
|
|
|
}
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let canFoldAsLoad = 1, isReMaterializable = 1, SchedRW = [WriteLoad] in {
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV8rm : I<0x8A, MRMSrcMem, (outs GR8 :$dst), (ins i8mem :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{b}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR8:$dst, (loadi8 addr:$src))], IIC_MOV_MEM>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV16rm : I<0x8B, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{w}\t{$src, $dst|$dst, $src}",
|
2014-02-02 09:25:09 +00:00
|
|
|
[(set GR16:$dst, (loadi16 addr:$src))], IIC_MOV_MEM>, OpSize16;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV32rm : I<0x8B, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{l}\t{$src, $dst|$dst, $src}",
|
2014-02-02 09:25:09 +00:00
|
|
|
[(set GR32:$dst, (loadi32 addr:$src))], IIC_MOV_MEM>, OpSize32;
|
2010-10-05 20:49:15 +00:00
|
|
|
def MOV64rm : RI<0x8B, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
|
|
|
|
"mov{q}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR64:$dst, (load addr:$src))], IIC_MOV_MEM>;
|
2007-08-30 05:49:43 +00:00
|
|
|
}
|
2004-10-03 20:35:00 +00:00
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteStore] in {
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV8mr : I<0x88, MRMDestMem, (outs), (ins i8mem :$dst, GR8 :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{b}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(store GR8:$src, addr:$dst)], IIC_MOV_MEM>;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV16mr : I<0x89, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{w}\t{$src, $dst|$dst, $src}",
|
2014-02-02 09:25:09 +00:00
|
|
|
[(store GR16:$src, addr:$dst)], IIC_MOV_MEM>, OpSize16;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def MOV32mr : I<0x89, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{l}\t{$src, $dst|$dst, $src}",
|
2014-02-02 09:25:09 +00:00
|
|
|
[(store GR32:$src, addr:$dst)], IIC_MOV_MEM>, OpSize32;
|
2010-10-05 20:49:15 +00:00
|
|
|
def MOV64mr : RI<0x89, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src),
|
|
|
|
"mov{q}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(store GR64:$src, addr:$dst)], IIC_MOV_MEM>;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // SchedRW
|
Implement x86 h-register extract support.
- Add patterns for h-register extract, which avoids a shift and mask,
and in some cases a temporary register.
- Add address-mode matching for turning (X>>(8-n))&(255<<n), where
n is a valid address-mode scale value, into an h-register extract
and a scaled-offset address.
- Replace X86's MOV32to32_ and related instructions with the new
target-independent COPY_TO_SUBREG instruction.
On x86-64 there are complicated constraints on h registers, and
CodeGen doesn't currently provide a high-level way to express all of them,
so they are handled with a bunch of special code. This code currently only
supports extracts where the result is used by a zero-extend or a store,
though these are fairly common.
These transformations are not always beneficial; since there are only
4 h registers, they sometimes require extra move instructions, and
this sometimes increases register pressure because it can force out
values that would otherwise be in one of those registers. However,
this appears to be relatively uncommon.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@68962 91177308-0d34-0410-b5e6-96231b3b80d8
2009-04-13 16:09:41 +00:00
|
|
|
|
2009-04-27 16:41:36 +00:00
|
|
|
// Versions of MOV8rr, MOV8mr, and MOV8rm that use i8mem_NOREX and GR8_NOREX so
|
|
|
|
// that they can be used for copying and storing h registers, which can't be
|
|
|
|
// encoded when a REX prefix is present.
|
2010-07-19 06:14:49 +00:00
|
|
|
let isCodeGenOnly = 1 in {
|
2014-11-26 00:46:26 +00:00
|
|
|
let hasSideEffects = 0 in
|
2009-04-15 19:48:57 +00:00
|
|
|
def MOV8rr_NOREX : I<0x88, MRMDestReg,
|
|
|
|
(outs GR8_NOREX:$dst), (ins GR8_NOREX:$src),
|
2013-03-19 18:03:55 +00:00
|
|
|
"mov{b}\t{$src, $dst|$dst, $src} # NOREX", [], IIC_MOV>,
|
|
|
|
Sched<[WriteMove]>;
|
2014-11-26 00:46:26 +00:00
|
|
|
let mayStore = 1, hasSideEffects = 0 in
|
2009-04-15 00:04:23 +00:00
|
|
|
def MOV8mr_NOREX : I<0x88, MRMDestMem,
|
|
|
|
(outs), (ins i8mem_NOREX:$dst, GR8_NOREX:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"mov{b}\t{$src, $dst|$dst, $src} # NOREX", [],
|
2013-03-19 18:03:55 +00:00
|
|
|
IIC_MOV_MEM>, Sched<[WriteStore]>;
|
2014-11-26 00:46:26 +00:00
|
|
|
let mayLoad = 1, hasSideEffects = 0,
|
2010-02-27 23:47:46 +00:00
|
|
|
canFoldAsLoad = 1, isReMaterializable = 1 in
|
2009-04-27 16:41:36 +00:00
|
|
|
def MOV8rm_NOREX : I<0x8A, MRMSrcMem,
|
|
|
|
(outs GR8_NOREX:$dst), (ins i8mem_NOREX:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"mov{b}\t{$src, $dst|$dst, $src} # NOREX", [],
|
2013-03-19 18:03:55 +00:00
|
|
|
IIC_MOV_MEM>, Sched<[WriteLoad]>;
|
2010-07-19 06:14:49 +00:00
|
|
|
}
|
Implement x86 h-register extract support.
- Add patterns for h-register extract, which avoids a shift and mask,
and in some cases a temporary register.
- Add address-mode matching for turning (X>>(8-n))&(255<<n), where
n is a valid address-mode scale value, into an h-register extract
and a scaled-offset address.
- Replace X86's MOV32to32_ and related instructions with the new
target-independent COPY_TO_SUBREG instruction.
On x86-64 there are complicated constraints on h registers, and
CodeGen doesn't currently provide a high-level way to express all of them,
so they are handled with a bunch of special code. This code currently only
supports extracts where the result is used by a zero-extend or a store,
though these are fairly common.
These transformations are not always beneficial; since there are only
4 h registers, they sometimes require extra move instructions, and
this sometimes increases register pressure because it can force out
values that would otherwise be in one of those registers. However,
this appears to be relatively uncommon.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@68962 91177308-0d34-0410-b5e6-96231b3b80d8
2009-04-13 16:09:41 +00:00
|
|
|
|
2007-09-25 01:57:46 +00:00
|
|
|
|
2004-02-28 22:02:05 +00:00
|
|
|
// Condition code ops, incl. set if equal/not equal/...
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
2012-04-27 12:07:43 +00:00
|
|
|
let Defs = [EFLAGS], Uses = [AH] in
|
|
|
|
def SAHF : I<0x9E, RawFrm, (outs), (ins), "sahf",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set EFLAGS, (X86sahf AH))], IIC_AHF>;
|
2014-11-26 00:46:26 +00:00
|
|
|
let Defs = [AH], Uses = [EFLAGS], hasSideEffects = 0 in
|
2012-05-10 21:58:35 +00:00
|
|
|
def LAHF : I<0x9F, RawFrm, (outs), (ins), "lahf", [],
|
|
|
|
IIC_AHF>; // AH = flags
|
2013-03-19 18:03:55 +00:00
|
|
|
} // SchedRW
|
2010-03-09 22:50:40 +00:00
|
|
|
|
2010-10-05 20:49:15 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Bit tests instructions: BT, BTS, BTR, BTC.
|
2007-09-25 01:57:46 +00:00
|
|
|
|
2008-12-23 22:45:23 +00:00
|
|
|
let Defs = [EFLAGS] in {
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
2009-01-13 20:32:45 +00:00
|
|
|
def BT16rr : I<0xA3, MRMDestReg, (outs), (ins GR16:$src1, GR16:$src2),
|
2008-12-23 22:45:23 +00:00
|
|
|
"bt{w}\t{$src2, $src1|$src1, $src2}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set EFLAGS, (X86bt GR16:$src1, GR16:$src2))], IIC_BT_RR>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16, TB;
|
2009-01-13 20:32:45 +00:00
|
|
|
def BT32rr : I<0xA3, MRMDestReg, (outs), (ins GR32:$src1, GR32:$src2),
|
2008-12-23 22:45:23 +00:00
|
|
|
"bt{l}\t{$src2, $src1|$src1, $src2}",
|
2014-01-08 12:57:40 +00:00
|
|
|
[(set EFLAGS, (X86bt GR32:$src1, GR32:$src2))], IIC_BT_RR>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BT64rr : RI<0xA3, MRMDestReg, (outs), (ins GR64:$src1, GR64:$src2),
|
|
|
|
"bt{q}\t{$src2, $src1|$src1, $src2}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set EFLAGS, (X86bt GR64:$src1, GR64:$src2))], IIC_BT_RR>, TB;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // SchedRW
|
2009-01-13 23:23:30 +00:00
|
|
|
|
|
|
|
// Unlike with the register+register form, the memory+register form of the
|
|
|
|
// bt instruction does not ignore the high bits of the index. From ISel's
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
// perspective, this is pretty bizarre. Make these instructions disassembly
|
|
|
|
// only for now.
|
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let mayLoad = 1, hasSideEffects = 0, SchedRW = [WriteALULd] in {
|
2012-12-27 02:01:33 +00:00
|
|
|
def BT16mr : I<0xA3, MRMDestMem, (outs), (ins i16mem:$src1, GR16:$src2),
|
|
|
|
"bt{w}\t{$src2, $src1|$src1, $src2}",
|
|
|
|
// [(X86bt (loadi16 addr:$src1), GR16:$src2),
|
|
|
|
// (implicit EFLAGS)]
|
|
|
|
[], IIC_BT_MR
|
2014-02-02 09:25:09 +00:00
|
|
|
>, OpSize16, TB, Requires<[FastBTMem]>;
|
2012-12-27 02:01:33 +00:00
|
|
|
def BT32mr : I<0xA3, MRMDestMem, (outs), (ins i32mem:$src1, GR32:$src2),
|
|
|
|
"bt{l}\t{$src2, $src1|$src1, $src2}",
|
|
|
|
// [(X86bt (loadi32 addr:$src1), GR32:$src2),
|
|
|
|
// (implicit EFLAGS)]
|
|
|
|
[], IIC_BT_MR
|
2014-02-02 09:25:09 +00:00
|
|
|
>, OpSize32, TB, Requires<[FastBTMem]>;
|
2012-12-27 02:01:33 +00:00
|
|
|
def BT64mr : RI<0xA3, MRMDestMem, (outs), (ins i64mem:$src1, GR64:$src2),
|
|
|
|
"bt{q}\t{$src2, $src1|$src1, $src2}",
|
|
|
|
// [(X86bt (loadi64 addr:$src1), GR64:$src2),
|
|
|
|
// (implicit EFLAGS)]
|
|
|
|
[], IIC_BT_MR
|
|
|
|
>, TB;
|
|
|
|
}
|
2009-01-13 20:33:23 +00:00
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
2009-01-13 20:33:23 +00:00
|
|
|
def BT16ri8 : Ii8<0xBA, MRM4r, (outs), (ins GR16:$src1, i16i8imm:$src2),
|
|
|
|
"bt{w}\t{$src2, $src1|$src1, $src2}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set EFLAGS, (X86bt GR16:$src1, i16immSExt8:$src2))],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_BT_RI>, OpSize16, TB;
|
2009-01-13 20:33:23 +00:00
|
|
|
def BT32ri8 : Ii8<0xBA, MRM4r, (outs), (ins GR32:$src1, i32i8imm:$src2),
|
|
|
|
"bt{l}\t{$src2, $src1|$src1, $src2}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set EFLAGS, (X86bt GR32:$src1, i32immSExt8:$src2))],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_BT_RI>, OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BT64ri8 : RIi8<0xBA, MRM4r, (outs), (ins GR64:$src1, i64i8imm:$src2),
|
|
|
|
"bt{q}\t{$src2, $src1|$src1, $src2}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set EFLAGS, (X86bt GR64:$src1, i64immSExt8:$src2))],
|
|
|
|
IIC_BT_RI>, TB;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // SchedRW
|
2010-10-05 20:49:15 +00:00
|
|
|
|
2009-01-13 20:33:23 +00:00
|
|
|
// Note that these instructions don't need FastBTMem because that
|
|
|
|
// only applies when the other operand is in a register. When it's
|
|
|
|
// an immediate, bt is still fast.
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
2009-01-13 20:33:23 +00:00
|
|
|
def BT16mi8 : Ii8<0xBA, MRM4m, (outs), (ins i16mem:$src1, i16i8imm:$src2),
|
|
|
|
"bt{w}\t{$src2, $src1|$src1, $src2}",
|
Now that tblgen can handle matching implicit defs of instructions
to input patterns, we can fix X86ISD::CMP and X86ISD::BT as taking
two inputs (which have to be the same type) and *returning an i32*.
This is how the SDNodes get made in the graph, but we weren't able
to model it this way due to deficiencies in the pattern language.
Now we can change things like this:
def UCOM_FpIr80: FpI_<(outs), (ins RFP80:$lhs, RFP80:$rhs), CompareFP,
- [(X86cmp RFP80:$lhs, RFP80:$rhs),
- (implicit EFLAGS)]>; // CC = ST(0) cmp ST(i)
+ [(set EFLAGS, (X86cmp RFP80:$lhs, RFP80:$rhs))]>;
and fix terrible crimes like this:
-def : Pat<(parallel (X86cmp GR8:$src1, 0), (implicit EFLAGS)),
+def : Pat<(X86cmp GR8:$src1, 0),
(TEST8rr GR8:$src1, GR8:$src1)>;
This relies on matching the result of TEST8rr (which is EFLAGS, which is
an implicit def) to the result of X86cmp, an i32.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@98903 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-19 00:01:11 +00:00
|
|
|
[(set EFLAGS, (X86bt (loadi16 addr:$src1), i16immSExt8:$src2))
|
2014-02-02 09:25:09 +00:00
|
|
|
], IIC_BT_MI>, OpSize16, TB;
|
2009-01-13 20:33:23 +00:00
|
|
|
def BT32mi8 : Ii8<0xBA, MRM4m, (outs), (ins i32mem:$src1, i32i8imm:$src2),
|
|
|
|
"bt{l}\t{$src2, $src1|$src1, $src2}",
|
Now that tblgen can handle matching implicit defs of instructions
to input patterns, we can fix X86ISD::CMP and X86ISD::BT as taking
two inputs (which have to be the same type) and *returning an i32*.
This is how the SDNodes get made in the graph, but we weren't able
to model it this way due to deficiencies in the pattern language.
Now we can change things like this:
def UCOM_FpIr80: FpI_<(outs), (ins RFP80:$lhs, RFP80:$rhs), CompareFP,
- [(X86cmp RFP80:$lhs, RFP80:$rhs),
- (implicit EFLAGS)]>; // CC = ST(0) cmp ST(i)
+ [(set EFLAGS, (X86cmp RFP80:$lhs, RFP80:$rhs))]>;
and fix terrible crimes like this:
-def : Pat<(parallel (X86cmp GR8:$src1, 0), (implicit EFLAGS)),
+def : Pat<(X86cmp GR8:$src1, 0),
(TEST8rr GR8:$src1, GR8:$src1)>;
This relies on matching the result of TEST8rr (which is EFLAGS, which is
an implicit def) to the result of X86cmp, an i32.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@98903 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-19 00:01:11 +00:00
|
|
|
[(set EFLAGS, (X86bt (loadi32 addr:$src1), i32immSExt8:$src2))
|
2014-02-02 09:25:09 +00:00
|
|
|
], IIC_BT_MI>, OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BT64mi8 : RIi8<0xBA, MRM4m, (outs), (ins i64mem:$src1, i64i8imm:$src2),
|
|
|
|
"bt{q}\t{$src2, $src1|$src1, $src2}",
|
|
|
|
[(set EFLAGS, (X86bt (loadi64 addr:$src1),
|
2012-05-10 21:58:35 +00:00
|
|
|
i64immSExt8:$src2))], IIC_BT_MI>, TB;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // SchedRW
|
2010-10-05 20:49:15 +00:00
|
|
|
|
2012-12-27 02:01:33 +00:00
|
|
|
let hasSideEffects = 0 in {
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTC16rr : I<0xBB, MRMDestReg, (outs), (ins GR16:$src1, GR16:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btc{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTC32rr : I<0xBB, MRMDestReg, (outs), (ins GR32:$src1, GR32:$src2),
|
2014-01-08 12:57:40 +00:00
|
|
|
"btc{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BTC64rr : RI<0xBB, MRMDestReg, (outs), (ins GR64:$src1, GR64:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btc{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>, TB;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // SchedRW
|
2012-12-27 02:01:33 +00:00
|
|
|
|
2013-03-26 18:24:15 +00:00
|
|
|
let mayLoad = 1, mayStore = 1, SchedRW = [WriteALULd, WriteRMW] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTC16mr : I<0xBB, MRMDestMem, (outs), (ins i16mem:$src1, GR16:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btc{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTC32mr : I<0xBB, MRMDestMem, (outs), (ins i32mem:$src1, GR32:$src2),
|
2014-01-08 12:57:40 +00:00
|
|
|
"btc{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BTC64mr : RI<0xBB, MRMDestMem, (outs), (ins i64mem:$src1, GR64:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btc{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>, TB;
|
2012-12-27 02:01:33 +00:00
|
|
|
}
|
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTC16ri8 : Ii8<0xBA, MRM7r, (outs), (ins GR16:$src1, i16i8imm:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btc{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTC32ri8 : Ii8<0xBA, MRM7r, (outs), (ins GR32:$src1, i32i8imm:$src2),
|
2014-01-08 12:57:40 +00:00
|
|
|
"btc{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BTC64ri8 : RIi8<0xBA, MRM7r, (outs), (ins GR64:$src1, i64i8imm:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btc{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>, TB;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // SchedRW
|
2012-12-27 02:01:33 +00:00
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let mayLoad = 1, mayStore = 1, SchedRW = [WriteALULd, WriteRMW] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTC16mi8 : Ii8<0xBA, MRM7m, (outs), (ins i16mem:$src1, i16i8imm:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btc{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTC32mi8 : Ii8<0xBA, MRM7m, (outs), (ins i32mem:$src1, i32i8imm:$src2),
|
2014-01-08 12:57:40 +00:00
|
|
|
"btc{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BTC64mi8 : RIi8<0xBA, MRM7m, (outs), (ins i64mem:$src1, i64i8imm:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btc{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>, TB;
|
2012-12-27 02:01:33 +00:00
|
|
|
}
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTR16rr : I<0xB3, MRMDestReg, (outs), (ins GR16:$src1, GR16:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btr{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTR32rr : I<0xB3, MRMDestReg, (outs), (ins GR32:$src1, GR32:$src2),
|
2014-01-08 12:57:40 +00:00
|
|
|
"btr{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BTR64rr : RI<0xB3, MRMDestReg, (outs), (ins GR64:$src1, GR64:$src2),
|
|
|
|
"btr{q}\t{$src2, $src1|$src1, $src2}", []>, TB;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // SchedRW
|
2012-12-27 02:01:33 +00:00
|
|
|
|
2013-03-26 18:24:15 +00:00
|
|
|
let mayLoad = 1, mayStore = 1, SchedRW = [WriteALULd, WriteRMW] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTR16mr : I<0xB3, MRMDestMem, (outs), (ins i16mem:$src1, GR16:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btr{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTR32mr : I<0xB3, MRMDestMem, (outs), (ins i32mem:$src1, GR32:$src2),
|
2014-01-08 12:57:40 +00:00
|
|
|
"btr{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BTR64mr : RI<0xB3, MRMDestMem, (outs), (ins i64mem:$src1, GR64:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btr{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>, TB;
|
2012-12-27 02:01:33 +00:00
|
|
|
}
|
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTR16ri8 : Ii8<0xBA, MRM6r, (outs), (ins GR16:$src1, i16i8imm:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btr{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTR32ri8 : Ii8<0xBA, MRM6r, (outs), (ins GR32:$src1, i32i8imm:$src2),
|
2014-01-08 12:57:40 +00:00
|
|
|
"btr{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BTR64ri8 : RIi8<0xBA, MRM6r, (outs), (ins GR64:$src1, i64i8imm:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btr{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>, TB;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // SchedRW
|
2012-12-27 02:01:33 +00:00
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let mayLoad = 1, mayStore = 1, SchedRW = [WriteALULd, WriteRMW] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTR16mi8 : Ii8<0xBA, MRM6m, (outs), (ins i16mem:$src1, i16i8imm:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btr{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTR32mi8 : Ii8<0xBA, MRM6m, (outs), (ins i32mem:$src1, i32i8imm:$src2),
|
2014-01-08 12:57:40 +00:00
|
|
|
"btr{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BTR64mi8 : RIi8<0xBA, MRM6m, (outs), (ins i64mem:$src1, i64i8imm:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"btr{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>, TB;
|
2012-12-27 02:01:33 +00:00
|
|
|
}
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTS16rr : I<0xAB, MRMDestReg, (outs), (ins GR16:$src1, GR16:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"bts{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTS32rr : I<0xAB, MRMDestReg, (outs), (ins GR32:$src1, GR32:$src2),
|
2014-01-08 12:57:40 +00:00
|
|
|
"bts{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BTS64rr : RI<0xAB, MRMDestReg, (outs), (ins GR64:$src1, GR64:$src2),
|
2014-02-02 09:25:09 +00:00
|
|
|
"bts{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>, TB;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // SchedRW
|
2012-12-27 02:01:33 +00:00
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let mayLoad = 1, mayStore = 1, SchedRW = [WriteALULd, WriteRMW] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTS16mr : I<0xAB, MRMDestMem, (outs), (ins i16mem:$src1, GR16:$src2),
|
2014-02-02 09:25:09 +00:00
|
|
|
"bts{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>,
|
|
|
|
OpSize16, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTS32mr : I<0xAB, MRMDestMem, (outs), (ins i32mem:$src1, GR32:$src2),
|
2014-02-02 09:25:09 +00:00
|
|
|
"bts{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>,
|
|
|
|
OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BTS64mr : RI<0xAB, MRMDestMem, (outs), (ins i64mem:$src1, GR64:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"bts{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>, TB;
|
2012-12-27 02:01:33 +00:00
|
|
|
}
|
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTS16ri8 : Ii8<0xBA, MRM5r, (outs), (ins GR16:$src1, i16i8imm:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"bts{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTS32ri8 : Ii8<0xBA, MRM5r, (outs), (ins GR32:$src1, i32i8imm:$src2),
|
2014-01-08 12:57:40 +00:00
|
|
|
"bts{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BTS64ri8 : RIi8<0xBA, MRM5r, (outs), (ins GR64:$src1, i64i8imm:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"bts{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>, TB;
|
2013-03-19 18:03:55 +00:00
|
|
|
} // SchedRW
|
2012-12-27 02:01:33 +00:00
|
|
|
|
2013-03-19 18:03:55 +00:00
|
|
|
let mayLoad = 1, mayStore = 1, SchedRW = [WriteALULd, WriteRMW] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTS16mi8 : Ii8<0xBA, MRM5m, (outs), (ins i16mem:$src1, i16i8imm:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"bts{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def BTS32mi8 : Ii8<0xBA, MRM5m, (outs), (ins i32mem:$src1, i32i8imm:$src2),
|
2014-01-08 12:57:40 +00:00
|
|
|
"bts{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, TB;
|
2010-10-05 20:49:15 +00:00
|
|
|
def BTS64mi8 : RIi8<0xBA, MRM5m, (outs), (ins i64mem:$src1, i64i8imm:$src2),
|
2012-05-10 21:58:35 +00:00
|
|
|
"bts{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>, TB;
|
2012-12-27 02:01:33 +00:00
|
|
|
}
|
|
|
|
} // hasSideEffects = 0
|
2008-12-23 22:45:23 +00:00
|
|
|
} // Defs = [EFLAGS]
|
|
|
|
|
2007-07-14 14:06:15 +00:00
|
|
|
|
2008-02-21 06:45:13 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Atomic support
|
|
|
|
//
|
2008-03-01 13:37:02 +00:00
|
|
|
|
2008-04-19 01:20:30 +00:00
|
|
|
// Atomic swap. These are just normal xchg instructions. But since a memory
|
|
|
|
// operand is referenced, the atomicity is ensured.
|
2012-09-21 03:00:17 +00:00
|
|
|
multiclass ATOMIC_SWAP<bits<8> opc8, bits<8> opc, string mnemonic, string frag,
|
|
|
|
InstrItinClass itin> {
|
2013-03-26 18:24:15 +00:00
|
|
|
let Constraints = "$val = $dst", SchedRW = [WriteALULd, WriteRMW] in {
|
2013-01-07 05:26:58 +00:00
|
|
|
def NAME#8rm : I<opc8, MRMSrcMem, (outs GR8:$dst),
|
|
|
|
(ins GR8:$val, i8mem:$ptr),
|
|
|
|
!strconcat(mnemonic, "{b}\t{$val, $ptr|$ptr, $val}"),
|
|
|
|
[(set
|
|
|
|
GR8:$dst,
|
|
|
|
(!cast<PatFrag>(frag # "_8") addr:$ptr, GR8:$val))],
|
|
|
|
itin>;
|
|
|
|
def NAME#16rm : I<opc, MRMSrcMem, (outs GR16:$dst),
|
|
|
|
(ins GR16:$val, i16mem:$ptr),
|
|
|
|
!strconcat(mnemonic, "{w}\t{$val, $ptr|$ptr, $val}"),
|
|
|
|
[(set
|
|
|
|
GR16:$dst,
|
|
|
|
(!cast<PatFrag>(frag # "_16") addr:$ptr, GR16:$val))],
|
2014-02-02 09:25:09 +00:00
|
|
|
itin>, OpSize16;
|
2013-01-07 05:26:58 +00:00
|
|
|
def NAME#32rm : I<opc, MRMSrcMem, (outs GR32:$dst),
|
|
|
|
(ins GR32:$val, i32mem:$ptr),
|
|
|
|
!strconcat(mnemonic, "{l}\t{$val, $ptr|$ptr, $val}"),
|
|
|
|
[(set
|
|
|
|
GR32:$dst,
|
|
|
|
(!cast<PatFrag>(frag # "_32") addr:$ptr, GR32:$val))],
|
2014-02-02 09:25:09 +00:00
|
|
|
itin>, OpSize32;
|
2013-01-07 05:26:58 +00:00
|
|
|
def NAME#64rm : RI<opc, MRMSrcMem, (outs GR64:$dst),
|
|
|
|
(ins GR64:$val, i64mem:$ptr),
|
|
|
|
!strconcat(mnemonic, "{q}\t{$val, $ptr|$ptr, $val}"),
|
2012-09-21 03:00:17 +00:00
|
|
|
[(set
|
2013-01-07 05:26:58 +00:00
|
|
|
GR64:$dst,
|
|
|
|
(!cast<PatFrag>(frag # "_64") addr:$ptr, GR64:$val))],
|
2012-09-21 03:00:17 +00:00
|
|
|
itin>;
|
|
|
|
}
|
|
|
|
}
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2012-09-21 03:00:17 +00:00
|
|
|
defm XCHG : ATOMIC_SWAP<0x86, 0x87, "xchg", "atomic_swap", IIC_XCHG_MEM>;
|
|
|
|
|
|
|
|
// Swap between registers.
|
2013-03-26 18:24:15 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
2012-09-21 03:00:17 +00:00
|
|
|
let Constraints = "$val = $dst" in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def XCHG8rr : I<0x86, MRMSrcReg, (outs GR8:$dst), (ins GR8:$val, GR8:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"xchg{b}\t{$val, $src|$src, $val}", [], IIC_XCHG_REG>;
|
2010-10-05 06:22:35 +00:00
|
|
|
def XCHG16rr : I<0x87, MRMSrcReg, (outs GR16:$dst), (ins GR16:$val, GR16:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"xchg{w}\t{$val, $src|$src, $val}", [], IIC_XCHG_REG>,
|
|
|
|
OpSize16;
|
2010-10-05 06:22:35 +00:00
|
|
|
def XCHG32rr : I<0x87, MRMSrcReg, (outs GR32:$dst), (ins GR32:$val, GR32:$src),
|
2014-01-08 12:57:40 +00:00
|
|
|
"xchg{l}\t{$val, $src|$src, $val}", [], IIC_XCHG_REG>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32;
|
2010-10-05 06:22:35 +00:00
|
|
|
def XCHG64rr : RI<0x87, MRMSrcReg, (outs GR64:$dst), (ins GR64:$val,GR64:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"xchg{q}\t{$val, $src|$src, $val}", [], IIC_XCHG_REG>;
|
2008-04-19 01:20:30 +00:00
|
|
|
}
|
|
|
|
|
2012-09-21 03:00:17 +00:00
|
|
|
// Swap between EAX and other registers.
|
2014-02-27 04:27:00 +00:00
|
|
|
let Uses = [AX], Defs = [AX] in
|
2011-10-07 05:35:38 +00:00
|
|
|
def XCHG16ar : I<0x90, AddRegFrm, (outs), (ins GR16:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"xchg{w}\t{$src, %ax|ax, $src}", [], IIC_XCHG_REG>, OpSize16;
|
2014-02-27 04:27:00 +00:00
|
|
|
let Uses = [EAX], Defs = [EAX] in
|
2011-10-07 05:35:38 +00:00
|
|
|
def XCHG32ar : I<0x90, AddRegFrm, (outs), (ins GR32:$src),
|
2013-07-31 02:47:52 +00:00
|
|
|
"xchg{l}\t{$src, %eax|eax, $src}", [], IIC_XCHG_REG>,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32, Requires<[Not64BitMode]>;
|
2014-02-27 04:27:00 +00:00
|
|
|
let Uses = [EAX], Defs = [EAX] in
|
2011-10-07 05:35:38 +00:00
|
|
|
// Uses GR32_NOAX in 64-bit mode to prevent encoding using the 0x90 NOP encoding.
|
|
|
|
// xchg %eax, %eax needs to clear upper 32-bits of RAX so is not a NOP.
|
|
|
|
def XCHG32ar64 : I<0x90, AddRegFrm, (outs), (ins GR32_NOAX:$src),
|
2013-07-31 02:47:52 +00:00
|
|
|
"xchg{l}\t{$src, %eax|eax, $src}", [], IIC_XCHG_REG>,
|
2014-02-18 08:18:29 +00:00
|
|
|
OpSize32, Requires<[In64BitMode]>;
|
2014-02-27 04:27:00 +00:00
|
|
|
let Uses = [RAX], Defs = [RAX] in
|
2011-10-07 05:35:38 +00:00
|
|
|
def XCHG64ar : RI<0x90, AddRegFrm, (outs), (ins GR64:$src),
|
2013-07-31 02:47:52 +00:00
|
|
|
"xchg{q}\t{$src, %rax|rax, $src}", [], IIC_XCHG_REG>;
|
2013-03-26 18:24:15 +00:00
|
|
|
} // SchedRW
|
2010-10-05 06:22:35 +00:00
|
|
|
|
2013-03-26 18:24:15 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def XADD8rr : I<0xC0, MRMDestReg, (outs GR8:$dst), (ins GR8:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"xadd{b}\t{$src, $dst|$dst, $src}", [], IIC_XADD_REG>, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def XADD16rr : I<0xC1, MRMDestReg, (outs GR16:$dst), (ins GR16:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"xadd{w}\t{$src, $dst|$dst, $src}", [], IIC_XADD_REG>, TB,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def XADD32rr : I<0xC1, MRMDestReg, (outs GR32:$dst), (ins GR32:$src),
|
2014-01-08 12:57:40 +00:00
|
|
|
"xadd{l}\t{$src, $dst|$dst, $src}", [], IIC_XADD_REG>, TB,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32;
|
2010-10-05 06:22:35 +00:00
|
|
|
def XADD64rr : RI<0xC1, MRMDestReg, (outs GR64:$dst), (ins GR64:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"xadd{q}\t{$src, $dst|$dst, $src}", [], IIC_XADD_REG>, TB;
|
2013-03-26 18:24:15 +00:00
|
|
|
} // SchedRW
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2013-03-26 18:24:15 +00:00
|
|
|
let mayLoad = 1, mayStore = 1, SchedRW = [WriteALULd, WriteRMW] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def XADD8rm : I<0xC0, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"xadd{b}\t{$src, $dst|$dst, $src}", [], IIC_XADD_MEM>, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def XADD16rm : I<0xC1, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"xadd{w}\t{$src, $dst|$dst, $src}", [], IIC_XADD_MEM>, TB,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def XADD32rm : I<0xC1, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
|
2014-01-08 12:57:40 +00:00
|
|
|
"xadd{l}\t{$src, $dst|$dst, $src}", [], IIC_XADD_MEM>, TB,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32;
|
2010-10-05 06:22:35 +00:00
|
|
|
def XADD64rm : RI<0xC1, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"xadd{q}\t{$src, $dst|$dst, $src}", [], IIC_XADD_MEM>, TB;
|
2010-10-05 06:22:35 +00:00
|
|
|
|
2010-05-14 16:34:55 +00:00
|
|
|
}
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2013-03-26 18:24:15 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def CMPXCHG8rr : I<0xB0, MRMDestReg, (outs GR8:$dst), (ins GR8:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"cmpxchg{b}\t{$src, $dst|$dst, $src}", [],
|
|
|
|
IIC_CMPXCHG_REG8>, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def CMPXCHG16rr : I<0xB1, MRMDestReg, (outs GR16:$dst), (ins GR16:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"cmpxchg{w}\t{$src, $dst|$dst, $src}", [],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_CMPXCHG_REG>, TB, OpSize16;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def CMPXCHG32rr : I<0xB1, MRMDestReg, (outs GR32:$dst), (ins GR32:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"cmpxchg{l}\t{$src, $dst|$dst, $src}", [],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_CMPXCHG_REG>, TB, OpSize32;
|
2010-10-05 06:22:35 +00:00
|
|
|
def CMPXCHG64rr : RI<0xB1, MRMDestReg, (outs GR64:$dst), (ins GR64:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"cmpxchg{q}\t{$src, $dst|$dst, $src}", [],
|
|
|
|
IIC_CMPXCHG_REG>, TB;
|
2013-03-26 18:24:15 +00:00
|
|
|
} // SchedRW
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2013-03-26 18:24:15 +00:00
|
|
|
let SchedRW = [WriteALULd, WriteRMW] in {
|
2010-05-14 16:34:55 +00:00
|
|
|
let mayLoad = 1, mayStore = 1 in {
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def CMPXCHG8rm : I<0xB0, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"cmpxchg{b}\t{$src, $dst|$dst, $src}", [],
|
|
|
|
IIC_CMPXCHG_MEM8>, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def CMPXCHG16rm : I<0xB1, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"cmpxchg{w}\t{$src, $dst|$dst, $src}", [],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_CMPXCHG_MEM>, TB, OpSize16;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def CMPXCHG32rm : I<0xB1, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"cmpxchg{l}\t{$src, $dst|$dst, $src}", [],
|
2014-02-02 09:25:09 +00:00
|
|
|
IIC_CMPXCHG_MEM>, TB, OpSize32;
|
2010-10-05 06:22:35 +00:00
|
|
|
def CMPXCHG64rm : RI<0xB1, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"cmpxchg{q}\t{$src, $dst|$dst, $src}", [],
|
|
|
|
IIC_CMPXCHG_MEM>, TB;
|
2010-05-14 16:34:55 +00:00
|
|
|
}
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2010-01-08 01:29:19 +00:00
|
|
|
let Defs = [EAX, EDX, EFLAGS], Uses = [EAX, EBX, ECX, EDX] in
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
def CMPXCHG8B : I<0xC7, MRM1m, (outs), (ins i64mem:$dst),
|
2012-05-10 21:58:35 +00:00
|
|
|
"cmpxchg8b\t$dst", [], IIC_CMPXCHG_8B>, TB;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2010-10-05 06:22:35 +00:00
|
|
|
let Defs = [RAX, RDX, EFLAGS], Uses = [RAX, RBX, RCX, RDX] in
|
|
|
|
def CMPXCHG16B : RI<0xC7, MRM1m, (outs), (ins i128mem:$dst),
|
2012-05-10 21:58:35 +00:00
|
|
|
"cmpxchg16b\t$dst", [], IIC_CMPXCHG_16B>,
|
|
|
|
TB, Requires<[HasCmpxchg16b]>;
|
2013-03-26 18:24:15 +00:00
|
|
|
} // SchedRW
|
2010-10-05 06:22:35 +00:00
|
|
|
|
2008-10-02 18:53:47 +00:00
|
|
|
|
2010-02-03 21:04:42 +00:00
|
|
|
// Lock instruction prefix
|
|
|
|
def LOCK_PREFIX : I<0xF0, RawFrm, (outs), (ins), "lock", []>;
|
|
|
|
|
2010-11-23 11:23:24 +00:00
|
|
|
// Rex64 instruction prefix
|
2014-01-02 19:12:10 +00:00
|
|
|
def REX64_PREFIX : I<0x48, RawFrm, (outs), (ins), "rex64", []>,
|
|
|
|
Requires<[In64BitMode]>;
|
2010-11-23 11:23:24 +00:00
|
|
|
|
2010-11-27 20:29:45 +00:00
|
|
|
// Data16 instruction prefix
|
|
|
|
def DATA16_PREFIX : I<0x66, RawFrm, (outs), (ins), "data16", []>;
|
|
|
|
|
2010-02-03 21:04:42 +00:00
|
|
|
// Repeat string operation instruction prefixes
|
|
|
|
// These uses the DF flag in the EFLAGS register to inc or dec ECX
|
|
|
|
let Defs = [ECX], Uses = [ECX,EFLAGS] in {
|
|
|
|
// Repeat (used with INS, OUTS, MOVS, LODS and STOS)
|
|
|
|
def REP_PREFIX : I<0xF3, RawFrm, (outs), (ins), "rep", []>;
|
|
|
|
// Repeat while not equal (used with CMPS and SCAS)
|
|
|
|
def REPNE_PREFIX : I<0xF2, RawFrm, (outs), (ins), "repne", []>;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-09-16 22:59:28 +00:00
|
|
|
// String manipulation instructions
|
2013-03-26 18:24:15 +00:00
|
|
|
let SchedRW = [WriteMicrocoded] in {
|
2014-02-27 05:08:25 +00:00
|
|
|
// These uses the DF flag in the EFLAGS register to inc or dec EDI and ESI
|
|
|
|
let Defs = [AL,ESI], Uses = [ESI,EFLAGS] in
|
2014-01-22 15:08:08 +00:00
|
|
|
def LODSB : I<0xAC, RawFrmSrc, (outs), (ins srcidx8:$src),
|
|
|
|
"lodsb\t{$src, %al|al, $src}", [], IIC_LODS>;
|
2014-02-27 05:08:25 +00:00
|
|
|
let Defs = [AX,ESI], Uses = [ESI,EFLAGS] in
|
2014-01-22 15:08:08 +00:00
|
|
|
def LODSW : I<0xAD, RawFrmSrc, (outs), (ins srcidx16:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"lodsw\t{$src, %ax|ax, $src}", [], IIC_LODS>, OpSize16;
|
2014-02-27 05:08:25 +00:00
|
|
|
let Defs = [EAX,ESI], Uses = [ESI,EFLAGS] in
|
2014-01-22 15:08:08 +00:00
|
|
|
def LODSL : I<0xAD, RawFrmSrc, (outs), (ins srcidx32:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"lods{l|d}\t{$src, %eax|eax, $src}", [], IIC_LODS>, OpSize32;
|
2014-02-27 05:08:25 +00:00
|
|
|
let Defs = [RAX,ESI], Uses = [ESI,EFLAGS] in
|
2014-01-22 15:08:08 +00:00
|
|
|
def LODSQ : RI<0xAD, RawFrmSrc, (outs), (ins srcidx64:$src),
|
|
|
|
"lodsq\t{$src, %rax|rax, $src}", [], IIC_LODS>;
|
2013-03-26 18:24:15 +00:00
|
|
|
}
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2013-03-26 18:24:15 +00:00
|
|
|
let SchedRW = [WriteSystem] in {
|
2014-02-27 05:08:25 +00:00
|
|
|
// These uses the DF flag in the EFLAGS register to inc or dec EDI and ESI
|
|
|
|
let Defs = [ESI], Uses = [DX,ESI,EFLAGS] in {
|
2014-01-22 15:08:49 +00:00
|
|
|
def OUTSB : I<0x6E, RawFrmSrc, (outs), (ins srcidx8:$src),
|
|
|
|
"outsb\t{$src, %dx|dx, $src}", [], IIC_OUTS>;
|
|
|
|
def OUTSW : I<0x6F, RawFrmSrc, (outs), (ins srcidx16:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"outsw\t{$src, %dx|dx, $src}", [], IIC_OUTS>, OpSize16;
|
2014-01-22 15:08:49 +00:00
|
|
|
def OUTSL : I<0x6F, RawFrmSrc, (outs), (ins srcidx32:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"outs{l|d}\t{$src, %dx|dx, $src}", [], IIC_OUTS>, OpSize32;
|
2013-03-26 18:24:15 +00:00
|
|
|
}
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2014-02-27 05:08:25 +00:00
|
|
|
// These uses the DF flag in the EFLAGS register to inc or dec EDI and ESI
|
|
|
|
let Defs = [EDI], Uses = [DX,EDI,EFLAGS] in {
|
|
|
|
def INSB : I<0x6C, RawFrmDst, (outs dstidx8:$dst), (ins),
|
|
|
|
"insb\t{%dx, $dst|$dst, dx}", [], IIC_INS>;
|
|
|
|
def INSW : I<0x6D, RawFrmDst, (outs dstidx16:$dst), (ins),
|
|
|
|
"insw\t{%dx, $dst|$dst, dx}", [], IIC_INS>, OpSize16;
|
|
|
|
def INSL : I<0x6D, RawFrmDst, (outs dstidx32:$dst), (ins),
|
|
|
|
"ins{l|d}\t{%dx, $dst|$dst, dx}", [], IIC_INS>, OpSize32;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
// Flag instructions
|
2013-03-26 18:24:15 +00:00
|
|
|
let SchedRW = [WriteALU] in {
|
2012-05-10 21:58:35 +00:00
|
|
|
def CLC : I<0xF8, RawFrm, (outs), (ins), "clc", [], IIC_CLC>;
|
|
|
|
def STC : I<0xF9, RawFrm, (outs), (ins), "stc", [], IIC_STC>;
|
|
|
|
def CLI : I<0xFA, RawFrm, (outs), (ins), "cli", [], IIC_CLI>;
|
|
|
|
def STI : I<0xFB, RawFrm, (outs), (ins), "sti", [], IIC_STI>;
|
|
|
|
def CLD : I<0xFC, RawFrm, (outs), (ins), "cld", [], IIC_CLD>;
|
|
|
|
def STD : I<0xFD, RawFrm, (outs), (ins), "std", [], IIC_STD>;
|
|
|
|
def CMC : I<0xF5, RawFrm, (outs), (ins), "cmc", [], IIC_CMC>;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2012-05-10 21:58:35 +00:00
|
|
|
def CLTS : I<0x06, RawFrm, (outs), (ins), "clts", [], IIC_CLTS>, TB;
|
2013-03-26 18:24:15 +00:00
|
|
|
}
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
|
|
|
// Table lookup instructions
|
2013-03-26 18:24:15 +00:00
|
|
|
def XLAT : I<0xD7, RawFrm, (outs), (ins), "xlatb", [], IIC_XLAT>,
|
|
|
|
Sched<[WriteLoad]>;
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@91638 91177308-0d34-0410-b5e6-96231b3b80d8
2009-12-18 00:01:26 +00:00
|
|
|
|
2013-03-21 00:07:17 +00:00
|
|
|
let SchedRW = [WriteMicrocoded] in {
|
2010-10-18 17:04:36 +00:00
|
|
|
// ASCII Adjust After Addition
|
|
|
|
// sets AL, AH and CF and AF of EFLAGS and uses AL and AF of EFLAGS
|
2012-05-10 21:58:35 +00:00
|
|
|
def AAA : I<0x37, RawFrm, (outs), (ins), "aaa", [], IIC_AAA>,
|
2013-12-20 02:04:49 +00:00
|
|
|
Requires<[Not64BitMode]>;
|
2010-10-18 17:04:36 +00:00
|
|
|
|
|
|
|
// ASCII Adjust AX Before Division
|
|
|
|
// sets AL, AH and EFLAGS and uses AL and AH
|
|
|
|
def AAD8i8 : Ii8<0xD5, RawFrm, (outs), (ins i8imm:$src),
|
2013-12-20 02:04:49 +00:00
|
|
|
"aad\t$src", [], IIC_AAD>, Requires<[Not64BitMode]>;
|
2010-10-18 17:04:36 +00:00
|
|
|
|
|
|
|
// ASCII Adjust AX After Multiply
|
|
|
|
// sets AL, AH and EFLAGS and uses AL
|
|
|
|
def AAM8i8 : Ii8<0xD4, RawFrm, (outs), (ins i8imm:$src),
|
2013-12-20 02:04:49 +00:00
|
|
|
"aam\t$src", [], IIC_AAM>, Requires<[Not64BitMode]>;
|
2010-10-18 17:04:36 +00:00
|
|
|
|
2010-10-20 23:40:27 +00:00
|
|
|
// ASCII Adjust AL After Subtraction - sets
|
2010-10-18 17:04:36 +00:00
|
|
|
// sets AL, AH and CF and AF of EFLAGS and uses AL and AF of EFLAGS
|
2012-05-10 21:58:35 +00:00
|
|
|
def AAS : I<0x3F, RawFrm, (outs), (ins), "aas", [], IIC_AAS>,
|
2013-12-20 02:04:49 +00:00
|
|
|
Requires<[Not64BitMode]>;
|
2010-10-18 17:04:36 +00:00
|
|
|
|
|
|
|
// Decimal Adjust AL after Addition
|
|
|
|
// sets AL, CF and AF of EFLAGS and uses AL, CF and AF of EFLAGS
|
2012-05-10 21:58:35 +00:00
|
|
|
def DAA : I<0x27, RawFrm, (outs), (ins), "daa", [], IIC_DAA>,
|
2013-12-20 02:04:49 +00:00
|
|
|
Requires<[Not64BitMode]>;
|
2010-10-18 17:04:36 +00:00
|
|
|
|
|
|
|
// Decimal Adjust AL after Subtraction
|
|
|
|
// sets AL, CF and AF of EFLAGS and uses AL, CF and AF of EFLAGS
|
2012-05-10 21:58:35 +00:00
|
|
|
def DAS : I<0x2F, RawFrm, (outs), (ins), "das", [], IIC_DAS>,
|
2013-12-20 02:04:49 +00:00
|
|
|
Requires<[Not64BitMode]>;
|
2013-03-21 00:07:17 +00:00
|
|
|
} // SchedRW
|
2010-10-18 17:04:36 +00:00
|
|
|
|
2013-03-21 00:07:17 +00:00
|
|
|
let SchedRW = [WriteSystem] in {
|
2010-10-18 17:04:36 +00:00
|
|
|
// Check Array Index Against Bounds
|
|
|
|
def BOUNDS16rm : I<0x62, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"bound\t{$src, $dst|$dst, $src}", [], IIC_BOUND>, OpSize16,
|
2013-12-20 02:04:49 +00:00
|
|
|
Requires<[Not64BitMode]>;
|
2010-10-18 17:04:36 +00:00
|
|
|
def BOUNDS32rm : I<0x62, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
|
2014-02-02 09:25:09 +00:00
|
|
|
"bound\t{$src, $dst|$dst, $src}", [], IIC_BOUND>, OpSize32,
|
2013-12-20 02:04:49 +00:00
|
|
|
Requires<[Not64BitMode]>;
|
2010-10-18 17:04:36 +00:00
|
|
|
|
|
|
|
// Adjust RPL Field of Segment Selector
|
2012-12-26 23:27:57 +00:00
|
|
|
def ARPL16rr : I<0x63, MRMDestReg, (outs GR16:$dst), (ins GR16:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"arpl\t{$src, $dst|$dst, $src}", [], IIC_ARPL_REG>,
|
2013-12-20 02:04:49 +00:00
|
|
|
Requires<[Not64BitMode]>;
|
2012-12-26 23:27:57 +00:00
|
|
|
def ARPL16mr : I<0x63, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
|
2012-05-10 21:58:35 +00:00
|
|
|
"arpl\t{$src, $dst|$dst, $src}", [], IIC_ARPL_MEM>,
|
2013-12-20 02:04:49 +00:00
|
|
|
Requires<[Not64BitMode]>;
|
2013-03-21 00:07:17 +00:00
|
|
|
} // SchedRW
|
2009-09-18 19:59:53 +00:00
|
|
|
|
2011-10-03 17:28:23 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// MOVBE Instructions
|
|
|
|
//
|
|
|
|
let Predicates = [HasMOVBE] in {
|
2013-03-19 18:03:55 +00:00
|
|
|
let SchedRW = [WriteALULd] in {
|
2011-10-03 17:28:23 +00:00
|
|
|
def MOVBE16rm : I<0xF0, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
|
2011-10-10 18:34:56 +00:00
|
|
|
"movbe{w}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR16:$dst, (bswap (loadi16 addr:$src)))], IIC_MOVBE>,
|
2014-02-18 00:21:49 +00:00
|
|
|
OpSize16, T8PS;
|
2011-10-03 17:28:23 +00:00
|
|
|
def MOVBE32rm : I<0xF0, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
|
2011-10-10 18:34:56 +00:00
|
|
|
"movbe{l}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR32:$dst, (bswap (loadi32 addr:$src)))], IIC_MOVBE>,
|
2014-02-18 00:21:49 +00:00
|
|
|
OpSize32, T8PS;
|
2011-10-03 17:28:23 +00:00
|
|
|
def MOVBE64rm : RI<0xF0, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
|
2011-10-10 18:34:56 +00:00
|
|
|
"movbe{q}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(set GR64:$dst, (bswap (loadi64 addr:$src)))], IIC_MOVBE>,
|
2014-02-18 00:21:49 +00:00
|
|
|
T8PS;
|
2013-03-19 18:03:55 +00:00
|
|
|
}
|
|
|
|
let SchedRW = [WriteStore] in {
|
2011-10-03 17:28:23 +00:00
|
|
|
def MOVBE16mr : I<0xF1, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
|
2011-10-10 18:34:56 +00:00
|
|
|
"movbe{w}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(store (bswap GR16:$src), addr:$dst)], IIC_MOVBE>,
|
2014-02-18 00:21:49 +00:00
|
|
|
OpSize16, T8PS;
|
2011-10-03 17:28:23 +00:00
|
|
|
def MOVBE32mr : I<0xF1, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
|
2011-10-10 18:34:56 +00:00
|
|
|
"movbe{l}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(store (bswap GR32:$src), addr:$dst)], IIC_MOVBE>,
|
2014-02-18 00:21:49 +00:00
|
|
|
OpSize32, T8PS;
|
2011-10-03 17:28:23 +00:00
|
|
|
def MOVBE64mr : RI<0xF1, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src),
|
2011-10-10 18:34:56 +00:00
|
|
|
"movbe{q}\t{$src, $dst|$dst, $src}",
|
2012-05-10 21:58:35 +00:00
|
|
|
[(store (bswap GR64:$src), addr:$dst)], IIC_MOVBE>,
|
2014-02-18 00:21:49 +00:00
|
|
|
T8PS;
|
2013-03-19 18:03:55 +00:00
|
|
|
}
|
2011-10-03 17:28:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// RDRAND Instruction
|
|
|
|
//
|
|
|
|
let Predicates = [HasRDRAND], Defs = [EFLAGS] in {
|
|
|
|
def RDRAND16r : I<0xC7, MRM6r, (outs GR16:$dst), (ins),
|
2012-07-12 09:31:43 +00:00
|
|
|
"rdrand{w}\t$dst",
|
2014-02-02 09:25:09 +00:00
|
|
|
[(set GR16:$dst, EFLAGS, (X86rdrand))]>, OpSize16, TB;
|
2011-10-03 17:28:23 +00:00
|
|
|
def RDRAND32r : I<0xC7, MRM6r, (outs GR32:$dst), (ins),
|
2012-07-12 09:31:43 +00:00
|
|
|
"rdrand{l}\t$dst",
|
2014-02-02 09:25:09 +00:00
|
|
|
[(set GR32:$dst, EFLAGS, (X86rdrand))]>, OpSize32, TB;
|
2011-10-03 17:28:23 +00:00
|
|
|
def RDRAND64r : RI<0xC7, MRM6r, (outs GR64:$dst), (ins),
|
2012-07-12 09:31:43 +00:00
|
|
|
"rdrand{q}\t$dst",
|
|
|
|
[(set GR64:$dst, EFLAGS, (X86rdrand))]>, TB;
|
2011-10-03 17:28:23 +00:00
|
|
|
}
|
|
|
|
|
2013-03-28 23:41:26 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// RDSEED Instruction
|
|
|
|
//
|
|
|
|
let Predicates = [HasRDSEED], Defs = [EFLAGS] in {
|
|
|
|
def RDSEED16r : I<0xC7, MRM7r, (outs GR16:$dst), (ins),
|
|
|
|
"rdseed{w}\t$dst",
|
2014-02-02 09:25:09 +00:00
|
|
|
[(set GR16:$dst, EFLAGS, (X86rdseed))]>, OpSize16, TB;
|
2013-03-28 23:41:26 +00:00
|
|
|
def RDSEED32r : I<0xC7, MRM7r, (outs GR32:$dst), (ins),
|
|
|
|
"rdseed{l}\t$dst",
|
2014-02-02 09:25:09 +00:00
|
|
|
[(set GR32:$dst, EFLAGS, (X86rdseed))]>, OpSize32, TB;
|
2013-03-28 23:41:26 +00:00
|
|
|
def RDSEED64r : RI<0xC7, MRM7r, (outs GR64:$dst), (ins),
|
|
|
|
"rdseed{q}\t$dst",
|
|
|
|
[(set GR64:$dst, EFLAGS, (X86rdseed))]>, TB;
|
|
|
|
}
|
|
|
|
|
2011-10-11 06:44:02 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// LZCNT Instruction
|
|
|
|
//
|
|
|
|
let Predicates = [HasLZCNT], Defs = [EFLAGS] in {
|
|
|
|
def LZCNT16rr : I<0xBD, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src),
|
|
|
|
"lzcnt{w}\t{$src, $dst|$dst, $src}",
|
2011-10-13 06:18:52 +00:00
|
|
|
[(set GR16:$dst, (ctlz GR16:$src)), (implicit EFLAGS)]>, XS,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16;
|
2011-10-11 06:44:02 +00:00
|
|
|
def LZCNT16rm : I<0xBD, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
|
|
|
|
"lzcnt{w}\t{$src, $dst|$dst, $src}",
|
2011-10-13 06:18:52 +00:00
|
|
|
[(set GR16:$dst, (ctlz (loadi16 addr:$src))),
|
2014-02-02 09:25:09 +00:00
|
|
|
(implicit EFLAGS)]>, XS, OpSize16;
|
2011-10-11 06:44:02 +00:00
|
|
|
|
|
|
|
def LZCNT32rr : I<0xBD, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src),
|
|
|
|
"lzcnt{l}\t{$src, $dst|$dst, $src}",
|
2014-01-08 12:57:40 +00:00
|
|
|
[(set GR32:$dst, (ctlz GR32:$src)), (implicit EFLAGS)]>, XS,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32;
|
2011-10-11 06:44:02 +00:00
|
|
|
def LZCNT32rm : I<0xBD, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
|
|
|
|
"lzcnt{l}\t{$src, $dst|$dst, $src}",
|
2011-10-13 06:18:52 +00:00
|
|
|
[(set GR32:$dst, (ctlz (loadi32 addr:$src))),
|
2014-02-02 09:25:09 +00:00
|
|
|
(implicit EFLAGS)]>, XS, OpSize32;
|
2011-10-11 06:44:02 +00:00
|
|
|
|
|
|
|
def LZCNT64rr : RI<0xBD, MRMSrcReg, (outs GR64:$dst), (ins GR64:$src),
|
|
|
|
"lzcnt{q}\t{$src, $dst|$dst, $src}",
|
2011-10-13 06:18:52 +00:00
|
|
|
[(set GR64:$dst, (ctlz GR64:$src)), (implicit EFLAGS)]>,
|
|
|
|
XS;
|
2011-10-11 06:44:02 +00:00
|
|
|
def LZCNT64rm : RI<0xBD, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
|
|
|
|
"lzcnt{q}\t{$src, $dst|$dst, $src}",
|
2011-10-13 06:18:52 +00:00
|
|
|
[(set GR64:$dst, (ctlz (loadi64 addr:$src))),
|
|
|
|
(implicit EFLAGS)]>, XS;
|
2011-10-11 06:44:02 +00:00
|
|
|
}
|
|
|
|
|
2014-05-19 20:38:59 +00:00
|
|
|
let Predicates = [HasLZCNT] in {
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (ctlz GR16:$src), (i16 16), (X86_COND_E_OR_NE),
|
2014-12-04 05:20:33 +00:00
|
|
|
(X86cmp GR16:$src, (i16 0))),
|
2014-05-19 20:38:59 +00:00
|
|
|
(LZCNT16rr GR16:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (ctlz GR32:$src), (i32 32), (X86_COND_E_OR_NE),
|
2014-05-19 20:38:59 +00:00
|
|
|
(X86cmp GR32:$src, (i32 0))),
|
|
|
|
(LZCNT32rr GR32:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (ctlz GR64:$src), (i64 64), (X86_COND_E_OR_NE),
|
2014-05-19 20:38:59 +00:00
|
|
|
(X86cmp GR64:$src, (i64 0))),
|
|
|
|
(LZCNT64rr GR64:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (i16 16), (ctlz GR16:$src), (X86_COND_E_OR_NE),
|
2014-05-19 20:38:59 +00:00
|
|
|
(X86cmp GR16:$src, (i16 0))),
|
|
|
|
(LZCNT16rr GR16:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (i32 32), (ctlz GR32:$src), (X86_COND_E_OR_NE),
|
2014-05-19 20:38:59 +00:00
|
|
|
(X86cmp GR32:$src, (i32 0))),
|
|
|
|
(LZCNT32rr GR32:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (i64 64), (ctlz GR64:$src), (X86_COND_E_OR_NE),
|
2014-05-19 20:38:59 +00:00
|
|
|
(X86cmp GR64:$src, (i64 0))),
|
|
|
|
(LZCNT64rr GR64:$src)>;
|
|
|
|
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (ctlz (loadi16 addr:$src)), (i16 16), (X86_COND_E_OR_NE),
|
2014-12-04 05:20:33 +00:00
|
|
|
(X86cmp (loadi16 addr:$src), (i16 0))),
|
2014-05-19 20:38:59 +00:00
|
|
|
(LZCNT16rm addr:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (ctlz (loadi32 addr:$src)), (i32 32), (X86_COND_E_OR_NE),
|
2014-12-04 05:20:33 +00:00
|
|
|
(X86cmp (loadi32 addr:$src), (i32 0))),
|
2014-05-19 20:38:59 +00:00
|
|
|
(LZCNT32rm addr:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (ctlz (loadi64 addr:$src)), (i64 64), (X86_COND_E_OR_NE),
|
2014-12-04 05:20:33 +00:00
|
|
|
(X86cmp (loadi64 addr:$src), (i64 0))),
|
2014-05-19 20:38:59 +00:00
|
|
|
(LZCNT64rm addr:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (i16 16), (ctlz (loadi16 addr:$src)), (X86_COND_E_OR_NE),
|
2014-12-04 05:20:33 +00:00
|
|
|
(X86cmp (loadi16 addr:$src), (i16 0))),
|
2014-05-19 20:38:59 +00:00
|
|
|
(LZCNT16rm addr:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (i32 32), (ctlz (loadi32 addr:$src)), (X86_COND_E_OR_NE),
|
2014-12-04 05:20:33 +00:00
|
|
|
(X86cmp (loadi32 addr:$src), (i32 0))),
|
2014-05-19 20:38:59 +00:00
|
|
|
(LZCNT32rm addr:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (i64 64), (ctlz (loadi64 addr:$src)), (X86_COND_E_OR_NE),
|
2014-12-04 05:20:33 +00:00
|
|
|
(X86cmp (loadi64 addr:$src), (i64 0))),
|
2014-05-19 20:38:59 +00:00
|
|
|
(LZCNT64rm addr:$src)>;
|
|
|
|
}
|
|
|
|
|
2011-10-14 03:21:46 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2011-10-15 20:46:47 +00:00
|
|
|
// BMI Instructions
|
2011-10-14 03:21:46 +00:00
|
|
|
//
|
|
|
|
let Predicates = [HasBMI], Defs = [EFLAGS] in {
|
|
|
|
def TZCNT16rr : I<0xBC, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src),
|
|
|
|
"tzcnt{w}\t{$src, $dst|$dst, $src}",
|
|
|
|
[(set GR16:$dst, (cttz GR16:$src)), (implicit EFLAGS)]>, XS,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize16;
|
2011-10-14 03:21:46 +00:00
|
|
|
def TZCNT16rm : I<0xBC, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
|
|
|
|
"tzcnt{w}\t{$src, $dst|$dst, $src}",
|
|
|
|
[(set GR16:$dst, (cttz (loadi16 addr:$src))),
|
2014-02-02 09:25:09 +00:00
|
|
|
(implicit EFLAGS)]>, XS, OpSize16;
|
2011-10-14 03:21:46 +00:00
|
|
|
|
|
|
|
def TZCNT32rr : I<0xBC, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src),
|
|
|
|
"tzcnt{l}\t{$src, $dst|$dst, $src}",
|
2014-01-08 12:57:40 +00:00
|
|
|
[(set GR32:$dst, (cttz GR32:$src)), (implicit EFLAGS)]>, XS,
|
2014-02-02 09:25:09 +00:00
|
|
|
OpSize32;
|
2011-10-14 03:21:46 +00:00
|
|
|
def TZCNT32rm : I<0xBC, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
|
|
|
|
"tzcnt{l}\t{$src, $dst|$dst, $src}",
|
|
|
|
[(set GR32:$dst, (cttz (loadi32 addr:$src))),
|
2014-02-02 09:25:09 +00:00
|
|
|
(implicit EFLAGS)]>, XS, OpSize32;
|
2011-10-14 03:21:46 +00:00
|
|
|
|
|
|
|
def TZCNT64rr : RI<0xBC, MRMSrcReg, (outs GR64:$dst), (ins GR64:$src),
|
|
|
|
"tzcnt{q}\t{$src, $dst|$dst, $src}",
|
|
|
|
[(set GR64:$dst, (cttz GR64:$src)), (implicit EFLAGS)]>,
|
|
|
|
XS;
|
|
|
|
def TZCNT64rm : RI<0xBC, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
|
|
|
|
"tzcnt{q}\t{$src, $dst|$dst, $src}",
|
|
|
|
[(set GR64:$dst, (cttz (loadi64 addr:$src))),
|
|
|
|
(implicit EFLAGS)]>, XS;
|
|
|
|
}
|
|
|
|
|
2011-10-15 20:46:47 +00:00
|
|
|
multiclass bmi_bls<string mnemonic, Format RegMRM, Format MemMRM,
|
2014-02-05 07:09:40 +00:00
|
|
|
RegisterClass RC, X86MemOperand x86memop> {
|
|
|
|
let hasSideEffects = 0 in {
|
2011-10-15 20:46:47 +00:00
|
|
|
def rr : I<0xF3, RegMRM, (outs RC:$dst), (ins RC:$src),
|
2011-10-19 07:48:35 +00:00
|
|
|
!strconcat(mnemonic, "\t{$src, $dst|$dst, $src}"),
|
2014-02-18 00:21:49 +00:00
|
|
|
[]>, T8PS, VEX_4V;
|
2014-02-05 07:09:40 +00:00
|
|
|
let mayLoad = 1 in
|
2011-10-15 20:46:47 +00:00
|
|
|
def rm : I<0xF3, MemMRM, (outs RC:$dst), (ins x86memop:$src),
|
2011-10-19 07:48:35 +00:00
|
|
|
!strconcat(mnemonic, "\t{$src, $dst|$dst, $src}"),
|
2014-02-18 00:21:49 +00:00
|
|
|
[]>, T8PS, VEX_4V;
|
2014-02-05 07:09:40 +00:00
|
|
|
}
|
2011-10-15 20:46:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
let Predicates = [HasBMI], Defs = [EFLAGS] in {
|
2014-02-05 07:09:40 +00:00
|
|
|
defm BLSR32 : bmi_bls<"blsr{l}", MRM1r, MRM1m, GR32, i32mem>;
|
|
|
|
defm BLSR64 : bmi_bls<"blsr{q}", MRM1r, MRM1m, GR64, i64mem>, VEX_W;
|
|
|
|
defm BLSMSK32 : bmi_bls<"blsmsk{l}", MRM2r, MRM2m, GR32, i32mem>;
|
|
|
|
defm BLSMSK64 : bmi_bls<"blsmsk{q}", MRM2r, MRM2m, GR64, i64mem>, VEX_W;
|
|
|
|
defm BLSI32 : bmi_bls<"blsi{l}", MRM3r, MRM3m, GR32, i32mem>;
|
|
|
|
defm BLSI64 : bmi_bls<"blsi{q}", MRM3r, MRM3m, GR64, i64mem>, VEX_W;
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Pattern fragments to auto generate BMI instructions.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
let Predicates = [HasBMI] in {
|
|
|
|
// FIXME: patterns for the load versions are not implemented
|
|
|
|
def : Pat<(and GR32:$src, (add GR32:$src, -1)),
|
|
|
|
(BLSR32rr GR32:$src)>;
|
|
|
|
def : Pat<(and GR64:$src, (add GR64:$src, -1)),
|
|
|
|
(BLSR64rr GR64:$src)>;
|
|
|
|
|
|
|
|
def : Pat<(xor GR32:$src, (add GR32:$src, -1)),
|
|
|
|
(BLSMSK32rr GR32:$src)>;
|
|
|
|
def : Pat<(xor GR64:$src, (add GR64:$src, -1)),
|
|
|
|
(BLSMSK64rr GR64:$src)>;
|
|
|
|
|
|
|
|
def : Pat<(and GR32:$src, (ineg GR32:$src)),
|
|
|
|
(BLSI32rr GR32:$src)>;
|
|
|
|
def : Pat<(and GR64:$src, (ineg GR64:$src)),
|
|
|
|
(BLSI64rr GR64:$src)>;
|
2011-10-16 03:51:13 +00:00
|
|
|
}
|
|
|
|
|
2014-05-19 20:38:59 +00:00
|
|
|
let Predicates = [HasBMI] in {
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (cttz GR16:$src), (i16 16), (X86_COND_E_OR_NE),
|
2014-05-19 20:38:59 +00:00
|
|
|
(X86cmp GR16:$src, (i16 0))),
|
|
|
|
(TZCNT16rr GR16:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (cttz GR32:$src), (i32 32), (X86_COND_E_OR_NE),
|
2014-05-19 20:38:59 +00:00
|
|
|
(X86cmp GR32:$src, (i32 0))),
|
|
|
|
(TZCNT32rr GR32:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (cttz GR64:$src), (i64 64), (X86_COND_E_OR_NE),
|
2014-05-19 20:38:59 +00:00
|
|
|
(X86cmp GR64:$src, (i64 0))),
|
|
|
|
(TZCNT64rr GR64:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (i16 16), (cttz GR16:$src), (X86_COND_E_OR_NE),
|
2014-05-19 20:38:59 +00:00
|
|
|
(X86cmp GR16:$src, (i16 0))),
|
|
|
|
(TZCNT16rr GR16:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (i32 32), (cttz GR32:$src), (X86_COND_E_OR_NE),
|
2014-05-19 20:38:59 +00:00
|
|
|
(X86cmp GR32:$src, (i32 0))),
|
|
|
|
(TZCNT32rr GR32:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (i64 64), (cttz GR64:$src), (X86_COND_E_OR_NE),
|
2014-05-19 20:38:59 +00:00
|
|
|
(X86cmp GR64:$src, (i64 0))),
|
|
|
|
(TZCNT64rr GR64:$src)>;
|
|
|
|
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (cttz (loadi16 addr:$src)), (i16 16), (X86_COND_E_OR_NE),
|
2014-12-04 05:20:33 +00:00
|
|
|
(X86cmp (loadi16 addr:$src), (i16 0))),
|
2014-05-19 20:38:59 +00:00
|
|
|
(TZCNT16rm addr:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (cttz (loadi32 addr:$src)), (i32 32), (X86_COND_E_OR_NE),
|
2014-12-04 05:20:33 +00:00
|
|
|
(X86cmp (loadi32 addr:$src), (i32 0))),
|
2014-05-19 20:38:59 +00:00
|
|
|
(TZCNT32rm addr:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (cttz (loadi64 addr:$src)), (i64 64), (X86_COND_E_OR_NE),
|
2014-12-04 05:20:33 +00:00
|
|
|
(X86cmp (loadi64 addr:$src), (i64 0))),
|
2014-05-19 20:38:59 +00:00
|
|
|
(TZCNT64rm addr:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (i16 16), (cttz (loadi16 addr:$src)), (X86_COND_E_OR_NE),
|
2014-12-04 05:20:33 +00:00
|
|
|
(X86cmp (loadi16 addr:$src), (i16 0))),
|
2014-05-19 20:38:59 +00:00
|
|
|
(TZCNT16rm addr:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (i32 32), (cttz (loadi32 addr:$src)), (X86_COND_E_OR_NE),
|
2014-12-04 05:20:33 +00:00
|
|
|
(X86cmp (loadi32 addr:$src), (i32 0))),
|
2014-05-19 20:38:59 +00:00
|
|
|
(TZCNT32rm addr:$src)>;
|
2014-12-08 17:47:18 +00:00
|
|
|
def : Pat<(X86cmov (i64 64), (cttz (loadi64 addr:$src)), (X86_COND_E_OR_NE),
|
2014-12-04 05:20:33 +00:00
|
|
|
(X86cmp (loadi64 addr:$src), (i64 0))),
|
2014-05-19 20:38:59 +00:00
|
|
|
(TZCNT64rm addr:$src)>;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-10-16 07:55:05 +00:00
|
|
|
multiclass bmi_bextr_bzhi<bits<8> opc, string mnemonic, RegisterClass RC,
|
2011-10-19 07:48:35 +00:00
|
|
|
X86MemOperand x86memop, Intrinsic Int,
|
|
|
|
PatFrag ld_frag> {
|
2011-10-16 07:55:05 +00:00
|
|
|
def rr : I<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
|
2011-10-16 03:51:13 +00:00
|
|
|
!strconcat(mnemonic, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
|
2011-10-19 07:48:35 +00:00
|
|
|
[(set RC:$dst, (Int RC:$src1, RC:$src2)), (implicit EFLAGS)]>,
|
2014-02-18 00:21:49 +00:00
|
|
|
T8PS, VEX_4VOp3;
|
2011-10-16 07:55:05 +00:00
|
|
|
def rm : I<opc, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src1, RC:$src2),
|
2011-10-16 03:51:13 +00:00
|
|
|
!strconcat(mnemonic, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
|
2011-10-19 07:48:35 +00:00
|
|
|
[(set RC:$dst, (Int (ld_frag addr:$src1), RC:$src2)),
|
2014-02-18 00:21:49 +00:00
|
|
|
(implicit EFLAGS)]>, T8PS, VEX_4VOp3;
|
2011-10-16 03:51:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
let Predicates = [HasBMI], Defs = [EFLAGS] in {
|
2011-10-19 07:48:35 +00:00
|
|
|
defm BEXTR32 : bmi_bextr_bzhi<0xF7, "bextr{l}", GR32, i32mem,
|
|
|
|
int_x86_bmi_bextr_32, loadi32>;
|
|
|
|
defm BEXTR64 : bmi_bextr_bzhi<0xF7, "bextr{q}", GR64, i64mem,
|
|
|
|
int_x86_bmi_bextr_64, loadi64>, VEX_W;
|
2011-10-16 07:55:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
let Predicates = [HasBMI2], Defs = [EFLAGS] in {
|
2011-10-19 07:48:35 +00:00
|
|
|
defm BZHI32 : bmi_bextr_bzhi<0xF5, "bzhi{l}", GR32, i32mem,
|
|
|
|
int_x86_bmi_bzhi_32, loadi32>;
|
|
|
|
defm BZHI64 : bmi_bextr_bzhi<0xF5, "bzhi{q}", GR64, i64mem,
|
|
|
|
int_x86_bmi_bzhi_64, loadi64>, VEX_W;
|
2011-10-15 20:46:47 +00:00
|
|
|
}
|
|
|
|
|
2014-04-22 10:41:56 +00:00
|
|
|
|
|
|
|
def CountTrailingOnes : SDNodeXForm<imm, [{
|
|
|
|
// Count the trailing ones in the immediate.
|
|
|
|
return getI8Imm(CountTrailingOnes_64(N->getZExtValue()));
|
|
|
|
}]>;
|
|
|
|
|
|
|
|
def BZHIMask : ImmLeaf<i64, [{
|
|
|
|
return isMask_64(Imm) && (CountTrailingOnes_64(Imm) > 32);
|
|
|
|
}]>;
|
|
|
|
|
2014-04-22 12:04:53 +00:00
|
|
|
let Predicates = [HasBMI2] in {
|
|
|
|
def : Pat<(and GR64:$src, BZHIMask:$mask),
|
|
|
|
(BZHI64rr GR64:$src,
|
|
|
|
(INSERT_SUBREG (i64 (IMPLICIT_DEF)),
|
|
|
|
(MOV8ri (CountTrailingOnes imm:$mask)), sub_8bit))>;
|
|
|
|
|
|
|
|
def : Pat<(and GR32:$src, (add (shl 1, GR8:$lz), -1)),
|
|
|
|
(BZHI32rr GR32:$src,
|
|
|
|
(INSERT_SUBREG (i32 (IMPLICIT_DEF)), GR8:$lz, sub_8bit))>;
|
|
|
|
|
|
|
|
def : Pat<(and (loadi32 addr:$src), (add (shl 1, GR8:$lz), -1)),
|
|
|
|
(BZHI32rm addr:$src,
|
|
|
|
(INSERT_SUBREG (i32 (IMPLICIT_DEF)), GR8:$lz, sub_8bit))>;
|
|
|
|
|
|
|
|
def : Pat<(and GR64:$src, (add (shl 1, GR8:$lz), -1)),
|
|
|
|
(BZHI64rr GR64:$src,
|
|
|
|
(INSERT_SUBREG (i64 (IMPLICIT_DEF)), GR8:$lz, sub_8bit))>;
|
|
|
|
|
|
|
|
def : Pat<(and (loadi64 addr:$src), (add (shl 1, GR8:$lz), -1)),
|
|
|
|
(BZHI64rm addr:$src,
|
|
|
|
(INSERT_SUBREG (i64 (IMPLICIT_DEF)), GR8:$lz, sub_8bit))>;
|
|
|
|
} // HasBMI2
|
2013-08-30 06:52:21 +00:00
|
|
|
|
2013-10-03 04:16:45 +00:00
|
|
|
let Predicates = [HasBMI] in {
|
|
|
|
def : Pat<(X86bextr GR32:$src1, GR32:$src2),
|
|
|
|
(BEXTR32rr GR32:$src1, GR32:$src2)>;
|
|
|
|
def : Pat<(X86bextr (loadi32 addr:$src1), GR32:$src2),
|
|
|
|
(BEXTR32rm addr:$src1, GR32:$src2)>;
|
|
|
|
def : Pat<(X86bextr GR64:$src1, GR64:$src2),
|
|
|
|
(BEXTR64rr GR64:$src1, GR64:$src2)>;
|
|
|
|
def : Pat<(X86bextr (loadi64 addr:$src1), GR64:$src2),
|
|
|
|
(BEXTR64rm addr:$src1, GR64:$src2)>;
|
|
|
|
} // HasBMI
|
2013-09-02 07:53:17 +00:00
|
|
|
|
2011-10-19 07:48:35 +00:00
|
|
|
multiclass bmi_pdep_pext<string mnemonic, RegisterClass RC,
|
|
|
|
X86MemOperand x86memop, Intrinsic Int,
|
|
|
|
PatFrag ld_frag> {
|
2011-10-16 16:50:08 +00:00
|
|
|
def rr : I<0xF5, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
|
|
|
|
!strconcat(mnemonic, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
|
2011-10-19 07:48:35 +00:00
|
|
|
[(set RC:$dst, (Int RC:$src1, RC:$src2))]>,
|
|
|
|
VEX_4V;
|
2011-10-16 16:50:08 +00:00
|
|
|
def rm : I<0xF5, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
|
|
|
|
!strconcat(mnemonic, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
|
2011-10-19 07:48:35 +00:00
|
|
|
[(set RC:$dst, (Int RC:$src1, (ld_frag addr:$src2)))]>, VEX_4V;
|
2011-10-16 16:50:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
let Predicates = [HasBMI2] in {
|
2011-10-19 07:48:35 +00:00
|
|
|
defm PDEP32 : bmi_pdep_pext<"pdep{l}", GR32, i32mem,
|
|
|
|
int_x86_bmi_pdep_32, loadi32>, T8XD;
|
|
|
|
defm PDEP64 : bmi_pdep_pext<"pdep{q}", GR64, i64mem,
|
|
|
|
int_x86_bmi_pdep_64, loadi64>, T8XD, VEX_W;
|
|
|
|
defm PEXT32 : bmi_pdep_pext<"pext{l}", GR32, i32mem,
|
|
|
|
int_x86_bmi_pext_32, loadi32>, T8XS;
|
|
|
|
defm PEXT64 : bmi_pdep_pext<"pext{q}", GR64, i64mem,
|
|
|
|
int_x86_bmi_pext_64, loadi64>, T8XS, VEX_W;
|
2011-10-16 16:50:08 +00:00
|
|
|
}
|
|
|
|
|
2013-09-27 18:38:42 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// TBM Instructions
|
|
|
|
//
|
2013-10-03 05:17:48 +00:00
|
|
|
let Predicates = [HasTBM], Defs = [EFLAGS] in {
|
2013-09-27 18:38:42 +00:00
|
|
|
|
|
|
|
multiclass tbm_ternary_imm_intr<bits<8> opc, RegisterClass RC, string OpcodeStr,
|
|
|
|
X86MemOperand x86memop, PatFrag ld_frag,
|
2013-10-03 04:16:45 +00:00
|
|
|
Intrinsic Int, Operand immtype,
|
|
|
|
SDPatternOperator immoperator> {
|
|
|
|
def ri : Ii32<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, immtype:$cntl),
|
2013-09-27 18:38:42 +00:00
|
|
|
!strconcat(OpcodeStr,
|
|
|
|
"\t{$cntl, $src1, $dst|$dst, $src1, $cntl}"),
|
2013-10-03 04:16:45 +00:00
|
|
|
[(set RC:$dst, (Int RC:$src1, immoperator:$cntl))]>,
|
2014-02-02 07:08:01 +00:00
|
|
|
XOP, XOPA;
|
2013-10-03 04:16:45 +00:00
|
|
|
def mi : Ii32<opc, MRMSrcMem, (outs RC:$dst),
|
|
|
|
(ins x86memop:$src1, immtype:$cntl),
|
2013-09-27 18:38:42 +00:00
|
|
|
!strconcat(OpcodeStr,
|
|
|
|
"\t{$cntl, $src1, $dst|$dst, $src1, $cntl}"),
|
2013-10-03 04:16:45 +00:00
|
|
|
[(set RC:$dst, (Int (ld_frag addr:$src1), immoperator:$cntl))]>,
|
2014-02-02 07:08:01 +00:00
|
|
|
XOP, XOPA;
|
2013-09-27 18:38:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
defm BEXTRI32 : tbm_ternary_imm_intr<0x10, GR32, "bextr", i32mem, loadi32,
|
2013-10-03 04:16:45 +00:00
|
|
|
int_x86_tbm_bextri_u32, i32imm, imm>;
|
2014-01-30 22:20:41 +00:00
|
|
|
let ImmT = Imm32S in
|
2013-09-27 18:38:42 +00:00
|
|
|
defm BEXTRI64 : tbm_ternary_imm_intr<0x10, GR64, "bextr", i64mem, loadi64,
|
2013-10-03 04:16:45 +00:00
|
|
|
int_x86_tbm_bextri_u64, i64i32imm,
|
|
|
|
i64immSExt32>, VEX_W;
|
2013-09-27 18:38:42 +00:00
|
|
|
|
|
|
|
multiclass tbm_binary_rm<bits<8> opc, Format FormReg, Format FormMem,
|
|
|
|
RegisterClass RC, string OpcodeStr,
|
2013-10-05 19:22:59 +00:00
|
|
|
X86MemOperand x86memop, PatFrag ld_frag> {
|
|
|
|
let hasSideEffects = 0 in {
|
2013-09-27 18:38:42 +00:00
|
|
|
def rr : I<opc, FormReg, (outs RC:$dst), (ins RC:$src),
|
|
|
|
!strconcat(OpcodeStr,"\t{$src, $dst|$dst, $src}"),
|
2014-02-02 07:08:01 +00:00
|
|
|
[]>, XOP_4V, XOP9;
|
2013-10-05 19:22:59 +00:00
|
|
|
let mayLoad = 1 in
|
2013-09-27 18:38:42 +00:00
|
|
|
def rm : I<opc, FormMem, (outs RC:$dst), (ins x86memop:$src),
|
|
|
|
!strconcat(OpcodeStr,"\t{$src, $dst|$dst, $src}"),
|
2014-02-02 07:08:01 +00:00
|
|
|
[]>, XOP_4V, XOP9;
|
2013-10-05 19:22:59 +00:00
|
|
|
}
|
2013-09-27 18:38:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
multiclass tbm_binary_intr<bits<8> opc, string OpcodeStr,
|
2013-10-05 19:22:59 +00:00
|
|
|
Format FormReg, Format FormMem> {
|
2013-10-05 19:27:26 +00:00
|
|
|
defm NAME#32 : tbm_binary_rm<opc, FormReg, FormMem, GR32, OpcodeStr, i32mem,
|
|
|
|
loadi32>;
|
|
|
|
defm NAME#64 : tbm_binary_rm<opc, FormReg, FormMem, GR64, OpcodeStr, i64mem,
|
|
|
|
loadi64>, VEX_W;
|
2013-10-05 19:22:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
defm BLCFILL : tbm_binary_intr<0x01, "blcfill", MRM1r, MRM1m>;
|
|
|
|
defm BLCI : tbm_binary_intr<0x02, "blci", MRM6r, MRM6m>;
|
|
|
|
defm BLCIC : tbm_binary_intr<0x01, "blcic", MRM5r, MRM5m>;
|
|
|
|
defm BLCMSK : tbm_binary_intr<0x02, "blcmsk", MRM1r, MRM1m>;
|
|
|
|
defm BLCS : tbm_binary_intr<0x01, "blcs", MRM3r, MRM3m>;
|
|
|
|
defm BLSFILL : tbm_binary_intr<0x01, "blsfill", MRM2r, MRM2m>;
|
|
|
|
defm BLSIC : tbm_binary_intr<0x01, "blsic", MRM6r, MRM6m>;
|
|
|
|
defm T1MSKC : tbm_binary_intr<0x01, "t1mskc", MRM7r, MRM7m>;
|
|
|
|
defm TZMSK : tbm_binary_intr<0x01, "tzmsk", MRM4r, MRM4m>;
|
2013-10-03 05:17:48 +00:00
|
|
|
} // HasTBM, EFLAGS
|
2013-09-27 18:38:42 +00:00
|
|
|
|
2013-10-03 04:16:45 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Pattern fragments to auto generate TBM instructions.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
let Predicates = [HasTBM] in {
|
|
|
|
def : Pat<(X86bextr GR32:$src1, (i32 imm:$src2)),
|
|
|
|
(BEXTRI32ri GR32:$src1, imm:$src2)>;
|
|
|
|
def : Pat<(X86bextr (loadi32 addr:$src1), (i32 imm:$src2)),
|
|
|
|
(BEXTRI32mi addr:$src1, imm:$src2)>;
|
|
|
|
def : Pat<(X86bextr GR64:$src1, i64immSExt32:$src2),
|
|
|
|
(BEXTRI64ri GR64:$src1, i64immSExt32:$src2)>;
|
|
|
|
def : Pat<(X86bextr (loadi64 addr:$src1), i64immSExt32:$src2),
|
|
|
|
(BEXTRI64mi addr:$src1, i64immSExt32:$src2)>;
|
|
|
|
|
|
|
|
// FIXME: patterns for the load versions are not implemented
|
|
|
|
def : Pat<(and GR32:$src, (add GR32:$src, 1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLCFILL32rr GR32:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
def : Pat<(and GR64:$src, (add GR64:$src, 1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLCFILL64rr GR64:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
|
|
|
|
def : Pat<(or GR32:$src, (not (add GR32:$src, 1))),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLCI32rr GR32:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
def : Pat<(or GR64:$src, (not (add GR64:$src, 1))),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLCI64rr GR64:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
|
2013-10-05 17:17:53 +00:00
|
|
|
// Extra patterns because opt can optimize the above patterns to this.
|
|
|
|
def : Pat<(or GR32:$src, (sub -2, GR32:$src)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLCI32rr GR32:$src)>;
|
2013-10-05 17:17:53 +00:00
|
|
|
def : Pat<(or GR64:$src, (sub -2, GR64:$src)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLCI64rr GR64:$src)>;
|
2013-10-05 17:17:53 +00:00
|
|
|
|
2013-10-03 04:16:45 +00:00
|
|
|
def : Pat<(and (not GR32:$src), (add GR32:$src, 1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLCIC32rr GR32:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
def : Pat<(and (not GR64:$src), (add GR64:$src, 1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLCIC64rr GR64:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
|
|
|
|
def : Pat<(xor GR32:$src, (add GR32:$src, 1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLCMSK32rr GR32:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
def : Pat<(xor GR64:$src, (add GR64:$src, 1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLCMSK64rr GR64:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
|
|
|
|
def : Pat<(or GR32:$src, (add GR32:$src, 1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLCS32rr GR32:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
def : Pat<(or GR64:$src, (add GR64:$src, 1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLCS64rr GR64:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
|
|
|
|
def : Pat<(or GR32:$src, (add GR32:$src, -1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLSFILL32rr GR32:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
def : Pat<(or GR64:$src, (add GR64:$src, -1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLSFILL64rr GR64:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
|
|
|
|
def : Pat<(or (not GR32:$src), (add GR32:$src, -1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLSIC32rr GR32:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
def : Pat<(or (not GR64:$src), (add GR64:$src, -1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(BLSIC64rr GR64:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
|
|
|
|
def : Pat<(or (not GR32:$src), (add GR32:$src, 1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(T1MSKC32rr GR32:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
def : Pat<(or (not GR64:$src), (add GR64:$src, 1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(T1MSKC64rr GR64:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
|
|
|
|
def : Pat<(and (not GR32:$src), (add GR32:$src, -1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(TZMSK32rr GR32:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
def : Pat<(and (not GR64:$src), (add GR64:$src, -1)),
|
2013-10-05 19:27:26 +00:00
|
|
|
(TZMSK64rr GR64:$src)>;
|
2013-10-03 04:16:45 +00:00
|
|
|
} // HasTBM
|
|
|
|
|
2006-02-21 20:00:20 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2010-10-05 05:32:15 +00:00
|
|
|
// Subsystems.
|
2006-02-21 20:00:20 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-10-05 16:39:12 +00:00
|
|
|
include "X86InstrArithmetic.td"
|
2010-10-05 06:33:16 +00:00
|
|
|
include "X86InstrCMovSetCC.td"
|
2010-10-05 06:52:26 +00:00
|
|
|
include "X86InstrExtension.td"
|
2010-10-05 06:04:14 +00:00
|
|
|
include "X86InstrControl.td"
|
2010-10-05 07:00:12 +00:00
|
|
|
include "X86InstrShiftRotate.td"
|
2010-10-05 06:04:14 +00:00
|
|
|
|
2010-10-05 16:39:12 +00:00
|
|
|
// X87 Floating Point Stack.
|
|
|
|
include "X86InstrFPStack.td"
|
|
|
|
|
2010-02-09 23:52:19 +00:00
|
|
|
// SIMD support (SSE, MMX and AVX)
|
|
|
|
include "X86InstrFragmentsSIMD.td"
|
|
|
|
|
2010-07-23 00:54:35 +00:00
|
|
|
// FMA - Fused Multiply-Add support (requires FMA)
|
|
|
|
include "X86InstrFMA.td"
|
|
|
|
|
2011-12-12 19:37:49 +00:00
|
|
|
// XOP
|
|
|
|
include "X86InstrXOP.td"
|
|
|
|
|
2010-10-05 05:32:15 +00:00
|
|
|
// SSE, MMX and 3DNow! vector support.
|
2008-04-25 18:19:54 +00:00
|
|
|
include "X86InstrSSE.td"
|
2013-07-31 11:35:14 +00:00
|
|
|
include "X86InstrAVX512.td"
|
2008-04-25 18:19:54 +00:00
|
|
|
include "X86InstrMMX.td"
|
2010-10-02 23:06:23 +00:00
|
|
|
include "X86Instr3DNow.td"
|
|
|
|
|
2010-10-05 06:06:53 +00:00
|
|
|
include "X86InstrVMX.td"
|
2012-02-18 08:19:49 +00:00
|
|
|
include "X86InstrSVM.td"
|
2010-10-05 06:06:53 +00:00
|
|
|
|
2012-11-08 07:28:54 +00:00
|
|
|
include "X86InstrTSX.td"
|
2014-07-31 23:57:38 +00:00
|
|
|
include "X86InstrSGX.td"
|
2012-11-08 07:28:54 +00:00
|
|
|
|
2010-10-05 05:32:15 +00:00
|
|
|
// System instructions.
|
|
|
|
include "X86InstrSystem.td"
|
2010-10-05 06:04:14 +00:00
|
|
|
|
|
|
|
// Compiler Pseudo Instructions and Pat Patterns
|
|
|
|
include "X86InstrCompiler.td"
|
|
|
|
|
2010-10-30 17:36:36 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2010-11-01 23:07:52 +00:00
|
|
|
// Assembler Mnemonic Aliases
|
2010-10-30 17:36:36 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-01-08 12:57:49 +00:00
|
|
|
def : MnemonicAlias<"call", "callw", "att">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"call", "calll", "att">, Requires<[In32BitMode]>;
|
2013-04-18 22:35:36 +00:00
|
|
|
def : MnemonicAlias<"call", "callq", "att">, Requires<[In64BitMode]>;
|
2010-11-01 21:06:34 +00:00
|
|
|
|
2013-04-18 22:35:36 +00:00
|
|
|
def : MnemonicAlias<"cbw", "cbtw", "att">;
|
|
|
|
def : MnemonicAlias<"cwde", "cwtl", "att">;
|
|
|
|
def : MnemonicAlias<"cwd", "cwtd", "att">;
|
|
|
|
def : MnemonicAlias<"cdq", "cltd", "att">;
|
|
|
|
def : MnemonicAlias<"cdqe", "cltq", "att">;
|
|
|
|
def : MnemonicAlias<"cqo", "cqto", "att">;
|
2010-10-30 18:07:17 +00:00
|
|
|
|
2014-01-13 14:05:59 +00:00
|
|
|
// In 64-bit mode lret maps to lretl; it is not ambiguous with lretq.
|
2014-01-08 12:58:07 +00:00
|
|
|
def : MnemonicAlias<"lret", "lretw", "att">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"lret", "lretl", "att">, Requires<[Not16BitMode]>;
|
2010-11-12 18:54:56 +00:00
|
|
|
|
2013-12-20 02:04:49 +00:00
|
|
|
def : MnemonicAlias<"leavel", "leave", "att">, Requires<[Not64BitMode]>;
|
2013-04-18 22:35:36 +00:00
|
|
|
def : MnemonicAlias<"leaveq", "leave", "att">, Requires<[In64BitMode]>;
|
2011-02-17 23:36:39 +00:00
|
|
|
|
2013-04-18 22:35:36 +00:00
|
|
|
def : MnemonicAlias<"loopz", "loope", "att">;
|
|
|
|
def : MnemonicAlias<"loopnz", "loopne", "att">;
|
2011-02-22 00:43:07 +00:00
|
|
|
|
2014-01-08 12:57:45 +00:00
|
|
|
def : MnemonicAlias<"pop", "popw", "att">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"pop", "popl", "att">, Requires<[In32BitMode]>;
|
2013-04-18 22:35:36 +00:00
|
|
|
def : MnemonicAlias<"pop", "popq", "att">, Requires<[In64BitMode]>;
|
2014-01-08 12:57:45 +00:00
|
|
|
def : MnemonicAlias<"popf", "popfw", "att">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"popf", "popfl", "att">, Requires<[In32BitMode]>;
|
2013-04-18 22:35:36 +00:00
|
|
|
def : MnemonicAlias<"popf", "popfq", "att">, Requires<[In64BitMode]>;
|
|
|
|
def : MnemonicAlias<"popfd", "popfl", "att">;
|
2010-10-30 18:07:17 +00:00
|
|
|
|
2010-10-31 18:43:46 +00:00
|
|
|
// FIXME: This is wrong for "push reg". "push %bx" should turn into pushw in
|
|
|
|
// all modes. However: "push (addr)" and "push $42" should default to
|
|
|
|
// pushl/pushq depending on the current mode. Similar for "pop %bx"
|
2014-01-08 12:57:45 +00:00
|
|
|
def : MnemonicAlias<"push", "pushw", "att">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"push", "pushl", "att">, Requires<[In32BitMode]>;
|
2013-04-18 22:35:36 +00:00
|
|
|
def : MnemonicAlias<"push", "pushq", "att">, Requires<[In64BitMode]>;
|
2014-01-08 12:57:45 +00:00
|
|
|
def : MnemonicAlias<"pushf", "pushfw", "att">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"pushf", "pushfl", "att">, Requires<[In32BitMode]>;
|
2013-04-18 22:35:36 +00:00
|
|
|
def : MnemonicAlias<"pushf", "pushfq", "att">, Requires<[In64BitMode]>;
|
|
|
|
def : MnemonicAlias<"pushfd", "pushfl", "att">;
|
2010-10-30 19:23:13 +00:00
|
|
|
|
2014-01-08 12:57:45 +00:00
|
|
|
def : MnemonicAlias<"popad", "popal", "intel">, Requires<[Not64BitMode]>;
|
|
|
|
def : MnemonicAlias<"pushad", "pushal", "intel">, Requires<[Not64BitMode]>;
|
|
|
|
def : MnemonicAlias<"popa", "popaw", "intel">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"pusha", "pushaw", "intel">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"popa", "popal", "intel">, Requires<[In32BitMode]>;
|
|
|
|
def : MnemonicAlias<"pusha", "pushal", "intel">, Requires<[In32BitMode]>;
|
|
|
|
|
|
|
|
def : MnemonicAlias<"popa", "popaw", "att">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"pusha", "pushaw", "att">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"popa", "popal", "att">, Requires<[In32BitMode]>;
|
|
|
|
def : MnemonicAlias<"pusha", "pushal", "att">, Requires<[In32BitMode]>;
|
2013-05-10 18:24:17 +00:00
|
|
|
|
2013-04-18 22:35:36 +00:00
|
|
|
def : MnemonicAlias<"repe", "rep", "att">;
|
|
|
|
def : MnemonicAlias<"repz", "rep", "att">;
|
|
|
|
def : MnemonicAlias<"repnz", "repne", "att">;
|
2010-10-30 18:17:33 +00:00
|
|
|
|
2014-01-08 12:58:07 +00:00
|
|
|
def : MnemonicAlias<"ret", "retw", "att">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"ret", "retl", "att">, Requires<[In32BitMode]>;
|
|
|
|
def : MnemonicAlias<"ret", "retq", "att">, Requires<[In64BitMode]>;
|
2010-10-30 19:23:13 +00:00
|
|
|
|
2013-04-18 22:35:36 +00:00
|
|
|
def : MnemonicAlias<"salb", "shlb", "att">;
|
|
|
|
def : MnemonicAlias<"salw", "shlw", "att">;
|
|
|
|
def : MnemonicAlias<"sall", "shll", "att">;
|
|
|
|
def : MnemonicAlias<"salq", "shlq", "att">;
|
2010-10-30 18:14:54 +00:00
|
|
|
|
2013-04-18 22:35:36 +00:00
|
|
|
def : MnemonicAlias<"smovb", "movsb", "att">;
|
|
|
|
def : MnemonicAlias<"smovw", "movsw", "att">;
|
|
|
|
def : MnemonicAlias<"smovl", "movsl", "att">;
|
|
|
|
def : MnemonicAlias<"smovq", "movsq", "att">;
|
2010-10-30 17:36:36 +00:00
|
|
|
|
2013-04-18 22:35:36 +00:00
|
|
|
def : MnemonicAlias<"ud2a", "ud2", "att">;
|
|
|
|
def : MnemonicAlias<"verrw", "verr", "att">;
|
2010-10-30 17:36:36 +00:00
|
|
|
|
2010-11-01 21:06:34 +00:00
|
|
|
// System instruction aliases.
|
2014-01-08 12:58:07 +00:00
|
|
|
def : MnemonicAlias<"iret", "iretw", "att">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"iret", "iretl", "att">, Requires<[Not16BitMode]>;
|
2013-04-18 22:35:36 +00:00
|
|
|
def : MnemonicAlias<"sysret", "sysretl", "att">;
|
|
|
|
def : MnemonicAlias<"sysexit", "sysexitl", "att">;
|
2010-11-01 21:06:34 +00:00
|
|
|
|
2014-01-08 12:57:55 +00:00
|
|
|
def : MnemonicAlias<"lgdt", "lgdtw", "att">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"lgdt", "lgdtl", "att">, Requires<[In32BitMode]>;
|
|
|
|
def : MnemonicAlias<"lgdt", "lgdtq", "att">, Requires<[In64BitMode]>;
|
|
|
|
def : MnemonicAlias<"lidt", "lidtw", "att">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"lidt", "lidtl", "att">, Requires<[In32BitMode]>;
|
|
|
|
def : MnemonicAlias<"lidt", "lidtq", "att">, Requires<[In64BitMode]>;
|
|
|
|
def : MnemonicAlias<"sgdt", "sgdtw", "att">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"sgdt", "sgdtl", "att">, Requires<[In32BitMode]>;
|
|
|
|
def : MnemonicAlias<"sgdt", "sgdtq", "att">, Requires<[In64BitMode]>;
|
|
|
|
def : MnemonicAlias<"sidt", "sidtw", "att">, Requires<[In16BitMode]>;
|
|
|
|
def : MnemonicAlias<"sidt", "sidtl", "att">, Requires<[In32BitMode]>;
|
|
|
|
def : MnemonicAlias<"sidt", "sidtq", "att">, Requires<[In64BitMode]>;
|
2010-11-01 21:06:34 +00:00
|
|
|
|
2010-10-30 17:36:36 +00:00
|
|
|
|
2010-10-30 18:07:17 +00:00
|
|
|
// Floating point stack aliases.
|
2013-04-18 22:35:36 +00:00
|
|
|
def : MnemonicAlias<"fcmovz", "fcmove", "att">;
|
|
|
|
def : MnemonicAlias<"fcmova", "fcmovnbe", "att">;
|
|
|
|
def : MnemonicAlias<"fcmovnae", "fcmovb", "att">;
|
|
|
|
def : MnemonicAlias<"fcmovna", "fcmovbe", "att">;
|
|
|
|
def : MnemonicAlias<"fcmovae", "fcmovnb", "att">;
|
|
|
|
def : MnemonicAlias<"fcomip", "fcompi", "att">;
|
|
|
|
def : MnemonicAlias<"fildq", "fildll", "att">;
|
|
|
|
def : MnemonicAlias<"fistpq", "fistpll", "att">;
|
|
|
|
def : MnemonicAlias<"fisttpq", "fisttpll", "att">;
|
|
|
|
def : MnemonicAlias<"fldcww", "fldcw", "att">;
|
|
|
|
def : MnemonicAlias<"fnstcww", "fnstcw", "att">;
|
|
|
|
def : MnemonicAlias<"fnstsww", "fnstsw", "att">;
|
|
|
|
def : MnemonicAlias<"fucomip", "fucompi", "att">;
|
2014-10-14 21:41:17 +00:00
|
|
|
def : MnemonicAlias<"fwait", "wait">;
|
2010-10-30 18:07:17 +00:00
|
|
|
|
|
|
|
|
2013-06-13 15:45:24 +00:00
|
|
|
class CondCodeAlias<string Prefix,string Suffix, string OldCond, string NewCond,
|
|
|
|
string VariantName>
|
2010-10-30 17:56:50 +00:00
|
|
|
: MnemonicAlias<!strconcat(Prefix, OldCond, Suffix),
|
2013-06-13 15:45:24 +00:00
|
|
|
!strconcat(Prefix, NewCond, Suffix), VariantName>;
|
2010-10-30 17:51:45 +00:00
|
|
|
|
|
|
|
/// IntegerCondCodeMnemonicAlias - This multiclass defines a bunch of
|
|
|
|
/// MnemonicAlias's that canonicalize the condition code in a mnemonic, for
|
|
|
|
/// example "setz" -> "sete".
|
2013-06-13 15:45:24 +00:00
|
|
|
multiclass IntegerCondCodeMnemonicAlias<string Prefix, string Suffix,
|
|
|
|
string V = ""> {
|
|
|
|
def C : CondCodeAlias<Prefix, Suffix, "c", "b", V>; // setc -> setb
|
|
|
|
def Z : CondCodeAlias<Prefix, Suffix, "z" , "e", V>; // setz -> sete
|
|
|
|
def NA : CondCodeAlias<Prefix, Suffix, "na", "be", V>; // setna -> setbe
|
|
|
|
def NB : CondCodeAlias<Prefix, Suffix, "nb", "ae", V>; // setnb -> setae
|
|
|
|
def NC : CondCodeAlias<Prefix, Suffix, "nc", "ae", V>; // setnc -> setae
|
|
|
|
def NG : CondCodeAlias<Prefix, Suffix, "ng", "le", V>; // setng -> setle
|
|
|
|
def NL : CondCodeAlias<Prefix, Suffix, "nl", "ge", V>; // setnl -> setge
|
|
|
|
def NZ : CondCodeAlias<Prefix, Suffix, "nz", "ne", V>; // setnz -> setne
|
|
|
|
def PE : CondCodeAlias<Prefix, Suffix, "pe", "p", V>; // setpe -> setp
|
|
|
|
def PO : CondCodeAlias<Prefix, Suffix, "po", "np", V>; // setpo -> setnp
|
|
|
|
|
|
|
|
def NAE : CondCodeAlias<Prefix, Suffix, "nae", "b", V>; // setnae -> setb
|
|
|
|
def NBE : CondCodeAlias<Prefix, Suffix, "nbe", "a", V>; // setnbe -> seta
|
|
|
|
def NGE : CondCodeAlias<Prefix, Suffix, "nge", "l", V>; // setnge -> setl
|
|
|
|
def NLE : CondCodeAlias<Prefix, Suffix, "nle", "g", V>; // setnle -> setg
|
2010-10-30 17:51:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Aliases for set<CC>
|
2010-10-30 17:56:50 +00:00
|
|
|
defm : IntegerCondCodeMnemonicAlias<"set", "">;
|
2010-10-30 17:51:45 +00:00
|
|
|
// Aliases for j<CC>
|
2010-10-30 17:56:50 +00:00
|
|
|
defm : IntegerCondCodeMnemonicAlias<"j", "">;
|
|
|
|
// Aliases for cmov<CC>{w,l,q}
|
2013-06-13 15:45:24 +00:00
|
|
|
defm : IntegerCondCodeMnemonicAlias<"cmov", "w", "att">;
|
|
|
|
defm : IntegerCondCodeMnemonicAlias<"cmov", "l", "att">;
|
|
|
|
defm : IntegerCondCodeMnemonicAlias<"cmov", "q", "att">;
|
|
|
|
// No size suffix for intel-style asm.
|
|
|
|
defm : IntegerCondCodeMnemonicAlias<"cmov", "", "intel">;
|
2010-10-30 17:36:36 +00:00
|
|
|
|
2010-11-01 23:07:52 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Assembler Instruction Aliases
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-11-06 19:25:43 +00:00
|
|
|
// aad/aam default to base 10 if no operand is specified.
|
|
|
|
def : InstAlias<"aad", (AAD8i8 10)>;
|
|
|
|
def : InstAlias<"aam", (AAM8i8 10)>;
|
|
|
|
|
2011-02-19 21:06:36 +00:00
|
|
|
// Disambiguate the mem/imm form of bt-without-a-suffix as btl.
|
2013-07-23 00:56:15 +00:00
|
|
|
// Likewise for btc/btr/bts.
|
2013-07-22 07:47:51 +00:00
|
|
|
def : InstAlias<"bt {$imm, $mem|$mem, $imm}",
|
|
|
|
(BT32mi8 i32mem:$mem, i32i8imm:$imm), 0>;
|
2013-07-23 00:56:15 +00:00
|
|
|
def : InstAlias<"btc {$imm, $mem|$mem, $imm}",
|
|
|
|
(BTC32mi8 i32mem:$mem, i32i8imm:$imm), 0>;
|
|
|
|
def : InstAlias<"btr {$imm, $mem|$mem, $imm}",
|
|
|
|
(BTR32mi8 i32mem:$mem, i32i8imm:$imm), 0>;
|
|
|
|
def : InstAlias<"bts {$imm, $mem|$mem, $imm}",
|
|
|
|
(BTS32mi8 i32mem:$mem, i32i8imm:$imm), 0>;
|
2011-02-19 21:06:36 +00:00
|
|
|
|
2010-11-06 07:31:43 +00:00
|
|
|
// clr aliases.
|
2013-07-23 00:15:19 +00:00
|
|
|
def : InstAlias<"clrb $reg", (XOR8rr GR8 :$reg, GR8 :$reg), 0>;
|
|
|
|
def : InstAlias<"clrw $reg", (XOR16rr GR16:$reg, GR16:$reg), 0>;
|
|
|
|
def : InstAlias<"clrl $reg", (XOR32rr GR32:$reg, GR32:$reg), 0>;
|
|
|
|
def : InstAlias<"clrq $reg", (XOR64rr GR64:$reg, GR64:$reg), 0>;
|
2010-11-06 07:31:43 +00:00
|
|
|
|
2014-01-22 15:08:08 +00:00
|
|
|
// lods aliases. Accept the destination being omitted because it's implicit
|
|
|
|
// in the mnemonic, or the mnemonic suffix being omitted because it's implicit
|
|
|
|
// in the destination.
|
|
|
|
def : InstAlias<"lodsb $src", (LODSB srcidx8:$src), 0>;
|
|
|
|
def : InstAlias<"lodsw $src", (LODSW srcidx16:$src), 0>;
|
|
|
|
def : InstAlias<"lods{l|d} $src", (LODSL srcidx32:$src), 0>;
|
|
|
|
def : InstAlias<"lodsq $src", (LODSQ srcidx64:$src), 0>, Requires<[In64BitMode]>;
|
|
|
|
def : InstAlias<"lods {$src, %al|al, $src}", (LODSB srcidx8:$src), 0>;
|
|
|
|
def : InstAlias<"lods {$src, %ax|ax, $src}", (LODSW srcidx16:$src), 0>;
|
|
|
|
def : InstAlias<"lods {$src, %eax|eax, $src}", (LODSL srcidx32:$src), 0>;
|
|
|
|
def : InstAlias<"lods {$src, %rax|rax, $src}", (LODSQ srcidx64:$src), 0>, Requires<[In64BitMode]>;
|
|
|
|
|
2014-01-22 15:08:21 +00:00
|
|
|
// stos aliases. Accept the source being omitted because it's implicit in
|
|
|
|
// the mnemonic, or the mnemonic suffix being omitted because it's implicit
|
|
|
|
// in the source.
|
|
|
|
def : InstAlias<"stosb $dst", (STOSB dstidx8:$dst), 0>;
|
|
|
|
def : InstAlias<"stosw $dst", (STOSW dstidx16:$dst), 0>;
|
|
|
|
def : InstAlias<"stos{l|d} $dst", (STOSL dstidx32:$dst), 0>;
|
|
|
|
def : InstAlias<"stosq $dst", (STOSQ dstidx64:$dst), 0>, Requires<[In64BitMode]>;
|
|
|
|
def : InstAlias<"stos {%al, $dst|$dst, al}", (STOSB dstidx8:$dst), 0>;
|
|
|
|
def : InstAlias<"stos {%ax, $dst|$dst, ax}", (STOSW dstidx16:$dst), 0>;
|
|
|
|
def : InstAlias<"stos {%eax, $dst|$dst, eax}", (STOSL dstidx32:$dst), 0>;
|
|
|
|
def : InstAlias<"stos {%rax, $dst|$dst, rax}", (STOSQ dstidx64:$dst), 0>, Requires<[In64BitMode]>;
|
|
|
|
|
2014-01-22 15:08:27 +00:00
|
|
|
// scas aliases. Accept the destination being omitted because it's implicit
|
|
|
|
// in the mnemonic, or the mnemonic suffix being omitted because it's implicit
|
|
|
|
// in the destination.
|
2014-02-27 05:08:25 +00:00
|
|
|
def : InstAlias<"scasb $dst", (SCASB dstidx8:$dst), 0>;
|
|
|
|
def : InstAlias<"scasw $dst", (SCASW dstidx16:$dst), 0>;
|
|
|
|
def : InstAlias<"scas{l|d} $dst", (SCASL dstidx32:$dst), 0>;
|
|
|
|
def : InstAlias<"scasq $dst", (SCASQ dstidx64:$dst), 0>, Requires<[In64BitMode]>;
|
|
|
|
def : InstAlias<"scas {$dst, %al|al, $dst}", (SCASB dstidx8:$dst), 0>;
|
|
|
|
def : InstAlias<"scas {$dst, %ax|ax, $dst}", (SCASW dstidx16:$dst), 0>;
|
|
|
|
def : InstAlias<"scas {$dst, %eax|eax, $dst}", (SCASL dstidx32:$dst), 0>;
|
|
|
|
def : InstAlias<"scas {$dst, %rax|rax, $dst}", (SCASQ dstidx64:$dst), 0>, Requires<[In64BitMode]>;
|
2014-01-22 15:08:27 +00:00
|
|
|
|
2010-11-06 22:41:18 +00:00
|
|
|
// div and idiv aliases for explicit A register.
|
2013-07-31 02:47:52 +00:00
|
|
|
def : InstAlias<"div{b}\t{$src, %al|al, $src}", (DIV8r GR8 :$src)>;
|
|
|
|
def : InstAlias<"div{w}\t{$src, %ax|ax, $src}", (DIV16r GR16:$src)>;
|
|
|
|
def : InstAlias<"div{l}\t{$src, %eax|eax, $src}", (DIV32r GR32:$src)>;
|
|
|
|
def : InstAlias<"div{q}\t{$src, %rax|rax, $src}", (DIV64r GR64:$src)>;
|
|
|
|
def : InstAlias<"div{b}\t{$src, %al|al, $src}", (DIV8m i8mem :$src)>;
|
|
|
|
def : InstAlias<"div{w}\t{$src, %ax|ax, $src}", (DIV16m i16mem:$src)>;
|
|
|
|
def : InstAlias<"div{l}\t{$src, %eax|eax, $src}", (DIV32m i32mem:$src)>;
|
|
|
|
def : InstAlias<"div{q}\t{$src, %rax|rax, $src}", (DIV64m i64mem:$src)>;
|
|
|
|
def : InstAlias<"idiv{b}\t{$src, %al|al, $src}", (IDIV8r GR8 :$src)>;
|
|
|
|
def : InstAlias<"idiv{w}\t{$src, %ax|ax, $src}", (IDIV16r GR16:$src)>;
|
|
|
|
def : InstAlias<"idiv{l}\t{$src, %eax|eax, $src}", (IDIV32r GR32:$src)>;
|
|
|
|
def : InstAlias<"idiv{q}\t{$src, %rax|rax, $src}", (IDIV64r GR64:$src)>;
|
|
|
|
def : InstAlias<"idiv{b}\t{$src, %al|al, $src}", (IDIV8m i8mem :$src)>;
|
|
|
|
def : InstAlias<"idiv{w}\t{$src, %ax|ax, $src}", (IDIV16m i16mem:$src)>;
|
|
|
|
def : InstAlias<"idiv{l}\t{$src, %eax|eax, $src}", (IDIV32m i32mem:$src)>;
|
|
|
|
def : InstAlias<"idiv{q}\t{$src, %rax|rax, $src}", (IDIV64m i64mem:$src)>;
|
2010-11-06 22:41:18 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
2010-11-06 20:47:38 +00:00
|
|
|
// Various unary fpstack operations default to operating on on ST1.
|
|
|
|
// For example, "fxch" -> "fxch %st(1)"
|
2011-04-14 01:11:51 +00:00
|
|
|
def : InstAlias<"faddp", (ADD_FPrST0 ST1), 0>;
|
2013-07-26 05:37:46 +00:00
|
|
|
def : InstAlias<"fsub{|r}p", (SUBR_FPrST0 ST1), 0>;
|
|
|
|
def : InstAlias<"fsub{r|}p", (SUB_FPrST0 ST1), 0>;
|
2013-07-23 00:03:33 +00:00
|
|
|
def : InstAlias<"fmulp", (MUL_FPrST0 ST1), 0>;
|
2013-07-26 05:37:46 +00:00
|
|
|
def : InstAlias<"fdiv{|r}p", (DIVR_FPrST0 ST1), 0>;
|
|
|
|
def : InstAlias<"fdiv{r|}p", (DIV_FPrST0 ST1), 0>;
|
2013-07-23 00:03:33 +00:00
|
|
|
def : InstAlias<"fxch", (XCH_F ST1), 0>;
|
|
|
|
def : InstAlias<"fcom", (COM_FST0r ST1), 0>;
|
|
|
|
def : InstAlias<"fcomp", (COMP_FST0r ST1), 0>;
|
|
|
|
def : InstAlias<"fcomi", (COM_FIr ST1), 0>;
|
|
|
|
def : InstAlias<"fcompi", (COM_FIPr ST1), 0>;
|
|
|
|
def : InstAlias<"fucom", (UCOM_Fr ST1), 0>;
|
|
|
|
def : InstAlias<"fucomp", (UCOM_FPr ST1), 0>;
|
|
|
|
def : InstAlias<"fucomi", (UCOM_FIr ST1), 0>;
|
|
|
|
def : InstAlias<"fucompi", (UCOM_FIPr ST1), 0>;
|
2010-11-06 20:47:38 +00:00
|
|
|
|
|
|
|
// Handle fmul/fadd/fsub/fdiv instructions with explicitly written st(0) op.
|
|
|
|
// For example, "fadd %st(4), %st(0)" -> "fadd %st(4)". We also disambiguate
|
|
|
|
// instructions like "fadd %st(0), %st(0)" as "fadd %st(0)" for consistency with
|
|
|
|
// gas.
|
2011-04-14 01:11:51 +00:00
|
|
|
multiclass FpUnaryAlias<string Mnemonic, Instruction Inst, bit EmitAlias = 1> {
|
2013-07-31 02:47:52 +00:00
|
|
|
def : InstAlias<!strconcat(Mnemonic, "\t{$op, %st(0)|st(0), $op}"),
|
2011-04-14 01:11:51 +00:00
|
|
|
(Inst RST:$op), EmitAlias>;
|
2013-07-31 02:47:52 +00:00
|
|
|
def : InstAlias<!strconcat(Mnemonic, "\t{%st(0), %st(0)|st(0), st(0)}"),
|
2011-04-14 01:11:51 +00:00
|
|
|
(Inst ST0), EmitAlias>;
|
2010-11-06 20:47:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
defm : FpUnaryAlias<"fadd", ADD_FST0r>;
|
2011-04-14 01:11:51 +00:00
|
|
|
defm : FpUnaryAlias<"faddp", ADD_FPrST0, 0>;
|
2010-11-06 20:47:38 +00:00
|
|
|
defm : FpUnaryAlias<"fsub", SUB_FST0r>;
|
2013-07-26 05:37:46 +00:00
|
|
|
defm : FpUnaryAlias<"fsub{|r}p", SUBR_FPrST0>;
|
2010-11-06 20:47:38 +00:00
|
|
|
defm : FpUnaryAlias<"fsubr", SUBR_FST0r>;
|
2013-07-26 05:37:46 +00:00
|
|
|
defm : FpUnaryAlias<"fsub{r|}p", SUB_FPrST0>;
|
2010-11-06 20:47:38 +00:00
|
|
|
defm : FpUnaryAlias<"fmul", MUL_FST0r>;
|
|
|
|
defm : FpUnaryAlias<"fmulp", MUL_FPrST0>;
|
|
|
|
defm : FpUnaryAlias<"fdiv", DIV_FST0r>;
|
2013-07-26 05:37:46 +00:00
|
|
|
defm : FpUnaryAlias<"fdiv{|r}p", DIVR_FPrST0>;
|
2010-11-06 20:47:38 +00:00
|
|
|
defm : FpUnaryAlias<"fdivr", DIVR_FST0r>;
|
2013-07-26 05:37:46 +00:00
|
|
|
defm : FpUnaryAlias<"fdiv{r|}p", DIV_FPrST0>;
|
2011-04-14 01:11:51 +00:00
|
|
|
defm : FpUnaryAlias<"fcomi", COM_FIr, 0>;
|
|
|
|
defm : FpUnaryAlias<"fucomi", UCOM_FIr, 0>;
|
2010-11-06 21:37:06 +00:00
|
|
|
defm : FpUnaryAlias<"fcompi", COM_FIPr>;
|
|
|
|
defm : FpUnaryAlias<"fucompi", UCOM_FIPr>;
|
2010-11-06 20:55:09 +00:00
|
|
|
|
2010-11-06 20:47:38 +00:00
|
|
|
|
|
|
|
// Handle "f{mulp,addp} st(0), $op" the same as "f{mulp,addp} $op", since they
|
2010-12-30 22:10:49 +00:00
|
|
|
// commute. We also allow fdiv[r]p/fsubrp even though they don't commute,
|
|
|
|
// solely because gas supports it.
|
2013-07-31 02:47:52 +00:00
|
|
|
def : InstAlias<"faddp\t{%st(0), $op|$op, st(0)}", (ADD_FPrST0 RST:$op), 0>;
|
|
|
|
def : InstAlias<"fmulp\t{%st(0), $op|$op, st(0)}", (MUL_FPrST0 RST:$op)>;
|
|
|
|
def : InstAlias<"fsub{|r}p\t{%st(0), $op|$op, st(0)}", (SUBR_FPrST0 RST:$op)>;
|
|
|
|
def : InstAlias<"fsub{r|}p\t{%st(0), $op|$op, st(0)}", (SUB_FPrST0 RST:$op)>;
|
|
|
|
def : InstAlias<"fdiv{|r}p\t{%st(0), $op|$op, st(0)}", (DIVR_FPrST0 RST:$op)>;
|
|
|
|
def : InstAlias<"fdiv{r|}p\t{%st(0), $op|$op, st(0)}", (DIV_FPrST0 RST:$op)>;
|
2010-11-06 19:57:21 +00:00
|
|
|
|
2010-12-30 22:10:49 +00:00
|
|
|
// We accept "fnstsw %eax" even though it only writes %ax.
|
2013-07-31 02:47:52 +00:00
|
|
|
def : InstAlias<"fnstsw\t{%eax|eax}", (FNSTSW16r)>;
|
|
|
|
def : InstAlias<"fnstsw\t{%al|al}" , (FNSTSW16r)>;
|
2012-04-27 12:07:43 +00:00
|
|
|
def : InstAlias<"fnstsw" , (FNSTSW16r)>;
|
2010-11-06 18:58:32 +00:00
|
|
|
|
2010-11-06 07:48:45 +00:00
|
|
|
// lcall and ljmp aliases. This seems to be an odd mapping in 64-bit mode, but
|
|
|
|
// this is compatible with what GAS does.
|
2014-05-15 13:36:01 +00:00
|
|
|
def : InstAlias<"lcall $seg, $off", (FARCALL32i i32imm:$off, i16imm:$seg), 0>, Requires<[Not16BitMode]>;
|
|
|
|
def : InstAlias<"ljmp $seg, $off", (FARJMP32i i32imm:$off, i16imm:$seg), 0>, Requires<[Not16BitMode]>;
|
|
|
|
def : InstAlias<"lcall *$dst", (FARCALL32m opaque48mem:$dst), 0>, Requires<[Not16BitMode]>;
|
|
|
|
def : InstAlias<"ljmp *$dst", (FARJMP32m opaque48mem:$dst), 0>, Requires<[Not16BitMode]>;
|
|
|
|
def : InstAlias<"lcall $seg, $off", (FARCALL16i i16imm:$off, i16imm:$seg), 0>, Requires<[In16BitMode]>;
|
|
|
|
def : InstAlias<"ljmp $seg, $off", (FARJMP16i i16imm:$off, i16imm:$seg), 0>, Requires<[In16BitMode]>;
|
|
|
|
def : InstAlias<"lcall *$dst", (FARCALL16m opaque32mem:$dst), 0>, Requires<[In16BitMode]>;
|
|
|
|
def : InstAlias<"ljmp *$dst", (FARJMP16m opaque32mem:$dst), 0>, Requires<[In16BitMode]>;
|
|
|
|
|
|
|
|
def : InstAlias<"call *$dst", (CALL64m i16mem:$dst), 0>, Requires<[In64BitMode]>;
|
|
|
|
def : InstAlias<"jmp *$dst", (JMP64m i16mem:$dst), 0>, Requires<[In64BitMode]>;
|
|
|
|
def : InstAlias<"call *$dst", (CALL32m i16mem:$dst), 0>, Requires<[In32BitMode]>;
|
|
|
|
def : InstAlias<"jmp *$dst", (JMP32m i16mem:$dst), 0>, Requires<[In32BitMode]>;
|
|
|
|
def : InstAlias<"call *$dst", (CALL16m i16mem:$dst), 0>, Requires<[In16BitMode]>;
|
|
|
|
def : InstAlias<"jmp *$dst", (JMP16m i16mem:$dst), 0>, Requires<[In16BitMode]>;
|
2014-01-08 12:57:49 +00:00
|
|
|
|
2010-11-06 07:48:45 +00:00
|
|
|
|
2010-11-06 18:44:26 +00:00
|
|
|
// "imul <imm>, B" is an alias for "imul <imm>, B, B".
|
|
|
|
def : InstAlias<"imulw $imm, $r", (IMUL16rri GR16:$r, GR16:$r, i16imm:$imm)>;
|
|
|
|
def : InstAlias<"imulw $imm, $r", (IMUL16rri8 GR16:$r, GR16:$r, i16i8imm:$imm)>;
|
|
|
|
def : InstAlias<"imull $imm, $r", (IMUL32rri GR32:$r, GR32:$r, i32imm:$imm)>;
|
|
|
|
def : InstAlias<"imull $imm, $r", (IMUL32rri8 GR32:$r, GR32:$r, i32i8imm:$imm)>;
|
|
|
|
def : InstAlias<"imulq $imm, $r",(IMUL64rri32 GR64:$r, GR64:$r,i64i32imm:$imm)>;
|
|
|
|
def : InstAlias<"imulq $imm, $r", (IMUL64rri8 GR64:$r, GR64:$r, i64i8imm:$imm)>;
|
|
|
|
|
2010-11-06 18:52:40 +00:00
|
|
|
// inb %dx -> inb %al, %dx
|
2013-07-31 02:47:52 +00:00
|
|
|
def : InstAlias<"inb\t{%dx|dx}", (IN8rr), 0>;
|
|
|
|
def : InstAlias<"inw\t{%dx|dx}", (IN16rr), 0>;
|
|
|
|
def : InstAlias<"inl\t{%dx|dx}", (IN32rr), 0>;
|
2013-07-22 20:46:37 +00:00
|
|
|
def : InstAlias<"inb\t$port", (IN8ri i8imm:$port), 0>;
|
|
|
|
def : InstAlias<"inw\t$port", (IN16ri i8imm:$port), 0>;
|
|
|
|
def : InstAlias<"inl\t$port", (IN32ri i8imm:$port), 0>;
|
2010-11-06 18:52:40 +00:00
|
|
|
|
2010-11-06 18:44:26 +00:00
|
|
|
|
2010-11-06 07:48:45 +00:00
|
|
|
// jmp and call aliases for lcall and ljmp. jmp $42,$5 -> ljmp
|
2014-01-08 12:57:49 +00:00
|
|
|
def : InstAlias<"call $seg, $off", (FARCALL16i i16imm:$off, i16imm:$seg)>, Requires<[In16BitMode]>;
|
|
|
|
def : InstAlias<"jmp $seg, $off", (FARJMP16i i16imm:$off, i16imm:$seg)>, Requires<[In16BitMode]>;
|
|
|
|
def : InstAlias<"call $seg, $off", (FARCALL32i i32imm:$off, i16imm:$seg)>, Requires<[Not16BitMode]>;
|
|
|
|
def : InstAlias<"jmp $seg, $off", (FARJMP32i i32imm:$off, i16imm:$seg)>, Requires<[Not16BitMode]>;
|
2010-11-06 07:48:45 +00:00
|
|
|
def : InstAlias<"callw $seg, $off", (FARCALL16i i16imm:$off, i16imm:$seg)>;
|
|
|
|
def : InstAlias<"jmpw $seg, $off", (FARJMP16i i16imm:$off, i16imm:$seg)>;
|
|
|
|
def : InstAlias<"calll $seg, $off", (FARCALL32i i32imm:$off, i16imm:$seg)>;
|
|
|
|
def : InstAlias<"jmpl $seg, $off", (FARJMP32i i32imm:$off, i16imm:$seg)>;
|
|
|
|
|
2010-11-06 22:35:34 +00:00
|
|
|
// Force mov without a suffix with a segment and mem to prefer the 'l' form of
|
|
|
|
// the move. All segment/mem forms are equivalent, this has the shortest
|
|
|
|
// encoding.
|
2014-05-16 09:41:26 +00:00
|
|
|
def : InstAlias<"mov $mem, $seg", (MOV32sm SEGMENT_REG:$seg, i32mem:$mem), 0>;
|
|
|
|
def : InstAlias<"mov $seg, $mem", (MOV32ms i32mem:$mem, SEGMENT_REG:$seg), 0>;
|
2010-11-06 07:48:45 +00:00
|
|
|
|
2010-11-06 18:44:26 +00:00
|
|
|
// Match 'movq <largeimm>, <reg>' as an alias for movabsq.
|
2014-05-16 09:41:26 +00:00
|
|
|
def : InstAlias<"movq $imm, $reg", (MOV64ri GR64:$reg, i64imm:$imm), 0>;
|
2010-11-06 18:44:26 +00:00
|
|
|
|
2010-11-21 08:18:57 +00:00
|
|
|
// Match 'movq GR64, MMX' as an alias for movd.
|
2011-04-13 23:36:21 +00:00
|
|
|
def : InstAlias<"movq $src, $dst",
|
2011-04-14 01:11:51 +00:00
|
|
|
(MMX_MOVD64to64rr VR64:$dst, GR64:$src), 0>;
|
2011-04-13 23:36:21 +00:00
|
|
|
def : InstAlias<"movq $src, $dst",
|
2011-04-14 01:11:51 +00:00
|
|
|
(MMX_MOVD64from64rr GR64:$dst, VR64:$src), 0>;
|
2010-11-21 08:18:57 +00:00
|
|
|
|
2010-11-01 23:07:52 +00:00
|
|
|
// movsx aliases
|
2011-05-20 19:04:40 +00:00
|
|
|
def : InstAlias<"movsx $src, $dst", (MOVSX16rr8 GR16:$dst, GR8:$src), 0>;
|
|
|
|
def : InstAlias<"movsx $src, $dst", (MOVSX16rm8 GR16:$dst, i8mem:$src), 0>;
|
2011-04-14 01:46:37 +00:00
|
|
|
def : InstAlias<"movsx $src, $dst", (MOVSX32rr8 GR32:$dst, GR8:$src), 0>;
|
|
|
|
def : InstAlias<"movsx $src, $dst", (MOVSX32rr16 GR32:$dst, GR16:$src), 0>;
|
|
|
|
def : InstAlias<"movsx $src, $dst", (MOVSX64rr8 GR64:$dst, GR8:$src), 0>;
|
|
|
|
def : InstAlias<"movsx $src, $dst", (MOVSX64rr16 GR64:$dst, GR16:$src), 0>;
|
|
|
|
def : InstAlias<"movsx $src, $dst", (MOVSX64rr32 GR64:$dst, GR32:$src), 0>;
|
2010-11-01 23:07:52 +00:00
|
|
|
|
|
|
|
// movzx aliases
|
2011-05-20 19:04:40 +00:00
|
|
|
def : InstAlias<"movzx $src, $dst", (MOVZX16rr8 GR16:$dst, GR8:$src), 0>;
|
|
|
|
def : InstAlias<"movzx $src, $dst", (MOVZX16rm8 GR16:$dst, i8mem:$src), 0>;
|
2011-04-14 01:46:37 +00:00
|
|
|
def : InstAlias<"movzx $src, $dst", (MOVZX32rr8 GR32:$dst, GR8:$src), 0>;
|
|
|
|
def : InstAlias<"movzx $src, $dst", (MOVZX32rr16 GR32:$dst, GR16:$src), 0>;
|
|
|
|
def : InstAlias<"movzx $src, $dst", (MOVZX64rr8_Q GR64:$dst, GR8:$src), 0>;
|
|
|
|
def : InstAlias<"movzx $src, $dst", (MOVZX64rr16_Q GR64:$dst, GR16:$src), 0>;
|
2010-11-01 23:07:52 +00:00
|
|
|
// Note: No GR32->GR64 movzx form.
|
|
|
|
|
2010-11-06 18:52:40 +00:00
|
|
|
// outb %dx -> outb %al, %dx
|
2013-07-31 02:47:52 +00:00
|
|
|
def : InstAlias<"outb\t{%dx|dx}", (OUT8rr), 0>;
|
|
|
|
def : InstAlias<"outw\t{%dx|dx}", (OUT16rr), 0>;
|
|
|
|
def : InstAlias<"outl\t{%dx|dx}", (OUT32rr), 0>;
|
2013-07-22 20:46:37 +00:00
|
|
|
def : InstAlias<"outb\t$port", (OUT8ir i8imm:$port), 0>;
|
|
|
|
def : InstAlias<"outw\t$port", (OUT16ir i8imm:$port), 0>;
|
|
|
|
def : InstAlias<"outl\t$port", (OUT32ir i8imm:$port), 0>;
|
2010-11-06 18:52:40 +00:00
|
|
|
|
2010-11-06 18:44:26 +00:00
|
|
|
// 'sldt <mem>' can be encoded with either sldtw or sldtq with the same
|
|
|
|
// effect (both store to a 16-bit mem). Force to sldtw to avoid ambiguity
|
|
|
|
// errors, since its encoding is the most compact.
|
2014-05-15 13:36:01 +00:00
|
|
|
def : InstAlias<"sldt $mem", (SLDT16m i16mem:$mem), 0>;
|
2010-11-06 18:44:26 +00:00
|
|
|
|
2012-03-05 04:31:54 +00:00
|
|
|
// shld/shrd op,op -> shld op, op, CL
|
2013-07-24 04:38:13 +00:00
|
|
|
def : InstAlias<"shld{w}\t{$r2, $r1|$r1, $r2}", (SHLD16rrCL GR16:$r1, GR16:$r2), 0>;
|
|
|
|
def : InstAlias<"shld{l}\t{$r2, $r1|$r1, $r2}", (SHLD32rrCL GR32:$r1, GR32:$r2), 0>;
|
|
|
|
def : InstAlias<"shld{q}\t{$r2, $r1|$r1, $r2}", (SHLD64rrCL GR64:$r1, GR64:$r2), 0>;
|
|
|
|
def : InstAlias<"shrd{w}\t{$r2, $r1|$r1, $r2}", (SHRD16rrCL GR16:$r1, GR16:$r2), 0>;
|
|
|
|
def : InstAlias<"shrd{l}\t{$r2, $r1|$r1, $r2}", (SHRD32rrCL GR32:$r1, GR32:$r2), 0>;
|
|
|
|
def : InstAlias<"shrd{q}\t{$r2, $r1|$r1, $r2}", (SHRD64rrCL GR64:$r1, GR64:$r2), 0>;
|
|
|
|
|
|
|
|
def : InstAlias<"shld{w}\t{$reg, $mem|$mem, $reg}", (SHLD16mrCL i16mem:$mem, GR16:$reg), 0>;
|
|
|
|
def : InstAlias<"shld{l}\t{$reg, $mem|$mem, $reg}", (SHLD32mrCL i32mem:$mem, GR32:$reg), 0>;
|
|
|
|
def : InstAlias<"shld{q}\t{$reg, $mem|$mem, $reg}", (SHLD64mrCL i64mem:$mem, GR64:$reg), 0>;
|
|
|
|
def : InstAlias<"shrd{w}\t{$reg, $mem|$mem, $reg}", (SHRD16mrCL i16mem:$mem, GR16:$reg), 0>;
|
|
|
|
def : InstAlias<"shrd{l}\t{$reg, $mem|$mem, $reg}", (SHRD32mrCL i32mem:$mem, GR32:$reg), 0>;
|
|
|
|
def : InstAlias<"shrd{q}\t{$reg, $mem|$mem, $reg}", (SHRD64mrCL i64mem:$mem, GR64:$reg), 0>;
|
2010-11-06 22:25:39 +00:00
|
|
|
|
|
|
|
/* FIXME: This is disabled because the asm matcher is currently incapable of
|
|
|
|
* matching a fixed immediate like $1.
|
2010-11-06 22:05:43 +00:00
|
|
|
// "shl X, $1" is an alias for "shl X".
|
|
|
|
multiclass ShiftRotateByOneAlias<string Mnemonic, string Opc> {
|
2010-11-06 21:23:40 +00:00
|
|
|
def : InstAlias<!strconcat(Mnemonic, "b $op, $$1"),
|
|
|
|
(!cast<Instruction>(!strconcat(Opc, "8r1")) GR8:$op)>;
|
|
|
|
def : InstAlias<!strconcat(Mnemonic, "w $op, $$1"),
|
|
|
|
(!cast<Instruction>(!strconcat(Opc, "16r1")) GR16:$op)>;
|
|
|
|
def : InstAlias<!strconcat(Mnemonic, "l $op, $$1"),
|
|
|
|
(!cast<Instruction>(!strconcat(Opc, "32r1")) GR32:$op)>;
|
|
|
|
def : InstAlias<!strconcat(Mnemonic, "q $op, $$1"),
|
|
|
|
(!cast<Instruction>(!strconcat(Opc, "64r1")) GR64:$op)>;
|
|
|
|
def : InstAlias<!strconcat(Mnemonic, "b $op, $$1"),
|
|
|
|
(!cast<Instruction>(!strconcat(Opc, "8m1")) i8mem:$op)>;
|
|
|
|
def : InstAlias<!strconcat(Mnemonic, "w $op, $$1"),
|
|
|
|
(!cast<Instruction>(!strconcat(Opc, "16m1")) i16mem:$op)>;
|
|
|
|
def : InstAlias<!strconcat(Mnemonic, "l $op, $$1"),
|
|
|
|
(!cast<Instruction>(!strconcat(Opc, "32m1")) i32mem:$op)>;
|
|
|
|
def : InstAlias<!strconcat(Mnemonic, "q $op, $$1"),
|
|
|
|
(!cast<Instruction>(!strconcat(Opc, "64m1")) i64mem:$op)>;
|
|
|
|
}
|
|
|
|
|
2010-11-06 22:05:43 +00:00
|
|
|
defm : ShiftRotateByOneAlias<"rcl", "RCL">;
|
|
|
|
defm : ShiftRotateByOneAlias<"rcr", "RCR">;
|
|
|
|
defm : ShiftRotateByOneAlias<"rol", "ROL">;
|
|
|
|
defm : ShiftRotateByOneAlias<"ror", "ROR">;
|
2010-11-06 22:25:39 +00:00
|
|
|
FIXME */
|
2010-11-06 21:23:40 +00:00
|
|
|
|
2010-11-06 08:20:59 +00:00
|
|
|
// test: We accept "testX <reg>, <mem>" and "testX <mem>, <reg>" as synonyms.
|
2014-05-15 11:16:32 +00:00
|
|
|
def : InstAlias<"test{b}\t{$val, $mem|$mem, $val}",
|
|
|
|
(TEST8rm GR8 :$val, i8mem :$mem), 0>;
|
|
|
|
def : InstAlias<"test{w}\t{$val, $mem|$mem, $val}",
|
|
|
|
(TEST16rm GR16:$val, i16mem:$mem), 0>;
|
|
|
|
def : InstAlias<"test{l}\t{$val, $mem|$mem, $val}",
|
|
|
|
(TEST32rm GR32:$val, i32mem:$mem), 0>;
|
|
|
|
def : InstAlias<"test{q}\t{$val, $mem|$mem, $val}",
|
|
|
|
(TEST64rm GR64:$val, i64mem:$mem), 0>;
|
2010-11-06 08:20:59 +00:00
|
|
|
|
|
|
|
// xchg: We accept "xchgX <reg>, <mem>" and "xchgX <mem>, <reg>" as synonyms.
|
2014-05-15 11:16:32 +00:00
|
|
|
def : InstAlias<"xchg{b}\t{$mem, $val|$val, $mem}",
|
|
|
|
(XCHG8rm GR8 :$val, i8mem :$mem), 0>;
|
|
|
|
def : InstAlias<"xchg{w}\t{$mem, $val|$val, $mem}",
|
|
|
|
(XCHG16rm GR16:$val, i16mem:$mem), 0>;
|
|
|
|
def : InstAlias<"xchg{l}\t{$mem, $val|$val, $mem}",
|
|
|
|
(XCHG32rm GR32:$val, i32mem:$mem), 0>;
|
|
|
|
def : InstAlias<"xchg{q}\t{$mem, $val|$val, $mem}",
|
|
|
|
(XCHG64rm GR64:$val, i64mem:$mem), 0>;
|
2011-10-06 06:44:41 +00:00
|
|
|
|
|
|
|
// xchg: We accept "xchgX <reg>, %eax" and "xchgX %eax, <reg>" as synonyms.
|
2014-05-15 11:16:32 +00:00
|
|
|
def : InstAlias<"xchg{w}\t{%ax, $src|$src, ax}", (XCHG16ar GR16:$src), 0>;
|
|
|
|
def : InstAlias<"xchg{l}\t{%eax, $src|$src, eax}",
|
|
|
|
(XCHG32ar GR32:$src), 0>, Requires<[Not64BitMode]>;
|
|
|
|
def : InstAlias<"xchg{l}\t{%eax, $src|$src, eax}",
|
|
|
|
(XCHG32ar64 GR32_NOAX:$src), 0>, Requires<[In64BitMode]>;
|
|
|
|
def : InstAlias<"xchg{q}\t{%rax, $src|$src, rax}", (XCHG64ar GR64:$src), 0>;
|