Casting a dlsym'd function pointer to to same function signature but changed parameter definition

Question

Let's say I have a struct defined in MyType.h

struct MyType {
    int x;
    int y;
};

And I build a lib myLib.so which exposes a function that takes the above type as a parameter.

#include "MyType.h"
extern "C" void myLibFunc(MyType myType) {
    ...
}

Then I update my MyType.h changing the definition of MyType to include an extra member variable.

struct MyType {
    int x;
    int y;
    int z;
};

Now in my executable, I open myLib.so and load myLibFunc symbol from it which was built with old definition of MyType, but cast the void * returned by dlsym using a function signature that uses the new definition of MyType.

#include <dlfcn.h>
#include "MyType.h" //updated version

typedef void(*myLibFuncType)(MyType myType);

int main() {
    auto myLibHandle = dlopen("myLib.so", RTLD_LOCAL | RTLD_NOW);
    auto myLibFunc = (myLibFuncType) dlsym(myLibHandle, "myLibFunc");
    ...
    return 0;
}

Is this supposed to work?

I have read this answer but could not figure out if the case presented here satisfies "compatible function pointer" requirement.

The function types are fundamentally different. The library knows nothing of `int z;`. The first sentence in the linked answer would apply. — David C. Rankin, Aug 17 '23 at 22:37
Can you define, specifically, what "work" means to you? Yes, `dlsym()` will return the symbol, it has C linkage, hence it's symbol does not get mangled. Will calling this function produce defined results? Unknown, but likely not. — Sam Varshavchik, Aug 17 '23 at 22:39
In that answer the description of compatible says **corresponding parameters shall have compatible types.** Two struct types with different numbers of members are definitely not compatible types. — Barmar, Aug 17 '23 at 22:42
If the parameter type were a pointer to struct instead of the struct itself, you could probably get away with it, because in practice all pointers are the same (as long as it's not being used to access an array of structs, because indexing won't work correctly) and the structs have common prefixes. — Barmar, Aug 17 '23 at 22:44
Microsoft do this all the time, so MSVC at least, doesn't mind. But what goes on in Windows, stays in Windows. — Paul Sanders, Aug 17 '23 at 23:26
The shown code does not compile with a C compiler. Why is the tag C used? — 273K, Aug 17 '23 at 23:30

score 0 · Accepted Answer · answered Aug 17 '23 at 22:41

The two instance of the struct types are not compatible because the members are different. Section 6.2.7p1 of the C standard regarding compatible types states:

... Moreover, two structure, union, or enumerated types declared in separate translation units are compatible if their tags and members satisfy the following requirements: If one is declared with a tag, the other shall be declared with the same tag. If both are completed anywhere within their respective translation units, then the following additional requirements apply: there shall be a one-to-one correspondence between their members such that each pair of corresponding members are declared with compatible types; if one member of the pair is declared with an alignment specifier, the other is declared with an equivalent alignment specifier; and if one member of the pair is declared with a name, the other is declared with the same name. For two structures, corresponding members shall be declared in the same order. For two structures or unions, corresponding bit-fields shall have the same widths. For two enumerations, corresponding members shall have the same values.

And since the struct types are not compatible, the function pointers are not compatible because their parameters are not compatible, as noted in the post you linked.

This means that attempting to call the function through that function pointer will trigger undefined behavior.

As a side note, casting an void *, which is an object pointer, to a function pointer is not strictly allowed by the C standard. The man page for dlsym contains the following example regarding the proper way to handle this:

   /* Writing: cosine = (double (*)(double)) dlsym(handle, "cos");
      would seem more natural, but the C99 standard leaves
      casting from "void *" to a function pointer undefined.
      The assignment used below is the POSIX.1-2003 (Technical
      Corrigendum 1) workaround; see the Rationale for the
      POSIX specification of dlsym(). */

   *(void **) (&cosine) = dlsym(handle, "cos");

Casting a dlsym'd function pointer to to same function signature but changed parameter definition

1 Answers1