Back when Ksplice was just a research project at MIT, we all spent a lot of time around the student computing group, SIPB. While there, several precocious undergrads kept talking about how excited they were to take 6.828, MIT's operating systems class.

"You really need to understand pointers for this class," we cautioned them. "Reread K&R Chapter 5, again." Of course, they insisted that they understood pointers and didn't need to. So we devised a test.

Ladies and gentlemen, I hereby do officially present the Ksplice Pointer Challenge, to be answered without the use of a computer:

What does this program print?

#include <stdio.h> int main() { int x[5]; printf("%p

", x); printf("%p

", x+1); printf("%p

", &x); printf("%p

", &x+1); return 0; }

This looks simple, but it captures a surprising amount of complexity. Let's break it down.

To make this concrete, let's assume that x is stored at address 0x7fffdfbf7f00 (this is a 64-bit system). We've hidden each entry so that you have to click to make it appear -- I'd encourage you to think about what the line should output, before revealing the answer.

printf("%p

", x);

Well, x is an array, right? You're no stranger to array syntax: x[i] accesses the i th element of x . If we search back in the depths of our memory, we remember that x[i] can be rewritten as *(x+i) . For that to work, x must be the memory location of the start of the array. Result: printf("%p

", x) prints 0x7fffdfbf7f00 . Alright.

printf("%p

", x+1);

So, x is 0x7fffdfbf7f00 , and therefore x+1 should be 0x7fffdfbf7f01 , right? You're not fooled. You remember that in C, pointer arithmetic is special and magical. If you have a pointer p to an int , p+1 actually adds sizeof(int) to p . It turns out that we need this behavior if *(x+i) is properly going to end up pointing us at the right place -- we need to move over enough to pass one entry in the array. In this case, sizeof(int) is 4. Result: printf("%p

", x) prints 0x7fffdfbf7f04 . So far so good.

printf("%p

", &x);

Well, let's see. & basically means "the address of", so this is like asking "Where does x live in memory?" We answered that earlier, didn't we? x lives at 0x7fffdfbf7f00 , so that's what this should print. But hang on a second... if &x is 0x7fffdfbf7f00 , that means that it lives at 0x7fffdfbf7f00. But when we print x , we also get 0x7fffdfbf7f00 . So x == &x . How can that possibly work? If x is a pointer that lives at 0x7fffdfbf7f00 , and also points to 0x7fffdfbf7f00 , where is the actual array stored? Thinking about that, I draw a picture like this:

That can't be right.









That can't be right. So what's really going on here? Well, first off, anyone who ever told you that a pointer and an array were the same thing was lying to you. That's our fallacy here. If x were a pointer, and x == &x , then yes, we would have something like the picture above. But x isn't a pointer -- x is an array! And it turns out that in certain situations, an array can automatically "decay" into a pointer. Into &x[0] , to be precise. That's what's going on in examples 1 and 2. But not here. So &x does indeed print the address of x . Result: printf("%p

", &x) prints 0x7fffdfbf7f00 . Aside: what is the type of &x[0] ? Well, x[0] is an int, so &x[0] is "pointer to int ". That feels right.

printf("%p

", &x+1);

Ok, now for the coup de grace. x may be an array, but &x is definitely a pointer. So what's &x+1 ? First, another aside: what is the type of &x ? Well... &x is a pointer to an array of 5 ints. How would you declare something like that? Let's fire up cdecl and find out: cdecl> declare y as array 5 of int; int y[5] cdecl> declare y as pointer to array 5 of int; int (*y)[5] Confusing syntax, but it works:

int (*y)[5] = &x; compiles without error and works the way you'd expect. But back to the question at hand. Pointer arithmetic tells us that &x+1 is going to be the address of x + sizeof(x) . What's sizeof(x) ? Well, it's an array of 5 int s. On this system, each int is 4 bytes, so it should be 20 bytes, or 0x14 . Result &x+1 prints 0x7fffdfbf7f14 .

What will this print?What will this print?What will this print?What will this print?

And thus concludes the Ksplice pointer challenge.

What's the takeaway? Arrays are not pointers (though they sometimes pretend to be!). More generally, C is subtle. Oh, and 6.828 students, if you're having trouble with Lab 5, it's probably because of a bug in your Lab 2.

P.S. If you're interested in hacking on low-level systems at a place where your backwards-and-forwards knowledge of C semantics will be more than just an awesome party trick, we're looking to hire kernel hackers for the Ksplice team. Send me an email at jamie.iles@oracle.com with a resume and/or a github link if you're interested!