char and strict aliasing

Hello all,

consider the following code:

typedef char T;
class test {
        T *data;
public:
        void f(T, T, T);
        void f2(T, T, T);
};

void test::f(T a, T b, T c)
{
        data[3] = a;
        data[4] = b;
        data[5] = c;
}

void test::f2(T a, T b, T c)
{
        T *d = data;
        d[3] = a;
        d[4] = b;
        d[5] = c;
}

g++ (v4.3, options "-fomit-frame-pointer -O3 -S -Wall") for x86 produces the
following nice code for f2:
        movq (%rdi), %rax
        movb %sil, 3(%rax)
        movb %dl, 4(%rax)
        movb %cl, 5(%rax)
        ret
but quite strange code for f:
        movq (%rdi), %rax
        movb %sil, 3(%rax)
        movq (%rdi), %rax
        movb %dl, 4(%rax)
        movq (%rdi), %rax
        movb %cl, 5(%rax)
        ret

Apparently the pointer data is reloaded after every store. I guess this is
due to the aliasing rules for char types: for some strange reason data
might point to itself and to be correct it has to be reloaded after every
store. Indeed replacing the char for an int gives the same code for f and
f2. IMO this is a bad language decision: It's highly inconsistent. Anyway,
having to live with it, I have to wonder how to implement a char type which
does not alias with everything.

Besides "char" I tried "unsigned char", "signed char", "uint8_t"
and "int8_t", all to no avail. Also the restrict keyword didn't help: g++
doesn't like it. As a last measure I tried a wrapper class:

typedef class my_char {
        char data;
public:
        my_char() { }
        my_char(char c) { data = c; }
        char operator=(char c) { return data = c; }
        char operator=(my_char c) { return data = c.data; }
        operator char() { return data; }
} T;

Amazingly, this produces byte by byte the same code as using a simple char.
g++ cannot be right about this one: Does "class { char x; }" really have
the same aliasing rules as "char"?

Or am I missing something obvious?

TIA!