13

This question comes from an attempt to understand the "C philosophy" and not from any "real problem".

Suppose that in a C program I use sin(x):

#include <stdio.h>

int main() {
  char s[20] = "aha";
  printf("%f", sin(s));
  return 0;
}

I have deliberately made two mistakes:

  1. I have not #includeed math.h (or provided any declaration for sin).
  2. I made s of type char * (just something that cannot be cast meaningfully to a double).

I compile using GCC with the -lm flag.

As expected, I get one warning and one error.

Of course, there is the warning of implicit declaration of function blah blah:

bad.c: In function ‘main’:

bad.c:5:15: warning: implicit declaration of function ‘sin’ [-Wimplicit-function-declaration]
    5 |   printf("%f", sin(s));
      |                ^~~
bad.c:5:16: warning: incompatible implicit declaration of built-in function ‘sin’
bad.c:2:1: note: include ‘<math.h>’ or provide a declaration of ‘sin’
    1 | #include <stdio.h>
  +++ |+#include <math.h>

A little research seems to indicate that if a function is not declared beforehand, then C assumes a "default declaration" (the so called "implicit declaration") which is like int undeclaredfunction(void).

But I also get the following error:

    2 |
bad.c:5:19: error: incompatible type for argument 1 of ‘sin’
    5 |   printf("%f", sin(s));
      |                    ^
      |                    |
      |                    char *
bad.c:5:20: note: expected ‘double’ but argument is of type ‘char *’

This shows that the "implicit declaration" expects an argument of type double.

  1. It seems that C maintains a list of correct "implicit declarations" for "standard functions". Where can I find the comprehensive list of such correct implicit declarations for a given compiler (say gcc or clang)?
  2. If C already has the correct declarations of the standard math functions built in, then why does it expect the programmer to #include<math.h>? Just because of tradition? Or neatness?

The answer(s) that I looking for are about the exact rules used by the compiler, and not about subjective comments about "good programming practices".

Improve this question
7
  • 4
    "C" does not have a list of implicit declarations for standard functions. If there was no function declaration, then the compiler will assume the argument to be int, so if you pass char* that can't be right. The compiler does not know that sin is a double value (it could be your own function), but is does know that %f in printf() expects a double value. A compiler might supply a recommendation, though, for math.h. Commented Apr 4 at 12:34
  • 3
    @WeatherVane looks like the error about double is related to the input for sin, not the output (which is supposed to be printed with %f). Commented Apr 4 at 12:37
  • @wohlstad MSVC's messages are slightly different. 'sin' undefined; assuming extern returning int, and 'printf' : format string '%f' requires an argument of type 'double', but variadic argument 1 has type 'int' Commented Apr 4 at 12:39
  • 1
    @WeatherVane sure, I was refering to the error message the OP posted (presumably from gcc). Commented Apr 4 at 12:46
  • 2
    @NTG That's because even the most ancient gcc version on Godbolt is still decades newer than MSVC 17.10 which was released in 2022 but with a compiler from 1989 somewhere. Commented Apr 4 at 13:00

4 Answers 4

Reset to default
23

This shows that the "implicit declaration" expects an argument of type double.

No, it does not show that. The reason the compiler expected a double argument is not because there was an implicit declaration. It is because the name sin is reserved.

C 2024 7.1.3 says:

… All identifiers with external linkage in any of the following subclauses (including the future library directions) and errno are always reserved for use as identifiers with external linkage…

Reserving the name for use by the C standard library means that, if a program uses it other than in the reserved way, the behavior is not defined by the C standard. It does not specifically say that a C implementation must treat the name as predeclared and known to the compiler, but it allows that. In this case, GCC did know about the name and issued an error on that basis. That is, it did not use a generic implicit declaration; it used its own knowledge of what the sin routine particularly should be.

… "default declaration" (the so called "implicit declaration") which is like int undeclaredfunction(void).

In C 1990, an undeclared identifier used for a function call would be implicitly declared as extern int identifier();, per C 1990 6.3.2.2. This was removed in C 1999. Some compilers have retained support for it, particularly in modes that do not conform to the current C standard.

The () in that declaration meant the parameter types were not specified. (That changed in C 2024; it would now mean there are no parameters.)

  1. It seems that C maintains a list of correct "implicit declarations" for "standard functions". Where can I find the comprehensive list of such correct implicit declarations for a given compiler (say gcc or clang)?

The C 2024 standard specifies reserved identifiers and forms of reserved identifiers primarily in clause 7, with some mentions elsewhere. For example, while is reserved because it is a keyword, not because it is a library routine. Some reserved identifiers are specified as patterns, not specific single strings. For example, C 2024 6.4.3.1 says all identifiers beginning with two underscores or one underscore and an uppercase letter are reserved for any use.

GCC supports many built-in functions beginning with __builtin, and those are documented here. However, that is not a complete list of all the reserved identifiers it uses. GCC and Clang also predefine certain macros. Clang documents those here. I do not think there is a single place where you will find all the predefined (or otherwise special) identifiers that either GCC and Clang uses. Compilers, libraries, and system headers may use reserved identifiers for internal purposes without documenting them.

  1. If C already has the correct declarations of the standard math functions built in, then why does it expect the programmer to #include<math.h>? Just because of tradition? Or neatness?

When a person is writing code for the operating system kernel and wants to call its routine to write to the system log, they want log to link to that routine, and have its declaration, and not be the mathematical log routine declared in <math.h>. The standard library routines were grouped into subsets to reduce name collisions for people working in different domains. When compiling for a freestanding environment (such as operating system code) instead of a hosted environment (the ordinary programs you are most familiar with), the reserved identifiers are reduced.

Additionally, while sin is reserved for use with external linkage, a programmer may define their own sin routine with internal linkage (declared with static), and that declaration may differ from the math library routine.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

15

The C standard gives little if any mention of built-in functions, however some C implementations have a set of built-in functions that are "predeclared", so to speak.

For GCC in particular, the following page lists the built-in functions:

7 Built-in functions provided by GCC

And this page in particular lists C library functions that are built in:

7.1 Builtins for C library functions

The sin function is among this list, so the proper declaration of double sin(double) exists as a built-in.

If this same code is compiled under MSVC, it does not generate an error. Their list of built-in functions can be found here:

Compiler intrinsics

And apparently sin is not among its list of built-in functions, so it uses the implicit declaration of int sin() (note that prior to C23 this is not the same as int sin(void), as the former has an unspecified number of arguments while the latter has zero). Subsequently running the program would trigger undefined behavior as the sin function is being called through an incompatible function pointer.

Improve this answer

4 Comments

"...so it [MSVC] uses the implicit declaration of int sin()" It should be noted that this is non-conforming behavior by MSVC.
@Lundin: I take it you mean "non-comforming to C23"? That's hardly a surprise. MSVC++ is primarily a C++ compiler. Even C99 support lagged until they needed it for C++11 compliance.
@MSalters This behavior is non-conforming from C99 and up to C23. The MSVC compiler is non-conforming to any C standard out of the box. With some compiler options added, you can make it conform to C 1989, but not to make it fully compliant with C 1999 or later.
The MSVC compiler is a C++ compiler. If you mean it is non-conforming to C++, you should explain that. If you mean that it is non-conforming to some other language standard, you shouldn't claim that it "should* be noted.
7

First of all, implicit declarations are obsolete. A thing of the past. Never rely on them.

It seems that C maintains a list of correct "implicit declarations" for "standard functions". Where can I find the comprehensive list of such correct implicit declarations for a given compiler (say gcc or clang)?

An implicit declaration is made when you first use the function (without a prior explicit declaration). However you used it will become the implicit declaration. int as a return value apparently seemed like a good guess at the time implicit declarations was accepted, so the implicit declaration means the function is expected to return int.

If C already has the correct declarations of the standard math functions built in, then why does it expect the programmer to #include<math.h>? Just because of tradition? Or neatness?

You are gravedigging. There's no list of correct declarations. Modern compilers tuned into modern C standards will refuse programs relying on implicit declarations. Historically, the compiler guessed wrong too many times and made a mess of your final program so they removed implicit declarations from the language.

Improve this answer

1 Comment

int as a return value might even have some echos of B language, which didn't have distinct types (and so didn't really need function declarations). Implicit declarations almost certainly wouldn't exist without the B heritage of C.
4

A little research seems to indicate that if a function is not declared beforehand, then C assumes a "default declaration"

No, that's wrong. It used to be that back in the 1990s, but it was a big language design mistake, which why implicit declaration/implicit int was removed from the language in year 1999.

It seems that C maintains a list of correct "implicit declarations" for "standard functions". Where can I find the comprehensive list of such correct implicit declarations for a given compiler (say GCC or Clang)?

First of all, the GCC compiler might unfortunately, as a "feature", use certain standard functions/macros even when you forgot to include the relevant header. This introduces a potential for bugs to remain undetected whenever using GCC, since it "only" gives a warning, all the way up to the most recent version 14.x which gives an error. (I think this has to do with C23 rendering certain K&R style declarations invalid.)

The ability to use "built-in" versions of standard library functions might be related to if the standard library implements the function as a function-like macro or not. When I change your code to the still valid C (sin)(s), then the compiler loses the ability to expand this as a function-like macro and suddenly it knows nothing about sin (because we didn't include math.h).

If C already has the correct declarations of the standard math functions built in, then why does it expect the programmer to #include<math.h>? Just because of tradition? Or neatness?

It doesn't. This is just a GCC thing.

The answer(s) that I looking for are about the exact rules used by the compiler

The compiler may not follow standard C. In fact, GCC does not out of the box. If you want it to behave as a standard C compiler, you have to tell it to compile with for example:

-std=c17 -pedantic-errors
Improve this answer

4 Comments

"It used to be that back in the 1990s" -- and the 1980s, and the 1970s. Although those years preceded ANSI and ISO standardization, implicit function declarations were a consistent feature of substantially all C implementations of the time. That's about as long in the language than they have been out of it, and it explains, in part, why the (mis)feature is still supported by many compilers.
@JohnBollinger gcc only dates back to 1987 or some such though.
Yes, but the question is presented mostly in terms of the requirements of the C language, with gcc and clang given as exemplars. It is not specific to gcc. I am reading this answer as being oriented in the same way, else it would be much less responsive to the question.
@JohnBollinger Either way, if the OP is actually interested in C language behavior before C89 then they should ask a separate question about that on the retrocomputing site.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.