Re: GCC has problems with 64-bit multiplication
On Thursday 08 February 2007 16:02, Graham Stott wrote:
All,
Not a bug in GCC the result is correct as you've only asked for a 32-bit
multiply.
Hi again,
The problem was not that mull is used, but that gcc 3.4.6 generates highly
un-optimized code when I for example multiply a 16-bit integer by a 64-bit
integer.
It actually generates code where three multiplications are used instead of
two. That has a speed impact.
Code:
#include stdio.h
#include sys/types.h
int main() {
int64_t temp;
int16_t x;
temp *= x;
printf(%lld\n, temp);
return 0;
}
objdump -D ./a.out
8048507: 89 4d e8mov%ecx,0xffe8(%ebp)
804850a: 31 c0 xor%eax,%eax
804850c: 89 55 ecmov%edx,0xffec(%ebp)
804850f: f7 65 e8mull 0xffe8(%ebp)
8048512: 6b 7d ec 00 imul $0x0,0xffec(%ebp),%edi
8048516: 89 d6 mov%edx,%esi
8048518: 89 c1 mov%eax,%ecx
804851a: 01 fe add%edi,%esi
804851c: 6b 45 e8 00 imul $0x0,0xffe8(%ebp),%eax
8048520: 83 e4 f0and$0xfff0,%esp
8048523: 83 ec 14sub$0x14,%esp
8048526: 8d 1c 06lea(%esi,%eax,1),%ebx
--HPS
GCC has problems with 64-bit multiplication
Test program:
#include stdio.h
#include sys/types.h
int main() {
int32_t a = 0x4000;
int16_t b = 0x4000;
int64_t c = a * b;
printf(0x%016llx\n, c);
return 0;
}
%cc test.c
%./a.out
0x
%gcc --version
gcc (GCC) 3.4.6 [FreeBSD] 20060305
Copyright (C) 2006 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
Generated assembly code:
8048514: c7 45 fc 00 00 00 40movl $0x4000,0xfffc(%ebp)
804851b: 66 c7 45 fa 00 40 movw $0x4000,0xfffa(%ebp)
8048521: 0f bf 45 fa movswl 0xfffa(%ebp),%eax
8048525: 0f af 45 fc imul 0xfffc(%ebp),%eax
XXX this instruction is probably the bug:
8048529: 99 cltd
804852a: 89 45 f0mov%eax,0xfff0(%ebp)
804852d: 89 55 f4mov%edx,0xfff4(%ebp)
8048530: 83 ec 04sub$0x4,%esp
8048533: ff 75 f4pushl 0xfff4(%ebp)
8048536: ff 75 f0pushl 0xfff0(%ebp)
8048539: 68 cb 85 04 08 push $0x80485cb
804853e: e8 49 fe ff ff call 804838c _init+0x24
8048543: 83 c4 10add$0x10,%esp
--HPS
Re: GCC has problems with 64-bit multiplication
All,
Not a bug in GCC the result is correct as you've only asked for a 32-bit
multiply.
--- Hans Petter Selasky [EMAIL PROTECTED] wrote:
Test program:
#include stdio.h
#include sys/types.h
int main() {
int32_t a = 0x4000;
int16_t b = 0x4000;
int64_t c = a * b;
^ this is a 32-bit multiply with the result widened
to 64-bit,
printf(0x%016llx\n, c);
return 0;
}
Re: GCC has problems with 64-bit multiplication
On Thursday 08 February 2007 16:02, Graham Stott wrote:
All,
Not a bug in GCC the result is correct as you've only asked for a 32-bit
multiply.
Ok, thanks. But really I don't want to do ((int64_t)a) * b, which I know
works, hence that is very much slower than a * b on intel processors, hence
the mull instruction will be used instead of imul.
I found the following option by googling:
-mwide-multiply multiplies of 32 bits are 64
Is there an __attribute__() that I can use that will enable this for one
multiplication, and not all ? Or something similar ?
--- Hans Petter Selasky [EMAIL PROTECTED] wrote:
Test program:
#include stdio.h
#include sys/types.h
int main() {
int32_t a = 0x4000;
int16_t b = 0x4000;
int64_t c = a * b;
^ this is a 32-bit multiply with the result
widened to 64-bit,
printf(0x%016llx\n, c);
return 0;
}
--HPS
