1 /*
2  * Routines to emulate some Altivec/VMX instructions, specifically
3  * those that can trap when given denormalized operands in Java mode.
4  */
5 #include <linux/kernel.h>
6 #include <linux/errno.h>
7 #include <linux/sched.h>
8 #include <asm/ptrace.h>
9 #include <asm/processor.h>
10 #include <asm/uaccess.h>
11 
12 /* Functions in vector.S */
13 extern void vaddfp(vector128 *dst, vector128 *a, vector128 *b);
14 extern void vsubfp(vector128 *dst, vector128 *a, vector128 *b);
15 extern void vmaddfp(vector128 *dst, vector128 *a, vector128 *b, vector128 *c);
16 extern void vnmsubfp(vector128 *dst, vector128 *a, vector128 *b, vector128 *c);
17 extern void vrefp(vector128 *dst, vector128 *src);
18 extern void vrsqrtefp(vector128 *dst, vector128 *src);
19 extern void vexptep(vector128 *dst, vector128 *src);
20 
21 static unsigned int exp2s[8] = {
22 	0x800000,
23 	0x8b95c2,
24 	0x9837f0,
25 	0xa5fed7,
26 	0xb504f3,
27 	0xc5672a,
28 	0xd744fd,
29 	0xeac0c7
30 };
31 
32 /*
33  * Computes an estimate of 2^x.  The `s' argument is the 32-bit
34  * single-precision floating-point representation of x.
35  */
eexp2(unsigned int s)36 static unsigned int eexp2(unsigned int s)
37 {
38 	int exp, pwr;
39 	unsigned int mant, frac;
40 
41 	/* extract exponent field from input */
42 	exp = ((s >> 23) & 0xff) - 127;
43 	if (exp > 7) {
44 		/* check for NaN input */
45 		if (exp == 128 && (s & 0x7fffff) != 0)
46 			return s | 0x400000;	/* return QNaN */
47 		/* 2^-big = 0, 2^+big = +Inf */
48 		return (s & 0x80000000)? 0: 0x7f800000;	/* 0 or +Inf */
49 	}
50 	if (exp < -23)
51 		return 0x3f800000;	/* 1.0 */
52 
53 	/* convert to fixed point integer in 9.23 representation */
54 	pwr = (s & 0x7fffff) | 0x800000;
55 	if (exp > 0)
56 		pwr <<= exp;
57 	else
58 		pwr >>= -exp;
59 	if (s & 0x80000000)
60 		pwr = -pwr;
61 
62 	/* extract integer part, which becomes exponent part of result */
63 	exp = (pwr >> 23) + 126;
64 	if (exp >= 254)
65 		return 0x7f800000;
66 	if (exp < -23)
67 		return 0;
68 
69 	/* table lookup on top 3 bits of fraction to get mantissa */
70 	mant = exp2s[(pwr >> 20) & 7];
71 
72 	/* linear interpolation using remaining 20 bits of fraction */
73 	asm("mulhwu %0,%1,%2" : "=r" (frac)
74 	    : "r" (pwr << 12), "r" (0x172b83ff));
75 	asm("mulhwu %0,%1,%2" : "=r" (frac) : "r" (frac), "r" (mant));
76 	mant += frac;
77 
78 	if (exp >= 0)
79 		return mant + (exp << 23);
80 
81 	/* denormalized result */
82 	exp = -exp;
83 	mant += 1 << (exp - 1);
84 	return mant >> exp;
85 }
86 
87 /*
88  * Computes an estimate of log_2(x).  The `s' argument is the 32-bit
89  * single-precision floating-point representation of x.
90  */
elog2(unsigned int s)91 static unsigned int elog2(unsigned int s)
92 {
93 	int exp, mant, lz, frac;
94 
95 	exp = s & 0x7f800000;
96 	mant = s & 0x7fffff;
97 	if (exp == 0x7f800000) {	/* Inf or NaN */
98 		if (mant != 0)
99 			s |= 0x400000;	/* turn NaN into QNaN */
100 		return s;
101 	}
102 	if ((exp | mant) == 0)		/* +0 or -0 */
103 		return 0xff800000;	/* return -Inf */
104 
105 	if (exp == 0) {
106 		/* denormalized */
107 		asm("cntlzw %0,%1" : "=r" (lz) : "r" (mant));
108 		mant <<= lz - 8;
109 		exp = (-118 - lz) << 23;
110 	} else {
111 		mant |= 0x800000;
112 		exp -= 127 << 23;
113 	}
114 
115 	if (mant >= 0xb504f3) {				/* 2^0.5 * 2^23 */
116 		exp |= 0x400000;			/* 0.5 * 2^23 */
117 		asm("mulhwu %0,%1,%2" : "=r" (mant)
118 		    : "r" (mant), "r" (0xb504f334));	/* 2^-0.5 * 2^32 */
119 	}
120 	if (mant >= 0x9837f0) {				/* 2^0.25 * 2^23 */
121 		exp |= 0x200000;			/* 0.25 * 2^23 */
122 		asm("mulhwu %0,%1,%2" : "=r" (mant)
123 		    : "r" (mant), "r" (0xd744fccb));	/* 2^-0.25 * 2^32 */
124 	}
125 	if (mant >= 0x8b95c2) {				/* 2^0.125 * 2^23 */
126 		exp |= 0x100000;			/* 0.125 * 2^23 */
127 		asm("mulhwu %0,%1,%2" : "=r" (mant)
128 		    : "r" (mant), "r" (0xeac0c6e8));	/* 2^-0.125 * 2^32 */
129 	}
130 	if (mant > 0x800000) {				/* 1.0 * 2^23 */
131 		/* calculate (mant - 1) * 1.381097463 */
132 		/* 1.381097463 == 0.125 / (2^0.125 - 1) */
133 		asm("mulhwu %0,%1,%2" : "=r" (frac)
134 		    : "r" ((mant - 0x800000) << 1), "r" (0xb0c7cd3a));
135 		exp += frac;
136 	}
137 	s = exp & 0x80000000;
138 	if (exp != 0) {
139 		if (s)
140 			exp = -exp;
141 		asm("cntlzw %0,%1" : "=r" (lz) : "r" (exp));
142 		lz = 8 - lz;
143 		if (lz > 0)
144 			exp >>= lz;
145 		else if (lz < 0)
146 			exp <<= -lz;
147 		s += ((lz + 126) << 23) + exp;
148 	}
149 	return s;
150 }
151 
152 #define VSCR_SAT	1
153 
ctsxs(unsigned int x,int scale,unsigned int * vscrp)154 static int ctsxs(unsigned int x, int scale, unsigned int *vscrp)
155 {
156 	int exp, mant;
157 
158 	exp = (x >> 23) & 0xff;
159 	mant = x & 0x7fffff;
160 	if (exp == 255 && mant != 0)
161 		return 0;		/* NaN -> 0 */
162 	exp = exp - 127 + scale;
163 	if (exp < 0)
164 		return 0;		/* round towards zero */
165 	if (exp >= 31) {
166 		/* saturate, unless the result would be -2^31 */
167 		if (x + (scale << 23) != 0xcf000000)
168 			*vscrp |= VSCR_SAT;
169 		return (x & 0x80000000)? 0x80000000: 0x7fffffff;
170 	}
171 	mant |= 0x800000;
172 	mant = (mant << 7) >> (30 - exp);
173 	return (x & 0x80000000)? -mant: mant;
174 }
175 
ctuxs(unsigned int x,int scale,unsigned int * vscrp)176 static unsigned int ctuxs(unsigned int x, int scale, unsigned int *vscrp)
177 {
178 	int exp;
179 	unsigned int mant;
180 
181 	exp = (x >> 23) & 0xff;
182 	mant = x & 0x7fffff;
183 	if (exp == 255 && mant != 0)
184 		return 0;		/* NaN -> 0 */
185 	exp = exp - 127 + scale;
186 	if (exp < 0)
187 		return 0;		/* round towards zero */
188 	if (x & 0x80000000) {
189 		/* negative => saturate to 0 */
190 		*vscrp |= VSCR_SAT;
191 		return 0;
192 	}
193 	if (exp >= 32) {
194 		/* saturate */
195 		*vscrp |= VSCR_SAT;
196 		return 0xffffffff;
197 	}
198 	mant |= 0x800000;
199 	mant = (mant << 8) >> (31 - exp);
200 	return mant;
201 }
202 
203 /* Round to floating integer, towards 0 */
rfiz(unsigned int x)204 static unsigned int rfiz(unsigned int x)
205 {
206 	int exp;
207 
208 	exp = ((x >> 23) & 0xff) - 127;
209 	if (exp == 128 && (x & 0x7fffff) != 0)
210 		return x | 0x400000;	/* NaN -> make it a QNaN */
211 	if (exp >= 23)
212 		return x;		/* it's an integer already (or Inf) */
213 	if (exp < 0)
214 		return x & 0x80000000;	/* |x| < 1.0 rounds to 0 */
215 	return x & ~(0x7fffff >> exp);
216 }
217 
218 /* Round to floating integer, towards +/- Inf */
rfii(unsigned int x)219 static unsigned int rfii(unsigned int x)
220 {
221 	int exp, mask;
222 
223 	exp = ((x >> 23) & 0xff) - 127;
224 	if (exp == 128 && (x & 0x7fffff) != 0)
225 		return x | 0x400000;	/* NaN -> make it a QNaN */
226 	if (exp >= 23)
227 		return x;		/* it's an integer already (or Inf) */
228 	if ((x & 0x7fffffff) == 0)
229 		return x;		/* +/-0 -> +/-0 */
230 	if (exp < 0)
231 		/* 0 < |x| < 1.0 rounds to +/- 1.0 */
232 		return (x & 0x80000000) | 0x3f800000;
233 	mask = 0x7fffff >> exp;
234 	/* mantissa overflows into exponent - that's OK,
235 	   it can't overflow into the sign bit */
236 	return (x + mask) & ~mask;
237 }
238 
239 /* Round to floating integer, to nearest */
rfin(unsigned int x)240 static unsigned int rfin(unsigned int x)
241 {
242 	int exp, half;
243 
244 	exp = ((x >> 23) & 0xff) - 127;
245 	if (exp == 128 && (x & 0x7fffff) != 0)
246 		return x | 0x400000;	/* NaN -> make it a QNaN */
247 	if (exp >= 23)
248 		return x;		/* it's an integer already (or Inf) */
249 	if (exp < -1)
250 		return x & 0x80000000;	/* |x| < 0.5 -> +/-0 */
251 	if (exp == -1)
252 		/* 0.5 <= |x| < 1.0 rounds to +/- 1.0 */
253 		return (x & 0x80000000) | 0x3f800000;
254 	half = 0x400000 >> exp;
255 	/* add 0.5 to the magnitude and chop off the fraction bits */
256 	return (x + half) & ~(0x7fffff >> exp);
257 }
258 
emulate_altivec(struct pt_regs * regs)259 int emulate_altivec(struct pt_regs *regs)
260 {
261 	unsigned int instr, i;
262 	unsigned int va, vb, vc, vd;
263 	vector128 *vrs;
264 
265 	if (get_user(instr, (unsigned int __user *) regs->nip))
266 		return -EFAULT;
267 	if ((instr >> 26) != 4)
268 		return -EINVAL;		/* not an altivec instruction */
269 	vd = (instr >> 21) & 0x1f;
270 	va = (instr >> 16) & 0x1f;
271 	vb = (instr >> 11) & 0x1f;
272 	vc = (instr >> 6) & 0x1f;
273 
274 	vrs = current->thread.vr;
275 	switch (instr & 0x3f) {
276 	case 10:
277 		switch (vc) {
278 		case 0:	/* vaddfp */
279 			vaddfp(&vrs[vd], &vrs[va], &vrs[vb]);
280 			break;
281 		case 1:	/* vsubfp */
282 			vsubfp(&vrs[vd], &vrs[va], &vrs[vb]);
283 			break;
284 		case 4:	/* vrefp */
285 			vrefp(&vrs[vd], &vrs[vb]);
286 			break;
287 		case 5:	/* vrsqrtefp */
288 			vrsqrtefp(&vrs[vd], &vrs[vb]);
289 			break;
290 		case 6:	/* vexptefp */
291 			for (i = 0; i < 4; ++i)
292 				vrs[vd].u[i] = eexp2(vrs[vb].u[i]);
293 			break;
294 		case 7:	/* vlogefp */
295 			for (i = 0; i < 4; ++i)
296 				vrs[vd].u[i] = elog2(vrs[vb].u[i]);
297 			break;
298 		case 8:		/* vrfin */
299 			for (i = 0; i < 4; ++i)
300 				vrs[vd].u[i] = rfin(vrs[vb].u[i]);
301 			break;
302 		case 9:		/* vrfiz */
303 			for (i = 0; i < 4; ++i)
304 				vrs[vd].u[i] = rfiz(vrs[vb].u[i]);
305 			break;
306 		case 10:	/* vrfip */
307 			for (i = 0; i < 4; ++i) {
308 				u32 x = vrs[vb].u[i];
309 				x = (x & 0x80000000)? rfiz(x): rfii(x);
310 				vrs[vd].u[i] = x;
311 			}
312 			break;
313 		case 11:	/* vrfim */
314 			for (i = 0; i < 4; ++i) {
315 				u32 x = vrs[vb].u[i];
316 				x = (x & 0x80000000)? rfii(x): rfiz(x);
317 				vrs[vd].u[i] = x;
318 			}
319 			break;
320 		case 14:	/* vctuxs */
321 			for (i = 0; i < 4; ++i)
322 				vrs[vd].u[i] = ctuxs(vrs[vb].u[i], va,
323 						&current->thread.vscr.u[3]);
324 			break;
325 		case 15:	/* vctsxs */
326 			for (i = 0; i < 4; ++i)
327 				vrs[vd].u[i] = ctsxs(vrs[vb].u[i], va,
328 						&current->thread.vscr.u[3]);
329 			break;
330 		default:
331 			return -EINVAL;
332 		}
333 		break;
334 	case 46:	/* vmaddfp */
335 		vmaddfp(&vrs[vd], &vrs[va], &vrs[vb], &vrs[vc]);
336 		break;
337 	case 47:	/* vnmsubfp */
338 		vnmsubfp(&vrs[vd], &vrs[va], &vrs[vb], &vrs[vc]);
339 		break;
340 	default:
341 		return -EINVAL;
342 	}
343 
344 	return 0;
345 }
346