Can linking be nested (e.g. by using intermediate object files)? [duplicate]

This seems like a duplicate of combine two GCC compiled .o object files into a third .o file, right?

The top answer over there says yes, with GNU ld you can use ld --relocatable a.o b.o -o c.o. I can neither confirm nor deny whether that's (still) true, nor whether any linkers besides GNU ld (e.g. lld, mold, gold) support a similar option, but I would guess so, because it seems like a pretty obvious and easy feature to add.

(FYI, I found the duplicate by googling "gnu ld combine .o file"; it's the top hit.)

Can the linker produce object files?

I assume you are talking about the GNU/Linux linker , ld, in use with a GCC or Clang Linux toolchain.

Yes, it can produce object files, per the manual:

-r
--relocatable
    Generate relocatable output—i.e., generate an output file that can in turn serve as input to ld. 
    ...

and as illustrated by the top answer to @Quuxplusone's proposed duplicate.

But that's not what you really want to know. You really want to know if a relocatable (-r) linkage can optimise external references between object files a.o and b.o into local references in a combined object file c.o "with potential inlining so that they don't occur in the symbol table of c.o ." And this question seems to harbour some confusion.

To enable link-time optimisations you must pass -flto to the link command. And before that you must also pass -flto to the compile commands, prompting the compiler to emit object files in an intermediate representation enabling link-time optimisations to be applied when such object files are linked into an output file. A relocatable linkage per se does enact any link-time optimisation.

Localisation of a function - converting its binding from strongly or weakly global to local - does not imply inlining it, and inlining it does require it to local. Being local and being inline are independent function attributes.

It seems you are not really interested in inlining but in whether a relocatable linkage combining a.o and b.o into c.o will localise the external references and definitions in either of these files wherever a reference in one of the files has a definition in the other one, as per your example function bar and integer a.

It won't. A relocatable linkage of a.o and b.o into c.o outputs a c.o that defines just the same global symbols, with just the same definitions, as a.o + b.o. It would not be fit for purpose if didn't.

The linker will only ever localise an input global definition when it is assured that the output definition is excused from reference in any subsequent linkage, including runtime linkage by the dynamic linker. There are only a few such scenarios, arising from the use of the -fvisibility=hidden compile option, or of the __attribute__((visibility("hidden"))) declaration qualifier in-source, or the whole-program optimisation options -flto or --whole-program. All of them result in the localisation of definitions in a linker output file that is a program or shared library, not an object file.

If you wish to produce an object file in which you localise a global definition compiled in another object file, then you must resort to objcopy, as per:

$ objcopy --localize-symbol=foo in.o out.o

For the objective that interests you - localising a symbol within an object file that combines a set of original object files, one of which globally defines the symbol while the rest make references to that definition - you need to perform a relocatable linkage of the original object files and then apply objcopy --localize-symbol=foo ... to the output file of that linkage to produce another one in which foo is localised. Here is a illustration inspired by your psuedo-code.

Source files:

$ tail -n +1 *.c
==> a.c <==
#include <stdio.h>

int a = 0;

static int b = 0;

static void foo(void)
{
    printf("%d\n",a);
}


void bar(void)
{
    foo();
    printf("%d\n",b);
}

==> b.c <==
#include <stdio.h>
extern void bar(void);

extern int a;

static int b = 5;

static inline void foo(void)
{
    printf("%d\n",b);
}

void baz(void)
{
    foo();
    bar();
}

==> main.c <==
extern void baz(void);
extern void bar(void);

int main(void)
{
    baz();
    bar();
    return 0;
}

==> other_bar.c <==
#include <stdio.h>

int a = 42;

void bar(void)
{
    printf("a = %d in the other %s\n",a,__func__);
}
    

Compile the 2 source files in which we want to localise definitions of bar and a:

$ gcc -c a.c b.c

Relocatable link:

$ gcc -r -o ab.o a.o b.o

Localise bar and a:

$ objcopy --localize-symbol=bar --localize-symbol=a ab.o c.o

Compile the other source files:

$ gcc -c main.c other_bar.c

And link this program:

$ gcc -o prog main.o other_bar.o c.o

whose symbol table now contains local definitions of bar and a from c.o

$ readelf -sW prog | grep -P 'LOCAL.*(\sa|\sbar)'
    14: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS a.c
    20: 000000000000401c     4 OBJECT  LOCAL  DEFAULT   26 a
    21: 00000000000011b7    44 FUNC    LOCAL  DEFAULT   16 bar
    

as well as global definitions from other_bar.o:

$ readelf -sW prog | grep -P 'GLOBAL.*(\sa|\sbar)'
    33: 0000000000001162    46 FUNC    GLOBAL DEFAULT   16 bar
    42: 0000000000004010     4 OBJECT  GLOBAL DEFAULT   25 a
    

and runs:

$ ./prog
5
0
0
a = 42 in the other bar

But this is unnecessary

Editing of binaries between compilation and linkage - with objcopy or other binary editors - is to be shunned except as a last resort, and it is not the last resort when as in your case you just want to prempt multiple definition errors in a linkage where some function is called that in turn externally references a definition of foo and some other function is or may be called that exernally references a different definition of foo. You can achieve this without binary editing by using regular dynamic linkage together with the linker option Bsymbolic

-Bsymbolic
    When creating a shared library, bind references to global symbols to the 
    definition within the shared library, if any. Normally, it is possible for 
    a program linked against a shared library to override the definition within 
    the shared library. This option is only meaningful on ELF platforms which 
    support shared libraries.

Like so:

Make shared library libbaz.so

$ gcc -c -fPIC a.c b.c
$ gcc -shared -o libbaz.so a.o b.o -Wl,-Bsymbolic

Compile the other source files:

$ gcc -c main.c other_bar.c

Link the program:

$ gcc -o prog main.o other_bar.o -L. -lbaz -Wl,-rpath='$ORIGIN'

which suceeds, and runs identically:

$ ./prog
5
0
0
a = 42 in the other bar

The call to baz() in the program is resolved to the definition in libbaz.so, which calls its internal definition of bar and references its internal definition of a. The call to bar() in the program is resolved to the definition in other_bar.o and references that file's definition of a.

You can create a static library, but that is like a container of different object files, they are not yet linked to each other.

Yes, and in fact, creating static libraries is not even a function of the linker.

You can also create a dynamic library, but this has everything already prepared for the runtime linker.

Yes, and this is a useful thing to do.

Is there a way to output the linking result of to object files as if it would have been a translation unit to the compiler.

Note well that "translation unit" is a compile-time concept with implications for the scope and linkage of some identifiers. And this "linkage" is a language-level concept. Although related to the operation of your toolchain's linker, it is not something that the linker can manipulate. Often compilation will produce an object file that corresponds to a particular translation unit, but such an object file is not itself a translation unit.

Some linkers can combine multiple relocatable objects [files] to produce another relocatable object [file]. GNU ld can do this, for example, and its docs refer to it as "partial linking". But those linkers that can do this are among the ones producing object file formats that are not directly tied to the language level scope and linkage properties. Partial linking does not change which symbol references will resolve to which symbol definitions. For most intents and purposes, it is equivalent to creating a static library.

The use-case would be that you have two translation units potentially from different languages, with all their isolation of local linkage, optimized for themself, and then link them together potentially also optimizing across the original separate translation units and taking into account symbols that have now local linkage.

I've never heard the term "linkage" used that way before, probably because it conflicts with the related, but distinct, usage of the same term at the C (and C++) language level. And perhaps that's part of your issue. Your "linkage" has to do with the contents of relocatable object files and shared objects, including both shared libraries and dynamic executables, not, directly, with translation units. From comments, your idea is to improve function-call performance by having direct calls instead of calls mediated by a GOT or PLT, but

1. that's a way premature optimization, and
2. what you've asked for is not necessary for producing it.

We'll suppose that your ultimate build target is a shared libary, a dynamically linked executable, or both, because if you're targeting statically linked anything then dynamic symbol resolution via a GOT / PLT is not relevant anyway. When you build a shared object, it is the static linker that creates its GOT. The linker has everything it needs to link references between the contributing object files exactly the same way it would do if it were creating a relocatable object (as you asked) instead, so creating a relocatable object separately does not gain you anything. At least not anything serving your stated purpose.

• Having different name scope (linkage) for different symbols. As I wrote, like if you have static variables for some translation unit first and then compile to an object file, but want to have a larger translation unit for another static variable. But you can't just put the files into larger translation units, because that will conflict with the other static symbols you want smaller translation units for.

Linkers operate on object files, not translation units. Generally speaking, it is among their key objectives to implement the language-level semantics associated with the contents of the objects they work with, and to avoid altering those semantics. The programmer determines the scope and (language-level) linkage of various identifiers according to their needs. The linker works with that; it does not redefine these after the fact.

• Using object files compiled from different languages. They can't have local linkage, because you can't compile them as a single translation unit, but when they should be accessible across languages. Then when they are linked together, the symbols could be changed to local linkage and then linked as if they have been a single translation unit all along.

The contents of different relocatable objects used to build one shared object absolutely can have what you are calling "local linkage" relative to each other, meaning that references from one to another are resolved at static link time, this isn't really a question either way of whether (external) symbols definitions and references appear in the same object file.