Linux and Windows generate different binaries

["Klaus Kruse Pedersen (Klaus)" <klauskpedersen at rdamicro dot com>]

I have seen reproducible builds being discussed here, but what is the
position on inter c-lib and OS reproducible builds?

As it happens, I just hit by an interesting case were different OS'es
generate (significant) different code. The difference originate from a
relatively small memory ordering difference in the 'lim2' / tree-ssa-
loop-im  pass". Memory references show something like:

    Memory reference 1: AGC_S_error
    Memory reference 2: AGC_ACC_error
    Memory reference 3: AGC_Coeff
    Memory reference 4: *_35
    Memory reference 5: *_9

Investigation show that a call to qsort() without any tie breaker is
the root-cause:

    static int
    sort_bbs_in_loop_postorder_cmp (const void *bb1_, const void *bb2_)
    {
      basic_block bb1 = *(basic_block *)const_cast<void *>(bb1_);
      basic_block bb2 = *(basic_block *)const_cast<void *>(bb2_);
      struct loop *loop1 = bb1->loop_father;
      struct loop *loop2 = bb2->loop_father;
 ->  fprintf(stderr, "Debug: loop1->num == loop2->num (%d,%d)\n",
                     loop1->num, loop2->num);
      if (loop1->num == loop2->num)
        return 0;
      return bb_loop_postorder[loop1->num] < bb_loop_postorder[loop2-
>num] ? -1 : 1;
    }

The debug statement show (for this test-case) that:

    loop1->num == loop2->num (1,1)
    loop1->num == loop2->num (1,1)
    loop1->num == loop2->num (1,1)
    [...]
    loop1->num == loop2->num (1,1)

... all (loop_father->num)'s are the same and thus the sort_bbs..()
function return 0. This guarantee that qsort shuffle the elements in a
implementation specific way.

Obviously not the best case if you are interested in reproducible
builds (and the qsort() implementation isn't part of your build).


Maybe it is time to add a stable sort?


BR, Klaus