summaryrefslogtreecommitdiff
path: root/arch/m68k/fpsp040/get_op.S
blob: 64c36d79ef836ca97a8bbdbe741addcb4c1a452e (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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
|
|	get_op.sa 3.6 5/19/92
|
|	get_op.sa 3.5 4/26/91
|
|  Description: This routine is called by the unsupported format/data
| type exception handler ('unsupp' - vector 55) and the unimplemented
| instruction exception handler ('unimp' - vector 11).  'get_op'
| determines the opclass (0, 2, or 3) and branches to the
| opclass handler routine.  See 68881/2 User's Manual table 4-11
| for a description of the opclasses.
|
| For UNSUPPORTED data/format (exception vector 55) and for
| UNIMPLEMENTED instructions (exception vector 11) the following
| applies:
|
| - For unnormalized numbers (opclass 0, 2, or 3) the
| number(s) is normalized and the operand type tag is updated.
|
| - For a packed number (opclass 2) the number is unpacked and the
| operand type tag is updated.
|
| - For denormalized numbers (opclass 0 or 2) the number(s) is not
| changed but passed to the next module.  The next module for
| unimp is do_func, the next module for unsupp is res_func.
|
| For UNSUPPORTED data/format (exception vector 55) only the
| following applies:
|
| - If there is a move out with a packed number (opclass 3) the
| number is packed and written to user memory.  For the other
| opclasses the number(s) are written back to the fsave stack
| and the instruction is then restored back into the '040.  The
| '040 is then able to complete the instruction.
|
| For example:
| fadd.x fpm,fpn where the fpm contains an unnormalized number.
| The '040 takes an unsupported data trap and gets to this
| routine.  The number is normalized, put back on the stack and
| then an frestore is done to restore the instruction back into
| the '040.  The '040 then re-executes the fadd.x fpm,fpn with
| a normalized number in the source and the instruction is
| successful.
|
| Next consider if in the process of normalizing the un-
| normalized number it becomes a denormalized number.  The
| routine which converts the unnorm to a norm (called mk_norm)
| detects this and tags the number as a denorm.  The routine
| res_func sees the denorm tag and converts the denorm to a
| norm.  The instruction is then restored back into the '040
| which re_executes the instruction.
|
|
|		Copyright (C) Motorola, Inc. 1990
|			All Rights Reserved
|
|       For details on the license for this file, please see the
|       file, README, in this same directory.

GET_OP:    |idnt    2,1 | Motorola 040 Floating Point Software Package

	|section	8

#include "fpsp.h"

	.global	PIRN,PIRZRM,PIRP
	.global	SMALRN,SMALRZRM,SMALRP
	.global	BIGRN,BIGRZRM,BIGRP

PIRN:
	.long 0x40000000,0xc90fdaa2,0x2168c235    |pi
PIRZRM:
	.long 0x40000000,0xc90fdaa2,0x2168c234    |pi
PIRP:
	.long 0x40000000,0xc90fdaa2,0x2168c235    |pi

|round to nearest
SMALRN:
	.long 0x3ffd0000,0x9a209a84,0xfbcff798    |log10(2)
	.long 0x40000000,0xadf85458,0xa2bb4a9a    |e
	.long 0x3fff0000,0xb8aa3b29,0x5c17f0bc    |log2(e)
	.long 0x3ffd0000,0xde5bd8a9,0x37287195    |log10(e)
	.long 0x00000000,0x00000000,0x00000000    |0.0
| round to zero;round to negative infinity
SMALRZRM:
	.long 0x3ffd0000,0x9a209a84,0xfbcff798    |log10(2)
	.long 0x40000000,0xadf85458,0xa2bb4a9a    |e
	.long 0x3fff0000,0xb8aa3b29,0x5c17f0bb    |log2(e)
	.long 0x3ffd0000,0xde5bd8a9,0x37287195    |log10(e)
	.long 0x00000000,0x00000000,0x00000000    |0.0
| round to positive infinity
SMALRP:
	.long 0x3ffd0000,0x9a209a84,0xfbcff799    |log10(2)
	.long 0x40000000,0xadf85458,0xa2bb4a9b    |e
	.long 0x3fff0000,0xb8aa3b29,0x5c17f0bc    |log2(e)
	.long 0x3ffd0000,0xde5bd8a9,0x37287195    |log10(e)
	.long 0x00000000,0x00000000,0x00000000    |0.0

|round to nearest
BIGRN:
	.long 0x3ffe0000,0xb17217f7,0xd1cf79ac    |ln(2)
	.long 0x40000000,0x935d8ddd,0xaaa8ac17    |ln(10)
	.long 0x3fff0000,0x80000000,0x00000000    |10 ^ 0

	.global	PTENRN
PTENRN:
	.long 0x40020000,0xA0000000,0x00000000    |10 ^ 1
	.long 0x40050000,0xC8000000,0x00000000    |10 ^ 2
	.long 0x400C0000,0x9C400000,0x00000000    |10 ^ 4
	.long 0x40190000,0xBEBC2000,0x00000000    |10 ^ 8
	.long 0x40340000,0x8E1BC9BF,0x04000000    |10 ^ 16
	.long 0x40690000,0x9DC5ADA8,0x2B70B59E    |10 ^ 32
	.long 0x40D30000,0xC2781F49,0xFFCFA6D5    |10 ^ 64
	.long 0x41A80000,0x93BA47C9,0x80E98CE0    |10 ^ 128
	.long 0x43510000,0xAA7EEBFB,0x9DF9DE8E    |10 ^ 256
	.long 0x46A30000,0xE319A0AE,0xA60E91C7    |10 ^ 512
	.long 0x4D480000,0xC9767586,0x81750C17    |10 ^ 1024
	.long 0x5A920000,0x9E8B3B5D,0xC53D5DE5    |10 ^ 2048
	.long 0x75250000,0xC4605202,0x8A20979B    |10 ^ 4096
|round to minus infinity
BIGRZRM:
	.long 0x3ffe0000,0xb17217f7,0xd1cf79ab    |ln(2)
	.long 0x40000000,0x935d8ddd,0xaaa8ac16    |ln(10)
	.long 0x3fff0000,0x80000000,0x00000000    |10 ^ 0

	.global	PTENRM
PTENRM:
	.long 0x40020000,0xA0000000,0x00000000    |10 ^ 1
	.long 0x40050000,0xC8000000,0x00000000    |10 ^ 2
	.long 0x400C0000,0x9C400000,0x00000000    |10 ^ 4
	.long 0x40190000,0xBEBC2000,0x00000000    |10 ^ 8
	.long 0x40340000,0x8E1BC9BF,0x04000000    |10 ^ 16
	.long 0x40690000,0x9DC5ADA8,0x2B70B59D    |10 ^ 32
	.long 0x40D30000,0xC2781F49,0xFFCFA6D5    |10 ^ 64
	.long 0x41A80000,0x93BA47C9,0x80E98CDF    |10 ^ 128
	.long 0x43510000,0xAA7EEBFB,0x9DF9DE8D    |10 ^ 256
	.long 0x46A30000,0xE319A0AE,0xA60E91C6    |10 ^ 512
	.long 0x4D480000,0xC9767586,0x81750C17    |10 ^ 1024
	.long 0x5A920000,0x9E8B3B5D,0xC53D5DE5    |10 ^ 2048
	.long 0x75250000,0xC4605202,0x8A20979A    |10 ^ 4096
|round to positive infinity
BIGRP:
	.long 0x3ffe0000,0xb17217f7,0xd1cf79ac    |ln(2)
	.long 0x40000000,0x935d8ddd,0xaaa8ac17    |ln(10)
	.long 0x3fff0000,0x80000000,0x00000000    |10 ^ 0

	.global	PTENRP
PTENRP:
	.long 0x40020000,0xA0000000,0x00000000    |10 ^ 1
	.long 0x40050000,0xC8000000,0x00000000    |10 ^ 2
	.long 0x400C0000,0x9C400000,0x00000000    |10 ^ 4
	.long 0x40190000,0xBEBC2000,0x00000000    |10 ^ 8
	.long 0x40340000,0x8E1BC9BF,0x04000000    |10 ^ 16
	.long 0x40690000,0x9DC5ADA8,0x2B70B59E    |10 ^ 32
	.long 0x40D30000,0xC2781F49,0xFFCFA6D6    |10 ^ 64
	.long 0x41A80000,0x93BA47C9,0x80E98CE0    |10 ^ 128
	.long 0x43510000,0xAA7EEBFB,0x9DF9DE8E    |10 ^ 256
	.long 0x46A30000,0xE319A0AE,0xA60E91C7    |10 ^ 512
	.long 0x4D480000,0xC9767586,0x81750C18    |10 ^ 1024
	.long 0x5A920000,0x9E8B3B5D,0xC53D5DE6    |10 ^ 2048
	.long 0x75250000,0xC4605202,0x8A20979B    |10 ^ 4096

	|xref	nrm_zero
	|xref	decbin
	|xref	round

	.global    get_op
	.global    uns_getop
	.global    uni_getop
get_op:
	clrb	DY_MO_FLG(%a6)
	tstb	UFLG_TMP(%a6)	|test flag for unsupp/unimp state
	beq	uni_getop

uns_getop:
	btstb	#direction_bit,CMDREG1B(%a6)
	bne	opclass3	|branch if a fmove out (any kind)
	btstb	#6,CMDREG1B(%a6)
	beqs	uns_notpacked

	bfextu	CMDREG1B(%a6){#3:#3},%d0
	cmpb	#3,%d0
	beq	pack_source	|check for a packed src op, branch if so
uns_notpacked:
	bsr	chk_dy_mo	|set the dyadic/monadic flag
	tstb	DY_MO_FLG(%a6)
	beqs	src_op_ck	|if monadic, go check src op
|				;else, check dst op (fall through)

	btstb	#7,DTAG(%a6)
	beqs	src_op_ck	|if dst op is norm, check src op
	bras	dst_ex_dnrm	|else, handle destination unnorm/dnrm

uni_getop:
	bfextu	CMDREG1B(%a6){#0:#6},%d0 |get opclass and src fields
	cmpil	#0x17,%d0		|if op class and size fields are $17,
|				;it is FMOVECR; if not, continue
|
| If the instruction is fmovecr, exit get_op.  It is handled
| in do_func and smovecr.sa.
|
	bne	not_fmovecr	|handle fmovecr as an unimplemented inst
	rts

not_fmovecr:
	btstb	#E1,E_BYTE(%a6)	|if set, there is a packed operand
	bne	pack_source	|check for packed src op, branch if so

| The following lines of are coded to optimize on normalized operands
	moveb	STAG(%a6),%d0
	orb	DTAG(%a6),%d0	|check if either of STAG/DTAG msb set
	bmis	dest_op_ck	|if so, some op needs to be fixed
	rts

dest_op_ck:
	btstb	#7,DTAG(%a6)	|check for unsupported data types in
	beqs	src_op_ck	|the destination, if not, check src op
	bsr	chk_dy_mo	|set dyadic/monadic flag
	tstb	DY_MO_FLG(%a6)	|
	beqs	src_op_ck	|if monadic, check src op
|
| At this point, destination has an extended denorm or unnorm.
|
dst_ex_dnrm:
	movew	FPTEMP_EX(%a6),%d0 |get destination exponent
	andiw	#0x7fff,%d0	|mask sign, check if exp = 0000
	beqs	src_op_ck	|if denorm then check source op.
|				;denorms are taken care of in res_func
|				;(unsupp) or do_func (unimp)
|				;else unnorm fall through
	leal	FPTEMP(%a6),%a0	|point a0 to dop - used in mk_norm
	bsr	mk_norm		|go normalize - mk_norm returns:
|				;L_SCR1{7:5} = operand tag
|				;	(000 = norm, 100 = denorm)
|				;L_SCR1{4} = fpte15 or ete15
|				;	0 = exp >  $3fff
|				;	1 = exp <= $3fff
|				;and puts the normalized num back
|				;on the fsave stack
|
	moveb L_SCR1(%a6),DTAG(%a6) |write the new tag & fpte15
|				;to the fsave stack and fall
|				;through to check source operand
|
src_op_ck:
	btstb	#7,STAG(%a6)
	beq	end_getop	|check for unsupported data types on the
|				;source operand
	btstb	#5,STAG(%a6)
	bnes	src_sd_dnrm	|if bit 5 set, handle sgl/dbl denorms
|
| At this point only unnorms or extended denorms are possible.
|
src_ex_dnrm:
	movew	ETEMP_EX(%a6),%d0 |get source exponent
	andiw	#0x7fff,%d0	|mask sign, check if exp = 0000
	beq	end_getop	|if denorm then exit, denorms are
|				;handled in do_func
	leal	ETEMP(%a6),%a0	|point a0 to sop - used in mk_norm
	bsr	mk_norm		|go normalize - mk_norm returns:
|				;L_SCR1{7:5} = operand tag
|				;	(000 = norm, 100 = denorm)
|				;L_SCR1{4} = fpte15 or ete15
|				;	0 = exp >  $3fff
|				;	1 = exp <= $3fff
|				;and puts the normalized num back
|				;on the fsave stack
|
	moveb	L_SCR1(%a6),STAG(%a6) |write the new tag & ete15
	rts			|end_getop

|
| At this point, only single or double denorms are possible.
| If the inst is not fmove, normalize the source.  If it is,
| do nothing to the input.
|
src_sd_dnrm:
	btstb	#4,CMDREG1B(%a6)	|differentiate between sgl/dbl denorm
	bnes	is_double
is_single:
	movew	#0x3f81,%d1	|write bias for sgl denorm
	bras	common		|goto the common code
is_double:
	movew	#0x3c01,%d1	|write the bias for a dbl denorm
common:
	btstb	#sign_bit,ETEMP_EX(%a6) |grab sign bit of mantissa
	beqs	pos
	bset	#15,%d1		|set sign bit because it is negative
pos:
	movew	%d1,ETEMP_EX(%a6)
|				;put exponent on stack

	movew	CMDREG1B(%a6),%d1
	andw	#0xe3ff,%d1	|clear out source specifier
	orw	#0x0800,%d1	|set source specifier to extended prec
	movew	%d1,CMDREG1B(%a6)	|write back to the command word in stack
|				;this is needed to fix unsupp data stack
	leal	ETEMP(%a6),%a0	|point a0 to sop

	bsr	mk_norm		|convert sgl/dbl denorm to norm
	moveb	L_SCR1(%a6),STAG(%a6) |put tag into source tag reg - d0
	rts			|end_getop
|
| At this point, the source is definitely packed, whether
| instruction is dyadic or monadic is still unknown
|
pack_source:
	movel	FPTEMP_LO(%a6),ETEMP(%a6)	|write ms part of packed
|				;number to etemp slot
	bsr	chk_dy_mo	|set dyadic/monadic flag
	bsr	unpack

	tstb	DY_MO_FLG(%a6)
	beqs	end_getop	|if monadic, exit
|				;else, fix FPTEMP
pack_dya:
	bfextu	CMDREG1B(%a6){#6:#3},%d0 |extract dest fp reg
	movel	#7,%d1
	subl	%d0,%d1
	clrl	%d0
	bsetl	%d1,%d0		|set up d0 as a dynamic register mask
	fmovemx %d0,FPTEMP(%a6)	|write to FPTEMP

	btstb	#7,DTAG(%a6)	|check dest tag for unnorm or denorm
	bne	dst_ex_dnrm	|else, handle the unnorm or ext denorm
|
| Dest is not denormalized.  Check for norm, and set fpte15
| accordingly.
|
	moveb	DTAG(%a6),%d0
	andib	#0xf0,%d0		|strip to only dtag:fpte15
	tstb	%d0		|check for normalized value
	bnes	end_getop	|if inf/nan/zero leave get_op
	movew	FPTEMP_EX(%a6),%d0
	andiw	#0x7fff,%d0
	cmpiw	#0x3fff,%d0	|check if fpte15 needs setting
	bges	end_getop	|if >= $3fff, leave fpte15=0
	orb	#0x10,DTAG(%a6)
	bras	end_getop

|
| At this point, it is either an fmoveout packed, unnorm or denorm
|
opclass3:
	clrb	DY_MO_FLG(%a6)	|set dyadic/monadic flag to monadic
	bfextu	CMDREG1B(%a6){#4:#2},%d0
	cmpib	#3,%d0
	bne	src_ex_dnrm	|if not equal, must be unnorm or denorm
|				;else it is a packed move out
|				;exit
end_getop:
	rts

|
| Sets the DY_MO_FLG correctly. This is used only on if it is an
| unsupported data type exception.  Set if dyadic.
|
chk_dy_mo:
	movew	CMDREG1B(%a6),%d0
	btstl	#5,%d0		|testing extension command word
	beqs	set_mon		|if bit 5 = 0 then monadic
	btstl	#4,%d0		|know that bit 5 = 1
	beqs	set_dya		|if bit 4 = 0 then dyadic
	andiw	#0x007f,%d0	|get rid of all but extension bits {6:0}
	cmpiw	#0x0038,%d0	|if extension = $38 then fcmp (dyadic)
	bnes	set_mon
set_dya:
	st	DY_MO_FLG(%a6)	|set the inst flag type to dyadic
	rts
set_mon:
	clrb	DY_MO_FLG(%a6)	|set the inst flag type to monadic
	rts
|
|	MK_NORM
|
| Normalizes unnormalized numbers, sets tag to norm or denorm, sets unfl
| exception if denorm.
|
| CASE opclass 0x0 unsupp
|	mk_norm till msb set
|	set tag = norm
|
| CASE opclass 0x0 unimp
|	mk_norm till msb set or exp = 0
|	if integer bit = 0
|	   tag = denorm
|	else
|	   tag = norm
|
| CASE opclass 011 unsupp
|	mk_norm till msb set or exp = 0
|	if integer bit = 0
|	   tag = denorm
|	   set unfl_nmcexe = 1
|	else
|	   tag = norm
|
| if exp <= $3fff
|   set ete15 or fpte15 = 1
| else set ete15 or fpte15 = 0

| input:
|	a0 = points to operand to be normalized
| output:
|	L_SCR1{7:5} = operand tag (000 = norm, 100 = denorm)
|	L_SCR1{4}   = fpte15 or ete15 (0 = exp > $3fff, 1 = exp <=$3fff)
|	the normalized operand is placed back on the fsave stack
mk_norm:
	clrl	L_SCR1(%a6)
	bclrb	#sign_bit,LOCAL_EX(%a0)
	sne	LOCAL_SGN(%a0)	|transform into internal extended format

	cmpib	#0x2c,1+EXC_VEC(%a6) |check if unimp
	bnes	uns_data	|branch if unsupp
	bsr	uni_inst	|call if unimp (opclass 0x0)
	bras	reload
uns_data:
	btstb	#direction_bit,CMDREG1B(%a6) |check transfer direction
	bnes	bit_set		|branch if set (opclass 011)
	bsr	uns_opx		|call if opclass 0x0
	bras	reload
bit_set:
	bsr	uns_op3		|opclass 011
reload:
	cmpw	#0x3fff,LOCAL_EX(%a0) |if exp > $3fff
	bgts	end_mk		|   fpte15/ete15 already set to 0
	bsetb	#4,L_SCR1(%a6)	|else set fpte15/ete15 to 1
|				;calling routine actually sets the
|				;value on the stack (along with the
|				;tag), since this routine doesn't
|				;know if it should set ete15 or fpte15
|				;ie, it doesn't know if this is the
|				;src op or dest op.
end_mk:
	bfclr	LOCAL_SGN(%a0){#0:#8}
	beqs	end_mk_pos
	bsetb	#sign_bit,LOCAL_EX(%a0) |convert back to IEEE format
end_mk_pos:
	rts
|
|     CASE opclass 011 unsupp
|
uns_op3:
	bsr	nrm_zero	|normalize till msb = 1 or exp = zero
	btstb	#7,LOCAL_HI(%a0)	|if msb = 1
	bnes	no_unfl		|then branch
set_unfl:
	orw	#dnrm_tag,L_SCR1(%a6) |set denorm tag
	bsetb	#unfl_bit,FPSR_EXCEPT(%a6) |set unfl exception bit
no_unfl:
	rts
|
|     CASE opclass 0x0 unsupp
|
uns_opx:
	bsr	nrm_zero	|normalize the number
	btstb	#7,LOCAL_HI(%a0)	|check if integer bit (j-bit) is set
	beqs	uns_den		|if clear then now have a denorm
uns_nrm:
	orb	#norm_tag,L_SCR1(%a6) |set tag to norm
	rts
uns_den:
	orb	#dnrm_tag,L_SCR1(%a6) |set tag to denorm
	rts
|
|     CASE opclass 0x0 unimp
|
uni_inst:
	bsr	nrm_zero
	btstb	#7,LOCAL_HI(%a0)	|check if integer bit (j-bit) is set
	beqs	uni_den		|if clear then now have a denorm
uni_nrm:
	orb	#norm_tag,L_SCR1(%a6) |set tag to norm
	rts
uni_den:
	orb	#dnrm_tag,L_SCR1(%a6) |set tag to denorm
	rts

|
|	Decimal to binary conversion
|
| Special cases of inf and NaNs are completed outside of decbin.
| If the input is an snan, the snan bit is not set.
|
| input:
|	ETEMP(a6)	- points to packed decimal string in memory
| output:
|	fp0	- contains packed string converted to extended precision
|	ETEMP	- same as fp0
unpack:
	movew	CMDREG1B(%a6),%d0	|examine command word, looking for fmove's
	andw	#0x3b,%d0
	beq	move_unpack	|special handling for fmove: must set FPSR_CC

	movew	ETEMP(%a6),%d0	|get word with inf information
	bfextu	%d0{#20:#12},%d1	|get exponent into d1
	cmpiw	#0x0fff,%d1	|test for inf or NaN
	bnes	try_zero	|if not equal, it is not special
	bfextu	%d0{#17:#3},%d1	|get SE and y bits into d1
	cmpiw	#7,%d1		|SE and y bits must be on for special
	bnes	try_zero	|if not on, it is not special
|input is of the special cases of inf and NaN
	tstl	ETEMP_HI(%a6)	|check ms mantissa
	bnes	fix_nan		|if non-zero, it is a NaN
	tstl	ETEMP_LO(%a6)	|check ls mantissa
	bnes	fix_nan		|if non-zero, it is a NaN
	bra	finish		|special already on stack
fix_nan:
	btstb	#signan_bit,ETEMP_HI(%a6) |test for snan
	bne	finish
	orl	#snaniop_mask,USER_FPSR(%a6) |always set snan if it is so
	bra	finish
try_zero:
	movew	ETEMP_EX+2(%a6),%d0 |get word 4
	andiw	#0x000f,%d0	|clear all but last ni(y)bble
	tstw	%d0		|check for zero.
	bne	not_spec
	tstl	ETEMP_HI(%a6)	|check words 3 and 2
	bne	not_spec
	tstl	ETEMP_LO(%a6)	|check words 1 and 0
	bne	not_spec
	tstl	ETEMP(%a6)	|test sign of the zero
	bges	pos_zero
	movel	#0x80000000,ETEMP(%a6) |write neg zero to etemp
	clrl	ETEMP_HI(%a6)
	clrl	ETEMP_LO(%a6)
	bra	finish
pos_zero:
	clrl	ETEMP(%a6)
	clrl	ETEMP_HI(%a6)
	clrl	ETEMP_LO(%a6)
	bra	finish

not_spec:
	fmovemx %fp0-%fp1,-(%a7)	|save fp0 - decbin returns in it
	bsr	decbin
	fmovex %fp0,ETEMP(%a6)	|put the unpacked sop in the fsave stack
	fmovemx (%a7)+,%fp0-%fp1
	fmovel	#0,%FPSR		|clr fpsr from decbin
	bra	finish

|
| Special handling for packed move in:  Same results as all other
| packed cases, but we must set the FPSR condition codes properly.
|
move_unpack:
	movew	ETEMP(%a6),%d0	|get word with inf information
	bfextu	%d0{#20:#12},%d1	|get exponent into d1
	cmpiw	#0x0fff,%d1	|test for inf or NaN
	bnes	mtry_zero	|if not equal, it is not special
	bfextu	%d0{#17:#3},%d1	|get SE and y bits into d1
	cmpiw	#7,%d1		|SE and y bits must be on for special
	bnes	mtry_zero	|if not on, it is not special
|input is of the special cases of inf and NaN
	tstl	ETEMP_HI(%a6)	|check ms mantissa
	bnes	mfix_nan		|if non-zero, it is a NaN
	tstl	ETEMP_LO(%a6)	|check ls mantissa
	bnes	mfix_nan		|if non-zero, it is a NaN
|input is inf
	orl	#inf_mask,USER_FPSR(%a6) |set I bit
	tstl	ETEMP(%a6)	|check sign
	bge	finish
	orl	#neg_mask,USER_FPSR(%a6) |set N bit
	bra	finish		|special already on stack
mfix_nan:
	orl	#nan_mask,USER_FPSR(%a6) |set NaN bit
	moveb	#nan_tag,STAG(%a6)	|set stag to NaN
	btstb	#signan_bit,ETEMP_HI(%a6) |test for snan
	bnes	mn_snan
	orl	#snaniop_mask,USER_FPSR(%a6) |set snan bit
	btstb	#snan_bit,FPCR_ENABLE(%a6) |test for snan enabled
	bnes	mn_snan
	bsetb	#signan_bit,ETEMP_HI(%a6) |force snans to qnans
mn_snan:
	tstl	ETEMP(%a6)	|check for sign
	bge	finish		|if clr, go on
	orl	#neg_mask,USER_FPSR(%a6) |set N bit
	bra	finish

mtry_zero:
	movew	ETEMP_EX+2(%a6),%d0 |get word 4
	andiw	#0x000f,%d0	|clear all but last ni(y)bble
	tstw	%d0		|check for zero.
	bnes	mnot_spec
	tstl	ETEMP_HI(%a6)	|check words 3 and 2
	bnes	mnot_spec
	tstl	ETEMP_LO(%a6)	|check words 1 and 0
	bnes	mnot_spec
	tstl	ETEMP(%a6)	|test sign of the zero
	bges	mpos_zero
	orl	#neg_mask+z_mask,USER_FPSR(%a6) |set N and Z
	movel	#0x80000000,ETEMP(%a6) |write neg zero to etemp
	clrl	ETEMP_HI(%a6)
	clrl	ETEMP_LO(%a6)
	bras	finish
mpos_zero:
	orl	#z_mask,USER_FPSR(%a6) |set Z
	clrl	ETEMP(%a6)
	clrl	ETEMP_HI(%a6)
	clrl	ETEMP_LO(%a6)
	bras	finish

mnot_spec:
	fmovemx %fp0-%fp1,-(%a7)	|save fp0 ,fp1 - decbin returns in fp0
	bsr	decbin
	fmovex %fp0,ETEMP(%a6)
|				;put the unpacked sop in the fsave stack
	fmovemx (%a7)+,%fp0-%fp1

finish:
	movew	CMDREG1B(%a6),%d0	|get the command word
	andw	#0xfbff,%d0	|change the source specifier field to
|				;extended (was packed).
	movew	%d0,CMDREG1B(%a6)	|write command word back to fsave stack
|				;we need to do this so the 040 will
|				;re-execute the inst. without taking
|				;another packed trap.

fix_stag:
|Converted result is now in etemp on fsave stack, now set the source
|tag (stag)
|	if (ete =$7fff) then INF or NAN
|		if (etemp = $x.0----0) then
|			stag = INF
|		else
|			stag = NAN
|	else
|		if (ete = $0000) then
|			stag = ZERO
|		else
|			stag = NORM
|
| Note also that the etemp_15 bit (just right of the stag) must
| be set accordingly.
|
	movew		ETEMP_EX(%a6),%d1
	andiw		#0x7fff,%d1   |strip sign
	cmpw		#0x7fff,%d1
	bnes		z_or_nrm
	movel		ETEMP_HI(%a6),%d1
	bnes		is_nan
	movel		ETEMP_LO(%a6),%d1
	bnes		is_nan
is_inf:
	moveb		#0x40,STAG(%a6)
	movel		#0x40,%d0
	rts
is_nan:
	moveb		#0x60,STAG(%a6)
	movel		#0x60,%d0
	rts
z_or_nrm:
	tstw		%d1
	bnes		is_nrm
is_zro:
| For a zero, set etemp_15
	moveb		#0x30,STAG(%a6)
	movel		#0x20,%d0
	rts
is_nrm:
| For a norm, check if the exp <= $3fff; if so, set etemp_15
	cmpiw		#0x3fff,%d1
	bles		set_bit15
	moveb		#0,STAG(%a6)
	bras		end_is_nrm
set_bit15:
	moveb		#0x10,STAG(%a6)
end_is_nrm:
	movel		#0,%d0
end_fix:
	rts

end_get:
	rts
	|end