Why does -r option (relocatable) make ld not find any libraries

In the world of programming and computer science, there are different techniques and tools used to solve various problems. One common problem that programmers encounter is linking errors. When a program is compiled and linked, it has to find the necessary libraries to function properly. However, there are times when the linker fails to find required libraries, resulting in a linking error. In this article, we will discuss why the -r option (relocatable) makes ld not find any libraries and provide practical examples.

What is the -r Option?

The -r option is a command-line option used with the GNU linker, ld. This option specifies that the output of the linker should be a relocatable object file, which is a file that can be further linked to create an executable or shared object file. The -r option is typically used when linking object files to create a static library or when combining multiple object files into a single relocatable object.

When the -r option is used, the linker does not resolve all undefined symbols in the object files, and the output is a relocatable object file that can be used later for further linking.

Why Does -r Option Make ld Not Find Libraries?

When the -r option is used, ld operates in relocatable mode, which fundamentally changes its behavior. In this mode, the linker assumes that all necessary symbols are defined in the input object files and does not search for external libraries. This design choice exists because relocatable linking is intended to combine object files without creating a final executable.

The key reasons why -r prevents library searching include:

• Purpose ? Relocatable linking creates intermediate files, not final executables

• Symbol Resolution ? Undefined symbols are preserved for later resolution

• Library Independence ? The output should not depend on specific library versions

Example

To better understand why the -r option makes ld not find any libraries, let us consider a practical example. Suppose we have two object files, a.o and b.o, that we want to combine into a single relocatable object.

If we use the following command to link the object files:

$ ld -r a.o b.o -o combined.o

The output will be a relocatable object file, combined.o, that can be used later for further linking. However, if we try to link combined.o to create an executable file without providing the necessary libraries, we will get a linking error:

$ ld combined.o -o myprog

ld: combined.o: undefined symbols:
  _printf
  _malloc

In this case, ld cannot find the symbols _printf and _malloc because no libraries were specified, and the relocatable object preserves these undefined references.

Solutions and Best Practices

To work with relocatable objects effectively, follow these approaches:

For Final Linking

When creating the final executable, explicitly link with required libraries:

$ ld combined.o -lc -o myprog

Using GCC Instead of ld

For most cases, use gcc which handles library linking automatically:

$ gcc combined.o -o myprog

Creating Static Libraries

Use ar to create proper static libraries from relocatable objects:

$ ar rcs libmylib.a combined.o
$ gcc main.o -L. -lmylib -o myprog

Key Points

• The -r option creates intermediate, relocatable object files

• Library searching is disabled in relocatable mode by design

• Undefined symbols are preserved for later resolution

• Use gcc instead of ld directly for most linking tasks

Conclusion

The -r option makes ld not find libraries because it operates in relocatable mode, designed for creating intermediate object files rather than final executables. Understanding this behavior is crucial for effective linking workflows and avoiding common linking errors in complex build systems.