//===----------------------------------------------------------------------===//
// Address operands
+def op_addr_mode1 : Operand<iPTR> {
+ let PrintMethod = "printAddrMode1";
+ let NumMIOperands = 3;
+ let MIOperandInfo = (ops ptr_rc, ptr_rc, i32imm);
+}
+
def memri : Operand<iPTR> {
let PrintMethod = "printMemRegImm";
let NumMIOperands = 2;
}
// Define ARM specific addressing mode.
+//Addressing Mode 1: data processing operands
+def addr_mode1 : ComplexPattern<iPTR, 3, "SelectAddrMode1", [imm, sra, shl, srl],
+ []>;
+
//register plus/minus 12 bit offset
-def iaddr : ComplexPattern<iPTR, 2, "SelectAddrRegImm", [frameindex]>;
+def iaddr : ComplexPattern<iPTR, 2, "SelectAddrRegImm", [frameindex], []>;
//register plus scaled register
-//def raddr : ComplexPattern<iPTR, 2, "SelectAddrRegReg", []>;
+//def raddr : ComplexPattern<iPTR, 2, "SelectAddrRegReg", [], []>;
//===----------------------------------------------------------------------===//
// Instructions
[SDNPHasChain, SDNPOptInFlag]>;
def SDTarmselect : SDTypeProfile<1, 3, [SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisInt<0>, SDTCisVT<2, i32>]>;
-
def armselect : SDNode<"ARMISD::SELECT", SDTarmselect, [SDNPInFlag, SDNPOutFlag]>;
+def SDTarmfmstat : SDTypeProfile<0, 0, []>;
+def armfmstat : SDNode<"ARMISD::FMSTAT", SDTarmfmstat, [SDNPInFlag, SDNPOutFlag]>;
+
def SDTarmbr : SDTypeProfile<0, 2, [SDTCisVT<0, OtherVT>, SDTCisVT<1, i32>]>;
def armbr : SDNode<"ARMISD::BR", SDTarmbr, [SDNPHasChain, SDNPInFlag]>;
def SDTVoidBinOp : SDTypeProfile<0, 2, [SDTCisSameAs<0, 1>]>;
def armcmp : SDNode<"ARMISD::CMP", SDTVoidBinOp, [SDNPOutFlag]>;
+def armfsitos : SDNode<"ARMISD::FSITOS", SDTUnaryOp>;
+def armftosis : SDNode<"ARMISD::FTOSIS", SDTUnaryOp>;
+def armfsitod : SDNode<"ARMISD::FSITOD", SDTUnaryOp>;
+def armftosid : SDNode<"ARMISD::FTOSID", SDTUnaryOp>;
+def armfuitos : SDNode<"ARMISD::FUITOS", SDTUnaryOp>;
+def armftouis : SDNode<"ARMISD::FTOUIS", SDTUnaryOp>;
+def armfuitod : SDNode<"ARMISD::FUITOD", SDTUnaryOp>;
+def armftouid : SDNode<"ARMISD::FTOUID", SDTUnaryOp>;
+
+def SDTarmfmrrd : SDTypeProfile<0, 3, [SDTCisInt<0>, SDTCisInt<1>, SDTCisFP<2>]>;
+def armfmrrd : SDNode<"ARMISD::FMRRD", SDTarmfmrrd,
+ [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
+
+def SDTarmfmdrr : SDTypeProfile<1, 2, [SDTCisFP<0>, SDTCisInt<1>, SDTCisInt<2>]>;
+def armfmdrr : SDNode<"ARMISD::FMDRR", SDTarmfmdrr, []>;
+
def ADJCALLSTACKUP : InstARM<(ops i32imm:$amt),
"!ADJCALLSTACKUP $amt",
- [(callseq_end imm:$amt)]>;
+ [(callseq_end imm:$amt)]>, Imp<[R13],[R13]>;
def ADJCALLSTACKDOWN : InstARM<(ops i32imm:$amt),
"!ADJCALLSTACKDOWN $amt",
- [(callseq_start imm:$amt)]>;
+ [(callseq_start imm:$amt)]>, Imp<[R13],[R13]>;
let isReturn = 1 in {
def bx: InstARM<(ops), "bx r14", [(retflag)]>;
"str $src, $addr",
[(store IntRegs:$src, iaddr:$addr)]>;
-def movrr : InstARM<(ops IntRegs:$dst, IntRegs:$src),
- "mov $dst, $src", []>;
-
-def movri : InstARM<(ops IntRegs:$dst, i32imm:$src),
- "mov $dst, $src", [(set IntRegs:$dst, imm:$src)]>;
+def MOV : InstARM<(ops IntRegs:$dst, op_addr_mode1:$src),
+ "mov $dst, $src", [(set IntRegs:$dst, addr_mode1:$src)]>;
-def addri : InstARM<(ops IntRegs:$dst, IntRegs:$a, i32imm:$b),
+def ADD : InstARM<(ops IntRegs:$dst, IntRegs:$a, op_addr_mode1:$b),
"add $dst, $a, $b",
- [(set IntRegs:$dst, (add IntRegs:$a, imm:$b))]>;
+ [(set IntRegs:$dst, (add IntRegs:$a, addr_mode1:$b))]>;
+
+def ADCS : InstARM<(ops IntRegs:$dst, IntRegs:$a, op_addr_mode1:$b),
+ "adcs $dst, $a, $b",
+ [(set IntRegs:$dst, (adde IntRegs:$a, addr_mode1:$b))]>;
+
+def ADDS : InstARM<(ops IntRegs:$dst, IntRegs:$a, op_addr_mode1:$b),
+ "adds $dst, $a, $b",
+ [(set IntRegs:$dst, (addc IntRegs:$a, addr_mode1:$b))]>;
// "LEA" forms of add
def lea_addri : InstARM<(ops IntRegs:$dst, memri:$addr),
[(set IntRegs:$dst, iaddr:$addr)]>;
-def subri : InstARM<(ops IntRegs:$dst, IntRegs:$a, i32imm:$b),
+def SUB : InstARM<(ops IntRegs:$dst, IntRegs:$a, op_addr_mode1:$b),
"sub $dst, $a, $b",
- [(set IntRegs:$dst, (sub IntRegs:$a, imm:$b))]>;
+ [(set IntRegs:$dst, (sub IntRegs:$a, addr_mode1:$b))]>;
-def andrr : InstARM<(ops IntRegs:$dst, IntRegs:$a, IntRegs:$b),
- "and $dst, $a, $b",
- [(set IntRegs:$dst, (and IntRegs:$a, IntRegs:$b))]>;
+def SBCS : InstARM<(ops IntRegs:$dst, IntRegs:$a, op_addr_mode1:$b),
+ "sbcs $dst, $a, $b",
+ [(set IntRegs:$dst, (sube IntRegs:$a, addr_mode1:$b))]>;
+def SUBS : InstARM<(ops IntRegs:$dst, IntRegs:$a, op_addr_mode1:$b),
+ "subs $dst, $a, $b",
+ [(set IntRegs:$dst, (subc IntRegs:$a, addr_mode1:$b))]>;
-// All arm data processing instructions have a shift. Maybe we don't have
-// to implement this
-def SHL : InstARM<(ops IntRegs:$dst, IntRegs:$a, IntRegs:$b),
- "mov $dst, $a, lsl $b",
- [(set IntRegs:$dst, (shl IntRegs:$a, IntRegs:$b))]>;
+def AND : InstARM<(ops IntRegs:$dst, IntRegs:$a, op_addr_mode1:$b),
+ "and $dst, $a, $b",
+ [(set IntRegs:$dst, (and IntRegs:$a, addr_mode1:$b))]>;
-def SRA : InstARM<(ops IntRegs:$dst, IntRegs:$a, IntRegs:$b),
- "mov $dst, $a, asr $b",
- [(set IntRegs:$dst, (sra IntRegs:$a, IntRegs:$b))]>;
+def EOR : InstARM<(ops IntRegs:$dst, IntRegs:$a, op_addr_mode1:$b),
+ "eor $dst, $a, $b",
+ [(set IntRegs:$dst, (xor IntRegs:$a, addr_mode1:$b))]>;
+def ORR : InstARM<(ops IntRegs:$dst, IntRegs:$a, op_addr_mode1:$b),
+ "orr $dst, $a, $b",
+ [(set IntRegs:$dst, (or IntRegs:$a, addr_mode1:$b))]>;
-def eor_rr : InstARM<(ops IntRegs:$dst, IntRegs:$a, IntRegs:$b),
- "eor $dst, $a, $b",
- [(set IntRegs:$dst, (xor IntRegs:$a, IntRegs:$b))]>;
+let isTwoAddress = 1 in {
+ def movcond : InstARM<(ops IntRegs:$dst, IntRegs:$false,
+ op_addr_mode1:$true, CCOp:$cc),
+ "mov$cc $dst, $true",
+ [(set IntRegs:$dst, (armselect addr_mode1:$true,
+ IntRegs:$false, imm:$cc))]>;
+}
-def orr_rr : InstARM<(ops IntRegs:$dst, IntRegs:$a, IntRegs:$b),
- "orr $dst, $a, $b",
- [(set IntRegs:$dst, (or IntRegs:$a, IntRegs:$b))]>;
+def MUL : InstARM<(ops IntRegs:$dst, IntRegs:$a, IntRegs:$b),
+ "mul $dst, $a, $b",
+ [(set IntRegs:$dst, (mul IntRegs:$a, IntRegs:$b))]>;
+let Defs = [R0] in {
+ def SMULL : InstARM<(ops IntRegs:$dst, IntRegs:$a, IntRegs:$b),
+ "smull r12, $dst, $a, $b",
+ [(set IntRegs:$dst, (mulhs IntRegs:$a, IntRegs:$b))]>;
-let isTwoAddress = 1 in {
- def movcond : InstARM<(ops IntRegs:$dst, IntRegs:$false, IntRegs:$true, CCOp:$cc),
- "mov$cc $dst, $true",
- [(set IntRegs:$dst, (armselect IntRegs:$true, IntRegs:$false, imm:$cc))]>;
+ def UMULL : InstARM<(ops IntRegs:$dst, IntRegs:$a, IntRegs:$b),
+ "umull r12, $dst, $a, $b",
+ [(set IntRegs:$dst, (mulhu IntRegs:$a, IntRegs:$b))]>;
}
def bcond : InstARM<(ops brtarget:$dst, CCOp:$cc),
"b $dst",
[(br bb:$dst)]>;
-def cmp : InstARM<(ops IntRegs:$a, IntRegs:$b),
+def cmp : InstARM<(ops IntRegs:$a, op_addr_mode1:$b),
"cmp $a, $b",
- [(armcmp IntRegs:$a, IntRegs:$b)]>;
+ [(armcmp IntRegs:$a, addr_mode1:$b)]>;
+
+// Floating Point Compare
+def fcmps : InstARM<(ops FPRegs:$a, FPRegs:$b),
+ "fcmps $a, $b",
+ [(armcmp FPRegs:$a, FPRegs:$b)]>;
+
+def fcmpd : InstARM<(ops DFPRegs:$a, DFPRegs:$b),
+ "fcmpd $a, $b",
+ [(armcmp DFPRegs:$a, DFPRegs:$b)]>;
+
+// Floating Point Conversion
+// We use bitconvert for moving the data between the register classes.
+// The format conversion is done with ARM specific nodes
+
+def FMSR : InstARM<(ops FPRegs:$dst, IntRegs:$src),
+ "fmsr $dst, $src", [(set FPRegs:$dst, (bitconvert IntRegs:$src))]>;
+
+def FMRS : InstARM<(ops IntRegs:$dst, FPRegs:$src),
+ "fmrs $dst, $src", [(set IntRegs:$dst, (bitconvert FPRegs:$src))]>;
+
+def FMRRD : InstARM<(ops IntRegs:$i0, IntRegs:$i1, DFPRegs:$src),
+ "fmrrd $i0, $i1, $src", [(armfmrrd IntRegs:$i0, IntRegs:$i1, DFPRegs:$src)]>;
+
+def FMDRR : InstARM<(ops DFPRegs:$dst, IntRegs:$i0, IntRegs:$i1),
+ "fmdrr $dst, $i0, $i1", [(set DFPRegs:$dst, (armfmdrr IntRegs:$i0, IntRegs:$i1))]>;
+
+def FSITOS : InstARM<(ops FPRegs:$dst, FPRegs:$src),
+ "fsitos $dst, $src", [(set FPRegs:$dst, (armfsitos FPRegs:$src))]>;
+
+def FTOSIS : InstARM<(ops FPRegs:$dst, FPRegs:$src),
+ "ftosis $dst, $src", [(set FPRegs:$dst, (armftosis FPRegs:$src))]>;
+
+def FSITOD : InstARM<(ops DFPRegs:$dst, FPRegs:$src),
+ "fsitod $dst, $src", [(set DFPRegs:$dst, (armfsitod FPRegs:$src))]>;
+
+def FTOSID : InstARM<(ops FPRegs:$dst, DFPRegs:$src),
+ "ftosid $dst, $src", [(set FPRegs:$dst, (armftosid DFPRegs:$src))]>;
+
+def FUITOS : InstARM<(ops FPRegs:$dst, FPRegs:$src),
+ "fuitos $dst, $src", [(set FPRegs:$dst, (armfuitos FPRegs:$src))]>;
+
+def FTOUIS : InstARM<(ops FPRegs:$dst, FPRegs:$src),
+ "ftouis $dst, $src", [(set FPRegs:$dst, (armftouis FPRegs:$src))]>;
+
+def FUITOD : InstARM<(ops DFPRegs:$dst, FPRegs:$src),
+ "fuitod $dst, $src", [(set DFPRegs:$dst, (armfuitod FPRegs:$src))]>;
+
+def FTOUID : InstARM<(ops FPRegs:$dst, DFPRegs:$src),
+ "ftouid $dst, $src", [(set FPRegs:$dst, (armftouid DFPRegs:$src))]>;
+
+def FCVTDS : InstARM<(ops DFPRegs:$dst, FPRegs:$src),
+ "fcvtds $dst, $src", [(set DFPRegs:$dst, (fextend FPRegs:$src))]>;
+
+def FCVTSD : InstARM<(ops FPRegs:$dst, DFPRegs:$src),
+ "fcvtsd $dst, $src", [(set FPRegs:$dst, (fround DFPRegs:$src))]>;
+
+def FMSTAT : InstARM<(ops ), "fmstat", [(armfmstat)]>;
+
+// Floating Point Arithmetic
+def FADDS : InstARM<(ops FPRegs:$dst, FPRegs:$a, FPRegs:$b),
+ "fadds $dst, $a, $b",
+ [(set FPRegs:$dst, (fadd FPRegs:$a, FPRegs:$b))]>;
+
+def FADDD : InstARM<(ops DFPRegs:$dst, DFPRegs:$a, DFPRegs:$b),
+ "faddd $dst, $a, $b",
+ [(set DFPRegs:$dst, (fadd DFPRegs:$a, DFPRegs:$b))]>;
+
+def FSUBS : InstARM<(ops FPRegs:$dst, FPRegs:$a, FPRegs:$b),
+ "fsubs $dst, $a, $b",
+ [(set FPRegs:$dst, (fsub FPRegs:$a, FPRegs:$b))]>;
+
+def FSUBD : InstARM<(ops DFPRegs:$dst, DFPRegs:$a, DFPRegs:$b),
+ "fsubd $dst, $a, $b",
+ [(set DFPRegs:$dst, (fsub DFPRegs:$a, DFPRegs:$b))]>;
+
+def FNEGS : InstARM<(ops FPRegs:$dst, FPRegs:$src),
+ "fnegs $dst, $src",
+ [(set FPRegs:$dst, (fneg FPRegs:$src))]>;
+
+def FNEGD : InstARM<(ops DFPRegs:$dst, DFPRegs:$src),
+ "fnegd $dst, $src",
+ [(set DFPRegs:$dst, (fneg DFPRegs:$src))]>;
+
+def FMULS : InstARM<(ops FPRegs:$dst, FPRegs:$a, FPRegs:$b),
+ "fmuls $dst, $a, $b",
+ [(set FPRegs:$dst, (fmul FPRegs:$a, FPRegs:$b))]>;
+
+def FMULD : InstARM<(ops DFPRegs:$dst, DFPRegs:$a, DFPRegs:$b),
+ "fmuld $dst, $a, $b",
+ [(set DFPRegs:$dst, (fmul DFPRegs:$a, DFPRegs:$b))]>;
+
+
+// Floating Point Load
+def FLDS : InstARM<(ops FPRegs:$dst, IntRegs:$addr),
+ "flds $dst, $addr",
+ [(set FPRegs:$dst, (load IntRegs:$addr))]>;
+
+def FLDD : InstARM<(ops DFPRegs:$dst, IntRegs:$addr),
+ "fldd $dst, $addr",
+ [(set DFPRegs:$dst, (load IntRegs:$addr))]>;