Coder Perfect

To provide more application coverage, we’re linking against an older version of libc.


The core system library is generally dynamically linked to Linux binaries (libc). This reduces the binary’s memory footprint, but binaries that rely on the most recent libraries will not operate on older platforms. Binaries linked to earlier libraries, on the other hand, will happily run on the most recent systems.

As a result, in order to ensure that our program has adequate distribution coverage, we must determine the oldest libc we can support and link our binary against it.

How can we figure out the version of libc we can link to?

Asked by Gearoid Murphy

Solution #1

Determine which symbols in your executable are causing the dependency on the glibc version you don’t want.

$ objdump -p myprog
Version References:
  required from
    0x09691972 0x00 05 GLIBC_2.3
    0x09691a75 0x00 03 GLIBC_2.2.5

$ objdump -T myprog | fgrep GLIBC_2.3
0000000000000000      DF *UND*  0000000000000000  GLIBC_2.3   realpath

Look through the depended-upon library to check if any symbols from previous versions can be linked to:

$ objdump -T /lib/ | grep -w realpath
0000000000105d90 g    DF .text  0000000000000021 (GLIBC_2.2.5) realpath
000000000003e7b0 g    DF .text  00000000000004bf  GLIBC_2.3   realpath

We’re in luck!

In your code, request the version from GLIBC 2.2.5:

#include <limits.h>
#include <stdlib.h>

__asm__(".symver realpath,realpath@GLIBC_2.2.5");

int main () {
    realpath ("foo", "bar");

It’s worth noting that GLIBC 2.3 is no longer required:

$ objdump -p myprog
Version References:
  required from
    0x09691a75 0x00 02 GLIBC_2.2.5

$ objdump -T myprog | grep realpath
0000000000000000      DF *UND*  0000000000000000  GLIBC_2.2.5 realpath

See for more information.

Answered by Sam Morris

Solution #2

Unfortunately, in my case, @Sam’s method does not work. But, in his opinion, I came up with my own solution.

This is my predicament:

I’m using the Thrift framework (an RPC middleware) to write a C++ program. Because I prefer static links to dynamic links, my program is statically linked to libthrift.a rather than However, because libthrift.a is dynamically linked to glibc, and because my libthrift.a was built with glibc 2.15 on my machine, it utilizes memcpy version 2.14(memcpy@GLIBC 2.14) given by glibc 2.15.

However, our server machines only have glibc version 2.5, which only includes memcpy@GLIBC 2.2.5. It is significantly less than memcpy@GLIBC 2.14. So, of course, my server program can’t run on those machines.

And then I came across this solution:

The code for stages 1 and 2 may be found here:

Answered by nicky_zs

Solution #3

You may use the following script to build a list of all the symbols that are newer in your GLIBC than in a particular version in a more automatic manner (set on line 2). It generates a glibc.h file (the name of which is determined by the script parameter) that contains all of the required.symver declarations. Then, in your CFLAGS, add -include glibc.h to ensure that it is included everywhere in your compilation.

If you don’t utilize any static libraries that were not compiled with the aforementioned include, this will suffice. You can use objcopy to build a copy of the library with the symbols renamed to the old versions if you don’t want to recompile. The script’s second to last line builds a version of libstdc++.a for your system that will link against the old glibc symbols. If you add -L. (or -Lpath/to/libstdc++.a/) to your program, it will statically link libstdc++ instead of linking in a load of new symbols. Remove the last two lines, as well as the printf… redeff line, if you don’t require it.

set -e
for lib in; do
objdump -T /usr/lib/$lib
done | awk -v maxver=${maxver} -vheaderf=${headerf} -vredeff=${headerf}.redef -f <(cat <<'EOF'
split(maxver, ver, /\./)
limit_ver = ver[1] * 10000 + ver[2]*100 + ver[3]
/GLIBC_/ {
gsub(/\(|\)/, "",$(NF-1))
split($(NF-1), ver, /GLIBC_|\./)
vers = ver[2] * 10000 + ver[3]*100 + ver[4]
if (vers > 0) {
    if (symvertext[$(NF)] != $(NF-1))
    if (vers <= limit_ver && vers > symvers[$(NF)]) {
        symvers[$(NF)] = vers
        symvertext[$(NF)] = $(NF-1)
for (s in symvers) {
    if (count[s] > 1) {
        printf("__asm__(\".symver %s,%s@%s\");\n", s, s, symvertext[s]) > headerf
        printf("%s %s@%s\n", s, s, symvertext[s]) > redeff
sort ${headerf} -o ${headerf}
objcopy --redefine-syms=${headerf}.redef /usr/lib/libstdc++.a libstdc++.a
rm ${headerf}.redef

Answered by patstew

Solution #4

Glibc 2.2 is the most often used minimal version. Finding a build platform for that version, on the other hand, may be difficult.

It’s probably a better idea to start with the oldest OS you wish to support and expand from there.

Answered by Douglas Leeder

Post is based on