// I am assuming something like this
typedef long FixedPoint;
// assuming long is 32 bits
#define FP_INTEGER_PRECISION 16
#define FP_DECIMAL_PRECISION 16
#define FP_INTEGER_MASK 0xFF00
#define FP_DECIMAL_MASK 0x00FF

FixedPoint operator*(FixedPoint op1,FixedPoint op2)
{
FixedPoint op2int = op2 > FP_DECIMAL_PRECISION;
FixedPoint op2dec = op2 & FP_DECIMAL_MASK;
FixedPoint product = 0;
product = op1 * op2dec;
product = product > FP_DECIMAL_PRECISION;
product += op1 * op2high;
return product;
}

I haven't had time to test this code...so please respond here or email me if it has any errors. Also, please note that the potential for overflow is enormous. It is no different than multiplying 2 integers, but it is easy to forget that the highest 32 bit fixed point number (if 16x16 format is assumed) is the same as a 16 bit number, so 300*254 doesn't fit.

[This message has been edited by Xai (edited October 17, 1999).]

fixed FixedMul(fixed num1, fixed num2)
{
fixed result;
bool sign=0;
asm
{
//num1 = ebx = eax
//num2 = ecx = edx
FixedMul_top:
mov ebx, num1
mov ecx, num2
xor eax, eax
xor edx, edx
//Check for negative numbers...
cmp ebx, 0
jg FixedMul_next1
mov sign, 1
neg ebx
FixedMul_next1:
cmp ecx, 0
jg FixedMul_next2
xor sign, 1
neg ecx
FixedMul_next2:
//num1.high * num2.high
mov eax, ebx
mov edx, ecx
shr eax, 16
shr edx, 16
mul edx
shl eax, 16
mov result, eax
//num1.high * num2.low
mov eax, ebx
mov dx, cx
shr eax, 16
mul edx
add result, eax
//num2.high * num1.low
xor eax, eax
mov edx, ecx
mov ax, bx
shr edx, 16
mul edx
add result, eax
//num1.low * num2.low
xor eax, eax
xor edx, edx
mov ax, bx
mov dx, cx
mul edx
shr eax, 16
add result, eax
//If sign variable is true, negate result
cmp sign, 0
jz FixedMul_bottom
neg result
FixedMul_bottom:
}
return (result);
}

It takes 2 32-bit fixed numbers, and returns a 32-bit fixed product. The precision is 16 bits, that is, shift right 16 times to get the integer value(but I'm sure you knew that). Optimize it further if you can/want to...let me know how it works for you or if you have questions.

asmlock@aol.com

I need to multiply two fixedpoint variables.
The following snippet is from a friend. But it does'nt work in MS-Visual C++ 5:

Fixedpoint FixedMul(long num1, long num2);
#pragma aux FixedMul = \
"imul edx" \
"add eax, 8000h" \
"adc edx, 0" \
"shrd eax, edx, 16" \
parm caller [eax] [edx] \
value [eax] \
modify [eax edx];

Can anybody help me by converting the above snippet into plain C/C++/Pascal/Delphi.
Or just ASM without the "shrd"-command.
The Debugger stops on that line with "unknown command"...

Thanks!
Nazghul