Question

I am making a memory block copy routine and need to deal with blocks of raw memory in efficient chunks. My question is not about the specialized copy routine I’m making, but in how to correctly examine raw pointer alignment in C.

I have a raw pointer of memory, let’s say it’s already cast as a non-null char *.
In my architecture, I can very efficiently copy memory in 64 byte chunks WHEN IT IS ALIGNED TO A 64 BYTE chunk. So the (standard) trick is that I will do a simple copy of 0-63 bytes “manually” at the head and/or tail to transform the copy from an arbitrary char* of arbitrary length to a 64 byte aligned pointer with some multiple of 64 bytes in length.

Now the question is, how do you legally “examine” a pointer to determine (and manipulate) its alignment?
The obvious way is to cast it into an integer and just examine the bits:

char *pointer=something.
int p=(int)pointer;
char *alignedPointer=(char *)((p+63)&~63);

Note here I realize that alignedPointer doesn’t point to the same memory as pointer… this is the “rounded up” pointer that I can call my efficient copy routine on, and I’ll handle any other bytes at the beginning manually.

But compilers (justifiably) freak out at casting a pointer into an integer. But how else can I examine and manipulate the pointer’s lower bits in LEGAL C? Ideally so that with different compilers I’d get no errors or warnings.

Answer 1

For integer types that are large enough to hold pointers, C99 stdint.h has:

• uintptr_t
• intptr_t

For data lengths there are:

• size_t
• ssize_t

which have been around since well before C99.

If your platform doesn’t have these, you can maximise your code’s portability by still using these type names, and making suitable typedefs for them.