pointer aliasing

[moi]

So my current project which I'd been compiling so far with no -O flag, breaks some things on-O2 (although it's spiffy faster). I've been scrounging around a little bit and read up on the evilness of modifying something with a pointer of a different type and how it can break optimizations, particularly in GCC.

  int rdhi, rdlo, rs, rm;
  u32 regs[16];

  ...

  u64 result = regs[rm] * (u64) regs[rs];
  result += regs[rdlo];
  result += (u64) regs[rdhi] << 32;
  regs[rdhi] = ((u32 *) (&result))[1];
  regs[rdlo] = ((u32 *) (&result))[0];

Do you think this particular code could break optimizations. Even though I am using a u32* to point to a u64, I'm only using it to read, not modify, and the u32* is not a "mysterious pointer" pointing to an unknown place - it's made directly from &result and dereferenced in the same statement. So it doesn't seem to me to fit the mold of aliasing that breaks optimization - where there's a mysterious pointer floating around that the compiler can have no idea where it points to, and it uses the same type rule to limit the number of options.

[swoopy]

> regs[rdhi] = ((u32 *) (&result))[1];
> regs[rdlo] = ((u32 *) (&result))[0];

I don't have an answer to your question. But have you tried making these:

  regs[rdhi] = result >> 32;
  regs[rdlo] = result;

[moi]

> regs[rdhi] = ((u32 *) (&result))[1];
> regs[rdlo] = ((u32 *) (&result))[0];

I don't have an answer to your question. But have you tried making these:

  regs[rdhi] = result >> 32;
  regs[rdlo] = result;

Yeah, that should work; I'll probably switch to it... in GCC I could also use the union hack

union
{
  u64 big;
  u32 small[2];
} foo;

It's more a question of correctness, to increase my knowledge, than anything else. Unfortunately I only use this "trick" in the various 64 bit multiply routines, so most of my problems from -O2 must be coming from somewhere else... but that will have to wait until I've had more time to narrow things down.