strange gcc problem...

[RichSelian]

#include <stdio.h>

static void DoSwapPointer(void** pointer1, void** pointer2)
{
    void* tempPointer1 = *pointer1;
    void* tempPointer2 = *pointer2;
    *pointer1 = tempPointer2;
    *pointer2 = tempPointer1;
    return;
}

int main()
{
    int data1 = 15, data2 = 30;
    int* ptr1 = &data1;
    int* ptr2 = &data2;

    printf("DBGA %d %d\n", *ptr1, *ptr2);
    DoSwapPointer((void**)&ptr1, (void**)&ptr2);
    printf("DBGB %d %d\n", *ptr2, *ptr2);
    return 0;
}

I compile these code with "gcc main.c". The result is

DBGA 15 30
DBGB 30 15

But if I compile them with "gcc -O3 main.c". I will get

DBGA 15 30
DBGB 15 30

Isn't it strange? Why would this happen?

[RichSelian]

I posted the wrong code. The second "printf" line is "printf("DBGB %d %d\n", *ptr1, *ptr2);".

[User Name:]

You need a "volatile " in your declarations of your pointers.

[Memloop]

I can't reproduce the bug with gcc version 4.2.1. The O3 optimization level can sometimes break code, and I guess your version of GCC has an optimization bug in it.

[Memloop]

You need a "volatile " in your declarations of your pointers.

No, that's not how you use volatile. The volatile keyword is needed when the compiler can't see the flow of the program, i.e. when interrupts can happen or when dealing with memory mapped I/O.

[cyberfish]

Read up on pointer aliasing.

No, this is not a bug in GCC. It's a bug in your code.

[User Name:]

It's not a bug in GCC, it's ambiguity in your code. Tell GCC want you want, and it'll give it to you, be vague and tell GCC to cut out everything not needed, GCC will probably assume something that is needed is not because you're vague.

[cyberfish]

volatile will fix it, because it essentially disables all aliasing assumptions.

But that's not how volatile is intended to be used.

[User Name:]

I'll admit I'm no C guru. What is more correct?

[RichSelian]

Using "volatile" is right. I added "volatile" in my declaration and it works correctly under -O3 optimization.

static void DoSwapPointer(void** volatile pointer1, void** volatile pointer2)
{
    void* tempPointer1 = *pointer1;
    void* tempPointer2 = *pointer2;
    *pointer1 = tempPointer2;
    *pointer2 = tempPointer1;
    return;
}

[cyberfish]

It's a lesser known rule of C/C++ -

The compiler can assume that data will only be accessed by pointers of the same type.

This is called strict aliasing.

In this case you are accessing the int pointers using void double pointers, and the compiler assumed you won't do that, and decided that since DoSwapPointers takes in 2 void double pointers, it can't possibly change ptr1 and ptr2. Therefore it probably optimized out DoSwapPointers altogether.

I'm not sure what's the "correct" way to fix that. Why are you using void double pointers instead of int double pointers in the first place?

[cyberfish]

Or you can use -fno-strict-aliasing.

But your code is still wrong.

[Memloop]

I wonder why GCC doesn't produce the famous "dereferencing type-punned pointer will break strict-aliasing rules" warning?

[cyberfish]

It does if you use -Wall in combination with -O3.

cyberfish@cyberfish-desktop:/tmp$ gcc -Wall -O3 b.c
b.c: In function ‘main’:
b.c:7: warning: dereferencing pointer ‘ptr1.18’ does break strict-aliasing rules
b.c:19: note: initialized from here
b.c:8: warning: dereferencing pointer ‘ptr2.17’ does break strict-aliasing rules
b.c:19: note: initialized from here

And I get this output instead -

cyberfish@cyberfish-desktop:/tmp$ gcc b.c
cyberfish@cyberfish-desktop:/tmp$ ./a.out
DBGA 15 30
DBGB 15 15
cyberfish@cyberfish-desktop:/tmp$ gcc -O3 b.c
cyberfish@cyberfish-desktop:/tmp$ ./a.out
DBGA 15 30
DBGB 30 30

So it doesn't work even at -O0. The fact that it worked for you is just coincidence.

And adding volatile doesn't change anything for me, surprisingly.

This is GCC 4.4.1

[cyberfish]

Uh oops I was running the uncorrected code.

With the corrected code I get same results (no swapping with -O3).

And volatile does "fix it".