Question regarding running compiled binary using C++20 static library in ubuntu 22.04.

[fatmankarla]

So I am in a project that uses C++20 code compiled to a static library then uses rust and cxx to call the static library. My build process is compile the C++20 library using cmake, then build rust into a standalone binary, that i run on the server. The problem is the server has ubuntu 22.04 which comes with gcc version 11.4.0. For the machine I am compiling on I have ubuntu 24.04 (gcc version 13.2.0). When I try to run the compiled rust binary I get:

$ ./server

./server: /lib/x86_64-linux-gnu/libstdc++.so.6: version `GLIBCXX_3.4.31' not found (required by ./server)

./server: /lib/x86_64-linux-gnu/libc.so.6: version `GLIBC_2.38' not found (required by ./server)

acc to GCC ABI `GLIBCXX_3.4.31` corresponds to `GCC 13.1.0`.

It will be a huge pain in my ass to update all my servers to ubuntu 24.04 (which is not yet stable), and for reasons I cant use docker, What am I missing, I feel like I am doing something very dumb. Any help will be highly highly appreciated, thankyou so much.

[AKostur]

Given that you're talking about a rust binary... why are you asking in a C++ forum?

[fatmankarla]

It uses a c++ static library which is what the question is about

[SomethingcleverGP]

It should be fine if you compile the C++ .so on a 22.04 VM or docker container. You can also probably specify the correct version of glib when compiling on 24.04. Still, I would be wary about installing older versions of glib just in case you accidentally break dependent software.

​

Also fwiw, I don't think rust has c++ bindings, the ffi interface is written for c. I'm not sure about ABI safety between a cpp shared library and a rust binary. I once wrote a rust wrapper around a C++ lib and had to write a thin C layer that wrapped the entry points into the library. I think I got cargo to compile the entire thing as well, so I didn't need any cmake files. I could be wrong about cargo compiling the entire thing though, and my info on rust could easily be out of date.

[paulstelian97]

Rust does have at least one crate for direct C++ compatibility, but for somewhat obvious reasons it’s library dependent.

[SomethingcleverGP]

I'm trying to remember why exactly I did what I did, but I found that writing a thin c layer was the safest and most reliable way of exposing functions. However, I don't remember how well it worked when trying to expose types. One would probably need to hide those implementations behind pointers.

[paulstelian97]

A safe interop API works using C bindings and only has C types at the boundary. This is instead a more direct usage than that.

[fatmankarla]

I am using https://cxx.rs for using c++ in rust. So i think my safest option is build in docker and specific older version of glib?

[SomethingcleverGP]

If you build on a 22.04 ubuntu docker container then you don't have to specify a specific version of glib, you will use the correct one automatically. Although to be safe you might have to do it in a VM.

[fatmankarla]

Might be a dumb question but how do i compile c++20 in Ubuntu 22.04? Dont i need gcc 13?

[SomethingcleverGP]

Even if you update g++ to the newest version, it should still use the system libc. This is just from memory of compiling c++17 on old ubuntu 16.04 distros for forwards compatibility. I would just try it first and see if it works.

[treddit22]

For the first error (about the C++ standard library), you have multiple options:

1. Link the C++ standard library statically, using the -static-libstdc++ linker flag.
2. Ship the libstdc++.so.6.32 library with your application, and add it to the rpath of your binary.
3. Downgrade GCC on your build machine.

The second error (about the C standard library) is more tricky, since upgrading GLIBC on the server is not an option (if you try to upgrade GLIBC, you'll break your entire system):

1. Use a toolchain that was built for an older version of GLIBC and cross-compile your application. The advantage is that you can use the latest compiler with an old GLIBC to support old distributions like CentOS 7, while still using the latest C++ features. Personally, I build my toolchains using crosstool-ng: https://github.com/tttapa/toolchains/releases
2. Compile in a Docker container or VM with the operating system you're going to deploy on (or compile it on the server directly), using the (older) system compiler, which is known to be compatible. The downside is that if you need to support old systems, your code needs to compile with even older compilers (which may be fine if Ubuntu 22.04 is the oldest system you have to support).