Differences of the inline-keyword in C and C++

Question

Consider the following C++-code with an inline-function:

// this function is in a header-file:
// recursion prevents inlining
inline int calc(int k){
    if(k<=1) return 1;
    return calc(k-1)+calc(k-2);
}

// this function is in a source-file:
int fun(int k){
    return calc(k);
}

Here I use recursion, to simulate the case when compiler was not able to inline the function calc.

The resulting assembly (compiled with -Os, see live on https://godbolt.org/):

...
        .weak   calc(int)
        .type   calc(int), @function
calc(int):
    // some assembler


       .text
        .globl  fun(int)
        .type   fun(int), @function
fun(int):
...
        jmp     calc(int)

As expected, the compiler was not able to inline calc, and thus emitted code for it, but due to inline-keyword it becomes a weak symbol.

Compiling the same code as C, produces a different result (with -Os,see live on https://godbolt.org/):

.Ltext0:
        .globl  fun
        .type   fun, @function
fun:
...
        jmp     calc

The most notable difference: there is no code emitted for calc, so basically the linker will not able to link the executable, as the definition of calc is missing.

Obviously, inline means different things in C compared to C++.

What are differences for inline in C compared to C++? How the definition of calc should be done, that it can be used in a header in C and C++ at the same time?

Inline is an interesting mess. [And there are more kinds of it.](https://stackoverflow.com/questions/216510/what-does-extern-inline-do) — , Jun 16 '21 at 14:13
See the linked question's answers for a "just make it work" variant. — , Jun 16 '21 at 14:24
If you try `__attribute((always_inline))` it will give you the error: `error: inlining failed in call to 'always_inline' 'int calc(int)': recursive inlining`.. Alternatively specify `extern` and it'll do what the C++ one does. https://en.cppreference.com/w/c/language/inline See "Notes" section for difference. — Brandon, Jun 16 '21 at 14:52
comparing `inline` behavior with `-Os` flag looks a bit weird - inlining often results in larger code size and `-Os` is a flag to minimize the code size. so it looks like a bit different heuristics, it looks more natural to check with `-O2`. — dewaffled, Jun 16 '21 at 14:56
@dewaffled I have chosen -Os because the resulting assembler is clearest. The inline function is chosen in such a way that it will not be Inlined no matter which optimization level. — ead, Jun 16 '21 at 15:25
Yep they are different. Basically the C++ version means "it's a weak symbol" and the C version means "no weak symbols; if you need a symbol, define a strong symbol separately". That us, create a separate extern function. https://stackoverflow.com/questions/17504316/what-happens-with-an-extern-inline-function — n. m. could be an AI, Jun 16 '21 at 15:34

score 3 · Answer 1 · answered Jun 26 '21 at 20:37

While the inline-keyword has the same goal in C and C++: to provide the definition of a function at compile time in multiple translation units, these languages use different methods to cope with its fallout - multiple definitions of the same symbol in different translation units.

When the C- or C++-compiler really inlines the inline-function in a translation unit, its definition is no longer needed and no corresponding symbol is emitted. As for example here:

inline int fun(){return 2;}

int doit(){
    return fun();
}

the resulting assembler is (live)

doit():
        movl    $2, %eax
        ret

However, when the function don't get inlined, the C++-standard mandates among other things the following:

There may be more than one definition of an inline function in the program as long as each definition appears in a different translation unit and all definitions are identical.
The function has the same address in every translation unit.

This more or less describes a weak symbol - and no surprise, C++-compiler emits a weak symbol in the OP's code - it has to, because the C++-standard doesn't guarantee, that this symbol will be defined in another translation unit.

On the other hand, the C-standard gurantees, that the definition of the inline-function must be provided in another translation unit(i.e. has external linkage) and thus (in order to avoid multiple definition of the same symbol) nothing is emited for the inline function - it is just called.

Thus, there must be a c-file, in which the function is "instantiated" via

inline int calc(int k)

This doesn't work well with the idea of having a header-only library. An alternative is, the use internal linkage via static-keyword, i.e.

static inline int calc(int k){
    if(k<=1) return 1;
    return calc(k-1)+calc(k-2);
}

This will emit a local symbol in every translation unit (if not inlined), independent of whether compiled as C or C++. That means, there are multipe definitions (i.e. in every translation object the function has a different address) of the same function, which will possible lead to a bigger executable, and is a setback for compared to C++-default behavior.

An alternative is to use the following definiton of inline:

#ifdef __cplusplus
    #define INLINE inline
#else
    #define INLINE static inline
#endif

and use as

INLINE int calc(int k){
    ...
}

score 0 · Answer 2 · answered Jun 16 '21 at 14:48

0

extern inline int calc(int k){

https://godbolt.org/z/3McjjT54T

answered Jun 16 '21 at 14:48

0___________

60,014
4
34
74

1

I think OP is looking for something that can be put into a header and used by multiple translation units. `extern inline` is not it. – Jun 16 '21 at 15:01

Differences of the inline-keyword in C and C++

2 Answers2