Build on AIX fails because of "restrict" pointers

[smuehlst]

I'm trying to build OpenJPEG on AIX with the xlc compiler. I invoked cmake like this:

CC=xlc cmake .

Running make fails with the following error:

(1)$ make
[  2%] Building C object src/lib/openjp2/CMakeFiles/openjp2.dir/dwt.c.o
"/home/stm/src/openjpeg_aix/src/lib/openjp2/openjpeg.h", line 75.9: 1506-224 (I) Incorrect pragma ignored.
"/home/stm/src/openjpeg_aix/src/lib/openjp2/dwt.c", line 764.20: 1506-1418 (E) Assignment between restrict pointers "fl" and "fw" is not allowed. Only outer-to-inner scope assignments between restrict pointers are allowed.
make: 1254-004 The error code from the last command is 1.


Stop.
make: 1254-004 The error code from the last command is 2.


Stop.
make: 1254-004 The error code from the last command is 2.

The problematic source code is this:

static void opj_v4dwt_decode_step2(opj_v4_t* l, opj_v4_t* w, OPJ_INT32 k, OPJ_INT32 m, OPJ_FLOAT32 c)
{
        OPJ_FLOAT32* restrict fl = (OPJ_FLOAT32*) l;
        OPJ_FLOAT32* restrict fw = (OPJ_FLOAT32*) w;
        OPJ_INT32 i;
        for(i = 0; i < m; ++i){
                ...
                fl = fw;
                fw += 8;
        }

If I understand the C99 standard correctly, then the assignment fl = fw is undefined behavior because fl and fw are declared at the same level. See example 4 in "6.7.3.1 Formal definition of restrict" in the C99 standard:

{
    int * restrict p1;
    int * restrict q1;
    p1 = q1; // undefined behavior
    {
        int * restrict p2 = p1; // valid
        int * restrict q2 = q1; // valid
        p1 = q2; // undefined behavior
        p2 = q2; // undefined behavior
    }
}

[malaterre]

Code first appeared in: dbeebe72#diff-1ea8331903552f12aee1bc3924cd0780R658

@fodevaux do you remember what the code was supposed to do. AFAIK I do not see the point of restrict keywords at the beginning of the funtion.

[fodevaux]

Sorry, I won't be able to help you in this one...

[Dzonatas]

The original patch I submitted had no change to the lossless compress/decompress and did not have the restrict keywords. I wrote in the (GCC specific) single vector variable before that was wrote out with the expanded, autovectorized code and wrapped with SSE intrinsics. Note: I did not apply it to the lossless code due to the 80/20 rule, anchored to specific integer math.

[SegHaxx]

I refactored those loops a bit from what Dzonatas wrote. The restrict pointers were an attempt to make GCC's autovectorizer happy, at the time if all pointers were not restrict then it would refuse to vectorize. Current GCC is smarter now and may not require this.

I guess for now, you could just drop the 'restrict'. This code is all a bit hairy and I should probably re-work it anyway. It was all an attempt to keep the icache/BTB footprint down by merging some of the original loops, but the optimizer seems insistent on duplicating them back anyway. :P

[SegHaxx]

Re-reading the spec, it seems using restrict is indeed invalid here. If that kills autovectorization, then oh well...