[linux-2.6-block.git] / arch / mips / math-emu / sp_sub.c

/* IEEE754 floating point arithmetic
 * single precision
 */
/*
 * MIPS floating point support
 * Copyright (C) 1994-2000 Algorithmics Ltd.
 *
 * ########################################################################
 *
 *  This program is free software; you can distribute it and/or modify it
 *  under the terms of the GNU General Public License (Version 2) as
 *  published by the Free Software Foundation.
 *
 *  This program is distributed in the hope it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 *  for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
 *
 * ########################################################################
 */


#include "ieee754sp.h"

union ieee754sp ieee754sp_sub(union ieee754sp x, union ieee754sp y)
{
	COMPXSP;
	COMPYSP;

	EXPLODEXSP;
	EXPLODEYSP;

	ieee754_clearcx();

	FLUSHXSP;
	FLUSHYSP;

	switch (CLPAIR(xc, yc)) {
	case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_QNAN):
	case CLPAIR(IEEE754_CLASS_QNAN, IEEE754_CLASS_SNAN):
	case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_SNAN):
	case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_SNAN):
	case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_SNAN):
	case CLPAIR(IEEE754_CLASS_DNORM, IEEE754_CLASS_SNAN):
	case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_SNAN):
	case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_ZERO):
	case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_NORM):
	case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_DNORM):
	case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_INF):
		ieee754_setcx(IEEE754_INVALID_OPERATION);
		return ieee754sp_nanxcpt(ieee754sp_indef(), "sub", x, y);

	case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_QNAN):
	case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_QNAN):
	case CLPAIR(IEEE754_CLASS_DNORM, IEEE754_CLASS_QNAN):
	case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_QNAN):
		return y;

	case CLPAIR(IEEE754_CLASS_QNAN, IEEE754_CLASS_QNAN):
	case CLPAIR(IEEE754_CLASS_QNAN, IEEE754_CLASS_ZERO):
	case CLPAIR(IEEE754_CLASS_QNAN, IEEE754_CLASS_NORM):
	case CLPAIR(IEEE754_CLASS_QNAN, IEEE754_CLASS_DNORM):
	case CLPAIR(IEEE754_CLASS_QNAN, IEEE754_CLASS_INF):
		return x;


		/* Infinity handling
		 */

	case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF):
		if (xs != ys)
			return x;
		ieee754_setcx(IEEE754_INVALID_OPERATION);
		return ieee754sp_xcpt(ieee754sp_indef(), "sub", x, y);

	case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_INF):
	case CLPAIR(IEEE754_CLASS_DNORM, IEEE754_CLASS_INF):
	case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_INF):
		return ieee754sp_inf(ys ^ 1);

	case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_ZERO):
	case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_NORM):
	case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_DNORM):
		return x;

		/* Zero handling
		 */

	case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO):
		if (xs != ys)
			return x;
		else
			return ieee754sp_zero(ieee754_csr.rm ==
					      IEEE754_RD);

	case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_ZERO):
	case CLPAIR(IEEE754_CLASS_DNORM, IEEE754_CLASS_ZERO):
		return x;

	case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_NORM):
	case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_DNORM):
		/* quick fix up */
		DPSIGN(y) ^= 1;
		return y;

	case CLPAIR(IEEE754_CLASS_DNORM, IEEE754_CLASS_DNORM):
		SPDNORMX;

	case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_DNORM):
		SPDNORMY;
		break;

	case CLPAIR(IEEE754_CLASS_DNORM, IEEE754_CLASS_NORM):
		SPDNORMX;
		break;

	case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_NORM):
		break;
	}
	/* flip sign of y and handle as add */
	ys ^= 1;

	assert(xm & SP_HIDDEN_BIT);
	assert(ym & SP_HIDDEN_BIT);


	/* provide guard,round and stick bit space */
	xm <<= 3;
	ym <<= 3;

	if (xe > ye) {
		/* have to shift y fraction right to align
		 */
		int s = xe - ye;
		SPXSRSYn(s);
	} else if (ye > xe) {
		/* have to shift x fraction right to align
		 */
		int s = ye - xe;
		SPXSRSXn(s);
	}
	assert(xe == ye);
	assert(xe <= SP_EMAX);

	if (xs == ys) {
		/* generate 28 bit result of adding two 27 bit numbers
		 */
		xm = xm + ym;
		xe = xe;
		xs = xs;

		if (xm >> (SP_MBITS + 1 + 3)) { /* carry out */
			SPXSRSX1();	/* shift preserving sticky */
		}
	} else {
		if (xm >= ym) {
			xm = xm - ym;
			xe = xe;
			xs = xs;
		} else {
			xm = ym - xm;
			xe = xe;
			xs = ys;
		}
		if (xm == 0) {
			if (ieee754_csr.rm == IEEE754_RD)
				return ieee754sp_zero(1);	/* round negative inf. => sign = -1 */
			else
				return ieee754sp_zero(0);	/* other round modes   => sign = 1 */
		}
		/* normalize to rounding precision
		 */
		while ((xm >> (SP_MBITS + 3)) == 0) {
			xm <<= 1;
			xe--;
		}
	}
	SPNORMRET2(xs, xe, xm, "sub", x, y);
}
Commit	Line	Data
1da177e4 LT	1	/* IEEE754 floating point arithmetic
	2	* single precision
	3	*/
	4	/*
	5	* MIPS floating point support
	6	* Copyright (C) 1994-2000 Algorithmics Ltd.
1da177e4 LT	7	*
	8	* ########################################################################
	9	*
	10	* This program is free software; you can distribute it and/or modify it
	11	* under the terms of the GNU General Public License (Version 2) as
	12	* published by the Free Software Foundation.
	13	*
	14	* This program is distributed in the hope it will be useful, but WITHOUT
	15	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	16	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	17	* for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License along
	20	* with this program; if not, write to the Free Software Foundation, Inc.,
	21	* 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
	22	*
	23	* ########################################################################
	24	*/
	25
	26
	27	#include "ieee754sp.h"
	28
2209bcb1	29	union ieee754sp ieee754sp_sub(union ieee754sp x, union ieee754sp y)
1da177e4 LT	30	{
	31	COMPXSP;
	32	COMPYSP;
	33
	34	EXPLODEXSP;
	35	EXPLODEYSP;
	36
9e8bad1f	37	ieee754_clearcx();
1da177e4 LT	38
	39	FLUSHXSP;
	40	FLUSHYSP;
	41
	42	switch (CLPAIR(xc, yc)) {
	43	case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_QNAN):
	44	case CLPAIR(IEEE754_CLASS_QNAN, IEEE754_CLASS_SNAN):
	45	case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_SNAN):
	46	case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_SNAN):
	47	case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_SNAN):
	48	case CLPAIR(IEEE754_CLASS_DNORM, IEEE754_CLASS_SNAN):
	49	case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_SNAN):
	50	case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_ZERO):
	51	case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_NORM):
	52	case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_DNORM):
	53	case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_INF):
9e8bad1f	54	ieee754_setcx(IEEE754_INVALID_OPERATION);
1da177e4 LT	55	return ieee754sp_nanxcpt(ieee754sp_indef(), "sub", x, y);
	56
	57	case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_QNAN):
	58	case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_QNAN):
	59	case CLPAIR(IEEE754_CLASS_DNORM, IEEE754_CLASS_QNAN):
	60	case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_QNAN):
	61	return y;
	62
	63	case CLPAIR(IEEE754_CLASS_QNAN, IEEE754_CLASS_QNAN):
	64	case CLPAIR(IEEE754_CLASS_QNAN, IEEE754_CLASS_ZERO):
	65	case CLPAIR(IEEE754_CLASS_QNAN, IEEE754_CLASS_NORM):
	66	case CLPAIR(IEEE754_CLASS_QNAN, IEEE754_CLASS_DNORM):
	67	case CLPAIR(IEEE754_CLASS_QNAN, IEEE754_CLASS_INF):
	68	return x;
	69
	70
	71	/* Infinity handling
	72	*/
	73
	74	case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF):
	75	if (xs != ys)
	76	return x;
9e8bad1f	77	ieee754_setcx(IEEE754_INVALID_OPERATION);
1da177e4 LT	78	return ieee754sp_xcpt(ieee754sp_indef(), "sub", x, y);
	79
	80	case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_INF):
	81	case CLPAIR(IEEE754_CLASS_DNORM, IEEE754_CLASS_INF):
	82	case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_INF):
	83	return ieee754sp_inf(ys ^ 1);
	84
	85	case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_ZERO):
	86	case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_NORM):
	87	case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_DNORM):
	88	return x;
	89
	90	/* Zero handling
	91	*/
	92
	93	case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO):
	94	if (xs != ys)
	95	return x;
	96	else
	97	return ieee754sp_zero(ieee754_csr.rm ==
	98	IEEE754_RD);
	99
	100	case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_ZERO):
	101	case CLPAIR(IEEE754_CLASS_DNORM, IEEE754_CLASS_ZERO):
	102	return x;
	103
	104	case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_NORM):
	105	case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_DNORM):
	106	/* quick fix up */
	107	DPSIGN(y) ^= 1;
	108	return y;
	109
	110	case CLPAIR(IEEE754_CLASS_DNORM, IEEE754_CLASS_DNORM):
	111	SPDNORMX;
	112
	113	case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_DNORM):
	114	SPDNORMY;
	115	break;
	116
	117	case CLPAIR(IEEE754_CLASS_DNORM, IEEE754_CLASS_NORM):
	118	SPDNORMX;
	119	break;
	120
	121	case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_NORM):
	122	break;
	123	}
	124	/* flip sign of y and handle as add */
	125	ys ^= 1;
	126
	127	assert(xm & SP_HIDDEN_BIT);
	128	assert(ym & SP_HIDDEN_BIT);
	129
	130
	131	/* provide guard,round and stick bit space */
	132	xm <<= 3;
	133	ym <<= 3;
	134
	135	if (xe > ye) {
	136	/* have to shift y fraction right to align
	137	*/
	138	int s = xe - ye;
	139	SPXSRSYn(s);
	140	} else if (ye > xe) {
	141	/* have to shift x fraction right to align
142	*/
143	int s = ye - xe;
144	SPXSRSXn(s);
145	}
146	assert(xe == ye);
147	assert(xe <= SP_EMAX);
148
149	if (xs == ys) {
150	/* generate 28 bit result of adding two 27 bit numbers
151	*/
152	xm = xm + ym;
153	xe = xe;
154	xs = xs;
155
70342287	156	if (xm >> (SP_MBITS + 1 + 3)) { /* carry out */
1da177e4 LT	157	SPXSRSX1(); /* shift preserving sticky */
	158	}
	159	} else {
	160	if (xm >= ym) {
	161	xm = xm - ym;
	162	xe = xe;
	163	xs = xs;
	164	} else {
	165	xm = ym - xm;
	166	xe = xe;
	167	xs = ys;
	168	}
	169	if (xm == 0) {
	170	if (ieee754_csr.rm == IEEE754_RD)
	171	return ieee754sp_zero(1); /* round negative inf. => sign = -1 */
	172	else
	173	return ieee754sp_zero(0); /* other round modes => sign = 1 */
	174	}
	175	/* normalize to rounding precision
	176	*/
	177	while ((xm >> (SP_MBITS + 3)) == 0) {
	178	xm <<= 1;
	179	xe--;
	180	}
	181	}
	182	SPNORMRET2(xs, xe, xm, "sub", x, y);
	183	}