[linux-2.6-block.git] / arch / arm / nwfpe / single_cpdo.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
    NetWinder Floating Point Emulator
    (c) Rebel.COM, 1998,1999
    (c) Philip Blundell, 2001

    Direct questions, comments to Scott Bambrough <scottb@netwinder.org>

*/

#include "fpa11.h"
#include "softfloat.h"
#include "fpopcode.h"

float32 float32_exp(float32 Fm);
float32 float32_ln(float32 Fm);
float32 float32_sin(float32 rFm);
float32 float32_cos(float32 rFm);
float32 float32_arcsin(float32 rFm);
float32 float32_arctan(float32 rFm);
float32 float32_log(float32 rFm);
float32 float32_tan(float32 rFm);
float32 float32_arccos(float32 rFm);
float32 float32_pow(float32 rFn, float32 rFm);
float32 float32_pol(float32 rFn, float32 rFm);

static float32 float32_rsf(struct roundingData *roundData, float32 rFn, float32 rFm)
{
	return float32_sub(roundData, rFm, rFn);
}

static float32 float32_rdv(struct roundingData *roundData, float32 rFn, float32 rFm)
{
	return float32_div(roundData, rFm, rFn);
}

static float32 (*const dyadic_single[16])(struct roundingData *, float32 rFn, float32 rFm) = {
	[ADF_CODE >> 20] = float32_add,
	[MUF_CODE >> 20] = float32_mul,
	[SUF_CODE >> 20] = float32_sub,
	[RSF_CODE >> 20] = float32_rsf,
	[DVF_CODE >> 20] = float32_div,
	[RDF_CODE >> 20] = float32_rdv,
	[RMF_CODE >> 20] = float32_rem,

	[FML_CODE >> 20] = float32_mul,
	[FDV_CODE >> 20] = float32_div,
	[FRD_CODE >> 20] = float32_rdv,
};

static float32 float32_mvf(struct roundingData *roundData, float32 rFm)
{
	return rFm;
}

static float32 float32_mnf(struct roundingData *roundData, float32 rFm)
{
	return rFm ^ 0x80000000;
}

static float32 float32_abs(struct roundingData *roundData, float32 rFm)
{
	return rFm & 0x7fffffff;
}

static float32 (*const monadic_single[16])(struct roundingData*, float32 rFm) = {
	[MVF_CODE >> 20] = float32_mvf,
	[MNF_CODE >> 20] = float32_mnf,
	[ABS_CODE >> 20] = float32_abs,
	[RND_CODE >> 20] = float32_round_to_int,
	[URD_CODE >> 20] = float32_round_to_int,
	[SQT_CODE >> 20] = float32_sqrt,
	[NRM_CODE >> 20] = float32_mvf,
};

unsigned int SingleCPDO(struct roundingData *roundData, const unsigned int opcode, FPREG * rFd)
{
	FPA11 *fpa11 = GET_FPA11();
	float32 rFm;
	unsigned int Fm, opc_mask_shift;

	Fm = getFm(opcode);
	if (CONSTANT_FM(opcode)) {
		rFm = getSingleConstant(Fm);
	} else if (fpa11->fType[Fm] == typeSingle) {
		rFm = fpa11->fpreg[Fm].fSingle;
	} else {
		return 0;
	}

	opc_mask_shift = (opcode & MASK_ARITHMETIC_OPCODE) >> 20;
	if (!MONADIC_INSTRUCTION(opcode)) {
		unsigned int Fn = getFn(opcode);
		float32 rFn;

		if (fpa11->fType[Fn] == typeSingle &&
		    dyadic_single[opc_mask_shift]) {
			rFn = fpa11->fpreg[Fn].fSingle;
			rFd->fSingle = dyadic_single[opc_mask_shift](roundData, rFn, rFm);
		} else {
			return 0;
		}
	} else {
		if (monadic_single[opc_mask_shift]) {
			rFd->fSingle = monadic_single[opc_mask_shift](roundData, rFm);
		} else {
			return 0;
		}
	}

	return 1;
}
Commit	Line	Data
74ba9207	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 LT	2	/*
	3	NetWinder Floating Point Emulator
	4	(c) Rebel.COM, 1998,1999
	5	(c) Philip Blundell, 2001
	6
	7	Direct questions, comments to Scott Bambrough <scottb@netwinder.org>
	8
1da177e4 LT	9	*/
	10
	11	#include "fpa11.h"
	12	#include "softfloat.h"
	13	#include "fpopcode.h"
	14
	15	float32 float32_exp(float32 Fm);
	16	float32 float32_ln(float32 Fm);
	17	float32 float32_sin(float32 rFm);
	18	float32 float32_cos(float32 rFm);
	19	float32 float32_arcsin(float32 rFm);
	20	float32 float32_arctan(float32 rFm);
	21	float32 float32_log(float32 rFm);
	22	float32 float32_tan(float32 rFm);
	23	float32 float32_arccos(float32 rFm);
	24	float32 float32_pow(float32 rFn, float32 rFm);
	25	float32 float32_pol(float32 rFn, float32 rFm);
	26
f148af25	27	static float32 float32_rsf(struct roundingData *roundData, float32 rFn, float32 rFm)
1da177e4	28	{
f148af25	29	return float32_sub(roundData, rFm, rFn);
1da177e4 LT	30	}
1da177e4 LT	31
f148af25	32	static float32 float32_rdv(struct roundingData *roundData, float32 rFn, float32 rFm)
1da177e4	33	{
f148af25	34	return float32_div(roundData, rFm, rFn);
1da177e4 LT	35	}
1da177e4 LT	36
f148af25	37	static float32 (const dyadic_single[16])(struct roundingData , float32 rFn, float32 rFm) = {
1da177e4 LT	38	[ADF_CODE >> 20] = float32_add,
	39	[MUF_CODE >> 20] = float32_mul,
	40	[SUF_CODE >> 20] = float32_sub,
	41	[RSF_CODE >> 20] = float32_rsf,
	42	[DVF_CODE >> 20] = float32_div,
	43	[RDF_CODE >> 20] = float32_rdv,
	44	[RMF_CODE >> 20] = float32_rem,
	45
	46	[FML_CODE >> 20] = float32_mul,
	47	[FDV_CODE >> 20] = float32_div,
	48	[FRD_CODE >> 20] = float32_rdv,
	49	};
	50
f148af25	51	static float32 float32_mvf(struct roundingData *roundData, float32 rFm)
1da177e4 LT	52	{
	53	return rFm;
	54	}
	55
f148af25	56	static float32 float32_mnf(struct roundingData *roundData, float32 rFm)
1da177e4 LT	57	{
	58	return rFm ^ 0x80000000;
	59	}
	60
f148af25	61	static float32 float32_abs(struct roundingData *roundData, float32 rFm)
1da177e4 LT	62	{
	63	return rFm & 0x7fffffff;
	64	}
	65
f148af25	66	static float32 (const monadic_single[16])(struct roundingData, float32 rFm) = {
1da177e4 LT	67	[MVF_CODE >> 20] = float32_mvf,
	68	[MNF_CODE >> 20] = float32_mnf,
	69	[ABS_CODE >> 20] = float32_abs,
	70	[RND_CODE >> 20] = float32_round_to_int,
	71	[URD_CODE >> 20] = float32_round_to_int,
	72	[SQT_CODE >> 20] = float32_sqrt,
	73	[NRM_CODE >> 20] = float32_mvf,
	74	};
	75
f148af25	76	unsigned int SingleCPDO(struct roundingData roundData, const unsigned int opcode, FPREG rFd)
1da177e4 LT	77	{
	78	FPA11 *fpa11 = GET_FPA11();
	79	float32 rFm;
	80	unsigned int Fm, opc_mask_shift;
	81
	82	Fm = getFm(opcode);
	83	if (CONSTANT_FM(opcode)) {
	84	rFm = getSingleConstant(Fm);
	85	} else if (fpa11->fType[Fm] == typeSingle) {
	86	rFm = fpa11->fpreg[Fm].fSingle;
	87	} else {
	88	return 0;
	89	}
	90
	91	opc_mask_shift = (opcode & MASK_ARITHMETIC_OPCODE) >> 20;
	92	if (!MONADIC_INSTRUCTION(opcode)) {
	93	unsigned int Fn = getFn(opcode);
	94	float32 rFn;
	95
	96	if (fpa11->fType[Fn] == typeSingle &&
	97	dyadic_single[opc_mask_shift]) {
	98	rFn = fpa11->fpreg[Fn].fSingle;
f148af25	99	rFd->fSingle = dyadic_single[opc_mask_shift](roundData, rFn, rFm);
1da177e4 LT	100	} else {
	101	return 0;
	102	}
	103	} else {
	104	if (monadic_single[opc_mask_shift]) {
f148af25	105	rFd->fSingle = monadic_single[opc_mask_shift](roundData, rFm);
1da177e4 LT	106	} else {
	107	return 0;
	108	}
	109	}
	110
	111	return 1;
	112	}