Quelle  reg_u_mul.S   Sprache: Sparc

/* SPDX-License-Identifier: GPL-2.0 */
 .file "reg_u_mul.S"
/*---------------------------------------------------------------------------+
 |  reg_u_mul.S                                                              |
 |                                                                           |
 | Core multiplication routine                                               |
 |                                                                           |
 | Copyright (C) 1992,1993,1995,1997                                         |
 |                  W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia |
 |                  E-mail   billm@suburbia.net                              |
 |                                                                           |
 |                                                                           |
 +---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------+
 |   Basic multiplication routine.                                           |
 |   Does not check the resulting exponent for overflow/underflow            |
 |                                                                           |
 |   FPU_u_mul(FPU_REG *a, FPU_REG *b, FPU_REG *c, unsigned int cw);         |
 |                                                                           |
 |   Internal working is at approx 128 bits.                                 |
 |   Result is rounded to nearest 53 or 64 bits, using "nearest or even".    |
 +---------------------------------------------------------------------------*/

#include "exception.h"
#include "fpu_emu.h"
#include "control_w.h"



#ifndef NON_REENTRANT_FPU
/*  Local storage on the stack: */
#define FPU_accum_0 -4(%ebp) /* ms word */
#define FPU_accum_1 -8(%ebp)

#else
/*  Local storage in a static area: */
.data
 .align 4,0
FPU_accum_0:
 .long 0
FPU_accum_1:
 .long 0
#endif /* NON_REENTRANT_FPU */


.text
SYM_FUNC_START(FPU_u_mul)
 pushl %ebp
 movl %esp,%ebp
#ifndef NON_REENTRANT_FPU
 subl $8,%esp
#endif /* NON_REENTRANT_FPU */ 

 pushl %esi
 pushl %edi
 pushl %ebx

 movl PARAM1,%esi
 movl PARAM2,%edi

#ifdef PARANOID
 testl $0x80000000,SIGH(%esi)
 jz L_bugged
 testl $0x80000000,SIGH(%edi)
 jz L_bugged
#endif /* PARANOID */

 xorl %ecx,%ecx
 xorl %ebx,%ebx

 movl SIGL(%esi),%eax
 mull SIGL(%edi)
 movl %eax,FPU_accum_0
 movl %edx,FPU_accum_1

 movl SIGL(%esi),%eax
 mull SIGH(%edi)
 addl %eax,FPU_accum_1
 adcl %edx,%ebx
/* adcl $0,%ecx // overflow here is not possible */

 movl SIGH(%esi),%eax
 mull SIGL(%edi)
 addl %eax,FPU_accum_1
 adcl %edx,%ebx
 adcl $0,%ecx

 movl SIGH(%esi),%eax
 mull SIGH(%edi)
 addl %eax,%ebx
 adcl %edx,%ecx

 /* Get the sum of the exponents. */
 movl PARAM6,%eax
 subl EXP_BIAS-1,%eax

 /* Two denormals can cause an exponent underflow */
 cmpl EXP_WAY_UNDER,%eax
 jg Exp_not_underflow

 /* Set to a really low value allow correct handling */
 movl EXP_WAY_UNDER,%eax

Exp_not_underflow:

/*  Have now finished with the sources */
 movl PARAM3,%edi /* Point to the destination */
 movw %ax,EXP(%edi)

/*  Now make sure that the result is normalized */
 testl $0x80000000,%ecx
 jnz LResult_Normalised

 /* Normalize by shifting left one bit */
 shll $1,FPU_accum_0
 rcll $1,FPU_accum_1
 rcll $1,%ebx
 rcll $1,%ecx
 decw EXP(%edi)

LResult_Normalised:
 movl FPU_accum_0,%eax
 movl FPU_accum_1,%edx
 orl %eax,%eax
 jz L_extent_zero

 orl $1,%edx

L_extent_zero:
 movl %ecx,%eax
 jmp fpu_reg_round


#ifdef PARANOID
L_bugged:
 pushl EX_INTERNAL|0x205
 call EXCEPTION
 pop %ebx
 jmp L_exit

L_exit:
 popl %ebx
 popl %edi
 popl %esi
 leave
 RET
#endif /* PARANOID */ 

SYM_FUNC_END(FPU_u_mul)