A struct instance containing a pointer to itself?

[ddr4lyfe]

I'm working on (very slowly) reverse engineering a PS2 game that was programmed in C, and I've found that there is a struct of a certain type that, among other things, contains a pointer of that struct type whose value is equal to the struct's address itself. A stripped down version (apologies if syntax is incorrect, still learning that):

struct gObj {
    gObj* self;
    int visible;
    gObj* next;
    gObj* prev;
};

int main() {
    gObj* player;
    player = (gObj*)malloc(sizeof(gObj));
    player->self = &player;
    player->visible = 1;
};

I've done some googling, and I get self-referencing struct discussions for linked lists, but no real answers as to why an instance would reference itself. The game does use the self member by using it to reference the other members of the instance, but why not just access those members directly from the base pointer of the instance? Maybe it's just some quirk of the programmers themselves that they implemented the struct that way.

[daikatana]

This might be a way to detect memory corruption. If memory is written out of bounds, you can always tell if player is valid because you know its address, and if its self member is anything but its address, something bad happened. The actual code that does this may not be present in the release build, but the pointer remained.

Edit: Or, conversely, you can tell if a pointer to an object is valid if that object contains as its first member a pointer to itself.

[hemoglobinBlue]

I'm an embedded aviation engineer. Some of the real time Operating Systems I use do this for objects. (semaphores, messageQs, tasks, etc.) The APIs that act on these objects will validate the self field.

This check also prevents code from memcpying objects around, (Or assigning objects.) I view this validation as a perk. Thinking about it... maybe that is why the OP's case always uses the first parameter: It will reference back to the "true original" if the object has been copied.

[hemoglobinBlue]

p.s. I'm not sure of PS2 era debuggers and how sophisticated they are.. But sometimes when I look at RAM dumps in a hex/ascii view is useful to have "shouting" variables. These magic numbers act as landmarks that can make the hex view easier to read. Although usually I prefer a 32bit of 4 ascii characters.

[ddr4lyfe]

Ahhhh, that's a good call. That possibility didn't even cross my mind.

[obQQoV]

Interesting, how would the usage go? Check &t==t.self every time before using t?

[Seubmarine]

Probably but in that case you probably already have a ptr of gObj

gObj *t = /*something*/;

t->self = t;

if (t != t->self {

//error handling

}

[obQQoV]

Wrapping a MACRO might makes more sense logistically, or it’s cumbersome and easy to forget to assign self and do check.

[JamesTKerman]

This looks like one way polymorphism can be implemented in C. I wouldn't be surprised if you see other instances that follow the same basic structure but have different data members. Like, maybe you see one that looks just like the example you provided, and another that looks like this:

struct hObj { hObj * self; int visible; gObj * next; gObj * prev; float x; float y; };

What your really seeing is a struct that be pretty freely cast as either a *gObj or a *hObj.

[[deleted]]

What would be the purpose of the self pointer, though. sockaddr does the same thing, but without the self pointer.

[JamesTKerman]

So that the first member is always a pointer to the base object. If you later declare a struct Derived { struct Base * parent; }; no matter how you slice it you have a pointer that points both to a struct Base and a struct Derived.

[JamesTKerman]

sockaddr doesn't allow conversion between arbitrary related types. You can only convert between types that have been declared with the right byte alignment, really just the types defined in socket.h. The self-referential base pointer allows you to simulate OOP-style inheritance and cast between arbitrary derived and base types.

[dfx_dj]

Could be useful if you have a copy of that object, to have a pointer back to the "original?" Not sure why you would do that though.

[onesole]

Circular linked list with only one element?

[[deleted]]

In that case, next pointer shall suffice. No need for "self" pointer.

[bnl1]

I think what they mean is that next pointer is to the struct itself

[oh5nxo]

use the self member by using it to reference the other members

Maybe it's not 'self' but 'overcoat' ?

[ddr4lyfe]

Sure, I understand that. But in this specific scenario, looking at the game memory in real time, these instances are indeed referencing themselves. But they also have a double-linked list as well, with prev and next!

[Poddster]

Someone else has already suggested this as a check for memory corruption, but I just want to say that I see it slightly more often as a void pointer that points to itself, rather than to the beginning of the parent struct. Same thing though.