2007-10-12 21:30:57 +00:00
|
|
|
//===- X86InstrInfo.td - Describe the X86 Instruction Set --*- tablegen -*-===//
|
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.
|
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>]>;
|
|
|
|
|
2006-01-26 00:29:36 +00:00
|
|
|
def SDTX86CmpTest : SDTypeProfile<0, 2, [SDTCisSameAs<0, 1>]>;
|
2005-12-17 01:24:02 +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.
|
|
|
|
def SDTUnaryArithWithFlags : SDTypeProfile<1, 1,
|
|
|
|
[SDTCisInt<0>]>;
|
|
|
|
def SDTBinaryArithWithFlags : SDTypeProfile<1, 2,
|
|
|
|
[SDTCisSameAs<0, 1>,
|
|
|
|
SDTCisSameAs<0, 2>,
|
|
|
|
SDTCisInt<0>]>;
|
2008-12-12 00:56:36 +00:00
|
|
|
|
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>]>;
|
2005-12-21 20:21:51 +00:00
|
|
|
|
2008-03-01 21:52:34 +00:00
|
|
|
def SDTX86cas : SDTypeProfile<0, 3, [SDTCisPtrTy<0>, SDTCisInt<1>,
|
|
|
|
SDTCisVT<2, i8>]>;
|
2008-03-05 01:15:49 +00:00
|
|
|
def SDTX86cas8 : 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
|
|
|
|
2007-11-13 09:19:02 +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
|
|
|
|
2006-01-11 22:15:48 +00:00
|
|
|
def SDTX86RepStr : SDTypeProfile<0, 1, [SDTCisVT<0, OtherVT>]>;
|
|
|
|
|
2006-01-09 18:33:28 +00:00
|
|
|
def SDTX86RdTsc : 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
|
|
|
|
2009-04-08 21:14:34 +00:00
|
|
|
def SDT_X86SegmentBaseAddress : SDTypeProfile<1, 1, [SDTCisPtrTy<0>]>;
|
2007-04-20 21:38:10 +00:00
|
|
|
|
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>]>;
|
|
|
|
|
2007-12-14 02:13:44 +00:00
|
|
|
def X86bsf : SDNode<"X86ISD::BSF", SDTIntUnaryOp>;
|
|
|
|
def X86bsr : SDNode<"X86ISD::BSR", SDTIntUnaryOp>;
|
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>;
|
2005-12-21 02:39:21 +00:00
|
|
|
|
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>;
|
2005-12-21 02:39:21 +00:00
|
|
|
|
2008-03-01 21:52:34 +00:00
|
|
|
def X86cas : SDNode<"X86ISD::LCMPXCHG_DAG", SDTX86cas,
|
|
|
|
[SDNPHasChain, SDNPInFlag, SDNPOutFlag, SDNPMayStore,
|
|
|
|
SDNPMayLoad]>;
|
2008-03-05 01:15:49 +00:00
|
|
|
def X86cas8 : SDNode<"X86ISD::LCMPXCHG8_DAG", SDTX86cas8,
|
|
|
|
[SDNPHasChain, SDNPInFlag, SDNPOutFlag, SDNPMayStore,
|
|
|
|
SDNPMayLoad]>;
|
2008-10-02 18:53:47 +00:00
|
|
|
def X86AtomAdd64 : SDNode<"X86ISD::ATOMADD64_DAG", SDTX86atomicBinary,
|
|
|
|
[SDNPHasChain, SDNPMayStore,
|
|
|
|
SDNPMayLoad, SDNPMemOperand]>;
|
|
|
|
def X86AtomSub64 : SDNode<"X86ISD::ATOMSUB64_DAG", SDTX86atomicBinary,
|
|
|
|
[SDNPHasChain, SDNPMayStore,
|
|
|
|
SDNPMayLoad, SDNPMemOperand]>;
|
|
|
|
def X86AtomOr64 : SDNode<"X86ISD::ATOMOR64_DAG", SDTX86atomicBinary,
|
|
|
|
[SDNPHasChain, SDNPMayStore,
|
|
|
|
SDNPMayLoad, SDNPMemOperand]>;
|
|
|
|
def X86AtomXor64 : SDNode<"X86ISD::ATOMXOR64_DAG", SDTX86atomicBinary,
|
|
|
|
[SDNPHasChain, SDNPMayStore,
|
|
|
|
SDNPMayLoad, SDNPMemOperand]>;
|
|
|
|
def X86AtomAnd64 : SDNode<"X86ISD::ATOMAND64_DAG", SDTX86atomicBinary,
|
|
|
|
[SDNPHasChain, SDNPMayStore,
|
|
|
|
SDNPMayLoad, SDNPMemOperand]>;
|
|
|
|
def X86AtomNand64 : SDNode<"X86ISD::ATOMNAND64_DAG", SDTX86atomicBinary,
|
|
|
|
[SDNPHasChain, SDNPMayStore,
|
|
|
|
SDNPMayLoad, SDNPMemOperand]>;
|
2008-10-03 22:25:52 +00:00
|
|
|
def X86AtomSwap64 : SDNode<"X86ISD::ATOMSWAP64_DAG", SDTX86atomicBinary,
|
|
|
|
[SDNPHasChain, SDNPMayStore,
|
|
|
|
SDNPMayLoad, SDNPMemOperand]>;
|
2006-01-09 18:33:28 +00:00
|
|
|
def X86retflag : SDNode<"X86ISD::RET_FLAG", SDTX86Ret,
|
|
|
|
[SDNPHasChain, SDNPOptInFlag]>;
|
2005-12-21 02:39:21 +00:00
|
|
|
|
2006-01-09 18:33:28 +00:00
|
|
|
def X86callseq_start :
|
|
|
|
SDNode<"ISD::CALLSEQ_START", SDT_X86CallSeqStart,
|
2006-08-11 09:03:33 +00:00
|
|
|
[SDNPHasChain, SDNPOutFlag]>;
|
2006-01-09 18:33:28 +00:00
|
|
|
def X86callseq_end :
|
|
|
|
SDNode<"ISD::CALLSEQ_END", SDT_X86CallSeqEnd,
|
2007-10-11 19:40:01 +00:00
|
|
|
[SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
|
2005-12-21 02:39:21 +00:00
|
|
|
|
2006-01-09 18:33:28 +00:00
|
|
|
def X86call : SDNode<"X86ISD::CALL", SDT_X86Call,
|
|
|
|
[SDNPHasChain, SDNPOutFlag, SDNPOptInFlag]>;
|
2005-12-17 01:24:02 +00:00
|
|
|
|
2006-05-20 01:40:16 +00:00
|
|
|
def X86tailcall: SDNode<"X86ISD::TAILCALL", SDT_X86Call,
|
2006-04-27 08:40:39 +00:00
|
|
|
[SDNPHasChain, SDNPOutFlag, SDNPOptInFlag]>;
|
|
|
|
|
2006-01-11 22:15:48 +00:00
|
|
|
def X86rep_stos: SDNode<"X86ISD::REP_STOS", SDTX86RepStr,
|
2008-01-10 05:12:37 +00:00
|
|
|
[SDNPHasChain, SDNPInFlag, SDNPOutFlag, SDNPMayStore]>;
|
2006-01-11 22:15:48 +00:00
|
|
|
def X86rep_movs: SDNode<"X86ISD::REP_MOVS", SDTX86RepStr,
|
2008-01-10 05:12:37 +00:00
|
|
|
[SDNPHasChain, SDNPInFlag, SDNPOutFlag, SDNPMayStore,
|
|
|
|
SDNPMayLoad]>;
|
2006-01-11 22:15:48 +00:00
|
|
|
|
2006-01-09 18:33:28 +00:00
|
|
|
def X86rdtsc : SDNode<"X86ISD::RDTSC_DAG",SDTX86RdTsc,
|
2008-01-10 07:59:24 +00:00
|
|
|
[SDNPHasChain, SDNPOutFlag, 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,
|
2008-05-04 21:36:32 +00:00
|
|
|
[SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
|
2009-04-08 21:14:34 +00:00
|
|
|
def X86SegmentBaseAddress : SDNode<"X86ISD::SegmentBaseAddress",
|
|
|
|
SDT_X86SegmentBaseAddress, []>;
|
2007-04-20 21:38:10 +00:00
|
|
|
|
2007-07-14 14:06:15 +00:00
|
|
|
def X86ehret : SDNode<"X86ISD::EH_RETURN", SDT_X86EHRET,
|
|
|
|
[SDNPHasChain]>;
|
|
|
|
|
2007-10-11 19:40:01 +00:00
|
|
|
def X86tcret : SDNode<"X86ISD::TC_RETURN", SDT_X86TCRET,
|
|
|
|
[SDNPHasChain, SDNPOptInFlag]>;
|
2007-04-20 21:38:10 +00:00
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
def X86add_flag : SDNode<"X86ISD::ADD", SDTBinaryArithWithFlags>;
|
|
|
|
def X86sub_flag : SDNode<"X86ISD::SUB", SDTBinaryArithWithFlags>;
|
|
|
|
def X86smul_flag : SDNode<"X86ISD::SMUL", SDTBinaryArithWithFlags>;
|
|
|
|
def X86umul_flag : SDNode<"X86ISD::UMUL", SDTUnaryArithWithFlags>;
|
|
|
|
def X86inc_flag : SDNode<"X86ISD::INC", SDTUnaryArithWithFlags>;
|
|
|
|
def X86dec_flag : SDNode<"X86ISD::DEC", SDTUnaryArithWithFlags>;
|
2008-12-12 00:56:36 +00:00
|
|
|
|
2009-03-30 21:36:47 +00:00
|
|
|
def X86mul_imm : SDNode<"X86ISD::MUL_IMM", SDTIntBinOp>;
|
|
|
|
|
2005-12-17 01:24:02 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// X86 Operand Definitions.
|
|
|
|
//
|
|
|
|
|
2004-08-11 02:25:00 +00:00
|
|
|
// *mem - Operand definitions for the funky X86 addressing mode operands.
|
|
|
|
//
|
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-04-08 21:14:34 +00:00
|
|
|
let MIOperandInfo = (ops ptr_rc, i8imm, ptr_rc, i32imm, i8imm);
|
2004-08-11 02:25:00 +00:00
|
|
|
}
|
2005-11-30 18:54:35 +00:00
|
|
|
|
2005-12-17 19:47:05 +00:00
|
|
|
def i8mem : X86MemOperand<"printi8mem">;
|
|
|
|
def i16mem : X86MemOperand<"printi16mem">;
|
|
|
|
def i32mem : X86MemOperand<"printi32mem">;
|
|
|
|
def i64mem : X86MemOperand<"printi64mem">;
|
2006-02-22 02:26:30 +00:00
|
|
|
def i128mem : X86MemOperand<"printi128mem">;
|
2005-12-17 19:47:05 +00:00
|
|
|
def f32mem : X86MemOperand<"printf32mem">;
|
|
|
|
def f64mem : X86MemOperand<"printf64mem">;
|
2007-08-05 18:49:15 +00:00
|
|
|
def f80mem : X86MemOperand<"printf80mem">;
|
2006-01-31 22:28:30 +00:00
|
|
|
def f128mem : X86MemOperand<"printf128mem">;
|
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";
|
|
|
|
let MIOperandInfo = (ops GR64_NOREX, i8imm, GR64_NOREX, i32imm, i8imm);
|
|
|
|
}
|
|
|
|
|
2006-09-08 06:48:29 +00:00
|
|
|
def lea32mem : Operand<i32> {
|
2009-04-08 21:14:34 +00:00
|
|
|
let PrintMethod = "printlea32mem";
|
2006-09-08 06:48:29 +00:00
|
|
|
let MIOperandInfo = (ops GR32, i8imm, GR32, i32imm);
|
|
|
|
}
|
|
|
|
|
2005-07-15 00:38:55 +00:00
|
|
|
def SSECC : Operand<i8> {
|
|
|
|
let PrintMethod = "printSSECC";
|
|
|
|
}
|
2004-08-11 02:25:00 +00:00
|
|
|
|
2006-02-18 00:15:05 +00:00
|
|
|
def piclabel: Operand<i32> {
|
|
|
|
let PrintMethod = "printPICLabel";
|
|
|
|
}
|
|
|
|
|
2005-11-18 01:04:42 +00:00
|
|
|
// A couple of more descriptive operand definitions.
|
|
|
|
// 16-bits but only 8 bits are significant.
|
|
|
|
def i16i8imm : Operand<i16>;
|
|
|
|
// 32-bits but only 8 bits are significant.
|
|
|
|
def i32i8imm : Operand<i32>;
|
|
|
|
|
2005-12-04 08:19:43 +00:00
|
|
|
// Branch targets have OtherVT type.
|
|
|
|
def brtarget : Operand<OtherVT>;
|
|
|
|
|
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.
|
2009-04-08 21:14:34 +00:00
|
|
|
def addr : ComplexPattern<iPTR, 5, "SelectAddr", [], []>;
|
2006-09-08 06:48:29 +00:00
|
|
|
def lea32addr : ComplexPattern<i32, 4, "SelectLEAAddr",
|
2006-10-11 21:03:53 +00:00
|
|
|
[add, mul, shl, or, frameindex], []>;
|
2005-12-08 02:01:35 +00:00
|
|
|
|
2005-12-20 22:59:51 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// X86 Instruction Predicate Definitions.
|
2006-12-05 19:50:18 +00:00
|
|
|
def HasMMX : Predicate<"Subtarget->hasMMX()">;
|
|
|
|
def HasSSE1 : Predicate<"Subtarget->hasSSE1()">;
|
|
|
|
def HasSSE2 : Predicate<"Subtarget->hasSSE2()">;
|
|
|
|
def HasSSE3 : Predicate<"Subtarget->hasSSE3()">;
|
2007-04-10 22:10:25 +00:00
|
|
|
def HasSSSE3 : Predicate<"Subtarget->hasSSSE3()">;
|
2008-02-03 07:18:54 +00:00
|
|
|
def HasSSE41 : Predicate<"Subtarget->hasSSE41()">;
|
|
|
|
def HasSSE42 : Predicate<"Subtarget->hasSSE42()">;
|
2007-09-23 14:52:20 +00:00
|
|
|
def FPStackf32 : Predicate<"!Subtarget->hasSSE1()">;
|
|
|
|
def FPStackf64 : Predicate<"!Subtarget->hasSSE2()">;
|
2006-12-05 19:50:18 +00:00
|
|
|
def In32BitMode : Predicate<"!Subtarget->is64Bit()">;
|
|
|
|
def In64BitMode : Predicate<"Subtarget->is64Bit()">;
|
|
|
|
def SmallCode : Predicate<"TM.getCodeModel() == CodeModel::Small">;
|
|
|
|
def NotSmallCode : Predicate<"TM.getCodeModel() != CodeModel::Small">;
|
|
|
|
def IsStatic : Predicate<"TM.getRelocationModel() == Reloc::Static">;
|
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()">;
|
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
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Pattern fragments...
|
|
|
|
//
|
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
|
|
|
|
2005-12-13 00:14:11 +00:00
|
|
|
def i16immSExt8 : PatLeaf<(i16 imm), [{
|
|
|
|
// i16immSExt8 predicate - True if the 16-bit immediate fits in a 8-bit
|
2005-12-13 00:01:09 +00:00
|
|
|
// sign extended field.
|
2008-09-12 16:56:44 +00:00
|
|
|
return (int16_t)N->getZExtValue() == (int8_t)N->getZExtValue();
|
2005-11-18 01:04:42 +00:00
|
|
|
}]>;
|
|
|
|
|
2005-12-13 00:14:11 +00:00
|
|
|
def i32immSExt8 : PatLeaf<(i32 imm), [{
|
|
|
|
// i32immSExt8 predicate - True if the 32-bit immediate fits in a 8-bit
|
2005-12-13 00:01:09 +00:00
|
|
|
// sign extended field.
|
2008-09-12 16:56:44 +00:00
|
|
|
return (int32_t)N->getZExtValue() == (int8_t)N->getZExtValue();
|
2005-12-13 00:01:09 +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);
|
2009-04-10 00:16:23 +00:00
|
|
|
if (const Value *Src = LD->getSrcValue())
|
|
|
|
if (const PointerType *PT = dyn_cast<PointerType>(Src->getType()))
|
2009-04-27 07:22:10 +00:00
|
|
|
if (PT->getAddressSpace() > 255)
|
2009-04-10 00:16:23 +00:00
|
|
|
return false;
|
2008-08-20 15:24:22 +00:00
|
|
|
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;
|
|
|
|
}]>;
|
|
|
|
|
2008-10-15 06:50:19 +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);
|
2009-04-10 00:16:23 +00:00
|
|
|
if (const Value *Src = LD->getSrcValue())
|
|
|
|
if (const PointerType *PT = dyn_cast<PointerType>(Src->getType()))
|
2009-04-27 07:22:10 +00:00
|
|
|
if (PT->getAddressSpace() > 255)
|
2009-04-10 00:16:23 +00:00
|
|
|
return false;
|
2008-09-24 23:27:55 +00:00
|
|
|
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);
|
2009-04-10 00:16:23 +00:00
|
|
|
if (const Value *Src = LD->getSrcValue())
|
|
|
|
if (const PointerType *PT = dyn_cast<PointerType>(Src->getType()))
|
2009-04-27 07:22:10 +00:00
|
|
|
if (PT->getAddressSpace() > 255)
|
2009-04-10 00:16:23 +00:00
|
|
|
return false;
|
2008-08-20 15:24:22 +00:00
|
|
|
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;
|
|
|
|
}]>;
|
|
|
|
|
2008-10-15 06:50:19 +00:00
|
|
|
def nvloadi32 : PatFrag<(ops node:$ptr), (i32 (unindexedload node:$ptr)), [{
|
2008-09-29 17:26:18 +00:00
|
|
|
LoadSDNode *LD = cast<LoadSDNode>(N);
|
2009-04-10 00:16:23 +00:00
|
|
|
if (const Value *Src = LD->getSrcValue())
|
|
|
|
if (const PointerType *PT = dyn_cast<PointerType>(Src->getType()))
|
2009-04-27 07:22:10 +00:00
|
|
|
if (PT->getAddressSpace() > 255)
|
2009-04-10 00:16:23 +00:00
|
|
|
return false;
|
2008-09-29 17:26:18 +00:00
|
|
|
if (LD->isVolatile())
|
|
|
|
return false;
|
|
|
|
ISD::LoadExtType ExtType = LD->getExtensionType();
|
|
|
|
if (ExtType == ISD::NON_EXTLOAD)
|
|
|
|
return true;
|
|
|
|
if (ExtType == ISD::EXTLOAD)
|
|
|
|
return LD->getAlignment() >= 4;
|
|
|
|
return false;
|
|
|
|
}]>;
|
|
|
|
|
2009-01-26 01:24:32 +00:00
|
|
|
def gsload : PatFrag<(ops node:$ptr), (load node:$ptr), [{
|
2009-04-10 00:16:23 +00:00
|
|
|
if (const Value *Src = cast<LoadSDNode>(N)->getSrcValue())
|
|
|
|
if (const PointerType *PT = dyn_cast<PointerType>(Src->getType()))
|
|
|
|
return PT->getAddressSpace() == 256;
|
2009-01-26 01:24:32 +00:00
|
|
|
return false;
|
|
|
|
}]>;
|
|
|
|
|
2009-04-10 00:16:23 +00:00
|
|
|
def loadi8 : PatFrag<(ops node:$ptr), (i8 (load node:$ptr)), [{
|
|
|
|
if (const Value *Src = cast<LoadSDNode>(N)->getSrcValue())
|
|
|
|
if (const PointerType *PT = dyn_cast<PointerType>(Src->getType()))
|
2009-04-27 07:22:10 +00:00
|
|
|
if (PT->getAddressSpace() > 255)
|
2009-04-10 00:16:23 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}]>;
|
|
|
|
def loadi64 : PatFrag<(ops node:$ptr), (i64 (load node:$ptr)), [{
|
|
|
|
if (const Value *Src = cast<LoadSDNode>(N)->getSrcValue())
|
|
|
|
if (const PointerType *PT = dyn_cast<PointerType>(Src->getType()))
|
2009-04-27 07:22:10 +00:00
|
|
|
if (PT->getAddressSpace() > 255)
|
2009-04-10 00:16:23 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}]>;
|
2006-03-17 19:55:52 +00:00
|
|
|
|
2009-04-10 00:16:23 +00:00
|
|
|
def loadf32 : PatFrag<(ops node:$ptr), (f32 (load node:$ptr)), [{
|
|
|
|
if (const Value *Src = cast<LoadSDNode>(N)->getSrcValue())
|
|
|
|
if (const PointerType *PT = dyn_cast<PointerType>(Src->getType()))
|
2009-04-27 07:22:10 +00:00
|
|
|
if (PT->getAddressSpace() > 255)
|
2009-04-10 00:16:23 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}]>;
|
|
|
|
def loadf64 : PatFrag<(ops node:$ptr), (f64 (load node:$ptr)), [{
|
|
|
|
if (const Value *Src = cast<LoadSDNode>(N)->getSrcValue())
|
|
|
|
if (const PointerType *PT = dyn_cast<PointerType>(Src->getType()))
|
2009-04-27 07:22:10 +00:00
|
|
|
if (PT->getAddressSpace() > 255)
|
2009-04-10 00:16:23 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}]>;
|
|
|
|
def loadf80 : PatFrag<(ops node:$ptr), (f80 (load node:$ptr)), [{
|
|
|
|
if (const Value *Src = cast<LoadSDNode>(N)->getSrcValue())
|
|
|
|
if (const PointerType *PT = dyn_cast<PointerType>(Src->getType()))
|
2009-04-27 07:22:10 +00:00
|
|
|
if (PT->getAddressSpace() > 255)
|
2009-04-10 00:16:23 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}]>;
|
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))>;
|
|
|
|
|
|
|
|
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))>;
|
|
|
|
|
|
|
|
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))>;
|
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
|
|
|
|
2008-10-17 01:23:35 +00:00
|
|
|
// 'shld' and 'shrd' instruction patterns. Note that even though these have
|
|
|
|
// the srl and shl in their patterns, the C++ code must still check for them,
|
|
|
|
// because predicates are tested before children nodes are explored.
|
|
|
|
|
|
|
|
def shrd : PatFrag<(ops node:$src1, node:$amt1, node:$src2, node:$amt2),
|
|
|
|
(or (srl node:$src1, node:$amt1),
|
|
|
|
(shl node:$src2, node:$amt2)), [{
|
|
|
|
assert(N->getOpcode() == ISD::OR);
|
|
|
|
return N->getOperand(0).getOpcode() == ISD::SRL &&
|
|
|
|
N->getOperand(1).getOpcode() == ISD::SHL &&
|
|
|
|
isa<ConstantSDNode>(N->getOperand(0).getOperand(1)) &&
|
|
|
|
isa<ConstantSDNode>(N->getOperand(1).getOperand(1)) &&
|
|
|
|
N->getOperand(0).getConstantOperandVal(1) ==
|
|
|
|
N->getValueSizeInBits(0) - N->getOperand(1).getConstantOperandVal(1);
|
|
|
|
}]>;
|
|
|
|
|
|
|
|
def shld : PatFrag<(ops node:$src1, node:$amt1, node:$src2, node:$amt2),
|
|
|
|
(or (shl node:$src1, node:$amt1),
|
|
|
|
(srl node:$src2, node:$amt2)), [{
|
|
|
|
assert(N->getOpcode() == ISD::OR);
|
|
|
|
return N->getOperand(0).getOpcode() == ISD::SHL &&
|
|
|
|
N->getOperand(1).getOpcode() == ISD::SRL &&
|
|
|
|
isa<ConstantSDNode>(N->getOperand(0).getOperand(1)) &&
|
|
|
|
isa<ConstantSDNode>(N->getOperand(1).getOperand(1)) &&
|
|
|
|
N->getOperand(0).getConstantOperandVal(1) ==
|
|
|
|
N->getValueSizeInBits(0) - N->getOperand(1).getConstantOperandVal(1);
|
|
|
|
}]>;
|
|
|
|
|
2003-08-03 21:54:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Instruction list...
|
|
|
|
//
|
|
|
|
|
2006-10-12 17:42:56 +00:00
|
|
|
// ADJCALLSTACKDOWN/UP implicitly use/def ESP because they may be expanded into
|
|
|
|
// a stack adjustment and the codegen must know that they may modify the stack
|
|
|
|
// pointer before prolog-epilog rewriting occurs.
|
2008-03-11 03:23:40 +00:00
|
|
|
// Pessimistically assume ADJCALLSTACKDOWN / ADJCALLSTACKUP will become
|
|
|
|
// sub / add which can clobber EFLAGS.
|
2007-09-28 01:19:48 +00:00
|
|
|
let Defs = [ESP, EFLAGS], Uses = [ESP] in {
|
2008-10-01 18:28:06 +00:00
|
|
|
def ADJCALLSTACKDOWN32 : I<0, Pseudo, (outs), (ins i32imm:$amt),
|
|
|
|
"#ADJCALLSTACKDOWN",
|
2008-10-11 22:08:30 +00:00
|
|
|
[(X86callseq_start timm:$amt)]>,
|
2008-10-01 18:28:06 +00:00
|
|
|
Requires<[In32BitMode]>;
|
|
|
|
def ADJCALLSTACKUP32 : I<0, Pseudo, (outs), (ins i32imm:$amt1, i32imm:$amt2),
|
|
|
|
"#ADJCALLSTACKUP",
|
2008-10-11 22:08:30 +00:00
|
|
|
[(X86callseq_end timm:$amt1, timm:$amt2)]>,
|
2008-10-01 18:28:06 +00:00
|
|
|
Requires<[In32BitMode]>;
|
2007-09-11 19:55:27 +00:00
|
|
|
}
|
2006-01-11 00:33:36 +00:00
|
|
|
|
|
|
|
// Nop
|
2008-01-10 07:59:24 +00:00
|
|
|
let neverHasSideEffects = 1 in
|
|
|
|
def NOOP : I<0x90, RawFrm, (outs), (ins), "nop", []>;
|
2006-01-11 00:33:36 +00:00
|
|
|
|
2008-01-05 00:41:47 +00:00
|
|
|
// PIC base
|
2008-10-01 04:14:30 +00:00
|
|
|
let neverHasSideEffects = 1, isNotDuplicable = 1, Uses = [ESP] in
|
2008-01-10 07:59:24 +00:00
|
|
|
def MOVPC32r : Ii32<0xE8, Pseudo, (outs GR32:$reg), (ins piclabel:$label),
|
2009-04-27 15:13:28 +00:00
|
|
|
"call\t$label\n\t"
|
|
|
|
"pop{l}\t$reg", []>;
|
2006-05-05 05:40:20 +00:00
|
|
|
|
2003-08-03 21:54:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Control Flow Instructions...
|
|
|
|
//
|
|
|
|
|
2005-05-13 17:56:48 +00:00
|
|
|
// Return instructions.
|
2005-12-26 09:11:45 +00:00
|
|
|
let isTerminator = 1, isReturn = 1, isBarrier = 1,
|
2008-03-11 03:23:40 +00:00
|
|
|
hasCtrlDep = 1, FPForm = SpecialFP, FPFormBits = SpecialFP.Value in {
|
2008-05-31 02:11:25 +00:00
|
|
|
def RET : I <0xC3, RawFrm, (outs), (ins variable_ops),
|
2008-03-11 03:23:40 +00:00
|
|
|
"ret",
|
2008-05-31 02:11:25 +00:00
|
|
|
[(X86retflag 0)]>;
|
2008-03-11 03:23:40 +00:00
|
|
|
def RETI : Ii16<0xC2, RawFrm, (outs), (ins i16imm:$amt, variable_ops),
|
|
|
|
"ret\t$amt",
|
2006-01-09 18:33:28 +00:00
|
|
|
[(X86retflag imm:$amt)]>;
|
2005-12-23 22:14:32 +00:00
|
|
|
}
|
2003-08-03 21:54:21 +00:00
|
|
|
|
|
|
|
// All branches are RawFrm, Void, Branch, and Terminators
|
2007-07-21 00:34:19 +00:00
|
|
|
let isBranch = 1, isTerminator = 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
|
|
|
class IBr<bits<8> opcode, dag ins, string asm, list<dag> pattern> :
|
|
|
|
I<opcode, RawFrm, (outs), ins, asm, pattern>;
|
2003-08-03 21:54:21 +00:00
|
|
|
|
2006-09-07 19:03:48 +00:00
|
|
|
let isBranch = 1, isBarrier = 1 in
|
2007-07-31 20:11:57 +00:00
|
|
|
def JMP : IBr<0xE9, (ins brtarget:$dst), "jmp\t$dst", [(br bb:$dst)]>;
|
2005-12-19 23:12:38 +00:00
|
|
|
|
2007-11-12 07:39:39 +00:00
|
|
|
// Indirect branches
|
|
|
|
let isBranch = 1, isTerminator = 1, isBarrier = 1, isIndirectBranch = 1 in {
|
2007-07-31 20:11:57 +00:00
|
|
|
def JMP32r : I<0xFF, MRM4r, (outs), (ins GR32:$dst), "jmp{l}\t{*}$dst",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(brind GR32:$dst)]>;
|
2007-07-31 20:11:57 +00:00
|
|
|
def JMP32m : I<0xFF, MRM4m, (outs), (ins i32mem:$dst), "jmp{l}\t{*}$dst",
|
2006-09-08 06:48:29 +00:00
|
|
|
[(brind (loadi32 addr:$dst))]>;
|
2006-04-22 18:53:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Conditional branches
|
2007-09-25 01:57:46 +00:00
|
|
|
let Uses = [EFLAGS] in {
|
2007-07-31 20:11:57 +00:00
|
|
|
def JE : IBr<0x84, (ins brtarget:$dst), "je\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_E, EFLAGS)]>, TB;
|
2007-07-31 20:11:57 +00:00
|
|
|
def JNE : IBr<0x85, (ins brtarget:$dst), "jne\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_NE, EFLAGS)]>, TB;
|
2007-07-31 20:11:57 +00:00
|
|
|
def JL : IBr<0x8C, (ins brtarget:$dst), "jl\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_L, EFLAGS)]>, TB;
|
2007-07-31 20:11:57 +00:00
|
|
|
def JLE : IBr<0x8E, (ins brtarget:$dst), "jle\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_LE, EFLAGS)]>, TB;
|
2007-07-31 20:11:57 +00:00
|
|
|
def JG : IBr<0x8F, (ins brtarget:$dst), "jg\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_G, EFLAGS)]>, TB;
|
2007-07-31 20:11:57 +00:00
|
|
|
def JGE : IBr<0x8D, (ins brtarget:$dst), "jge\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_GE, EFLAGS)]>, TB;
|
2005-12-19 23:12:38 +00:00
|
|
|
|
2007-07-31 20:11:57 +00:00
|
|
|
def JB : IBr<0x82, (ins brtarget:$dst), "jb\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_B, EFLAGS)]>, TB;
|
2007-07-31 20:11:57 +00:00
|
|
|
def JBE : IBr<0x86, (ins brtarget:$dst), "jbe\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_BE, EFLAGS)]>, TB;
|
2007-07-31 20:11:57 +00:00
|
|
|
def JA : IBr<0x87, (ins brtarget:$dst), "ja\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_A, EFLAGS)]>, TB;
|
2007-07-31 20:11:57 +00:00
|
|
|
def JAE : IBr<0x83, (ins brtarget:$dst), "jae\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_AE, EFLAGS)]>, TB;
|
2005-12-19 23:12:38 +00:00
|
|
|
|
2007-07-31 20:11:57 +00:00
|
|
|
def JS : IBr<0x88, (ins brtarget:$dst), "js\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_S, EFLAGS)]>, TB;
|
2007-07-31 20:11:57 +00:00
|
|
|
def JNS : IBr<0x89, (ins brtarget:$dst), "jns\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_NS, EFLAGS)]>, TB;
|
2007-07-31 20:11:57 +00:00
|
|
|
def JP : IBr<0x8A, (ins brtarget:$dst), "jp\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_P, EFLAGS)]>, TB;
|
2007-07-31 20:11:57 +00:00
|
|
|
def JNP : IBr<0x8B, (ins brtarget:$dst), "jnp\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_NP, EFLAGS)]>, TB;
|
2007-07-31 20:11:57 +00:00
|
|
|
def JO : IBr<0x80, (ins brtarget:$dst), "jo\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_O, EFLAGS)]>, TB;
|
2007-07-31 20:11:57 +00:00
|
|
|
def JNO : IBr<0x81, (ins brtarget:$dst), "jno\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86brcond bb:$dst, X86_COND_NO, EFLAGS)]>, TB;
|
2007-09-25 01:57:46 +00:00
|
|
|
} // Uses = [EFLAGS]
|
2003-08-03 21:54:21 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Call Instructions...
|
|
|
|
//
|
2007-07-21 00:34:19 +00:00
|
|
|
let isCall = 1 in
|
2008-10-01 18:28:06 +00:00
|
|
|
// All calls clobber the non-callee saved registers. ESP is marked as
|
|
|
|
// a use to prevent stack-pointer assignments that appear immediately
|
|
|
|
// before calls from potentially appearing dead. Uses for argument
|
|
|
|
// registers are added manually.
|
2005-07-06 18:59:04 +00:00
|
|
|
let Defs = [EAX, ECX, EDX, FP0, FP1, FP2, FP3, FP4, FP5, FP6, ST0,
|
2007-04-25 21:31:48 +00:00
|
|
|
MM0, MM1, MM2, MM3, MM4, MM5, MM6, MM7,
|
2008-10-17 21:02:22 +00:00
|
|
|
XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7,
|
|
|
|
XMM8, XMM9, XMM10, XMM11, XMM12, XMM13, XMM14, XMM15, EFLAGS],
|
2008-10-01 04:14:30 +00:00
|
|
|
Uses = [ESP] in {
|
2007-12-22 02:26:46 +00:00
|
|
|
def CALLpcrel32 : Ii32<0xE8, RawFrm, (outs), (ins i32imm:$dst,variable_ops),
|
2009-03-12 18:15:39 +00:00
|
|
|
"call\t${dst:call}", [(X86call imm:$dst)]>,
|
|
|
|
Requires<[In32BitMode]>;
|
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 CALL32r : I<0xFF, MRM2r, (outs), (ins GR32:$dst, variable_ops),
|
2007-07-31 20:11:57 +00:00
|
|
|
"call\t{*}$dst", [(X86call GR32:$dst)]>;
|
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 CALL32m : I<0xFF, MRM2m, (outs), (ins i32mem:$dst, variable_ops),
|
2008-05-29 21:50:34 +00:00
|
|
|
"call\t{*}$dst", [(X86call (loadi32 addr:$dst))]>;
|
2003-08-03 21:54:21 +00:00
|
|
|
}
|
|
|
|
|
2005-05-15 03:10:37 +00:00
|
|
|
// Tail call stuff.
|
2007-10-11 19:40:01 +00:00
|
|
|
|
2008-03-11 03:23:40 +00:00
|
|
|
def TAILCALL : I<0, Pseudo, (outs), (ins),
|
2007-10-11 19:40:01 +00:00
|
|
|
"#TAILCALL",
|
|
|
|
[]>;
|
|
|
|
|
|
|
|
let isCall = 1, isTerminator = 1, isReturn = 1, isBarrier = 1 in
|
2008-03-19 16:39:45 +00:00
|
|
|
def TCRETURNdi : I<0, Pseudo, (outs), (ins i32imm:$dst, i32imm:$offset, variable_ops),
|
2007-10-11 19:40:01 +00:00
|
|
|
"#TC_RETURN $dst $offset",
|
|
|
|
[]>;
|
|
|
|
|
2007-07-21 00:34:19 +00:00
|
|
|
let isCall = 1, isTerminator = 1, isReturn = 1, isBarrier = 1 in
|
2008-03-19 16:39:45 +00:00
|
|
|
def TCRETURNri : I<0, Pseudo, (outs), (ins GR32:$dst, i32imm:$offset, variable_ops),
|
2007-10-11 19:40:01 +00:00
|
|
|
"#TC_RETURN $dst $offset",
|
2006-09-22 21:43:59 +00:00
|
|
|
[]>;
|
2007-10-11 19:40:01 +00:00
|
|
|
|
2007-07-21 00:34:19 +00:00
|
|
|
let isCall = 1, isTerminator = 1, isReturn = 1, isBarrier = 1 in
|
2008-04-30 09:16:33 +00:00
|
|
|
|
2007-10-11 19:40:01 +00:00
|
|
|
def TAILJMPd : IBr<0xE9, (ins i32imm:$dst), "jmp\t${dst:call} # TAILCALL",
|
2006-09-22 21:43:59 +00:00
|
|
|
[]>;
|
2007-10-11 19:40:01 +00:00
|
|
|
let isCall = 1, isTerminator = 1, isReturn = 1, isBarrier = 1 in
|
|
|
|
def TAILJMPr : I<0xFF, MRM4r, (outs), (ins GR32:$dst), "jmp{l}\t{*}$dst # TAILCALL",
|
|
|
|
[]>;
|
2007-07-21 00:34:19 +00:00
|
|
|
let isCall = 1, isTerminator = 1, isReturn = 1, isBarrier = 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 TAILJMPm : I<0xFF, MRM4m, (outs), (ins i32mem:$dst),
|
2007-10-11 19:40:01 +00:00
|
|
|
"jmp\t{*}$dst # TAILCALL", []>;
|
2005-05-15 03:10:37 +00:00
|
|
|
|
2003-08-03 21:54:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Miscellaneous Instructions...
|
|
|
|
//
|
2008-01-10 07:59:24 +00:00
|
|
|
let Defs = [EBP, ESP], Uses = [EBP, ESP], mayLoad = 1, neverHasSideEffects=1 in
|
2004-08-10 20:17:41 +00:00
|
|
|
def LEAVE : I<0xC9, RawFrm,
|
2007-09-11 19:55:27 +00:00
|
|
|
(outs), (ins), "leave", []>;
|
|
|
|
|
2008-01-10 07:59:24 +00:00
|
|
|
let Defs = [ESP], Uses = [ESP], neverHasSideEffects=1 in {
|
|
|
|
let mayLoad = 1 in
|
2007-09-26 01:29:06 +00:00
|
|
|
def POP32r : I<0x58, AddRegFrm, (outs GR32:$reg), (ins), "pop{l}\t$reg", []>;
|
2003-08-03 21:54:21 +00:00
|
|
|
|
2008-01-10 07:59:24 +00:00
|
|
|
let mayStore = 1 in
|
2007-09-26 01:29:06 +00:00
|
|
|
def PUSH32r : I<0x50, AddRegFrm, (outs), (ins GR32:$reg), "push{l}\t$reg",[]>;
|
2007-09-11 19:55:27 +00:00
|
|
|
}
|
2007-04-17 09:20:00 +00:00
|
|
|
|
2008-01-10 07:59:24 +00:00
|
|
|
let Defs = [ESP, EFLAGS], Uses = [ESP], mayLoad = 1, neverHasSideEffects=1 in
|
2007-09-26 21:28:00 +00:00
|
|
|
def POPFD : I<0x9D, RawFrm, (outs), (ins), "popf", []>;
|
2008-01-10 07:59:24 +00:00
|
|
|
let Defs = [ESP], Uses = [ESP, EFLAGS], mayStore = 1, neverHasSideEffects=1 in
|
2007-09-26 21:28:00 +00:00
|
|
|
def PUSHFD : I<0x9C, RawFrm, (outs), (ins), "pushf", []>;
|
2007-09-26 01:29:06 +00:00
|
|
|
|
2006-05-16 07:21:53 +00:00
|
|
|
let isTwoAddress = 1 in // GR32 = bswap GR32
|
2004-08-10 20:17:41 +00:00
|
|
|
def BSWAP32r : I<0xC8, AddRegFrm,
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"bswap{l}\t$dst",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (bswap GR32:$src))]>, TB;
|
2004-08-01 09:52:59 +00:00
|
|
|
|
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}",
|
2007-12-14 08:30:15 +00:00
|
|
|
[(set GR16:$dst, (X86bsf GR16:$src)), (implicit EFLAGS)]>, TB;
|
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}",
|
2007-12-14 08:30:15 +00:00
|
|
|
[(set GR16:$dst, (X86bsf (loadi16 addr:$src))),
|
|
|
|
(implicit EFLAGS)]>, TB;
|
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}",
|
2007-12-14 08:30:15 +00:00
|
|
|
[(set GR32:$dst, (X86bsf GR32:$src)), (implicit EFLAGS)]>, TB;
|
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}",
|
2007-12-14 08:30:15 +00:00
|
|
|
[(set GR32:$dst, (X86bsf (loadi32 addr:$src))),
|
|
|
|
(implicit EFLAGS)]>, TB;
|
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}",
|
2007-12-14 08:30:15 +00:00
|
|
|
[(set GR16:$dst, (X86bsr GR16:$src)), (implicit EFLAGS)]>, TB;
|
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}",
|
2007-12-14 08:30:15 +00:00
|
|
|
[(set GR16:$dst, (X86bsr (loadi16 addr:$src))),
|
|
|
|
(implicit EFLAGS)]>, TB;
|
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}",
|
2007-12-14 08:30:15 +00:00
|
|
|
[(set GR32:$dst, (X86bsr GR32:$src)), (implicit EFLAGS)]>, TB;
|
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}",
|
2007-12-14 08:30:15 +00:00
|
|
|
[(set GR32:$dst, (X86bsr (loadi32 addr:$src))),
|
|
|
|
(implicit EFLAGS)]>, TB;
|
2007-12-14 02:13:44 +00:00
|
|
|
} // Defs = [EFLAGS]
|
|
|
|
|
2008-01-10 07:59:24 +00:00
|
|
|
let neverHasSideEffects = 1 in
|
2004-10-03 20:35:00 +00:00
|
|
|
def LEA16r : I<0x8D, MRMSrcMem,
|
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
|
|
|
(outs GR16:$dst), (ins i32mem:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"lea{w}\t{$src|$dst}, {$dst|$src}", []>, OpSize;
|
2008-03-27 01:41:09 +00:00
|
|
|
let isReMaterializable = 1 in
|
2004-10-03 20:35:00 +00:00
|
|
|
def LEA32r : I<0x8D, MRMSrcMem,
|
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
|
|
|
(outs GR32:$dst), (ins lea32mem:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"lea{l}\t{$src|$dst}, {$dst|$src}",
|
2006-09-08 06:48:29 +00:00
|
|
|
[(set GR32:$dst, lea32addr:$src)]>, Requires<[In32BitMode]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
|
2007-09-11 19:55:27 +00:00
|
|
|
let Defs = [ECX,EDI,ESI], Uses = [ECX,EDI,ESI] 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 REP_MOVSB : I<0xA4, RawFrm, (outs), (ins), "{rep;movsb|rep movsb}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(X86rep_movs i8)]>, REP;
|
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 REP_MOVSW : I<0xA5, RawFrm, (outs), (ins), "{rep;movsw|rep movsw}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(X86rep_movs i16)]>, REP, OpSize;
|
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 REP_MOVSD : I<0xA5, RawFrm, (outs), (ins), "{rep;movsl|rep movsd}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(X86rep_movs i32)]>, REP;
|
|
|
|
}
|
2004-08-10 20:17:41 +00:00
|
|
|
|
2007-09-11 19:55:27 +00:00
|
|
|
let Defs = [ECX,EDI], Uses = [AL,ECX,EDI] 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 REP_STOSB : I<0xAA, RawFrm, (outs), (ins), "{rep;stosb|rep stosb}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(X86rep_stos i8)]>, REP;
|
|
|
|
let Defs = [ECX,EDI], Uses = [AX,ECX,EDI] 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 REP_STOSW : I<0xAB, RawFrm, (outs), (ins), "{rep;stosw|rep stosw}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(X86rep_stos i16)]>, REP, OpSize;
|
|
|
|
let Defs = [ECX,EDI], Uses = [EAX,ECX,EDI] 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 REP_STOSD : I<0xAB, RawFrm, (outs), (ins), "{rep;stosl|rep stosd}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(X86rep_stos i32)]>, REP;
|
2004-08-10 20:17:41 +00:00
|
|
|
|
2007-09-11 19:55:27 +00:00
|
|
|
let Defs = [RAX, RDX] 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 RDTSC : I<0x31, RawFrm, (outs), (ins), "rdtsc", [(X86rdtsc)]>,
|
2007-09-11 19:55:27 +00:00
|
|
|
TB;
|
2004-04-08 20:31:47 +00:00
|
|
|
|
2008-01-15 07:02:33 +00:00
|
|
|
let isBarrier = 1, hasCtrlDep = 1 in {
|
2008-01-15 21:58:22 +00:00
|
|
|
def TRAP : I<0x0B, RawFrm, (outs), (ins), "ud2", [(trap)]>, TB;
|
2008-01-15 07:02:33 +00:00
|
|
|
}
|
|
|
|
|
2004-04-08 20:31:47 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Input/Output Instructions...
|
|
|
|
//
|
2007-09-11 19:55:27 +00:00
|
|
|
let Defs = [AL], Uses = [DX] 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 IN8rr : I<0xEC, RawFrm, (outs), (ins),
|
2007-09-11 19:55:27 +00:00
|
|
|
"in{b}\t{%dx, %al|%AL, %DX}", []>;
|
|
|
|
let Defs = [AX], Uses = [DX] 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 IN16rr : I<0xED, RawFrm, (outs), (ins),
|
2007-09-11 19:55:27 +00:00
|
|
|
"in{w}\t{%dx, %ax|%AX, %DX}", []>, OpSize;
|
|
|
|
let Defs = [EAX], Uses = [DX] 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 IN32rr : I<0xED, RawFrm, (outs), (ins),
|
2007-09-11 19:55:27 +00:00
|
|
|
"in{l}\t{%dx, %eax|%EAX, %DX}", []>;
|
2005-12-20 07:38:38 +00:00
|
|
|
|
2007-09-11 19:55:27 +00:00
|
|
|
let Defs = [AL] 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 IN8ri : Ii8<0xE4, RawFrm, (outs), (ins i16i8imm:$port),
|
2007-09-11 19:55:27 +00:00
|
|
|
"in{b}\t{$port, %al|%AL, $port}", []>;
|
|
|
|
let Defs = [AX] 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 IN16ri : Ii8<0xE5, RawFrm, (outs), (ins i16i8imm:$port),
|
2007-09-11 19:55:27 +00:00
|
|
|
"in{w}\t{$port, %ax|%AX, $port}", []>, OpSize;
|
|
|
|
let Defs = [EAX] 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 IN32ri : Ii8<0xE5, RawFrm, (outs), (ins i16i8imm:$port),
|
2007-09-11 19:55:27 +00:00
|
|
|
"in{l}\t{$port, %eax|%EAX, $port}", []>;
|
2004-08-10 20:17:41 +00:00
|
|
|
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [DX, AL] 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 OUT8rr : I<0xEE, RawFrm, (outs), (ins),
|
2007-09-11 19:55:27 +00:00
|
|
|
"out{b}\t{%al, %dx|%DX, %AL}", []>;
|
|
|
|
let Uses = [DX, AX] 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 OUT16rr : I<0xEF, RawFrm, (outs), (ins),
|
2007-09-11 19:55:27 +00:00
|
|
|
"out{w}\t{%ax, %dx|%DX, %AX}", []>, OpSize;
|
|
|
|
let Uses = [DX, EAX] 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 OUT32rr : I<0xEF, RawFrm, (outs), (ins),
|
2007-09-11 19:55:27 +00:00
|
|
|
"out{l}\t{%eax, %dx|%DX, %EAX}", []>;
|
2005-12-05 23:09:43 +00:00
|
|
|
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [AL] 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 OUT8ir : Ii8<0xE6, RawFrm, (outs), (ins i16i8imm:$port),
|
2007-09-11 19:55:27 +00:00
|
|
|
"out{b}\t{%al, $port|$port, %AL}", []>;
|
|
|
|
let Uses = [AX] 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 OUT16ir : Ii8<0xE7, RawFrm, (outs), (ins i16i8imm:$port),
|
2007-09-11 19:55:27 +00:00
|
|
|
"out{w}\t{%ax, $port|$port, %AX}", []>, OpSize;
|
|
|
|
let Uses = [EAX] 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 OUT32ir : Ii8<0xE7, RawFrm, (outs), (ins i16i8imm:$port),
|
2007-09-11 19:55:27 +00:00
|
|
|
"out{l}\t{%eax, $port|$port, %EAX}", []>;
|
2004-02-14 04:45:37 +00:00
|
|
|
|
2003-08-03 21:54:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Move Instructions...
|
|
|
|
//
|
2008-01-10 07:59:24 +00:00
|
|
|
let neverHasSideEffects = 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 MOV8rr : I<0x88, MRMDestReg, (outs GR8 :$dst), (ins GR8 :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{b}\t{$src, $dst|$dst, $src}", []>;
|
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),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{w}\t{$src, $dst|$dst, $src}", []>, OpSize;
|
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),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mov{l}\t{$src, $dst|$dst, $src}", []>;
|
2008-01-10 07:59:24 +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}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR8:$dst, imm:$src)]>;
|
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}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, imm:$src)]>, OpSize;
|
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}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, imm:$src)]>;
|
2007-06-26 00:48:07 +00:00
|
|
|
}
|
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}",
|
2005-12-10 00:48:20 +00:00
|
|
|
[(store (i8 imm:$src), addr:$dst)]>;
|
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}",
|
2005-12-10 00:48:20 +00:00
|
|
|
[(store (i16 imm:$src), addr:$dst)]>, OpSize;
|
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}",
|
2005-12-10 00:48:20 +00:00
|
|
|
[(store (i32 imm:$src), addr:$dst)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
|
2008-12-03 18:15:48 +00:00
|
|
|
let canFoldAsLoad = 1, isReMaterializable = 1, mayHaveSideEffects = 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 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}",
|
2009-04-10 00:16:23 +00:00
|
|
|
[(set GR8:$dst, (loadi8 addr:$src))]>;
|
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}",
|
2009-04-10 00:16:23 +00:00
|
|
|
[(set GR16:$dst, (loadi16 addr:$src))]>, OpSize;
|
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}",
|
2009-04-10 00:16:23 +00:00
|
|
|
[(set GR32:$dst, (loadi32 addr:$src))]>;
|
2007-08-30 05:49:43 +00:00
|
|
|
}
|
2004-10-03 20:35:00 +00:00
|
|
|
|
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}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(store GR8:$src, addr:$dst)]>;
|
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}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(store GR16:$src, addr:$dst)]>, OpSize;
|
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}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(store GR32:$src, addr:$dst)]>;
|
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-15 00:04:23 +00:00
|
|
|
// Versions of MOV8rr and MOV8mr 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.
|
|
|
|
let neverHasSideEffects = 1 in
|
2009-04-15 19:48:57 +00:00
|
|
|
def MOV8rr_NOREX : I<0x88, MRMDestReg,
|
|
|
|
(outs GR8_NOREX:$dst), (ins GR8_NOREX:$src),
|
2009-04-15 00:04:23 +00:00
|
|
|
"mov{b}\t{$src, $dst|$dst, $src} # NOREX", []>;
|
|
|
|
def MOV8mr_NOREX : I<0x88, MRMDestMem,
|
|
|
|
(outs), (ins i8mem_NOREX:$dst, GR8_NOREX:$src),
|
|
|
|
"mov{b}\t{$src, $dst|$dst, $src} # NOREX", []>;
|
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
|
|
|
|
2003-08-03 21:54:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Fixed-Register Multiplication and Division Instructions...
|
|
|
|
//
|
2003-08-04 04:59:56 +00:00
|
|
|
|
|
|
|
// Extra precision multiplication
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [AL,AH,EFLAGS], Uses = [AL] in
|
2007-07-31 20:11:57 +00:00
|
|
|
def MUL8r : I<0xF6, MRM4r, (outs), (ins GR8:$src), "mul{b}\t$src",
|
2006-01-15 10:05:20 +00:00
|
|
|
// FIXME: Used for 8-bit mul, ignore result upper 8 bits.
|
|
|
|
// This probably ought to be moved to a def : Pat<> if the
|
|
|
|
// syntax can be accepted.
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set AL, (mul AL, GR8:$src)),
|
|
|
|
(implicit EFLAGS)]>; // AL,AH = AL*GR8
|
|
|
|
|
2008-01-11 07:18:17 +00:00
|
|
|
let Defs = [AX,DX,EFLAGS], Uses = [AX], neverHasSideEffects = 1 in
|
2008-12-12 21:15:41 +00:00
|
|
|
def MUL16r : I<0xF7, MRM4r, (outs), (ins GR16:$src),
|
|
|
|
"mul{w}\t$src",
|
|
|
|
[]>, OpSize; // AX,DX = AX*GR16
|
|
|
|
|
2008-01-11 07:18:17 +00:00
|
|
|
let Defs = [EAX,EDX,EFLAGS], Uses = [EAX], neverHasSideEffects = 1 in
|
2008-12-12 21:15:41 +00:00
|
|
|
def MUL32r : I<0xF7, MRM4r, (outs), (ins GR32:$src),
|
|
|
|
"mul{l}\t$src",
|
|
|
|
[]>; // EAX,EDX = EAX*GR32
|
|
|
|
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [AL,AH,EFLAGS], Uses = [AL] 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 MUL8m : I<0xF6, MRM4m, (outs), (ins i8mem :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"mul{b}\t$src",
|
2006-01-15 10:05:20 +00:00
|
|
|
// FIXME: Used for 8-bit mul, ignore result upper 8 bits.
|
|
|
|
// This probably ought to be moved to a def : Pat<> if the
|
|
|
|
// syntax can be accepted.
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set AL, (mul AL, (loadi8 addr:$src))),
|
|
|
|
(implicit EFLAGS)]>; // AL,AH = AL*[mem8]
|
|
|
|
|
2008-01-10 07:59:24 +00:00
|
|
|
let mayLoad = 1, neverHasSideEffects = 1 in {
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [AX,DX,EFLAGS], Uses = [AX] 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 MUL16m : I<0xF7, MRM4m, (outs), (ins i16mem:$src),
|
2008-12-12 21:15:41 +00:00
|
|
|
"mul{w}\t$src",
|
|
|
|
[]>, OpSize; // AX,DX = AX*[mem16]
|
|
|
|
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [EAX,EDX,EFLAGS], Uses = [EAX] 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 MUL32m : I<0xF7, MRM4m, (outs), (ins i32mem:$src),
|
2008-12-12 21:15:41 +00:00
|
|
|
"mul{l}\t$src",
|
|
|
|
[]>; // EAX,EDX = EAX*[mem32]
|
2008-01-10 07:59:24 +00:00
|
|
|
}
|
2003-08-04 04:59:56 +00:00
|
|
|
|
2008-01-10 07:59:24 +00:00
|
|
|
let neverHasSideEffects = 1 in {
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [AL,AH,EFLAGS], Uses = [AL] in
|
2007-09-11 19:55:27 +00:00
|
|
|
def IMUL8r : I<0xF6, MRM5r, (outs), (ins GR8:$src), "imul{b}\t$src", []>;
|
|
|
|
// AL,AH = AL*GR8
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [AX,DX,EFLAGS], Uses = [AX] in
|
2007-07-31 20:11:57 +00:00
|
|
|
def IMUL16r : I<0xF7, MRM5r, (outs), (ins GR16:$src), "imul{w}\t$src", []>,
|
2007-09-11 19:55:27 +00:00
|
|
|
OpSize; // AX,DX = AX*GR16
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [EAX,EDX,EFLAGS], Uses = [EAX] in
|
2007-09-11 19:55:27 +00:00
|
|
|
def IMUL32r : I<0xF7, MRM5r, (outs), (ins GR32:$src), "imul{l}\t$src", []>;
|
|
|
|
// EAX,EDX = EAX*GR32
|
2008-01-10 07:59:24 +00:00
|
|
|
let mayLoad = 1 in {
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [AL,AH,EFLAGS], Uses = [AL] 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 IMUL8m : I<0xF6, MRM5m, (outs), (ins i8mem :$src),
|
2007-09-11 19:55:27 +00:00
|
|
|
"imul{b}\t$src", []>; // AL,AH = AL*[mem8]
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [AX,DX,EFLAGS], Uses = [AX] 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 IMUL16m : I<0xF7, MRM5m, (outs), (ins i16mem:$src),
|
2007-09-11 19:55:27 +00:00
|
|
|
"imul{w}\t$src", []>, OpSize; // AX,DX = AX*[mem16]
|
|
|
|
let Defs = [EAX,EDX], Uses = [EAX] 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 IMUL32m : I<0xF7, MRM5m, (outs), (ins i32mem:$src),
|
2007-09-11 19:55:27 +00:00
|
|
|
"imul{l}\t$src", []>; // EAX,EDX = EAX*[mem32]
|
2008-01-10 07:59:24 +00:00
|
|
|
}
|
2008-11-18 21:29:14 +00:00
|
|
|
} // neverHasSideEffects
|
2005-04-06 04:19:22 +00:00
|
|
|
|
2003-08-04 04:59:56 +00:00
|
|
|
// unsigned division/remainder
|
2008-10-07 18:54:28 +00:00
|
|
|
let Defs = [AL,AH,EFLAGS], Uses = [AX] 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 DIV8r : I<0xF6, MRM6r, (outs), (ins GR8:$src), // AX/r8 = AL,AH
|
2007-09-11 19:55:27 +00:00
|
|
|
"div{b}\t$src", []>;
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] 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 DIV16r : I<0xF7, MRM6r, (outs), (ins GR16:$src), // DX:AX/r16 = AX,DX
|
2007-09-11 19:55:27 +00:00
|
|
|
"div{w}\t$src", []>, OpSize;
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] 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 DIV32r : I<0xF7, MRM6r, (outs), (ins GR32:$src), // EDX:EAX/r32 = EAX,EDX
|
2007-09-11 19:55:27 +00:00
|
|
|
"div{l}\t$src", []>;
|
2008-01-10 07:59:24 +00:00
|
|
|
let mayLoad = 1 in {
|
2008-10-07 18:54:28 +00:00
|
|
|
let Defs = [AL,AH,EFLAGS], Uses = [AX] 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 DIV8m : I<0xF6, MRM6m, (outs), (ins i8mem:$src), // AX/[mem8] = AL,AH
|
2007-09-11 19:55:27 +00:00
|
|
|
"div{b}\t$src", []>;
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] 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 DIV16m : I<0xF7, MRM6m, (outs), (ins i16mem:$src), // DX:AX/[mem16] = AX,DX
|
2007-09-11 19:55:27 +00:00
|
|
|
"div{w}\t$src", []>, OpSize;
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] 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 DIV32m : I<0xF7, MRM6m, (outs), (ins i32mem:$src), // EDX:EAX/[mem32] = EAX,EDX
|
2007-09-11 19:55:27 +00:00
|
|
|
"div{l}\t$src", []>;
|
2008-01-10 07:59:24 +00:00
|
|
|
}
|
2003-08-04 04:59:56 +00:00
|
|
|
|
2004-08-01 09:52:59 +00:00
|
|
|
// Signed division/remainder.
|
2008-10-07 18:54:28 +00:00
|
|
|
let Defs = [AL,AH,EFLAGS], Uses = [AX] 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 IDIV8r : I<0xF6, MRM7r, (outs), (ins GR8:$src), // AX/r8 = AL,AH
|
2007-09-11 19:55:27 +00:00
|
|
|
"idiv{b}\t$src", []>;
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] 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 IDIV16r: I<0xF7, MRM7r, (outs), (ins GR16:$src), // DX:AX/r16 = AX,DX
|
2007-09-11 19:55:27 +00:00
|
|
|
"idiv{w}\t$src", []>, OpSize;
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] 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 IDIV32r: I<0xF7, MRM7r, (outs), (ins GR32:$src), // EDX:EAX/r32 = EAX,EDX
|
2007-09-11 19:55:27 +00:00
|
|
|
"idiv{l}\t$src", []>;
|
2008-01-10 07:59:24 +00:00
|
|
|
let mayLoad = 1, mayLoad = 1 in {
|
2008-10-07 18:54:28 +00:00
|
|
|
let Defs = [AL,AH,EFLAGS], Uses = [AX] 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 IDIV8m : I<0xF6, MRM7m, (outs), (ins i8mem:$src), // AX/[mem8] = AL,AH
|
2007-09-11 19:55:27 +00:00
|
|
|
"idiv{b}\t$src", []>;
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] 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 IDIV16m: I<0xF7, MRM7m, (outs), (ins i16mem:$src), // DX:AX/[mem16] = AX,DX
|
2007-09-11 19:55:27 +00:00
|
|
|
"idiv{w}\t$src", []>, OpSize;
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] 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 IDIV32m: I<0xF7, MRM7m, (outs), (ins i32mem:$src), // EDX:EAX/[mem32] = EAX,EDX
|
2007-09-11 19:55:27 +00:00
|
|
|
"idiv{l}\t$src", []>;
|
2008-01-10 07:59:24 +00:00
|
|
|
}
|
2003-08-03 21:54:21 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2008-01-10 07:59:24 +00:00
|
|
|
// Two address Instructions.
|
2003-08-03 21:54:21 +00:00
|
|
|
//
|
2004-02-28 22:02:05 +00:00
|
|
|
let isTwoAddress = 1 in {
|
|
|
|
|
2004-03-12 17:59:56 +00:00
|
|
|
// Conditional moves
|
2007-09-25 01:57:46 +00:00
|
|
|
let Uses = [EFLAGS] in {
|
2007-10-05 23:13:21 +00:00
|
|
|
let isCommutable = 1 in {
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVB16rr : I<0x42, MRMSrcReg, // if <u, GR16 = GR16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovb\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_B, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVB32rr : I<0x42, MRMSrcReg, // if <u, GR32 = GR32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovb\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_B, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVAE16rr: I<0x43, MRMSrcReg, // if >=u, GR16 = GR16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovae\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_AE, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVAE32rr: I<0x43, MRMSrcReg, // if >=u, GR32 = GR32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovae\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_AE, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVE16rr : I<0x44, MRMSrcReg, // if ==, GR16 = GR16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmove\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_E, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVE32rr : I<0x44, MRMSrcReg, // if ==, GR32 = GR32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmove\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_E, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVNE16rr: I<0x45, MRMSrcReg, // if !=, GR16 = GR16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovne\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_NE, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVNE32rr: I<0x45, MRMSrcReg, // if !=, GR32 = GR32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovne\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_NE, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVBE16rr: I<0x46, MRMSrcReg, // if <=u, GR16 = GR16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovbe\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_BE, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVBE32rr: I<0x46, MRMSrcReg, // if <=u, GR32 = GR32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovbe\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_BE, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVA16rr : I<0x47, MRMSrcReg, // if >u, GR16 = GR16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmova\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_A, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVA32rr : I<0x47, MRMSrcReg, // if >u, GR32 = GR32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmova\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_A, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVL16rr : I<0x4C, MRMSrcReg, // if <s, GR16 = GR16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovl\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_L, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVL32rr : I<0x4C, MRMSrcReg, // if <s, GR32 = GR32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovl\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_L, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVGE16rr: I<0x4D, MRMSrcReg, // if >=s, GR16 = GR16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovge\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_GE, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVGE32rr: I<0x4D, MRMSrcReg, // if >=s, GR32 = GR32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovge\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_GE, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVLE16rr: I<0x4E, MRMSrcReg, // if <=s, GR16 = GR16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovle\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_LE, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVLE32rr: I<0x4E, MRMSrcReg, // if <=s, GR32 = GR32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovle\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_LE, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVG16rr : I<0x4F, MRMSrcReg, // if >s, GR16 = GR16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovg\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_G, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVG32rr : I<0x4F, MRMSrcReg, // if >s, GR32 = GR32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovg\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_G, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVS16rr : I<0x48, MRMSrcReg, // if signed, GR16 = GR16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovs\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_S, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVS32rr : I<0x48, MRMSrcReg, // if signed, GR32 = GR32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovs\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_S, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVNS16rr: I<0x49, MRMSrcReg, // if !signed, GR16 = GR16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovns\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_NS, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVNS32rr: I<0x49, MRMSrcReg, // if !signed, GR32 = GR32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovns\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_NS, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVP16rr : I<0x4A, MRMSrcReg, // if parity, GR16 = GR16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovp\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_P, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVP32rr : I<0x4A, MRMSrcReg, // if parity, GR32 = GR32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovp\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_P, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVNP16rr : I<0x4B, MRMSrcReg, // if !parity, GR16 = GR16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovnp\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_NP, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def CMOVNP32rr : I<0x4B, MRMSrcReg, // if !parity, GR32 = GR32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmovnp\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
2007-09-29 00:00:36 +00:00
|
|
|
X86_COND_NP, EFLAGS))]>,
|
2006-01-26 00:29:36 +00:00
|
|
|
TB;
|
2009-01-07 00:35:10 +00:00
|
|
|
def CMOVO16rr : I<0x40, MRMSrcReg, // if overflow, GR16 = GR16
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
|
|
|
"cmovo\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
|
|
|
X86_COND_O, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVO32rr : I<0x40, MRMSrcReg, // if overflow, GR32 = GR32
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
|
|
|
"cmovo\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
|
|
|
X86_COND_O, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVNO16rr : I<0x41, MRMSrcReg, // if !overflow, GR16 = GR16
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
|
|
|
"cmovno\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, GR16:$src2,
|
|
|
|
X86_COND_NO, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVNO32rr : I<0x41, MRMSrcReg, // if !overflow, GR32 = GR32
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
|
|
|
"cmovno\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, GR32:$src2,
|
|
|
|
X86_COND_NO, EFLAGS))]>,
|
2007-09-25 01:57:46 +00:00
|
|
|
TB;
|
2009-01-07 00:35:10 +00:00
|
|
|
} // isCommutable = 1
|
2007-10-05 23:13:21 +00:00
|
|
|
|
|
|
|
def CMOVB16rm : I<0x42, MRMSrcMem, // if <u, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmovb\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_B, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVB32rm : I<0x42, MRMSrcMem, // if <u, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmovb\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_B, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVAE16rm: I<0x43, MRMSrcMem, // if >=u, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmovae\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_AE, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVAE32rm: I<0x43, MRMSrcMem, // if >=u, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmovae\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_AE, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVE16rm : I<0x44, MRMSrcMem, // if ==, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmove\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_E, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVE32rm : I<0x44, MRMSrcMem, // if ==, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmove\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_E, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVNE16rm: I<0x45, MRMSrcMem, // if !=, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmovne\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_NE, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVNE32rm: I<0x45, MRMSrcMem, // if !=, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmovne\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_NE, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVBE16rm: I<0x46, MRMSrcMem, // if <=u, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmovbe\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_BE, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVBE32rm: I<0x46, MRMSrcMem, // if <=u, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmovbe\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_BE, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVA16rm : I<0x47, MRMSrcMem, // if >u, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmova\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_A, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVA32rm : I<0x47, MRMSrcMem, // if >u, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmova\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_A, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVL16rm : I<0x4C, MRMSrcMem, // if <s, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmovl\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_L, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVL32rm : I<0x4C, MRMSrcMem, // if <s, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmovl\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_L, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVGE16rm: I<0x4D, MRMSrcMem, // if >=s, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmovge\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_GE, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVGE32rm: I<0x4D, MRMSrcMem, // if >=s, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmovge\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_GE, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVLE16rm: I<0x4E, MRMSrcMem, // if <=s, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmovle\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_LE, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVLE32rm: I<0x4E, MRMSrcMem, // if <=s, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmovle\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_LE, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVG16rm : I<0x4F, MRMSrcMem, // if >s, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmovg\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_G, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVG32rm : I<0x4F, MRMSrcMem, // if >s, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmovg\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_G, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVS16rm : I<0x48, MRMSrcMem, // if signed, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmovs\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_S, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVS32rm : I<0x48, MRMSrcMem, // if signed, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmovs\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_S, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVNS16rm: I<0x49, MRMSrcMem, // if !signed, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmovns\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_NS, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVNS32rm: I<0x49, MRMSrcMem, // if !signed, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmovns\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_NS, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVP16rm : I<0x4A, MRMSrcMem, // if parity, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmovp\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_P, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVP32rm : I<0x4A, MRMSrcMem, // if parity, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmovp\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_P, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVNP16rm : I<0x4B, MRMSrcMem, // if !parity, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmovnp\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_NP, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
2009-01-07 00:35:10 +00:00
|
|
|
def CMOVNP32rm : I<0x4B, MRMSrcMem, // if !parity, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmovnp\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_NP, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVO16rm : I<0x40, MRMSrcMem, // if overflow, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmovo\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_O, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVO32rm : I<0x40, MRMSrcMem, // if overflow, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmovo\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_O, EFLAGS))]>,
|
|
|
|
TB;
|
|
|
|
def CMOVNO16rm : I<0x41, MRMSrcMem, // if !overflow, GR16 = [mem16]
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
|
|
|
"cmovno\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR16:$dst, (X86cmov GR16:$src1, (loadi16 addr:$src2),
|
|
|
|
X86_COND_NO, EFLAGS))]>,
|
|
|
|
TB, OpSize;
|
|
|
|
def CMOVNO32rm : I<0x41, MRMSrcMem, // if !overflow, GR32 = [mem32]
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
|
|
|
"cmovno\t{$src2, $dst|$dst, $src2}",
|
|
|
|
[(set GR32:$dst, (X86cmov GR32:$src1, (loadi32 addr:$src2),
|
|
|
|
X86_COND_NO, EFLAGS))]>,
|
|
|
|
TB;
|
2007-09-25 01:57:46 +00:00
|
|
|
} // Uses = [EFLAGS]
|
|
|
|
|
|
|
|
|
2003-10-19 19:25:35 +00:00
|
|
|
// unary instructions
|
2006-07-19 00:27:29 +00:00
|
|
|
let CodeSize = 2 in {
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [EFLAGS] in {
|
2007-07-31 20:11:57 +00:00
|
|
|
def NEG8r : I<0xF6, MRM3r, (outs GR8 :$dst), (ins GR8 :$src), "neg{b}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR8:$dst, (ineg GR8:$src)),
|
|
|
|
(implicit EFLAGS)]>;
|
2007-07-31 20:11:57 +00:00
|
|
|
def NEG16r : I<0xF7, MRM3r, (outs GR16:$dst), (ins GR16:$src), "neg{w}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR16:$dst, (ineg GR16:$src)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2007-07-31 20:11:57 +00:00
|
|
|
def NEG32r : I<0xF7, MRM3r, (outs GR32:$dst), (ins GR32:$src), "neg{l}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR32:$dst, (ineg GR32:$src)),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-08-11 04:31:00 +00:00
|
|
|
let isTwoAddress = 0 in {
|
2007-07-31 20:11:57 +00:00
|
|
|
def NEG8m : I<0xF6, MRM3m, (outs), (ins i8mem :$dst), "neg{b}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (ineg (loadi8 addr:$dst)), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2007-07-31 20:11:57 +00:00
|
|
|
def NEG16m : I<0xF7, MRM3m, (outs), (ins i16mem:$dst), "neg{w}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (ineg (loadi16 addr:$dst)), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2007-07-31 20:11:57 +00:00
|
|
|
def NEG32m : I<0xF7, MRM3m, (outs), (ins i32mem:$dst), "neg{l}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (ineg (loadi32 addr:$dst)), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-08-11 04:31:00 +00:00
|
|
|
}
|
2007-09-14 21:48:26 +00:00
|
|
|
} // Defs = [EFLAGS]
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
2009-01-21 02:09:05 +00:00
|
|
|
// Match xor -1 to not. Favors these over a move imm + xor to save code size.
|
|
|
|
let AddedComplexity = 15 in {
|
2007-07-31 20:11:57 +00:00
|
|
|
def NOT8r : I<0xF6, MRM2r, (outs GR8 :$dst), (ins GR8 :$src), "not{b}\t$dst",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR8:$dst, (not GR8:$src))]>;
|
2007-07-31 20:11:57 +00:00
|
|
|
def NOT16r : I<0xF7, MRM2r, (outs GR16:$dst), (ins GR16:$src), "not{w}\t$dst",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (not GR16:$src))]>, OpSize;
|
2007-07-31 20:11:57 +00:00
|
|
|
def NOT32r : I<0xF7, MRM2r, (outs GR32:$dst), (ins GR32:$src), "not{l}\t$dst",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (not GR32:$src))]>;
|
2009-01-21 02:09:05 +00:00
|
|
|
}
|
2004-08-11 04:31:00 +00:00
|
|
|
let isTwoAddress = 0 in {
|
2007-07-31 20:11:57 +00:00
|
|
|
def NOT8m : I<0xF6, MRM2m, (outs), (ins i8mem :$dst), "not{b}\t$dst",
|
2005-12-13 01:57:51 +00:00
|
|
|
[(store (not (loadi8 addr:$dst)), addr:$dst)]>;
|
2007-07-31 20:11:57 +00:00
|
|
|
def NOT16m : I<0xF7, MRM2m, (outs), (ins i16mem:$dst), "not{w}\t$dst",
|
2005-12-13 01:57:51 +00:00
|
|
|
[(store (not (loadi16 addr:$dst)), addr:$dst)]>, OpSize;
|
2007-07-31 20:11:57 +00:00
|
|
|
def NOT32m : I<0xF7, MRM2m, (outs), (ins i32mem:$dst), "not{l}\t$dst",
|
2005-12-13 01:57:51 +00:00
|
|
|
[(store (not (loadi32 addr:$dst)), addr:$dst)]>;
|
2004-08-11 04:31:00 +00:00
|
|
|
}
|
2006-07-19 00:27:29 +00:00
|
|
|
} // CodeSize
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
2005-12-10 00:48:20 +00:00
|
|
|
// TODO: inc/dec is slow for P4, but fast for Pentium-M.
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [EFLAGS] in {
|
2006-07-19 00:27:29 +00:00
|
|
|
let CodeSize = 2 in
|
2007-07-31 20:11:57 +00:00
|
|
|
def INC8r : I<0xFE, MRM0r, (outs GR8 :$dst), (ins GR8 :$src), "inc{b}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR8:$dst, (add GR8:$src, 1)),
|
|
|
|
(implicit EFLAGS)]>;
|
2006-07-19 00:27:29 +00:00
|
|
|
let isConvertibleToThreeAddress = 1, CodeSize = 1 in { // Can xform into LEA.
|
2007-07-31 20:11:57 +00:00
|
|
|
def INC16r : I<0x40, AddRegFrm, (outs GR16:$dst), (ins GR16:$src), "inc{w}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR16:$dst, (add GR16:$src, 1)),
|
|
|
|
(implicit EFLAGS)]>,
|
2006-09-08 06:48:29 +00:00
|
|
|
OpSize, Requires<[In32BitMode]>;
|
2007-07-31 20:11:57 +00:00
|
|
|
def INC32r : I<0x40, AddRegFrm, (outs GR32:$dst), (ins GR32:$src), "inc{l}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR32:$dst, (add GR32:$src, 1)),
|
|
|
|
(implicit EFLAGS)]>, Requires<[In32BitMode]>;
|
2005-01-02 02:35:46 +00:00
|
|
|
}
|
2006-07-19 00:27:29 +00:00
|
|
|
let isTwoAddress = 0, CodeSize = 2 in {
|
2007-07-31 20:11:57 +00:00
|
|
|
def INC8m : I<0xFE, MRM0m, (outs), (ins i8mem :$dst), "inc{b}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (add (loadi8 addr:$dst), 1), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2007-07-31 20:11:57 +00:00
|
|
|
def INC16m : I<0xFF, MRM0m, (outs), (ins i16mem:$dst), "inc{w}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (add (loadi16 addr:$dst), 1), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>,
|
2007-10-19 21:23:22 +00:00
|
|
|
OpSize, Requires<[In32BitMode]>;
|
2007-07-31 20:11:57 +00:00
|
|
|
def INC32m : I<0xFF, MRM0m, (outs), (ins i32mem:$dst), "inc{l}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (add (loadi32 addr:$dst), 1), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>,
|
2007-10-19 21:23:22 +00:00
|
|
|
Requires<[In32BitMode]>;
|
2004-08-11 04:31:00 +00:00
|
|
|
}
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
2006-07-19 00:27:29 +00:00
|
|
|
let CodeSize = 2 in
|
2007-07-31 20:11:57 +00:00
|
|
|
def DEC8r : I<0xFE, MRM1r, (outs GR8 :$dst), (ins GR8 :$src), "dec{b}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR8:$dst, (add GR8:$src, -1)),
|
|
|
|
(implicit EFLAGS)]>;
|
2006-07-19 00:27:29 +00:00
|
|
|
let isConvertibleToThreeAddress = 1, CodeSize = 1 in { // Can xform into LEA.
|
2007-07-31 20:11:57 +00:00
|
|
|
def DEC16r : I<0x48, AddRegFrm, (outs GR16:$dst), (ins GR16:$src), "dec{w}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR16:$dst, (add GR16:$src, -1)),
|
|
|
|
(implicit EFLAGS)]>,
|
2006-09-08 06:48:29 +00:00
|
|
|
OpSize, Requires<[In32BitMode]>;
|
2007-07-31 20:11:57 +00:00
|
|
|
def DEC32r : I<0x48, AddRegFrm, (outs GR32:$dst), (ins GR32:$src), "dec{l}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR32:$dst, (add GR32:$src, -1)),
|
|
|
|
(implicit EFLAGS)]>, Requires<[In32BitMode]>;
|
2005-01-02 02:35:46 +00:00
|
|
|
}
|
2004-08-11 04:31:00 +00:00
|
|
|
|
2006-07-19 00:27:29 +00:00
|
|
|
let isTwoAddress = 0, CodeSize = 2 in {
|
2007-07-31 20:11:57 +00:00
|
|
|
def DEC8m : I<0xFE, MRM1m, (outs), (ins i8mem :$dst), "dec{b}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (add (loadi8 addr:$dst), -1), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2007-07-31 20:11:57 +00:00
|
|
|
def DEC16m : I<0xFF, MRM1m, (outs), (ins i16mem:$dst), "dec{w}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (add (loadi16 addr:$dst), -1), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>,
|
2007-10-19 21:23:22 +00:00
|
|
|
OpSize, Requires<[In32BitMode]>;
|
2007-07-31 20:11:57 +00:00
|
|
|
def DEC32m : I<0xFF, MRM1m, (outs), (ins i32mem:$dst), "dec{l}\t$dst",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (add (loadi32 addr:$dst), -1), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>,
|
2007-10-19 21:23:22 +00:00
|
|
|
Requires<[In32BitMode]>;
|
2004-08-11 04:31:00 +00:00
|
|
|
}
|
2007-09-14 21:48:26 +00:00
|
|
|
} // Defs = [EFLAGS]
|
2004-02-28 22:02:05 +00:00
|
|
|
|
|
|
|
// Logical operators...
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [EFLAGS] in {
|
2005-01-02 02:35:46 +00:00
|
|
|
let isCommutable = 1 in { // X = AND Y, Z --> X = AND Z, Y
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND8rr : I<0x20, MRMDestReg,
|
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
|
|
|
(outs GR8 :$dst), (ins GR8 :$src1, GR8 :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{b}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR8:$dst, (and GR8:$src1, GR8:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND16rr : I<0x21, MRMDestReg,
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{w}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR16:$dst, (and GR16:$src1, GR16:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND32rr : I<0x21, MRMDestReg,
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{l}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR32:$dst, (and GR32:$src1, GR32:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2005-01-02 02:35:46 +00:00
|
|
|
}
|
2004-10-03 20:35:00 +00:00
|
|
|
|
|
|
|
def AND8rm : I<0x22, MRMSrcMem,
|
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
|
|
|
(outs GR8 :$dst), (ins GR8 :$src1, i8mem :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{b}\t{$src2, $dst|$dst, $src2}",
|
2009-04-10 00:16:23 +00:00
|
|
|
[(set GR8:$dst, (and GR8:$src1, (loadi8 addr:$src2))),
|
2009-03-03 19:53:46 +00:00
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND16rm : I<0x23, MRMSrcMem,
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{w}\t{$src2, $dst|$dst, $src2}",
|
2009-04-10 00:16:23 +00:00
|
|
|
[(set GR16:$dst, (and GR16:$src1, (loadi16 addr:$src2))),
|
2009-03-03 19:53:46 +00:00
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND32rm : I<0x23, MRMSrcMem,
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{l}\t{$src2, $dst|$dst, $src2}",
|
2009-04-10 00:16:23 +00:00
|
|
|
[(set GR32:$dst, (and GR32:$src1, (loadi32 addr:$src2))),
|
2009-03-03 19:53:46 +00:00
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
|
|
|
|
def AND8ri : Ii8<0x80, MRM4r,
|
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
|
|
|
(outs GR8 :$dst), (ins GR8 :$src1, i8imm :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{b}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR8:$dst, (and GR8:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND16ri : Ii16<0x81, MRM4r,
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{w}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR16:$dst, (and GR16:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND32ri : Ii32<0x81, MRM4r,
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{l}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR32:$dst, (and GR32:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND16ri8 : Ii8<0x83, MRM4r,
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{w}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR16:$dst, (and GR16:$src1, i16immSExt8:$src2)),
|
|
|
|
(implicit EFLAGS)]>,
|
2005-12-13 00:14:11 +00:00
|
|
|
OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND32ri8 : Ii8<0x83, MRM4r,
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{l}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR32:$dst, (and GR32:$src1, i32immSExt8:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-08-11 05:07:25 +00:00
|
|
|
|
|
|
|
let isTwoAddress = 0 in {
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND8mr : I<0x20, MRMDestMem,
|
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
|
|
|
(outs), (ins i8mem :$dst, GR8 :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{b}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (and (load addr:$dst), GR8:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND16mr : I<0x21, MRMDestMem,
|
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
|
|
|
(outs), (ins i16mem:$dst, GR16:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{w}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (and (load addr:$dst), GR16:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>,
|
2005-12-13 01:41:36 +00:00
|
|
|
OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND32mr : I<0x21, MRMDestMem,
|
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
|
|
|
(outs), (ins i32mem:$dst, GR32:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{l}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (and (load addr:$dst), GR32:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND8mi : Ii8<0x80, MRM4m,
|
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
|
|
|
(outs), (ins i8mem :$dst, i8imm :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{b}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (and (loadi8 addr:$dst), imm:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND16mi : Ii16<0x81, MRM4m,
|
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
|
|
|
(outs), (ins i16mem:$dst, i16imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{w}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (and (loadi16 addr:$dst), imm:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>,
|
2005-12-13 01:41:36 +00:00
|
|
|
OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND32mi : Ii32<0x81, MRM4m,
|
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
|
|
|
(outs), (ins i32mem:$dst, i32imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{l}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (and (loadi32 addr:$dst), imm:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND16mi8 : Ii8<0x83, MRM4m,
|
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
|
|
|
(outs), (ins i16mem:$dst, i16i8imm :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{w}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (and (load addr:$dst), i16immSExt8:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>,
|
2005-12-13 01:41:36 +00:00
|
|
|
OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def AND32mi8 : Ii8<0x83, MRM4m,
|
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
|
|
|
(outs), (ins i32mem:$dst, i32i8imm :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"and{l}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (and (load addr:$dst), i32immSExt8:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-08-11 05:07:25 +00:00
|
|
|
}
|
|
|
|
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
2005-01-02 02:35:46 +00:00
|
|
|
let isCommutable = 1 in { // X = OR Y, Z --> X = OR Z, Y
|
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 OR8rr : I<0x08, MRMDestReg, (outs GR8 :$dst), (ins GR8 :$src1, GR8 :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{b}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR8:$dst, (or GR8:$src1, GR8:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
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 OR16rr : I<0x09, MRMDestReg, (outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{w}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR16:$dst, (or GR16:$src1, GR16:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
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 OR32rr : I<0x09, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{l}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR32:$dst, (or GR32:$src1, GR32:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2005-01-02 02:35:46 +00:00
|
|
|
}
|
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 OR8rm : I<0x0A, MRMSrcMem , (outs GR8 :$dst), (ins GR8 :$src1, i8mem :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{b}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR8:$dst, (or GR8:$src1, (load addr:$src2))),
|
|
|
|
(implicit EFLAGS)]>;
|
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 OR16rm : I<0x0B, MRMSrcMem , (outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{w}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR16:$dst, (or GR16:$src1, (load addr:$src2))),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
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 OR32rm : I<0x0B, MRMSrcMem , (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{l}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR32:$dst, (or GR32:$src1, (load addr:$src2))),
|
|
|
|
(implicit EFLAGS)]>;
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
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 OR8ri : Ii8 <0x80, MRM1r, (outs GR8 :$dst), (ins GR8 :$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{b}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR8:$dst, (or GR8:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
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 OR16ri : Ii16<0x81, MRM1r, (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{w}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR16:$dst, (or GR16:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
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 OR32ri : Ii32<0x81, MRM1r, (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{l}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR32:$dst, (or GR32:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
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 OR16ri8 : Ii8<0x83, MRM1r, (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{w}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR16:$dst, (or GR16:$src1, i16immSExt8:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
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 OR32ri8 : Ii8<0x83, MRM1r, (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{l}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR32:$dst, (or GR32:$src1, i32immSExt8:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-08-11 04:31:00 +00:00
|
|
|
let isTwoAddress = 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 OR8mr : I<0x08, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{b}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (or (load addr:$dst), GR8:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
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 OR16mr : I<0x09, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{w}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (or (load addr:$dst), GR16:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
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 OR32mr : I<0x09, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{l}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (or (load addr:$dst), GR32:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
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 OR8mi : Ii8<0x80, MRM1m, (outs), (ins i8mem :$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{b}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (or (loadi8 addr:$dst), imm:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
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 OR16mi : Ii16<0x81, MRM1m, (outs), (ins i16mem:$dst, i16imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{w}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (or (loadi16 addr:$dst), imm:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>,
|
2005-12-13 01:41:36 +00:00
|
|
|
OpSize;
|
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 OR32mi : Ii32<0x81, MRM1m, (outs), (ins i32mem:$dst, i32imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{l}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (or (loadi32 addr:$dst), imm:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
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 OR16mi8 : Ii8<0x83, MRM1m, (outs), (ins i16mem:$dst, i16i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{w}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (or (load addr:$dst), i16immSExt8:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>,
|
2005-12-13 01:41:36 +00:00
|
|
|
OpSize;
|
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 OR32mi8 : Ii8<0x83, MRM1m, (outs), (ins i32mem:$dst, i32i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"or{l}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (or (load addr:$dst), i32immSExt8:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-05-29 01:02:09 +00:00
|
|
|
} // isTwoAddress = 0
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
|
|
|
|
2008-06-18 08:13:07 +00:00
|
|
|
let isCommutable = 1 in { // X = XOR Y, Z --> X = XOR Z, Y
|
2008-05-29 01:02:09 +00:00
|
|
|
def XOR8rr : I<0x30, MRMDestReg,
|
|
|
|
(outs GR8 :$dst), (ins GR8 :$src1, GR8 :$src2),
|
|
|
|
"xor{b}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR8:$dst, (xor GR8:$src1, GR8:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-05-29 01:02:09 +00:00
|
|
|
def XOR16rr : I<0x31, MRMDestReg,
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
|
|
|
"xor{w}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR16:$dst, (xor GR16:$src1, GR16:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2008-05-29 01:02:09 +00:00
|
|
|
def XOR32rr : I<0x31, MRMDestReg,
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
|
|
|
"xor{l}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR32:$dst, (xor GR32:$src1, GR32:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-06-18 08:13:07 +00:00
|
|
|
} // isCommutable = 1
|
2005-01-02 02:35:46 +00:00
|
|
|
|
2004-10-03 20:35:00 +00:00
|
|
|
def XOR8rm : I<0x32, MRMSrcMem ,
|
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
|
|
|
(outs GR8 :$dst), (ins GR8:$src1, i8mem :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"xor{b}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR8:$dst, (xor GR8:$src1, (load addr:$src2))),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def XOR16rm : I<0x33, MRMSrcMem ,
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"xor{w}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR16:$dst, (xor GR16:$src1, (load addr:$src2))),
|
|
|
|
(implicit EFLAGS)]>,
|
2008-05-29 01:02:09 +00:00
|
|
|
OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def XOR32rm : I<0x33, MRMSrcMem ,
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"xor{l}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR32:$dst, (xor GR32:$src1, (load addr:$src2))),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
|
2008-05-29 03:46:36 +00:00
|
|
|
def XOR8ri : Ii8<0x80, MRM6r,
|
|
|
|
(outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
|
|
|
|
"xor{b}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR8:$dst, (xor GR8:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-05-29 03:46:36 +00:00
|
|
|
def XOR16ri : Ii16<0x81, MRM6r,
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
|
|
|
|
"xor{w}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR16:$dst, (xor GR16:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2008-05-29 03:46:36 +00:00
|
|
|
def XOR32ri : Ii32<0x81, MRM6r,
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
|
|
|
|
"xor{l}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR32:$dst, (xor GR32:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-05-29 03:46:36 +00:00
|
|
|
def XOR16ri8 : Ii8<0x83, MRM6r,
|
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
|
|
|
|
"xor{w}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR16:$dst, (xor GR16:$src1, i16immSExt8:$src2)),
|
|
|
|
(implicit EFLAGS)]>,
|
2008-05-29 03:46:36 +00:00
|
|
|
OpSize;
|
|
|
|
def XOR32ri8 : Ii8<0x83, MRM6r,
|
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
|
|
|
|
"xor{l}\t{$src2, $dst|$dst, $src2}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(set GR32:$dst, (xor GR32:$src1, i32immSExt8:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-05-29 01:02:09 +00:00
|
|
|
|
2004-08-11 04:31:00 +00:00
|
|
|
let isTwoAddress = 0 in {
|
2004-10-03 20:35:00 +00:00
|
|
|
def XOR8mr : I<0x30, MRMDestMem,
|
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
|
|
|
(outs), (ins i8mem :$dst, GR8 :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"xor{b}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (xor (load addr:$dst), GR8:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def XOR16mr : I<0x31, MRMDestMem,
|
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
|
|
|
(outs), (ins i16mem:$dst, GR16:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"xor{w}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (xor (load addr:$dst), GR16:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>,
|
2005-12-13 01:41:36 +00:00
|
|
|
OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def XOR32mr : I<0x31, MRMDestMem,
|
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
|
|
|
(outs), (ins i32mem:$dst, GR32:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"xor{l}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (xor (load addr:$dst), GR32:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def XOR8mi : Ii8<0x80, MRM6m,
|
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
|
|
|
(outs), (ins i8mem :$dst, i8imm :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"xor{b}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (xor (loadi8 addr:$dst), imm:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def XOR16mi : Ii16<0x81, MRM6m,
|
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
|
|
|
(outs), (ins i16mem:$dst, i16imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"xor{w}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (xor (loadi16 addr:$dst), imm:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>,
|
2005-12-13 01:41:36 +00:00
|
|
|
OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def XOR32mi : Ii32<0x81, MRM6m,
|
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
|
|
|
(outs), (ins i32mem:$dst, i32imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"xor{l}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (xor (loadi32 addr:$dst), imm:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def XOR16mi8 : Ii8<0x83, MRM6m,
|
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
|
|
|
(outs), (ins i16mem:$dst, i16i8imm :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"xor{w}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (xor (load addr:$dst), i16immSExt8:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>,
|
2005-12-13 01:41:36 +00:00
|
|
|
OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def XOR32mi8 : Ii8<0x83, MRM6m,
|
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
|
|
|
(outs), (ins i32mem:$dst, i32i8imm :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"xor{l}\t{$src, $dst|$dst, $src}",
|
2009-03-03 19:53:46 +00:00
|
|
|
[(store (xor (load addr:$dst), i32immSExt8:$src), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-05-29 01:02:09 +00:00
|
|
|
} // isTwoAddress = 0
|
2007-09-14 21:48:26 +00:00
|
|
|
} // Defs = [EFLAGS]
|
2003-10-19 19:25:35 +00:00
|
|
|
|
2004-02-28 22:02:05 +00:00
|
|
|
// Shift instructions
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [EFLAGS] in {
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [CL] 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 SHL8rCL : I<0xD2, MRM4r, (outs GR8 :$dst), (ins GR8 :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{b}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR8:$dst, (shl GR8:$src, CL))]>;
|
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 SHL16rCL : I<0xD3, MRM4r, (outs GR16:$dst), (ins GR16:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{w}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR16:$dst, (shl GR16:$src, CL))]>, OpSize;
|
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 SHL32rCL : I<0xD3, MRM4r, (outs GR32:$dst), (ins GR32:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{l}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR32:$dst, (shl GR32:$src, CL))]>;
|
2008-05-29 01:02:09 +00:00
|
|
|
} // Uses = [CL]
|
2005-01-02 02:35:46 +00:00
|
|
|
|
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 SHL8ri : Ii8<0xC0, MRM4r, (outs GR8 :$dst), (ins GR8 :$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{b}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR8:$dst, (shl GR8:$src1, (i8 imm:$src2)))]>;
|
2005-01-02 02:35:46 +00:00
|
|
|
let isConvertibleToThreeAddress = 1 in { // Can transform into LEA.
|
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 SHL16ri : Ii8<0xC1, MRM4r, (outs GR16:$dst), (ins GR16:$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{w}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (shl GR16:$src1, (i8 imm:$src2)))]>, OpSize;
|
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 SHL32ri : Ii8<0xC1, MRM4r, (outs GR32:$dst), (ins GR32:$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{l}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (shl GR32:$src1, (i8 imm:$src2)))]>;
|
2008-01-11 18:00:50 +00:00
|
|
|
// NOTE: We don't use shifts of a register by one, because 'add reg,reg' is
|
|
|
|
// cheaper.
|
2008-05-29 01:02:09 +00:00
|
|
|
} // isConvertibleToThreeAddress = 1
|
2006-06-29 00:36:51 +00:00
|
|
|
|
2004-08-11 05:07:25 +00:00
|
|
|
let isTwoAddress = 0 in {
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [CL] 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 SHL8mCL : I<0xD2, MRM4m, (outs), (ins i8mem :$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{b}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(store (shl (loadi8 addr:$dst), CL), addr:$dst)]>;
|
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 SHL16mCL : I<0xD3, MRM4m, (outs), (ins i16mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{w}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(store (shl (loadi16 addr:$dst), CL), addr:$dst)]>, OpSize;
|
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 SHL32mCL : I<0xD3, MRM4m, (outs), (ins i32mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{l}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(store (shl (loadi32 addr:$dst), CL), addr:$dst)]>;
|
|
|
|
}
|
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 SHL8mi : Ii8<0xC0, MRM4m, (outs), (ins i8mem :$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{b}\t{$src, $dst|$dst, $src}",
|
2005-12-13 02:34:51 +00:00
|
|
|
[(store (shl (loadi8 addr:$dst), (i8 imm:$src)), addr:$dst)]>;
|
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 SHL16mi : Ii8<0xC1, MRM4m, (outs), (ins i16mem:$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{w}\t{$src, $dst|$dst, $src}",
|
2005-12-13 02:34:51 +00:00
|
|
|
[(store (shl (loadi16 addr:$dst), (i8 imm:$src)), addr:$dst)]>,
|
|
|
|
OpSize;
|
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 SHL32mi : Ii8<0xC1, MRM4m, (outs), (ins i32mem:$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{l}\t{$src, $dst|$dst, $src}",
|
2005-12-13 02:34:51 +00:00
|
|
|
[(store (shl (loadi32 addr:$dst), (i8 imm:$src)), addr:$dst)]>;
|
2006-06-29 00:36:51 +00:00
|
|
|
|
|
|
|
// Shift by 1
|
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 SHL8m1 : I<0xD0, MRM4m, (outs), (ins i8mem :$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{b}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (shl (loadi8 addr:$dst), (i8 1)), addr:$dst)]>;
|
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 SHL16m1 : I<0xD1, MRM4m, (outs), (ins i16mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{w}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (shl (loadi16 addr:$dst), (i8 1)), addr:$dst)]>,
|
|
|
|
OpSize;
|
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 SHL32m1 : I<0xD1, MRM4m, (outs), (ins i32mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shl{l}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (shl (loadi32 addr:$dst), (i8 1)), addr:$dst)]>;
|
2004-08-11 05:07:25 +00:00
|
|
|
}
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [CL] 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 SHR8rCL : I<0xD2, MRM5r, (outs GR8 :$dst), (ins GR8 :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{b}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR8:$dst, (srl GR8:$src, CL))]>;
|
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 SHR16rCL : I<0xD3, MRM5r, (outs GR16:$dst), (ins GR16:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{w}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR16:$dst, (srl GR16:$src, CL))]>, OpSize;
|
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 SHR32rCL : I<0xD3, MRM5r, (outs GR32:$dst), (ins GR32:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{l}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR32:$dst, (srl GR32:$src, CL))]>;
|
|
|
|
}
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
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 SHR8ri : Ii8<0xC0, MRM5r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{b}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR8:$dst, (srl GR8:$src1, (i8 imm:$src2)))]>;
|
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 SHR16ri : Ii8<0xC1, MRM5r, (outs GR16:$dst), (ins GR16:$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{w}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (srl GR16:$src1, (i8 imm:$src2)))]>, OpSize;
|
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 SHR32ri : Ii8<0xC1, MRM5r, (outs GR32:$dst), (ins GR32:$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{l}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (srl GR32:$src1, (i8 imm:$src2)))]>;
|
2004-08-11 05:07:25 +00:00
|
|
|
|
2006-06-29 00:36:51 +00:00
|
|
|
// Shift by 1
|
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 SHR8r1 : I<0xD0, MRM5r, (outs GR8:$dst), (ins GR8:$src1),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{b}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(set GR8:$dst, (srl GR8:$src1, (i8 1)))]>;
|
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 SHR16r1 : I<0xD1, MRM5r, (outs GR16:$dst), (ins GR16:$src1),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{w}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(set GR16:$dst, (srl GR16:$src1, (i8 1)))]>, OpSize;
|
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 SHR32r1 : I<0xD1, MRM5r, (outs GR32:$dst), (ins GR32:$src1),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{l}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(set GR32:$dst, (srl GR32:$src1, (i8 1)))]>;
|
|
|
|
|
2004-08-11 04:31:00 +00:00
|
|
|
let isTwoAddress = 0 in {
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [CL] 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 SHR8mCL : I<0xD2, MRM5m, (outs), (ins i8mem :$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{b}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(store (srl (loadi8 addr:$dst), CL), addr:$dst)]>;
|
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 SHR16mCL : I<0xD3, MRM5m, (outs), (ins i16mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{w}\t{%cl, $dst|$dst, %CL}",
|
2005-12-13 07:24:22 +00:00
|
|
|
[(store (srl (loadi16 addr:$dst), CL), addr:$dst)]>,
|
2007-09-11 19:55:27 +00:00
|
|
|
OpSize;
|
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 SHR32mCL : I<0xD3, MRM5m, (outs), (ins i32mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{l}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(store (srl (loadi32 addr:$dst), CL), addr:$dst)]>;
|
|
|
|
}
|
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 SHR8mi : Ii8<0xC0, MRM5m, (outs), (ins i8mem :$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{b}\t{$src, $dst|$dst, $src}",
|
2005-12-13 07:24:22 +00:00
|
|
|
[(store (srl (loadi8 addr:$dst), (i8 imm:$src)), addr:$dst)]>;
|
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 SHR16mi : Ii8<0xC1, MRM5m, (outs), (ins i16mem:$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{w}\t{$src, $dst|$dst, $src}",
|
2005-12-13 07:24:22 +00:00
|
|
|
[(store (srl (loadi16 addr:$dst), (i8 imm:$src)), addr:$dst)]>,
|
|
|
|
OpSize;
|
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 SHR32mi : Ii8<0xC1, MRM5m, (outs), (ins i32mem:$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{l}\t{$src, $dst|$dst, $src}",
|
2005-12-13 07:24:22 +00:00
|
|
|
[(store (srl (loadi32 addr:$dst), (i8 imm:$src)), addr:$dst)]>;
|
2006-06-29 00:36:51 +00:00
|
|
|
|
|
|
|
// Shift by 1
|
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 SHR8m1 : I<0xD0, MRM5m, (outs), (ins i8mem :$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{b}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (srl (loadi8 addr:$dst), (i8 1)), addr:$dst)]>;
|
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 SHR16m1 : I<0xD1, MRM5m, (outs), (ins i16mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{w}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (srl (loadi16 addr:$dst), (i8 1)), addr:$dst)]>,OpSize;
|
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 SHR32m1 : I<0xD1, MRM5m, (outs), (ins i32mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shr{l}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (srl (loadi32 addr:$dst), (i8 1)), addr:$dst)]>;
|
2004-08-11 04:31:00 +00:00
|
|
|
}
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [CL] 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 SAR8rCL : I<0xD2, MRM7r, (outs GR8 :$dst), (ins GR8 :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{b}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR8:$dst, (sra GR8:$src, CL))]>;
|
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 SAR16rCL : I<0xD3, MRM7r, (outs GR16:$dst), (ins GR16:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{w}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR16:$dst, (sra GR16:$src, CL))]>, OpSize;
|
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 SAR32rCL : I<0xD3, MRM7r, (outs GR32:$dst), (ins GR32:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{l}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR32:$dst, (sra GR32:$src, CL))]>;
|
|
|
|
}
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
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 SAR8ri : Ii8<0xC0, MRM7r, (outs GR8 :$dst), (ins GR8 :$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{b}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR8:$dst, (sra GR8:$src1, (i8 imm:$src2)))]>;
|
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 SAR16ri : Ii8<0xC1, MRM7r, (outs GR16:$dst), (ins GR16:$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{w}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (sra GR16:$src1, (i8 imm:$src2)))]>,
|
2005-12-05 02:40:25 +00:00
|
|
|
OpSize;
|
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 SAR32ri : Ii8<0xC1, MRM7r, (outs GR32:$dst), (ins GR32:$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{l}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (sra GR32:$src1, (i8 imm:$src2)))]>;
|
2006-06-29 00:36:51 +00:00
|
|
|
|
|
|
|
// Shift by 1
|
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 SAR8r1 : I<0xD0, MRM7r, (outs GR8 :$dst), (ins GR8 :$src1),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{b}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(set GR8:$dst, (sra GR8:$src1, (i8 1)))]>;
|
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 SAR16r1 : I<0xD1, MRM7r, (outs GR16:$dst), (ins GR16:$src1),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{w}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(set GR16:$dst, (sra GR16:$src1, (i8 1)))]>, OpSize;
|
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 SAR32r1 : I<0xD1, MRM7r, (outs GR32:$dst), (ins GR32:$src1),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{l}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(set GR32:$dst, (sra GR32:$src1, (i8 1)))]>;
|
|
|
|
|
2004-08-11 05:07:25 +00:00
|
|
|
let isTwoAddress = 0 in {
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [CL] 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 SAR8mCL : I<0xD2, MRM7m, (outs), (ins i8mem :$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{b}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(store (sra (loadi8 addr:$dst), CL), addr:$dst)]>;
|
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 SAR16mCL : I<0xD3, MRM7m, (outs), (ins i16mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{w}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(store (sra (loadi16 addr:$dst), CL), addr:$dst)]>, OpSize;
|
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 SAR32mCL : I<0xD3, MRM7m, (outs), (ins i32mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{l}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(store (sra (loadi32 addr:$dst), CL), addr:$dst)]>;
|
|
|
|
}
|
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 SAR8mi : Ii8<0xC0, MRM7m, (outs), (ins i8mem :$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{b}\t{$src, $dst|$dst, $src}",
|
2005-12-13 07:24:22 +00:00
|
|
|
[(store (sra (loadi8 addr:$dst), (i8 imm:$src)), addr:$dst)]>;
|
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 SAR16mi : Ii8<0xC1, MRM7m, (outs), (ins i16mem:$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{w}\t{$src, $dst|$dst, $src}",
|
2005-12-13 07:24:22 +00:00
|
|
|
[(store (sra (loadi16 addr:$dst), (i8 imm:$src)), addr:$dst)]>,
|
|
|
|
OpSize;
|
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 SAR32mi : Ii8<0xC1, MRM7m, (outs), (ins i32mem:$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{l}\t{$src, $dst|$dst, $src}",
|
2005-12-13 07:24:22 +00:00
|
|
|
[(store (sra (loadi32 addr:$dst), (i8 imm:$src)), addr:$dst)]>;
|
2006-06-29 00:36:51 +00:00
|
|
|
|
|
|
|
// Shift by 1
|
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 SAR8m1 : I<0xD0, MRM7m, (outs), (ins i8mem :$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{b}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (sra (loadi8 addr:$dst), (i8 1)), addr:$dst)]>;
|
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 SAR16m1 : I<0xD1, MRM7m, (outs), (ins i16mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{w}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (sra (loadi16 addr:$dst), (i8 1)), addr:$dst)]>,
|
|
|
|
OpSize;
|
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 SAR32m1 : I<0xD1, MRM7m, (outs), (ins i32mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sar{l}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (sra (loadi32 addr:$dst), (i8 1)), addr:$dst)]>;
|
2004-08-11 05:07:25 +00:00
|
|
|
}
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
2005-01-19 07:50:03 +00:00
|
|
|
// Rotate instructions
|
|
|
|
// FIXME: provide shorter instructions when imm8 == 1
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [CL] 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 ROL8rCL : I<0xD2, MRM0r, (outs GR8 :$dst), (ins GR8 :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{b}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR8:$dst, (rotl GR8:$src, CL))]>;
|
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 ROL16rCL : I<0xD3, MRM0r, (outs GR16:$dst), (ins GR16:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{w}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR16:$dst, (rotl GR16:$src, CL))]>, OpSize;
|
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 ROL32rCL : I<0xD3, MRM0r, (outs GR32:$dst), (ins GR32:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{l}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR32:$dst, (rotl GR32:$src, CL))]>;
|
|
|
|
}
|
2005-01-19 07:50:03 +00:00
|
|
|
|
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 ROL8ri : Ii8<0xC0, MRM0r, (outs GR8 :$dst), (ins GR8 :$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{b}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR8:$dst, (rotl GR8:$src1, (i8 imm:$src2)))]>;
|
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 ROL16ri : Ii8<0xC1, MRM0r, (outs GR16:$dst), (ins GR16:$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{w}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (rotl GR16:$src1, (i8 imm:$src2)))]>, OpSize;
|
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 ROL32ri : Ii8<0xC1, MRM0r, (outs GR32:$dst), (ins GR32:$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{l}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (rotl GR32:$src1, (i8 imm:$src2)))]>;
|
2005-01-19 07:50:03 +00:00
|
|
|
|
2006-06-29 00:36:51 +00:00
|
|
|
// Rotate by 1
|
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 ROL8r1 : I<0xD0, MRM0r, (outs GR8 :$dst), (ins GR8 :$src1),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{b}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(set GR8:$dst, (rotl GR8:$src1, (i8 1)))]>;
|
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 ROL16r1 : I<0xD1, MRM0r, (outs GR16:$dst), (ins GR16:$src1),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{w}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(set GR16:$dst, (rotl GR16:$src1, (i8 1)))]>, OpSize;
|
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 ROL32r1 : I<0xD1, MRM0r, (outs GR32:$dst), (ins GR32:$src1),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{l}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(set GR32:$dst, (rotl GR32:$src1, (i8 1)))]>;
|
|
|
|
|
2005-01-19 07:50:03 +00:00
|
|
|
let isTwoAddress = 0 in {
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [CL] 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 ROL8mCL : I<0xD2, MRM0m, (outs), (ins i8mem :$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{b}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(store (rotl (loadi8 addr:$dst), CL), addr:$dst)]>;
|
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 ROL16mCL : I<0xD3, MRM0m, (outs), (ins i16mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{w}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(store (rotl (loadi16 addr:$dst), CL), addr:$dst)]>, OpSize;
|
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 ROL32mCL : I<0xD3, MRM0m, (outs), (ins i32mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{l}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(store (rotl (loadi32 addr:$dst), CL), addr:$dst)]>;
|
|
|
|
}
|
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 ROL8mi : Ii8<0xC0, MRM0m, (outs), (ins i8mem :$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{b}\t{$src, $dst|$dst, $src}",
|
2006-01-11 23:20:05 +00:00
|
|
|
[(store (rotl (loadi8 addr:$dst), (i8 imm:$src)), addr:$dst)]>;
|
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 ROL16mi : Ii8<0xC1, MRM0m, (outs), (ins i16mem:$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{w}\t{$src, $dst|$dst, $src}",
|
2006-01-11 23:20:05 +00:00
|
|
|
[(store (rotl (loadi16 addr:$dst), (i8 imm:$src)), addr:$dst)]>,
|
|
|
|
OpSize;
|
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 ROL32mi : Ii8<0xC1, MRM0m, (outs), (ins i32mem:$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{l}\t{$src, $dst|$dst, $src}",
|
2006-01-11 23:20:05 +00:00
|
|
|
[(store (rotl (loadi32 addr:$dst), (i8 imm:$src)), addr:$dst)]>;
|
2006-06-29 00:36:51 +00:00
|
|
|
|
|
|
|
// Rotate by 1
|
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 ROL8m1 : I<0xD0, MRM0m, (outs), (ins i8mem :$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{b}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (rotl (loadi8 addr:$dst), (i8 1)), addr:$dst)]>;
|
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 ROL16m1 : I<0xD1, MRM0m, (outs), (ins i16mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{w}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (rotl (loadi16 addr:$dst), (i8 1)), addr:$dst)]>,
|
|
|
|
OpSize;
|
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 ROL32m1 : I<0xD1, MRM0m, (outs), (ins i32mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"rol{l}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (rotl (loadi32 addr:$dst), (i8 1)), addr:$dst)]>;
|
2005-01-19 07:50:03 +00:00
|
|
|
}
|
|
|
|
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [CL] 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 ROR8rCL : I<0xD2, MRM1r, (outs GR8 :$dst), (ins GR8 :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{b}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR8:$dst, (rotr GR8:$src, CL))]>;
|
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 ROR16rCL : I<0xD3, MRM1r, (outs GR16:$dst), (ins GR16:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{w}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR16:$dst, (rotr GR16:$src, CL))]>, OpSize;
|
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 ROR32rCL : I<0xD3, MRM1r, (outs GR32:$dst), (ins GR32:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{l}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR32:$dst, (rotr GR32:$src, CL))]>;
|
|
|
|
}
|
2005-01-19 07:50:03 +00:00
|
|
|
|
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 ROR8ri : Ii8<0xC0, MRM1r, (outs GR8 :$dst), (ins GR8 :$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{b}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR8:$dst, (rotr GR8:$src1, (i8 imm:$src2)))]>;
|
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 ROR16ri : Ii8<0xC1, MRM1r, (outs GR16:$dst), (ins GR16:$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{w}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (rotr GR16:$src1, (i8 imm:$src2)))]>, OpSize;
|
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 ROR32ri : Ii8<0xC1, MRM1r, (outs GR32:$dst), (ins GR32:$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{l}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (rotr GR32:$src1, (i8 imm:$src2)))]>;
|
2006-06-29 00:36:51 +00:00
|
|
|
|
|
|
|
// Rotate by 1
|
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 ROR8r1 : I<0xD0, MRM1r, (outs GR8 :$dst), (ins GR8 :$src1),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{b}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(set GR8:$dst, (rotr GR8:$src1, (i8 1)))]>;
|
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 ROR16r1 : I<0xD1, MRM1r, (outs GR16:$dst), (ins GR16:$src1),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{w}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(set GR16:$dst, (rotr GR16:$src1, (i8 1)))]>, OpSize;
|
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 ROR32r1 : I<0xD1, MRM1r, (outs GR32:$dst), (ins GR32:$src1),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{l}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(set GR32:$dst, (rotr GR32:$src1, (i8 1)))]>;
|
|
|
|
|
2005-01-19 07:50:03 +00:00
|
|
|
let isTwoAddress = 0 in {
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [CL] 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 ROR8mCL : I<0xD2, MRM1m, (outs), (ins i8mem :$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{b}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(store (rotr (loadi8 addr:$dst), CL), addr:$dst)]>;
|
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 ROR16mCL : I<0xD3, MRM1m, (outs), (ins i16mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{w}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(store (rotr (loadi16 addr:$dst), CL), addr:$dst)]>, OpSize;
|
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 ROR32mCL : I<0xD3, MRM1m, (outs), (ins i32mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{l}\t{%cl, $dst|$dst, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(store (rotr (loadi32 addr:$dst), CL), addr:$dst)]>;
|
|
|
|
}
|
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 ROR8mi : Ii8<0xC0, MRM1m, (outs), (ins i8mem :$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{b}\t{$src, $dst|$dst, $src}",
|
2006-01-11 23:20:05 +00:00
|
|
|
[(store (rotr (loadi8 addr:$dst), (i8 imm:$src)), addr:$dst)]>;
|
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 ROR16mi : Ii8<0xC1, MRM1m, (outs), (ins i16mem:$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{w}\t{$src, $dst|$dst, $src}",
|
2006-01-11 23:20:05 +00:00
|
|
|
[(store (rotr (loadi16 addr:$dst), (i8 imm:$src)), addr:$dst)]>,
|
|
|
|
OpSize;
|
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 ROR32mi : Ii8<0xC1, MRM1m, (outs), (ins i32mem:$dst, i8imm:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{l}\t{$src, $dst|$dst, $src}",
|
2006-01-11 23:20:05 +00:00
|
|
|
[(store (rotr (loadi32 addr:$dst), (i8 imm:$src)), addr:$dst)]>;
|
2006-06-29 00:36:51 +00:00
|
|
|
|
|
|
|
// Rotate by 1
|
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 ROR8m1 : I<0xD0, MRM1m, (outs), (ins i8mem :$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{b}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (rotr (loadi8 addr:$dst), (i8 1)), addr:$dst)]>;
|
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 ROR16m1 : I<0xD1, MRM1m, (outs), (ins i16mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{w}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (rotr (loadi16 addr:$dst), (i8 1)), addr:$dst)]>,
|
|
|
|
OpSize;
|
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 ROR32m1 : I<0xD1, MRM1m, (outs), (ins i32mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ror{l}\t$dst",
|
2006-06-29 00:36:51 +00:00
|
|
|
[(store (rotr (loadi32 addr:$dst), (i8 1)), addr:$dst)]>;
|
2005-01-19 07:50:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Double shift instructions (generalizations of rotate)
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [CL] 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 SHLD32rrCL : I<0xA5, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shld{l}\t{%cl, $src2, $dst|$dst, $src2, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR32:$dst, (X86shld GR32:$src1, GR32:$src2, CL))]>, TB;
|
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 SHRD32rrCL : I<0xAD, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shrd{l}\t{%cl, $src2, $dst|$dst, $src2, %CL}",
|
2007-09-11 19:55:27 +00:00
|
|
|
[(set GR32:$dst, (X86shrd GR32:$src1, GR32:$src2, CL))]>, TB;
|
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 SHLD16rrCL : I<0xA5, MRMDestReg, (outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shld{w}\t{%cl, $src2, $dst|$dst, $src2, %CL}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86shld GR16:$src1, GR16:$src2, CL))]>,
|
2007-09-11 19:55:27 +00:00
|
|
|
TB, OpSize;
|
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 SHRD16rrCL : I<0xAD, MRMDestReg, (outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shrd{w}\t{%cl, $src2, $dst|$dst, $src2, %CL}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86shrd GR16:$src1, GR16:$src2, CL))]>,
|
2007-09-11 19:55:27 +00:00
|
|
|
TB, OpSize;
|
|
|
|
}
|
Teach the code generator that shrd/shld is commutable if it has an immediate.
This allows us to generate this:
foo:
mov %EAX, DWORD PTR [%ESP + 4]
mov %EDX, DWORD PTR [%ESP + 8]
shld %EDX, %EDX, 2
shl %EAX, 2
ret
instead of this:
foo:
mov %EAX, DWORD PTR [%ESP + 4]
mov %ECX, DWORD PTR [%ESP + 8]
mov %EDX, %EAX
shrd %EDX, %ECX, 30
shl %EAX, 2
ret
Note the magically transmogrifying immediate.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19686 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-19 07:11:01 +00:00
|
|
|
|
|
|
|
let isCommutable = 1 in { // These instructions commute to each other.
|
2004-10-03 20:35:00 +00:00
|
|
|
def SHLD32rri8 : Ii8<0xA4, MRMDestReg,
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2, i8imm:$src3),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shld{l}\t{$src3, $src2, $dst|$dst, $src2, $src3}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86shld GR32:$src1, GR32:$src2,
|
2006-01-09 18:33:28 +00:00
|
|
|
(i8 imm:$src3)))]>,
|
|
|
|
TB;
|
2004-10-03 20:35:00 +00:00
|
|
|
def SHRD32rri8 : Ii8<0xAC, MRMDestReg,
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, GR32:$src2, i8imm:$src3),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shrd{l}\t{$src3, $src2, $dst|$dst, $src2, $src3}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (X86shrd GR32:$src1, GR32:$src2,
|
2006-01-09 18:33:28 +00:00
|
|
|
(i8 imm:$src3)))]>,
|
|
|
|
TB;
|
2005-01-19 07:31:24 +00:00
|
|
|
def SHLD16rri8 : Ii8<0xA4, MRMDestReg,
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2, i8imm:$src3),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shld{w}\t{$src3, $src2, $dst|$dst, $src2, $src3}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86shld GR16:$src1, GR16:$src2,
|
2006-01-09 18:33:28 +00:00
|
|
|
(i8 imm:$src3)))]>,
|
2005-01-19 07:31:24 +00:00
|
|
|
TB, OpSize;
|
|
|
|
def SHRD16rri8 : Ii8<0xAC, MRMDestReg,
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, GR16:$src2, i8imm:$src3),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shrd{w}\t{$src3, $src2, $dst|$dst, $src2, $src3}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR16:$dst, (X86shrd GR16:$src1, GR16:$src2,
|
2006-01-09 18:33:28 +00:00
|
|
|
(i8 imm:$src3)))]>,
|
2005-01-19 07:31:24 +00:00
|
|
|
TB, OpSize;
|
Teach the code generator that shrd/shld is commutable if it has an immediate.
This allows us to generate this:
foo:
mov %EAX, DWORD PTR [%ESP + 4]
mov %EDX, DWORD PTR [%ESP + 8]
shld %EDX, %EDX, 2
shl %EAX, 2
ret
instead of this:
foo:
mov %EAX, DWORD PTR [%ESP + 4]
mov %ECX, DWORD PTR [%ESP + 8]
mov %EDX, %EAX
shrd %EDX, %ECX, 30
shl %EAX, 2
ret
Note the magically transmogrifying immediate.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19686 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-19 07:11:01 +00:00
|
|
|
}
|
2004-08-11 04:31:00 +00:00
|
|
|
|
|
|
|
let isTwoAddress = 0 in {
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [CL] 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 SHLD32mrCL : I<0xA5, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shld{l}\t{%cl, $src2, $dst|$dst, $src2, %CL}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(store (X86shld (loadi32 addr:$dst), GR32:$src2, CL),
|
2007-09-11 19:55:27 +00:00
|
|
|
addr:$dst)]>, TB;
|
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 SHRD32mrCL : I<0xAD, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shrd{l}\t{%cl, $src2, $dst|$dst, $src2, %CL}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(store (X86shrd (loadi32 addr:$dst), GR32:$src2, CL),
|
2007-09-11 19:55:27 +00:00
|
|
|
addr:$dst)]>, TB;
|
|
|
|
}
|
2004-10-03 20:35:00 +00:00
|
|
|
def SHLD32mri8 : Ii8<0xA4, MRMDestMem,
|
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
|
|
|
(outs), (ins i32mem:$dst, GR32:$src2, i8imm:$src3),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shld{l}\t{$src3, $src2, $dst|$dst, $src2, $src3}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(store (X86shld (loadi32 addr:$dst), GR32:$src2,
|
2006-01-09 18:33:28 +00:00
|
|
|
(i8 imm:$src3)), addr:$dst)]>,
|
2005-11-18 01:04:42 +00:00
|
|
|
TB;
|
2004-10-03 20:35:00 +00:00
|
|
|
def SHRD32mri8 : Ii8<0xAC, MRMDestMem,
|
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
|
|
|
(outs), (ins i32mem:$dst, GR32:$src2, i8imm:$src3),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shrd{l}\t{$src3, $src2, $dst|$dst, $src2, $src3}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(store (X86shrd (loadi32 addr:$dst), GR32:$src2,
|
2006-01-09 18:33:28 +00:00
|
|
|
(i8 imm:$src3)), addr:$dst)]>,
|
2005-11-18 01:04:42 +00:00
|
|
|
TB;
|
2005-01-19 07:31:24 +00:00
|
|
|
|
2007-09-11 19:55:27 +00:00
|
|
|
let Uses = [CL] 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 SHLD16mrCL : I<0xA5, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shld{w}\t{%cl, $src2, $dst|$dst, $src2, %CL}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(store (X86shld (loadi16 addr:$dst), GR16:$src2, CL),
|
2007-09-11 19:55:27 +00:00
|
|
|
addr:$dst)]>, TB, OpSize;
|
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 SHRD16mrCL : I<0xAD, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shrd{w}\t{%cl, $src2, $dst|$dst, $src2, %CL}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(store (X86shrd (loadi16 addr:$dst), GR16:$src2, CL),
|
2007-09-11 19:55:27 +00:00
|
|
|
addr:$dst)]>, TB, OpSize;
|
|
|
|
}
|
2005-01-19 07:31:24 +00:00
|
|
|
def SHLD16mri8 : Ii8<0xA4, MRMDestMem,
|
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
|
|
|
(outs), (ins i16mem:$dst, GR16:$src2, i8imm:$src3),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shld{w}\t{$src3, $src2, $dst|$dst, $src2, $src3}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(store (X86shld (loadi16 addr:$dst), GR16:$src2,
|
2006-01-09 18:33:28 +00:00
|
|
|
(i8 imm:$src3)), addr:$dst)]>,
|
2005-01-19 07:31:24 +00:00
|
|
|
TB, OpSize;
|
|
|
|
def SHRD16mri8 : Ii8<0xAC, MRMDestMem,
|
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
|
|
|
(outs), (ins i16mem:$dst, GR16:$src2, i8imm:$src3),
|
2007-07-31 20:11:57 +00:00
|
|
|
"shrd{w}\t{$src3, $src2, $dst|$dst, $src2, $src3}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(store (X86shrd (loadi16 addr:$dst), GR16:$src2,
|
2006-01-09 18:33:28 +00:00
|
|
|
(i8 imm:$src3)), addr:$dst)]>,
|
2005-01-19 07:31:24 +00:00
|
|
|
TB, OpSize;
|
2004-08-01 08:13:11 +00:00
|
|
|
}
|
2007-09-14 21:48:26 +00:00
|
|
|
} // Defs = [EFLAGS]
|
2004-08-01 08:13:11 +00:00
|
|
|
|
2003-10-19 19:25:35 +00:00
|
|
|
|
2005-01-02 02:35:46 +00:00
|
|
|
// Arithmetic.
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [EFLAGS] in {
|
2005-01-02 02:35:46 +00:00
|
|
|
let isCommutable = 1 in { // X = ADD Y, Z --> X = ADD Z, Y
|
2008-12-12 00:56:36 +00:00
|
|
|
// Register-Register Addition
|
|
|
|
def ADD8rr : I<0x00, MRMDestReg, (outs GR8 :$dst),
|
|
|
|
(ins GR8 :$src1, GR8 :$src2),
|
|
|
|
"add{b}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR8:$dst, (add GR8:$src1, GR8:$src2)),
|
2008-12-12 00:56:36 +00:00
|
|
|
(implicit EFLAGS)]>;
|
|
|
|
|
2005-01-02 02:35:46 +00:00
|
|
|
let isConvertibleToThreeAddress = 1 in { // Can transform into LEA.
|
2008-12-12 00:56:36 +00:00
|
|
|
// Register-Register Addition
|
2007-09-11 19:55:27 +00:00
|
|
|
def ADD16rr : I<0x01, MRMDestReg, (outs GR16:$dst),
|
|
|
|
(ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR16:$dst, (add GR16:$src1, GR16:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2007-09-11 19:55:27 +00:00
|
|
|
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst),
|
|
|
|
(ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR32:$dst, (add GR32:$src1, GR32:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2005-01-02 02:35:46 +00:00
|
|
|
} // end isConvertibleToThreeAddress
|
|
|
|
} // end isCommutable
|
2008-12-12 00:56:36 +00:00
|
|
|
|
|
|
|
// Register-Memory Addition
|
2007-09-11 19:55:27 +00:00
|
|
|
def ADD8rm : I<0x02, MRMSrcMem, (outs GR8 :$dst),
|
|
|
|
(ins GR8 :$src1, i8mem :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{b}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR8:$dst, (add GR8:$src1, (load addr:$src2))),
|
|
|
|
(implicit EFLAGS)]>;
|
2007-09-11 19:55:27 +00:00
|
|
|
def ADD16rm : I<0x03, MRMSrcMem, (outs GR16:$dst),
|
|
|
|
(ins GR16:$src1, i16mem:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR16:$dst, (add GR16:$src1, (load addr:$src2))),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2007-09-11 19:55:27 +00:00
|
|
|
def ADD32rm : I<0x03, MRMSrcMem, (outs GR32:$dst),
|
|
|
|
(ins GR32:$src1, i32mem:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR32:$dst, (add GR32:$src1, (load addr:$src2))),
|
|
|
|
(implicit EFLAGS)]>;
|
2005-01-02 02:35:46 +00:00
|
|
|
|
2008-12-12 00:56:36 +00:00
|
|
|
// Register-Integer Addition
|
|
|
|
def ADD8ri : Ii8<0x80, MRM0r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
|
|
|
|
"add{b}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR8:$dst, (add GR8:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-12-12 00:56:36 +00:00
|
|
|
|
2005-01-02 02:35:46 +00:00
|
|
|
let isConvertibleToThreeAddress = 1 in { // Can transform into LEA.
|
2008-12-12 00:56:36 +00:00
|
|
|
// Register-Integer Addition
|
2007-09-11 19:55:27 +00:00
|
|
|
def ADD16ri : Ii16<0x81, MRM0r, (outs GR16:$dst),
|
|
|
|
(ins GR16:$src1, i16imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR16:$dst, (add GR16:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2007-09-11 19:55:27 +00:00
|
|
|
def ADD32ri : Ii32<0x81, MRM0r, (outs GR32:$dst),
|
|
|
|
(ins GR32:$src1, i32imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR32:$dst, (add GR32:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2007-09-11 19:55:27 +00:00
|
|
|
def ADD16ri8 : Ii8<0x83, MRM0r, (outs GR16:$dst),
|
|
|
|
(ins GR16:$src1, i16i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR16:$dst, (add GR16:$src1, i16immSExt8:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2007-09-11 19:55:27 +00:00
|
|
|
def ADD32ri8 : Ii8<0x83, MRM0r, (outs GR32:$dst),
|
|
|
|
(ins GR32:$src1, i32i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR32:$dst, (add GR32:$src1, i32immSExt8:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2006-05-19 18:40:54 +00:00
|
|
|
}
|
2004-08-11 04:31:00 +00:00
|
|
|
|
|
|
|
let isTwoAddress = 0 in {
|
2008-12-12 00:56:36 +00:00
|
|
|
// Memory-Register Addition
|
2008-12-12 21:15:41 +00:00
|
|
|
def ADD8mr : I<0x00, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{b}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(store (add (load addr:$dst), GR8:$src2), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
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 ADD16mr : I<0x01, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(store (add (load addr:$dst), GR16:$src2), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
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 ADD32mr : I<0x01, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(store (add (load addr:$dst), GR32:$src2), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
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 ADD8mi : Ii8<0x80, MRM0m, (outs), (ins i8mem :$dst, i8imm :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{b}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(store (add (loadi8 addr:$dst), imm:$src2), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
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 ADD16mi : Ii16<0x81, MRM0m, (outs), (ins i16mem:$dst, i16imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(store (add (loadi16 addr:$dst), imm:$src2), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
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 ADD32mi : Ii32<0x81, MRM0m, (outs), (ins i32mem:$dst, i32imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(store (add (loadi32 addr:$dst), imm:$src2), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
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 ADD16mi8 : Ii8<0x83, MRM0m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(store (add (load addr:$dst), i16immSExt8:$src2),
|
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
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 ADD32mi8 : Ii8<0x83, MRM0m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"add{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 00:56:36 +00:00
|
|
|
[(store (add (load addr:$dst), i32immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-08-11 04:31:00 +00:00
|
|
|
}
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
2007-10-05 17:59:57 +00:00
|
|
|
let Uses = [EFLAGS] in {
|
2005-01-03 01:27:59 +00:00
|
|
|
let isCommutable = 1 in { // X = ADC Y, Z --> X = ADC Z, Y
|
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 ADC32rr : I<0x11, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"adc{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-01 23:44:08 +00:00
|
|
|
[(set GR32:$dst, (adde GR32:$src1, GR32:$src2))]>;
|
2005-01-03 01:27:59 +00:00
|
|
|
}
|
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 ADC32rm : I<0x13, MRMSrcMem , (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"adc{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-01 23:44:08 +00:00
|
|
|
[(set GR32:$dst, (adde GR32:$src1, (load addr:$src2)))]>;
|
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 ADC32ri : Ii32<0x81, MRM2r, (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"adc{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-01 23:44:08 +00:00
|
|
|
[(set GR32:$dst, (adde GR32:$src1, imm:$src2))]>;
|
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 ADC32ri8 : Ii8<0x83, MRM2r, (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"adc{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-01 23:44:08 +00:00
|
|
|
[(set GR32:$dst, (adde GR32:$src1, i32immSExt8:$src2))]>;
|
2004-08-11 04:31:00 +00:00
|
|
|
|
|
|
|
let isTwoAddress = 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 ADC32mr : I<0x11, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"adc{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-01 23:44:08 +00:00
|
|
|
[(store (adde (load addr:$dst), GR32:$src2), addr:$dst)]>;
|
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 ADC32mi : Ii32<0x81, MRM2m, (outs), (ins i32mem:$dst, i32imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"adc{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-01 23:44:08 +00:00
|
|
|
[(store (adde (loadi32 addr:$dst), imm:$src2), addr:$dst)]>;
|
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 ADC32mi8 : Ii8<0x83, MRM2m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"adc{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-02 00:07:05 +00:00
|
|
|
[(store (adde (load addr:$dst), i32immSExt8:$src2), addr:$dst)]>;
|
2004-08-11 04:31:00 +00:00
|
|
|
}
|
2007-10-05 17:59:57 +00:00
|
|
|
} // Uses = [EFLAGS]
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
2008-12-12 00:56:36 +00:00
|
|
|
// Register-Register Subtraction
|
|
|
|
def SUB8rr : I<0x28, MRMDestReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
|
|
|
|
"sub{b}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR8:$dst, (sub GR8:$src1, GR8:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-12-12 00:56:36 +00:00
|
|
|
def SUB16rr : I<0x29, MRMDestReg, (outs GR16:$dst), (ins GR16:$src1,GR16:$src2),
|
|
|
|
"sub{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR16:$dst, (sub GR16:$src1, GR16:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2008-12-12 00:56:36 +00:00
|
|
|
def SUB32rr : I<0x29, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1,GR32:$src2),
|
|
|
|
"sub{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR32:$dst, (sub GR32:$src1, GR32:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-12-12 00:56:36 +00:00
|
|
|
|
|
|
|
// Register-Memory Subtraction
|
|
|
|
def SUB8rm : I<0x2A, MRMSrcMem, (outs GR8 :$dst),
|
|
|
|
(ins GR8 :$src1, i8mem :$src2),
|
|
|
|
"sub{b}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR8:$dst, (sub GR8:$src1, (load addr:$src2))),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-12-12 00:56:36 +00:00
|
|
|
def SUB16rm : I<0x2B, MRMSrcMem, (outs GR16:$dst),
|
|
|
|
(ins GR16:$src1, i16mem:$src2),
|
|
|
|
"sub{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR16:$dst, (sub GR16:$src1, (load addr:$src2))),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2008-12-12 00:56:36 +00:00
|
|
|
def SUB32rm : I<0x2B, MRMSrcMem, (outs GR32:$dst),
|
|
|
|
(ins GR32:$src1, i32mem:$src2),
|
|
|
|
"sub{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR32:$dst, (sub GR32:$src1, (load addr:$src2))),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-12-12 00:56:36 +00:00
|
|
|
|
|
|
|
// Register-Integer Subtraction
|
|
|
|
def SUB8ri : Ii8 <0x80, MRM5r, (outs GR8:$dst),
|
|
|
|
(ins GR8:$src1, i8imm:$src2),
|
|
|
|
"sub{b}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR8:$dst, (sub GR8:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-12-12 00:56:36 +00:00
|
|
|
def SUB16ri : Ii16<0x81, MRM5r, (outs GR16:$dst),
|
|
|
|
(ins GR16:$src1, i16imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sub{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR16:$dst, (sub GR16:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2008-12-12 00:56:36 +00:00
|
|
|
def SUB32ri : Ii32<0x81, MRM5r, (outs GR32:$dst),
|
|
|
|
(ins GR32:$src1, i32imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sub{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR32:$dst, (sub GR32:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-12-12 00:56:36 +00:00
|
|
|
def SUB16ri8 : Ii8<0x83, MRM5r, (outs GR16:$dst),
|
|
|
|
(ins GR16:$src1, i16i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sub{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR16:$dst, (sub GR16:$src1, i16immSExt8:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2008-12-12 00:56:36 +00:00
|
|
|
def SUB32ri8 : Ii8<0x83, MRM5r, (outs GR32:$dst),
|
|
|
|
(ins GR32:$src1, i32i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sub{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR32:$dst, (sub GR32:$src1, i32immSExt8:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-12-12 00:56:36 +00:00
|
|
|
|
2004-08-11 04:31:00 +00:00
|
|
|
let isTwoAddress = 0 in {
|
2008-12-12 00:56:36 +00:00
|
|
|
// Memory-Register Subtraction
|
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 SUB8mr : I<0x28, MRMDestMem, (outs), (ins i8mem :$dst, GR8 :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sub{b}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(store (sub (load addr:$dst), GR8:$src2), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
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 SUB16mr : I<0x29, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sub{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(store (sub (load addr:$dst), GR16:$src2), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
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 SUB32mr : I<0x29, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sub{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(store (sub (load addr:$dst), GR32:$src2), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2008-12-12 00:56:36 +00:00
|
|
|
|
|
|
|
// Memory-Integer Subtraction
|
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 SUB8mi : Ii8<0x80, MRM5m, (outs), (ins i8mem :$dst, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sub{b}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(store (sub (loadi8 addr:$dst), imm:$src2), addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
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 SUB16mi : Ii16<0x81, MRM5m, (outs), (ins i16mem:$dst, i16imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sub{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(store (sub (loadi16 addr:$dst), imm:$src2),addr:$dst),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
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 SUB32mi : Ii32<0x81, MRM5m, (outs), (ins i32mem:$dst, i32imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sub{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(store (sub (loadi32 addr:$dst), imm:$src2),addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
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 SUB16mi8 : Ii8<0x83, MRM5m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sub{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 00:56:36 +00:00
|
|
|
[(store (sub (load addr:$dst), i16immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2008-12-12 00:56:36 +00:00
|
|
|
def SUB32mi8 : Ii8<0x83, MRM5m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sub{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 00:56:36 +00:00
|
|
|
[(store (sub (load addr:$dst), i32immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-08-11 04:31:00 +00:00
|
|
|
}
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
2007-10-05 17:59:57 +00:00
|
|
|
let Uses = [EFLAGS] 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 SBB32rr : I<0x19, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sbb{l}\t{$src2, $dst|$dst, $src2}",
|
2007-09-14 21:48:26 +00:00
|
|
|
[(set GR32:$dst, (sube GR32:$src1, GR32:$src2))]>;
|
2004-10-06 04:01:02 +00:00
|
|
|
|
2004-08-11 04:31:00 +00:00
|
|
|
let isTwoAddress = 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 SBB32mr : I<0x19, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sbb{l}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(store (sube (load addr:$dst), GR32:$src2), addr:$dst)]>;
|
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 SBB8mi : Ii32<0x80, MRM3m, (outs), (ins i8mem:$dst, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sbb{b}\t{$src2, $dst|$dst, $src2}",
|
2006-02-17 05:43:56 +00:00
|
|
|
[(store (sube (loadi8 addr:$dst), imm:$src2), addr:$dst)]>;
|
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 SBB32mi : Ii32<0x81, MRM3m, (outs), (ins i32mem:$dst, i32imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sbb{l}\t{$src2, $dst|$dst, $src2}",
|
2006-02-17 05:43:56 +00:00
|
|
|
[(store (sube (loadi32 addr:$dst), imm:$src2), addr:$dst)]>;
|
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 SBB32mi8 : Ii8<0x83, MRM3m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sbb{l}\t{$src2, $dst|$dst, $src2}",
|
2007-09-14 21:48:26 +00:00
|
|
|
[(store (sube (load addr:$dst), i32immSExt8:$src2), addr:$dst)]>;
|
2004-08-11 04:31:00 +00:00
|
|
|
}
|
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 SBB32rm : I<0x1B, MRMSrcMem, (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sbb{l}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (sube GR32:$src1, (load addr:$src2)))]>;
|
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 SBB32ri : Ii32<0x81, MRM3r, (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sbb{l}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (sube GR32:$src1, imm:$src2))]>;
|
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 SBB32ri8 : Ii8<0x83, MRM3r, (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sbb{l}\t{$src2, $dst|$dst, $src2}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (sube GR32:$src1, i32immSExt8:$src2))]>;
|
2007-10-05 17:59:57 +00:00
|
|
|
} // Uses = [EFLAGS]
|
2007-09-14 21:48:26 +00:00
|
|
|
} // Defs = [EFLAGS]
|
A big X86 instruction rename. The instructions are renamed to make
their names more decriptive. A name consists of the base name, a
default operand size followed by a character per operand with an
optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11995 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-29 08:50:03 +00:00
|
|
|
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [EFLAGS] in {
|
2005-01-03 01:27:59 +00:00
|
|
|
let isCommutable = 1 in { // X = IMUL Y, Z --> X = IMUL Z, Y
|
2008-12-12 21:15:41 +00:00
|
|
|
// Register-Register Signed Integer Multiply
|
2008-12-12 00:56:36 +00:00
|
|
|
def IMUL16rr : I<0xAF, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src1,GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"imul{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR16:$dst, (mul GR16:$src1, GR16:$src2)),
|
|
|
|
(implicit EFLAGS)]>, TB, OpSize;
|
2008-12-12 00:56:36 +00:00
|
|
|
def IMUL32rr : I<0xAF, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src1,GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"imul{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR32:$dst, (mul GR32:$src1, GR32:$src2)),
|
|
|
|
(implicit EFLAGS)]>, TB;
|
2005-01-03 01:27:59 +00:00
|
|
|
}
|
2008-12-12 00:56:36 +00:00
|
|
|
|
2008-12-12 21:15:41 +00:00
|
|
|
// Register-Memory Signed Integer Multiply
|
2008-12-12 00:56:36 +00:00
|
|
|
def IMUL16rm : I<0xAF, MRMSrcMem, (outs GR16:$dst),
|
|
|
|
(ins GR16:$src1, i16mem:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"imul{w}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR16:$dst, (mul GR16:$src1, (load addr:$src2))),
|
|
|
|
(implicit EFLAGS)]>, TB, OpSize;
|
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 IMUL32rm : I<0xAF, MRMSrcMem, (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"imul{l}\t{$src2, $dst|$dst, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR32:$dst, (mul GR32:$src1, (load addr:$src2))),
|
|
|
|
(implicit EFLAGS)]>, TB;
|
2007-09-14 21:48:26 +00:00
|
|
|
} // Defs = [EFLAGS]
|
2004-02-28 22:02:05 +00:00
|
|
|
} // end Two Address instructions
|
2004-02-17 04:26:43 +00:00
|
|
|
|
2004-08-11 05:31:07 +00:00
|
|
|
// Suprisingly enough, these are not two address instructions!
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [EFLAGS] in {
|
2008-12-12 21:15:41 +00:00
|
|
|
// Register-Integer Signed Integer Multiply
|
2006-05-16 07:21:53 +00:00
|
|
|
def IMUL16rri : Ii16<0x69, MRMSrcReg, // GR16 = GR16*I16
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR16:$dst, (mul GR16:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def IMUL32rri : Ii32<0x69, MRMSrcReg, // GR32 = GR32*I32
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR32:$dst, (mul GR32:$src1, imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2006-05-16 07:21:53 +00:00
|
|
|
def IMUL16rri8 : Ii8<0x6B, MRMSrcReg, // GR16 = GR16*I8
|
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
|
|
|
(outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR16:$dst, (mul GR16:$src1, i16immSExt8:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def IMUL32rri8 : Ii8<0x6B, MRMSrcReg, // GR32 = GR32*I8
|
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
|
|
|
(outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR32:$dst, (mul GR32:$src1, i32immSExt8:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
|
|
|
|
|
|
|
// Memory-Integer Signed Integer Multiply
|
2006-05-16 07:21:53 +00:00
|
|
|
def IMUL16rmi : Ii16<0x69, MRMSrcMem, // GR16 = [mem16]*I16
|
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
|
|
|
(outs GR16:$dst), (ins i16mem:$src1, i16imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR16:$dst, (mul (load addr:$src1), imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def IMUL32rmi : Ii32<0x69, MRMSrcMem, // GR32 = [mem32]*I32
|
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
|
|
|
(outs GR32:$dst), (ins i32mem:$src1, i32imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
|
2008-12-12 21:15:41 +00:00
|
|
|
[(set GR32:$dst, (mul (load addr:$src1), imm:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2006-05-16 07:21:53 +00:00
|
|
|
def IMUL16rmi8 : Ii8<0x6B, MRMSrcMem, // GR16 = [mem16]*I8
|
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
|
|
|
(outs GR16:$dst), (ins i16mem:$src1, i16i8imm :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
|
2008-12-12 00:56:36 +00:00
|
|
|
[(set GR16:$dst, (mul (load addr:$src1),
|
2008-12-12 21:15:41 +00:00
|
|
|
i16immSExt8:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2006-05-16 07:21:53 +00:00
|
|
|
def IMUL32rmi8 : Ii8<0x6B, MRMSrcMem, // GR32 = [mem32]*I8
|
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
|
|
|
(outs GR32:$dst), (ins i32mem:$src1, i32i8imm: $src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
|
2008-12-12 00:56:36 +00:00
|
|
|
[(set GR32:$dst, (mul (load addr:$src1),
|
2008-12-12 21:15:41 +00:00
|
|
|
i32immSExt8:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2007-09-14 21:48:26 +00:00
|
|
|
} // Defs = [EFLAGS]
|
2003-08-03 21:54:21 +00:00
|
|
|
|
2004-02-28 22:02:05 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2003-08-03 21:54:21 +00:00
|
|
|
// Test instructions are just like AND, except they don't generate a result.
|
2004-10-03 20:35:00 +00:00
|
|
|
//
|
2007-09-25 01:57:46 +00:00
|
|
|
let Defs = [EFLAGS] in {
|
2005-01-02 02:35:46 +00:00
|
|
|
let isCommutable = 1 in { // TEST X, Y --> TEST Y, X
|
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 TEST8rr : I<0x84, MRMDestReg, (outs), (ins GR8:$src1, GR8:$src2),
|
2007-09-25 01:57:46 +00:00
|
|
|
"test{b}\t{$src2, $src1|$src1, $src2}",
|
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
|
|
|
[(X86cmp (and_su GR8:$src1, GR8:$src2), 0),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>;
|
2007-09-29 00:00:36 +00:00
|
|
|
def TEST16rr : I<0x85, MRMDestReg, (outs), (ins GR16:$src1, GR16:$src2),
|
2007-09-25 01:57:46 +00:00
|
|
|
"test{w}\t{$src2, $src1|$src1, $src2}",
|
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
|
|
|
[(X86cmp (and_su GR16:$src1, GR16:$src2), 0),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>,
|
|
|
|
OpSize;
|
2007-09-29 00:00:36 +00:00
|
|
|
def TEST32rr : I<0x85, MRMDestReg, (outs), (ins GR32:$src1, GR32:$src2),
|
2007-09-25 01:57:46 +00:00
|
|
|
"test{l}\t{$src2, $src1|$src1, $src2}",
|
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
|
|
|
[(X86cmp (and_su GR32:$src1, GR32:$src2), 0),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>;
|
|
|
|
}
|
|
|
|
|
2007-09-29 00:00:36 +00:00
|
|
|
def TEST8rm : I<0x84, MRMSrcMem, (outs), (ins GR8 :$src1, i8mem :$src2),
|
2007-09-25 01:57:46 +00:00
|
|
|
"test{b}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp (and GR8:$src1, (loadi8 addr:$src2)), 0),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>;
|
2007-09-29 00:00:36 +00:00
|
|
|
def TEST16rm : I<0x85, MRMSrcMem, (outs), (ins GR16:$src1, i16mem:$src2),
|
2007-09-25 01:57:46 +00:00
|
|
|
"test{w}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp (and GR16:$src1, (loadi16 addr:$src2)), 0),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2007-09-29 00:00:36 +00:00
|
|
|
def TEST32rm : I<0x85, MRMSrcMem, (outs), (ins GR32:$src1, i32mem:$src2),
|
2007-09-25 01:57:46 +00:00
|
|
|
"test{l}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp (and GR32:$src1, (loadi32 addr:$src2)), 0),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>;
|
|
|
|
|
2007-09-29 00:00:36 +00:00
|
|
|
def TEST8ri : Ii8 <0xF6, MRM0r, // flags = GR8 & imm8
|
2007-09-25 01:57:46 +00:00
|
|
|
(outs), (ins GR8:$src1, i8imm:$src2),
|
|
|
|
"test{b}\t{$src2, $src1|$src1, $src2}",
|
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
|
|
|
[(X86cmp (and_su GR8:$src1, imm:$src2), 0),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>;
|
2007-09-29 00:00:36 +00:00
|
|
|
def TEST16ri : Ii16<0xF7, MRM0r, // flags = GR16 & imm16
|
2007-09-25 01:57:46 +00:00
|
|
|
(outs), (ins GR16:$src1, i16imm:$src2),
|
|
|
|
"test{w}\t{$src2, $src1|$src1, $src2}",
|
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
|
|
|
[(X86cmp (and_su GR16:$src1, imm:$src2), 0),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2007-09-29 00:00:36 +00:00
|
|
|
def TEST32ri : Ii32<0xF7, MRM0r, // flags = GR32 & imm32
|
2007-09-25 01:57:46 +00:00
|
|
|
(outs), (ins GR32:$src1, i32imm:$src2),
|
|
|
|
"test{l}\t{$src2, $src1|$src1, $src2}",
|
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
|
|
|
[(X86cmp (and_su GR32:$src1, imm:$src2), 0),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>;
|
|
|
|
|
2007-09-29 00:00:36 +00:00
|
|
|
def TEST8mi : Ii8 <0xF6, MRM0m, // flags = [mem8] & imm8
|
2007-09-25 01:57:46 +00:00
|
|
|
(outs), (ins i8mem:$src1, i8imm:$src2),
|
|
|
|
"test{b}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp (and (loadi8 addr:$src1), imm:$src2), 0),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>;
|
2007-09-29 00:00:36 +00:00
|
|
|
def TEST16mi : Ii16<0xF7, MRM0m, // flags = [mem16] & imm16
|
2007-09-25 01:57:46 +00:00
|
|
|
(outs), (ins i16mem:$src1, i16imm:$src2),
|
|
|
|
"test{w}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp (and (loadi16 addr:$src1), imm:$src2), 0),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2007-09-29 00:00:36 +00:00
|
|
|
def TEST32mi : Ii32<0xF7, MRM0m, // flags = [mem32] & imm32
|
2007-09-25 01:57:46 +00:00
|
|
|
(outs), (ins i32mem:$src1, i32imm:$src2),
|
|
|
|
"test{l}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp (and (loadi32 addr:$src1), imm:$src2), 0),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>;
|
|
|
|
} // Defs = [EFLAGS]
|
|
|
|
|
|
|
|
|
2004-02-28 22:02:05 +00:00
|
|
|
// Condition code ops, incl. set if equal/not equal/...
|
2008-01-10 07:59:24 +00:00
|
|
|
let Defs = [EFLAGS], Uses = [AH], neverHasSideEffects = 1 in
|
2007-09-11 19:55:27 +00:00
|
|
|
def SAHF : I<0x9E, RawFrm, (outs), (ins), "sahf", []>; // flags = AH
|
2008-01-10 07:59:24 +00:00
|
|
|
let Defs = [AH], Uses = [EFLAGS], neverHasSideEffects = 1 in
|
2007-09-11 19:55:27 +00:00
|
|
|
def LAHF : I<0x9F, RawFrm, (outs), (ins), "lahf", []>; // AH = flags
|
2004-02-28 22:02:05 +00:00
|
|
|
|
2007-09-25 01:57:46 +00:00
|
|
|
let Uses = [EFLAGS] in {
|
2004-10-03 20:35:00 +00:00
|
|
|
def SETEr : I<0x94, MRM0r,
|
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
|
|
|
(outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sete\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_E, EFLAGS))]>,
|
2006-05-16 07:21:53 +00:00
|
|
|
TB; // GR8 = ==
|
2004-10-03 20:35:00 +00:00
|
|
|
def SETEm : I<0x94, MRM0m,
|
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
|
|
|
(outs), (ins i8mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sete\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(store (X86setcc X86_COND_E, EFLAGS), addr:$dst)]>,
|
2005-12-21 20:21:51 +00:00
|
|
|
TB; // [mem8] = ==
|
2008-12-02 00:07:05 +00:00
|
|
|
|
2004-10-03 20:35:00 +00:00
|
|
|
def SETNEr : I<0x95, MRM0r,
|
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
|
|
|
(outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setne\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_NE, EFLAGS))]>,
|
2006-05-16 07:21:53 +00:00
|
|
|
TB; // GR8 = !=
|
2004-10-03 20:35:00 +00:00
|
|
|
def SETNEm : I<0x95, MRM0m,
|
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
|
|
|
(outs), (ins i8mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setne\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(store (X86setcc X86_COND_NE, EFLAGS), addr:$dst)]>,
|
2005-12-21 20:21:51 +00:00
|
|
|
TB; // [mem8] = !=
|
2008-12-02 00:07:05 +00:00
|
|
|
|
2005-12-21 20:21:51 +00:00
|
|
|
def SETLr : I<0x9C, MRM0r,
|
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
|
|
|
(outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setl\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_L, EFLAGS))]>,
|
2006-05-16 07:21:53 +00:00
|
|
|
TB; // GR8 = < signed
|
2005-12-21 20:21:51 +00:00
|
|
|
def SETLm : I<0x9C, MRM0m,
|
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
|
|
|
(outs), (ins i8mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setl\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(store (X86setcc X86_COND_L, EFLAGS), addr:$dst)]>,
|
2005-12-21 20:21:51 +00:00
|
|
|
TB; // [mem8] = < signed
|
2008-12-02 00:07:05 +00:00
|
|
|
|
2005-12-21 20:21:51 +00:00
|
|
|
def SETGEr : I<0x9D, MRM0r,
|
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
|
|
|
(outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setge\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_GE, EFLAGS))]>,
|
2006-05-16 07:21:53 +00:00
|
|
|
TB; // GR8 = >= signed
|
2005-12-21 20:21:51 +00:00
|
|
|
def SETGEm : I<0x9D, MRM0m,
|
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
|
|
|
(outs), (ins i8mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setge\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(store (X86setcc X86_COND_GE, EFLAGS), addr:$dst)]>,
|
2005-12-21 20:21:51 +00:00
|
|
|
TB; // [mem8] = >= signed
|
2008-12-02 00:07:05 +00:00
|
|
|
|
2005-12-21 20:21:51 +00:00
|
|
|
def SETLEr : I<0x9E, MRM0r,
|
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
|
|
|
(outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setle\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_LE, EFLAGS))]>,
|
2006-05-16 07:21:53 +00:00
|
|
|
TB; // GR8 = <= signed
|
2005-12-21 20:21:51 +00:00
|
|
|
def SETLEm : I<0x9E, MRM0m,
|
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
|
|
|
(outs), (ins i8mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setle\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(store (X86setcc X86_COND_LE, EFLAGS), addr:$dst)]>,
|
2005-12-21 20:21:51 +00:00
|
|
|
TB; // [mem8] = <= signed
|
2008-12-02 00:07:05 +00:00
|
|
|
|
2005-12-21 20:21:51 +00:00
|
|
|
def SETGr : I<0x9F, MRM0r,
|
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
|
|
|
(outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setg\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_G, EFLAGS))]>,
|
2006-05-16 07:21:53 +00:00
|
|
|
TB; // GR8 = > signed
|
2005-12-21 20:21:51 +00:00
|
|
|
def SETGm : I<0x9F, MRM0m,
|
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
|
|
|
(outs), (ins i8mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setg\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(store (X86setcc X86_COND_G, EFLAGS), addr:$dst)]>,
|
2005-12-21 20:21:51 +00:00
|
|
|
TB; // [mem8] = > signed
|
|
|
|
|
|
|
|
def SETBr : I<0x92, MRM0r,
|
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
|
|
|
(outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setb\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_B, EFLAGS))]>,
|
2006-05-16 07:21:53 +00:00
|
|
|
TB; // GR8 = < unsign
|
2005-12-21 20:21:51 +00:00
|
|
|
def SETBm : I<0x92, MRM0m,
|
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
|
|
|
(outs), (ins i8mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setb\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(store (X86setcc X86_COND_B, EFLAGS), addr:$dst)]>,
|
2005-12-21 20:21:51 +00:00
|
|
|
TB; // [mem8] = < unsign
|
2008-12-02 00:07:05 +00:00
|
|
|
|
2005-12-21 20:21:51 +00:00
|
|
|
def SETAEr : I<0x93, MRM0r,
|
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
|
|
|
(outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setae\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_AE, EFLAGS))]>,
|
2006-05-16 07:21:53 +00:00
|
|
|
TB; // GR8 = >= unsign
|
2005-12-21 20:21:51 +00:00
|
|
|
def SETAEm : I<0x93, MRM0m,
|
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
|
|
|
(outs), (ins i8mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setae\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(store (X86setcc X86_COND_AE, EFLAGS), addr:$dst)]>,
|
2005-12-21 20:21:51 +00:00
|
|
|
TB; // [mem8] = >= unsign
|
2008-12-02 00:07:05 +00:00
|
|
|
|
2004-10-03 20:35:00 +00:00
|
|
|
def SETBEr : I<0x96, MRM0r,
|
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
|
|
|
(outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setbe\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_BE, EFLAGS))]>,
|
2006-05-16 07:21:53 +00:00
|
|
|
TB; // GR8 = <= unsign
|
2004-10-03 20:35:00 +00:00
|
|
|
def SETBEm : I<0x96, MRM0m,
|
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
|
|
|
(outs), (ins i8mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setbe\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(store (X86setcc X86_COND_BE, EFLAGS), addr:$dst)]>,
|
2005-12-21 20:21:51 +00:00
|
|
|
TB; // [mem8] = <= unsign
|
2008-12-02 00:07:05 +00:00
|
|
|
|
2004-10-03 20:35:00 +00:00
|
|
|
def SETAr : I<0x97, MRM0r,
|
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
|
|
|
(outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"seta\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_A, EFLAGS))]>,
|
2006-05-16 07:21:53 +00:00
|
|
|
TB; // GR8 = > signed
|
2004-10-03 20:35:00 +00:00
|
|
|
def SETAm : I<0x97, MRM0m,
|
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
|
|
|
(outs), (ins i8mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"seta\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(store (X86setcc X86_COND_A, EFLAGS), addr:$dst)]>,
|
2005-12-21 20:21:51 +00:00
|
|
|
TB; // [mem8] = > signed
|
2006-01-06 00:43:03 +00:00
|
|
|
|
2004-10-03 20:35:00 +00:00
|
|
|
def SETSr : I<0x98, MRM0r,
|
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
|
|
|
(outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sets\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_S, EFLAGS))]>,
|
2006-05-16 07:21:53 +00:00
|
|
|
TB; // GR8 = <sign bit>
|
2004-10-03 20:35:00 +00:00
|
|
|
def SETSm : I<0x98, MRM0m,
|
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
|
|
|
(outs), (ins i8mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"sets\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(store (X86setcc X86_COND_S, EFLAGS), addr:$dst)]>,
|
2006-01-06 00:43:03 +00:00
|
|
|
TB; // [mem8] = <sign bit>
|
2004-10-03 20:35:00 +00:00
|
|
|
def SETNSr : I<0x99, MRM0r,
|
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
|
|
|
(outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setns\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_NS, EFLAGS))]>,
|
2006-05-16 07:21:53 +00:00
|
|
|
TB; // GR8 = !<sign bit>
|
2004-10-03 20:35:00 +00:00
|
|
|
def SETNSm : I<0x99, MRM0m,
|
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
|
|
|
(outs), (ins i8mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setns\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(store (X86setcc X86_COND_NS, EFLAGS), addr:$dst)]>,
|
2006-01-06 00:43:03 +00:00
|
|
|
TB; // [mem8] = !<sign bit>
|
2008-12-02 00:07:05 +00:00
|
|
|
|
2004-10-03 20:35:00 +00:00
|
|
|
def SETPr : I<0x9A, MRM0r,
|
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
|
|
|
(outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setp\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_P, EFLAGS))]>,
|
2006-05-16 07:21:53 +00:00
|
|
|
TB; // GR8 = parity
|
2004-10-03 20:35:00 +00:00
|
|
|
def SETPm : I<0x9A, MRM0m,
|
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
|
|
|
(outs), (ins i8mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setp\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(store (X86setcc X86_COND_P, EFLAGS), addr:$dst)]>,
|
2006-01-06 00:43:03 +00:00
|
|
|
TB; // [mem8] = parity
|
2005-01-02 02:35:46 +00:00
|
|
|
def SETNPr : I<0x9B, MRM0r,
|
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
|
|
|
(outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setnp\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_NP, EFLAGS))]>,
|
2006-05-16 07:21:53 +00:00
|
|
|
TB; // GR8 = not parity
|
2005-01-02 02:35:46 +00:00
|
|
|
def SETNPm : I<0x9B, MRM0m,
|
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
|
|
|
(outs), (ins i8mem:$dst),
|
2007-07-31 20:11:57 +00:00
|
|
|
"setnp\t$dst",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(store (X86setcc X86_COND_NP, EFLAGS), addr:$dst)]>,
|
2006-01-06 00:43:03 +00:00
|
|
|
TB; // [mem8] = not parity
|
2008-12-02 00:07:05 +00:00
|
|
|
|
|
|
|
def SETOr : I<0x90, MRM0r,
|
|
|
|
(outs GR8 :$dst), (ins),
|
|
|
|
"seto\t$dst",
|
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_O, EFLAGS))]>,
|
|
|
|
TB; // GR8 = overflow
|
|
|
|
def SETOm : I<0x90, MRM0m,
|
|
|
|
(outs), (ins i8mem:$dst),
|
|
|
|
"seto\t$dst",
|
|
|
|
[(store (X86setcc X86_COND_O, EFLAGS), addr:$dst)]>,
|
|
|
|
TB; // [mem8] = overflow
|
|
|
|
def SETNOr : I<0x91, MRM0r,
|
|
|
|
(outs GR8 :$dst), (ins),
|
|
|
|
"setno\t$dst",
|
|
|
|
[(set GR8:$dst, (X86setcc X86_COND_NO, EFLAGS))]>,
|
|
|
|
TB; // GR8 = not overflow
|
|
|
|
def SETNOm : I<0x91, MRM0m,
|
|
|
|
(outs), (ins i8mem:$dst),
|
|
|
|
"setno\t$dst",
|
|
|
|
[(store (X86setcc X86_COND_NO, EFLAGS), addr:$dst)]>,
|
|
|
|
TB; // [mem8] = not overflow
|
2007-09-25 01:57:46 +00:00
|
|
|
} // Uses = [EFLAGS]
|
|
|
|
|
2003-08-03 21:54:21 +00:00
|
|
|
|
|
|
|
// Integer comparisons
|
2007-09-14 21:48:26 +00:00
|
|
|
let Defs = [EFLAGS] in {
|
2004-10-03 20:35:00 +00:00
|
|
|
def CMP8rr : I<0x38, MRMDestReg,
|
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
|
|
|
(outs), (ins GR8 :$src1, GR8 :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmp{b}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp GR8:$src1, GR8:$src2), (implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def CMP16rr : I<0x39, MRMDestReg,
|
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
|
|
|
(outs), (ins GR16:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmp{w}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp GR16:$src1, GR16:$src2), (implicit EFLAGS)]>, OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def CMP32rr : I<0x39, MRMDestReg,
|
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
|
|
|
(outs), (ins GR32:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmp{l}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp GR32:$src1, GR32:$src2), (implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def CMP8mr : I<0x38, MRMDestMem,
|
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
|
|
|
(outs), (ins i8mem :$src1, GR8 :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmp{b}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp (loadi8 addr:$src1), GR8:$src2),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def CMP16mr : I<0x39, MRMDestMem,
|
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
|
|
|
(outs), (ins i16mem:$src1, GR16:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmp{w}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp (loadi16 addr:$src1), GR16:$src2),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def CMP32mr : I<0x39, MRMDestMem,
|
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
|
|
|
(outs), (ins i32mem:$src1, GR32:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmp{l}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp (loadi32 addr:$src1), GR32:$src2),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def CMP8rm : I<0x3A, MRMSrcMem,
|
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
|
|
|
(outs), (ins GR8 :$src1, i8mem :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmp{b}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp GR8:$src1, (loadi8 addr:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def CMP16rm : I<0x3B, MRMSrcMem,
|
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
|
|
|
(outs), (ins GR16:$src1, i16mem:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmp{w}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp GR16:$src1, (loadi16 addr:$src2)),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def CMP32rm : I<0x3B, MRMSrcMem,
|
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
|
|
|
(outs), (ins GR32:$src1, i32mem:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmp{l}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp GR32:$src1, (loadi32 addr:$src2)),
|
|
|
|
(implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def CMP8ri : Ii8<0x80, MRM7r,
|
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
|
|
|
(outs), (ins GR8:$src1, i8imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmp{b}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp GR8:$src1, imm:$src2), (implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def CMP16ri : Ii16<0x81, MRM7r,
|
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
|
|
|
(outs), (ins GR16:$src1, i16imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmp{w}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp GR16:$src1, imm:$src2),
|
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2004-10-03 20:35:00 +00:00
|
|
|
def CMP32ri : Ii32<0x81, MRM7r,
|
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
|
|
|
(outs), (ins GR32:$src1, i32imm:$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmp{l}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp GR32:$src1, imm:$src2), (implicit EFLAGS)]>;
|
2004-10-03 20:35:00 +00:00
|
|
|
def CMP8mi : Ii8 <0x80, MRM7m,
|
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
|
|
|
(outs), (ins i8mem :$src1, i8imm :$src2),
|
2007-07-31 20:11:57 +00:00
|
|
|
"cmp{b}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp (loadi8 addr:$src1), imm:$src2),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>;
|
2007-09-29 00:00:36 +00:00
|
|
|
def CMP16mi : Ii16<0x81, MRM7m,
|
2007-09-25 01:57:46 +00:00
|
|
|
(outs), (ins i16mem:$src1, i16imm:$src2),
|
|
|
|
"cmp{w}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp (loadi16 addr:$src1), imm:$src2),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2007-09-29 00:00:36 +00:00
|
|
|
def CMP32mi : Ii32<0x81, MRM7m,
|
2007-09-25 01:57:46 +00:00
|
|
|
(outs), (ins i32mem:$src1, i32imm:$src2),
|
|
|
|
"cmp{l}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp (loadi32 addr:$src1), imm:$src2),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>;
|
2007-09-29 00:00:36 +00:00
|
|
|
def CMP16ri8 : Ii8<0x83, MRM7r,
|
2007-09-25 01:57:46 +00:00
|
|
|
(outs), (ins GR16:$src1, i16i8imm:$src2),
|
|
|
|
"cmp{w}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp GR16:$src1, i16immSExt8:$src2),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2007-09-29 00:00:36 +00:00
|
|
|
def CMP16mi8 : Ii8<0x83, MRM7m,
|
2007-09-25 01:57:46 +00:00
|
|
|
(outs), (ins i16mem:$src1, i16i8imm:$src2),
|
|
|
|
"cmp{w}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp (loadi16 addr:$src1), i16immSExt8:$src2),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>, OpSize;
|
2007-09-29 00:00:36 +00:00
|
|
|
def CMP32mi8 : Ii8<0x83, MRM7m,
|
2007-09-25 01:57:46 +00:00
|
|
|
(outs), (ins i32mem:$src1, i32i8imm:$src2),
|
|
|
|
"cmp{l}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp (loadi32 addr:$src1), i32immSExt8:$src2),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>;
|
2007-09-29 00:00:36 +00:00
|
|
|
def CMP32ri8 : Ii8<0x83, MRM7r,
|
2007-09-25 01:57:46 +00:00
|
|
|
(outs), (ins GR32:$src1, i32i8imm:$src2),
|
|
|
|
"cmp{l}\t{$src2, $src1|$src1, $src2}",
|
2007-09-29 00:00:36 +00:00
|
|
|
[(X86cmp GR32:$src1, i32immSExt8:$src2),
|
2007-09-25 01:57:46 +00:00
|
|
|
(implicit EFLAGS)]>;
|
|
|
|
} // Defs = [EFLAGS]
|
|
|
|
|
2008-12-23 22:45:23 +00:00
|
|
|
// Bit tests.
|
|
|
|
// TODO: BTC, BTR, and BTS
|
|
|
|
let Defs = [EFLAGS] 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}",
|
|
|
|
[(X86bt GR16:$src1, GR16:$src2),
|
2008-12-25 01:32:49 +00:00
|
|
|
(implicit EFLAGS)]>, OpSize, 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}",
|
|
|
|
[(X86bt GR32:$src1, GR32:$src2),
|
2008-12-25 01:32:49 +00:00
|
|
|
(implicit EFLAGS)]>, TB;
|
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
|
|
|
|
// perspective, this is pretty bizarre. Disable these instructions for now.
|
|
|
|
//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)]>, OpSize, TB, Requires<[FastBTMem]>;
|
|
|
|
//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)]>, TB, Requires<[FastBTMem]>;
|
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}",
|
|
|
|
[(X86bt GR16:$src1, i16immSExt8:$src2),
|
|
|
|
(implicit EFLAGS)]>, OpSize, TB;
|
|
|
|
def BT32ri8 : Ii8<0xBA, MRM4r, (outs), (ins GR32:$src1, i32i8imm:$src2),
|
|
|
|
"bt{l}\t{$src2, $src1|$src1, $src2}",
|
|
|
|
[(X86bt GR32:$src1, i32immSExt8:$src2),
|
|
|
|
(implicit EFLAGS)]>, TB;
|
|
|
|
// 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.
|
|
|
|
def BT16mi8 : Ii8<0xBA, MRM4m, (outs), (ins i16mem:$src1, i16i8imm:$src2),
|
|
|
|
"bt{w}\t{$src2, $src1|$src1, $src2}",
|
|
|
|
[(X86bt (loadi16 addr:$src1), i16immSExt8:$src2),
|
|
|
|
(implicit EFLAGS)]>, OpSize, TB;
|
|
|
|
def BT32mi8 : Ii8<0xBA, MRM4m, (outs), (ins i32mem:$src1, i32i8imm:$src2),
|
|
|
|
"bt{l}\t{$src2, $src1|$src1, $src2}",
|
|
|
|
[(X86bt (loadi32 addr:$src1), i32immSExt8:$src2),
|
|
|
|
(implicit EFLAGS)]>, TB;
|
2008-12-23 22:45:23 +00:00
|
|
|
} // Defs = [EFLAGS]
|
|
|
|
|
2003-08-03 21:54:21 +00:00
|
|
|
// Sign/Zero extenders
|
2008-07-30 18:09:17 +00:00
|
|
|
// Use movsbl intead of movsbw; we don't care about the high 16 bits
|
|
|
|
// of the register here. This has a smaller encoding and avoids a
|
|
|
|
// partial-register update.
|
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 MOVSX16rr8 : I<0xBE, MRMSrcReg, (outs GR16:$dst), (ins GR8 :$src),
|
2008-07-30 18:09:17 +00:00
|
|
|
"movs{bl|x}\t{$src, ${dst:subreg32}|${dst:subreg32}, $src}",
|
|
|
|
[(set GR16:$dst, (sext GR8:$src))]>, TB;
|
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 MOVSX16rm8 : I<0xBE, MRMSrcMem, (outs GR16:$dst), (ins i8mem :$src),
|
2008-07-30 18:09:17 +00:00
|
|
|
"movs{bl|x}\t{$src, ${dst:subreg32}|${dst:subreg32}, $src}",
|
|
|
|
[(set GR16:$dst, (sextloadi16i8 addr:$src))]>, TB;
|
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 MOVSX32rr8 : I<0xBE, MRMSrcReg, (outs GR32:$dst), (ins GR8 :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"movs{bl|x}\t{$src, $dst|$dst, $src}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (sext GR8:$src))]>, TB;
|
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 MOVSX32rm8 : I<0xBE, MRMSrcMem, (outs GR32:$dst), (ins i8mem :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"movs{bl|x}\t{$src, $dst|$dst, $src}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (sextloadi32i8 addr:$src))]>, TB;
|
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 MOVSX32rr16: I<0xBF, MRMSrcReg, (outs GR32:$dst), (ins GR16:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"movs{wl|x}\t{$src, $dst|$dst, $src}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (sext GR16:$src))]>, TB;
|
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 MOVSX32rm16: I<0xBF, MRMSrcMem, (outs GR32:$dst), (ins i16mem:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"movs{wl|x}\t{$src, $dst|$dst, $src}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (sextloadi32i16 addr:$src))]>, TB;
|
2004-10-03 20:35:00 +00:00
|
|
|
|
2008-07-30 18:09:17 +00:00
|
|
|
// Use movzbl intead of movzbw; we don't care about the high 16 bits
|
|
|
|
// of the register here. This has a smaller encoding and avoids a
|
|
|
|
// partial-register update.
|
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 MOVZX16rr8 : I<0xB6, MRMSrcReg, (outs GR16:$dst), (ins GR8 :$src),
|
2008-07-30 18:09:17 +00:00
|
|
|
"movz{bl|x}\t{$src, ${dst:subreg32}|${dst:subreg32}, $src}",
|
|
|
|
[(set GR16:$dst, (zext GR8:$src))]>, TB;
|
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 MOVZX16rm8 : I<0xB6, MRMSrcMem, (outs GR16:$dst), (ins i8mem :$src),
|
2008-07-30 18:09:17 +00:00
|
|
|
"movz{bl|x}\t{$src, ${dst:subreg32}|${dst:subreg32}, $src}",
|
|
|
|
[(set GR16:$dst, (zextloadi16i8 addr:$src))]>, TB;
|
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 MOVZX32rr8 : I<0xB6, MRMSrcReg, (outs GR32:$dst), (ins GR8 :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"movz{bl|x}\t{$src, $dst|$dst, $src}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (zext GR8:$src))]>, TB;
|
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 MOVZX32rm8 : I<0xB6, MRMSrcMem, (outs GR32:$dst), (ins i8mem :$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"movz{bl|x}\t{$src, $dst|$dst, $src}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (zextloadi32i8 addr:$src))]>, TB;
|
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 MOVZX32rr16: I<0xB7, MRMSrcReg, (outs GR32:$dst), (ins GR16:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"movz{wl|x}\t{$src, $dst|$dst, $src}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (zext GR16:$src))]>, TB;
|
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 MOVZX32rm16: I<0xB7, MRMSrcMem, (outs GR32:$dst), (ins i16mem:$src),
|
2007-07-31 20:11:57 +00:00
|
|
|
"movz{wl|x}\t{$src, $dst|$dst, $src}",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, (zextloadi32i16 addr:$src))]>, TB;
|
2005-12-14 02:22:27 +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
|
|
|
// These are the same as the regular regular MOVZX32rr8 and MOVZX32rm8
|
|
|
|
// except that they use GR32_NOREX for the output operand register class
|
|
|
|
// instead of GR32. This allows them to operate on h registers on x86-64.
|
|
|
|
def MOVZX32_NOREXrr8 : I<0xB6, MRMSrcReg,
|
|
|
|
(outs GR32_NOREX:$dst), (ins GR8:$src),
|
|
|
|
"movz{bl|x}\t{$src, $dst|$dst, $src} # NOREX",
|
|
|
|
[]>, TB;
|
|
|
|
def MOVZX32_NOREXrm8 : I<0xB6, MRMSrcMem,
|
|
|
|
(outs GR32_NOREX:$dst), (ins i8mem:$src),
|
|
|
|
"movz{bl|x}\t{$src, $dst|$dst, $src} # NOREX",
|
|
|
|
[]>, TB;
|
|
|
|
|
2008-01-10 07:59:24 +00:00
|
|
|
let neverHasSideEffects = 1 in {
|
|
|
|
let Defs = [AX], Uses = [AL] in
|
|
|
|
def CBW : I<0x98, RawFrm, (outs), (ins),
|
|
|
|
"{cbtw|cbw}", []>, OpSize; // AX = signext(AL)
|
|
|
|
let Defs = [EAX], Uses = [AX] in
|
|
|
|
def CWDE : I<0x98, RawFrm, (outs), (ins),
|
|
|
|
"{cwtl|cwde}", []>; // EAX = signext(AX)
|
|
|
|
|
|
|
|
let Defs = [AX,DX], Uses = [AX] in
|
|
|
|
def CWD : I<0x99, RawFrm, (outs), (ins),
|
|
|
|
"{cwtd|cwd}", []>, OpSize; // DX:AX = signext(AX)
|
|
|
|
let Defs = [EAX,EDX], Uses = [EAX] in
|
|
|
|
def CDQ : I<0x99, RawFrm, (outs), (ins),
|
|
|
|
"{cltd|cdq}", []>; // EDX:EAX = signext(EAX)
|
|
|
|
}
|
2006-02-21 02:24:38 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Alias Instructions
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
// Alias instructions that map movr0 to xor.
|
|
|
|
// FIXME: remove when we can teach regalloc that xor reg, reg is ok.
|
2008-05-29 01:02:09 +00:00
|
|
|
let Defs = [EFLAGS], 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 MOV8r0 : I<0x30, MRMInitReg, (outs GR8 :$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"xor{b}\t$dst, $dst",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR8:$dst, 0)]>;
|
2008-07-30 18:09:17 +00:00
|
|
|
// Use xorl instead of xorw since we don't care about the high 16 bits,
|
|
|
|
// it's smaller, and it avoids a partial-register update.
|
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 MOV16r0 : I<0x31, MRMInitReg, (outs GR16:$dst), (ins),
|
2008-07-30 18:09:17 +00:00
|
|
|
"xor{l}\t${dst:subreg32}, ${dst:subreg32}",
|
|
|
|
[(set GR16:$dst, 0)]>;
|
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 MOV32r0 : I<0x31, MRMInitReg, (outs GR32:$dst), (ins),
|
2007-07-31 20:11:57 +00:00
|
|
|
"xor{l}\t$dst, $dst",
|
2006-05-16 07:21:53 +00:00
|
|
|
[(set GR32:$dst, 0)]>;
|
2007-09-07 21:32:51 +00:00
|
|
|
}
|
2006-02-21 02:24:38 +00:00
|
|
|
|
2007-04-20 21:38:10 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Thread Local Storage Instructions
|
|
|
|
//
|
|
|
|
|
2009-04-24 12:59:40 +00:00
|
|
|
// All calls clobber the non-callee saved registers. ESP is marked as
|
|
|
|
// a use to prevent stack-pointer assignments that appear immediately
|
|
|
|
// before calls from potentially appearing dead.
|
|
|
|
let Defs = [EAX, ECX, EDX, FP0, FP1, FP2, FP3, FP4, FP5, FP6, ST0,
|
|
|
|
MM0, MM1, MM2, MM3, MM4, MM5, MM6, MM7,
|
|
|
|
XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7,
|
|
|
|
XMM8, XMM9, XMM10, XMM11, XMM12, XMM13, XMM14, XMM15, EFLAGS],
|
|
|
|
Uses = [ESP, EBX] in
|
2009-04-17 14:35:58 +00:00
|
|
|
def TLS_addr32 : I<0, Pseudo, (outs), (ins i32imm:$sym),
|
2009-04-27 15:13:28 +00:00
|
|
|
"leal\t${sym:mem}(,%ebx,1), %eax; "
|
|
|
|
"call\t___tls_get_addr@PLT",
|
2009-04-17 14:35:58 +00:00
|
|
|
[(X86tlsaddr tglobaltlsaddr:$sym)]>,
|
|
|
|
Requires<[In32BitMode]>;
|
2007-04-20 21:38:10 +00:00
|
|
|
|
2009-01-26 01:24:32 +00:00
|
|
|
let AddedComplexity = 5 in
|
|
|
|
def GS_MOV32rm : I<0x8B, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
|
|
|
|
"movl\t%gs:$src, $dst",
|
|
|
|
[(set GR32:$dst, (gsload addr:$src))]>, SegGS;
|
|
|
|
|
2006-03-07 02:02:57 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// DWARF Pseudo Instructions
|
|
|
|
//
|
|
|
|
|
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 DWARF_LOC : I<0, Pseudo, (outs),
|
|
|
|
(ins i32imm:$line, i32imm:$col, i32imm:$file),
|
2007-09-24 19:25:06 +00:00
|
|
|
".loc\t${file:debug} ${line:debug} ${col:debug}",
|
2006-03-07 02:02:57 +00:00
|
|
|
[(dwarf_loc (i32 imm:$line), (i32 imm:$col),
|
|
|
|
(i32 imm:$file))]>;
|
|
|
|
|
2007-07-14 14:06:15 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// EH Pseudo Instructions
|
|
|
|
//
|
|
|
|
let isTerminator = 1, isReturn = 1, isBarrier = 1,
|
2007-07-21 00:34:19 +00:00
|
|
|
hasCtrlDep = 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 EH_RETURN : I<0xC3, RawFrm, (outs), (ins GR32:$addr),
|
2007-07-31 20:11:57 +00:00
|
|
|
"ret\t#eh_return, addr: $addr",
|
2007-07-14 14:06:15 +00:00
|
|
|
[(X86ehret GR32:$addr)]>;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
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.
|
2008-08-06 15:52:50 +00:00
|
|
|
let Constraints = "$val = $dst" in {
|
2008-04-19 01:20:30 +00:00
|
|
|
def XCHG32rm : I<0x87, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$ptr, GR32:$val),
|
|
|
|
"xchg{l}\t{$val, $ptr|$ptr, $val}",
|
|
|
|
[(set GR32:$dst, (atomic_swap_32 addr:$ptr, GR32:$val))]>;
|
|
|
|
def XCHG16rm : I<0x87, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$ptr, GR16:$val),
|
|
|
|
"xchg{w}\t{$val, $ptr|$ptr, $val}",
|
|
|
|
[(set GR16:$dst, (atomic_swap_16 addr:$ptr, GR16:$val))]>,
|
|
|
|
OpSize;
|
|
|
|
def XCHG8rm : I<0x86, MRMSrcMem, (outs GR8:$dst), (ins i8mem:$ptr, GR8:$val),
|
|
|
|
"xchg{b}\t{$val, $ptr|$ptr, $val}",
|
|
|
|
[(set GR8:$dst, (atomic_swap_8 addr:$ptr, GR8:$val))]>;
|
|
|
|
}
|
|
|
|
|
2008-04-18 20:55:36 +00:00
|
|
|
// Atomic compare and swap.
|
2008-03-01 21:52:34 +00:00
|
|
|
let Defs = [EAX, EFLAGS], Uses = [EAX] in {
|
2008-04-18 20:55:36 +00:00
|
|
|
def LCMPXCHG32 : I<0xB1, MRMDestMem, (outs), (ins i32mem:$ptr, GR32:$swap),
|
2009-04-27 15:13:28 +00:00
|
|
|
"lock\n\t"
|
|
|
|
"cmpxchg{l}\t{$swap, $ptr|$ptr, $swap}",
|
2008-03-04 03:20:06 +00:00
|
|
|
[(X86cas addr:$ptr, GR32:$swap, 4)]>, TB, LOCK;
|
2008-03-01 13:37:02 +00:00
|
|
|
}
|
2008-10-02 18:53:47 +00:00
|
|
|
let Defs = [EAX, EDX, EFLAGS], Uses = [EAX, EBX, ECX, EDX] in {
|
2008-07-22 16:22:48 +00:00
|
|
|
def LCMPXCHG8B : I<0xC7, MRM1m, (outs), (ins i32mem:$ptr),
|
2009-04-27 15:13:28 +00:00
|
|
|
"lock\n\t"
|
|
|
|
"cmpxchg8b\t$ptr",
|
2008-03-05 01:15:49 +00:00
|
|
|
[(X86cas8 addr:$ptr)]>, TB, LOCK;
|
|
|
|
}
|
2008-03-01 21:52:34 +00:00
|
|
|
|
|
|
|
let Defs = [AX, EFLAGS], Uses = [AX] in {
|
2008-04-18 20:55:36 +00:00
|
|
|
def LCMPXCHG16 : I<0xB1, MRMDestMem, (outs), (ins i16mem:$ptr, GR16:$swap),
|
2009-04-27 15:13:28 +00:00
|
|
|
"lock\n\t"
|
|
|
|
"cmpxchg{w}\t{$swap, $ptr|$ptr, $swap}",
|
2008-03-04 03:20:06 +00:00
|
|
|
[(X86cas addr:$ptr, GR16:$swap, 2)]>, TB, OpSize, LOCK;
|
2008-03-01 13:37:02 +00:00
|
|
|
}
|
2008-03-01 21:52:34 +00:00
|
|
|
let Defs = [AL, EFLAGS], Uses = [AL] in {
|
2008-04-18 20:55:36 +00:00
|
|
|
def LCMPXCHG8 : I<0xB0, MRMDestMem, (outs), (ins i8mem:$ptr, GR8:$swap),
|
2009-04-27 15:13:28 +00:00
|
|
|
"lock\n\t"
|
|
|
|
"cmpxchg{b}\t{$swap, $ptr|$ptr, $swap}",
|
2008-03-04 03:20:06 +00:00
|
|
|
[(X86cas addr:$ptr, GR8:$swap, 1)]>, TB, LOCK;
|
2008-03-01 13:37:02 +00:00
|
|
|
}
|
|
|
|
|
2008-04-18 20:55:36 +00:00
|
|
|
// Atomic exchange and add
|
2008-03-01 21:52:34 +00:00
|
|
|
let Constraints = "$val = $dst", Defs = [EFLAGS] in {
|
2008-04-18 20:55:36 +00:00
|
|
|
def LXADD32 : I<0xC1, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$ptr, GR32:$val),
|
2009-04-27 15:13:28 +00:00
|
|
|
"lock\n\t"
|
|
|
|
"xadd{l}\t{$val, $ptr|$ptr, $val}",
|
2008-06-25 08:15:39 +00:00
|
|
|
[(set GR32:$dst, (atomic_load_add_32 addr:$ptr, GR32:$val))]>,
|
2008-03-01 13:37:02 +00:00
|
|
|
TB, LOCK;
|
2008-04-18 20:55:36 +00:00
|
|
|
def LXADD16 : I<0xC1, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$ptr, GR16:$val),
|
2009-04-27 15:13:28 +00:00
|
|
|
"lock\n\t"
|
|
|
|
"xadd{w}\t{$val, $ptr|$ptr, $val}",
|
2008-06-25 08:15:39 +00:00
|
|
|
[(set GR16:$dst, (atomic_load_add_16 addr:$ptr, GR16:$val))]>,
|
2008-03-01 13:37:02 +00:00
|
|
|
TB, OpSize, LOCK;
|
2008-04-18 20:55:36 +00:00
|
|
|
def LXADD8 : I<0xC0, MRMSrcMem, (outs GR8:$dst), (ins i8mem:$ptr, GR8:$val),
|
2009-04-27 15:13:28 +00:00
|
|
|
"lock\n\t"
|
|
|
|
"xadd{b}\t{$val, $ptr|$ptr, $val}",
|
2008-06-25 08:15:39 +00:00
|
|
|
[(set GR8:$dst, (atomic_load_add_8 addr:$ptr, GR8:$val))]>,
|
2008-03-01 13:37:02 +00:00
|
|
|
TB, LOCK;
|
|
|
|
}
|
|
|
|
|
2008-06-25 08:15:39 +00:00
|
|
|
// Atomic exchange, and, or, xor
|
2008-05-05 19:05:59 +00:00
|
|
|
let Constraints = "$val = $dst", Defs = [EFLAGS],
|
|
|
|
usesCustomDAGSchedInserter = 1 in {
|
2008-05-12 20:22:45 +00:00
|
|
|
def ATOMAND32 : I<0, Pseudo, (outs GR32:$dst),(ins i32mem:$ptr, GR32:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMAND32 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR32:$dst, (atomic_load_and_32 addr:$ptr, GR32:$val))]>;
|
2008-05-12 20:22:45 +00:00
|
|
|
def ATOMOR32 : I<0, Pseudo, (outs GR32:$dst),(ins i32mem:$ptr, GR32:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMOR32 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR32:$dst, (atomic_load_or_32 addr:$ptr, GR32:$val))]>;
|
2008-05-12 20:22:45 +00:00
|
|
|
def ATOMXOR32 : I<0, Pseudo,(outs GR32:$dst),(ins i32mem:$ptr, GR32:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMXOR32 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR32:$dst, (atomic_load_xor_32 addr:$ptr, GR32:$val))]>;
|
2008-06-14 05:48:15 +00:00
|
|
|
def ATOMNAND32 : I<0, Pseudo,(outs GR32:$dst),(ins i32mem:$ptr, GR32:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMNAND32 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR32:$dst, (atomic_load_nand_32 addr:$ptr, GR32:$val))]>;
|
2008-05-12 20:22:45 +00:00
|
|
|
def ATOMMIN32: I<0, Pseudo, (outs GR32:$dst), (ins i32mem:$ptr, GR32:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMMIN32 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR32:$dst, (atomic_load_min_32 addr:$ptr, GR32:$val))]>;
|
2008-05-12 20:22:45 +00:00
|
|
|
def ATOMMAX32: I<0, Pseudo, (outs GR32:$dst),(ins i32mem:$ptr, GR32:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMMAX32 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR32:$dst, (atomic_load_max_32 addr:$ptr, GR32:$val))]>;
|
2008-05-12 20:22:45 +00:00
|
|
|
def ATOMUMIN32: I<0, Pseudo, (outs GR32:$dst),(ins i32mem:$ptr, GR32:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMUMIN32 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR32:$dst, (atomic_load_umin_32 addr:$ptr, GR32:$val))]>;
|
2008-05-12 20:22:45 +00:00
|
|
|
def ATOMUMAX32: I<0, Pseudo, (outs GR32:$dst),(ins i32mem:$ptr, GR32:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMUMAX32 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR32:$dst, (atomic_load_umax_32 addr:$ptr, GR32:$val))]>;
|
2008-08-19 18:47:28 +00:00
|
|
|
|
|
|
|
def ATOMAND16 : I<0, Pseudo, (outs GR16:$dst),(ins i16mem:$ptr, GR16:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMAND16 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR16:$dst, (atomic_load_and_16 addr:$ptr, GR16:$val))]>;
|
2008-08-19 18:47:28 +00:00
|
|
|
def ATOMOR16 : I<0, Pseudo, (outs GR16:$dst),(ins i16mem:$ptr, GR16:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMOR16 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR16:$dst, (atomic_load_or_16 addr:$ptr, GR16:$val))]>;
|
2008-08-19 18:47:28 +00:00
|
|
|
def ATOMXOR16 : I<0, Pseudo,(outs GR16:$dst),(ins i16mem:$ptr, GR16:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMXOR16 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR16:$dst, (atomic_load_xor_16 addr:$ptr, GR16:$val))]>;
|
2008-08-19 18:47:28 +00:00
|
|
|
def ATOMNAND16 : I<0, Pseudo,(outs GR16:$dst),(ins i16mem:$ptr, GR16:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMNAND16 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR16:$dst, (atomic_load_nand_16 addr:$ptr, GR16:$val))]>;
|
2008-08-19 18:47:28 +00:00
|
|
|
def ATOMMIN16: I<0, Pseudo, (outs GR16:$dst), (ins i16mem:$ptr, GR16:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMMIN16 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR16:$dst, (atomic_load_min_16 addr:$ptr, GR16:$val))]>;
|
2008-08-19 18:47:28 +00:00
|
|
|
def ATOMMAX16: I<0, Pseudo, (outs GR16:$dst),(ins i16mem:$ptr, GR16:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMMAX16 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR16:$dst, (atomic_load_max_16 addr:$ptr, GR16:$val))]>;
|
2008-08-19 18:47:28 +00:00
|
|
|
def ATOMUMIN16: I<0, Pseudo, (outs GR16:$dst),(ins i16mem:$ptr, GR16:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMUMIN16 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR16:$dst, (atomic_load_umin_16 addr:$ptr, GR16:$val))]>;
|
2008-08-19 18:47:28 +00:00
|
|
|
def ATOMUMAX16: I<0, Pseudo, (outs GR16:$dst),(ins i16mem:$ptr, GR16:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMUMAX16 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR16:$dst, (atomic_load_umax_16 addr:$ptr, GR16:$val))]>;
|
2008-08-19 18:47:28 +00:00
|
|
|
|
|
|
|
def ATOMAND8 : I<0, Pseudo, (outs GR8:$dst),(ins i8mem:$ptr, GR8:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMAND8 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR8:$dst, (atomic_load_and_8 addr:$ptr, GR8:$val))]>;
|
2008-08-19 18:47:28 +00:00
|
|
|
def ATOMOR8 : I<0, Pseudo, (outs GR8:$dst),(ins i8mem:$ptr, GR8:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMOR8 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR8:$dst, (atomic_load_or_8 addr:$ptr, GR8:$val))]>;
|
2008-08-19 18:47:28 +00:00
|
|
|
def ATOMXOR8 : I<0, Pseudo,(outs GR8:$dst),(ins i8mem:$ptr, GR8:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMXOR8 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR8:$dst, (atomic_load_xor_8 addr:$ptr, GR8:$val))]>;
|
2008-08-19 18:47:28 +00:00
|
|
|
def ATOMNAND8 : I<0, Pseudo,(outs GR8:$dst),(ins i8mem:$ptr, GR8:$val),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMNAND8 PSEUDO!",
|
2008-08-28 02:44:49 +00:00
|
|
|
[(set GR8:$dst, (atomic_load_nand_8 addr:$ptr, GR8:$val))]>;
|
2008-05-05 19:05:59 +00:00
|
|
|
}
|
|
|
|
|
2008-10-02 18:53:47 +00:00
|
|
|
let Constraints = "$val1 = $dst1, $val2 = $dst2",
|
|
|
|
Defs = [EFLAGS, EAX, EBX, ECX, EDX],
|
|
|
|
Uses = [EAX, EBX, ECX, EDX],
|
2008-10-03 19:41:08 +00:00
|
|
|
mayLoad = 1, mayStore = 1,
|
2008-10-02 18:53:47 +00:00
|
|
|
usesCustomDAGSchedInserter = 1 in {
|
|
|
|
def ATOMAND6432 : I<0, Pseudo, (outs GR32:$dst1, GR32:$dst2),
|
|
|
|
(ins i64mem:$ptr, GR32:$val1, GR32:$val2),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMAND6432 PSEUDO!", []>;
|
2008-10-02 18:53:47 +00:00
|
|
|
def ATOMOR6432 : I<0, Pseudo, (outs GR32:$dst1, GR32:$dst2),
|
|
|
|
(ins i64mem:$ptr, GR32:$val1, GR32:$val2),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMOR6432 PSEUDO!", []>;
|
2008-10-02 18:53:47 +00:00
|
|
|
def ATOMXOR6432 : I<0, Pseudo, (outs GR32:$dst1, GR32:$dst2),
|
|
|
|
(ins i64mem:$ptr, GR32:$val1, GR32:$val2),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMXOR6432 PSEUDO!", []>;
|
2008-10-02 18:53:47 +00:00
|
|
|
def ATOMNAND6432 : I<0, Pseudo, (outs GR32:$dst1, GR32:$dst2),
|
|
|
|
(ins i64mem:$ptr, GR32:$val1, GR32:$val2),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMNAND6432 PSEUDO!", []>;
|
2008-10-02 18:53:47 +00:00
|
|
|
def ATOMADD6432 : I<0, Pseudo, (outs GR32:$dst1, GR32:$dst2),
|
|
|
|
(ins i64mem:$ptr, GR32:$val1, GR32:$val2),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMADD6432 PSEUDO!", []>;
|
2008-10-02 18:53:47 +00:00
|
|
|
def ATOMSUB6432 : I<0, Pseudo, (outs GR32:$dst1, GR32:$dst2),
|
|
|
|
(ins i64mem:$ptr, GR32:$val1, GR32:$val2),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMSUB6432 PSEUDO!", []>;
|
2008-10-03 22:25:52 +00:00
|
|
|
def ATOMSWAP6432 : I<0, Pseudo, (outs GR32:$dst1, GR32:$dst2),
|
|
|
|
(ins i64mem:$ptr, GR32:$val1, GR32:$val2),
|
2008-12-07 03:49:52 +00:00
|
|
|
"#ATOMSWAP6432 PSEUDO!", []>;
|
2008-10-02 18:53:47 +00:00
|
|
|
}
|
|
|
|
|
2006-01-09 23:10:28 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Non-Instruction Patterns
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2008-09-16 21:48:12 +00:00
|
|
|
// ConstantPool GlobalAddress, ExternalSymbol, and JumpTable
|
2006-02-25 10:02:21 +00:00
|
|
|
def : Pat<(i32 (X86Wrapper tconstpool :$dst)), (MOV32ri tconstpool :$dst)>;
|
2006-04-22 18:53:45 +00:00
|
|
|
def : Pat<(i32 (X86Wrapper tjumptable :$dst)), (MOV32ri tjumptable :$dst)>;
|
2008-04-12 00:47:57 +00:00
|
|
|
def : Pat<(i32 (X86Wrapper tglobaltlsaddr:$dst)),(MOV32ri tglobaltlsaddr:$dst)>;
|
2006-02-25 10:02:21 +00:00
|
|
|
def : Pat<(i32 (X86Wrapper tglobaladdr :$dst)), (MOV32ri tglobaladdr :$dst)>;
|
|
|
|
def : Pat<(i32 (X86Wrapper texternalsym:$dst)), (MOV32ri texternalsym:$dst)>;
|
|
|
|
|
2006-05-16 07:21:53 +00:00
|
|
|
def : Pat<(add GR32:$src1, (X86Wrapper tconstpool:$src2)),
|
|
|
|
(ADD32ri GR32:$src1, tconstpool:$src2)>;
|
|
|
|
def : Pat<(add GR32:$src1, (X86Wrapper tjumptable:$src2)),
|
|
|
|
(ADD32ri GR32:$src1, tjumptable:$src2)>;
|
|
|
|
def : Pat<(add GR32:$src1, (X86Wrapper tglobaladdr :$src2)),
|
|
|
|
(ADD32ri GR32:$src1, tglobaladdr:$src2)>;
|
|
|
|
def : Pat<(add GR32:$src1, (X86Wrapper texternalsym:$src2)),
|
|
|
|
(ADD32ri GR32:$src1, texternalsym:$src2)>;
|
2006-02-25 10:02:21 +00:00
|
|
|
|
2006-05-19 07:30:36 +00:00
|
|
|
def : Pat<(store (i32 (X86Wrapper tglobaladdr:$src)), addr:$dst),
|
2006-02-25 10:02:21 +00:00
|
|
|
(MOV32mi addr:$dst, tglobaladdr:$src)>;
|
2006-05-19 07:30:36 +00:00
|
|
|
def : Pat<(store (i32 (X86Wrapper texternalsym:$src)), addr:$dst),
|
2006-02-25 10:02:21 +00:00
|
|
|
(MOV32mi addr:$dst, texternalsym:$src)>;
|
|
|
|
|
2006-01-09 23:10:28 +00:00
|
|
|
// Calls
|
2007-10-11 19:40:01 +00:00
|
|
|
// tailcall stuff
|
2006-05-16 07:21:53 +00:00
|
|
|
def : Pat<(X86tailcall GR32:$dst),
|
2007-10-11 19:40:01 +00:00
|
|
|
(TAILCALL)>;
|
2006-04-27 08:40:39 +00:00
|
|
|
|
2006-09-08 06:48:29 +00:00
|
|
|
def : Pat<(X86tailcall (i32 tglobaladdr:$dst)),
|
2007-10-11 19:40:01 +00:00
|
|
|
(TAILCALL)>;
|
2006-09-08 06:48:29 +00:00
|
|
|
def : Pat<(X86tailcall (i32 texternalsym:$dst)),
|
2007-10-11 19:40:01 +00:00
|
|
|
(TAILCALL)>;
|
|
|
|
|
|
|
|
def : Pat<(X86tcret GR32:$dst, imm:$off),
|
|
|
|
(TCRETURNri GR32:$dst, imm:$off)>;
|
|
|
|
|
|
|
|
def : Pat<(X86tcret (i32 tglobaladdr:$dst), imm:$off),
|
|
|
|
(TCRETURNdi texternalsym:$dst, imm:$off)>;
|
|
|
|
|
|
|
|
def : Pat<(X86tcret (i32 texternalsym:$dst), imm:$off),
|
|
|
|
(TCRETURNdi texternalsym:$dst, imm:$off)>;
|
2006-04-27 08:40:39 +00:00
|
|
|
|
2006-09-08 06:48:29 +00:00
|
|
|
def : Pat<(X86call (i32 tglobaladdr:$dst)),
|
2006-01-09 23:10:28 +00:00
|
|
|
(CALLpcrel32 tglobaladdr:$dst)>;
|
2006-09-08 06:48:29 +00:00
|
|
|
def : Pat<(X86call (i32 texternalsym:$dst)),
|
2006-01-11 06:09:51 +00:00
|
|
|
(CALLpcrel32 texternalsym:$dst)>;
|
2006-01-09 23:10:28 +00:00
|
|
|
|
|
|
|
// X86 specific add which produces a flag.
|
2006-05-16 07:21:53 +00:00
|
|
|
def : Pat<(addc GR32:$src1, GR32:$src2),
|
|
|
|
(ADD32rr GR32:$src1, GR32:$src2)>;
|
|
|
|
def : Pat<(addc GR32:$src1, (load addr:$src2)),
|
|
|
|
(ADD32rm GR32:$src1, addr:$src2)>;
|
|
|
|
def : Pat<(addc GR32:$src1, imm:$src2),
|
|
|
|
(ADD32ri GR32:$src1, imm:$src2)>;
|
|
|
|
def : Pat<(addc GR32:$src1, i32immSExt8:$src2),
|
|
|
|
(ADD32ri8 GR32:$src1, i32immSExt8:$src2)>;
|
|
|
|
|
|
|
|
def : Pat<(subc GR32:$src1, GR32:$src2),
|
|
|
|
(SUB32rr GR32:$src1, GR32:$src2)>;
|
|
|
|
def : Pat<(subc GR32:$src1, (load addr:$src2)),
|
|
|
|
(SUB32rm GR32:$src1, addr:$src2)>;
|
|
|
|
def : Pat<(subc GR32:$src1, imm:$src2),
|
|
|
|
(SUB32ri GR32:$src1, imm:$src2)>;
|
|
|
|
def : Pat<(subc GR32:$src1, i32immSExt8:$src2),
|
|
|
|
(SUB32ri8 GR32:$src1, i32immSExt8:$src2)>;
|
2006-01-09 23:10:28 +00:00
|
|
|
|
2006-09-07 20:33:45 +00:00
|
|
|
// Comparisons.
|
|
|
|
|
|
|
|
// TEST R,R is smaller than CMP R,0
|
2007-09-29 00:00:36 +00:00
|
|
|
def : Pat<(parallel (X86cmp GR8:$src1, 0), (implicit EFLAGS)),
|
2006-09-07 20:33:45 +00:00
|
|
|
(TEST8rr GR8:$src1, GR8:$src1)>;
|
2007-09-29 00:00:36 +00:00
|
|
|
def : Pat<(parallel (X86cmp GR16:$src1, 0), (implicit EFLAGS)),
|
2006-09-07 20:33:45 +00:00
|
|
|
(TEST16rr GR16:$src1, GR16:$src1)>;
|
2007-09-29 00:00:36 +00:00
|
|
|
def : Pat<(parallel (X86cmp GR32:$src1, 0), (implicit EFLAGS)),
|
2006-09-07 20:33:45 +00:00
|
|
|
(TEST32rr GR32:$src1, GR32:$src1)>;
|
|
|
|
|
2009-01-07 01:00:24 +00:00
|
|
|
// Conditional moves with folded loads with operands swapped and conditions
|
|
|
|
// inverted.
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_B, EFLAGS),
|
|
|
|
(CMOVAE16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_B, EFLAGS),
|
|
|
|
(CMOVAE32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_AE, EFLAGS),
|
|
|
|
(CMOVB16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_AE, EFLAGS),
|
|
|
|
(CMOVB32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_E, EFLAGS),
|
|
|
|
(CMOVNE16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_E, EFLAGS),
|
|
|
|
(CMOVNE32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_NE, EFLAGS),
|
|
|
|
(CMOVE16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_NE, EFLAGS),
|
|
|
|
(CMOVE32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_BE, EFLAGS),
|
|
|
|
(CMOVA16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_BE, EFLAGS),
|
|
|
|
(CMOVA32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_A, EFLAGS),
|
|
|
|
(CMOVBE16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_A, EFLAGS),
|
|
|
|
(CMOVBE32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_L, EFLAGS),
|
|
|
|
(CMOVGE16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_L, EFLAGS),
|
|
|
|
(CMOVGE32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_GE, EFLAGS),
|
|
|
|
(CMOVL16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_GE, EFLAGS),
|
|
|
|
(CMOVL32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_LE, EFLAGS),
|
|
|
|
(CMOVG16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_LE, EFLAGS),
|
|
|
|
(CMOVG32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_G, EFLAGS),
|
|
|
|
(CMOVLE16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_G, EFLAGS),
|
|
|
|
(CMOVLE32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_P, EFLAGS),
|
|
|
|
(CMOVNP16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_P, EFLAGS),
|
|
|
|
(CMOVNP32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_NP, EFLAGS),
|
|
|
|
(CMOVP16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_NP, EFLAGS),
|
|
|
|
(CMOVP32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_S, EFLAGS),
|
|
|
|
(CMOVNS16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_S, EFLAGS),
|
|
|
|
(CMOVNS32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_NS, EFLAGS),
|
|
|
|
(CMOVS16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_NS, EFLAGS),
|
|
|
|
(CMOVS32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_O, EFLAGS),
|
|
|
|
(CMOVNO16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_O, EFLAGS),
|
|
|
|
(CMOVNO32rm GR32:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi16 addr:$src1), GR16:$src2, X86_COND_NO, EFLAGS),
|
|
|
|
(CMOVO16rm GR16:$src2, addr:$src1)>;
|
|
|
|
def : Pat<(X86cmov (loadi32 addr:$src1), GR32:$src2, X86_COND_NO, EFLAGS),
|
|
|
|
(CMOVO32rm GR32:$src2, addr:$src1)>;
|
|
|
|
|
2008-01-23 20:39:46 +00:00
|
|
|
// zextload bool -> zextload byte
|
2006-01-17 07:02:46 +00:00
|
|
|
def : Pat<(zextloadi8i1 addr:$src), (MOV8rm addr:$src)>;
|
2006-01-09 23:10:28 +00:00
|
|
|
def : Pat<(zextloadi16i1 addr:$src), (MOVZX16rm8 addr:$src)>;
|
|
|
|
def : Pat<(zextloadi32i1 addr:$src), (MOVZX32rm8 addr:$src)>;
|
|
|
|
|
|
|
|
// extload bool -> extload byte
|
2006-05-05 08:23:07 +00:00
|
|
|
def : Pat<(extloadi8i1 addr:$src), (MOV8rm addr:$src)>;
|
2008-08-22 20:51:05 +00:00
|
|
|
def : Pat<(extloadi16i1 addr:$src), (MOVZX16rm8 addr:$src)>,
|
|
|
|
Requires<[In32BitMode]>;
|
2006-05-05 08:23:07 +00:00
|
|
|
def : Pat<(extloadi32i1 addr:$src), (MOVZX32rm8 addr:$src)>;
|
2008-08-22 20:51:05 +00:00
|
|
|
def : Pat<(extloadi16i8 addr:$src), (MOVZX16rm8 addr:$src)>,
|
|
|
|
Requires<[In32BitMode]>;
|
2006-05-05 08:23:07 +00:00
|
|
|
def : Pat<(extloadi32i8 addr:$src), (MOVZX32rm8 addr:$src)>;
|
|
|
|
def : Pat<(extloadi32i16 addr:$src), (MOVZX32rm16 addr:$src)>;
|
2006-01-09 23:10:28 +00:00
|
|
|
|
2008-08-20 21:27:32 +00:00
|
|
|
// anyext
|
2008-08-22 20:51:05 +00:00
|
|
|
def : Pat<(i16 (anyext GR8 :$src)), (MOVZX16rr8 GR8 :$src)>,
|
|
|
|
Requires<[In32BitMode]>;
|
|
|
|
def : Pat<(i32 (anyext GR8 :$src)), (MOVZX32rr8 GR8 :$src)>,
|
|
|
|
Requires<[In32BitMode]>;
|
2008-08-20 21:27:32 +00:00
|
|
|
def : Pat<(i32 (anyext GR16:$src)),
|
|
|
|
(INSERT_SUBREG (i32 (IMPLICIT_DEF)), GR16:$src, x86_subreg_16bit)>;
|
2006-01-09 23:10:28 +00:00
|
|
|
|
2007-12-13 00:43:27 +00:00
|
|
|
// (and (i32 load), 255) -> (zextload i8)
|
2008-09-29 17:26:18 +00:00
|
|
|
def : Pat<(i32 (and (nvloadi32 addr:$src), (i32 255))),
|
|
|
|
(MOVZX32rm8 addr:$src)>;
|
|
|
|
def : Pat<(i32 (and (nvloadi32 addr:$src), (i32 65535))),
|
|
|
|
(MOVZX32rm16 addr:$src)>;
|
2007-12-13 00:43:27 +00:00
|
|
|
|
2006-01-06 02:31:59 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Some peepholes
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2008-10-17 01:33:43 +00:00
|
|
|
// Odd encoding trick: -128 fits into an 8-bit immediate field while
|
|
|
|
// +128 doesn't, so in this special case use a sub instead of an add.
|
|
|
|
def : Pat<(add GR16:$src1, 128),
|
|
|
|
(SUB16ri8 GR16:$src1, -128)>;
|
|
|
|
def : Pat<(store (add (loadi16 addr:$dst), 128), addr:$dst),
|
|
|
|
(SUB16mi8 addr:$dst, -128)>;
|
|
|
|
def : Pat<(add GR32:$src1, 128),
|
|
|
|
(SUB32ri8 GR32:$src1, -128)>;
|
|
|
|
def : Pat<(store (add (loadi32 addr:$dst), 128), addr:$dst),
|
|
|
|
(SUB32mi8 addr:$dst, -128)>;
|
|
|
|
|
2008-07-30 18:09:17 +00:00
|
|
|
// r & (2^16-1) ==> movz
|
|
|
|
def : Pat<(and GR32:$src1, 0xffff),
|
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
|
|
|
(MOVZX32rr16 (EXTRACT_SUBREG GR32:$src1, x86_subreg_16bit))>;
|
2008-08-06 18:27:21 +00:00
|
|
|
// r & (2^8-1) ==> movz
|
|
|
|
def : Pat<(and GR32:$src1, 0xff),
|
2009-04-27 16:33:14 +00:00
|
|
|
(MOVZX32rr8 (EXTRACT_SUBREG (COPY_TO_REGCLASS GR32:$src1, GR32_ABCD),
|
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
|
|
|
x86_subreg_8bit))>,
|
2008-08-06 18:27:21 +00:00
|
|
|
Requires<[In32BitMode]>;
|
|
|
|
// r & (2^8-1) ==> movz
|
|
|
|
def : Pat<(and GR16:$src1, 0xff),
|
2009-04-27 16:33:14 +00:00
|
|
|
(MOVZX16rr8 (EXTRACT_SUBREG (COPY_TO_REGCLASS GR16:$src1, GR16_ABCD),
|
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
|
|
|
x86_subreg_8bit))>,
|
2008-08-20 21:27:32 +00:00
|
|
|
Requires<[In32BitMode]>;
|
|
|
|
|
|
|
|
// sext_inreg patterns
|
|
|
|
def : Pat<(sext_inreg GR32:$src, i16),
|
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
|
|
|
(MOVSX32rr16 (EXTRACT_SUBREG GR32:$src, x86_subreg_16bit))>;
|
2008-08-20 21:27:32 +00:00
|
|
|
def : Pat<(sext_inreg GR32:$src, i8),
|
2009-04-27 16:33:14 +00:00
|
|
|
(MOVSX32rr8 (EXTRACT_SUBREG (COPY_TO_REGCLASS GR32:$src, GR32_ABCD),
|
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
|
|
|
x86_subreg_8bit))>,
|
2008-08-20 21:27:32 +00:00
|
|
|
Requires<[In32BitMode]>;
|
|
|
|
def : Pat<(sext_inreg GR16:$src, i8),
|
2009-04-27 16:33:14 +00:00
|
|
|
(MOVSX16rr8 (EXTRACT_SUBREG (COPY_TO_REGCLASS GR16:$src, GR16_ABCD),
|
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
|
|
|
x86_subreg_8bit))>,
|
2008-08-20 21:27:32 +00:00
|
|
|
Requires<[In32BitMode]>;
|
|
|
|
|
|
|
|
// trunc patterns
|
|
|
|
def : Pat<(i16 (trunc GR32:$src)),
|
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
|
|
|
(EXTRACT_SUBREG GR32:$src, x86_subreg_16bit)>;
|
2008-08-20 21:27:32 +00:00
|
|
|
def : Pat<(i8 (trunc GR32:$src)),
|
2009-04-27 16:33:14 +00:00
|
|
|
(EXTRACT_SUBREG (COPY_TO_REGCLASS GR32:$src, GR32_ABCD),
|
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
|
|
|
x86_subreg_8bit)>,
|
2008-08-20 21:27:32 +00:00
|
|
|
Requires<[In32BitMode]>;
|
|
|
|
def : Pat<(i8 (trunc GR16:$src)),
|
2009-04-27 16:33:14 +00:00
|
|
|
(EXTRACT_SUBREG (COPY_TO_REGCLASS GR16:$src, GR16_ABCD),
|
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
|
|
|
x86_subreg_8bit)>,
|
|
|
|
Requires<[In32BitMode]>;
|
|
|
|
|
|
|
|
// h-register tricks
|
|
|
|
def : Pat<(i8 (trunc (srl_su GR16:$src, (i8 8)))),
|
2009-04-27 16:33:14 +00:00
|
|
|
(EXTRACT_SUBREG (COPY_TO_REGCLASS GR16:$src, GR16_ABCD),
|
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
|
|
|
x86_subreg_8bit_hi)>,
|
|
|
|
Requires<[In32BitMode]>;
|
|
|
|
def : Pat<(i8 (trunc (srl_su GR32:$src, (i8 8)))),
|
2009-04-27 16:33:14 +00:00
|
|
|
(EXTRACT_SUBREG (COPY_TO_REGCLASS GR32:$src, GR32_ABCD),
|
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
|
|
|
x86_subreg_8bit_hi)>,
|
|
|
|
Requires<[In32BitMode]>;
|
|
|
|
def : Pat<(srl_su GR16:$src, (i8 8)),
|
|
|
|
(EXTRACT_SUBREG
|
|
|
|
(MOVZX32rr8
|
2009-04-27 16:33:14 +00:00
|
|
|
(EXTRACT_SUBREG (COPY_TO_REGCLASS GR16:$src, GR16_ABCD),
|
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
|
|
|
x86_subreg_8bit_hi)),
|
|
|
|
x86_subreg_16bit)>,
|
|
|
|
Requires<[In32BitMode]>;
|
|
|
|
def : Pat<(and (srl_su GR32:$src, (i8 8)), (i32 255)),
|
2009-04-27 16:33:14 +00:00
|
|
|
(MOVZX32rr8 (EXTRACT_SUBREG (COPY_TO_REGCLASS GR32:$src, GR32_ABCD),
|
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
|
|
|
x86_subreg_8bit_hi))>,
|
2008-08-06 18:27:21 +00:00
|
|
|
Requires<[In32BitMode]>;
|
2008-07-30 18:09:17 +00:00
|
|
|
|
2006-01-06 02:31:59 +00:00
|
|
|
// (shl x, 1) ==> (add x, x)
|
2006-05-16 07:21:53 +00:00
|
|
|
def : Pat<(shl GR8 :$src1, (i8 1)), (ADD8rr GR8 :$src1, GR8 :$src1)>;
|
|
|
|
def : Pat<(shl GR16:$src1, (i8 1)), (ADD16rr GR16:$src1, GR16:$src1)>;
|
|
|
|
def : Pat<(shl GR32:$src1, (i8 1)), (ADD32rr GR32:$src1, GR32:$src1)>;
|
2006-01-19 01:56:29 +00:00
|
|
|
|
2008-08-30 02:03:58 +00:00
|
|
|
// (shl x (and y, 31)) ==> (shl x, y)
|
|
|
|
def : Pat<(shl GR8:$src1, (and CL:$amt, 31)),
|
|
|
|
(SHL8rCL GR8:$src1)>;
|
|
|
|
def : Pat<(shl GR16:$src1, (and CL:$amt, 31)),
|
|
|
|
(SHL16rCL GR16:$src1)>;
|
|
|
|
def : Pat<(shl GR32:$src1, (and CL:$amt, 31)),
|
|
|
|
(SHL32rCL GR32:$src1)>;
|
|
|
|
def : Pat<(store (shl (loadi8 addr:$dst), (and CL:$amt, 31)), addr:$dst),
|
|
|
|
(SHL8mCL addr:$dst)>;
|
|
|
|
def : Pat<(store (shl (loadi16 addr:$dst), (and CL:$amt, 31)), addr:$dst),
|
|
|
|
(SHL16mCL addr:$dst)>;
|
|
|
|
def : Pat<(store (shl (loadi32 addr:$dst), (and CL:$amt, 31)), addr:$dst),
|
|
|
|
(SHL32mCL addr:$dst)>;
|
|
|
|
|
|
|
|
def : Pat<(srl GR8:$src1, (and CL:$amt, 31)),
|
|
|
|
(SHR8rCL GR8:$src1)>;
|
|
|
|
def : Pat<(srl GR16:$src1, (and CL:$amt, 31)),
|
|
|
|
(SHR16rCL GR16:$src1)>;
|
|
|
|
def : Pat<(srl GR32:$src1, (and CL:$amt, 31)),
|
|
|
|
(SHR32rCL GR32:$src1)>;
|
|
|
|
def : Pat<(store (srl (loadi8 addr:$dst), (and CL:$amt, 31)), addr:$dst),
|
|
|
|
(SHR8mCL addr:$dst)>;
|
|
|
|
def : Pat<(store (srl (loadi16 addr:$dst), (and CL:$amt, 31)), addr:$dst),
|
|
|
|
(SHR16mCL addr:$dst)>;
|
|
|
|
def : Pat<(store (srl (loadi32 addr:$dst), (and CL:$amt, 31)), addr:$dst),
|
|
|
|
(SHR32mCL addr:$dst)>;
|
|
|
|
|
|
|
|
def : Pat<(sra GR8:$src1, (and CL:$amt, 31)),
|
|
|
|
(SAR8rCL GR8:$src1)>;
|
|
|
|
def : Pat<(sra GR16:$src1, (and CL:$amt, 31)),
|
|
|
|
(SAR16rCL GR16:$src1)>;
|
|
|
|
def : Pat<(sra GR32:$src1, (and CL:$amt, 31)),
|
|
|
|
(SAR32rCL GR32:$src1)>;
|
|
|
|
def : Pat<(store (sra (loadi8 addr:$dst), (and CL:$amt, 31)), addr:$dst),
|
|
|
|
(SAR8mCL addr:$dst)>;
|
|
|
|
def : Pat<(store (sra (loadi16 addr:$dst), (and CL:$amt, 31)), addr:$dst),
|
|
|
|
(SAR16mCL addr:$dst)>;
|
|
|
|
def : Pat<(store (sra (loadi32 addr:$dst), (and CL:$amt, 31)), addr:$dst),
|
|
|
|
(SAR32mCL addr:$dst)>;
|
|
|
|
|
2006-01-19 23:26:24 +00:00
|
|
|
// (or (x >> c) | (y << (32 - c))) ==> (shrd32 x, y, c)
|
2006-05-16 07:21:53 +00:00
|
|
|
def : Pat<(or (srl GR32:$src1, CL:$amt),
|
|
|
|
(shl GR32:$src2, (sub 32, CL:$amt))),
|
|
|
|
(SHRD32rrCL GR32:$src1, GR32:$src2)>;
|
2006-01-19 01:56:29 +00:00
|
|
|
|
2006-01-20 01:13:30 +00:00
|
|
|
def : Pat<(store (or (srl (loadi32 addr:$dst), CL:$amt),
|
2006-05-16 07:21:53 +00:00
|
|
|
(shl GR32:$src2, (sub 32, CL:$amt))), addr:$dst),
|
|
|
|
(SHRD32mrCL addr:$dst, GR32:$src2)>;
|
2006-01-20 01:13:30 +00:00
|
|
|
|
2008-10-17 01:23:35 +00:00
|
|
|
def : Pat<(or (srl GR32:$src1, (i8 (trunc ECX:$amt))),
|
|
|
|
(shl GR32:$src2, (i8 (trunc (sub 32, ECX:$amt))))),
|
|
|
|
(SHRD32rrCL GR32:$src1, GR32:$src2)>;
|
|
|
|
|
|
|
|
def : Pat<(store (or (srl (loadi32 addr:$dst), (i8 (trunc ECX:$amt))),
|
|
|
|
(shl GR32:$src2, (i8 (trunc (sub 32, ECX:$amt))))),
|
|
|
|
addr:$dst),
|
|
|
|
(SHRD32mrCL addr:$dst, GR32:$src2)>;
|
|
|
|
|
|
|
|
def : Pat<(shrd GR32:$src1, (i8 imm:$amt1), GR32:$src2, (i8 imm:$amt2)),
|
|
|
|
(SHRD32rri8 GR32:$src1, GR32:$src2, (i8 imm:$amt1))>;
|
|
|
|
|
|
|
|
def : Pat<(store (shrd (loadi32 addr:$dst), (i8 imm:$amt1),
|
|
|
|
GR32:$src2, (i8 imm:$amt2)), addr:$dst),
|
|
|
|
(SHRD32mri8 addr:$dst, GR32:$src2, (i8 imm:$amt1))>;
|
|
|
|
|
2006-01-19 23:26:24 +00:00
|
|
|
// (or (x << c) | (y >> (32 - c))) ==> (shld32 x, y, c)
|
2006-05-16 07:21:53 +00:00
|
|
|
def : Pat<(or (shl GR32:$src1, CL:$amt),
|
|
|
|
(srl GR32:$src2, (sub 32, CL:$amt))),
|
|
|
|
(SHLD32rrCL GR32:$src1, GR32:$src2)>;
|
2006-01-19 23:26:24 +00:00
|
|
|
|
2006-01-20 01:13:30 +00:00
|
|
|
def : Pat<(store (or (shl (loadi32 addr:$dst), CL:$amt),
|
2006-05-16 07:21:53 +00:00
|
|
|
(srl GR32:$src2, (sub 32, CL:$amt))), addr:$dst),
|
|
|
|
(SHLD32mrCL addr:$dst, GR32:$src2)>;
|
2006-01-20 01:13:30 +00:00
|
|
|
|
2008-10-17 01:23:35 +00:00
|
|
|
def : Pat<(or (shl GR32:$src1, (i8 (trunc ECX:$amt))),
|
|
|
|
(srl GR32:$src2, (i8 (trunc (sub 32, ECX:$amt))))),
|
|
|
|
(SHLD32rrCL GR32:$src1, GR32:$src2)>;
|
|
|
|
|
|
|
|
def : Pat<(store (or (shl (loadi32 addr:$dst), (i8 (trunc ECX:$amt))),
|
|
|
|
(srl GR32:$src2, (i8 (trunc (sub 32, ECX:$amt))))),
|
|
|
|
addr:$dst),
|
|
|
|
(SHLD32mrCL addr:$dst, GR32:$src2)>;
|
|
|
|
|
|
|
|
def : Pat<(shld GR32:$src1, (i8 imm:$amt1), GR32:$src2, (i8 imm:$amt2)),
|
|
|
|
(SHLD32rri8 GR32:$src1, GR32:$src2, (i8 imm:$amt1))>;
|
|
|
|
|
|
|
|
def : Pat<(store (shld (loadi32 addr:$dst), (i8 imm:$amt1),
|
|
|
|
GR32:$src2, (i8 imm:$amt2)), addr:$dst),
|
|
|
|
(SHLD32mri8 addr:$dst, GR32:$src2, (i8 imm:$amt1))>;
|
|
|
|
|
2006-01-19 23:26:24 +00:00
|
|
|
// (or (x >> c) | (y << (16 - c))) ==> (shrd16 x, y, c)
|
2006-05-16 07:21:53 +00:00
|
|
|
def : Pat<(or (srl GR16:$src1, CL:$amt),
|
|
|
|
(shl GR16:$src2, (sub 16, CL:$amt))),
|
|
|
|
(SHRD16rrCL GR16:$src1, GR16:$src2)>;
|
2006-01-19 23:26:24 +00:00
|
|
|
|
2006-01-20 01:13:30 +00:00
|
|
|
def : Pat<(store (or (srl (loadi16 addr:$dst), CL:$amt),
|
2006-05-16 07:21:53 +00:00
|
|
|
(shl GR16:$src2, (sub 16, CL:$amt))), addr:$dst),
|
|
|
|
(SHRD16mrCL addr:$dst, GR16:$src2)>;
|
2006-01-20 01:13:30 +00:00
|
|
|
|
2008-10-17 01:23:35 +00:00
|
|
|
def : Pat<(or (srl GR16:$src1, (i8 (trunc CX:$amt))),
|
|
|
|
(shl GR16:$src2, (i8 (trunc (sub 16, CX:$amt))))),
|
|
|
|
(SHRD16rrCL GR16:$src1, GR16:$src2)>;
|
|
|
|
|
|
|
|
def : Pat<(store (or (srl (loadi16 addr:$dst), (i8 (trunc CX:$amt))),
|
|
|
|
(shl GR16:$src2, (i8 (trunc (sub 16, CX:$amt))))),
|
|
|
|
addr:$dst),
|
|
|
|
(SHRD16mrCL addr:$dst, GR16:$src2)>;
|
|
|
|
|
|
|
|
def : Pat<(shrd GR16:$src1, (i8 imm:$amt1), GR16:$src2, (i8 imm:$amt2)),
|
|
|
|
(SHRD16rri8 GR16:$src1, GR16:$src2, (i8 imm:$amt1))>;
|
|
|
|
|
|
|
|
def : Pat<(store (shrd (loadi16 addr:$dst), (i8 imm:$amt1),
|
|
|
|
GR16:$src2, (i8 imm:$amt2)), addr:$dst),
|
|
|
|
(SHRD16mri8 addr:$dst, GR16:$src2, (i8 imm:$amt1))>;
|
|
|
|
|
2006-01-19 23:26:24 +00:00
|
|
|
// (or (x << c) | (y >> (16 - c))) ==> (shld16 x, y, c)
|
2006-05-16 07:21:53 +00:00
|
|
|
def : Pat<(or (shl GR16:$src1, CL:$amt),
|
|
|
|
(srl GR16:$src2, (sub 16, CL:$amt))),
|
|
|
|
(SHLD16rrCL GR16:$src1, GR16:$src2)>;
|
2006-01-20 01:13:30 +00:00
|
|
|
|
|
|
|
def : Pat<(store (or (shl (loadi16 addr:$dst), CL:$amt),
|
2006-05-16 07:21:53 +00:00
|
|
|
(srl GR16:$src2, (sub 16, CL:$amt))), addr:$dst),
|
|
|
|
(SHLD16mrCL addr:$dst, GR16:$src2)>;
|
2006-02-21 20:00:20 +00:00
|
|
|
|
2008-10-17 01:23:35 +00:00
|
|
|
def : Pat<(or (shl GR16:$src1, (i8 (trunc CX:$amt))),
|
|
|
|
(srl GR16:$src2, (i8 (trunc (sub 16, CX:$amt))))),
|
|
|
|
(SHLD16rrCL GR16:$src1, GR16:$src2)>;
|
|
|
|
|
|
|
|
def : Pat<(store (or (shl (loadi16 addr:$dst), (i8 (trunc CX:$amt))),
|
|
|
|
(srl GR16:$src2, (i8 (trunc (sub 16, CX:$amt))))),
|
|
|
|
addr:$dst),
|
|
|
|
(SHLD16mrCL addr:$dst, GR16:$src2)>;
|
|
|
|
|
|
|
|
def : Pat<(shld GR16:$src1, (i8 imm:$amt1), GR16:$src2, (i8 imm:$amt2)),
|
|
|
|
(SHLD16rri8 GR16:$src1, GR16:$src2, (i8 imm:$amt1))>;
|
|
|
|
|
|
|
|
def : Pat<(store (shld (loadi16 addr:$dst), (i8 imm:$amt1),
|
|
|
|
GR16:$src2, (i8 imm:$amt2)), addr:$dst),
|
|
|
|
(SHLD16mri8 addr:$dst, GR16:$src2, (i8 imm:$amt1))>;
|
|
|
|
|
2008-12-12 21:15:41 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2009-03-04 19:44:21 +00:00
|
|
|
// EFLAGS-defining Patterns
|
2008-12-12 21:15:41 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Register-Register Addition with EFLAGS result
|
|
|
|
def : Pat<(parallel (X86add_flag GR8:$src1, GR8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD8rr GR8:$src1, GR8:$src2)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Register-Register Addition with EFLAGS result
|
|
|
|
def : Pat<(parallel (X86add_flag GR16:$src1, GR16:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD16rr GR16:$src1, GR16:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86add_flag GR32:$src1, GR32:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD32rr GR32:$src1, GR32:$src2)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Register-Memory Addition with EFLAGS result
|
|
|
|
def : Pat<(parallel (X86add_flag GR8:$src1, (loadi8 addr:$src2)),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD8rm GR8:$src1, addr:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86add_flag GR16:$src1, (loadi16 addr:$src2)),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD16rm GR16:$src1, addr:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86add_flag GR32:$src1, (loadi32 addr:$src2)),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD32rm GR32:$src1, addr:$src2)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Register-Integer Addition with EFLAGS result
|
|
|
|
def : Pat<(parallel (X86add_flag GR8:$src1, imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD8ri GR8:$src1, imm:$src2)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Register-Integer Addition with EFLAGS result
|
|
|
|
def : Pat<(parallel (X86add_flag GR16:$src1, imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD16ri GR16:$src1, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86add_flag GR32:$src1, imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD32ri GR32:$src1, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86add_flag GR16:$src1, i16immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD16ri8 GR16:$src1, i16immSExt8:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86add_flag GR32:$src1, i32immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD32ri8 GR32:$src1, i32immSExt8:$src2)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Memory-Register Addition with EFLAGS result
|
|
|
|
def : Pat<(parallel (store (X86add_flag (loadi8 addr:$dst), GR8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD8mr addr:$dst, GR8:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (X86add_flag (loadi16 addr:$dst), GR16:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD16mr addr:$dst, GR16:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (X86add_flag (loadi32 addr:$dst), GR32:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD32mr addr:$dst, GR32:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (X86add_flag (loadi8 addr:$dst), imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD8mi addr:$dst, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (X86add_flag (loadi16 addr:$dst), imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD16mi addr:$dst, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (X86add_flag (loadi32 addr:$dst), imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD32mi addr:$dst, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (X86add_flag (loadi16 addr:$dst), i16immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD16mi8 addr:$dst, i16immSExt8:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (X86add_flag (loadi32 addr:$dst), i32immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD32mi8 addr:$dst, i32immSExt8:$src2)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Register-Register Subtraction with EFLAGS result
|
|
|
|
def : Pat<(parallel (X86sub_flag GR8:$src1, GR8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB8rr GR8:$src1, GR8:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86sub_flag GR16:$src1, GR16:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB16rr GR16:$src1, GR16:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86sub_flag GR32:$src1, GR32:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB32rr GR32:$src1, GR32:$src2)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Register-Memory Subtraction with EFLAGS result
|
|
|
|
def : Pat<(parallel (X86sub_flag GR8:$src1, (loadi8 addr:$src2)),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB8rm GR8:$src1, addr:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86sub_flag GR16:$src1, (loadi16 addr:$src2)),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB16rm GR16:$src1, addr:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86sub_flag GR32:$src1, (loadi32 addr:$src2)),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB32rm GR32:$src1, addr:$src2)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Register-Integer Subtraction with EFLAGS result
|
|
|
|
def : Pat<(parallel (X86sub_flag GR8:$src1, imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB8ri GR8:$src1, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86sub_flag GR16:$src1, imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB16ri GR16:$src1, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86sub_flag GR32:$src1, imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB32ri GR32:$src1, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86sub_flag GR16:$src1, i16immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB16ri8 GR16:$src1, i16immSExt8:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86sub_flag GR32:$src1, i32immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB32ri8 GR32:$src1, i32immSExt8:$src2)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Memory-Register Subtraction with EFLAGS result
|
|
|
|
def : Pat<(parallel (store (X86sub_flag (loadi8 addr:$dst), GR8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB8mr addr:$dst, GR8:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (X86sub_flag (loadi16 addr:$dst), GR16:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB16mr addr:$dst, GR16:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (X86sub_flag (loadi32 addr:$dst), GR32:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB32mr addr:$dst, GR32:$src2)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Memory-Integer Subtraction with EFLAGS result
|
|
|
|
def : Pat<(parallel (store (X86sub_flag (loadi8 addr:$dst), imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB8mi addr:$dst, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (X86sub_flag (loadi16 addr:$dst), imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB16mi addr:$dst, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (X86sub_flag (loadi32 addr:$dst), imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB32mi addr:$dst, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (X86sub_flag (loadi16 addr:$dst), i16immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB16mi8 addr:$dst, i16immSExt8:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (X86sub_flag (loadi32 addr:$dst), i32immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(SUB32mi8 addr:$dst, i32immSExt8:$src2)>;
|
|
|
|
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Register-Register Signed Integer Multiply with EFLAGS result
|
|
|
|
def : Pat<(parallel (X86smul_flag GR16:$src1, GR16:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(IMUL16rr GR16:$src1, GR16:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86smul_flag GR32:$src1, GR32:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(IMUL32rr GR32:$src1, GR32:$src2)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Register-Memory Signed Integer Multiply with EFLAGS result
|
|
|
|
def : Pat<(parallel (X86smul_flag GR16:$src1, (loadi16 addr:$src2)),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(IMUL16rm GR16:$src1, addr:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86smul_flag GR32:$src1, (loadi32 addr:$src2)),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(IMUL32rm GR32:$src1, addr:$src2)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Register-Integer Signed Integer Multiply with EFLAGS result
|
|
|
|
def : Pat<(parallel (X86smul_flag GR16:$src1, imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(IMUL16rri GR16:$src1, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86smul_flag GR32:$src1, imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(IMUL32rri GR32:$src1, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86smul_flag GR16:$src1, i16immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(IMUL16rri8 GR16:$src1, i16immSExt8:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86smul_flag GR32:$src1, i32immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(IMUL32rri8 GR32:$src1, i32immSExt8:$src2)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Memory-Integer Signed Integer Multiply with EFLAGS result
|
|
|
|
def : Pat<(parallel (X86smul_flag (loadi16 addr:$src1), imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(IMUL16rmi addr:$src1, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86smul_flag (loadi32 addr:$src1), imm:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(IMUL32rmi addr:$src1, imm:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86smul_flag (loadi16 addr:$src1), i16immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(IMUL16rmi8 addr:$src1, i16immSExt8:$src2)>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86smul_flag (loadi32 addr:$src1), i32immSExt8:$src2),
|
2008-12-12 21:15:41 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(IMUL32rmi8 addr:$src1, i32immSExt8:$src2)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// Optimize multiply by 2 with EFLAGS result.
|
2009-01-27 03:30:42 +00:00
|
|
|
let AddedComplexity = 2 in {
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86smul_flag GR16:$src1, 2),
|
2009-01-27 03:30:42 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD16rr GR16:$src1, GR16:$src1)>;
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86smul_flag GR32:$src1, 2),
|
2009-01-27 03:30:42 +00:00
|
|
|
(implicit EFLAGS)),
|
|
|
|
(ADD32rr GR32:$src1, GR32:$src1)>;
|
|
|
|
}
|
|
|
|
|
2009-03-04 19:44:21 +00:00
|
|
|
// INC and DEC with EFLAGS result. Note that these do not set CF.
|
|
|
|
def : Pat<(parallel (X86inc_flag GR8:$src), (implicit EFLAGS)),
|
|
|
|
(INC8r GR8:$src)>;
|
|
|
|
def : Pat<(parallel (store (i8 (X86inc_flag (loadi8 addr:$dst))), addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(INC8m addr:$dst)>;
|
|
|
|
def : Pat<(parallel (X86dec_flag GR8:$src), (implicit EFLAGS)),
|
|
|
|
(DEC8r GR8:$src)>;
|
|
|
|
def : Pat<(parallel (store (i8 (X86dec_flag (loadi8 addr:$dst))), addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
|
|
|
(DEC8m addr:$dst)>;
|
|
|
|
|
|
|
|
def : Pat<(parallel (X86inc_flag GR16:$src), (implicit EFLAGS)),
|
2009-03-05 21:32:23 +00:00
|
|
|
(INC16r GR16:$src)>, Requires<[In32BitMode]>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (i16 (X86inc_flag (loadi16 addr:$dst))), addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
2009-03-05 21:32:23 +00:00
|
|
|
(INC16m addr:$dst)>, Requires<[In32BitMode]>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86dec_flag GR16:$src), (implicit EFLAGS)),
|
2009-03-05 21:32:23 +00:00
|
|
|
(DEC16r GR16:$src)>, Requires<[In32BitMode]>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (i16 (X86dec_flag (loadi16 addr:$dst))), addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
2009-03-05 21:32:23 +00:00
|
|
|
(DEC16m addr:$dst)>, Requires<[In32BitMode]>;
|
2009-03-04 19:44:21 +00:00
|
|
|
|
|
|
|
def : Pat<(parallel (X86inc_flag GR32:$src), (implicit EFLAGS)),
|
2009-03-05 21:32:23 +00:00
|
|
|
(INC32r GR32:$src)>, Requires<[In32BitMode]>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (i32 (X86inc_flag (loadi32 addr:$dst))), addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
2009-03-05 21:32:23 +00:00
|
|
|
(INC32m addr:$dst)>, Requires<[In32BitMode]>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (X86dec_flag GR32:$src), (implicit EFLAGS)),
|
2009-03-05 21:32:23 +00:00
|
|
|
(DEC32r GR32:$src)>, Requires<[In32BitMode]>;
|
2009-03-04 19:44:21 +00:00
|
|
|
def : Pat<(parallel (store (i32 (X86dec_flag (loadi32 addr:$dst))), addr:$dst),
|
|
|
|
(implicit EFLAGS)),
|
2009-03-05 21:32:23 +00:00
|
|
|
(DEC32m addr:$dst)>, Requires<[In32BitMode]>;
|
2009-03-04 19:44:21 +00:00
|
|
|
|
2006-02-21 20:00:20 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Floating Point Stack Support
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
include "X86InstrFPStack.td"
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2007-07-31 08:04:03 +00:00
|
|
|
// X86-64 Support
|
2006-02-21 20:00:20 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2008-01-10 05:50:42 +00:00
|
|
|
include "X86Instr64bit.td"
|
2006-02-21 20:00:20 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2008-04-25 18:19:54 +00:00
|
|
|
// XMM Floating point support (requires SSE / SSE2)
|
2006-02-21 20:00:20 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2008-04-25 18:19:54 +00:00
|
|
|
include "X86InstrSSE.td"
|
2006-09-08 06:48:29 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2008-04-25 18:19:54 +00:00
|
|
|
// MMX and XMM Packed Integer support (requires MMX, SSE, and SSE2)
|
2006-09-08 06:48:29 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2008-04-25 18:19:54 +00:00
|
|
|
include "X86InstrMMX.td"
|