#strict aliasing rule

[mentalisttraceur-software]

C `unaliased`

I am imagining a variadic function or macro called `unaliased`. At runtime it is allowed to do nothing or expand to nothing, so that a compiler is free to eliminate it or ignore it. But it is defined that calling it is equivalent to saying "within this scope, as of this call to `unaliased`, I promise that none of the arguments to this `unaliased` call are aliasing each other". More pedantically: if you call `unaliased` and any of the arguments to it are actually aliased, you get undefined behavior.

With such built-in functionality, I think you can:

Get even more optimizations than can be done by just going off the strict aliasing rule and `restrict`.

Get the same optimizations as from the strict aliasing rule, provided the code author used `unaliased` to indicate it was safe.

Get back functionality currently lost to the strict aliasing rule, or express that functionality more clearly and simply.

[mentalisttraceur-software]

I have mixed feelings about the strict aliasing rule in C. I am tempted to say that the correct solution was maybe to just force compilers to assume anything could alias, but give programmers a way to tell the compiler about things that cannot.

It is entirely possible that `restrict` from C99 is strictly speaking sufficient? If you trust that the compiler will do a good job inlining, then you can always refactor the chunk of code for which the "these pointers cannot alias each other" holds into its own function with `restrict` parameters. And when you don't need to communicate that requirement to callers, you can just use `restrict` block-scoped variables.

Writing the word `restrict` in a bunch of places is annoying, but if you're following best practices you'd only do it in the places where

you wanted to say "this function literally cannot work if the stuff at this pointer is aliased", or

you profiled and looked at the machine code and determined this spot was the bottleneck because the code assumed possible aliasing.

However, I can definitely imagine code getting less readable and uglier if `restrict`-qualified pointers were the only way to achieve this. So maybe a more general and precise way to specify that two or more specific things cannot alias each other would be good?