Why can not the inline function square work?

I have 2 C source files:

file1.c:

#include <stdio.h>

void masp(double);

int main()
{
    masp(1.6);
    return 0;
}

file2.c:

#include <stdio.h>

inline double square(double x) 
{ 
    return (int) (x * x + 0.5); 
}

void masp(double w)
{
    double kw = square(w);
    printf("%.2f\n", kw);
    return;
}

the compile command is:
gcc file1.c file2.c -o files

why do I get an error:

Undefined symbols for architecture x86_64:
"_square", referenced from:
_masp in ccMowbTf.o

OP's function is declared as inline double square(double); (actually declared as part of the function definition in OP's code) and has a definition in the same translation unit. Because the function does not have internal linkage (i.e. it was not declared static, and was not explicitly declared extern, the inline function definition does not constitute an external definition of the function. For a call to a function not declared with internal linkage (i.e. not declared static), the compiler is free to use an inline definition of the function or to call the external function. In OP's case, the compiler chose to call the external function, but no definition of the function with external linkage has been provided, so the program failed to link.

There are three possible solutions:

1. Either: declare the function as static inline so that the function definition is an inline function with internal linkage. The compiler is free to translate calls to the function as an actual function call or as an inline function call, with the inline keyword acting as a hint to the compiler that inline calls are preferred by the programmer.
2. Or: provide an external definition of the function. That can be done either by duplicating the function definition without the inline specifier, or by explicitly adding the extern specifier to the existing inline definition (declaring it as extern inline).
3. Or: remove the inline specifier to turn the function definition into an external function definition.

For reference, see C17/C18 section 6.7.4 paragraphs 6 and 7 and footnotes 140, 141 and 142:

> 6. A function declared with an inline function specifier is an inline function. Making a function an inline function suggests that calls to the function be as fast as possible.¹⁴⁰⁾ The extent to which such
suggestions are effective is implementation-defined.¹⁴¹⁾
> 7. 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.¹⁴²⁾
> ---
> ¹⁴⁰⁾ By using, for example, an alternative to the usual function call mechanism, such as “inline substitution”. Inline substitution is not textual substitution, nor does it create a new function. Therefore, for example, the expansion of a macro used within the body of the function uses the definition it had at the point the function body appears, and not where the
function is called; and identifiers refer to the declarations in scope where the body occurs. Likewise, the function has a single address, regardless of the number of inline definitions that occur in addition to the external definition.<br />
¹⁴¹⁾ For example, an implementation might never perform inline substitution, or might only perform inline substitutions to
calls in the scope of an inline declaration.<br />
¹⁴²⁾ Since an inline definition is distinct from the corresponding external definition and from any other corresponding inline definitions in other translation units, all corresponding objects with static storage duration are also distinct in each of the definitions.

Using GCC to compile inline function you need to enable optimizations:

https://godbolt.org/z/bG6s458ef

or to define it as extern (to add an external linkage):

extern inline double square(double x) 
{ 
    return (x * x + 0.5); 
}

or make it static

static inline double square(double x) 
{ 
    return (x * x + 0.5); 
}

https://godbolt.org/z/qx1q6xM1K

BTW it is not necessary to have two files to reproduce this behaviour:
https://godbolt.org/z/3heanfWT3

By stating that the function is inline, you are hinting the compiler that you want it "copy and paste" the function into other functions.

This leads the compiler to not actually define a new function for the square function, but instead it just pastes it's implementation in the masp function.

To fix this issue, you can either:

1. Remove the inline directive.
2. Move the inline function to a header file and include it from both files.