What is "Pointer Alignment"

[signuts]

I am wondering what it means when a pointer is aligned?

Could someone perhaps enlighten me or point me in the right direction?

Thank you in advance.

 

[Hallvard B Furuseth]

I am wondering what it means when a pointer is aligned?

On some architectures, some data types can or should only be accessed
if their address is a multiple of 4 or the size of the datatype or
whatever. Otherwise the program crashes, or gives wrong results, or
maybe the pointer access just goes a lot slower.

For a type T, a pointer is aligned for T access if it contains an
address which is a multiple of whatever number T* pointers should be a
multiple of.

 

[Lew Pitcher]

I am wondering what it means when a pointer is aligned?

Could someone perhaps enlighten me or point me in the right direction?

In some systems, certain data types can only be stored such their addresses are
all on an even number boundary. In other systems, some data types require
addresses be on 4 octet boundaries.

If you had

char c;
char *Pc = &c;
int *Pi;

and you

Pi = (int *)Pc;

you might find that references to *Pi would cause errors because Pc didn't point
to a data item aligned on an "integer" boundary.



--
Lew Pitcher
IT Consultant, Enterprise Technology Solutions
Toronto Dominion Bank Financial Group

(Opinions expressed are my own, not my employers')

 

[Jens.Toerring]

I am wondering what it means when a pointer is aligned?
Could someone perhaps enlighten me or point me in the right direction?

Since this isn't directly C related off-topicality warning:

<OT>
There are several architectures where e.g. an integer must start at
an even address (or addresses that can be divided by 4). This is
related to the machines commands for e.g. loading an int from memory
into the CPU: when an int gets loaded it's probably done using a
machine instruction that roughly translates to "load word from
memory address 0xc73204". If you try to load a "word" from an odd
address this machine instruction does not work and you get a bus
error.

But in C you can write code that looks like this (error checking
omitted):

int a;
unsigned char *buf = malloc( 128 );
a = * ( int * ) ( buf + 1 );

malloc() will always return memory that's properly aligned, i.e.
the address you get can be used for all kinds of types without
running into danger of getting a bus error. So buf will be an
even address. But when you now try to assign to 'a' in the way
it's done above, you try to load 'a' from an odd memory address
and then you're in trouble, at least on machines which require
proper alignment (on other machines this might only result in a
slower memory access). So the above (if it's really necessary)
must be written e.g. as

memcpy( &a, buf + 1, sizeof a );

because memcpy() has to be written in a way that won't use a
"load word" (or similar) instruction that could result in a
bus error.

BTW, this is also the reason why structures often need padding.
If you have a structure like

struct {
char c;
int a;
} my_struct;

the compiler will have to insert at least one extra byte between
'c' and 'a' because otherwise 'a' would end up at an odd address
and

my_struct.a = 0;

might lead to a bus error.
</OT>
Regards, Jens
--
_ _____ _____
| ||_ _||_ _| (e-mail address removed)-berlin.de
_ | | | | | |
| |_| | | | | | http://www.physik.fu-berlin.de/~toerring
\___/ens|_|homs|_|oerring