Post History

The standard does not talk about object files and/or linking, but it does talk about translation units. In typical compilers, a single translation unit translates into a single object file.

Obviously the C standard does not talk about translation units that are not themselves C; that's what a platform's ABI is about.

Now what the C standard tells you is this:

  * If you have the declaration

    ```
    extern int foo(void);
    ```

    in some translation unit, then it makes the name available to the current translation unit. The declaration itself does not imply that this function exists anywhere.

  * If you do call that function from anywhere in your translation unit, then *some* translation unit must define it, and it must define it with exactly that signature. From the view of the C standard, that other translation unit is, of course, another C file compiled with the same C implementation.

    Your compiler's ABI (which is *not* covered by the C standard) then tells what this means in terms of symbols and code. For example, it tells you that there has to be a symbol that's named `foo` (in some ABIs, it's `_foo` instead), which must lead to executable code that leaves some integer value in a specific register (and usually has some further requirements, e.g. on what it does with the stack).

    Obviously some object file generated with another compiler or hand-written assembly will work exactly if the correct symbol exists and points to code fulfilling all the conditions required by the ABI.

    These days, the C ABI is usually fixed by the platform. That is, all C compilers on the same platform are interoperable. Note however that this is not mandated by the C standard, which always assumes a single C implementation. Note also that a compiler may support different ABIs (this was especially the case with early compilers on 8086, which supported different so-called memory models).

Note that usually different languages have different calling conventions. But often languages allow to explicitly use the C calling conventions of the platform. Sometimes it is even part of the language specification of that language (such es `extern "C"` in C++). But obviously the C language standard doesn't tell you anything about other languages.