summaryrefslogtreecommitdiffstats
path: root/arch/arm/nwfpe/extended_cpdo.c
blob: 529b047bac0b8f7b4c387d2bdaa0880ef788700e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
// SPDX-License-Identifier: GPL-2.0-or-later
/*
    NetWinder Floating Point Emulator
    (c) Rebel.COM, 1998,1999

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

*/

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

floatx80 floatx80_exp(floatx80 Fm);
floatx80 floatx80_ln(floatx80 Fm);
floatx80 floatx80_sin(floatx80 rFm);
floatx80 floatx80_cos(floatx80 rFm);
floatx80 floatx80_arcsin(floatx80 rFm);
floatx80 floatx80_arctan(floatx80 rFm);
floatx80 floatx80_log(floatx80 rFm);
floatx80 floatx80_tan(floatx80 rFm);
floatx80 floatx80_arccos(floatx80 rFm);
floatx80 floatx80_pow(floatx80 rFn, floatx80 rFm);
floatx80 floatx80_pol(floatx80 rFn, floatx80 rFm);

static floatx80 floatx80_rsf(struct roundingData *roundData, floatx80 rFn, floatx80 rFm)
{
	return floatx80_sub(roundData, rFm, rFn);
}

static floatx80 floatx80_rdv(struct roundingData *roundData, floatx80 rFn, floatx80 rFm)
{
	return floatx80_div(roundData, rFm, rFn);
}

static floatx80 (*const dyadic_extended[16])(struct roundingData*, floatx80 rFn, floatx80 rFm) = {
	[ADF_CODE >> 20] = floatx80_add,
	[MUF_CODE >> 20] = floatx80_mul,
	[SUF_CODE >> 20] = floatx80_sub,
	[RSF_CODE >> 20] = floatx80_rsf,
	[DVF_CODE >> 20] = floatx80_div,
	[RDF_CODE >> 20] = floatx80_rdv,
	[RMF_CODE >> 20] = floatx80_rem,

	/* strictly, these opcodes should not be implemented */
	[FML_CODE >> 20] = floatx80_mul,
	[FDV_CODE >> 20] = floatx80_div,
	[FRD_CODE >> 20] = floatx80_rdv,
};

static floatx80 floatx80_mvf(struct roundingData *roundData, floatx80 rFm)
{
	return rFm;
}

static floatx80 floatx80_mnf(struct roundingData *roundData, floatx80 rFm)
{
	rFm.high ^= 0x8000;
	return rFm;
}

static floatx80 floatx80_abs(struct roundingData *roundData, floatx80 rFm)
{
	rFm.high &= 0x7fff;
	return rFm;
}

static floatx80 (*const monadic_extended[16])(struct roundingData*, floatx80 rFm) = {
	[MVF_CODE >> 20] = floatx80_mvf,
	[MNF_CODE >> 20] = floatx80_mnf,
	[ABS_CODE >> 20] = floatx80_abs,
	[RND_CODE >> 20] = floatx80_round_to_int,
	[URD_CODE >> 20] = floatx80_round_to_int,
	[SQT_CODE >> 20] = floatx80_sqrt,
	[NRM_CODE >> 20] = floatx80_mvf,
};

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

	Fm = getFm(opcode);
	if (CONSTANT_FM(opcode)) {
		rFm = getExtendedConstant(Fm);
	} else {
		switch (fpa11->fType[Fm]) {
		case typeSingle:
			rFm = float32_to_floatx80(fpa11->fpreg[Fm].fSingle);
			break;

		case typeDouble:
			rFm = float64_to_floatx80(fpa11->fpreg[Fm].fDouble);
			break;

		case typeExtended:
			rFm = fpa11->fpreg[Fm].fExtended;
			break;

		default:
			return 0;
		}
	}

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

		switch (fpa11->fType[Fn]) {
		case typeSingle:
			rFn = float32_to_floatx80(fpa11->fpreg[Fn].fSingle);
			break;

		case typeDouble:
			rFn = float64_to_floatx80(fpa11->fpreg[Fn].fDouble);
			break;

		case typeExtended:
			rFn = fpa11->fpreg[Fn].fExtended;
			break;

		default:
			return 0;
		}

		if (dyadic_extended[opc_mask_shift]) {
			rFd->fExtended = dyadic_extended[opc_mask_shift](roundData, rFn, rFm);
		} else {
			return 0;
		}
	} else {
		if (monadic_extended[opc_mask_shift]) {
			rFd->fExtended = monadic_extended[opc_mask_shift](roundData, rFm);
		} else {
			return 0;
		}
	}

	return 1;
}