Hi, A lot of the APIs in PostgreSQL that accept a callback follow the familiar idiom of an extra void* argument allowing a single static callback address to be multiplexed. But not all of them do. For example, if I wanted to expose the possibility of defining GUCs from code written in my PL, I would run into the fact that none of GUC's check/assign/show hooks have the void* extra arg.
(The GUC machinery allows a way for extra info to be passed from a check hook to an assign hook, which for a moment I thought might be abusable to multiplex hooks, but I don't believe it is.) Making all such APIs follow the void *extra convention might have the virtue of consistency, but that might not be worth disturbing APIs that have been stable for many years, and an effort to do so might not be guaranteed to catch every such instance anyway. A more general solution might be a function that generates a callback stub: "please give me a void (*foo)() at a distinct address that I can pass into this API, and when called it will call bar(baz), passing this value for baz." In olden days I wasn't above writing C to just slam those instructions on the stack and return their address, but that was without multiple architectures to think about, and non-executable stacks, and so on. Now, there'd be a bit more magic required. Maybe some such ability is already present in LLVM and could be exposed in jit.c? I see that Java is currently incubating such a feature [0], so if I wait for that I will have another option that serves my specific purposes, but I wonder if it would be useful for PostgreSQL itself to have such a capability available (or if it already does, and I haven't found it). Regards, -Chap [0] https://docs.oracle.com/en/java/javase/16/docs/api/jdk.incubator.foreign/jdk/incubator/foreign/CLinker.html#upcallStub(java.lang.invoke.MethodHandle,jdk.incubator.foreign.FunctionDescriptor)