1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3     NetWinder Floating Point Emulator
4     (c) Rebel.COM, 1998,1999
5     (c) Philip Blundell, 1999, 2001
6 
7     Direct questions, comments to Scott Bambrough <scottb@netwinder.org>
8 
9 */
10 
11 #include "fpa11.h"
12 #include "fpopcode.h"
13 #include "fpa11.inl"
14 #include "fpmodule.h"
15 #include "fpmodule.inl"
16 #include "softfloat.h"
17 
18 unsigned int PerformFLT(const unsigned int opcode);
19 unsigned int PerformFIX(const unsigned int opcode);
20 
21 static unsigned int PerformComparison(const unsigned int opcode);
22 
EmulateCPRT(const unsigned int opcode)23 unsigned int EmulateCPRT(const unsigned int opcode)
24 {
25 
26 	if (opcode & 0x800000) {
27 		/* This is some variant of a comparison (PerformComparison
28 		   will sort out which one).  Since most of the other CPRT
29 		   instructions are oddball cases of some sort or other it
30 		   makes sense to pull this out into a fast path.  */
31 		return PerformComparison(opcode);
32 	}
33 
34 	/* Hint to GCC that we'd like a jump table rather than a load of CMPs */
35 	switch ((opcode & 0x700000) >> 20) {
36 	case FLT_CODE >> 20:
37 		return PerformFLT(opcode);
38 		break;
39 	case FIX_CODE >> 20:
40 		return PerformFIX(opcode);
41 		break;
42 
43 	case WFS_CODE >> 20:
44 		writeFPSR(readRegister(getRd(opcode)));
45 		break;
46 	case RFS_CODE >> 20:
47 		writeRegister(getRd(opcode), readFPSR());
48 		break;
49 
50 	default:
51 		return 0;
52 	}
53 
54 	return 1;
55 }
56 
PerformFLT(const unsigned int opcode)57 unsigned int PerformFLT(const unsigned int opcode)
58 {
59 	FPA11 *fpa11 = GET_FPA11();
60 	struct roundingData roundData;
61 
62 	roundData.mode = SetRoundingMode(opcode);
63 	roundData.precision = SetRoundingPrecision(opcode);
64 	roundData.exception = 0;
65 
66 	switch (opcode & MASK_ROUNDING_PRECISION) {
67 	case ROUND_SINGLE:
68 		{
69 			fpa11->fType[getFn(opcode)] = typeSingle;
70 			fpa11->fpreg[getFn(opcode)].fSingle = int32_to_float32(&roundData, readRegister(getRd(opcode)));
71 		}
72 		break;
73 
74 	case ROUND_DOUBLE:
75 		{
76 			fpa11->fType[getFn(opcode)] = typeDouble;
77 			fpa11->fpreg[getFn(opcode)].fDouble = int32_to_float64(readRegister(getRd(opcode)));
78 		}
79 		break;
80 
81 #ifdef CONFIG_FPE_NWFPE_XP
82 	case ROUND_EXTENDED:
83 		{
84 			fpa11->fType[getFn(opcode)] = typeExtended;
85 			fpa11->fpreg[getFn(opcode)].fExtended = int32_to_floatx80(readRegister(getRd(opcode)));
86 		}
87 		break;
88 #endif
89 
90 	default:
91 		return 0;
92 	}
93 
94 	if (roundData.exception)
95 		float_raise(roundData.exception);
96 
97 	return 1;
98 }
99 
PerformFIX(const unsigned int opcode)100 unsigned int PerformFIX(const unsigned int opcode)
101 {
102 	FPA11 *fpa11 = GET_FPA11();
103 	unsigned int Fn = getFm(opcode);
104 	struct roundingData roundData;
105 
106 	roundData.mode = SetRoundingMode(opcode);
107 	roundData.precision = SetRoundingPrecision(opcode);
108 	roundData.exception = 0;
109 
110 	switch (fpa11->fType[Fn]) {
111 	case typeSingle:
112 		{
113 			writeRegister(getRd(opcode), float32_to_int32(&roundData, fpa11->fpreg[Fn].fSingle));
114 		}
115 		break;
116 
117 	case typeDouble:
118 		{
119 			writeRegister(getRd(opcode), float64_to_int32(&roundData, fpa11->fpreg[Fn].fDouble));
120 		}
121 		break;
122 
123 #ifdef CONFIG_FPE_NWFPE_XP
124 	case typeExtended:
125 		{
126 			writeRegister(getRd(opcode), floatx80_to_int32(&roundData, fpa11->fpreg[Fn].fExtended));
127 		}
128 		break;
129 #endif
130 
131 	default:
132 		return 0;
133 	}
134 
135 	if (roundData.exception)
136 		float_raise(roundData.exception);
137 
138 	return 1;
139 }
140 
141 /* This instruction sets the flags N, Z, C, V in the FPSR. */
PerformComparison(const unsigned int opcode)142 static unsigned int PerformComparison(const unsigned int opcode)
143 {
144 	FPA11 *fpa11 = GET_FPA11();
145 	unsigned int Fn = getFn(opcode), Fm = getFm(opcode);
146 	int e_flag = opcode & 0x400000;	/* 1 if CxFE */
147 	int n_flag = opcode & 0x200000;	/* 1 if CNxx */
148 	unsigned int flags = 0;
149 
150 #ifdef CONFIG_FPE_NWFPE_XP
151 	floatx80 rFn, rFm;
152 
153 	/* Check for unordered condition and convert all operands to 80-bit
154 	   format.
155 	   ?? Might be some mileage in avoiding this conversion if possible.
156 	   Eg, if both operands are 32-bit, detect this and do a 32-bit
157 	   comparison (cheaper than an 80-bit one).  */
158 	switch (fpa11->fType[Fn]) {
159 	case typeSingle:
160 		//printk("single.\n");
161 		if (float32_is_nan(fpa11->fpreg[Fn].fSingle))
162 			goto unordered;
163 		rFn = float32_to_floatx80(fpa11->fpreg[Fn].fSingle);
164 		break;
165 
166 	case typeDouble:
167 		//printk("double.\n");
168 		if (float64_is_nan(fpa11->fpreg[Fn].fDouble))
169 			goto unordered;
170 		rFn = float64_to_floatx80(fpa11->fpreg[Fn].fDouble);
171 		break;
172 
173 	case typeExtended:
174 		//printk("extended.\n");
175 		if (floatx80_is_nan(fpa11->fpreg[Fn].fExtended))
176 			goto unordered;
177 		rFn = fpa11->fpreg[Fn].fExtended;
178 		break;
179 
180 	default:
181 		return 0;
182 	}
183 
184 	if (CONSTANT_FM(opcode)) {
185 		//printk("Fm is a constant: #%d.\n",Fm);
186 		rFm = getExtendedConstant(Fm);
187 		if (floatx80_is_nan(rFm))
188 			goto unordered;
189 	} else {
190 		//printk("Fm = r%d which contains a ",Fm);
191 		switch (fpa11->fType[Fm]) {
192 		case typeSingle:
193 			//printk("single.\n");
194 			if (float32_is_nan(fpa11->fpreg[Fm].fSingle))
195 				goto unordered;
196 			rFm = float32_to_floatx80(fpa11->fpreg[Fm].fSingle);
197 			break;
198 
199 		case typeDouble:
200 			//printk("double.\n");
201 			if (float64_is_nan(fpa11->fpreg[Fm].fDouble))
202 				goto unordered;
203 			rFm = float64_to_floatx80(fpa11->fpreg[Fm].fDouble);
204 			break;
205 
206 		case typeExtended:
207 			//printk("extended.\n");
208 			if (floatx80_is_nan(fpa11->fpreg[Fm].fExtended))
209 				goto unordered;
210 			rFm = fpa11->fpreg[Fm].fExtended;
211 			break;
212 
213 		default:
214 			return 0;
215 		}
216 	}
217 
218 	if (n_flag)
219 		rFm.high ^= 0x8000;
220 
221 	/* test for less than condition */
222 	if (floatx80_lt(rFn, rFm))
223 		flags |= CC_NEGATIVE;
224 
225 	/* test for equal condition */
226 	if (floatx80_eq(rFn, rFm))
227 		flags |= CC_ZERO;
228 
229 	/* test for greater than or equal condition */
230 	if (floatx80_lt(rFm, rFn))
231 		flags |= CC_CARRY;
232 
233 #else
234 	if (CONSTANT_FM(opcode)) {
235 		/* Fm is a constant.  Do the comparison in whatever precision
236 		   Fn happens to be stored in.  */
237 		if (fpa11->fType[Fn] == typeSingle) {
238 			float32 rFm = getSingleConstant(Fm);
239 			float32 rFn = fpa11->fpreg[Fn].fSingle;
240 
241 			if (float32_is_nan(rFn))
242 				goto unordered;
243 
244 			if (n_flag)
245 				rFm ^= 0x80000000;
246 
247 			/* test for less than condition */
248 			if (float32_lt_nocheck(rFn, rFm))
249 				flags |= CC_NEGATIVE;
250 
251 			/* test for equal condition */
252 			if (float32_eq_nocheck(rFn, rFm))
253 				flags |= CC_ZERO;
254 
255 			/* test for greater than or equal condition */
256 			if (float32_lt_nocheck(rFm, rFn))
257 				flags |= CC_CARRY;
258 		} else {
259 			float64 rFm = getDoubleConstant(Fm);
260 			float64 rFn = fpa11->fpreg[Fn].fDouble;
261 
262 			if (float64_is_nan(rFn))
263 				goto unordered;
264 
265 			if (n_flag)
266 				rFm ^= 0x8000000000000000ULL;
267 
268 			/* test for less than condition */
269 			if (float64_lt_nocheck(rFn, rFm))
270 				flags |= CC_NEGATIVE;
271 
272 			/* test for equal condition */
273 			if (float64_eq_nocheck(rFn, rFm))
274 				flags |= CC_ZERO;
275 
276 			/* test for greater than or equal condition */
277 			if (float64_lt_nocheck(rFm, rFn))
278 				flags |= CC_CARRY;
279 		}
280 	} else {
281 		/* Both operands are in registers.  */
282 		if (fpa11->fType[Fn] == typeSingle
283 		    && fpa11->fType[Fm] == typeSingle) {
284 			float32 rFm = fpa11->fpreg[Fm].fSingle;
285 			float32 rFn = fpa11->fpreg[Fn].fSingle;
286 
287 			if (float32_is_nan(rFn)
288 			    || float32_is_nan(rFm))
289 				goto unordered;
290 
291 			if (n_flag)
292 				rFm ^= 0x80000000;
293 
294 			/* test for less than condition */
295 			if (float32_lt_nocheck(rFn, rFm))
296 				flags |= CC_NEGATIVE;
297 
298 			/* test for equal condition */
299 			if (float32_eq_nocheck(rFn, rFm))
300 				flags |= CC_ZERO;
301 
302 			/* test for greater than or equal condition */
303 			if (float32_lt_nocheck(rFm, rFn))
304 				flags |= CC_CARRY;
305 		} else {
306 			/* Promote 32-bit operand to 64 bits.  */
307 			float64 rFm, rFn;
308 
309 			rFm = (fpa11->fType[Fm] == typeSingle) ?
310 			    float32_to_float64(fpa11->fpreg[Fm].fSingle)
311 			    : fpa11->fpreg[Fm].fDouble;
312 
313 			rFn = (fpa11->fType[Fn] == typeSingle) ?
314 			    float32_to_float64(fpa11->fpreg[Fn].fSingle)
315 			    : fpa11->fpreg[Fn].fDouble;
316 
317 			if (float64_is_nan(rFn)
318 			    || float64_is_nan(rFm))
319 				goto unordered;
320 
321 			if (n_flag)
322 				rFm ^= 0x8000000000000000ULL;
323 
324 			/* test for less than condition */
325 			if (float64_lt_nocheck(rFn, rFm))
326 				flags |= CC_NEGATIVE;
327 
328 			/* test for equal condition */
329 			if (float64_eq_nocheck(rFn, rFm))
330 				flags |= CC_ZERO;
331 
332 			/* test for greater than or equal condition */
333 			if (float64_lt_nocheck(rFm, rFn))
334 				flags |= CC_CARRY;
335 		}
336 	}
337 
338 #endif
339 
340 	writeConditionCodes(flags);
341 
342 	return 1;
343 
344       unordered:
345 	/* ?? The FPA data sheet is pretty vague about this, in particular
346 	   about whether the non-E comparisons can ever raise exceptions.
347 	   This implementation is based on a combination of what it says in
348 	   the data sheet, observation of how the Acorn emulator actually
349 	   behaves (and how programs expect it to) and guesswork.  */
350 	flags |= CC_OVERFLOW;
351 	flags &= ~(CC_ZERO | CC_NEGATIVE);
352 
353 	if (BIT_AC & readFPSR())
354 		flags |= CC_CARRY;
355 
356 	if (e_flag)
357 		float_raise(float_flag_invalid);
358 
359 	writeConditionCodes(flags);
360 	return 1;
361 }
362