|
  |	do_func.sa 3.4 2/18/91
  |
  | Do_func performs the unimplemented operation.  The operation
  | to be performed is determined from the lower 7 bits of the
  | extension word (except in the case of fmovecr and fsincos).
  | The opcode and tag bits form an index into a jump table in
  | tbldo.sa.  Cases of zero, infinity and NaN are handled in
  | do_func by forcing the default result.  Normalized and
  | denormalized (there are no unnormalized numbers at this
  | point) are passed onto the emulation code.
  |
  | CMDREG1B and STAG are extracted from the fsave frame
  | and combined to form the table index.  The function called
  | will start with a0 pointing to the ETEMP operand.  Dyadic
  | functions can find FPTEMP at -12(a0).
  |
  | Called functions return their result in fp0.  Sincos returns
  | sin(x) in fp0 and cos(x) in fp1.
  |
  
  |		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.
  
  DO_FUNC:	|idnt    2,1 | Motorola 040 Floating Point Software Package
  
  	|section	8
  
  #include "fpsp.h"
  
  	|xref	t_dz2
  	|xref	t_operr
  	|xref	t_inx2
  	|xref	t_resdnrm
  	|xref	dst_nan
  	|xref	src_nan
  	|xref	nrm_set
  	|xref	sto_cos
  
  	|xref	tblpre
  	|xref	slognp1,slogn,slog10,slog2
  	|xref	slognd,slog10d,slog2d
  	|xref	smod,srem
  	|xref	sscale
  	|xref	smovcr
  
  PONE:	.long	0x3fff0000,0x80000000,0x00000000	|+1
  MONE:	.long	0xbfff0000,0x80000000,0x00000000	|-1
  PZERO:	.long	0x00000000,0x00000000,0x00000000	|+0
  MZERO:	.long	0x80000000,0x00000000,0x00000000	|-0
  PINF:	.long	0x7fff0000,0x00000000,0x00000000	|+inf
  MINF:	.long	0xffff0000,0x00000000,0x00000000	|-inf
  QNAN:	.long	0x7fff0000,0xffffffff,0xffffffff	|non-signaling nan
  PPIBY2:  .long	0x3FFF0000,0xC90FDAA2,0x2168C235	|+PI/2
  MPIBY2:  .long	0xbFFF0000,0xC90FDAA2,0x2168C235	|-PI/2
  
  	.global	do_func
  do_func:
  	clrb	CU_ONLY(%a6)
  |
  | Check for fmovecr.  It does not follow the format of fp gen
  | unimplemented instructions.  The test is on the upper 6 bits;
  | if they are $17, the inst is fmovecr.  Call entry smovcr
  | directly.
  |
  	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
  	bnes	not_fmovecr
  	jmp	smovcr		|fmovecr; jmp directly to emulation
  
  not_fmovecr:
  	movew	CMDREG1B(%a6),%d0
  	andl	#0x7F,%d0
  	cmpil	#0x38,%d0		|if the extension is >= $38,
  	bge	serror		|it is illegal
  	bfextu	STAG(%a6){#0:#3},%d1
  	lsll	#3,%d0		|make room for STAG
  	addl	%d1,%d0		|combine for final index into table
  	leal	tblpre,%a1	|start of monster jump table
  	movel	(%a1,%d0.w*4),%a1	|real target address
  	leal	ETEMP(%a6),%a0	|a0 is pointer to src op
  	movel	USER_FPCR(%a6),%d1
  	andl	#0xFF,%d1		| discard all but rounding mode/prec
  	fmovel	#0,%fpcr
  	jmp	(%a1)
  |
  |	ERROR
  |
  	.global	serror
  serror:
  	st	STORE_FLG(%a6)
  	rts
  |
  | These routines load forced values into fp0.  They are called
  | by index into tbldo.
  |
  | Load a signed zero to fp0 and set inex2/ainex
  |
  	.global	snzrinx
  snzrinx:
  	btstb	#sign_bit,LOCAL_EX(%a0)	|get sign of source operand
  	bnes	ld_mzinx	|if negative, branch
  	bsr	ld_pzero	|bsr so we can return and set inx
  	bra	t_inx2		|now, set the inx for the next inst
  ld_mzinx:
  	bsr	ld_mzero	|if neg, load neg zero, return here
  	bra	t_inx2		|now, set the inx for the next inst
  |
  | Load a signed zero to fp0; do not set inex2/ainex
  |
  	.global	szero
  szero:
  	btstb	#sign_bit,LOCAL_EX(%a0) |get sign of source operand
  	bne	ld_mzero	|if neg, load neg zero
  	bra	ld_pzero	|load positive zero
  |
  | Load a signed infinity to fp0; do not set inex2/ainex
  |
  	.global	sinf
  sinf:
  	btstb	#sign_bit,LOCAL_EX(%a0)	|get sign of source operand
  	bne	ld_minf			|if negative branch
  	bra	ld_pinf
  |
  | Load a signed one to fp0; do not set inex2/ainex
  |
  	.global	sone
  sone:
  	btstb	#sign_bit,LOCAL_EX(%a0)	|check sign of source
  	bne	ld_mone
  	bra	ld_pone
  |
  | Load a signed pi/2 to fp0; do not set inex2/ainex
  |
  	.global	spi_2
  spi_2:
  	btstb	#sign_bit,LOCAL_EX(%a0)	|check sign of source
  	bne	ld_mpi2
  	bra	ld_ppi2
  |
  | Load either a +0 or +inf for plus/minus operand
  |
  	.global	szr_inf
  szr_inf:
  	btstb	#sign_bit,LOCAL_EX(%a0)	|check sign of source
  	bne	ld_pzero
  	bra	ld_pinf
  |
  | Result is either an operr or +inf for plus/minus operand
  | [Used by slogn, slognp1, slog10, and slog2]
  |
  	.global	sopr_inf
  sopr_inf:
  	btstb	#sign_bit,LOCAL_EX(%a0)	|check sign of source
  	bne	t_operr
  	bra	ld_pinf
  |
  |	FLOGNP1
  |
  	.global	sslognp1
  sslognp1:
  	fmovemx (%a0),%fp0-%fp0
  	fcmpb	#-1,%fp0
  	fbgt	slognp1
  	fbeq	t_dz2		|if = -1, divide by zero exception
  	fmovel	#0,%FPSR		|clr N flag
  	bra	t_operr		|take care of operands < -1
  |
  |	FETOXM1
  |
  	.global	setoxm1i
  setoxm1i:
  	btstb	#sign_bit,LOCAL_EX(%a0)	|check sign of source
  	bne	ld_mone
  	bra	ld_pinf
  |
  |	FLOGN
  |
  | Test for 1.0 as an input argument, returning +zero.  Also check
  | the sign and return operr if negative.
  |
  	.global	sslogn
  sslogn:
  	btstb	#sign_bit,LOCAL_EX(%a0)
  	bne	t_operr		|take care of operands < 0
  	cmpiw	#0x3fff,LOCAL_EX(%a0) |test for 1.0 input
  	bne	slogn
  	cmpil	#0x80000000,LOCAL_HI(%a0)
  	bne	slogn
  	tstl	LOCAL_LO(%a0)
  	bne	slogn
  	fmovex	PZERO,%fp0
  	rts
  
  	.global	sslognd
  sslognd:
  	btstb	#sign_bit,LOCAL_EX(%a0)
  	beq	slognd
  	bra	t_operr		|take care of operands < 0
  
  |
  |	FLOG10
  |
  	.global	sslog10
  sslog10:
  	btstb	#sign_bit,LOCAL_EX(%a0)
  	bne	t_operr		|take care of operands < 0
  	cmpiw	#0x3fff,LOCAL_EX(%a0) |test for 1.0 input
  	bne	slog10
  	cmpil	#0x80000000,LOCAL_HI(%a0)
  	bne	slog10
  	tstl	LOCAL_LO(%a0)
  	bne	slog10
  	fmovex	PZERO,%fp0
  	rts
  
  	.global	sslog10d
  sslog10d:
  	btstb	#sign_bit,LOCAL_EX(%a0)
  	beq	slog10d
  	bra	t_operr		|take care of operands < 0
  
  |
  |	FLOG2
  |
  	.global	sslog2
  sslog2:
  	btstb	#sign_bit,LOCAL_EX(%a0)
  	bne	t_operr		|take care of operands < 0
  	cmpiw	#0x3fff,LOCAL_EX(%a0) |test for 1.0 input
  	bne	slog2
  	cmpil	#0x80000000,LOCAL_HI(%a0)
  	bne	slog2
  	tstl	LOCAL_LO(%a0)
  	bne	slog2
  	fmovex	PZERO,%fp0
  	rts
  
  	.global	sslog2d
  sslog2d:
  	btstb	#sign_bit,LOCAL_EX(%a0)
  	beq	slog2d
  	bra	t_operr		|take care of operands < 0
  
  |
  |	FMOD
  |
  pmodt:
  |				;$21 fmod
  |				;dtag,stag
  	.long	smod		|  00,00  norm,norm = normal
  	.long	smod_oper	|  00,01  norm,zero = nan with operr
  	.long	smod_fpn	|  00,10  norm,inf  = fpn
  	.long	smod_snan	|  00,11  norm,nan  = nan
  	.long	smod_zro	|  01,00  zero,norm = +-zero
  	.long	smod_oper	|  01,01  zero,zero = nan with operr
  	.long	smod_zro	|  01,10  zero,inf  = +-zero
  	.long	smod_snan	|  01,11  zero,nan  = nan
  	.long	smod_oper	|  10,00  inf,norm  = nan with operr
  	.long	smod_oper	|  10,01  inf,zero  = nan with operr
  	.long	smod_oper	|  10,10  inf,inf   = nan with operr
  	.long	smod_snan	|  10,11  inf,nan   = nan
  	.long	smod_dnan	|  11,00  nan,norm  = nan
  	.long	smod_dnan	|  11,01  nan,zero  = nan
  	.long	smod_dnan	|  11,10  nan,inf   = nan
  	.long	smod_dnan	|  11,11  nan,nan   = nan
  
  	.global	pmod
  pmod:
  	clrb	FPSR_QBYTE(%a6) | clear quotient field
  	bfextu	STAG(%a6){#0:#3},%d0 |stag = d0
  	bfextu	DTAG(%a6){#0:#3},%d1 |dtag = d1
  
  |
  | Alias extended denorms to norms for the jump table.
  |
  	bclrl	#2,%d0
  	bclrl	#2,%d1
  
  	lslb	#2,%d1
  	orb	%d0,%d1		|d1{3:2} = dtag, d1{1:0} = stag
  |				;Tag values:
  |				;00 = norm or denorm
  |				;01 = zero
  |				;10 = inf
  |				;11 = nan
  	lea	pmodt,%a1
  	movel	(%a1,%d1.w*4),%a1
  	jmp	(%a1)
  
  smod_snan:
  	bra	src_nan
  smod_dnan:
  	bra	dst_nan
  smod_oper:
  	bra	t_operr
  smod_zro:
  	moveb	ETEMP(%a6),%d1	|get sign of src op
  	moveb	FPTEMP(%a6),%d0	|get sign of dst op
  	eorb	%d0,%d1		|get exor of sign bits
  	btstl	#7,%d1		|test for sign
  	beqs	smod_zsn	|if clr, do not set sign big
  	bsetb	#q_sn_bit,FPSR_QBYTE(%a6) |set q-byte sign bit
  smod_zsn:
  	btstl	#7,%d0		|test if + or -
  	beq	ld_pzero	|if pos then load +0
  	bra	ld_mzero	|else neg load -0
  
  smod_fpn:
  	moveb	ETEMP(%a6),%d1	|get sign of src op
  	moveb	FPTEMP(%a6),%d0	|get sign of dst op
  	eorb	%d0,%d1		|get exor of sign bits
  	btstl	#7,%d1		|test for sign
  	beqs	smod_fsn	|if clr, do not set sign big
  	bsetb	#q_sn_bit,FPSR_QBYTE(%a6) |set q-byte sign bit
  smod_fsn:
  	tstb	DTAG(%a6)	|filter out denormal destination case
  	bpls	smod_nrm	|
  	leal	FPTEMP(%a6),%a0	|a0<- addr(FPTEMP)
  	bra	t_resdnrm	|force UNFL(but exact) result
  smod_nrm:
  	fmovel USER_FPCR(%a6),%fpcr |use user's rmode and precision
  	fmovex FPTEMP(%a6),%fp0	|return dest to fp0
  	rts
  
  |
  |	FREM
  |
  premt:
  |				;$25 frem
  |				;dtag,stag
  	.long	srem		|  00,00  norm,norm = normal
  	.long	srem_oper	|  00,01  norm,zero = nan with operr
  	.long	srem_fpn	|  00,10  norm,inf  = fpn
  	.long	srem_snan	|  00,11  norm,nan  = nan
  	.long	srem_zro	|  01,00  zero,norm = +-zero
  	.long	srem_oper	|  01,01  zero,zero = nan with operr
  	.long	srem_zro	|  01,10  zero,inf  = +-zero
  	.long	srem_snan	|  01,11  zero,nan  = nan
  	.long	srem_oper	|  10,00  inf,norm  = nan with operr
  	.long	srem_oper	|  10,01  inf,zero  = nan with operr
  	.long	srem_oper	|  10,10  inf,inf   = nan with operr
  	.long	srem_snan	|  10,11  inf,nan   = nan
  	.long	srem_dnan	|  11,00  nan,norm  = nan
  	.long	srem_dnan	|  11,01  nan,zero  = nan
  	.long	srem_dnan	|  11,10  nan,inf   = nan
  	.long	srem_dnan	|  11,11  nan,nan   = nan
  
  	.global	prem
  prem:
  	clrb	FPSR_QBYTE(%a6)   |clear quotient field
  	bfextu	STAG(%a6){#0:#3},%d0 |stag = d0
  	bfextu	DTAG(%a6){#0:#3},%d1 |dtag = d1
  |
  | Alias extended denorms to norms for the jump table.
  |
  	bclr	#2,%d0
  	bclr	#2,%d1
  
  	lslb	#2,%d1
  	orb	%d0,%d1		|d1{3:2} = dtag, d1{1:0} = stag
  |				;Tag values:
  |				;00 = norm or denorm
  |				;01 = zero
  |				;10 = inf
  |				;11 = nan
  	lea	premt,%a1
  	movel	(%a1,%d1.w*4),%a1
  	jmp	(%a1)
  
  srem_snan:
  	bra	src_nan
  srem_dnan:
  	bra	dst_nan
  srem_oper:
  	bra	t_operr
  srem_zro:
  	moveb	ETEMP(%a6),%d1	|get sign of src op
  	moveb	FPTEMP(%a6),%d0	|get sign of dst op
  	eorb	%d0,%d1		|get exor of sign bits
  	btstl	#7,%d1		|test for sign
  	beqs	srem_zsn	|if clr, do not set sign big
  	bsetb	#q_sn_bit,FPSR_QBYTE(%a6) |set q-byte sign bit
  srem_zsn:
  	btstl	#7,%d0		|test if + or -
  	beq	ld_pzero	|if pos then load +0
  	bra	ld_mzero	|else neg load -0
  
  srem_fpn:
  	moveb	ETEMP(%a6),%d1	|get sign of src op
  	moveb	FPTEMP(%a6),%d0	|get sign of dst op
  	eorb	%d0,%d1		|get exor of sign bits
  	btstl	#7,%d1		|test for sign
  	beqs	srem_fsn	|if clr, do not set sign big
  	bsetb	#q_sn_bit,FPSR_QBYTE(%a6) |set q-byte sign bit
  srem_fsn:
  	tstb	DTAG(%a6)	|filter out denormal destination case
  	bpls	srem_nrm	|
  	leal	FPTEMP(%a6),%a0	|a0<- addr(FPTEMP)
  	bra	t_resdnrm	|force UNFL(but exact) result
  srem_nrm:
  	fmovel USER_FPCR(%a6),%fpcr |use user's rmode and precision
  	fmovex FPTEMP(%a6),%fp0	|return dest to fp0
  	rts
  |
  |	FSCALE
  |
  pscalet:
  |				;$26 fscale
  |				;dtag,stag
  	.long	sscale		|  00,00  norm,norm = result
  	.long	sscale		|  00,01  norm,zero = fpn
  	.long	scl_opr		|  00,10  norm,inf  = nan with operr
  	.long	scl_snan	|  00,11  norm,nan  = nan
  	.long	scl_zro		|  01,00  zero,norm = +-zero
  	.long	scl_zro		|  01,01  zero,zero = +-zero
  	.long	scl_opr		|  01,10  zero,inf  = nan with operr
  	.long	scl_snan	|  01,11  zero,nan  = nan
  	.long	scl_inf		|  10,00  inf,norm  = +-inf
  	.long	scl_inf		|  10,01  inf,zero  = +-inf
  	.long	scl_opr		|  10,10  inf,inf   = nan with operr
  	.long	scl_snan	|  10,11  inf,nan   = nan
  	.long	scl_dnan	|  11,00  nan,norm  = nan
  	.long	scl_dnan	|  11,01  nan,zero  = nan
  	.long	scl_dnan	|  11,10  nan,inf   = nan
  	.long	scl_dnan	|  11,11  nan,nan   = nan
  
  	.global	pscale
  pscale:
  	bfextu	STAG(%a6){#0:#3},%d0 |stag in d0
  	bfextu	DTAG(%a6){#0:#3},%d1 |dtag in d1
  	bclrl	#2,%d0		|alias  denorm into norm
  	bclrl	#2,%d1		|alias  denorm into norm
  	lslb	#2,%d1
  	orb	%d0,%d1		|d1{4:2} = dtag, d1{1:0} = stag
  |				;dtag values     stag values:
  |				;000 = norm      00 = norm
  |				;001 = zero	 01 = zero
  |				;010 = inf	 10 = inf
  |				;011 = nan	 11 = nan
  |				;100 = dnrm
  |
  |
  	leal	pscalet,%a1	|load start of jump table
  	movel	(%a1,%d1.w*4),%a1	|load a1 with label depending on tag
  	jmp	(%a1)		|go to the routine
  
  scl_opr:
  	bra	t_operr
  
  scl_dnan:
  	bra	dst_nan
  
  scl_zro:
  	btstb	#sign_bit,FPTEMP_EX(%a6)	|test if + or -
  	beq	ld_pzero		|if pos then load +0
  	bra	ld_mzero		|if neg then load -0
  scl_inf:
  	btstb	#sign_bit,FPTEMP_EX(%a6)	|test if + or -
  	beq	ld_pinf			|if pos then load +inf
  	bra	ld_minf			|else neg load -inf
  scl_snan:
  	bra	src_nan
  |
  |	FSINCOS
  |
  	.global	ssincosz
  ssincosz:
  	btstb	#sign_bit,ETEMP(%a6)	|get sign
  	beqs	sincosp
  	fmovex	MZERO,%fp0
  	bras	sincoscom
  sincosp:
  	fmovex PZERO,%fp0
  sincoscom:
  	fmovemx PONE,%fp1-%fp1	|do not allow FPSR to be affected
  	bra	sto_cos		|store cosine result
  
  	.global	ssincosi
  ssincosi:
  	fmovex QNAN,%fp1	|load NAN
  	bsr	sto_cos		|store cosine result
  	fmovex QNAN,%fp0	|load NAN
  	bra	t_operr
  
  	.global	ssincosnan
  ssincosnan:
  	movel	ETEMP_EX(%a6),FP_SCR1(%a6)
  	movel	ETEMP_HI(%a6),FP_SCR1+4(%a6)
  	movel	ETEMP_LO(%a6),FP_SCR1+8(%a6)
  	bsetb	#signan_bit,FP_SCR1+4(%a6)
  	fmovemx FP_SCR1(%a6),%fp1-%fp1
  	bsr	sto_cos
  	bra	src_nan
  |
  | This code forces default values for the zero, inf, and nan cases
  | in the transcendentals code.  The CC bits must be set in the
  | stacked FPSR to be correctly reported.
  |
  |**Returns +PI/2
  	.global	ld_ppi2
  ld_ppi2:
  	fmovex PPIBY2,%fp0		|load +pi/2
  	bra	t_inx2			|set inex2 exc
  
  |**Returns -PI/2
  	.global	ld_mpi2
  ld_mpi2:
  	fmovex MPIBY2,%fp0		|load -pi/2
  	orl	#neg_mask,USER_FPSR(%a6)	|set N bit
  	bra	t_inx2			|set inex2 exc
  
  |**Returns +inf
  	.global	ld_pinf
  ld_pinf:
  	fmovex PINF,%fp0		|load +inf
  	orl	#inf_mask,USER_FPSR(%a6)	|set I bit
  	rts
  
  |**Returns -inf
  	.global	ld_minf
  ld_minf:
  	fmovex MINF,%fp0		|load -inf
  	orl	#neg_mask+inf_mask,USER_FPSR(%a6)	|set N and I bits
  	rts
  
  |**Returns +1
  	.global	ld_pone
  ld_pone:
  	fmovex PONE,%fp0		|load +1
  	rts
  
  |**Returns -1
  	.global	ld_mone
  ld_mone:
  	fmovex MONE,%fp0		|load -1
  	orl	#neg_mask,USER_FPSR(%a6)	|set N bit
  	rts
  
  |**Returns +0
  	.global	ld_pzero
  ld_pzero:
  	fmovex PZERO,%fp0		|load +0
  	orl	#z_mask,USER_FPSR(%a6)	|set Z bit
  	rts
  
  |**Returns -0
  	.global	ld_mzero
  ld_mzero:
  	fmovex MZERO,%fp0		|load -0
  	orl	#neg_mask+z_mask,USER_FPSR(%a6)	|set N and Z bits
  	rts
  
  	|end