Boost logo

Boost :

Subject: Re: [boost] [optional] Strict Aliasing Warnings on Trunk
From: Patrick Horgan (phorgan1_at_[hidden])
Date: 2009-12-18 14:00:02

Dean Michael Berris wrote:
> I've recently been seeing this error more and more especially on GCC with -Wall:
> /home/dean/boost/boost/optional/optional.hpp:407: warning:
> dereferencing pointer ‘<anonymous>’ does break strict-aliasing rules
> /home/dean/boost/boost/optional/optional.hpp:427: note: initialized from here
> and:
> /home/dean/boost/boost/function/function_base.hpp:321: warning:
> dereferencing type-punned pointer will break strict-aliasing rules
> /home/dean/boost/boost/function/function_base.hpp:325: warning:
> dereferencing type-punned pointer will break strict-aliasing rules
> This is on Linux and GCC 4.4.1.
> I'm not an expert in this regard but is there a way to either silence
> or avoid these warnings? Anything you want me to try from my end?
> Thanks in advance and I hope this helps.
It's a fair bit dangerous to silence these since it's the compiler's way
of telling you that you're invoking undefined behavior, and that when
you turn on optimization your code isn't going to work as expected.

The following program generates 6 warnings about breaking
strict-aliasing rules, and many would dismiss them. The correct output
of the program is:


but when optimization is turned on it's:


THAT's what the warning is trying to tell you, that the optimizer is
going to do things that you don't like. In this case seeing that acopy
is set to a and never touched again, strict aliasing lets it optimize by
just returning the original value of a at the end.

swaphalves(uint32_t a)
    uint32_t acopy=a;
    uint16_t *ptr=(uint16_t*)&acopy;// can't use static_cast<>, not legal.
                                    // you should be warned by that.
    uint16_t tmp=ptr[0];
    return acopy;

int main()
    uint32_t a;
    cout << hex << setfill('0') << setw(8) << a << endl;
    cout << setw(8) << a << endl;

Here's the (annotated) x86 assembler generated by gcc 4.4.1 for swaphalves.

    pushl %ebp
    movl %esp, %ebp
    subl $16, %esp
    movl 8(%ebp), %eax # get a in %eax
    movl %eax, -8(%ebp) # and store in in acopy
    leal -8(%ebp), %eax # now get eax pointing at acopy (ptr=&acopy)
    movl %eax, -12(%ebp) # save that ptr at -12(%ebp)
    movl -12(%ebp), %eax # get the ptr back in %eax
    movzwl (%eax), %eax # get 16 bits from ptr[0] in eax
    movw %ax, -2(%ebp) # store the 16 bits into tmp
    movl -12(%ebp), %eax # get the ptr back in eax
    addl $2, %eax # bump up by two to get to ptr[1]
    movzwl (%eax), %edx # get that 16 bits into %edx
    movl -12(%ebp), %eax # get ptr into eax
    movw %dx, (%eax) # store the 16 bits into ptr[1]
    movl -12(%ebp), %eax # get the ptr again
    leal 2(%eax), %edx # get the address of ptr[1] into edx
    movzwl -2(%ebp), %eax # get tmp into eax
    movw %ax, (%edx) # store into ptr[1]
    movl -8(%ebp), %eax # return original a.

Scary, isn't it? Of course you could use -fno-strict-aliasing to get
the right output, but the generated code won't be as good. A better way
to accomplish the same thing without the warning's or the incorrect
output is to define swaphalves like this:

swaphalves(uint32_t a)
    union swapem{
        uint32_t a;
        uint16_t b[2];
    swapem s={a};
    uint16_t tmp;
    return s.a;

This follows the rules and helps the compiler generate MUCH better code:

    pushl %ebp # save the original value of ebp
    movl %esp, %ebp # point ebp at the stack frame
    movl 8(%ebp), %eax # get a in eax
    popl %ebp # get the original ebp value back
    roll $16, %eax # swap the two halves of a and return it

Ignore strict aliasing warnings at your peril. But if you really want
to -Wno-strict-warnings will do it.


Boost list run by bdawes at, gregod at, cpdaniel at, john at