Mercurial > projects > ldc

comparison runtime/import/ldc/intrinsics.di @ 1075:34bc1945bc85

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Factor out some common code between X86 and X86_64, and supply *_real versions of all floating point intrinsics that exist whether reals are 80-bit or 64-bit.
author Frits van Bommel <fvbommel wxs.nl>
date Mon, 09 Mar 2009 21:38:06 +0100
parents 7a0238db1962
children 39b7c32cd010
comparison
equal deleted inserted replaced
1074:d9820e08bb84 1075:34bc1945bc85
17 else 17 else
18 { 18 {
19 static assert(false, "This module is only valid for LDC"); 19 static assert(false, "This module is only valid for LDC");
20 } 20 }
21 21
22 version(X86)
23 version = Reals_80Bit;
24 else version(X86_64)
25 version = Reals_80Bit;
26
22 // 27 //
23 // CODE GENERATOR INTRINSICS 28 // CODE GENERATOR INTRINSICS
24 // 29 //
25 30
26 31
104 109
105 pragma(intrinsic, "llvm.sqrt.f32") 110 pragma(intrinsic, "llvm.sqrt.f32")
106 float llvm_sqrt_f32(float val); 111 float llvm_sqrt_f32(float val);
107 pragma(intrinsic, "llvm.sqrt.f64") 112 pragma(intrinsic, "llvm.sqrt.f64")
108 double llvm_sqrt_f64(double val); 113 double llvm_sqrt_f64(double val);
109 version(X86) 114
110 { 115 version(Reals_80Bit)
111 pragma(intrinsic, "llvm.sqrt.f80") 116 {
112 real llvm_sqrt_f80(real val); 117 pragma(intrinsic, "llvm.sqrt.f80")
113 } 118 real llvm_sqrt_f80(real val);
114 119 alias llvm_sqrt_f80 llvm_sqrt_real;
115 version(X86_64) 120 }
116 { 121 else
117 pragma(intrinsic, "llvm.sqrt.f80") 122 {
118 real llvm_sqrt_f80(real val); 123 pragma(intrinsic, "llvm.sqrt.f64")
124 real llvm_sqrt_real(real val);
119 } 125 }
120 126
121 127
122 // The 'llvm.sin.*' intrinsics return the sine of the operand. 128 // The 'llvm.sin.*' intrinsics return the sine of the operand.
123 129
124 pragma(intrinsic, "llvm.sin.f32") 130 pragma(intrinsic, "llvm.sin.f32")
125 float llvm_sin_f32(float val); 131 float llvm_sin_f32(float val);
126 pragma(intrinsic, "llvm.sin.f64") 132 pragma(intrinsic, "llvm.sin.f64")
127 double llvm_sin_f64(double val); 133 double llvm_sin_f64(double val);
128 version(X86) 134
129 { 135 version(Reals_80Bit)
130 pragma(intrinsic, "llvm.sin.f80") 136 {
131 real llvm_sin_f80(real val); 137 pragma(intrinsic, "llvm.sin.f80")
132 } 138 real llvm_sin_f80(real val);
133 139 alias llvm_sin_f80 llvm_sin_real;
134 version(X86_64) 140 }
135 { 141 else
136 pragma(intrinsic, "llvm.sin.f80") 142 {
137 real llvm_sin_f80(real val); 143 pragma(intrinsic, "llvm.sin.f64")
144 real llvm_sin_real(real val);
138 } 145 }
139 146
140 147
141 // The 'llvm.cos.*' intrinsics return the cosine of the operand. 148 // The 'llvm.cos.*' intrinsics return the cosine of the operand.
142 149
143 pragma(intrinsic, "llvm.cos.f32") 150 pragma(intrinsic, "llvm.cos.f32")
144 float llvm_cos_f32(float val); 151 float llvm_cos_f32(float val);
145 pragma(intrinsic, "llvm.cos.f64") 152 pragma(intrinsic, "llvm.cos.f64")
146 double llvm_cos_f64(double val); 153 double llvm_cos_f64(double val);
147 version(X86) 154
148 { 155 version(Reals_80Bit)
149 pragma(intrinsic, "llvm.cos.f80") 156 {
150 real llvm_cos_f80(real val); 157 pragma(intrinsic, "llvm.cos.f80")
151 } 158 real llvm_cos_f80(real val);
152 159 alias llvm_cos_f80 llvm_cos_real;
153 version(X86_64) 160 }
154 { 161 else
155 pragma(intrinsic, "llvm.cos.f80") 162 {
156 real llvm_cos_f80(real val); 163 pragma(intrinsic, "llvm.cos.f64")
164 real llvm_cos_real(real val);
157 } 165 }
158 166
159 167
160 // The 'llvm.powi.*' intrinsics return the first operand raised to the specified (positive or negative) power. The order of evaluation of multiplications is not defined. When a vector of floating point type is used, the second argument remains a scalar integer value. 168 // The 'llvm.powi.*' intrinsics return the first operand raised to the specified (positive or negative) power. The order of evaluation of multiplications is not defined. When a vector of floating point type is used, the second argument remains a scalar integer value.
161 169
162 pragma(intrinsic, "llvm.powi.f32") 170 pragma(intrinsic, "llvm.powi.f32")
163 float llvm_powi_f32(float val, int power); 171 float llvm_powi_f32(float val, int power);
164 172
165 pragma(intrinsic, "llvm.powi.f64") 173 pragma(intrinsic, "llvm.powi.f64")
166 double llvm_powi_f64(double val, int power); 174 double llvm_powi_f64(double val, int power);
167 version(X86) 175
168 { 176 version(Reals_80Bit)
169 pragma(intrinsic, "llvm.powi.f80") 177 {
170 real llvm_powi_f80(real val, int power); 178 pragma(intrinsic, "llvm.powi.f80")
171 } 179 real llvm_powi_f80(real val, int power);
172 180 alias llvm_powi_f80 llvm_powi_real;
173 version(X86_64) 181 }
174 { 182 else
175 pragma(intrinsic, "llvm.powi.f80") 183 {
176 real llvm_powi_f80(real val, int power); 184 pragma(intrinsic, "llvm.powi.f64")
177 } 185 real llvm_powi_real(real val, int power);
186 }
187
178 188
179 // The 'llvm.pow.*' intrinsics return the first operand raised to the specified (positive or negative) power. 189 // The 'llvm.pow.*' intrinsics return the first operand raised to the specified (positive or negative) power.
180 190
181 pragma(intrinsic, "llvm.pow.f32") 191 pragma(intrinsic, "llvm.pow.f32")
182 float llvm_pow_f32(float val, float power); 192 float llvm_pow_f32(float val, float power);
183 193
184 pragma(intrinsic, "llvm.pow.f64") 194 pragma(intrinsic, "llvm.pow.f64")
185 double llvm_pow_f64(double val, double power); 195 double llvm_pow_f64(double val, double power);
186 version(X86) 196
187 { 197 version(Reals_80Bit)
188 pragma(intrinsic, "llvm.pow.f80") 198 {
189 real llvm_pow_f80(real val, real power); 199 pragma(intrinsic, "llvm.pow.f80")
190 } 200 real llvm_pow_f80(real val, real power);
191 201 alias llvm_pow_f80 llvm_pow_real;
192 version(X86_64) 202 }
193 { 203 else
194 pragma(intrinsic, "llvm.pow.f80") 204 {
195 real llvm_pow_f80(real val, real power); 205 pragma(intrinsic, "llvm.pow.f64")
206 real llvm_pow_real(real val, real power);
196 } 207 }
197 208
198 209
199 // 210 //
200 // BIT MANIPULATION INTRINSICS 211 // BIT MANIPULATION INTRINSICS