Replacing a symbol in built libraries

[iliakan]

I'm building a large third-party C codebase with Emscripten.

Some functions don't work "as is" (e.g. they use fork), and I need to reimplement them.

Is there a way to do so without patching the code?

E.g. there's a function int run_command(struct args arguments) {... use fork() }.

I can manually patch the file and replace it with EM_JS function, but I'd be cleaner to provide my implementation in a separate file, to make future code sync easier. Only for this function, not others in the same file.

Is it possible to replace this in-build or after-the-build? Some library management magic? Late symbol-replacement?

[iliakan]

I tried to do use llvm-strip, but no luck so far.

Here's the error:

./emsdk/upstream/bin/llvm-strip --strip-symbol=fork run-command.o
./emsdk/upstream/bin/llvm-strip: error: only flags for section dumping, removal, and addition are supported

[kleisauke]

You can use the --wrap linker option for this.

main.c:

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

extern pid_t __real_fork();

pid_t __wrap_fork() {
    printf("wrap fork\n");
    return 0;
}

int main() {
    printf("fork(): %d\n", fork());
    printf("real fork(): %d\n", __real_fork());
    return 0;
}

$ emcc -sEXIT_RUNTIME -sALLOW_UNIMPLEMENTED_SYSCALLS main.c -Wl,--wrap=fork -o main.js
$ node main.js
wrap fork
fork(): 0
real fork(): -1

This is supported in wasm-ld since commit llvm/llvm-project@a5ca34e.

[kleisauke]

Could you try -Wl,--wrap=start_command -Wl,--wrap=finish_command instead? AFAIK, it only accepts a single value.

[kleisauke]

I create my own file my.c which implements these functions, with the same signature.

Assuming the start_command and finish_command is just a void function, they'll need to be implemented like this:
my.c:

#include <stdio.h>

void __wrap_start_command() {
    printf("wrap start_command()\n");
}

void __wrap_finish_command() {
    printf("wrap finish_command()\n");
}

(i.e. the function name needs to be prefixed with __wrap_)

[iliakan]

Thank you, now it goes better.

With your flags, this way it linked:

int __wrap_finish_command(struct child_process *cmd) {
	return 0;
}

(nm my.o shows the symbol: T __wrap_finish_command).

...But this way, it didn't:

EM_JS(int, __wrap_finish_command, (struct child_process *cmd), {
  	return finishCommand(cmd);
});

(nm my.o shows D __em_js____wrap_finish_command).

In both cases I just want to create a function with the same signature.

I guess, EM_JS generates things differently? Is there a simple way to make it work too? 😀

[kleisauke]

The simplest way to make this work with EM_JS is:

#include <emscripten/emscripten.h>

EM_JS(int, finish_command_js, (struct child_process *cmd), {
    return finishCommand(cmd);
});

int __wrap_finish_command(struct child_process *cmd) {
    return finish_command_js(cmd);
}

[iliakan]

Thank you!

That looks to be the simplest solution indeed!

Now everything works fine.

The wrap option is truly ideal to avoid patching the 3rd-party files.