1

I'm generating machine code to call functions from existing system libraries. Most system libraries were written in C, so I'll take C as an example, but the question probably applies to any other language.

If I understand this answer correctly, C compilers are free to choose the ABI/calling convention of a function as long as they preserve the semantics. For instance they can choose to pass a pointer for the returned value as an argument to obtain copy-elision.

Does this mean that no one can ever truly know what's the right way to call a function from a library, even if its C signature is known?

Is this a real concern in practice? Or is it safe to assume that all the functions with non-mangled names from system libraries always use the system's default calling convention?

What other assumptions or considerations can I make about the ABI/calling convention of functions with non-mangled names in system libraries?

Blue Nebula
  • 932
  • 4
  • 9
  • 1
    ABI typically depends on the target hardware and operating system, not on compiler. – Some programmer dude Mar 05 '21 at 11:50
  • @Someprogrammerdude: so you say that it's always known how a function should be called, given it's C signature and the target system (hardware+OS)? – Blue Nebula Mar 05 '21 at 12:04
  • https://uclibc.org/docs/psABI-x86_64.pdf – KamilCuk Mar 05 '21 at 12:05
  • A compiler is free to choose whatever ABI it wants to use for its own internal function calls. However, when writing functions to be be called from outside the things it compiles or when writing calls to functions outside the things it compiles, it must conform to an ABI specified for that use. Commonly, there is an ABI associated with the platform it is targeting, and that ABI is used for all calls between different object modules. There can be multiple ABIs, in which case the compiler would have some provision(s) for designating which ABI is to be used. – Eric Postpischil Mar 05 '21 at 12:07
  • (Note that while a compiler is free to vary the ABI it uses for internal calls, this would affect things such as debugging and stack traces/dumps, as those rely on the ABI.) – Eric Postpischil Mar 05 '21 at 12:08

2 Answers2

1

C compilers are free to choose the ABI/calling convention of a function as long as they preserve the semantics.

Well, yes and no. The ABI is often defined by the target system, in which case the compiler has to fall in line. In case there exists no ABI for the target system (often the case in microcontroller programming), the compiler is free to do as it pleases, essentially inventing the ABI.

Does this mean that no one can ever truly know what's the right way to call a function from a library, even if its C signature is known?

No you can't unless you know the target system and calling convention. Some systems have several "de facto" standards such as x86 Windows __cdecl vs __stdcall see https://en.wikipedia.org/wiki/X86_calling_conventions

Is this a real concern in practice?

Not within a program written entirely in C. But it becomes a big problem in case the program links external libs such as Windows DLLs, possibly written in other languages. Then you have to use the right calling convention or the program will soon crash.

It's also a very real concern whenever you attempt to mix assembler and C for the given system - the C compiler will handle stacking according to the calling convention, but in the assembler part you have to write this manually. This can also affect the C code, if it is written with care to suit assembler. You'd then pick parameter and return types that are convenient to use.

Lundin
  • 195,001
  • 40
  • 254
  • 396
1

If I understand this answer correctly, C compilers are free to choose the ABI/calling convention of a function as long as they preserve the semantics. For instance they can choose to pass a pointer for the returned value as an argument to obtain copy-elision.

I don't see how you conclude that from the answer you referenced. Calling conventions are a characteristic of the function, as it appears in compiled form. The compiler can do all manner of tricks at the point of call, but changing or ignoring the calling conventions of the function implementation is not one of them. Where it is possible, copy elision for returned structure values (the subject of that answer) does not rely on any such thing.

Does this mean that no one can ever truly know what's the right way to call a function from a library, even if its C signature is known?

Yes and no. The function signature alone does not convey anything about calling convention (with some caveats; see below), but libraries simply could not work if there were no way to know calling conventions. In practice, it is usually the case that calling convention (and ABI overall) is standardized on a per-platform basis.

Thus, for example, Linux implementations for x86_64 substantially all follow the same conventions. All the toolchains targeting that platform both use that convention for function calls and provide for functions to be called according to it. Compilers for Win64 likewise follow the appropriate (different) conventions.

Windows is in fact an interesting case, however, because historically, it has supported multiple calling conventions. In its case, there is a default convention, and different conventions can be specified in function declarations via extension keywords. The compiler knows which convention to use based on the function declaration.

Additionally, where it is not concerned about interoperability, compilers can do anything within their power. So, for example, when compiling a function with internal linkage, it could, in principle, use whatever calling convention it wants, as it is in full control of both the function and all callers (ignoring the possible effect of function pointers). This is not different in kind from compilers' ability to inline functions. As a practical matter, however, I would not expect compilers to use variant calling conventions under such circumstances, and I am not aware of any that do.

Is this a real concern in practice? Or is it safe to assume that all the functions with non-mangled names from system libraries always use the system's default calling convention?

Name mangling has nothing to do with it. That's part of a higher-level mapping of C++ (usually) semantics onto system-level, source-language-independent object-file formats.

Generally speaking, it is safe to assume that where the appropriate function declarations are in scope (from the library's header files, typically), the compiler will generate correct calls. This is an essential interoperability characteristic that is rarely violated in practice. It cannot be construed as a universal guarantee, but in practice, it is not something that you should worry about.

What other assumptions or considerations can I make about the ABI/calling convention of functions with non-mangled names in system libraries?

I'm unsure what kinds of assumptions you have in mind, and I suspect you're overcomplicating things. You make sure to include the header(s) from the relevant library that declare the functions you want to call. Having done so, you rely on your compiler to generate correct calls.

John Bollinger
  • 160,171
  • 8
  • 81
  • 157