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 | ffbacca | 2007-07-21 00:34:19 +0000 | [diff] [blame] | 144 | def FpSETRESULT32 : FpI_<(outs), (ins RFP32:$src), SpecialFP, |
| 145 | [(X86fpset RFP32:$src)]>, Imp<[], [ST0]>;// ST(0) = FPR |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 146 | |
Evan Cheng | ffbacca | 2007-07-21 00:34:19 +0000 | [diff] [blame] | 147 | def FpSETRESULT64 : FpI_<(outs), (ins RFP64:$src), SpecialFP, |
| 148 | [(X86fpset RFP64:$src)]>, Imp<[], [ST0]>;// ST(0) = FPR |
| 149 | |
Dale Johannesen | 6a30811 | 2007-08-06 21:31:06 +0000 | [diff] [blame] | 150 | def FpSETRESULT80 : FpI_<(outs), (ins RFP80:$src), SpecialFP, |
| 151 | [(X86fpset RFP80:$src)]>, Imp<[], [ST0]>;// ST(0) = FPR |
| 152 | |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 153 | // FpI - Floating Point Psuedo Instruction template. Predicated on FPStack. |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 154 | // Note that f80-only instructions are used even in SSE mode and use FpI_ |
| 155 | // not this predicate. |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 156 | class FpI<dag outs, dag ins, FPFormat fp, list<dag> pattern> : |
| 157 | FpI_<outs, ins, fp, pattern>, Requires<[FPStack]>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 158 | |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 159 | // Register copies. Just copies, the shortening ones do not truncate. |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 160 | def MOV_Fp3232 : FpI<(outs RFP32:$dst), (ins RFP32:$src), SpecialFP, []>; |
| 161 | def MOV_Fp3264 : FpI<(outs RFP64:$dst), (ins RFP32:$src), SpecialFP, []>; |
| 162 | def MOV_Fp6432 : FpI<(outs RFP32:$dst), (ins RFP64:$src), SpecialFP, []>; |
| 163 | def MOV_Fp6464 : FpI<(outs RFP64:$dst), (ins RFP64:$src), SpecialFP, []>; |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 164 | def MOV_Fp8032 : FpI<(outs RFP32:$dst), (ins RFP80:$src), SpecialFP, []>; |
| 165 | def MOV_Fp3280 : FpI<(outs RFP80:$dst), (ins RFP32:$src), SpecialFP, []>; |
| 166 | def MOV_Fp8064 : FpI<(outs RFP64:$dst), (ins RFP80:$src), SpecialFP, []>; |
| 167 | def MOV_Fp6480 : FpI<(outs RFP80:$dst), (ins RFP64:$src), SpecialFP, []>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 168 | def MOV_Fp8080 : FpI_<(outs RFP80:$dst), (ins RFP80:$src), SpecialFP, []>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 169 | |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 170 | // Factoring for arithmetic. |
| 171 | multiclass FPBinary_rr<SDNode OpNode> { |
| 172 | // Register op register -> register |
| 173 | // These are separated out because they have no reversed form. |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 174 | def _Fp32 : FpI<(outs RFP32:$dst), (ins RFP32:$src1, RFP32:$src2), TwoArgFP, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 175 | [(set RFP32:$dst, (OpNode RFP32:$src1, RFP32:$src2))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 176 | def _Fp64 : FpI<(outs RFP64:$dst), (ins RFP64:$src1, RFP64:$src2), TwoArgFP, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 177 | [(set RFP64:$dst, (OpNode RFP64:$src1, RFP64:$src2))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 178 | def _Fp80 : FpI_<(outs RFP80:$dst), (ins RFP80:$src1, RFP80:$src2), TwoArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 179 | [(set RFP80:$dst, (OpNode RFP80:$src1, RFP80:$src2))]>; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 180 | } |
| 181 | // The FopST0 series are not included here because of the irregularities |
| 182 | // in where the 'r' goes in assembly output. |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 183 | // These instructions cannot address 80-bit memory. |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 184 | multiclass FPBinary<SDNode OpNode, Format fp, string asmstring> { |
| 185 | // ST(0) = ST(0) + [mem] |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 186 | def _Fp32m : FpI<(outs RFP32:$dst), (ins RFP32:$src1, f32mem:$src2), OneArgFPRW, |
Dale Johannesen | bf6b827 | 2007-07-10 20:53:41 +0000 | [diff] [blame] | 187 | [(set RFP32:$dst, |
| 188 | (OpNode RFP32:$src1, (loadf32 addr:$src2)))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 189 | def _Fp64m : FpI<(outs RFP64:$dst), (ins RFP64:$src1, f64mem:$src2), OneArgFPRW, |
Dale Johannesen | bf6b827 | 2007-07-10 20:53:41 +0000 | [diff] [blame] | 190 | [(set RFP64:$dst, |
| 191 | (OpNode RFP64:$src1, (loadf64 addr:$src2)))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 192 | def _Fp64m32: FpI<(outs RFP64:$dst), (ins RFP64:$src1, f32mem:$src2), OneArgFPRW, |
Dale Johannesen | afdc7fd | 2007-07-10 21:53:30 +0000 | [diff] [blame] | 193 | [(set RFP64:$dst, |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 194 | (OpNode RFP64:$src1, (f64 (extloadf32 addr:$src2))))]>; |
| 195 | def _Fp80m32: FpI_<(outs RFP80:$dst), (ins RFP80:$src1, f32mem:$src2), OneArgFPRW, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 196 | [(set RFP80:$dst, |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 197 | (OpNode RFP80:$src1, (f80 (extloadf32 addr:$src2))))]>; |
| 198 | def _Fp80m64: FpI_<(outs RFP80:$dst), (ins RFP80:$src1, f64mem:$src2), OneArgFPRW, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 199 | [(set RFP80:$dst, |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 200 | (OpNode RFP80:$src1, (f80 (extloadf64 addr:$src2))))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 201 | def _F32m : FPI<0xD8, fp, (outs), (ins f32mem:$src), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 202 | !strconcat("f", !strconcat(asmstring, "{s}\t$src"))>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 203 | def _F64m : FPI<0xDC, fp, (outs), (ins f64mem:$src), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 204 | !strconcat("f", !strconcat(asmstring, "{l}\t$src"))>; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 205 | // ST(0) = ST(0) + [memint] |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 206 | def _FpI16m32 : FpI<(outs RFP32:$dst), (ins RFP32:$src1, i16mem:$src2), OneArgFPRW, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 207 | [(set RFP32:$dst, (OpNode RFP32:$src1, |
| 208 | (X86fild addr:$src2, i16)))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 209 | def _FpI32m32 : FpI<(outs RFP32:$dst), (ins RFP32:$src1, i32mem:$src2), OneArgFPRW, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 210 | [(set RFP32:$dst, (OpNode RFP32:$src1, |
| 211 | (X86fild addr:$src2, i32)))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 212 | def _FpI16m64 : FpI<(outs RFP64:$dst), (ins RFP64:$src1, i16mem:$src2), OneArgFPRW, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 213 | [(set RFP64:$dst, (OpNode RFP64:$src1, |
| 214 | (X86fild addr:$src2, i16)))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 215 | def _FpI32m64 : FpI<(outs RFP64:$dst), (ins RFP64:$src1, i32mem:$src2), OneArgFPRW, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 216 | [(set RFP64:$dst, (OpNode RFP64:$src1, |
| 217 | (X86fild addr:$src2, i32)))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 218 | def _FpI16m80 : FpI_<(outs RFP80:$dst), (ins RFP80:$src1, i16mem:$src2), OneArgFPRW, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 219 | [(set RFP80:$dst, (OpNode RFP80:$src1, |
| 220 | (X86fild addr:$src2, i16)))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 221 | def _FpI32m80 : FpI_<(outs RFP80:$dst), (ins RFP80:$src1, i32mem:$src2), OneArgFPRW, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 222 | [(set RFP80:$dst, (OpNode RFP80:$src1, |
| 223 | (X86fild addr:$src2, i32)))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 224 | def _FI16m : FPI<0xDE, fp, (outs), (ins i16mem:$src), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 225 | !strconcat("fi", !strconcat(asmstring, "{s}\t$src"))>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 226 | def _FI32m : FPI<0xDA, fp, (outs), (ins i32mem:$src), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 227 | !strconcat("fi", !strconcat(asmstring, "{l}\t$src"))>; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 228 | } |
| 229 | |
| 230 | defm ADD : FPBinary_rr<fadd>; |
| 231 | defm SUB : FPBinary_rr<fsub>; |
| 232 | defm MUL : FPBinary_rr<fmul>; |
| 233 | defm DIV : FPBinary_rr<fdiv>; |
| 234 | defm ADD : FPBinary<fadd, MRM0m, "add">; |
| 235 | defm SUB : FPBinary<fsub, MRM4m, "sub">; |
| 236 | defm SUBR: FPBinary<fsub ,MRM5m, "subr">; |
| 237 | defm MUL : FPBinary<fmul, MRM1m, "mul">; |
| 238 | defm DIV : FPBinary<fdiv, MRM6m, "div">; |
| 239 | defm DIVR: FPBinary<fdiv, MRM7m, "divr">; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 240 | |
| 241 | class FPST0rInst<bits<8> o, string asm> |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 242 | : FPI<o, AddRegFrm, (outs), (ins RST:$op), asm>, D8; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 243 | class FPrST0Inst<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>, DC; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 245 | class FPrST0PInst<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>, DE; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 247 | |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 248 | // NOTE: GAS and apparently all other AT&T style assemblers have a broken notion |
| 249 | // of some of the 'reverse' forms of the fsub and fdiv instructions. As such, |
| 250 | // 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] | 251 | def ADD_FST0r : FPST0rInst <0xC0, "fadd\t$op">; |
| 252 | def ADD_FrST0 : FPrST0Inst <0xC0, "fadd\t{%st(0), $op|$op, %ST(0)}">; |
| 253 | def ADD_FPrST0 : FPrST0PInst<0xC0, "faddp\t$op">; |
| 254 | def SUBR_FST0r : FPST0rInst <0xE8, "fsubr\t$op">; |
| 255 | def SUB_FrST0 : FPrST0Inst <0xE8, "fsub{r}\t{%st(0), $op|$op, %ST(0)}">; |
| 256 | def SUB_FPrST0 : FPrST0PInst<0xE8, "fsub{r}p\t$op">; |
| 257 | def SUB_FST0r : FPST0rInst <0xE0, "fsub\t$op">; |
| 258 | def SUBR_FrST0 : FPrST0Inst <0xE0, "fsub{|r}\t{%st(0), $op|$op, %ST(0)}">; |
| 259 | def SUBR_FPrST0 : FPrST0PInst<0xE0, "fsub{|r}p\t$op">; |
| 260 | def MUL_FST0r : FPST0rInst <0xC8, "fmul\t$op">; |
| 261 | def MUL_FrST0 : FPrST0Inst <0xC8, "fmul\t{%st(0), $op|$op, %ST(0)}">; |
| 262 | def MUL_FPrST0 : FPrST0PInst<0xC8, "fmulp\t$op">; |
| 263 | def DIVR_FST0r : FPST0rInst <0xF8, "fdivr\t$op">; |
| 264 | def DIV_FrST0 : FPrST0Inst <0xF8, "fdiv{r}\t{%st(0), $op|$op, %ST(0)}">; |
| 265 | def DIV_FPrST0 : FPrST0PInst<0xF8, "fdiv{r}p\t$op">; |
| 266 | def DIV_FST0r : FPST0rInst <0xF0, "fdiv\t$op">; |
| 267 | def DIVR_FrST0 : FPrST0Inst <0xF0, "fdiv{|r}\t{%st(0), $op|$op, %ST(0)}">; |
| 268 | def DIVR_FPrST0 : FPrST0PInst<0xF0, "fdiv{|r}p\t$op">; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 269 | |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 270 | // Unary operations. |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 271 | multiclass FPUnary<SDNode OpNode, bits<8> opcode, string asmstring> { |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 272 | def _Fp32 : FpI<(outs RFP32:$dst), (ins RFP32:$src), OneArgFPRW, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 273 | [(set RFP32:$dst, (OpNode RFP32:$src))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 274 | def _Fp64 : FpI<(outs RFP64:$dst), (ins RFP64:$src), OneArgFPRW, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 275 | [(set RFP64:$dst, (OpNode RFP64:$src))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 276 | def _Fp80 : FpI_<(outs RFP80:$dst), (ins RFP80:$src), OneArgFPRW, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 277 | [(set RFP80:$dst, (OpNode RFP80:$src))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 278 | def _F : FPI<opcode, RawFrm, (outs), (ins), asmstring>, D9; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 279 | } |
| 280 | |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 281 | defm CHS : FPUnary<fneg, 0xE0, "fchs">; |
| 282 | defm ABS : FPUnary<fabs, 0xE1, "fabs">; |
| 283 | defm SQRT: FPUnary<fsqrt,0xFA, "fsqrt">; |
| 284 | defm SIN : FPUnary<fsin, 0xFE, "fsin">; |
| 285 | defm COS : FPUnary<fcos, 0xFF, "fcos">; |
| 286 | |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 287 | def TST_Fp32 : FpI<(outs), (ins RFP32:$src), OneArgFP, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 288 | []>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 289 | def TST_Fp64 : FpI<(outs), (ins RFP64:$src), OneArgFP, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 290 | []>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 291 | def TST_Fp80 : FpI_<(outs), (ins RFP80:$src), OneArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 292 | []>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 293 | def TST_F : FPI<0xE4, RawFrm, (outs), (ins), "ftst">, D9; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 294 | |
| 295 | // Floating point cmovs. |
| 296 | multiclass FPCMov<PatLeaf cc> { |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 297 | def _Fp32 : FpI<(outs RFP32:$dst), (ins RFP32:$src1, RFP32:$src2), CondMovFP, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 298 | [(set RFP32:$dst, (X86cmov RFP32:$src1, RFP32:$src2, |
| 299 | cc))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 300 | def _Fp64 : FpI<(outs RFP64:$dst), (ins RFP64:$src1, RFP64:$src2), CondMovFP, |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 301 | [(set RFP64:$dst, (X86cmov RFP64:$src1, RFP64:$src2, |
| 302 | cc))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 303 | def _Fp80 : FpI_<(outs RFP80:$dst), (ins RFP80:$src1, RFP80:$src2), CondMovFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 304 | [(set RFP80:$dst, (X86cmov RFP80:$src1, RFP80:$src2, |
| 305 | cc))]>; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 306 | } |
| 307 | let isTwoAddress = 1 in { |
| 308 | defm CMOVB : FPCMov<X86_COND_B>; |
| 309 | defm CMOVBE : FPCMov<X86_COND_BE>; |
| 310 | defm CMOVE : FPCMov<X86_COND_E>; |
| 311 | defm CMOVP : FPCMov<X86_COND_P>; |
| 312 | defm CMOVNB : FPCMov<X86_COND_AE>; |
| 313 | defm CMOVNBE: FPCMov<X86_COND_A>; |
| 314 | defm CMOVNE : FPCMov<X86_COND_NE>; |
| 315 | defm CMOVNP : FPCMov<X86_COND_NP>; |
| 316 | } |
| 317 | |
| 318 | // 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] | 319 | def CMOVB_F : FPI<0xC0, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 320 | "fcmovb\t{$op, %st(0)|%ST(0), $op}">, DA; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 321 | def CMOVBE_F : FPI<0xD0, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 322 | "fcmovbe\t{$op, %st(0)|%ST(0), $op}">, DA; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 323 | def CMOVE_F : FPI<0xC8, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 324 | "fcmove\t{$op, %st(0)|%ST(0), $op}">, DA; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 325 | def CMOVP_F : FPI<0xD8, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 326 | "fcmovu\t {$op, %st(0)|%ST(0), $op}">, DA; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 327 | def CMOVNB_F : FPI<0xC0, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 328 | "fcmovnb\t{$op, %st(0)|%ST(0), $op}">, DB; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 329 | def CMOVNBE_F: FPI<0xD0, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 330 | "fcmovnbe\t{$op, %st(0)|%ST(0), $op}">, DB; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 331 | def CMOVNE_F : FPI<0xC8, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 332 | "fcmovne\t{$op, %st(0)|%ST(0), $op}">, DB; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 333 | def CMOVNP_F : FPI<0xD8, AddRegFrm, (outs RST:$op), (ins), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 334 | "fcmovnu\t{$op, %st(0)|%ST(0), $op}">, DB; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 335 | |
| 336 | // Floating point loads & stores. |
Evan Cheng | 2f39426 | 2007-08-30 05:49:43 +0000 | [diff] [blame^] | 337 | let isLoad = 1 in { |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 338 | def LD_Fp32m : FpI<(outs RFP32:$dst), (ins f32mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 339 | [(set RFP32:$dst, (loadf32 addr:$src))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 340 | def LD_Fp64m : FpI<(outs RFP64:$dst), (ins f64mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 341 | [(set RFP64:$dst, (loadf64 addr:$src))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 342 | def LD_Fp80m : FpI_<(outs RFP80:$dst), (ins f80mem:$src), ZeroArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 343 | [(set RFP80:$dst, (loadf80 addr:$src))]>; |
Evan Cheng | 2f39426 | 2007-08-30 05:49:43 +0000 | [diff] [blame^] | 344 | } |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 345 | def LD_Fp32m64 : FpI<(outs RFP64:$dst), (ins f32mem:$src), ZeroArgFP, |
| 346 | [(set RFP64:$dst, (f64 (extloadf32 addr:$src)))]>; |
| 347 | def LD_Fp64m80 : FpI_<(outs RFP80:$dst), (ins f64mem:$src), ZeroArgFP, |
| 348 | [(set RFP80:$dst, (f80 (extloadf64 addr:$src)))]>; |
| 349 | def LD_Fp32m80 : FpI_<(outs RFP80:$dst), (ins f32mem:$src), ZeroArgFP, |
| 350 | [(set RFP80:$dst, (f80 (extloadf32 addr:$src)))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 351 | def ILD_Fp16m32: FpI<(outs RFP32:$dst), (ins i16mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 352 | [(set RFP32:$dst, (X86fild addr:$src, i16))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 353 | def ILD_Fp32m32: FpI<(outs RFP32:$dst), (ins i32mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 354 | [(set RFP32:$dst, (X86fild addr:$src, i32))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 355 | def ILD_Fp64m32: FpI<(outs RFP32:$dst), (ins i64mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 356 | [(set RFP32:$dst, (X86fild addr:$src, i64))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 357 | def ILD_Fp16m64: FpI<(outs RFP64:$dst), (ins i16mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 358 | [(set RFP64:$dst, (X86fild addr:$src, i16))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 359 | def ILD_Fp32m64: FpI<(outs RFP64:$dst), (ins i32mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 360 | [(set RFP64:$dst, (X86fild addr:$src, i32))]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 361 | def ILD_Fp64m64: FpI<(outs RFP64:$dst), (ins i64mem:$src), ZeroArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 362 | [(set RFP64:$dst, (X86fild addr:$src, i64))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 363 | def ILD_Fp16m80: FpI_<(outs RFP80:$dst), (ins i16mem:$src), ZeroArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 364 | [(set RFP80:$dst, (X86fild addr:$src, i16))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 365 | def ILD_Fp32m80: FpI_<(outs RFP80:$dst), (ins i32mem:$src), ZeroArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 366 | [(set RFP80:$dst, (X86fild addr:$src, i32))]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 367 | def ILD_Fp64m80: FpI_<(outs RFP80:$dst), (ins i64mem:$src), ZeroArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 368 | [(set RFP80:$dst, (X86fild addr:$src, i64))]>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 369 | |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 370 | def ST_Fp32m : FpI<(outs), (ins f32mem:$op, RFP32:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 371 | [(store RFP32:$src, addr:$op)]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 372 | def ST_Fp64m32 : FpI<(outs), (ins f32mem:$op, RFP64:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 373 | [(truncstoref32 RFP64:$src, addr:$op)]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 374 | def ST_Fp64m : FpI<(outs), (ins f64mem:$op, RFP64:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 375 | [(store RFP64:$src, addr:$op)]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 376 | def ST_Fp80m32 : FpI_<(outs), (ins f32mem:$op, RFP80:$src), OneArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 377 | [(truncstoref32 RFP80:$src, addr:$op)]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 378 | def ST_Fp80m64 : FpI_<(outs), (ins f64mem:$op, RFP80:$src), OneArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 379 | [(truncstoref64 RFP80:$src, addr:$op)]>; |
| 380 | // FST does not support 80-bit memory target; FSTP must be used. |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 381 | |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 382 | def ST_FpP32m : FpI<(outs), (ins f32mem:$op, RFP32:$src), OneArgFP, []>; |
| 383 | def ST_FpP64m32 : FpI<(outs), (ins f32mem:$op, RFP64:$src), OneArgFP, []>; |
| 384 | def ST_FpP64m : FpI<(outs), (ins f64mem:$op, RFP64:$src), OneArgFP, []>; |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 385 | def ST_FpP80m32 : FpI<(outs), (ins f32mem:$op, RFP80:$src), OneArgFP, []>; |
| 386 | def ST_FpP80m64 : FpI<(outs), (ins f64mem:$op, RFP80:$src), OneArgFP, []>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 387 | def ST_FpP80m : FpI_<(outs), (ins f80mem:$op, RFP80:$src), OneArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 388 | [(store RFP80:$src, addr:$op)]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 389 | def IST_Fp16m32 : FpI<(outs), (ins i16mem:$op, RFP32:$src), OneArgFP, []>; |
| 390 | def IST_Fp32m32 : FpI<(outs), (ins i32mem:$op, RFP32:$src), OneArgFP, []>; |
| 391 | def IST_Fp64m32 : FpI<(outs), (ins i64mem:$op, RFP32:$src), OneArgFP, []>; |
| 392 | def IST_Fp16m64 : FpI<(outs), (ins i16mem:$op, RFP64:$src), OneArgFP, []>; |
| 393 | def IST_Fp32m64 : FpI<(outs), (ins i32mem:$op, RFP64:$src), OneArgFP, []>; |
| 394 | def IST_Fp64m64 : FpI<(outs), (ins i64mem:$op, RFP64:$src), OneArgFP, []>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 395 | def IST_Fp16m80 : FpI_<(outs), (ins i16mem:$op, RFP80:$src), OneArgFP, []>; |
| 396 | def IST_Fp32m80 : FpI_<(outs), (ins i32mem:$op, RFP80:$src), OneArgFP, []>; |
| 397 | def IST_Fp64m80 : FpI_<(outs), (ins i64mem:$op, RFP80:$src), OneArgFP, []>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 398 | |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 399 | def LD_F32m : FPI<0xD9, MRM0m, (outs), (ins f32mem:$src), "fld{s}\t$src">; |
| 400 | 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] | 401 | 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] | 402 | def ILD_F16m : FPI<0xDF, MRM0m, (outs), (ins i16mem:$src), "fild{s}\t$src">; |
| 403 | def ILD_F32m : FPI<0xDB, MRM0m, (outs), (ins i32mem:$src), "fild{l}\t$src">; |
| 404 | def ILD_F64m : FPI<0xDF, MRM5m, (outs), (ins i64mem:$src), "fild{ll}\t$src">; |
| 405 | def ST_F32m : FPI<0xD9, MRM2m, (outs), (ins f32mem:$dst), "fst{s}\t$dst">; |
| 406 | def ST_F64m : FPI<0xDD, MRM2m, (outs), (ins f64mem:$dst), "fst{l}\t$dst">; |
| 407 | def ST_FP32m : FPI<0xD9, MRM3m, (outs), (ins f32mem:$dst), "fstp{s}\t$dst">; |
| 408 | 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] | 409 | 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] | 410 | def IST_F16m : FPI<0xDF, MRM2m, (outs), (ins i16mem:$dst), "fist{s}\t$dst">; |
| 411 | def IST_F32m : FPI<0xDB, MRM2m, (outs), (ins i32mem:$dst), "fist{l}\t$dst">; |
| 412 | def IST_FP16m : FPI<0xDF, MRM3m, (outs), (ins i16mem:$dst), "fistp{s}\t$dst">; |
| 413 | def IST_FP32m : FPI<0xDB, MRM3m, (outs), (ins i32mem:$dst), "fistp{l}\t$dst">; |
| 414 | 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] | 415 | |
| 416 | // FISTTP requires SSE3 even though it's a FPStack op. |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 417 | def ISTT_Fp16m32 : FpI_<(outs), (ins i16mem:$op, RFP32:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 418 | [(X86fp_to_i16mem RFP32:$src, addr:$op)]>, |
| 419 | Requires<[HasSSE3]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 420 | def ISTT_Fp32m32 : FpI_<(outs), (ins i32mem:$op, RFP32:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 421 | [(X86fp_to_i32mem RFP32:$src, addr:$op)]>, |
| 422 | Requires<[HasSSE3]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 423 | def ISTT_Fp64m32 : FpI_<(outs), (ins i64mem:$op, RFP32:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 424 | [(X86fp_to_i64mem RFP32:$src, addr:$op)]>, |
| 425 | Requires<[HasSSE3]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 426 | def ISTT_Fp16m64 : FpI_<(outs), (ins i16mem:$op, RFP64:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 427 | [(X86fp_to_i16mem RFP64:$src, addr:$op)]>, |
| 428 | Requires<[HasSSE3]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 429 | def ISTT_Fp32m64 : FpI_<(outs), (ins i32mem:$op, RFP64:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 430 | [(X86fp_to_i32mem RFP64:$src, addr:$op)]>, |
| 431 | Requires<[HasSSE3]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 432 | def ISTT_Fp64m64 : FpI_<(outs), (ins i64mem:$op, RFP64:$src), OneArgFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 433 | [(X86fp_to_i64mem RFP64:$src, addr:$op)]>, |
| 434 | Requires<[HasSSE3]>; |
Dale Johannesen | a996d52 | 2007-08-07 01:17:37 +0000 | [diff] [blame] | 435 | def ISTT_Fp16m80 : FpI_<(outs), (ins i16mem:$op, RFP80:$src), OneArgFP, |
| 436 | [(X86fp_to_i16mem RFP80:$src, addr:$op)]>, |
| 437 | Requires<[HasSSE3]>; |
| 438 | def ISTT_Fp32m80 : FpI_<(outs), (ins i32mem:$op, RFP80:$src), OneArgFP, |
| 439 | [(X86fp_to_i32mem RFP80:$src, addr:$op)]>, |
| 440 | Requires<[HasSSE3]>; |
| 441 | def ISTT_Fp64m80 : FpI_<(outs), (ins i64mem:$op, RFP80:$src), OneArgFP, |
| 442 | [(X86fp_to_i64mem RFP80:$src, addr:$op)]>, |
| 443 | Requires<[HasSSE3]>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 444 | |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 445 | def ISTT_FP16m : FPI<0xDF, MRM1m, (outs), (ins i16mem:$dst), "fisttp{s}\t$dst">; |
| 446 | def ISTT_FP32m : FPI<0xDB, MRM1m, (outs), (ins i32mem:$dst), "fisttp{l}\t$dst">; |
| 447 | 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] | 448 | |
| 449 | // FP Stack manipulation instructions. |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 450 | def LD_Frr : FPI<0xC0, AddRegFrm, (outs), (ins RST:$op), "fld\t$op">, D9; |
| 451 | def ST_Frr : FPI<0xD0, AddRegFrm, (outs), (ins RST:$op), "fst\t$op">, DD; |
| 452 | def ST_FPrr : FPI<0xD8, AddRegFrm, (outs), (ins RST:$op), "fstp\t$op">, DD; |
| 453 | 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] | 454 | |
| 455 | // Floating point constant loads. |
Dan Gohman | d45eddd | 2007-06-26 00:48:07 +0000 | [diff] [blame] | 456 | let isReMaterializable = 1 in { |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 457 | def LD_Fp032 : FpI<(outs RFP32:$dst), (ins), ZeroArgFP, |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 458 | [(set RFP32:$dst, fpimm0)]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 459 | def LD_Fp132 : FpI<(outs RFP32:$dst), (ins), ZeroArgFP, |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 460 | [(set RFP32:$dst, fpimm1)]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 461 | def LD_Fp064 : FpI<(outs RFP64:$dst), (ins), ZeroArgFP, |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 462 | [(set RFP64:$dst, fpimm0)]>; |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 463 | def LD_Fp164 : FpI<(outs RFP64:$dst), (ins), ZeroArgFP, |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 464 | [(set RFP64:$dst, fpimm1)]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 465 | def LD_Fp080 : FpI_<(outs RFP80:$dst), (ins), ZeroArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 466 | [(set RFP80:$dst, fpimm0)]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 467 | def LD_Fp180 : FpI_<(outs RFP80:$dst), (ins), ZeroArgFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 468 | [(set RFP80:$dst, fpimm1)]>; |
Dan Gohman | d45eddd | 2007-06-26 00:48:07 +0000 | [diff] [blame] | 469 | } |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 470 | |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 471 | def LD_F0 : FPI<0xEE, RawFrm, (outs), (ins), "fldz">, D9; |
| 472 | def LD_F1 : FPI<0xE8, RawFrm, (outs), (ins), "fld1">, D9; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 473 | |
| 474 | |
| 475 | // Floating point compares. |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 476 | def UCOM_Fpr32 : FpI<(outs), (ins RFP32:$lhs, RFP32:$rhs), CompareFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 477 | []>; // FPSW = cmp ST(0) with ST(i) |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 478 | def UCOM_FpIr32: FpI<(outs), (ins RFP32:$lhs, RFP32:$rhs), CompareFP, |
Dale Johannesen | bf6b827 | 2007-07-10 20:53:41 +0000 | [diff] [blame] | 479 | [(X86cmp RFP32:$lhs, RFP32:$rhs)]>; // CC = ST(0) cmp ST(i) |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 480 | def UCOM_Fpr64 : FpI<(outs), (ins RFP64:$lhs, RFP64:$rhs), CompareFP, |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 481 | []>; // FPSW = cmp ST(0) with ST(i) |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 482 | def UCOM_FpIr64: FpI<(outs), (ins RFP64:$lhs, RFP64:$rhs), CompareFP, |
Dale Johannesen | bf6b827 | 2007-07-10 20:53:41 +0000 | [diff] [blame] | 483 | [(X86cmp RFP64:$lhs, RFP64:$rhs)]>; // CC = ST(0) cmp ST(i) |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 484 | def UCOM_Fpr80 : FpI_<(outs), (ins RFP80:$lhs, RFP80:$rhs), CompareFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 485 | []>; // FPSW = cmp ST(0) with ST(i) |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 486 | def UCOM_FpIr80: FpI_<(outs), (ins RFP80:$lhs, RFP80:$rhs), CompareFP, |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 487 | [(X86cmp RFP80:$lhs, RFP80:$rhs)]>; // CC = ST(0) cmp ST(i) |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 488 | |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 489 | 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] | 490 | (outs), (ins RST:$reg), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 491 | "fucom\t$reg">, DD, Imp<[ST0],[]>; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 492 | 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] | 493 | (outs), (ins RST:$reg), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 494 | "fucomp\t$reg">, DD, Imp<[ST0],[]>; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 495 | 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] | 496 | (outs), (ins), |
Dale Johannesen | 411d9c5 | 2007-07-03 17:07:33 +0000 | [diff] [blame] | 497 | "fucompp">, DA, Imp<[ST0],[]>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 498 | |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 499 | 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] | 500 | (outs), (ins RST:$reg), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 501 | "fucomi\t{$reg, %st(0)|%ST(0), $reg}">, DB, Imp<[ST0],[]>; |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 502 | 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] | 503 | (outs), (ins RST:$reg), |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 504 | "fucomip\t{$reg, %st(0)|%ST(0), $reg}">, DF, Imp<[ST0],[]>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 505 | |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 506 | // Floating point flag ops. |
| 507 | def FNSTSW8r : I<0xE0, RawFrm, // AX = fp flags |
Evan Cheng | 64d80e3 | 2007-07-19 01:14:50 +0000 | [diff] [blame] | 508 | (outs), (ins), "fnstsw", []>, DF, Imp<[],[AX]>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 509 | |
| 510 | def FNSTCW16m : I<0xD9, MRM7m, // [mem16] = X87 control world |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 511 | (outs), (ins i16mem:$dst), "fnstcw\t$dst", []>; |
Evan Cheng | ffcb95b | 2006-02-21 19:13:53 +0000 | [diff] [blame] | 512 | def FLDCW16m : I<0xD9, MRM5m, // X87 control world = [mem16] |
Dan Gohman | b1576f5 | 2007-07-31 20:11:57 +0000 | [diff] [blame] | 513 | (outs), (ins i16mem:$dst), "fldcw\t$dst", []>; |
Evan Cheng | 4e4c71e | 2006-02-21 20:00:20 +0000 | [diff] [blame] | 514 | |
| 515 | //===----------------------------------------------------------------------===// |
| 516 | // Non-Instruction Patterns |
| 517 | //===----------------------------------------------------------------------===// |
| 518 | |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 519 | // Required for RET of f32 / f64 / f80 values. |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 520 | def : Pat<(X86fld addr:$src, f32), (LD_Fp32m addr:$src)>; |
| 521 | def : Pat<(X86fld addr:$src, f64), (LD_Fp64m addr:$src)>; |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 522 | def : Pat<(X86fld addr:$src, f80), (LD_Fp80m addr:$src)>; |
Evan Cheng | 4e4c71e | 2006-02-21 20:00:20 +0000 | [diff] [blame] | 523 | |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 524 | // Required for CALL which return f32 / f64 / f80 values. |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 525 | def : Pat<(X86fst RFP32:$src, addr:$op, f32), (ST_Fp32m addr:$op, RFP32:$src)>; |
| 526 | def : Pat<(X86fst RFP64:$src, addr:$op, f32), (ST_Fp64m32 addr:$op, RFP64:$src)>; |
| 527 | 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] | 528 | def : Pat<(X86fst RFP80:$src, addr:$op, f32), (ST_Fp80m32 addr:$op, RFP80:$src)>; |
| 529 | def : Pat<(X86fst RFP80:$src, addr:$op, f64), (ST_Fp80m64 addr:$op, RFP80:$src)>; |
| 530 | 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] | 531 | |
| 532 | // Floating point constant -0.0 and -1.0 |
Dale Johannesen | e377d4d | 2007-07-04 21:07:47 +0000 | [diff] [blame] | 533 | def : Pat<(f32 fpimmneg0), (CHS_Fp32 (LD_Fp032))>, Requires<[FPStack]>; |
| 534 | def : Pat<(f32 fpimmneg1), (CHS_Fp32 (LD_Fp132))>, Requires<[FPStack]>; |
| 535 | def : Pat<(f64 fpimmneg0), (CHS_Fp64 (LD_Fp064))>, Requires<[FPStack]>; |
| 536 | def : Pat<(f64 fpimmneg1), (CHS_Fp64 (LD_Fp164))>, Requires<[FPStack]>; |
Dale Johannesen | cdbe4d3 | 2007-08-07 20:29:26 +0000 | [diff] [blame] | 537 | def : Pat<(f80 fpimmneg0), (CHS_Fp80 (LD_Fp080))>; |
| 538 | def : Pat<(f80 fpimmneg1), (CHS_Fp80 (LD_Fp180))>; |
Evan Cheng | 4e4c71e | 2006-02-21 20:00:20 +0000 | [diff] [blame] | 539 | |
| 540 | // 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] | 541 | def : Pat<(X86fildflag addr:$src, i64), (ILD_Fp64m64 addr:$src)>; |
Dale Johannesen | 849f214 | 2007-07-03 00:53:03 +0000 | [diff] [blame] | 542 | |
Dale Johannesen | 59a5873 | 2007-08-05 18:49:15 +0000 | [diff] [blame] | 543 | def : Pat<(f64 (fextend RFP32:$src)), (MOV_Fp3264 RFP32:$src)>, Requires<[FPStack]>; |
| 544 | def : Pat<(f80 (fextend RFP32:$src)), (MOV_Fp3280 RFP32:$src)>, Requires<[FPStack]>; |
| 545 | def : Pat<(f80 (fextend RFP64:$src)), (MOV_Fp6480 RFP64:$src)>, Requires<[FPStack]>; |