Please help me understand this bit-wise manipulation of pointer values

Question

I am not able to understand why is addr being typecasted to long, and then complemented with expression.. basically the whole line involving the calculation of peekAddr

void *addr;
char *peekAddr ;
peekAddr = (char *) ((long)addr & ~(sizeof(long) - 1 ) ) ;
peekWord = ptrace( PTRACE_PEEKDATA, pid, peekAddr, NULL ) ;

it basically aligns addr to long word boundary: http://stackoverflow.com/questions/227897/solve-the-memory-alignment-in-c-interview-question-that-stumped-me — Anycorn, Apr 26 '11 at 21:45
thanks. i am still not able to understand how it aligns memory — paseena, Apr 26 '11 at 21:48

score 5 · Answer 1 · answered Apr 26 '11 at 21:52

5

sizeof (long)     = (0)00000100
sizeof(long)-1    = (0)00000011
~(sizeof(long)-1) = (1)11111100

so 2 bits set to 0 make the address aligned to 4 bytes. additionally it's mostly used when the address was already incremented by sizeof(long)-1

answered Apr 26 '11 at 21:52

fazo

1,807
12
15

Fred Foo · Answer 2 · 2011-04-27T18:13:43.117

4

It's cast to long because (1) you can't do any operations on a void* except cast it and (2) on the author's platform, a void* value just so happens to fit in a long. He should really have used uintptr_t or size_t instead.

What the piece of code does:

sizeof(long) - 1

is most likely either 3 or 7, depending on the platform.

~(sizeof(long) - 1)

is a bitmask that selects all but the last few bits.

((long)addr & ~(sizeof(long) - 1))

is addr rounded down/aligned to address a long-sized chunk. Rounding occurs because the last lg(3) or lg(7) bits are zeros while the rest is copied from addr (where lg is integer binary logarithm).

edited Apr 27 '11 at 18:13

answered Apr 26 '11 at 21:50

Fred Foo

355,277
75
744
836

1

Nitpick: It's not the last 3 or 7 bits that are cleared, but the low 2 and 3 bits, respectively. (Since 3 is 11 binary and 7 is 111 binary.) – greyfade Apr 26 '11 at 22:17
1

Not in your last sentence. :) – greyfade Apr 27 '11 at 16:20
@greyfade: that's slightly embarassing ;) Fixed, thanks for pointing it out. – Fred Foo Apr 27 '11 at 18:14

score 3 · Answer 3 · answered Apr 26 '11 at 22:09

This is a really ugly, unportable way of doing

peakAddr = (char *)addr - ((uintptr_t)addr & -(uintptr_t)sizeof(long));

Note that the original version not only relies on successful round trip conversion of pointers to long and back, but also on size_t (the type of the result of the sizeof operator) being the same width or wider than long. If it's not, the bitmask generated with ~ would zero-extend in the upper bits and obliterate part of the pointer.

Basically, you should make a mental note that whatever program you found this in is bad code and not look to it as a source of ideas...

score 1 · Answer 4 · answered Apr 26 '11 at 21:49

1

you basically make peekAddr always aligned on sizeof(long) adresses. the line generates a bitmask and binary ands this to the peek address. The line strips the last sizeof(long)-1 bits from the peekAddr.

hth

Mario

answered Apr 26 '11 at 21:49

Mario The Spoon

4,799
1
24
36

score 1 · Answer 5 · answered Apr 26 '11 at 21:53

This will have a bug on some compilers where sizeof(long) < sizeof(char*), such as Microsoft's.

sizeof(long)-1 is creating a bit mask corresponding to the size of a long. This is a trick that only works on numbers that are a power of 2. The ~ in front inverts it, so now it's a mask of all the address bits that should remain unchanged when you're trying to align an address. The bitwise & is clearing the bottom bits of the address to make it align.

Please help me understand this bit-wise manipulation of pointer values

5 Answers5