[linux-2.6-block.git] / arch / powerpc / kernel / vecemu.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Routines to emulate some Altivec/VMX instructions, specifically
 * those that can trap when given denormalized operands in Java mode.
 */
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <asm/ptrace.h>
#include <asm/processor.h>
#include <asm/switch_to.h>
#include <linux/uaccess.h>

/* Functions in vector.S */
extern void vaddfp(vector128 *dst, vector128 *a, vector128 *b);
extern void vsubfp(vector128 *dst, vector128 *a, vector128 *b);
extern void vmaddfp(vector128 *dst, vector128 *a, vector128 *b, vector128 *c);
extern void vnmsubfp(vector128 *dst, vector128 *a, vector128 *b, vector128 *c);
extern void vrefp(vector128 *dst, vector128 *src);
extern void vrsqrtefp(vector128 *dst, vector128 *src);
extern void vexptep(vector128 *dst, vector128 *src);

static unsigned int exp2s[8] = {
	0x800000,
	0x8b95c2,
	0x9837f0,
	0xa5fed7,
	0xb504f3,
	0xc5672a,
	0xd744fd,
	0xeac0c7
};

/*
 * Computes an estimate of 2^x.  The `s' argument is the 32-bit
 * single-precision floating-point representation of x.
 */
static unsigned int eexp2(unsigned int s)
{
	int exp, pwr;
	unsigned int mant, frac;

	/* extract exponent field from input */
	exp = ((s >> 23) & 0xff) - 127;
	if (exp > 7) {
		/* check for NaN input */
		if (exp == 128 && (s & 0x7fffff) != 0)
			return s | 0x400000;	/* return QNaN */
		/* 2^-big = 0, 2^+big = +Inf */
		return (s & 0x80000000)? 0: 0x7f800000;	/* 0 or +Inf */
	}
	if (exp < -23)
		return 0x3f800000;	/* 1.0 */

	/* convert to fixed point integer in 9.23 representation */
	pwr = (s & 0x7fffff) | 0x800000;
	if (exp > 0)
		pwr <<= exp;
	else
		pwr >>= -exp;
	if (s & 0x80000000)
		pwr = -pwr;

	/* extract integer part, which becomes exponent part of result */
	exp = (pwr >> 23) + 126;
	if (exp >= 254)
		return 0x7f800000;
	if (exp < -23)
		return 0;

	/* table lookup on top 3 bits of fraction to get mantissa */
	mant = exp2s[(pwr >> 20) & 7];

	/* linear interpolation using remaining 20 bits of fraction */
	asm("mulhwu %0,%1,%2" : "=r" (frac)
	    : "r" (pwr << 12), "r" (0x172b83ff));
	asm("mulhwu %0,%1,%2" : "=r" (frac) : "r" (frac), "r" (mant));
	mant += frac;

	if (exp >= 0)
		return mant + (exp << 23);

	/* denormalized result */
	exp = -exp;
	mant += 1 << (exp - 1);
	return mant >> exp;
}

/*
 * Computes an estimate of log_2(x).  The `s' argument is the 32-bit
 * single-precision floating-point representation of x.
 */
static unsigned int elog2(unsigned int s)
{
	int exp, mant, lz, frac;

	exp = s & 0x7f800000;
	mant = s & 0x7fffff;
	if (exp == 0x7f800000) {	/* Inf or NaN */
		if (mant != 0)
			s |= 0x400000;	/* turn NaN into QNaN */
		return s;
	}
	if ((exp | mant) == 0)		/* +0 or -0 */
		return 0xff800000;	/* return -Inf */

	if (exp == 0) {
		/* denormalized */
		asm("cntlzw %0,%1" : "=r" (lz) : "r" (mant));
		mant <<= lz - 8;
		exp = (-118 - lz) << 23;
	} else {
		mant |= 0x800000;
		exp -= 127 << 23;
	}

	if (mant >= 0xb504f3) {				/* 2^0.5 * 2^23 */
		exp |= 0x400000;			/* 0.5 * 2^23 */
		asm("mulhwu %0,%1,%2" : "=r" (mant)
		    : "r" (mant), "r" (0xb504f334));	/* 2^-0.5 * 2^32 */
	}
	if (mant >= 0x9837f0) {				/* 2^0.25 * 2^23 */
		exp |= 0x200000;			/* 0.25 * 2^23 */
		asm("mulhwu %0,%1,%2" : "=r" (mant)
		    : "r" (mant), "r" (0xd744fccb));	/* 2^-0.25 * 2^32 */
	}
	if (mant >= 0x8b95c2) {				/* 2^0.125 * 2^23 */
		exp |= 0x100000;			/* 0.125 * 2^23 */
		asm("mulhwu %0,%1,%2" : "=r" (mant)
		    : "r" (mant), "r" (0xeac0c6e8));	/* 2^-0.125 * 2^32 */
	}
	if (mant > 0x800000) {				/* 1.0 * 2^23 */
		/* calculate (mant - 1) * 1.381097463 */
		/* 1.381097463 == 0.125 / (2^0.125 - 1) */
		asm("mulhwu %0,%1,%2" : "=r" (frac)
		    : "r" ((mant - 0x800000) << 1), "r" (0xb0c7cd3a));
		exp += frac;
	}
	s = exp & 0x80000000;
	if (exp != 0) {
		if (s)
			exp = -exp;
		asm("cntlzw %0,%1" : "=r" (lz) : "r" (exp));
		lz = 8 - lz;
		if (lz > 0)
			exp >>= lz;
		else if (lz < 0)
			exp <<= -lz;
		s += ((lz + 126) << 23) + exp;
	}
	return s;
}

#define VSCR_SAT	1

static int ctsxs(unsigned int x, int scale, unsigned int *vscrp)
{
	int exp, mant;

	exp = (x >> 23) & 0xff;
	mant = x & 0x7fffff;
	if (exp == 255 && mant != 0)
		return 0;		/* NaN -> 0 */
	exp = exp - 127 + scale;
	if (exp < 0)
		return 0;		/* round towards zero */
	if (exp >= 31) {
		/* saturate, unless the result would be -2^31 */
		if (x + (scale << 23) != 0xcf000000)
			*vscrp |= VSCR_SAT;
		return (x & 0x80000000)? 0x80000000: 0x7fffffff;
	}
	mant |= 0x800000;
	mant = (mant << 7) >> (30 - exp);
	return (x & 0x80000000)? -mant: mant;
}

static unsigned int ctuxs(unsigned int x, int scale, unsigned int *vscrp)
{
	int exp;
	unsigned int mant;

	exp = (x >> 23) & 0xff;
	mant = x & 0x7fffff;
	if (exp == 255 && mant != 0)
		return 0;		/* NaN -> 0 */
	exp = exp - 127 + scale;
	if (exp < 0)
		return 0;		/* round towards zero */
	if (x & 0x80000000) {
		/* negative => saturate to 0 */
		*vscrp |= VSCR_SAT;
		return 0;
	}
	if (exp >= 32) {
		/* saturate */
		*vscrp |= VSCR_SAT;
		return 0xffffffff;
	}
	mant |= 0x800000;
	mant = (mant << 8) >> (31 - exp);
	return mant;
}

/* Round to floating integer, towards 0 */
static unsigned int rfiz(unsigned int x)
{
	int exp;

	exp = ((x >> 23) & 0xff) - 127;
	if (exp == 128 && (x & 0x7fffff) != 0)
		return x | 0x400000;	/* NaN -> make it a QNaN */
	if (exp >= 23)
		return x;		/* it's an integer already (or Inf) */
	if (exp < 0)
		return x & 0x80000000;	/* |x| < 1.0 rounds to 0 */
	return x & ~(0x7fffff >> exp);
}

/* Round to floating integer, towards +/- Inf */
static unsigned int rfii(unsigned int x)
{
	int exp, mask;

	exp = ((x >> 23) & 0xff) - 127;
	if (exp == 128 && (x & 0x7fffff) != 0)
		return x | 0x400000;	/* NaN -> make it a QNaN */
	if (exp >= 23)
		return x;		/* it's an integer already (or Inf) */
	if ((x & 0x7fffffff) == 0)
		return x;		/* +/-0 -> +/-0 */
	if (exp < 0)
		/* 0 < |x| < 1.0 rounds to +/- 1.0 */
		return (x & 0x80000000) | 0x3f800000;
	mask = 0x7fffff >> exp;
	/* mantissa overflows into exponent - that's OK,
	   it can't overflow into the sign bit */
	return (x + mask) & ~mask;
}

/* Round to floating integer, to nearest */
static unsigned int rfin(unsigned int x)
{
	int exp, half;

	exp = ((x >> 23) & 0xff) - 127;
	if (exp == 128 && (x & 0x7fffff) != 0)
		return x | 0x400000;	/* NaN -> make it a QNaN */
	if (exp >= 23)
		return x;		/* it's an integer already (or Inf) */
	if (exp < -1)
		return x & 0x80000000;	/* |x| < 0.5 -> +/-0 */
	if (exp == -1)
		/* 0.5 <= |x| < 1.0 rounds to +/- 1.0 */
		return (x & 0x80000000) | 0x3f800000;
	half = 0x400000 >> exp;
	/* add 0.5 to the magnitude and chop off the fraction bits */
	return (x + half) & ~(0x7fffff >> exp);
}

int emulate_altivec(struct pt_regs *regs)
{
	unsigned int instr, i;
	unsigned int va, vb, vc, vd;
	vector128 *vrs;

	if (get_user(instr, (unsigned int __user *) regs->nip))
		return -EFAULT;
	if ((instr >> 26) != 4)
		return -EINVAL;		/* not an altivec instruction */
	vd = (instr >> 21) & 0x1f;
	va = (instr >> 16) & 0x1f;
	vb = (instr >> 11) & 0x1f;
	vc = (instr >> 6) & 0x1f;

	vrs = current->thread.vr_state.vr;
	switch (instr & 0x3f) {
	case 10:
		switch (vc) {
		case 0:	/* vaddfp */
			vaddfp(&vrs[vd], &vrs[va], &vrs[vb]);
			break;
		case 1:	/* vsubfp */
			vsubfp(&vrs[vd], &vrs[va], &vrs[vb]);
			break;
		case 4:	/* vrefp */
			vrefp(&vrs[vd], &vrs[vb]);
			break;
		case 5:	/* vrsqrtefp */
			vrsqrtefp(&vrs[vd], &vrs[vb]);
			break;
		case 6:	/* vexptefp */
			for (i = 0; i < 4; ++i)
				vrs[vd].u[i] = eexp2(vrs[vb].u[i]);
			break;
		case 7:	/* vlogefp */
			for (i = 0; i < 4; ++i)
				vrs[vd].u[i] = elog2(vrs[vb].u[i]);
			break;
		case 8:		/* vrfin */
			for (i = 0; i < 4; ++i)
				vrs[vd].u[i] = rfin(vrs[vb].u[i]);
			break;
		case 9:		/* vrfiz */
			for (i = 0; i < 4; ++i)
				vrs[vd].u[i] = rfiz(vrs[vb].u[i]);
			break;
		case 10:	/* vrfip */
			for (i = 0; i < 4; ++i) {
				u32 x = vrs[vb].u[i];
				x = (x & 0x80000000)? rfiz(x): rfii(x);
				vrs[vd].u[i] = x;
			}
			break;
		case 11:	/* vrfim */
			for (i = 0; i < 4; ++i) {
				u32 x = vrs[vb].u[i];
				x = (x & 0x80000000)? rfii(x): rfiz(x);
				vrs[vd].u[i] = x;
			}
			break;
		case 14:	/* vctuxs */
			for (i = 0; i < 4; ++i)
				vrs[vd].u[i] = ctuxs(vrs[vb].u[i], va,
					&current->thread.vr_state.vscr.u[3]);
			break;
		case 15:	/* vctsxs */
			for (i = 0; i < 4; ++i)
				vrs[vd].u[i] = ctsxs(vrs[vb].u[i], va,
					&current->thread.vr_state.vscr.u[3]);
			break;
		default:
			return -EINVAL;
		}
		break;
	case 46:	/* vmaddfp */
		vmaddfp(&vrs[vd], &vrs[va], &vrs[vb], &vrs[vc]);
		break;
	case 47:	/* vnmsubfp */
		vnmsubfp(&vrs[vd], &vrs[va], &vrs[vb], &vrs[vc]);
		break;
	default:
		return -EINVAL;
	}

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