/* 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);
}
/*@-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;
}