When to use unaligned access in C programming?
Memory access from the point of view of the software is just instructions for reading or writing bytes of data to or from memory. Let’s look at practical situations where unaligned access may occur when using the C programming language. First, we start with the structure shown below:
When do I run into an unaligned access problem?
In summary, the 2 main scenarios where you may run into unaligned access problems involve: 1 Casting variables to types of different lengths 2 Pointer arithmetic followed by access to at least 2 bytes of data More
Is the unaligned access function included in the kernel?
Despite the potential unaligned access problems with the above function, it is included in the kernel anyway but is understood to only work normally on 16-bit-aligned addresses. It is up to the caller to ensure this alignment or not use this function at all.
What does compiler do when unaligned access is not allowed?
The default behavior of the compiler when it comes to unaligned access is dependent on the target CPU architecture. If the architecture does not allow unaligned accesses, then the compiler will place all variables, functions, etc. in an aligned manner.
Why do CPUs only perform unaligned accesses?
CPUs used to perform better when memory accesses are aligned, that is when the pointer value is a multiple of the alignment value. This differentiation still exists in current CPUs, and still some have only instructions that perform aligned accesses.
What happens if a pointer to an object is not aligned?
Although the C language allows such castings, the result may cause undefined behavior: A pointer to an object or incomplete type may be converted to a pointer to a different object or incomplete type. If the resulting pointer is not correctly aligned for the referenced type, the behavior is undefined.
Why are unaligned accesses undefined in C + +?
In our case the alignment of uint64_t is 8 bytes (which can be checked for instance like this https://godbolt.org/z/SJjN9y ), hence we are experiencing this undefined behavior. What happens more precisely here is that the previous cast directly said to our compiler ” Ret is a multiple of 8, and so a multiple of 2. You are safe to use LDMIA “.