int
yasm_intnum_in_range(const yasm_intnum *intn, long low, long high)
{
wordptr val = intnum_tobv(result, intn);
wordptr lval = op1static;
wordptr hval = op2static;
/* Convert high and low to bitvects */
BitVector_Empty(lval);
if (low >= 0)
BitVector_Chunk_Store(lval, 32, 0, (unsigned long)low);
else {
BitVector_Chunk_Store(lval, 32, 0, (unsigned long)(-low));
BitVector_Negate(lval, lval);
}
BitVector_Empty(hval);
if (high >= 0)
BitVector_Chunk_Store(hval, 32, 0, (unsigned long)high);
else {
BitVector_Chunk_Store(hval, 32, 0, (unsigned long)(-high));
BitVector_Negate(hval, hval);
}
/* Compare! */
return (BitVector_Compare(val, lval) >= 0
&& BitVector_Compare(val, hval) <= 0);
}
yasm_intnum *
yasm_intnum_create_leb128(const unsigned char *ptr, int sign,
unsigned long *size)
{
yasm_intnum *intn = yasm_xmalloc(sizeof(yasm_intnum));
const unsigned char *ptr_orig = ptr;
unsigned long i = 0;
BitVector_Empty(conv_bv);
for (;;) {
BitVector_Chunk_Store(conv_bv, 7, i, *ptr);
i += 7;
if ((*ptr & 0x80) != 0x80)
break;
ptr++;
}
*size = (unsigned long)(ptr-ptr_orig)+1;
if(i > BITVECT_NATIVE_SIZE)
yasm_error_set(YASM_ERROR_OVERFLOW,
N_("Numeric constant too large for internal format"));
else if (sign && (*ptr & 0x40) == 0x40)
BitVector_Interval_Fill(conv_bv, i, BITVECT_NATIVE_SIZE-1);
intnum_frombv(intn, conv_bv);
return intn;
}
yasm_intnum *
yasm_intnum_create_sized(unsigned char *ptr, int sign, size_t srcsize,
int bigendian)
{
yasm_intnum *intn = yasm_xmalloc(sizeof(yasm_intnum));
unsigned long i = 0;
if (srcsize*8 > BITVECT_NATIVE_SIZE)
yasm_error_set(YASM_ERROR_OVERFLOW,
N_("Numeric constant too large for internal format"));
/* Read the buffer into a bitvect */
BitVector_Empty(conv_bv);
if (bigendian) {
/* TODO */
yasm_internal_error(N_("big endian not implemented"));
} else {
for (i = 0; i < srcsize; i++)
BitVector_Chunk_Store(conv_bv, 8, i*8, ptr[i]);
}
/* Sign extend if needed */
if (srcsize*8 < BITVECT_NATIVE_SIZE && sign && (ptr[i-1] & 0x80) == 0x80)
BitVector_Interval_Fill(conv_bv, i*8, BITVECT_NATIVE_SIZE-1);
intnum_frombv(intn, conv_bv);
return intn;
}
static void
x86_cpu_intel(wordptr cpu, unsigned int data)
{
BitVector_Empty(cpu);
BitVector_Bit_On(cpu, CPU_Priv);
if (data >= PROC_286)
BitVector_Bit_On(cpu, CPU_Prot);
if (data >= PROC_386)
BitVector_Bit_On(cpu, CPU_SMM);
if (data >= PROC_sandybridge)
BitVector_Bit_On(cpu, CPU_AVX);
if (data >= PROC_westmere) {
BitVector_Bit_On(cpu, CPU_AES);
BitVector_Bit_On(cpu, CPU_CLMUL);
}
if (data >= PROC_nehalem) {
BitVector_Bit_On(cpu, CPU_SSE42);
BitVector_Bit_On(cpu, CPU_XSAVE);
}
if (data >= PROC_penryn)
BitVector_Bit_On(cpu, CPU_SSE41);
if (data >= PROC_conroe)
BitVector_Bit_On(cpu, CPU_SSSE3);
if (data >= PROC_prescott)
BitVector_Bit_On(cpu, CPU_SSE3);
if (data >= PROC_p4)
BitVector_Bit_On(cpu, CPU_SSE2);
if (data >= PROC_p3)
BitVector_Bit_On(cpu, CPU_SSE);
if (data >= PROC_p2)
BitVector_Bit_On(cpu, CPU_MMX);
if (data >= PROC_486)
BitVector_Bit_On(cpu, CPU_FPU);
if (data >= PROC_prescott)
BitVector_Bit_On(cpu, CPU_EM64T);
if (data >= PROC_p4)
BitVector_Bit_On(cpu, CPU_P4);
if (data >= PROC_p3)
BitVector_Bit_On(cpu, CPU_P3);
if (data >= PROC_686)
BitVector_Bit_On(cpu, CPU_686);
if (data >= PROC_586)
BitVector_Bit_On(cpu, CPU_586);
if (data >= PROC_486)
BitVector_Bit_On(cpu, CPU_486);
if (data >= PROC_386)
BitVector_Bit_On(cpu, CPU_386);
if (data >= PROC_286)
BitVector_Bit_On(cpu, CPU_286);
if (data >= PROC_186)
BitVector_Bit_On(cpu, CPU_186);
BitVector_Bit_On(cpu, CPU_086);
}
unsigned long
yasm_size_uleb128(unsigned long v)
{
wordptr val = op1static;
if (v == 0)
return 1;
BitVector_Empty(val);
BitVector_Chunk_Store(val, 32, 0, v);
return size_leb128(val, 0);
}
unsigned long
yasm_get_uleb128(unsigned long v, unsigned char *ptr)
{
wordptr val = op1static;
/* Shortcut 0 */
if (v == 0) {
*ptr = 0;
return 1;
}
BitVector_Empty(val);
BitVector_Chunk_Store(val, 32, 0, v);
return get_leb128(val, ptr, 0);
}
/* If intnum is a BV, returns its bitvector directly.
* If not, converts into passed bv and returns that instead.
*/
static wordptr
intnum_tobv(/*@returned@*/ wordptr bv, const yasm_intnum *intn)
{
if (intn->type == INTNUM_BV)
return intn->val.bv;
BitVector_Empty(bv);
if (intn->val.l >= 0)
BitVector_Chunk_Store(bv, 32, 0, (unsigned long)intn->val.l);
else {
BitVector_Chunk_Store(bv, 32, 0, (unsigned long)-intn->val.l);
BitVector_Negate(bv, bv);
}
return bv;
}
yasm_intnum *
yasm_intnum_create_charconst_tasm(const char *str)
{
yasm_intnum *intn = yasm_xmalloc(sizeof(yasm_intnum));
size_t len = strlen(str);
size_t i;
if(len*8 > BITVECT_NATIVE_SIZE)
yasm_error_set(YASM_ERROR_OVERFLOW,
N_("Character constant too large for internal format"));
/* be conservative in choosing bitvect in case MSB is set */
if (len > 3) {
BitVector_Empty(conv_bv);
intn->type = INTNUM_BV;
} else {
intn->val.l = 0;
intn->type = INTNUM_L;
}
/* tasm uses big endian notation */
i = 0;
switch (len) {
case 3:
intn->val.l |= ((unsigned long)str[i++]) & 0xff;
intn->val.l <<= 8;
/*@fallthrough@*/
case 2:
intn->val.l |= ((unsigned long)str[i++]) & 0xff;
intn->val.l <<= 8;
/*@fallthrough@*/
case 1:
intn->val.l |= ((unsigned long)str[i++]) & 0xff;
case 0:
break;
default:
/* >=32 bit conversion */
while (i < len) {
BitVector_Chunk_Store(conv_bv, 8, (len-i-1)*8,
((unsigned long)str[i]) & 0xff);
i++;
}
intn->val.bv = BitVector_Clone(conv_bv);
}
return intn;
}
unsigned long
yasm_size_sleb128(long v)
{
wordptr val = op1static;
if (v == 0)
return 1;
BitVector_Empty(val);
if (v >= 0)
BitVector_Chunk_Store(val, 32, 0, (unsigned long)v);
else {
BitVector_Chunk_Store(val, 32, 0, (unsigned long)(-v));
BitVector_Negate(val, val);
}
return size_leb128(val, 1);
}
static void
x86_cpu_amd(wordptr cpu, yasm_arch_x86 *arch_x86, unsigned int data)
{
BitVector_Empty(cpu);
BitVector_Bit_On(cpu, CPU_Priv);
BitVector_Bit_On(cpu, CPU_Prot);
BitVector_Bit_On(cpu, CPU_SMM);
BitVector_Bit_On(cpu, CPU_3DNow);
if (data >= PROC_bulldozer) {
BitVector_Bit_On(cpu, CPU_XOP);
BitVector_Bit_On(cpu, CPU_FMA4);
}
if (data >= PROC_k10)
BitVector_Bit_On(cpu, CPU_SSE4a);
if (data >= PROC_venice)
BitVector_Bit_On(cpu, CPU_SSE3);
if (data >= PROC_hammer)
BitVector_Bit_On(cpu, CPU_SSE2);
if (data >= PROC_k7)
BitVector_Bit_On(cpu, CPU_SSE);
if (data >= PROC_k6)
BitVector_Bit_On(cpu, CPU_MMX);
BitVector_Bit_On(cpu, CPU_FPU);
if (data >= PROC_hammer)
BitVector_Bit_On(cpu, CPU_Hammer);
if (data >= PROC_k7)
BitVector_Bit_On(cpu, CPU_Athlon);
if (data >= PROC_k6)
BitVector_Bit_On(cpu, CPU_K6);
BitVector_Bit_On(cpu, CPU_686);
BitVector_Bit_On(cpu, CPU_586);
BitVector_Bit_On(cpu, CPU_486);
BitVector_Bit_On(cpu, CPU_386);
BitVector_Bit_On(cpu, CPU_286);
BitVector_Bit_On(cpu, CPU_186);
BitVector_Bit_On(cpu, CPU_086);
/* Use AMD long NOPs if k6 or better */
if (data >= PROC_k6)
arch_x86->nop = X86_NOP_AMD;
else
arch_x86->nop = X86_NOP_BASIC;
}
unsigned long
yasm_get_sleb128(long v, unsigned char *ptr)
{
wordptr val = op1static;
/* Shortcut 0 */
if (v == 0) {
*ptr = 0;
return 1;
}
BitVector_Empty(val);
if (v >= 0)
BitVector_Chunk_Store(val, 32, 0, (unsigned long)v);
else {
BitVector_Chunk_Store(val, 32, 0, (unsigned long)(-v));
BitVector_Negate(val, val);
}
return get_leb128(val, ptr, 1);
}
static void
x86_cpu_ia64(wordptr cpu, yasm_arch_x86 *arch_x86, unsigned int data)
{
BitVector_Empty(cpu);
BitVector_Bit_On(cpu, CPU_Priv);
BitVector_Bit_On(cpu, CPU_Prot);
BitVector_Bit_On(cpu, CPU_SMM);
BitVector_Bit_On(cpu, CPU_SSE2);
BitVector_Bit_On(cpu, CPU_SSE);
BitVector_Bit_On(cpu, CPU_MMX);
BitVector_Bit_On(cpu, CPU_FPU);
BitVector_Bit_On(cpu, CPU_IA64);
BitVector_Bit_On(cpu, CPU_P4);
BitVector_Bit_On(cpu, CPU_P3);
BitVector_Bit_On(cpu, CPU_686);
BitVector_Bit_On(cpu, CPU_586);
BitVector_Bit_On(cpu, CPU_486);
BitVector_Bit_On(cpu, CPU_386);
BitVector_Bit_On(cpu, CPU_286);
BitVector_Bit_On(cpu, CPU_186);
BitVector_Bit_On(cpu, CPU_086);
}
static void
x86_cpu_amd(wordptr cpu, unsigned int data)
{
BitVector_Empty(cpu);
BitVector_Bit_On(cpu, CPU_Priv);
BitVector_Bit_On(cpu, CPU_Prot);
BitVector_Bit_On(cpu, CPU_SMM);
BitVector_Bit_On(cpu, CPU_3DNow);
if (data >= PROC_bulldozer)
BitVector_Bit_On(cpu, CPU_SSE5);
if (data >= PROC_k10)
BitVector_Bit_On(cpu, CPU_SSE4a);
if (data >= PROC_venice)
BitVector_Bit_On(cpu, CPU_SSE3);
if (data >= PROC_hammer)
BitVector_Bit_On(cpu, CPU_SSE2);
if (data >= PROC_k7)
BitVector_Bit_On(cpu, CPU_SSE);
if (data >= PROC_k6)
BitVector_Bit_On(cpu, CPU_MMX);
BitVector_Bit_On(cpu, CPU_FPU);
if (data >= PROC_hammer)
BitVector_Bit_On(cpu, CPU_Hammer);
if (data >= PROC_k7)
BitVector_Bit_On(cpu, CPU_Athlon);
if (data >= PROC_k6)
BitVector_Bit_On(cpu, CPU_K6);
BitVector_Bit_On(cpu, CPU_686);
BitVector_Bit_On(cpu, CPU_586);
BitVector_Bit_On(cpu, CPU_486);
BitVector_Bit_On(cpu, CPU_386);
BitVector_Bit_On(cpu, CPU_286);
BitVector_Bit_On(cpu, CPU_186);
BitVector_Bit_On(cpu, CPU_086);
}
static void
x86_cpu_intel(wordptr cpu, yasm_arch_x86 *arch_x86, unsigned int data)
{
BitVector_Empty(cpu);
BitVector_Bit_On(cpu, CPU_Priv);
if (data >= PROC_286)
BitVector_Bit_On(cpu, CPU_Prot);
if (data >= PROC_386)
BitVector_Bit_On(cpu, CPU_SMM);
if (data >= PROC_sandybridge)
BitVector_Bit_On(cpu, CPU_AVX);
if (data >= PROC_westmere) {
BitVector_Bit_On(cpu, CPU_AES);
BitVector_Bit_On(cpu, CPU_CLMUL);
}
if (data >= PROC_nehalem) {
BitVector_Bit_On(cpu, CPU_SSE42);
BitVector_Bit_On(cpu, CPU_XSAVE);
}
if (data >= PROC_penryn)
BitVector_Bit_On(cpu, CPU_SSE41);
if (data >= PROC_conroe)
BitVector_Bit_On(cpu, CPU_SSSE3);
if (data >= PROC_prescott)
BitVector_Bit_On(cpu, CPU_SSE3);
if (data >= PROC_p4)
BitVector_Bit_On(cpu, CPU_SSE2);
if (data >= PROC_p3)
BitVector_Bit_On(cpu, CPU_SSE);
if (data >= PROC_p2)
BitVector_Bit_On(cpu, CPU_MMX);
if (data >= PROC_486)
BitVector_Bit_On(cpu, CPU_FPU);
if (data >= PROC_prescott)
BitVector_Bit_On(cpu, CPU_EM64T);
if (data >= PROC_p4)
BitVector_Bit_On(cpu, CPU_P4);
if (data >= PROC_p3)
BitVector_Bit_On(cpu, CPU_P3);
if (data >= PROC_686)
BitVector_Bit_On(cpu, CPU_686);
if (data >= PROC_586)
BitVector_Bit_On(cpu, CPU_586);
if (data >= PROC_486)
BitVector_Bit_On(cpu, CPU_486);
if (data >= PROC_386)
BitVector_Bit_On(cpu, CPU_386);
if (data >= PROC_286)
BitVector_Bit_On(cpu, CPU_286);
if (data >= PROC_186)
BitVector_Bit_On(cpu, CPU_186);
BitVector_Bit_On(cpu, CPU_086);
/* Use Intel long NOPs if 686 or better */
if (data >= PROC_686)
arch_x86->nop = X86_NOP_INTEL;
else
arch_x86->nop = X86_NOP_BASIC;
}
/*@-nullderef -nullpass -branchstate@*/
int
yasm_intnum_calc(yasm_intnum *acc, yasm_expr_op op, yasm_intnum *operand)
{
boolean carry = 0;
wordptr op1, op2 = NULL;
N_int count;
/* Always do computations with in full bit vector.
* Bit vector results must be calculated through intermediate storage.
*/
op1 = intnum_tobv(op1static, acc);
if (operand)
op2 = intnum_tobv(op2static, operand);
if (!operand && op != YASM_EXPR_NEG && op != YASM_EXPR_NOT &&
op != YASM_EXPR_LNOT) {
yasm_error_set(YASM_ERROR_ARITHMETIC,
N_("operation needs an operand"));
BitVector_Empty(result);
return 1;
}
/* A operation does a bitvector computation if result is allocated. */
switch (op) {
case YASM_EXPR_ADD:
BitVector_add(result, op1, op2, &carry);
break;
case YASM_EXPR_SUB:
BitVector_sub(result, op1, op2, &carry);
break;
case YASM_EXPR_MUL:
BitVector_Multiply(result, op1, op2);
break;
case YASM_EXPR_DIV:
/* TODO: make sure op1 and op2 are unsigned */
if (BitVector_is_empty(op2)) {
yasm_error_set(YASM_ERROR_ZERO_DIVISION, N_("divide by zero"));
BitVector_Empty(result);
return 1;
} else
BitVector_Divide(result, op1, op2, spare);
break;
case YASM_EXPR_SIGNDIV:
if (BitVector_is_empty(op2)) {
yasm_error_set(YASM_ERROR_ZERO_DIVISION, N_("divide by zero"));
BitVector_Empty(result);
return 1;
} else
BitVector_Divide(result, op1, op2, spare);
break;
case YASM_EXPR_MOD:
/* TODO: make sure op1 and op2 are unsigned */
if (BitVector_is_empty(op2)) {
yasm_error_set(YASM_ERROR_ZERO_DIVISION, N_("divide by zero"));
BitVector_Empty(result);
return 1;
} else
BitVector_Divide(spare, op1, op2, result);
break;
case YASM_EXPR_SIGNMOD:
if (BitVector_is_empty(op2)) {
yasm_error_set(YASM_ERROR_ZERO_DIVISION, N_("divide by zero"));
BitVector_Empty(result);
return 1;
} else
BitVector_Divide(spare, op1, op2, result);
break;
case YASM_EXPR_NEG:
BitVector_Negate(result, op1);
break;
case YASM_EXPR_NOT:
Set_Complement(result, op1);
break;
case YASM_EXPR_OR:
Set_Union(result, op1, op2);
break;
case YASM_EXPR_AND:
Set_Intersection(result, op1, op2);
break;
case YASM_EXPR_XOR:
Set_ExclusiveOr(result, op1, op2);
break;
case YASM_EXPR_XNOR:
Set_ExclusiveOr(result, op1, op2);
Set_Complement(result, result);
break;
case YASM_EXPR_NOR:
Set_Union(result, op1, op2);
Set_Complement(result, result);
break;
case YASM_EXPR_SHL:
if (operand->type == INTNUM_L && operand->val.l >= 0) {
BitVector_Copy(result, op1);
BitVector_Move_Left(result, (N_int)operand->val.l);
} else /* don't even bother, just zero result */
BitVector_Empty(result);
break;
case YASM_EXPR_SHR:
if (operand->type == INTNUM_L && operand->val.l >= 0) {
BitVector_Copy(result, op1);
carry = BitVector_msb_(op1);
count = (N_int)operand->val.l;
while (count-- > 0)
BitVector_shift_right(result, carry);
} else /* don't even bother, just zero result */
BitVector_Empty(result);
break;
case YASM_EXPR_LOR:
BitVector_Empty(result);
BitVector_LSB(result, !BitVector_is_empty(op1) ||
!BitVector_is_empty(op2));
break;
case YASM_EXPR_LAND:
BitVector_Empty(result);
BitVector_LSB(result, !BitVector_is_empty(op1) &&
!BitVector_is_empty(op2));
break;
case YASM_EXPR_LNOT:
BitVector_Empty(result);
BitVector_LSB(result, BitVector_is_empty(op1));
break;
case YASM_EXPR_LXOR:
BitVector_Empty(result);
BitVector_LSB(result, !BitVector_is_empty(op1) ^
!BitVector_is_empty(op2));
break;
case YASM_EXPR_LXNOR:
BitVector_Empty(result);
BitVector_LSB(result, !(!BitVector_is_empty(op1) ^
!BitVector_is_empty(op2)));
break;
case YASM_EXPR_LNOR:
BitVector_Empty(result);
BitVector_LSB(result, !(!BitVector_is_empty(op1) ||
!BitVector_is_empty(op2)));
break;
case YASM_EXPR_EQ:
BitVector_Empty(result);
BitVector_LSB(result, BitVector_equal(op1, op2));
break;
case YASM_EXPR_LT:
BitVector_Empty(result);
BitVector_LSB(result, BitVector_Compare(op1, op2) < 0);
break;
case YASM_EXPR_GT:
BitVector_Empty(result);
BitVector_LSB(result, BitVector_Compare(op1, op2) > 0);
break;
case YASM_EXPR_LE:
BitVector_Empty(result);
BitVector_LSB(result, BitVector_Compare(op1, op2) <= 0);
break;
case YASM_EXPR_GE:
BitVector_Empty(result);
BitVector_LSB(result, BitVector_Compare(op1, op2) >= 0);
break;
case YASM_EXPR_NE:
BitVector_Empty(result);
BitVector_LSB(result, !BitVector_equal(op1, op2));
break;
case YASM_EXPR_SEG:
yasm_error_set(YASM_ERROR_ARITHMETIC, N_("invalid use of '%s'"),
"SEG");
break;
case YASM_EXPR_WRT:
yasm_error_set(YASM_ERROR_ARITHMETIC, N_("invalid use of '%s'"),
"WRT");
break;
case YASM_EXPR_SEGOFF:
yasm_error_set(YASM_ERROR_ARITHMETIC, N_("invalid use of '%s'"),
":");
break;
case YASM_EXPR_IDENT:
if (result)
BitVector_Copy(result, op1);
break;
default:
yasm_error_set(YASM_ERROR_ARITHMETIC,
N_("invalid operation in intnum calculation"));
BitVector_Empty(result);
return 1;
}
/* Try to fit the result into 32 bits if possible */
if (acc->type == INTNUM_BV)
BitVector_Destroy(acc->val.bv);
intnum_frombv(acc, result);
return 0;
}
/* Function used by conversion routines to actually perform the conversion.
*
* ptr -> the array to return the little-endian floating point value into.
* flt -> the floating point value to convert.
* byte_size -> the size in bytes of the output format.
* mant_bits -> the size in bits of the output mantissa.
* implicit1 -> does the output format have an implicit 1? 1=yes, 0=no.
* exp_bits -> the size in bits of the output exponent.
*
* Returns 0 on success, 1 if overflow, -1 if underflow.
*/
static int
floatnum_get_common(const yasm_floatnum *flt, /*@out@*/ unsigned char *ptr,
N_int byte_size, N_int mant_bits, int implicit1,
N_int exp_bits)
{
long exponent = (long)flt->exponent;
wordptr output;
charptr buf;
unsigned int len;
unsigned int overflow = 0, underflow = 0;
int retval = 0;
long exp_bias = (1<<(exp_bits-1))-1;
long exp_inf = (1<<exp_bits)-1;
output = BitVector_Create(byte_size*8, TRUE);
/* copy mantissa */
BitVector_Interval_Copy(output, flt->mantissa, 0,
(N_int)((MANT_BITS-implicit1)-mant_bits),
mant_bits);
/* round mantissa */
if (BitVector_bit_test(flt->mantissa, (MANT_BITS-implicit1)-(mant_bits+1)))
BitVector_increment(output);
if (BitVector_bit_test(output, mant_bits)) {
/* overflowed, so zero mantissa (and set explicit bit if necessary) */
BitVector_Empty(output);
BitVector_Bit_Copy(output, mant_bits-1, !implicit1);
/* and up the exponent (checking for overflow) */
if (exponent+1 >= EXP_INF)
overflow = 1;
else
exponent++;
}
/* adjust the exponent to the output bias, checking for overflow */
exponent -= EXP_BIAS-exp_bias;
if (exponent >= exp_inf)
overflow = 1;
else if (exponent <= 0)
underflow = 1;
/* underflow and overflow both set!? */
if (underflow && overflow)
yasm_internal_error(N_("Both underflow and overflow set"));
/* check for underflow or overflow and set up appropriate output */
if (underflow) {
BitVector_Empty(output);
exponent = 0;
if (!(flt->flags & FLAG_ISZERO))
retval = -1;
} else if (overflow) {
BitVector_Empty(output);
exponent = exp_inf;
retval = 1;
}
/* move exponent into place */
BitVector_Chunk_Store(output, exp_bits, mant_bits, (N_long)exponent);
/* merge in sign bit */
BitVector_Bit_Copy(output, byte_size*8-1, flt->sign);
/* get little-endian bytes */
buf = BitVector_Block_Read(output, &len);
if (len < byte_size)
yasm_internal_error(
N_("Byte length of BitVector does not match bit length"));
/* copy to output */
memcpy(ptr, buf, byte_size*sizeof(unsigned char));
/* free allocated resources */
yasm_xfree(buf);
BitVector_Destroy(output);
return retval;
}
yasm_floatnum *
yasm_floatnum_create(const char *str)
{
yasm_floatnum *flt;
int dec_exponent, dec_exp_add; /* decimal (powers of 10) exponent */
int POT_index;
wordptr operand[2];
int sig_digits;
int decimal_pt;
boolean carry;
flt = yasm_xmalloc(sizeof(yasm_floatnum));
flt->mantissa = BitVector_Create(MANT_BITS, TRUE);
/* allocate and initialize calculation variables */
operand[0] = BitVector_Create(MANT_BITS, TRUE);
operand[1] = BitVector_Create(MANT_BITS, TRUE);
dec_exponent = 0;
sig_digits = 0;
decimal_pt = 1;
/* set initial flags to 0 */
flt->flags = 0;
/* check for + or - character and skip */
if (*str == '-') {
flt->sign = 1;
str++;
} else if (*str == '+') {
flt->sign = 0;
str++;
} else
flt->sign = 0;
/* eliminate any leading zeros (which do not count as significant digits) */
while (*str == '0')
str++;
/* When we reach the end of the leading zeros, first check for a decimal
* point. If the number is of the form "0---0.0000" we need to get rid
* of the zeros after the decimal point and not count them as significant
* digits.
*/
if (*str == '.') {
str++;
while (*str == '0') {
str++;
dec_exponent--;
}
} else {
/* The number is of the form "yyy.xxxx" (where y <> 0). */
while (isdigit(*str)) {
/* See if we've processed more than the max significant digits: */
if (sig_digits < MANT_SIGDIGITS) {
/* Multiply mantissa by 10 [x = (x<<1)+(x<<3)] */
BitVector_shift_left(flt->mantissa, 0);
BitVector_Copy(operand[0], flt->mantissa);
BitVector_Move_Left(flt->mantissa, 2);
carry = 0;
BitVector_add(operand[1], operand[0], flt->mantissa, &carry);
/* Add in current digit */
BitVector_Empty(operand[0]);
BitVector_Chunk_Store(operand[0], 4, 0, (N_long)(*str-'0'));
carry = 0;
BitVector_add(flt->mantissa, operand[1], operand[0], &carry);
} else {
/* Can't integrate more digits with mantissa, so instead just
* raise by a power of ten.
*/
dec_exponent++;
}
sig_digits++;
str++;
}
if (*str == '.')
str++;
else
decimal_pt = 0;
}
if (decimal_pt) {
/* Process the digits to the right of the decimal point. */
while (isdigit(*str)) {
/* See if we've processed more than 19 significant digits: */
if (sig_digits < 19) {
/* Raise by a power of ten */
dec_exponent--;
/* Multiply mantissa by 10 [x = (x<<1)+(x<<3)] */
BitVector_shift_left(flt->mantissa, 0);
BitVector_Copy(operand[0], flt->mantissa);
BitVector_Move_Left(flt->mantissa, 2);
carry = 0;
BitVector_add(operand[1], operand[0], flt->mantissa, &carry);
/* Add in current digit */
BitVector_Empty(operand[0]);
BitVector_Chunk_Store(operand[0], 4, 0, (N_long)(*str-'0'));
carry = 0;
BitVector_add(flt->mantissa, operand[1], operand[0], &carry);
}
sig_digits++;
str++;
}
}
if (*str == 'e' || *str == 'E') {
str++;
/* We just saw the "E" character, now read in the exponent value and
* add it into dec_exponent.
*/
dec_exp_add = 0;
sscanf(str, "%d", &dec_exp_add);
dec_exponent += dec_exp_add;
}
/* Free calculation variables. */
BitVector_Destroy(operand[1]);
BitVector_Destroy(operand[0]);
/* Normalize the number, checking for 0 first. */
if (BitVector_is_empty(flt->mantissa)) {
/* Mantissa is 0, zero exponent too. */
flt->exponent = 0;
/* Set zero flag so output functions don't see 0 value as underflow. */
flt->flags |= FLAG_ISZERO;
/* Return 0 value. */
return flt;
}
/* Exponent if already norm. */
flt->exponent = (unsigned short)(0x7FFF+(MANT_BITS-1));
floatnum_normalize(flt);
/* The number is normalized. Now multiply by 10 the number of times
* specified in DecExponent. This uses the power of ten tables to speed
* up this operation (and make it more accurate).
*/
if (dec_exponent > 0) {
POT_index = 0;
/* Until we hit 1.0 or finish exponent or overflow */
while ((POT_index < 14) && (dec_exponent != 0) &&
(flt->exponent != EXP_INF)) {
/* Find the first power of ten in the table which is just less than
* the exponent.
*/
while (dec_exponent < POT_TableP[POT_index].dec_exponent)
POT_index++;
if (POT_index < 14) {
/* Subtract out what we're multiplying in from exponent */
dec_exponent -= POT_TableP[POT_index].dec_exponent;
/* Multiply by current power of 10 */
floatnum_mul(flt, &POT_TableP[POT_index].f);
}
}
} else if (dec_exponent < 0) {
POT_index = 0;
/* Until we hit 1.0 or finish exponent or underflow */
while ((POT_index < 14) && (dec_exponent != 0) &&
(flt->exponent != EXP_ZERO)) {
/* Find the first power of ten in the table which is just less than
* the exponent.
*/
while (dec_exponent > POT_TableN[POT_index].dec_exponent)
POT_index++;
if (POT_index < 14) {
/* Subtract out what we're multiplying in from exponent */
dec_exponent -= POT_TableN[POT_index].dec_exponent;
/* Multiply by current power of 10 */
floatnum_mul(flt, &POT_TableN[POT_index].f);
}
}
}
/* Round the result. (Don't round underflow or overflow). Also don't
* increment if this would cause the mantissa to wrap.
*/
if ((flt->exponent != EXP_INF) && (flt->exponent != EXP_ZERO) &&
!BitVector_is_full(flt->mantissa))
BitVector_increment(flt->mantissa);
return flt;
}
/* acc *= op */
static void
floatnum_mul(yasm_floatnum *acc, const yasm_floatnum *op)
{
long expon;
wordptr product, op1, op2;
long norm_amt;
/* Compute the new sign */
acc->sign ^= op->sign;
/* Check for multiply by 0 */
if (BitVector_is_empty(acc->mantissa) || BitVector_is_empty(op->mantissa)) {
BitVector_Empty(acc->mantissa);
acc->exponent = EXP_ZERO;
return;
}
/* Add exponents, checking for overflow/underflow. */
expon = (((int)acc->exponent)-EXP_BIAS) + (((int)op->exponent)-EXP_BIAS);
expon += EXP_BIAS;
if (expon > EXP_MAX) {
/* Overflow; return infinity. */
BitVector_Empty(acc->mantissa);
acc->exponent = EXP_INF;
return;
} else if (expon < EXP_MIN) {
/* Underflow; return zero. */
BitVector_Empty(acc->mantissa);
acc->exponent = EXP_ZERO;
return;
}
/* Add one to the final exponent, as the multiply shifts one extra time. */
acc->exponent = (unsigned short)(expon+1);
/* Allocate space for the multiply result */
product = BitVector_Create((N_int)((MANT_BITS+1)*2), FALSE);
/* Allocate 1-bit-longer fields to force the operands to be unsigned */
op1 = BitVector_Create((N_int)(MANT_BITS+1), FALSE);
op2 = BitVector_Create((N_int)(MANT_BITS+1), FALSE);
/* Make the operands unsigned after copying from original operands */
BitVector_Copy(op1, acc->mantissa);
BitVector_MSB(op1, 0);
BitVector_Copy(op2, op->mantissa);
BitVector_MSB(op2, 0);
/* Compute the product of the mantissas */
BitVector_Multiply(product, op1, op2);
/* Normalize the product. Note: we know the product is non-zero because
* both of the original operands were non-zero.
*
* Look for the highest set bit, shift to make it the MSB, and adjust
* exponent. Don't let exponent go negative.
*/
norm_amt = (MANT_BITS*2-1)-Set_Max(product);
if (norm_amt > (long)acc->exponent)
norm_amt = (long)acc->exponent;
BitVector_Move_Left(product, (N_int)norm_amt);
acc->exponent -= (unsigned short)norm_amt;
/* Store the highest bits of the result */
BitVector_Interval_Copy(acc->mantissa, product, 0, MANT_BITS, MANT_BITS);
/* Free allocated variables */
BitVector_Destroy(product);
BitVector_Destroy(op1);
BitVector_Destroy(op2);
}
