Programming

Hi all, newbie here.
Does anyone know if it is possible to use GCC or Clang to multiply
two unsigned numbers and have it use for intel instructions, the mull instruction or an imul. I can't figure how to word this to accomplish this task:

Code:

(int)(((unsigned long long)result * (unsigned)2290649225) >> 37);

result is max of 2^17 bits, and trying to retrieve high word >> 5 after a
mull or imul instruction. The above wording creates two multiply instructions.
This wording creates one instruction:

Code:

(int)(((unsigned long long)result * (unsigned)1145324613) >> 36);

Not sure intel can handle first and that's why gcc breaks into two multiplies???
I believe the second will accomplish my task, but now need to recheck all my code.
Thanx, and I'll probably get kicked (was smoking and typing)
Pheonix

How many bits is your architecture?

---------- Post updated at 10:25 AM ---------- Previous update was at 10:06 AM ----------

Researching this a bit, gcc asm doesn't have MUL/MULL, differentiating between the two based on their source operands. Or rather, it does have MULL, but if you use it it's VERY picky about which types it'll accept. Trying to figure out how to work this...

---------- Post updated at 10:33 AM ---------- Previous update was at 10:25 AM ----------

Here is how you get a 64-bit result from a 32-bit multiply in x86 gcc:

Code:

#include <stdio.h>
#include <limits.h>

int main(void)
{
        unsigned long a=INT_MAX,b=INT_MAX-1;

        printf("a=%lu b=%lu\n", a, b);

        // Need to use the special one-operand mul instruction, which
        // dumps its result in eax:edx.
        asm( "mul %1"
                : "=a"(a), "=d"(b) /* output registers eax, edx */
                : "a"(a), "r"(b) /* input registers eax, any */ );

        printf("a=%lu b=%lu\n", a, b);
}

Hope this helps.

Thanx for reply, however maybe title a little misleading? I am trying to write "C"
code, usable by different processors. On an Intel processor using GCC or Clang
I wish to have:

Code:

(int)(((unsigned long long)result * (unsigned)2290649225) >> 37);

to look like:

Code:

mov $2290649225, %eax
imul (%ebp)
mov %edx, %eax
shr   %5, %eax
instead of:
imul $-2004318071, %edx, %esi
mov $-2004318071,%ecx
mov (%ebp), %eax
mull %ecx
lots more code
shr %5, %eax

if I use the second "C" language code:

Code:

(int)(((unsigned long long)result * (unsigned)1145324613) >> 36);

which is half of $2290649225 i get the first compiled result.
On i386 vs x86_64 the above codes should only differ in extension "l""d", but I believe the exact register reference with get you though both as "asm".
Again, I am trying to write "C" code, so I guess is there a way to tell compilers that (unsigned)2290649225, (uint32_t)2290649225, 2290649225U is an unsigned 32-bit number so shorter code is used?

Thanx Corona688! You got me in the direction I needed! Had me explain so understood what GCC might think? Strange that the 31st bit of a constant does this. Apparently the int result gets converted as long long then unsigned long long.
Resolved!

Code:

(int)(((unsigned long long)((unsigned)result) * (unsigned)2290649225) >> 37);

Sincere thanks! Pheonix

Not all processors have imul.

If you insist on an exact sequence of instructions for it to follow, inline asm is the way to go.

It wasn't about the imul instruction of intel, it was about GCC insisting that my "C" language statement wasn't a 32x32bit multiply just because the constant had the 31st bit set. GCC insisted that it should be done as a 64x32bit multiply. I saw no reason for a 2^17 * 2^32 should be done differently than a 2^17 *( 2^32 >> 1) considering they were unsigned multiplication. No reason to take high 32 of 2^17 = 0 * 2290649225 + low 32 of 2^17 * 2290649225, add in sign adjustment for the 2^17 for the answer. Especially since it doesn't do that on 2^17 * (2^32 >> 1).

I probably really shouldn't care how a compiler interprets a "C" statement. By the use of one "unsigned" where you normally don't need it, I can execute 4 instructions instead of 12 instructions. I never knew that it considered converting to "unsigned long long" was the same as converting to "long long" in this one instance. On a PPC execute 9 instructions instead of 21. And if done ppc asm only 5 (extra mr).