arch/arm26/lib/longlong.h - arm/linux - Git at Google


            
            /* longlong.h -- based on code from gcc-2.95.3


               definitions for mixed size 32/64 bit arithmetic.

            
               Copyright (C) 1991, 92, 94, 95, 96, 1997, 1998 Free Software Foundation, Inc.


               This definition file is free software; you can redistribute it

            
               and/or modify it under the terms of the GNU General Public

            
               License as published by the Free Software Foundation; either

            
               version 2, or (at your option) any later version.


               This definition file is distributed in the hope that it will be

            
               useful, but WITHOUT ANY WARRANTY; without even the implied

            
               warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

            
               See the GNU General Public License for more details.


               You should have received a copy of the GNU General Public License

            
               along with this program; if not, write to the Free Software

            
               Foundation, Inc., 59 Temple Place - Suite 330,

            
               Boston, MA 02111-1307, USA.  */


            /* Borrowed from GCC 2.95.3, I Molton 29/07/01 */


            #ifndef SI_TYPE_SIZE

            
            #define SI_TYPE_SIZE 32

            
            #endif


            #define __BITS4 (SI_TYPE_SIZE / 4)

            
            #define __ll_B (1L << (SI_TYPE_SIZE / 2))

            
            #define __ll_lowpart(t) ((USItype) (t) % __ll_B)

            
            #define __ll_highpart(t) ((USItype) (t) / __ll_B)


            /* Define auxiliary asm macros.


               1) umul_ppmm(high_prod, low_prod, multipler, multiplicand)

            
               multiplies two USItype integers MULTIPLER and MULTIPLICAND,

            
               and generates a two-part USItype product in HIGH_PROD and

            
               LOW_PROD.


               2) __umulsidi3(a,b) multiplies two USItype integers A and B,

            
               and returns a UDItype product.  This is just a variant of umul_ppmm.


               3) udiv_qrnnd(quotient, remainder, high_numerator, low_numerator,

            
               denominator) divides a two-word unsigned integer, composed by the

            
               integers HIGH_NUMERATOR and LOW_NUMERATOR, by DENOMINATOR and

            
               places the quotient in QUOTIENT and the remainder in REMAINDER.

            
               HIGH_NUMERATOR must be less than DENOMINATOR for correct operation.

            
               If, in addition, the most significant bit of DENOMINATOR must be 1,

            
               then the pre-processor symbol UDIV_NEEDS_NORMALIZATION is defined to 1.


               4) sdiv_qrnnd(quotient, remainder, high_numerator, low_numerator,

            
               denominator).  Like udiv_qrnnd but the numbers are signed.  The

            
               quotient is rounded towards 0.


               5) count_leading_zeros(count, x) counts the number of zero-bits from

            
               the msb to the first non-zero bit.  This is the number of steps X

            
               needs to be shifted left to set the msb.  Undefined for X == 0.


               6) add_ssaaaa(high_sum, low_sum, high_addend_1, low_addend_1,

            
               high_addend_2, low_addend_2) adds two two-word unsigned integers,

            
               composed by HIGH_ADDEND_1 and LOW_ADDEND_1, and HIGH_ADDEND_2 and

            
               LOW_ADDEND_2 respectively.  The result is placed in HIGH_SUM and

            
               LOW_SUM.  Overflow (i.e. carry out) is not stored anywhere, and is

            
               lost.


               7) sub_ddmmss(high_difference, low_difference, high_minuend,

            
               low_minuend, high_subtrahend, low_subtrahend) subtracts two

            
               two-word unsigned integers, composed by HIGH_MINUEND_1 and

            
               LOW_MINUEND_1, and HIGH_SUBTRAHEND_2 and LOW_SUBTRAHEND_2

            
               respectively.  The result is placed in HIGH_DIFFERENCE and

            
               LOW_DIFFERENCE.  Overflow (i.e. carry out) is not stored anywhere,

            
               and is lost.


               If any of these macros are left undefined for a particular CPU,

            
               C macros are used.  */


            #if defined (__arm__)

            
            #define add_ssaaaa(sh, sl, ah, al, bh, bl) \

            
              __asm__ ("adds	%1, %4, %5					\n\

            
            	adc	%0, %2, %3"						\

            
            	   : "=r" ((USItype) (sh)),					\

            
            	     "=&r" ((USItype) (sl))					\

            
            	   : "%r" ((USItype) (ah)),					\

            
            	     "rI" ((USItype) (bh)),					\

            
            	     "%r" ((USItype) (al)),					\

            
            	     "rI" ((USItype) (bl)))

            
            #define sub_ddmmss(sh, sl, ah, al, bh, bl) \

            
              __asm__ ("subs	%1, %4, %5					\n\

            
            	sbc	%0, %2, %3"						\

            
            	   : "=r" ((USItype) (sh)),					\

            
            	     "=&r" ((USItype) (sl))					\

            
            	   : "r" ((USItype) (ah)),					\

            
            	     "rI" ((USItype) (bh)),					\

            
            	     "r" ((USItype) (al)),					\

            
            	     "rI" ((USItype) (bl)))

            
            #define umul_ppmm(xh, xl, a, b) \

            
            {register USItype __t0, __t1, __t2;					\

            
              __asm__ ("%@ Inlined umul_ppmm					\n\

            
            	mov	%2, %5, lsr #16						\n\

            
            	mov	%0, %6, lsr #16						\n\

            
            	bic	%3, %5, %2, lsl #16					\n\

            
            	bic	%4, %6, %0, lsl #16					\n\

            
            	mul	%1, %3, %4						\n\

            
            	mul	%4, %2, %4						\n\

            
            	mul	%3, %0, %3						\n\

            
            	mul	%0, %2, %0						\n\

            
            	adds	%3, %4, %3						\n\

            
            	addcs	%0, %0, #65536						\n\

            
            	adds	%1, %1, %3, lsl #16					\n\

            
            	adc	%0, %0, %3, lsr #16"					\

            
            	   : "=&r" ((USItype) (xh)),					\

            
            	     "=r" ((USItype) (xl)),					\

            
            	     "=&r" (__t0), "=&r" (__t1), "=r" (__t2)			\

            
            	   : "r" ((USItype) (a)),					\

            
            	     "r" ((USItype) (b)));}

            
            #define UMUL_TIME 20

            
            #define UDIV_TIME 100

            
            #endif /* __arm__ */


            #define __umulsidi3(u, v) \

            
              ({DIunion __w;							\

            
                umul_ppmm (__w.s.high, __w.s.low, u, v);				\

            
                __w.ll; })


            #define __udiv_qrnnd_c(q, r, n1, n0, d) \

            
              do {									\

            
                USItype __d1, __d0, __q1, __q0;					\

            
                USItype __r1, __r0, __m;						\

            
                __d1 = __ll_highpart (d);						\

            
                __d0 = __ll_lowpart (d);						\

            
            									\

            
                __r1 = (n1) % __d1;							\

            
                __q1 = (n1) / __d1;							\

            
                __m = (USItype) __q1 * __d0;					\

            
                __r1 = __r1 * __ll_B | __ll_highpart (n0);				\

            
                if (__r1 < __m)							\

            
                  {									\

            
            	__q1--, __r1 += (d);						\

            
            	if (__r1 >= (d)) /* i.e. we didn't get carry when adding to __r1 */\

            
            	  if (__r1 < __m)						\

            
            	    __q1--, __r1 += (d);					\

            
                  }									\

            
                __r1 -= __m;							\

            
            									\

            
                __r0 = __r1 % __d1;							\

            
                __q0 = __r1 / __d1;							\

            
                __m = (USItype) __q0 * __d0;					\

            
                __r0 = __r0 * __ll_B | __ll_lowpart (n0);				\

            
                if (__r0 < __m)							\

            
                  {									\

            
            	__q0--, __r0 += (d);						\

            
            	if (__r0 >= (d))						\

            
            	  if (__r0 < __m)						\

            
            	    __q0--, __r0 += (d);					\

            
                  }									\

            
                __r0 -= __m;							\

            
            									\

            
                (q) = (USItype) __q1 * __ll_B | __q0;				\

            
                (r) = __r0;								\

            
              } while (0)


            #define UDIV_NEEDS_NORMALIZATION 1

            
            #define udiv_qrnnd __udiv_qrnnd_c


            extern const UQItype __clz_tab[];

            
            #define count_leading_zeros(count, x) \

            
              do {									\

            
                USItype __xr = (x);							\

            
                USItype __a;							\

            
            									\

            
                if (SI_TYPE_SIZE <= 32)						\

            
                  {									\

            
            	__a = __xr < ((USItype)1<<2*__BITS4)				\

            
            	  ? (__xr < ((USItype)1<<__BITS4) ? 0 : __BITS4)		\

            
            	  : (__xr < ((USItype)1<<3*__BITS4) ?  2*__BITS4 : 3*__BITS4);	\

            
                  }									\

            
                else								\

            
                  {									\

            
            	for (__a = SI_TYPE_SIZE - 8; __a > 0; __a -= 8)			\

            
            	  if (((__xr >> __a) & 0xff) != 0)				\

            
            	    break;							\

            
                  }									\

            
            									\

            
                (count) = SI_TYPE_SIZE - (__clz_tab[__xr >> __a] + __a);		\

            
              } while (0)
	/* longlong.h -- based on code from gcc-2.95.3

	definitions for mixed size 32/64 bit arithmetic.
	Copyright (C) 1991, 92, 94, 95, 96, 1997, 1998 Free Software Foundation, Inc.

	This definition file is free software; you can redistribute it
	and/or modify it under the terms of the GNU General Public
	License as published by the Free Software Foundation; either
	version 2, or (at your option) any later version.

	This definition file is distributed in the hope that it will be
	useful, but WITHOUT ANY WARRANTY; without even the implied
	warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	See the GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place - Suite 330,
	Boston, MA 02111-1307, USA. */

	/* Borrowed from GCC 2.95.3, I Molton 29/07/01 */

	#ifndef SI_TYPE_SIZE
	#define SI_TYPE_SIZE 32
	#endif

	#define __BITS4 (SI_TYPE_SIZE / 4)
	#define __ll_B (1L << (SI_TYPE_SIZE / 2))
	#define __ll_lowpart(t) ((USItype) (t) % __ll_B)
	#define __ll_highpart(t) ((USItype) (t) / __ll_B)

	/* Define auxiliary asm macros.

	1) umul_ppmm(high_prod, low_prod, multipler, multiplicand)
	multiplies two USItype integers MULTIPLER and MULTIPLICAND,
	and generates a two-part USItype product in HIGH_PROD and
	LOW_PROD.

	2) __umulsidi3(a,b) multiplies two USItype integers A and B,
	and returns a UDItype product. This is just a variant of umul_ppmm.

	3) udiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
	denominator) divides a two-word unsigned integer, composed by the
	integers HIGH_NUMERATOR and LOW_NUMERATOR, by DENOMINATOR and
	places the quotient in QUOTIENT and the remainder in REMAINDER.
	HIGH_NUMERATOR must be less than DENOMINATOR for correct operation.
	If, in addition, the most significant bit of DENOMINATOR must be 1,
	then the pre-processor symbol UDIV_NEEDS_NORMALIZATION is defined to 1.

	4) sdiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
	denominator). Like udiv_qrnnd but the numbers are signed. The
	quotient is rounded towards 0.

	5) count_leading_zeros(count, x) counts the number of zero-bits from
	the msb to the first non-zero bit. This is the number of steps X
	needs to be shifted left to set the msb. Undefined for X == 0.

	6) add_ssaaaa(high_sum, low_sum, high_addend_1, low_addend_1,
	high_addend_2, low_addend_2) adds two two-word unsigned integers,
	composed by HIGH_ADDEND_1 and LOW_ADDEND_1, and HIGH_ADDEND_2 and
	LOW_ADDEND_2 respectively. The result is placed in HIGH_SUM and
	LOW_SUM. Overflow (i.e. carry out) is not stored anywhere, and is
	lost.

	7) sub_ddmmss(high_difference, low_difference, high_minuend,
	low_minuend, high_subtrahend, low_subtrahend) subtracts two
	two-word unsigned integers, composed by HIGH_MINUEND_1 and
	LOW_MINUEND_1, and HIGH_SUBTRAHEND_2 and LOW_SUBTRAHEND_2
	respectively. The result is placed in HIGH_DIFFERENCE and
	LOW_DIFFERENCE. Overflow (i.e. carry out) is not stored anywhere,
	and is lost.

	If any of these macros are left undefined for a particular CPU,
	C macros are used. */

	#if defined (__arm__)
	#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
	__asm__ ("adds %1, %4, %5 \n\
	adc %0, %2, %3" \
	: "=r" ((USItype) (sh)), \
	"=&r" ((USItype) (sl)) \
	: "%r" ((USItype) (ah)), \
	"rI" ((USItype) (bh)), \
	"%r" ((USItype) (al)), \
	"rI" ((USItype) (bl)))
	#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
	__asm__ ("subs %1, %4, %5 \n\
	sbc %0, %2, %3" \
	: "=r" ((USItype) (sh)), \
	"=&r" ((USItype) (sl)) \
	: "r" ((USItype) (ah)), \
	"rI" ((USItype) (bh)), \
	"r" ((USItype) (al)), \
	"rI" ((USItype) (bl)))
	#define umul_ppmm(xh, xl, a, b) \
	{register USItype __t0, __t1, __t2; \
	__asm__ ("%@ Inlined umul_ppmm \n\
	mov %2, %5, lsr #16 \n\
	mov %0, %6, lsr #16 \n\
	bic %3, %5, %2, lsl #16 \n\
	bic %4, %6, %0, lsl #16 \n\
	mul %1, %3, %4 \n\
	mul %4, %2, %4 \n\
	mul %3, %0, %3 \n\
	mul %0, %2, %0 \n\
	adds %3, %4, %3 \n\
	addcs %0, %0, #65536 \n\
	adds %1, %1, %3, lsl #16 \n\
	adc %0, %0, %3, lsr #16" \
	: "=&r" ((USItype) (xh)), \
	"=r" ((USItype) (xl)), \
	"=&r" (__t0), "=&r" (__t1), "=r" (__t2) \
	: "r" ((USItype) (a)), \
	"r" ((USItype) (b)));}
	#define UMUL_TIME 20
	#define UDIV_TIME 100
	#endif /* __arm__ */

	#define __umulsidi3(u, v) \
	({DIunion __w; \
	umul_ppmm (__w.s.high, __w.s.low, u, v); \
	__w.ll; })

	#define __udiv_qrnnd_c(q, r, n1, n0, d) \
	do { \
	USItype __d1, __d0, __q1, __q0; \
	USItype __r1, __r0, __m; \
	__d1 = __ll_highpart (d); \
	__d0 = __ll_lowpart (d); \
	\
	__r1 = (n1) % __d1; \
	__q1 = (n1) / __d1; \
	__m = (USItype) __q1 * __d0; \
	__r1 = __r1 * __ll_B \| __ll_highpart (n0); \
	if (__r1 < __m) \
	{ \
	__q1--, __r1 += (d); \
	if (__r1 >= (d)) /* i.e. we didn't get carry when adding to __r1 */\
	if (__r1 < __m) \
	__q1--, __r1 += (d); \
	} \
	__r1 -= __m; \
	\
	__r0 = __r1 % __d1; \
	__q0 = __r1 / __d1; \
	__m = (USItype) __q0 * __d0; \
	__r0 = __r0 * __ll_B \| __ll_lowpart (n0); \
	if (__r0 < __m) \
	{ \
	__q0--, __r0 += (d); \
	if (__r0 >= (d)) \
	if (__r0 < __m) \
	__q0--, __r0 += (d); \
	} \
	__r0 -= __m; \
	\
	(q) = (USItype) __q1 * __ll_B \| __q0; \
	(r) = __r0; \
	} while (0)

	#define UDIV_NEEDS_NORMALIZATION 1
	#define udiv_qrnnd __udiv_qrnnd_c

	extern const UQItype __clz_tab[];
	#define count_leading_zeros(count, x) \
	do { \
	USItype __xr = (x); \
	USItype __a; \
	\
	if (SI_TYPE_SIZE <= 32) \
	{ \
	__a = __xr < ((USItype)1<<2*__BITS4) \
	? (__xr < ((USItype)1<<__BITS4) ? 0 : __BITS4) \
	: (__xr < ((USItype)1<<3__BITS4) ? 2__BITS4 : 3*__BITS4); \
	} \
	else \
	{ \
	for (__a = SI_TYPE_SIZE - 8; __a > 0; __a -= 8) \
	if (((__xr >> __a) & 0xff) != 0) \
	break; \
	} \
	\
	(count) = SI_TYPE_SIZE - (__clz_tab[__xr >> __a] + __a); \
	} while (0)