Any way to locally apply no-strict-alias?

[John Fine <johnsfine at verizon dot net>]

I have a very large module, which contains a few places where a pointer 
is cast based on a templated data type.

Typically a pointer is created using a templated type, then copied as a 
void*, then used as the templated type.  In one of those places, the 
optimizer removes the copy step, which is correct behavior for the 
optimizer under strict aliasing, but of course incorrect for the program.

Because of the way the templating fits in, it would be very hard to 
either make a correct union for the pointer, or do the copy using the 
correct type.

Creating, copying and using the pointer are coded in different sub 
projects in code templated on different things, but all of which might 
be brought together by inlining (so the optimizer can do this damage).

If I compile the whole module with no-strict-alias it runs correctly, 
but the generated code is 3% bigger and I think runs significantly 
slower (I can only approximate how fast the broken code runs).

It would be great to have some attribute one could define on a pointer 
to say that pointer violates strict aliasing.  The pointers described 
above are actually used through another layer of pointer, which is 
declared as a void**.  In concept the code looks like:

Datatype* a;
void** x = malloc ...
(Datatype*&)(x[n]) = a;
void** y = malloc ...
y[n] = x[n];
Datatype* b;
b = (Datatype*&)(y[n]);

So if there were a way to put an attribute on x and y to say they 
violate strict aliasing, that would be a perfect solution.

Alternately, if violation of strict aliasing could be applied to inline 
function definitions, that might be reasonable (hopefully just applying 
to the operations inside that function, not to the whole function into 
which it gets inlined).