Why are symbols unresolved here?

I've read here:

and it stated:

> A function defined with inline on its own. Stand-alone object code is always emitted. You can only write one definition like this in your entire program. If you want to use it from other translation units to the one where it is defined, you put a declaration in a header file; but it would not be inlined in those translation units.

however, in my minimal reproducible example:

test.c

inline                                                                                                                                                                         
int foo(void)                                                                                                                                                                  
{                                                                                                                                                                              
  return 0;                                                                                                                                                                    
}                                                                                                                                                                              
                                                                                                                                                                               
int main(void)                                                                                                                                                                 
{                                                                                                                                                                              
  foo();                                                                                                                                                                       
}  

receives

cc -std=c99 -Wall -Wextra -Wshadow -Wpedantic test.c -o test                                                                                                                   
Undefined symbols for architecture x86_64:                                                                                                                                     
  "_foo", referenced from:                                                                                                                                                     
      _main in test-febb67.o                                                                                                                                                   
ld: symbol(s) not found for architecture x86_64                                                                                                                                
clang: error: linker command failed with exit code 1 (use -v to see invocation)                                                                                                
make: *** [Makefile:4: test] Error 1 

so it seems that code is not being properly emitted. The same problem is also present in gcc. What is going on here? Specifically, I'd like to know, what are the differences here:

This fixes it.

inline foo(void) { /* definition */ }
foo(void);

This fixes it.

foo(void) { /* definition */ }
inline foo(void);

and my case:
Wrong.

inline foo(void) { /* definition */ }

I saw here that it could be because it has external linkage, but an external definition is not provided; however, this is only references in main and in a single translation unit (internally). Where is the symbol unresolved and why? It must be the call in main.

I’ve found that with -O2 turned on, there is no issue, and this is because code is not originally being emitted and it is not being inlined by default.

This did not answer my question. I am not asking about the static inline fix, except in why it is treated differently than just inline in this case, which I still do not understand. Why does that always cause an emission?

I’d like to understand why this is a problem in the first place, since I’d read that it would emit code. Is this present anywhere explicitly in the standard?

> Is this present anywhere explicitly in the standard?

This is what the C language specification says about it:

> Any function with internal linkage can be an inline function. For a
> function with external linkage, the following restrictions apply: If a
> function is declared with an inline function specifier, then it shall
> also be defined in the same translation unit. If all of the file scope
> declarations for a function in a translation unit include the inline
> function specifier without extern, then the definition in that
> translation unit is an inline definition. An inline definition does
> not provide an external definition for the function, and does not
> forbid an external definition in another translation unit. An inline
> definition provides an alternative to an external definition, which a
> translator may use to implement any call to the function in the same
> translation unit. It is unspecified whether a call to the function
> uses the inline definition or the external definition.

(C23 6.7.4/7; emphasis added)

and

> An external definition is an external declaration that is also a
> definition of a function (other than an inline definition) or an
> object. If an identifier declared with external linkage is used in an
> expression (other than [...]), somewhere in
> the entire program there shall be exactly one external definition for
> the identifier [...]

(C23 6.9/5; emphasis added)

That plays out for your code like so:

• By virtue of being declared at file scope without static, function foo has external linkage.

• Because foo is declared inline but not explicitly extern, the provided definition is an inline definition, not an external definition.

• Your main() calls foo, which has external linkage, so somewhere in the whole program there needs to be an external definition of that function, but there isn't. Therefore your program is non-conforming.

> so it seems that code is not being properly emitted.

No, you've got that mixed up. Rather: the code is properly not being emitted. An inline definition is not an external definition, and the compiler needs to leave room for an external definition to be provided by another translation unit.

GCC is not required to reject incorrect programs, and it's reasonable to imagine that it might figure out what to do with yours, but it is completely within its rights and the spec to reject the program. That it accepts the program when you enable optimization is fully consistent.

> This fixes it.
>
> inline foo(void) { /* definition */ }
> foo(void);
>

Yes. Now the condition "If all of the file scope declarations for a function in a translation unit include the inline function specifier without extern" is no longer satisfied, so the definition is an external one, not an inline one.

> This fixes it.
>
> foo(void) { /* definition */ }
> inline foo(void);
>

Same. Now foo's definition is an external one.

Another solution in the same vein:

extern inline foo(void) { /* definition */ }

And of course, you can avoid the issue by giving foo internal linkage. There are several variations on that, but this is one of them:

static inline foo(void) { /* definition */ }

.

If you think this is all a bit weird, then you're right. It's usually best to avoid the issue by giving your inline functions internal linkage (by declaring them static). But if you don't do that, then a reasonable usage pattern is similar to that for declaring and defining external variables:

• put the (inline) definition in a header.
• choose one translation unit to provide the external definition. In this TU,
  • #include the header, and
  • redeclare the function with the extern specifier.

That gets you the needed external definition without duplicating any code, but I don't see much to recommend it over simply making the definition static.