Subject: Re[4]: [PATCH] fork_init: fix division by zero

From: Yuri Tikhonov <[email-masked]>
Date: Wed, 10 Dec 2008 16:25:53 +0300

Hello David,

On Wednesday, December 10, 2008 you wrote:

> Yuri Tikhonov <[email-masked]> wrote:

>>  Here we believe in preprocessor: since all PAGE_SIZE, 8, and 
>> THREAD_SIZE are the constants we expect it will calculate this.

> The preprocessor shouldn't be calculating this.  I believe it will _only_
> calculate expressions for #if.  In the situation you're referring to, it
> should perform a substitution and nothing more.  The preprocessor doesn't
> necessarily know how to handle the types involved.

> In any case, there's an easy way to find out: you can ask the compiler to give
> you the result of running the source through the preprocessor only. For
> instance, if you run this:

>         #define PAGE_SIZE 4096
>         #define THREAD_SIZE 8192
>         unsigned long mempages;
>         unsigned long jump(void)
>         {
>                 unsigned long max_threads;
>                 max_threads = mempages * PAGE_SIZE / (8 * THREAD_SIZE);
>                 return max_threads;
>         }

> through "gcc -E", you get:

>         # 1 "calc.c"
>         # 1 "<built-in>"
>         # 1 "<command line>"
>         # 1 "calc.c"
>         unsigned long mempages;
>         unsigned long jump(void)
>         {
>          unsigned long max_threads;
>          max_threads = mempages * 4096 / (8 * 8192);
>          return max_threads;
>         }

>>  In any case, adding braces as follows probably would be better:
>> 
>> +     max_threads = mempages * (PAGE_SIZE / (8 * THREAD_SIZE));

> I think you mean brackets, not braces '{}'.

 Yes, it was a typo.

>>  Right ?

> Definitely not.

> I added this function to the above:

>         unsigned long alt(void)
>         {
>                 unsigned long max_threads;
>                 max_threads = mempages * (PAGE_SIZE / (8 * THREAD_SIZE));
>                 return max_threads;
>         }

> and ran it through "gcc -S -O2" for x86_64:

>         jump:
>                 movq    mempages(%rip), %rax
>                 salq    $12, %rax
>                 shrq    $16, %rax
>                 ret
>         alt:
>                 xorl    %eax, %eax
>                 ret

> Note the difference?  In jump(), x86_64 first multiplies mempages by 4096, and
> _then_ divides by 8*8192.

> In alt(), it just returns 0 because the compiler realised that you're
> multiplying by 0.

 I think Geert has already commented this: you've compiled your alt() 
functions having 4K PAGE_SIZE and 8K THREAD_SIZE - this case is 
handled by the old code in fork_init.

> If you're going to bracket the expression, it must be:

>                 max_threads = (mempages * PAGE_SIZE) / (8 * THREAD_SIZE);

> which should be superfluous.

>>  E.g. here is the result from this line as produced by cross-gcc 
>> 4.2.2:
>> 
>>         lis     r9,0
>>         rlwinm  r29,r29,2,16,29
>>         stw     r29,0(r9)
>> 
>>  As you see - only rotate-left, i.e. multiplication to the constant.

> Ummm...  On powerpc, I believe rotate-left would be a division as it does the
> bit-numbering and the bit direction the opposite way to more familiar CPUs
> such as x86.

 On powerpc shifting left is multiplication by 2, as this has the most 
significant bit first.

 Regards, Yuri

 --
 Yuri Tikhonov, Senior Software Engineer
 Emcraft Systems, www.emcraft.com