In computer programming, aliasing refers to the situation where the same memory location can be accessed using different names. For instance, if a function takes two pointersA and B which have the same value, then the name A aliases the name B. In this case we say the pointers A and Balias each other. Note that the concept of pointer aliasing is not very well-defined – two pointers A and B may or may not alias each other, depending on what operations are performed in the function using A and B.
Aliasing introduces strong constraints on program execution order. If two write accesses which alias occur in sequence in a program text, they must occur in sequence in the finalmachine code. Re-ordering the accesses will produce an incorrect program result. The same is true for a write access and a read access. However, if two read accesses which alias occur in sequence in a program text, they need not occur in the same sequence in the machine code - aliasing read accesses are safe to re-order. This is because the underlying data is not changed by the read operation, so the same value is always read. It is vitally important that a compiler can detect which accesses may alias each other, so that re-ordering optimizations can be performed correctly. Several strategies are possible: In C or C++, as mandated by the strict aliasing rule, pointer arguments in a function are assumed not to alias if they point to fundamentally different types, except forchar* and void*, which may alias to any other type. Some compilers allow the strict aliasing rule to be turned off, so that any pointer argument may alias any other pointer arguments. In this case, the compiler must assume that any accesses through these pointers can alias. This can prevent some optimizations. In C99, the restrict keyword was added, which specifies that a pointer argument does not alias any other pointer argument. In Fortran, procedure arguments and other variables may not alias each other, and the compiler assumes they do not. This enables excellent optimization, and is one major reason for Fortran's reputation as a fast language. In pure functional languages, function arguments may usually alias each other, but all pointers are read-only. Thus, no alias analysisneeds to be done.
Aliasing and multi-threading
If multiple threads have names which alias the same memory location, two problems arise. First, unless the memory location is protected in some way, then read-modify-write operations which are non-atomic might be interleaved with similar operations on another thread, producing incorrect results. In this case, some form of synchronization primitive must be used. Second, even with synchronization, if two aliasing accesses occur in different threads in a non-ordered way, the program behaviour may become non-deterministic - different runs of the same program on the same data may produce different results. Thus, it is often important to impose an explicit ordering between threads which have aliases.
