Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 1 | //==- X86InstrFPStack.td - Describe the X86 Instruction Set -------*- C++ -*-=// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 5 | // This file was developed by Evan Cheng and is distributed under |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 6 | // the University of Illinois Open Source License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file describes the X86 x87 FPU instruction set, defining the |
| 11 | // instructions, and properties of the instructions which are needed for code |
| 12 | // generation, machine code emission, and analysis. |
| 13 | // |
| 14 | //===----------------------------------------------------------------------===// |
| 15 | |
Evan Cheng | 06a8aa1 | 2006-03-17 19:55:52 +0000 | [diff] [blame] | 16 | //===----------------------------------------------------------------------===// |
Evan Cheng | 2246f84 | 2006-03-18 01:23:20 +0000 | [diff] [blame] | 17 | // FPStack specific DAG Nodes. |
| 18 | //===----------------------------------------------------------------------===// |
| 19 | |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 20 | def SDTX86FpGet : SDTypeProfile<1, 0, [SDTCisFP<0>]>; |
| 21 | def SDTX86FpSet : SDTypeProfile<0, 1, [SDTCisFP<0>]>; |
| 22 | def SDTX86Fld : SDTypeProfile<1, 2, [SDTCisFP<0>, |
Dale Johannesen | bf6b827 | 2007-07-10 20:53:41 +0000 | [diff] [blame] | 23 | SDTCisPtrTy<1>, |
| 24 | SDTCisVT<2, OtherVT>]>; |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 25 | def SDTX86Fst : SDTypeProfile<0, 3, [SDTCisFP<0>, |
Dale Johannesen | bf6b827 | 2007-07-10 20:53:41 +0000 | [diff] [blame] | 26 | SDTCisPtrTy<1>, |
| 27 | SDTCisVT<2, OtherVT>]>; |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 28 | def SDTX86Fild : SDTypeProfile<1, 2, [SDTCisFP<0>, SDTCisPtrTy<1>, |
| 29 | SDTCisVT<2, OtherVT>]>; |
| 30 | def SDTX86FpToIMem : SDTypeProfile<0, 2, [SDTCisFP<0>, SDTCisPtrTy<1>]>; |
Evan Cheng | 2246f84 | 2006-03-18 01:23:20 +0000 | [diff] [blame] | 31 | |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 32 | def X86fpget : SDNode<"X86ISD::FP_GET_RESULT", SDTX86FpGet, |
Evan Cheng | 2246f84 | 2006-03-18 01:23:20 +0000 | [diff] [blame] | 33 | [SDNPHasChain, SDNPInFlag, SDNPOutFlag]>; |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 34 | def X86fpset : SDNode<"X86ISD::FP_SET_RESULT", SDTX86FpSet, |
Evan Cheng | 2246f84 | 2006-03-18 01:23:20 +0000 | [diff] [blame] | 35 | [SDNPHasChain, SDNPOutFlag]>; |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 36 | def X86fld : SDNode<"X86ISD::FLD", SDTX86Fld, |
Evan Cheng | 2246f84 | 2006-03-18 01:23:20 +0000 | [diff] [blame] | 37 | [SDNPHasChain]>; |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 38 | def X86fst : SDNode<"X86ISD::FST", SDTX86Fst, |
Evan Cheng | 2246f84 | 2006-03-18 01:23:20 +0000 | [diff] [blame] | 39 | [SDNPHasChain, SDNPInFlag]>; |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 40 | def X86fild : SDNode<"X86ISD::FILD", SDTX86Fild, |
Evan Cheng | 2246f84 | 2006-03-18 01:23:20 +0000 | [diff] [blame] | 41 | [SDNPHasChain]>; |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 42 | def X86fildflag : SDNode<"X86ISD::FILD_FLAG",SDTX86Fild, |
Evan Cheng | 2246f84 | 2006-03-18 01:23:20 +0000 | [diff] [blame] | 43 | [SDNPHasChain, SDNPOutFlag]>; |
| 44 | def X86fp_to_i16mem : SDNode<"X86ISD::FP_TO_INT16_IN_MEM", SDTX86FpToIMem, |
| 45 | [SDNPHasChain]>; |
| 46 | def X86fp_to_i32mem : SDNode<"X86ISD::FP_TO_INT32_IN_MEM", SDTX86FpToIMem, |
| 47 | [SDNPHasChain]>; |
| 48 | def X86fp_to_i64mem : SDNode<"X86ISD::FP_TO_INT64_IN_MEM", SDTX86FpToIMem, |
| 49 | [SDNPHasChain]>; |
| 50 | |
| 51 | //===----------------------------------------------------------------------===// |
Evan Cheng | 06a8aa1 | 2006-03-17 19:55:52 +0000 | [diff] [blame] | 52 | // FPStack pattern fragments |
| 53 | //===----------------------------------------------------------------------===// |
| 54 | |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 55 | def fpimm0 : PatLeaf<(fpimm), [{ |
Evan Cheng | 06a8aa1 | 2006-03-17 19:55:52 +0000 | [diff] [blame] | 56 | return N->isExactlyValue(+0.0); |
| 57 | }]>; |
| 58 | |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 59 | def fpimmneg0 : PatLeaf<(fpimm), [{ |
Evan Cheng | 06a8aa1 | 2006-03-17 19:55:52 +0000 | [diff] [blame] | 60 | return N->isExactlyValue(-0.0); |
| 61 | }]>; |
| 62 | |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 63 | def fpimm1 : PatLeaf<(fpimm), [{ |
Evan Cheng | 06a8aa1 | 2006-03-17 19:55:52 +0000 | [diff] [blame] | 64 | return N->isExactlyValue(+1.0); |
| 65 | }]>; |
| 66 | |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 67 | def fpimmneg1 : PatLeaf<(fpimm), [{ |
Evan Cheng | 06a8aa1 | 2006-03-17 19:55:52 +0000 | [diff] [blame] | 68 | return N->isExactlyValue(-1.0); |
| 69 | }]>; |
| 70 | |
Evan Cheng | 4e4c71e | 2006-02-21 20:00:20 +0000 | [diff] [blame] | 71 | // Some 'special' instructions |
| 72 | let usesCustomDAGSchedInserter = 1 in { // Expanded by the scheduler. |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 73 | def FP32_TO_INT16_IN_MEM : I<0, Pseudo, |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 74 | (outs), (ins i16mem:$dst, RFP32:$src), |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 75 | "#FP32_TO_INT16_IN_MEM PSEUDO!", |
| 76 | [(X86fp_to_i16mem RFP32:$src, addr:$dst)]>; |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 77 | def FP32_TO_INT32_IN_MEM : I<0, Pseudo, |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 78 | (outs), (ins i32mem:$dst, RFP32:$src), |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 79 | "#FP32_TO_INT32_IN_MEM PSEUDO!", |
| 80 | [(X86fp_to_i32mem RFP32:$src, addr:$dst)]>; |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 81 | def FP32_TO_INT64_IN_MEM : I<0, Pseudo, |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 82 | (outs), (ins i64mem:$dst, RFP32:$src), |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 83 | "#FP32_TO_INT64_IN_MEM PSEUDO!", |
| 84 | [(X86fp_to_i64mem RFP32:$src, addr:$dst)]>; |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 85 | def FP64_TO_INT16_IN_MEM : I<0, Pseudo, |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 86 | (outs), (ins i16mem:$dst, RFP64:$src), |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 87 | "#FP64_TO_INT16_IN_MEM PSEUDO!", |
| 88 | [(X86fp_to_i16mem RFP64:$src, addr:$dst)]>; |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 89 | def FP64_TO_INT32_IN_MEM : I<0, Pseudo, |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 90 | (outs), (ins i32mem:$dst, RFP64:$src), |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 91 | "#FP64_TO_INT32_IN_MEM PSEUDO!", |
| 92 | [(X86fp_to_i32mem RFP64:$src, addr:$dst)]>; |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 93 | def FP64_TO_INT64_IN_MEM : I<0, Pseudo, |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 94 | (outs), (ins i64mem:$dst, RFP64:$src), |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 95 | "#FP64_TO_INT64_IN_MEM PSEUDO!", |
| 96 | [(X86fp_to_i64mem RFP64:$src, addr:$dst)]>; |
Dale Johannesen | a996d52 | 2007-08-07 01:17:37 +0000 | [diff] [blame] | 97 | def FP80_TO_INT16_IN_MEM : I<0, Pseudo, |
| 98 | (outs), (ins i16mem:$dst, RFP80:$src), |
| 99 | "#FP80_TO_INT16_IN_MEM PSEUDO!", |
| 100 | [(X86fp_to_i16mem RFP80:$src, addr:$dst)]>; |
| 101 | def FP80_TO_INT32_IN_MEM : I<0, Pseudo, |
| 102 | (outs), (ins i32mem:$dst, RFP80:$src), |
| 103 | "#FP80_TO_INT32_IN_MEM PSEUDO!", |
| 104 | [(X86fp_to_i32mem RFP80:$src, addr:$dst)]>; |
| 105 | def FP80_TO_INT64_IN_MEM : I<0, Pseudo, |
| 106 | (outs), (ins i64mem:$dst, RFP80:$src), |
| 107 | "#FP80_TO_INT64_IN_MEM PSEUDO!", |
| 108 | [(X86fp_to_i64mem RFP80:$src, addr:$dst)]>; |
Evan Cheng | 4e4c71e | 2006-02-21 20:00:20 +0000 | [diff] [blame] | 109 | } |
| 110 | |
| 111 | let isTerminator = 1 in |
| 112 | let Defs = [FP0, FP1, FP2, FP3, FP4, FP5, FP6] in |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 113 | def FP_REG_KILL : I<0, Pseudo, (outs), (ins), "#FP_REG_KILL", []>; |
Evan Cheng | 4e4c71e | 2006-02-21 20:00:20 +0000 | [diff] [blame] | 114 | |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 115 | // All FP Stack operations are represented with four instructions here. The |
| 116 | // first three instructions, generated by the instruction selector, use "RFP32" |
| 117 | // "RFP64" or "RFP80" registers: traditional register files to reference 32-bit, |
| 118 | // 64-bit or 80-bit floating point values. These sizes apply to the values, |
| 119 | // not the registers, which are always 80 bits; RFP32, RFP64 and RFP80 can be |
| 120 | // copied to each other without losing information. These instructions are all |
| 121 | // pseudo instructions and use the "_Fp" suffix. |
| 122 | // In some cases there are additional variants with a mixture of different |
| 123 | // register sizes. |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 124 | // The second instruction is defined with FPI, which is the actual instruction |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 125 | // emitted by the assembler. These use "RST" registers, although frequently |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 126 | // the actual register(s) used are implicit. These are always 80 bits. |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 127 | // The FP stackifier pass converts one to the other after register allocation |
| 128 | // occurs. |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 129 | // |
| 130 | // Note that the FpI instruction should have instruction selection info (e.g. |
| 131 | // a pattern) and the FPI instruction should have emission info (e.g. opcode |
| 132 | // encoding and asm printing info). |
| 133 | |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 134 | // Pseudo Instructions for FP stack return values. |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 135 | def FpGETRESULT32 : FpI_<(outs RFP32:$dst), (ins), SpecialFP, |
Dale Johannesen | bf6b827 | 2007-07-10 20:53:41 +0000 | [diff] [blame] | 136 | [(set RFP32:$dst, X86fpget)]>; // FPR = ST(0) |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 137 | |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 138 | def FpGETRESULT64 : FpI_<(outs RFP64:$dst), (ins), SpecialFP, |
Dale Johannesen | bf6b827 | 2007-07-10 20:53:41 +0000 | [diff] [blame] | 139 | [(set RFP64:$dst, X86fpget)]>; // FPR = ST(0) |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 140 | |
Dale Johannesen | 6a30811 | 2007-08-06 21:31:06 +0000 | [diff] [blame] | 141 | def FpGETRESULT80 : FpI_<(outs RFP80:$dst), (ins), SpecialFP, |
| 142 | [(set RFP80:$dst, X86fpget)]>; // FPR = ST(0) |
| 143 | |
Evan Cheng | 071a279 | 2007-09-11 19:55:27 +0000 | [diff] [blame] | 144 | let Defs = [ST0] in { |
Evan Cheng | ffbacca | 2007-07-21 00:34:19 +0000 | [diff] [blame] | 145 | def FpSETRESULT32 : FpI_<(outs), (ins RFP32:$src), SpecialFP, |
Evan Cheng | 071a279 | 2007-09-11 19:55:27 +0000 | [diff] [blame] | 146 | [(X86fpset RFP32:$src)]>;// ST(0) = FPR |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 147 | |
Evan Cheng | ffbacca | 2007-07-21 00:34:19 +0000 | [diff] [blame] | 148 | def FpSETRESULT64 : FpI_<(outs), (ins RFP64:$src), SpecialFP, |
Evan Cheng | 071a279 | 2007-09-11 19:55:27 +0000 | [diff] [blame] | 149 | [(X86fpset RFP64:$src)]>;// ST(0) = FPR |
Evan Cheng | ffbacca | 2007-07-21 00:34:19 +0000 | [diff] [blame] | 150 | |
Dale Johannesen | 6a30811 | 2007-08-06 21:31:06 +0000 | [diff] [blame] | 151 | def FpSETRESULT80 : FpI_<(outs), (ins RFP80:$src), SpecialFP, |
Evan Cheng | 071a279 | 2007-09-11 19:55:27 +0000 | [diff] [blame] | 152 | [(X86fpset RFP80:$src)]>;// ST(0) = FPR |
| 153 | } |
Dale Johannesen | 6a30811 | 2007-08-06 21:31:06 +0000 | [diff] [blame] | 154 | |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 155 | // FpI - Floating Point Psuedo Instruction template. Predicated on FPStack. |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 156 | // Note that f80-only instructions are used even in SSE mode and use FpI_ |
| 157 | // not this predicate. |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 158 | class FpI<dag outs, dag ins, FPFormat fp, list<dag> pattern> : |
| 159 | FpI_<outs, ins, fp, pattern>, Requires<[FPStack]>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 160 | |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 161 | // Register copies. Just copies, the shortening ones do not truncate. |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 162 | def MOV_Fp3232 : FpI<(outs RFP32:$dst), (ins RFP32:$src), SpecialFP, []>; |
| 163 | def MOV_Fp3264 : FpI<(outs RFP64:$dst), (ins RFP32:$src), SpecialFP, []>; |
| 164 | def MOV_Fp6432 : FpI<(outs RFP32:$dst), (ins RFP64:$src), SpecialFP, []>; |
| 165 | def MOV_Fp6464 : FpI<(outs RFP64:$dst), (ins RFP64:$src), SpecialFP, []>; |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 166 | def MOV_Fp8032 : FpI<(outs RFP32:$dst), (ins RFP80:$src), SpecialFP, []>; |
| 167 | def MOV_Fp3280 : FpI<(outs RFP80:$dst), (ins RFP32:$src), SpecialFP, []>; |
| 168 | def MOV_Fp8064 : FpI<(outs RFP64:$dst), (ins RFP80:$src), SpecialFP, []>; |
| 169 | def MOV_Fp6480 : FpI<(outs RFP80:$dst), (ins RFP64:$src), SpecialFP, []>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 170 | def MOV_Fp8080 : FpI_<(outs RFP80:$dst), (ins RFP80:$src), SpecialFP, []>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 171 | |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 172 | // Factoring for arithmetic. |
| 173 | multiclass FPBinary_rr<SDNode OpNode> { |
| 174 | // Register op register -> register |
| 175 | // These are separated out because they have no reversed form. |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 176 | def _Fp32 : FpI<(outs RFP32:$dst), (ins RFP32:$src1, RFP32:$src2), TwoArgFP, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 177 | [(set RFP32:$dst, (OpNode RFP32:$src1, RFP32:$src2))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 178 | def _Fp64 : FpI<(outs RFP64:$dst), (ins RFP64:$src1, RFP64:$src2), TwoArgFP, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 179 | [(set RFP64:$dst, (OpNode RFP64:$src1, RFP64:$src2))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 180 | def _Fp80 : FpI_<(outs RFP80:$dst), (ins RFP80:$src1, RFP80:$src2), TwoArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 181 | [(set RFP80:$dst, (OpNode RFP80:$src1, RFP80:$src2))]>; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 182 | } |
| 183 | // The FopST0 series are not included here because of the irregularities |
| 184 | // in where the 'r' goes in assembly output. |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 185 | // These instructions cannot address 80-bit memory. |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 186 | multiclass FPBinary<SDNode OpNode, Format fp, string asmstring> { |
| 187 | // ST(0) = ST(0) + [mem] |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 188 | def _Fp32m : FpI<(outs RFP32:$dst), (ins RFP32:$src1, f32mem:$src2), OneArgFPRW, |
Dale Johannesen | bf6b827 | 2007-07-10 20:53:41 +0000 | [diff] [blame] | 189 | [(set RFP32:$dst, |
| 190 | (OpNode RFP32:$src1, (loadf32 addr:$src2)))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 191 | def _Fp64m : FpI<(outs RFP64:$dst), (ins RFP64:$src1, f64mem:$src2), OneArgFPRW, |
Dale Johannesen | bf6b827 | 2007-07-10 20:53:41 +0000 | [diff] [blame] | 192 | [(set RFP64:$dst, |
| 193 | (OpNode RFP64:$src1, (loadf64 addr:$src2)))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 194 | def _Fp64m32: FpI<(outs RFP64:$dst), (ins RFP64:$src1, f32mem:$src2), OneArgFPRW, |
Dale Johannesen | afdc7fd | 2007-07-10 21:53:30 +0000 | [diff] [blame] | 195 | [(set RFP64:$dst, |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 196 | (OpNode RFP64:$src1, (f64 (extloadf32 addr:$src2))))]>; |
| 197 | def _Fp80m32: FpI_<(outs RFP80:$dst), (ins RFP80:$src1, f32mem:$src2), OneArgFPRW, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 198 | [(set RFP80:$dst, |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 199 | (OpNode RFP80:$src1, (f80 (extloadf32 addr:$src2))))]>; |
| 200 | def _Fp80m64: FpI_<(outs RFP80:$dst), (ins RFP80:$src1, f64mem:$src2), OneArgFPRW, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 201 | [(set RFP80:$dst, |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 202 | (OpNode RFP80:$src1, (f80 (extloadf64 addr:$src2))))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 203 | def _F32m : FPI<0xD8, fp, (outs), (ins f32mem:$src), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 204 | !strconcat("f", !strconcat(asmstring, "{s}\t$src"))>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 205 | def _F64m : FPI<0xDC, fp, (outs), (ins f64mem:$src), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 206 | !strconcat("f", !strconcat(asmstring, "{l}\t$src"))>; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 207 | // ST(0) = ST(0) + [memint] |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 208 | def _FpI16m32 : FpI<(outs RFP32:$dst), (ins RFP32:$src1, i16mem:$src2), OneArgFPRW, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 209 | [(set RFP32:$dst, (OpNode RFP32:$src1, |
| 210 | (X86fild addr:$src2, i16)))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 211 | def _FpI32m32 : FpI<(outs RFP32:$dst), (ins RFP32:$src1, i32mem:$src2), OneArgFPRW, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 212 | [(set RFP32:$dst, (OpNode RFP32:$src1, |
| 213 | (X86fild addr:$src2, i32)))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 214 | def _FpI16m64 : FpI<(outs RFP64:$dst), (ins RFP64:$src1, i16mem:$src2), OneArgFPRW, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 215 | [(set RFP64:$dst, (OpNode RFP64:$src1, |
| 216 | (X86fild addr:$src2, i16)))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 217 | def _FpI32m64 : FpI<(outs RFP64:$dst), (ins RFP64:$src1, i32mem:$src2), OneArgFPRW, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 218 | [(set RFP64:$dst, (OpNode RFP64:$src1, |
| 219 | (X86fild addr:$src2, i32)))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 220 | def _FpI16m80 : FpI_<(outs RFP80:$dst), (ins RFP80:$src1, i16mem:$src2), OneArgFPRW, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 221 | [(set RFP80:$dst, (OpNode RFP80:$src1, |
| 222 | (X86fild addr:$src2, i16)))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 223 | def _FpI32m80 : FpI_<(outs RFP80:$dst), (ins RFP80:$src1, i32mem:$src2), OneArgFPRW, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 224 | [(set RFP80:$dst, (OpNode RFP80:$src1, |
| 225 | (X86fild addr:$src2, i32)))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 226 | def _FI16m : FPI<0xDE, fp, (outs), (ins i16mem:$src), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 227 | !strconcat("fi", !strconcat(asmstring, "{s}\t$src"))>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 228 | def _FI32m : FPI<0xDA, fp, (outs), (ins i32mem:$src), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 229 | !strconcat("fi", !strconcat(asmstring, "{l}\t$src"))>; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 230 | } |
| 231 | |
| 232 | defm ADD : FPBinary_rr<fadd>; |
| 233 | defm SUB : FPBinary_rr<fsub>; |
| 234 | defm MUL : FPBinary_rr<fmul>; |
| 235 | defm DIV : FPBinary_rr<fdiv>; |
| 236 | defm ADD : FPBinary<fadd, MRM0m, "add">; |
| 237 | defm SUB : FPBinary<fsub, MRM4m, "sub">; |
| 238 | defm SUBR: FPBinary<fsub ,MRM5m, "subr">; |
| 239 | defm MUL : FPBinary<fmul, MRM1m, "mul">; |
| 240 | defm DIV : FPBinary<fdiv, MRM6m, "div">; |
| 241 | defm DIVR: FPBinary<fdiv, MRM7m, "divr">; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 242 | |
| 243 | class FPST0rInst<bits<8> o, string asm> |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 244 | : FPI<o, AddRegFrm, (outs), (ins RST:$op), asm>, D8; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 245 | class FPrST0Inst<bits<8> o, string asm> |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 246 | : FPI<o, AddRegFrm, (outs), (ins RST:$op), asm>, DC; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 247 | class FPrST0PInst<bits<8> o, string asm> |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 248 | : FPI<o, AddRegFrm, (outs), (ins RST:$op), asm>, DE; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 249 | |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 250 | // NOTE: GAS and apparently all other AT&T style assemblers have a broken notion |
| 251 | // of some of the 'reverse' forms of the fsub and fdiv instructions. As such, |
| 252 | // we have to put some 'r's in and take them out of weird places. |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 253 | def ADD_FST0r : FPST0rInst <0xC0, "fadd\t$op">; |
| 254 | def ADD_FrST0 : FPrST0Inst <0xC0, "fadd\t{%st(0), $op|$op, %ST(0)}">; |
| 255 | def ADD_FPrST0 : FPrST0PInst<0xC0, "faddp\t$op">; |
| 256 | def SUBR_FST0r : FPST0rInst <0xE8, "fsubr\t$op">; |
| 257 | def SUB_FrST0 : FPrST0Inst <0xE8, "fsub{r}\t{%st(0), $op|$op, %ST(0)}">; |
| 258 | def SUB_FPrST0 : FPrST0PInst<0xE8, "fsub{r}p\t$op">; |
| 259 | def SUB_FST0r : FPST0rInst <0xE0, "fsub\t$op">; |
| 260 | def SUBR_FrST0 : FPrST0Inst <0xE0, "fsub{|r}\t{%st(0), $op|$op, %ST(0)}">; |
| 261 | def SUBR_FPrST0 : FPrST0PInst<0xE0, "fsub{|r}p\t$op">; |
| 262 | def MUL_FST0r : FPST0rInst <0xC8, "fmul\t$op">; |
| 263 | def MUL_FrST0 : FPrST0Inst <0xC8, "fmul\t{%st(0), $op|$op, %ST(0)}">; |
| 264 | def MUL_FPrST0 : FPrST0PInst<0xC8, "fmulp\t$op">; |
| 265 | def DIVR_FST0r : FPST0rInst <0xF8, "fdivr\t$op">; |
| 266 | def DIV_FrST0 : FPrST0Inst <0xF8, "fdiv{r}\t{%st(0), $op|$op, %ST(0)}">; |
| 267 | def DIV_FPrST0 : FPrST0PInst<0xF8, "fdiv{r}p\t$op">; |
| 268 | def DIV_FST0r : FPST0rInst <0xF0, "fdiv\t$op">; |
| 269 | def DIVR_FrST0 : FPrST0Inst <0xF0, "fdiv{|r}\t{%st(0), $op|$op, %ST(0)}">; |
| 270 | def DIVR_FPrST0 : FPrST0PInst<0xF0, "fdiv{|r}p\t$op">; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 271 | |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 272 | // Unary operations. |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 273 | multiclass FPUnary<SDNode OpNode, bits<8> opcode, string asmstring> { |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 274 | def _Fp32 : FpI<(outs RFP32:$dst), (ins RFP32:$src), OneArgFPRW, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 275 | [(set RFP32:$dst, (OpNode RFP32:$src))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 276 | def _Fp64 : FpI<(outs RFP64:$dst), (ins RFP64:$src), OneArgFPRW, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 277 | [(set RFP64:$dst, (OpNode RFP64:$src))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 278 | def _Fp80 : FpI_<(outs RFP80:$dst), (ins RFP80:$src), OneArgFPRW, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 279 | [(set RFP80:$dst, (OpNode RFP80:$src))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 280 | def _F : FPI<opcode, RawFrm, (outs), (ins), asmstring>, D9; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 281 | } |
| 282 | |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 283 | defm CHS : FPUnary<fneg, 0xE0, "fchs">; |
| 284 | defm ABS : FPUnary<fabs, 0xE1, "fabs">; |
| 285 | defm SQRT: FPUnary<fsqrt,0xFA, "fsqrt">; |
| 286 | defm SIN : FPUnary<fsin, 0xFE, "fsin">; |
| 287 | defm COS : FPUnary<fcos, 0xFF, "fcos">; |
| 288 | |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 289 | def TST_Fp32 : FpI<(outs), (ins RFP32:$src), OneArgFP, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 290 | []>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 291 | def TST_Fp64 : FpI<(outs), (ins RFP64:$src), OneArgFP, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 292 | []>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 293 | def TST_Fp80 : FpI_<(outs), (ins RFP80:$src), OneArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 294 | []>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 295 | def TST_F : FPI<0xE4, RawFrm, (outs), (ins), "ftst">, D9; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 296 | |
| 297 | // Floating point cmovs. |
| 298 | multiclass FPCMov<PatLeaf cc> { |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 299 | def _Fp32 : FpI<(outs RFP32:$dst), (ins RFP32:$src1, RFP32:$src2), CondMovFP, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 300 | [(set RFP32:$dst, (X86cmov RFP32:$src1, RFP32:$src2, |
| 301 | cc))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 302 | def _Fp64 : FpI<(outs RFP64:$dst), (ins RFP64:$src1, RFP64:$src2), CondMovFP, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 303 | [(set RFP64:$dst, (X86cmov RFP64:$src1, RFP64:$src2, |
| 304 | cc))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 305 | def _Fp80 : FpI_<(outs RFP80:$dst), (ins RFP80:$src1, RFP80:$src2), CondMovFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 306 | [(set RFP80:$dst, (X86cmov RFP80:$src1, RFP80:$src2, |
| 307 | cc))]>; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 308 | } |
| 309 | let isTwoAddress = 1 in { |
| 310 | defm CMOVB : FPCMov<X86_COND_B>; |
| 311 | defm CMOVBE : FPCMov<X86_COND_BE>; |
| 312 | defm CMOVE : FPCMov<X86_COND_E>; |
| 313 | defm CMOVP : FPCMov<X86_COND_P>; |
| 314 | defm CMOVNB : FPCMov<X86_COND_AE>; |
| 315 | defm CMOVNBE: FPCMov<X86_COND_A>; |
| 316 | defm CMOVNE : FPCMov<X86_COND_NE>; |
| 317 | defm CMOVNP : FPCMov<X86_COND_NP>; |
| 318 | } |
| 319 | |
| 320 | // These are not factored because there's no clean way to pass DA/DB. |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 321 | def CMOVB_F : FPI<0xC0, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 322 | "fcmovb\t{$op, %st(0)|%ST(0), $op}">, DA; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 323 | def CMOVBE_F : FPI<0xD0, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 324 | "fcmovbe\t{$op, %st(0)|%ST(0), $op}">, DA; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 325 | def CMOVE_F : FPI<0xC8, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 326 | "fcmove\t{$op, %st(0)|%ST(0), $op}">, DA; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 327 | def CMOVP_F : FPI<0xD8, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 328 | "fcmovu\t {$op, %st(0)|%ST(0), $op}">, DA; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 329 | def CMOVNB_F : FPI<0xC0, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 330 | "fcmovnb\t{$op, %st(0)|%ST(0), $op}">, DB; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 331 | def CMOVNBE_F: FPI<0xD0, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 332 | "fcmovnbe\t{$op, %st(0)|%ST(0), $op}">, DB; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 333 | def CMOVNE_F : FPI<0xC8, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 334 | "fcmovne\t{$op, %st(0)|%ST(0), $op}">, DB; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 335 | def CMOVNP_F : FPI<0xD8, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 336 | "fcmovnu\t{$op, %st(0)|%ST(0), $op}">, DB; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 337 | |
| 338 | // Floating point loads & stores. |
Evan Cheng | 2f39426 | 2007-08-30 05:49:43 +0000 | [diff] [blame] | 339 | let isLoad = 1 in { |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 340 | def LD_Fp32m : FpI<(outs RFP32:$dst), (ins f32mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 341 | [(set RFP32:$dst, (loadf32 addr:$src))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 342 | def LD_Fp64m : FpI<(outs RFP64:$dst), (ins f64mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 343 | [(set RFP64:$dst, (loadf64 addr:$src))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 344 | def LD_Fp80m : FpI_<(outs RFP80:$dst), (ins f80mem:$src), ZeroArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 345 | [(set RFP80:$dst, (loadf80 addr:$src))]>; |
Evan Cheng | 2f39426 | 2007-08-30 05:49:43 +0000 | [diff] [blame] | 346 | } |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 347 | def LD_Fp32m64 : FpI<(outs RFP64:$dst), (ins f32mem:$src), ZeroArgFP, |
| 348 | [(set RFP64:$dst, (f64 (extloadf32 addr:$src)))]>; |
| 349 | def LD_Fp64m80 : FpI_<(outs RFP80:$dst), (ins f64mem:$src), ZeroArgFP, |
| 350 | [(set RFP80:$dst, (f80 (extloadf64 addr:$src)))]>; |
| 351 | def LD_Fp32m80 : FpI_<(outs RFP80:$dst), (ins f32mem:$src), ZeroArgFP, |
| 352 | [(set RFP80:$dst, (f80 (extloadf32 addr:$src)))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 353 | def ILD_Fp16m32: FpI<(outs RFP32:$dst), (ins i16mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 354 | [(set RFP32:$dst, (X86fild addr:$src, i16))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 355 | def ILD_Fp32m32: FpI<(outs RFP32:$dst), (ins i32mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 356 | [(set RFP32:$dst, (X86fild addr:$src, i32))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 357 | def ILD_Fp64m32: FpI<(outs RFP32:$dst), (ins i64mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 358 | [(set RFP32:$dst, (X86fild addr:$src, i64))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 359 | def ILD_Fp16m64: FpI<(outs RFP64:$dst), (ins i16mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 360 | [(set RFP64:$dst, (X86fild addr:$src, i16))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 361 | def ILD_Fp32m64: FpI<(outs RFP64:$dst), (ins i32mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 362 | [(set RFP64:$dst, (X86fild addr:$src, i32))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 363 | def ILD_Fp64m64: FpI<(outs RFP64:$dst), (ins i64mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 364 | [(set RFP64:$dst, (X86fild addr:$src, i64))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 365 | def ILD_Fp16m80: FpI_<(outs RFP80:$dst), (ins i16mem:$src), ZeroArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 366 | [(set RFP80:$dst, (X86fild addr:$src, i16))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 367 | def ILD_Fp32m80: FpI_<(outs RFP80:$dst), (ins i32mem:$src), ZeroArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 368 | [(set RFP80:$dst, (X86fild addr:$src, i32))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 369 | def ILD_Fp64m80: FpI_<(outs RFP80:$dst), (ins i64mem:$src), ZeroArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 370 | [(set RFP80:$dst, (X86fild addr:$src, i64))]>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 371 | |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 372 | def ST_Fp32m : FpI<(outs), (ins f32mem:$op, RFP32:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 373 | [(store RFP32:$src, addr:$op)]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 374 | def ST_Fp64m32 : FpI<(outs), (ins f32mem:$op, RFP64:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 375 | [(truncstoref32 RFP64:$src, addr:$op)]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 376 | def ST_Fp64m : FpI<(outs), (ins f64mem:$op, RFP64:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 377 | [(store RFP64:$src, addr:$op)]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 378 | def ST_Fp80m32 : FpI_<(outs), (ins f32mem:$op, RFP80:$src), OneArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 379 | [(truncstoref32 RFP80:$src, addr:$op)]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 380 | def ST_Fp80m64 : FpI_<(outs), (ins f64mem:$op, RFP80:$src), OneArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 381 | [(truncstoref64 RFP80:$src, addr:$op)]>; |
| 382 | // FST does not support 80-bit memory target; FSTP must be used. |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 383 | |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 384 | def ST_FpP32m : FpI<(outs), (ins f32mem:$op, RFP32:$src), OneArgFP, []>; |
| 385 | def ST_FpP64m32 : FpI<(outs), (ins f32mem:$op, RFP64:$src), OneArgFP, []>; |
| 386 | def ST_FpP64m : FpI<(outs), (ins f64mem:$op, RFP64:$src), OneArgFP, []>; |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 387 | def ST_FpP80m32 : FpI<(outs), (ins f32mem:$op, RFP80:$src), OneArgFP, []>; |
| 388 | def ST_FpP80m64 : FpI<(outs), (ins f64mem:$op, RFP80:$src), OneArgFP, []>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 389 | def ST_FpP80m : FpI_<(outs), (ins f80mem:$op, RFP80:$src), OneArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 390 | [(store RFP80:$src, addr:$op)]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 391 | def IST_Fp16m32 : FpI<(outs), (ins i16mem:$op, RFP32:$src), OneArgFP, []>; |
| 392 | def IST_Fp32m32 : FpI<(outs), (ins i32mem:$op, RFP32:$src), OneArgFP, []>; |
| 393 | def IST_Fp64m32 : FpI<(outs), (ins i64mem:$op, RFP32:$src), OneArgFP, []>; |
| 394 | def IST_Fp16m64 : FpI<(outs), (ins i16mem:$op, RFP64:$src), OneArgFP, []>; |
| 395 | def IST_Fp32m64 : FpI<(outs), (ins i32mem:$op, RFP64:$src), OneArgFP, []>; |
| 396 | def IST_Fp64m64 : FpI<(outs), (ins i64mem:$op, RFP64:$src), OneArgFP, []>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 397 | def IST_Fp16m80 : FpI_<(outs), (ins i16mem:$op, RFP80:$src), OneArgFP, []>; |
| 398 | def IST_Fp32m80 : FpI_<(outs), (ins i32mem:$op, RFP80:$src), OneArgFP, []>; |
| 399 | def IST_Fp64m80 : FpI_<(outs), (ins i64mem:$op, RFP80:$src), OneArgFP, []>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 400 | |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 401 | def LD_F32m : FPI<0xD9, MRM0m, (outs), (ins f32mem:$src), "fld{s}\t$src">; |
| 402 | def LD_F64m : FPI<0xDD, MRM0m, (outs), (ins f64mem:$src), "fld{l}\t$src">; |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 403 | def LD_F80m : FPI<0xDB, MRM5m, (outs), (ins f80mem:$src), "fld{t}\t$src">; |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 404 | def ILD_F16m : FPI<0xDF, MRM0m, (outs), (ins i16mem:$src), "fild{s}\t$src">; |
| 405 | def ILD_F32m : FPI<0xDB, MRM0m, (outs), (ins i32mem:$src), "fild{l}\t$src">; |
| 406 | def ILD_F64m : FPI<0xDF, MRM5m, (outs), (ins i64mem:$src), "fild{ll}\t$src">; |
| 407 | def ST_F32m : FPI<0xD9, MRM2m, (outs), (ins f32mem:$dst), "fst{s}\t$dst">; |
| 408 | def ST_F64m : FPI<0xDD, MRM2m, (outs), (ins f64mem:$dst), "fst{l}\t$dst">; |
| 409 | def ST_FP32m : FPI<0xD9, MRM3m, (outs), (ins f32mem:$dst), "fstp{s}\t$dst">; |
| 410 | def ST_FP64m : FPI<0xDD, MRM3m, (outs), (ins f64mem:$dst), "fstp{l}\t$dst">; |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 411 | def ST_FP80m : FPI<0xDB, MRM7m, (outs), (ins f80mem:$dst), "fstp{t}\t$dst">; |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 412 | def IST_F16m : FPI<0xDF, MRM2m, (outs), (ins i16mem:$dst), "fist{s}\t$dst">; |
| 413 | def IST_F32m : FPI<0xDB, MRM2m, (outs), (ins i32mem:$dst), "fist{l}\t$dst">; |
| 414 | def IST_FP16m : FPI<0xDF, MRM3m, (outs), (ins i16mem:$dst), "fistp{s}\t$dst">; |
| 415 | def IST_FP32m : FPI<0xDB, MRM3m, (outs), (ins i32mem:$dst), "fistp{l}\t$dst">; |
| 416 | def IST_FP64m : FPI<0xDF, MRM7m, (outs), (ins i64mem:$dst), "fistp{ll}\t$dst">; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 417 | |
| 418 | // FISTTP requires SSE3 even though it's a FPStack op. |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 419 | def ISTT_Fp16m32 : FpI_<(outs), (ins i16mem:$op, RFP32:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 420 | [(X86fp_to_i16mem RFP32:$src, addr:$op)]>, |
| 421 | Requires<[HasSSE3]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 422 | def ISTT_Fp32m32 : FpI_<(outs), (ins i32mem:$op, RFP32:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 423 | [(X86fp_to_i32mem RFP32:$src, addr:$op)]>, |
| 424 | Requires<[HasSSE3]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 425 | def ISTT_Fp64m32 : FpI_<(outs), (ins i64mem:$op, RFP32:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 426 | [(X86fp_to_i64mem RFP32:$src, addr:$op)]>, |
| 427 | Requires<[HasSSE3]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 428 | def ISTT_Fp16m64 : FpI_<(outs), (ins i16mem:$op, RFP64:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 429 | [(X86fp_to_i16mem RFP64:$src, addr:$op)]>, |
| 430 | Requires<[HasSSE3]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 431 | def ISTT_Fp32m64 : FpI_<(outs), (ins i32mem:$op, RFP64:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 432 | [(X86fp_to_i32mem RFP64:$src, addr:$op)]>, |
| 433 | Requires<[HasSSE3]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 434 | def ISTT_Fp64m64 : FpI_<(outs), (ins i64mem:$op, RFP64:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 435 | [(X86fp_to_i64mem RFP64:$src, addr:$op)]>, |
| 436 | Requires<[HasSSE3]>; |
Dale Johannesen | a996d52 | 2007-08-07 01:17:37 +0000 | [diff] [blame] | 437 | def ISTT_Fp16m80 : FpI_<(outs), (ins i16mem:$op, RFP80:$src), OneArgFP, |
| 438 | [(X86fp_to_i16mem RFP80:$src, addr:$op)]>, |
| 439 | Requires<[HasSSE3]>; |
| 440 | def ISTT_Fp32m80 : FpI_<(outs), (ins i32mem:$op, RFP80:$src), OneArgFP, |
| 441 | [(X86fp_to_i32mem RFP80:$src, addr:$op)]>, |
| 442 | Requires<[HasSSE3]>; |
| 443 | def ISTT_Fp64m80 : FpI_<(outs), (ins i64mem:$op, RFP80:$src), OneArgFP, |
| 444 | [(X86fp_to_i64mem RFP80:$src, addr:$op)]>, |
| 445 | Requires<[HasSSE3]>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 446 | |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 447 | def ISTT_FP16m : FPI<0xDF, MRM1m, (outs), (ins i16mem:$dst), "fisttp{s}\t$dst">; |
| 448 | def ISTT_FP32m : FPI<0xDB, MRM1m, (outs), (ins i32mem:$dst), "fisttp{l}\t$dst">; |
| 449 | def ISTT_FP64m : FPI<0xDD, MRM1m, (outs), (ins i64mem:$dst), "fisttp{ll}\t$dst">; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 450 | |
| 451 | // FP Stack manipulation instructions. |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 452 | def LD_Frr : FPI<0xC0, AddRegFrm, (outs), (ins RST:$op), "fld\t$op">, D9; |
| 453 | def ST_Frr : FPI<0xD0, AddRegFrm, (outs), (ins RST:$op), "fst\t$op">, DD; |
| 454 | def ST_FPrr : FPI<0xD8, AddRegFrm, (outs), (ins RST:$op), "fstp\t$op">, DD; |
| 455 | def XCH_F : FPI<0xC8, AddRegFrm, (outs), (ins RST:$op), "fxch\t$op">, D9; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 456 | |
| 457 | // Floating point constant loads. |
Dan Gohman | d45eddd | 2007-06-26 00:48:07 +0000 | [diff] [blame] | 458 | let isReMaterializable = 1 in { |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 459 | def LD_Fp032 : FpI<(outs RFP32:$dst), (ins), ZeroArgFP, |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 460 | [(set RFP32:$dst, fpimm0)]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 461 | def LD_Fp132 : FpI<(outs RFP32:$dst), (ins), ZeroArgFP, |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 462 | [(set RFP32:$dst, fpimm1)]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 463 | def LD_Fp064 : FpI<(outs RFP64:$dst), (ins), ZeroArgFP, |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 464 | [(set RFP64:$dst, fpimm0)]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 465 | def LD_Fp164 : FpI<(outs RFP64:$dst), (ins), ZeroArgFP, |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 466 | [(set RFP64:$dst, fpimm1)]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 467 | def LD_Fp080 : FpI_<(outs RFP80:$dst), (ins), ZeroArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 468 | [(set RFP80:$dst, fpimm0)]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 469 | def LD_Fp180 : FpI_<(outs RFP80:$dst), (ins), ZeroArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 470 | [(set RFP80:$dst, fpimm1)]>; |
Dan Gohman | d45eddd | 2007-06-26 00:48:07 +0000 | [diff] [blame] | 471 | } |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 472 | |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 473 | def LD_F0 : FPI<0xEE, RawFrm, (outs), (ins), "fldz">, D9; |
| 474 | def LD_F1 : FPI<0xE8, RawFrm, (outs), (ins), "fld1">, D9; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 475 | |
| 476 | |
| 477 | // Floating point compares. |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 478 | def UCOM_Fpr32 : FpI<(outs), (ins RFP32:$lhs, RFP32:$rhs), CompareFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 479 | []>; // FPSW = cmp ST(0) with ST(i) |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 480 | def UCOM_FpIr32: FpI<(outs), (ins RFP32:$lhs, RFP32:$rhs), CompareFP, |
Dale Johannesen | bf6b827 | 2007-07-10 20:53:41 +0000 | [diff] [blame] | 481 | [(X86cmp RFP32:$lhs, RFP32:$rhs)]>; // CC = ST(0) cmp ST(i) |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 482 | def UCOM_Fpr64 : FpI<(outs), (ins RFP64:$lhs, RFP64:$rhs), CompareFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 483 | []>; // FPSW = cmp ST(0) with ST(i) |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 484 | def UCOM_FpIr64: FpI<(outs), (ins RFP64:$lhs, RFP64:$rhs), CompareFP, |
Dale Johannesen | bf6b827 | 2007-07-10 20:53:41 +0000 | [diff] [blame] | 485 | [(X86cmp RFP64:$lhs, RFP64:$rhs)]>; // CC = ST(0) cmp ST(i) |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 486 | def UCOM_Fpr80 : FpI_<(outs), (ins RFP80:$lhs, RFP80:$rhs), CompareFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 487 | []>; // FPSW = cmp ST(0) with ST(i) |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 488 | def UCOM_FpIr80: FpI_<(outs), (ins RFP80:$lhs, RFP80:$rhs), CompareFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 489 | [(X86cmp RFP80:$lhs, RFP80:$rhs)]>; // CC = ST(0) cmp ST(i) |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 490 | |
Evan Cheng | 24f2ea3 | 2007-09-14 21:48:26 +0000 | [diff] [blame^] | 491 | let Defs = [EFLAGS], Uses = [ST0] in { |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 492 | def UCOM_Fr : FPI<0xE0, AddRegFrm, // FPSW = cmp ST(0) with ST(i) |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 493 | (outs), (ins RST:$reg), |
Evan Cheng | 071a279 | 2007-09-11 19:55:27 +0000 | [diff] [blame] | 494 | "fucom\t$reg">, DD; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 495 | def UCOM_FPr : FPI<0xE8, AddRegFrm, // FPSW = cmp ST(0) with ST(i), pop |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 496 | (outs), (ins RST:$reg), |
Evan Cheng | 071a279 | 2007-09-11 19:55:27 +0000 | [diff] [blame] | 497 | "fucomp\t$reg">, DD; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 498 | def UCOM_FPPr : FPI<0xE9, RawFrm, // cmp ST(0) with ST(1), pop, pop |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 499 | (outs), (ins), |
Evan Cheng | 071a279 | 2007-09-11 19:55:27 +0000 | [diff] [blame] | 500 | "fucompp">, DA; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 501 | |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 502 | def UCOM_FIr : FPI<0xE8, AddRegFrm, // CC = cmp ST(0) with ST(i) |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 503 | (outs), (ins RST:$reg), |
Evan Cheng | 071a279 | 2007-09-11 19:55:27 +0000 | [diff] [blame] | 504 | "fucomi\t{$reg, %st(0)|%ST(0), $reg}">, DB; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 505 | def UCOM_FIPr : FPI<0xE8, AddRegFrm, // CC = cmp ST(0) with ST(i), pop |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 506 | (outs), (ins RST:$reg), |
Evan Cheng | 071a279 | 2007-09-11 19:55:27 +0000 | [diff] [blame] | 507 | "fucomip\t{$reg, %st(0)|%ST(0), $reg}">, DF; |
| 508 | } |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 509 | |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 510 | // Floating point flag ops. |
Evan Cheng | 071a279 | 2007-09-11 19:55:27 +0000 | [diff] [blame] | 511 | let Defs = [AX] in |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 512 | def FNSTSW8r : I<0xE0, RawFrm, // AX = fp flags |
Evan Cheng | 071a279 | 2007-09-11 19:55:27 +0000 | [diff] [blame] | 513 | (outs), (ins), "fnstsw", []>, DF; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 514 | |
| 515 | def FNSTCW16m : I<0xD9, MRM7m, // [mem16] = X87 control world |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 516 | (outs), (ins i16mem:$dst), "fnstcw\t$dst", []>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 517 | def FLDCW16m : I<0xD9, MRM5m, // X87 control world = [mem16] |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 518 | (outs), (ins i16mem:$dst), "fldcw\t$dst", []>; |
Evan Cheng | 4e4c71e | 2006-02-21 20:00:20 +0000 | [diff] [blame] | 519 | |
| 520 | //===----------------------------------------------------------------------===// |
| 521 | // Non-Instruction Patterns |
| 522 | //===----------------------------------------------------------------------===// |
| 523 | |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 524 | // Required for RET of f32 / f64 / f80 values. |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 525 | def : Pat<(X86fld addr:$src, f32), (LD_Fp32m addr:$src)>; |
| 526 | def : Pat<(X86fld addr:$src, f64), (LD_Fp64m addr:$src)>; |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 527 | def : Pat<(X86fld addr:$src, f80), (LD_Fp80m addr:$src)>; |
Evan Cheng | 4e4c71e | 2006-02-21 20:00:20 +0000 | [diff] [blame] | 528 | |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 529 | // Required for CALL which return f32 / f64 / f80 values. |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 530 | def : Pat<(X86fst RFP32:$src, addr:$op, f32), (ST_Fp32m addr:$op, RFP32:$src)>; |
| 531 | def : Pat<(X86fst RFP64:$src, addr:$op, f32), (ST_Fp64m32 addr:$op, RFP64:$src)>; |
| 532 | def : Pat<(X86fst RFP64:$src, addr:$op, f64), (ST_Fp64m addr:$op, RFP64:$src)>; |
Dale Johannesen | a996d52 | 2007-08-07 01:17:37 +0000 | [diff] [blame] | 533 | def : Pat<(X86fst RFP80:$src, addr:$op, f32), (ST_Fp80m32 addr:$op, RFP80:$src)>; |
| 534 | def : Pat<(X86fst RFP80:$src, addr:$op, f64), (ST_Fp80m64 addr:$op, RFP80:$src)>; |
| 535 | def : Pat<(X86fst RFP80:$src, addr:$op, f80), (ST_FpP80m addr:$op, RFP80:$src)>; |
Evan Cheng | 4e4c71e | 2006-02-21 20:00:20 +0000 | [diff] [blame] | 536 | |
| 537 | // Floating point constant -0.0 and -1.0 |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 538 | def : Pat<(f32 fpimmneg0), (CHS_Fp32 (LD_Fp032))>, Requires<[FPStack]>; |
| 539 | def : Pat<(f32 fpimmneg1), (CHS_Fp32 (LD_Fp132))>, Requires<[FPStack]>; |
| 540 | def : Pat<(f64 fpimmneg0), (CHS_Fp64 (LD_Fp064))>, Requires<[FPStack]>; |
| 541 | def : Pat<(f64 fpimmneg1), (CHS_Fp64 (LD_Fp164))>, Requires<[FPStack]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 542 | def : Pat<(f80 fpimmneg0), (CHS_Fp80 (LD_Fp080))>; |
| 543 | def : Pat<(f80 fpimmneg1), (CHS_Fp80 (LD_Fp180))>; |
Evan Cheng | 4e4c71e | 2006-02-21 20:00:20 +0000 | [diff] [blame] | 544 | |
| 545 | // Used to conv. i64 to f64 since there isn't a SSE version. |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 546 | def : Pat<(X86fildflag addr:$src, i64), (ILD_Fp64m64 addr:$src)>; |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 547 | |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 548 | def : Pat<(f64 (fextend RFP32:$src)), (MOV_Fp3264 RFP32:$src)>, Requires<[FPStack]>; |
| 549 | def : Pat<(f80 (fextend RFP32:$src)), (MOV_Fp3280 RFP32:$src)>, Requires<[FPStack]>; |
| 550 | def : Pat<(f80 (fextend RFP64:$src)), (MOV_Fp6480 RFP64:$src)>, Requires<[FPStack]>; |