);
return _prod;
}
-#elif defined(__GNUC__) && defined(__i386__) && !defined(NO_ASM)
+#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) && !defined(NO_ASM)
inline uint32 mulu16 (uint16 arg1, uint16 arg2)
{
register uint16 _hi;
);
return _prod;
}
-#elif defined(__sparc__)
+#elif defined(__sparc__) && !defined(NO_ASM)
extern "C" uint32 mulu32_unchecked (uint32 x, uint32 y); // extern in Assembler
#else
// Wir können dafür auch die Bibliotheksroutine des C-Compilers nehmen:
); \
hi_zuweisung (uint32)_hi; lo_zuweisung (uint32)_lo; \
})
-#elif defined(__GNUC__) && defined(__sparc__)
+#elif defined(__GNUC__) && defined(__sparc__) && !defined(NO_ASM)
#define mulu32(x,y,hi_zuweisung,lo_zuweisung) \
({ lo_zuweisung mulu32_(x,y); /* extern in Assembler */ \
{var register uint32 _hi __asm__("%g1"); \
{var register uint32 _hi __asm__("%r1"/*"%a2"*/); \
hi_zuweisung _hi; \
}})
-#elif defined(__GNUC__) && defined(__i386__) && !defined(NO_ASM)
+#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) && !defined(NO_ASM)
#define mulu32(x,y,hi_zuweisung,lo_zuweisung) \
({ var register uint32 _hi; \
var register uint32 _lo; \
#else
#define mulu32(x,y,hi_zuweisung,lo_zuweisung) \
{ lo_zuweisung mulu32_(x,y); hi_zuweisung mulu32_high; }
- #if defined(__m68k__) || defined(__sparc__) || defined(__sparc64__) || defined(__arm__) || (defined(__i386__) && !defined(WATCOM) && !defined(MICROSOFT)) || defined(__mips__) || defined(__hppa__)
+ #if (defined(__m68k__) || defined(__sparc__) || defined(__sparc64__) || defined(__arm__) || (defined(__i386__) && !defined(WATCOM) && !defined(MICROSOFT)) || defined(__x86_64__) || defined(__mips__) || defined(__hppa__)) && !defined(NO_ASM)
// mulu32_ extern in Assembler
#if defined(__sparc__) || defined(__sparc64__)
extern "C" uint32 _get_g1 (void);
hi_zuweisung _hi; \
lo_zuweisung _lo; \
})
-#elif defined(__GNUC__) && defined(__sparc64__)
+#elif defined(__GNUC__) && defined(__sparc64__) && !defined(NO_ASM)
#define mulu64(x,y,hi_zuweisung,lo_zuweisung) \
({ lo_zuweisung mulu64_(x,y); /* extern in Assembler */ \
{var register uint64 _hi __asm__("%g2"); \
hi_zuweisung _hi; \
}})
+#elif defined(__GNUC__) && defined(__x86_64__) && !defined(NO_ASM)
+ #define mulu64(x,y,hi_zuweisung,lo_zuweisung) \
+ ({ var register uint64 _hi; \
+ var register uint64 _lo; \
+ __asm__("mulq %2" \
+ : "=d" /* %rdx */ (_hi), "=a" /* %rax */ (_lo) \
+ : "g" ((uint64)(x)), "1" /* %rax */ ((uint64)(y)) \
+ ); \
+ hi_zuweisung _hi; lo_zuweisung _lo; \
+ })
#else
#define mulu64(x,y,hi_zuweisung,lo_zuweisung) \
{ lo_zuweisung mulu64_(x,y); hi_zuweisung mulu64_high; }
q_zuweisung (uint16)__q; \
r_zuweisung (uint16)__r; \
})
-#elif defined(__GNUC__) && (defined(__sparc__) || defined(__sparc64__))
+#elif defined(__GNUC__) && (defined(__sparc__) || defined(__sparc64__)) && !defined(NO_ASM)
#define divu_3216_1616(x,y,q_zuweisung,r_zuweisung) \
({ var uint32 __qr = divu_3216_1616_(x,y); /* extern in Assembler */\
q_zuweisung low16(__qr); \
q_zuweisung low16(__qr); \
r_zuweisung high16(__qr); \
})
-#elif defined(__GNUC__) && defined(__i386__) && !defined(NO_ASM)
+#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) && !defined(NO_ASM)
#define divu_3216_1616(x,y,q_zuweisung,r_zuweisung) \
({var uint32 __x = (x); \
var uint16 __y = (y); \
q_zuweisung __q; \
r_zuweisung (__x - __q * __y); \
})
-#elif defined(__sparc__) || defined(__sparc64__)
+#elif (defined(__sparc__) || defined(__sparc64__)) && !defined(NO_ASM)
#define divu_3216_1616(x,y,q_zuweisung,r_zuweisung) \
{ var uint32 __qr = divu_3216_1616_(x,y); /* extern in Assembler */ \
q_zuweisung low16(__qr); \
r_zuweisung high16(__qr); \
}
-#elif defined(__arm__)
+#elif defined(__arm__) && !defined(NO_ASM)
#define divu_3216_1616(x,y,q_zuweisung,r_zuweisung) \
{ q_zuweisung divu_3216_1616_(x,y); /* extern in Assembler */ \
r_zuweisung divu_16_rest; \
q_zuweisung (uint32)__q; \
r_zuweisung (uint16)__r; \
})
-#elif defined(__sparc__) || defined(__sparc64__) || defined(__i386__)
+#elif defined(__sparc__) || defined(__sparc64__) || defined(__i386__) || defined(__x86_64__)
#define divu_3216_3216 divu_3232_3232
#else
// Methode: (beta = 2^16)
q_zuweisung (uint32)__q; \
r_zuweisung (uint32)__r; \
})
-#elif defined(__sparc__) || defined(__sparc64__) || defined(__i386__)
+#elif defined(__sparc__) || defined(__sparc64__) || defined(__i386__) || defined(__x86_64__)
#define divu_3232_3232(x,y,q_zuweisung,r_zuweisung) \
divu_6432_3232(0,x,y,q_zuweisung,r_zuweisung)
#define divu_3232_3232_(x,y) divu_6432_3232_(0,x,y)
q_zuweisung (uint32)__q; \
r_zuweisung (uint32)__r; \
})
-#elif defined(__GNUC__) && (defined(__sparc__) || defined(__sparc64__))
+#elif defined(__GNUC__) && (defined(__sparc__) || defined(__sparc64__)) && !defined(NO_ASM)
#define divu_6432_3232(xhi,xlo,y,q_zuweisung,r_zuweisung) \
({ var uint32 _q = divu_6432_3232_(xhi,xlo,y); /* extern in Assembler */\
var register uint32 _r __asm__("%g1"); \
var register uint32 _r __asm__("%r1"/*"%a2"*/); \
q_zuweisung _q; r_zuweisung _r; \
})
-#elif defined(__GNUC__) && defined(__i386__) && !defined(NO_ASM)
+#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) && !defined(NO_ASM)
#define divu_6432_3232(xhi,xlo,y,q_zuweisung,r_zuweisung) \
({var uint32 __xhi = (xhi); \
var uint32 __xlo = (xlo); \
#else
#define divu_6432_3232(xhi,xlo,y,q_zuweisung,r_zuweisung) \
{ q_zuweisung divu_6432_3232_(xhi,xlo,y); r_zuweisung divu_32_rest; }
- #if defined(__m68k__) || defined(__sparc__) || defined(__sparc64__) || defined(__arm__) || (defined(__i386__) && !defined(WATCOM) && !defined(MICROSOFT)) || defined(__hppa__)
+ #if (defined(__m68k__) || defined(__sparc__) || defined(__sparc64__) || defined(__arm__) || (defined(__i386__) && !defined(WATCOM) && !defined(MICROSOFT)) || defined(__x86_64__) || defined(__hppa__)) && !defined(NO_ASM)
// divu_6432_3232_ extern in Assembler
#if defined(__sparc__) || defined(__sparc64__)
extern "C" uint32 _get_g1 (void);
// < x = q*y+r
extern "C" uint64 divu_12864_6464_ (uint64 xhi, uint64 xlo, uint64 y); // -> Quotient q
extern "C" uint64 divu_64_rest; // -> Rest r
+#if defined(__GNUC__) && defined(__x86_64__) && !defined(NO_ASM)
+ #define divu_12864_6464(xhi,xlo,y,q_zuweisung,r_zuweisung) \
+ ({var uint64 __xhi = (xhi); \
+ var uint64 __xlo = (xlo); \
+ var uint64 __y = (y); \
+ var uint64 __q; \
+ var uint64 __r; \
+ __asm__ __volatile__ ( \
+ "divq %4" \
+ : "=a" /* %rax */ (__q), "=d" /* %rdx */ (__r) \
+ : "1" /* %rdx */ (__xhi), "0" /* %rax */ (__xlo), "rm" (__y) \
+ ); \
+ q_zuweisung __q; \
+ r_zuweisung __r; \
+ })
+ #define divu_12864_64364_(xhi,xlo,y) \
+ ({var uint64 ___q; divu_12864_6464(xhi,xlo,y,___q=,); ___q; })
+#else
#define divu_12864_6464(xhi,xlo,y,q_zuweisung,r_zuweisung) \
{ q_zuweisung divu_12864_6464_(xhi,xlo,y); r_zuweisung divu_64_rest; }
#define NEED_FUNCTION_divu_12864_6464_
+#endif
#endif /* HAVE_FAST_LONGLONG */
// < size: >0, <=8, mit 2^(size-1) <= digit < 2^size
#if defined(__GNUC__) && defined(__m68k__) && !defined(NO_ASM)
#define integerlength8(digit,size_zuweisung) \
- { var uintL zero_counter; /* zählt die führenden Nullbits in digit */\
- __asm__("bfffo %1{#0:#8},%0" : "=d" (zero_counter) : "dm" ((uint8)(digit)) ); \
- size_zuweisung (8-zero_counter); \
+ { var uintL _zero_counter; /* zählt die führenden Nullbits in digit */\
+ __asm__("bfffo %1{#0:#8},%0" : "=d" (_zero_counter) : "dm" ((uint8)(digit)) ); \
+ size_zuweisung (8-_zero_counter); \
}
#elif defined(__sparc__) && !defined(__sparc64__)
#define integerlength8(digit,size_zuweisung) \
integerlength16((uint16)(digit),size_zuweisung)
#else
#define integerlength8(digit,size_zuweisung) \
- { var uintC bitsize = 1; \
- var uintL x8 = (uint8)(digit); \
- /* x8 hat höchstens 8 Bits. */\
- if (x8 >= bit(4)) { x8 = x8>>4; bitsize += 4; } \
- /* x8 hat höchstens 4 Bits. */\
- if (x8 >= bit(2)) { x8 = x8>>2; bitsize += 2; } \
- /* x8 hat höchstens 2 Bits. */\
- if (x8 >= bit(1)) { /* x8 = x8>>1; */ bitsize += 1; } \
- /* x8 hat höchstens 1 Bit. Dieses Bit muß gesetzt sein. */\
- size_zuweisung bitsize; \
+ { var uintC _bitsize = 1; \
+ var uintL _x8 = (uint8)(digit); \
+ /* _x8 hat höchstens 8 Bits. */\
+ if (_x8 >= bit(4)) { _x8 = _x8>>4; _bitsize += 4; } \
+ /* _x8 hat höchstens 4 Bits. */\
+ if (_x8 >= bit(2)) { _x8 = _x8>>2; _bitsize += 2; } \
+ /* _x8 hat höchstens 2 Bits. */\
+ if (_x8 >= bit(1)) { /* _x8 = _x8>>1; */ _bitsize += 1; } \
+ /* _x8 hat höchstens 1 Bit. Dieses Bit muß gesetzt sein. */\
+ size_zuweisung _bitsize; \
}
#endif
// < size: >0, <=16, mit 2^(size-1) <= digit < 2^size
#if defined(__GNUC__) && defined(__m68k__) && !defined(NO_ASM)
#define integerlength16(digit,size_zuweisung) \
- { var uintL zero_counter; /* zählt die führenden Nullbits in digit */\
- __asm__("bfffo %1{#0:#16},%0" : "=d" (zero_counter) : "dm" ((uint16)(digit)) ); \
- size_zuweisung (16-zero_counter); \
+ { var uintL _zero_counter; /* zählt die führenden Nullbits in digit */\
+ __asm__("bfffo %1{#0:#16},%0" : "=d" (_zero_counter) : "dm" ((uint16)(digit)) ); \
+ size_zuweisung (16-_zero_counter); \
}
#elif defined(__sparc__) && !defined(__sparc64__)
#define integerlength16(digit,size_zuweisung) \
integerlength32((uint32)(digit),size_zuweisung) // siehe unten
#elif defined(__GNUC__) && defined(__i386__) && !defined(NO_ASM)
#define integerlength16(digit,size_zuweisung) \
- { var uintW one_position; /* Position der führenden 1 */\
- __asm__("bsrw %1,%0" : "=r" (one_position) : "r" ((uint16)(digit)) ); \
- size_zuweisung (1+one_position); \
+ { var uintW _one_position; /* Position der führenden 1 */\
+ __asm__("bsrw %1,%0" : "=r" (_one_position) : "r" ((uint16)(digit)) ); \
+ size_zuweisung (1+_one_position); \
}
// Die weiteren kommen von gcc/longlong.h :
#elif defined(__GNUC__) && defined(__ibm032__) && !defined(NO_ASM) // RT/ROMP
#define integerlength16(digit,size_zuweisung) \
- { var uintL zero_counter; /* zählt die führenden Nullbits in digit */\
- __asm__("clz %0,%1" : "=r" (zero_counter) : "r" ((uint32)(digit)) ); \
- size_zuweisung (16-zero_counter); \
+ { var uintL _zero_counter; /* zählt die führenden Nullbits in digit */\
+ __asm__("clz %0,%1" : "=r" (_zero_counter) : "r" ((uint32)(digit)) ); \
+ size_zuweisung (16-_zero_counter); \
}
#else
#define integerlength16(digit,size_zuweisung) \
- { var uintC bitsize = 1; \
- var uintWL x16 = (uint16)(digit); \
- /* x16 hat höchstens 16 Bits. */\
- if (x16 >= bit(8)) { x16 = x16>>8; bitsize += 8; } \
- /* x16 hat höchstens 8 Bits. */\
- if (x16 >= bit(4)) { x16 = x16>>4; bitsize += 4; } \
- /* x16 hat höchstens 4 Bits. */\
- if (x16 >= bit(2)) { x16 = x16>>2; bitsize += 2; } \
- /* x16 hat höchstens 2 Bits. */\
- if (x16 >= bit(1)) { /* x16 = x16>>1; */ bitsize += 1; } \
- /* x16 hat höchstens 1 Bit. Dieses Bit muß gesetzt sein. */\
- size_zuweisung bitsize; \
+ { var uintC _bitsize = 1; \
+ var uintWL _x16 = (uint16)(digit); \
+ /* _x16 hat höchstens 16 Bits. */\
+ if (_x16 >= bit(8)) { _x16 = _x16>>8; _bitsize += 8; } \
+ /* _x16 hat höchstens 8 Bits. */\
+ if (_x16 >= bit(4)) { _x16 = _x16>>4; _bitsize += 4; } \
+ /* _x16 hat höchstens 4 Bits. */\
+ if (_x16 >= bit(2)) { _x16 = _x16>>2; _bitsize += 2; } \
+ /* _x16 hat höchstens 2 Bits. */\
+ if (_x16 >= bit(1)) { /* _x16 = _x16>>1; */ _bitsize += 1; } \
+ /* _x16 hat höchstens 1 Bit. Dieses Bit muß gesetzt sein. */\
+ size_zuweisung _bitsize; \
}
#endif
// < size: >0, <=32, mit 2^(size-1) <= digit < 2^size
#if defined(__GNUC__) && defined(__m68k__) && !defined(NO_ASM)
#define integerlength32(digit,size_zuweisung) \
- { var uintL zero_counter; /* zählt die führenden Nullbits in digit */\
- __asm__("bfffo %1{#0:#32},%0" : "=d" (zero_counter) : "dm" ((uint32)(digit)) ); \
- size_zuweisung (32-zero_counter); \
+ { var uintL _zero_counter; /* zählt die führenden Nullbits in digit */\
+ __asm__("bfffo %1{#0:#32},%0" : "=d" (_zero_counter) : "dm" ((uint32)(digit)) ); \
+ size_zuweisung (32-_zero_counter); \
}
#elif defined(__sparc__) && !defined(__sparc64__) && defined(FAST_DOUBLE)
#define integerlength32(digit,size_zuweisung) \
}
#elif defined(__GNUC__) && defined(__i386__) && !defined(NO_ASM)
#define integerlength32(digit,size_zuweisung) \
- { var uintL one_position; /* Position der führenden 1 */\
- __asm__("bsrl %1,%0" : "=r" (one_position) : "rm" ((uint32)(digit)) ); \
- size_zuweisung (1+one_position); \
+ { var uintL _one_position; /* Position der führenden 1 */\
+ __asm__("bsrl %1,%0" : "=r" (_one_position) : "rm" ((uint32)(digit)) ); \
+ size_zuweisung (1+_one_position); \
}
#elif defined(__hppa__) && !defined(NO_ASM)
#define integerlength32(digit,size_zuweisung) \
// Die weiteren kommen von gcc/longlong.h :
#elif defined(__GNUC__) && (defined(__a29k__) || defined(___AM29K__)) && !defined(NO_ASM)
#define integerlength32(digit,size_zuweisung) \
- { var uintL zero_counter; /* zählt die führenden Nullbits in digit */\
- __asm__("clz %0,%1" : "=r" (zero_counter) : "r" ((uint32)(digit)) ); \
- size_zuweisung (32-zero_counter); \
+ { var uintL _zero_counter; /* zählt die führenden Nullbits in digit */\
+ __asm__("clz %0,%1" : "=r" (_zero_counter) : "r" ((uint32)(digit)) ); \
+ size_zuweisung (32-_zero_counter); \
}
#elif defined(__GNUC__) && defined(__gmicro__) && !defined(NO_ASM)
#define integerlength32(digit,size_zuweisung) \
- { var uintL zero_counter; /* zählt die führenden Nullbits in digit */\
- __asm__("bsch/1 %1,%0" : "=g" (zero_counter) : "g" ((uint32)(digit)) ); \
- size_zuweisung (32-zero_counter); \
+ { var uintL _zero_counter; /* zählt die führenden Nullbits in digit */\
+ __asm__("bsch/1 %1,%0" : "=g" (_zero_counter) : "g" ((uint32)(digit)) ); \
+ size_zuweisung (32-_zero_counter); \
}
#elif defined(__GNUC__) && defined(__rs6000__) && !defined(NO_ASM)
#ifdef _AIX
// old assembler syntax
#define integerlength32(digit,size_zuweisung) \
- { var uintL zero_counter; /* zählt die führenden Nullbits in digit */\
- __asm__("cntlz %0,%1" : "=r" (zero_counter) : "r" ((uint32)(digit)) ); \
- size_zuweisung (32-zero_counter); \
+ { var uintL _zero_counter; /* zählt die führenden Nullbits in digit */\
+ __asm__("cntlz %0,%1" : "=r" (_zero_counter) : "r" ((uint32)(digit)) ); \
+ size_zuweisung (32-_zero_counter); \
}
#else
// new assembler syntax
#define integerlength32(digit,size_zuweisung) \
- { var uintL zero_counter; /* zählt die führenden Nullbits in digit */\
- __asm__("cntlzw %0,%1" : "=r" (zero_counter) : "r" ((uint32)(digit)) ); \
- size_zuweisung (32-zero_counter); \
+ { var uintL _zero_counter; /* zählt die führenden Nullbits in digit */\
+ __asm__("cntlzw %0,%1" : "=r" (_zero_counter) : "r" ((uint32)(digit)) ); \
+ size_zuweisung (32-_zero_counter); \
}
#endif
#elif defined(__GNUC__) && defined(__m88k__) && !defined(NO_ASM)
#define integerlength32(digit,size_zuweisung) \
- { var uintL one_position; /* Position der führenden 1 */\
- __asm__("ff1 %0,%1" : "=r" (one_position) : "r" ((uint32)(digit)) ); \
- size_zuweisung (1+one_position); \
+ { var uintL _one_position; /* Position der führenden 1 */\
+ __asm__("ff1 %0,%1" : "=r" (_one_position) : "r" ((uint32)(digit)) ); \
+ size_zuweisung (1+_one_position); \
}
#elif defined(__GNUC__) && defined(__ibm032__) && !defined(NO_ASM) // RT/ROMP
#define integerlength32(digit,size_zuweisung) \
- { var uintL x32 = (uint32)(digit); \
- if (x32 >= bit(16)) \
- { integerlength16(x32>>16,size_zuweisung 16 + ); } \
+ { var uintL _x32 = (uint32)(digit); \
+ if (_x32 >= bit(16)) \
+ { integerlength16(_x32>>16,size_zuweisung 16 + ); } \
else \
- { integerlength16(x32,size_zuweisung); } \
+ { integerlength16(_x32,size_zuweisung); } \
}
#else
#define integerlength32(digit,size_zuweisung) \
- { var uintC bitsize = 1; \
- var uintL x32 = (uint32)(digit); \
- /* x32 hat höchstens 32 Bits. */\
- if (x32 >= bit(16)) { x32 = x32>>16; bitsize += 16; } \
- /* x32 hat höchstens 16 Bits. */\
- if (x32 >= bit(8)) { x32 = x32>>8; bitsize += 8; } \
- /* x32 hat höchstens 8 Bits. */\
- if (x32 >= bit(4)) { x32 = x32>>4; bitsize += 4; } \
- /* x32 hat höchstens 4 Bits. */\
- if (x32 >= bit(2)) { x32 = x32>>2; bitsize += 2; } \
- /* x32 hat höchstens 2 Bits. */\
- if (x32 >= bit(1)) { /* x32 = x32>>1; */ bitsize += 1; } \
- /* x32 hat höchstens 1 Bit. Dieses Bit muß gesetzt sein. */\
- size_zuweisung bitsize; \
+ { var uintC _bitsize = 1; \
+ var uintL _x32 = (uint32)(digit); \
+ /* _x32 hat höchstens 32 Bits. */\
+ if (_x32 >= bit(16)) { _x32 = _x32>>16; _bitsize += 16; } \
+ /* _x32 hat höchstens 16 Bits. */\
+ if (_x32 >= bit(8)) { _x32 = _x32>>8; _bitsize += 8; } \
+ /* _x32 hat höchstens 8 Bits. */\
+ if (_x32 >= bit(4)) { _x32 = _x32>>4; _bitsize += 4; } \
+ /* _x32 hat höchstens 4 Bits. */\
+ if (_x32 >= bit(2)) { _x32 = _x32>>2; _bitsize += 2; } \
+ /* _x32 hat höchstens 2 Bits. */\
+ if (_x32 >= bit(1)) { /* _x32 = _x32>>1; */ _bitsize += 1; } \
+ /* _x32 hat höchstens 1 Bit. Dieses Bit muß gesetzt sein. */\
+ size_zuweisung _bitsize; \
}
#endif
// > digit: ein uint64 >0
// < size: >0, <=64, mit 2^(size-1) <= digit < 2^size
#define integerlength64(digit,size_zuweisung) \
- { var uintC bitsize = 1; \
- var uint64 x64 = (uint64)(digit); \
- /* x64 hat höchstens 64 Bits. */\
- if (x64 >= bit(32)) { x64 = x64>>32; bitsize += 32; } \
- /* x64 hat höchstens 32 Bits. */\
- if (x64 >= bit(16)) { x64 = x64>>16; bitsize += 16; } \
- /* x64 hat höchstens 16 Bits. */\
- if (x64 >= bit(8)) { x64 = x64>>8; bitsize += 8; } \
- /* x64 hat höchstens 8 Bits. */\
- if (x64 >= bit(4)) { x64 = x64>>4; bitsize += 4; } \
- /* x64 hat höchstens 4 Bits. */\
- if (x64 >= bit(2)) { x64 = x64>>2; bitsize += 2; } \
- /* x64 hat höchstens 2 Bits. */\
- if (x64 >= bit(1)) { /* x64 = x64>>1; */ bitsize += 1; } \
- /* x64 hat höchstens 1 Bit. Dieses Bit muß gesetzt sein. */\
- size_zuweisung bitsize; \
+ { var uintC _bitsize = 1; \
+ var uint64 _x64 = (uint64)(digit); \
+ /* _x64 hat höchstens 64 Bits. */\
+ if (_x64 >= bit(32)) { _x64 = _x64>>32; _bitsize += 32; } \
+ /* _x64 hat höchstens 32 Bits. */\
+ if (_x64 >= bit(16)) { _x64 = _x64>>16; _bitsize += 16; } \
+ /* _x64 hat höchstens 16 Bits. */\
+ if (_x64 >= bit(8)) { _x64 = _x64>>8; _bitsize += 8; } \
+ /* _x64 hat höchstens 8 Bits. */\
+ if (_x64 >= bit(4)) { _x64 = _x64>>4; _bitsize += 4; } \
+ /* _x64 hat höchstens 4 Bits. */\
+ if (_x64 >= bit(2)) { _x64 = _x64>>2; _bitsize += 2; } \
+ /* _x64 hat höchstens 2 Bits. */\
+ if (_x64 >= bit(1)) { /* _x64 = _x64>>1; */ _bitsize += 1; } \
+ /* _x64 hat höchstens 1 Bit. Dieses Bit muß gesetzt sein. */\
+ size_zuweisung _bitsize; \
}
// Hintere Nullbits eines 32-Bit-Wortes zählen:
// < count: >=0, <32, mit 2^count | digit, digit/2^count ungerade
#if defined(__GNUC__) && defined(__i386__) && !defined(NO_ASM)
#define ord2_32(digit,count_zuweisung) \
- { var uintL one_position; /* Position der letzten 1 */\
- __asm__("bsfl %1,%0" : "=r" (one_position) : "rm" ((uint32)(digit)) ); \
- count_zuweisung one_position; \
+ { var uintL _one_position; /* Position der letzten 1 */\
+ __asm__("bsfl %1,%0" : "=r" (_one_position) : "rm" ((uint32)(digit)) ); \
+ count_zuweisung _one_position; \
}
#define FAST_ORD2
#elif defined(__sparc__) && !defined(__sparc64__)
git://www.ginac.de / cln.git / blobdiff