[clang] improve GCC-compat for C90 __builtin_ functions

[nickdesaulniers]

Summary

Implements most of the missing C90 __builtin_* functions, and a few
straglers like putchar, fputs, putc, fputc, and free.

Format strings for __builtin_* were copied (and f -> F), but the
signatures for the three above should be more carefully checked.

More importantly, start adding missing tests for
builtin_*/has_builtin, and document more builtins.

Reported-by: Masahiro Yamada <[e-mail]>
Signed-off-by: Nick Desaulniers <[e-mail]>

[nickdesaulniers]

• add more docs

[nickdesaulniers]

• misuploaded

[nickdesaulniers]

bumping for review. Are there additional reviewers we could add to share the burden?

[rsmith]

LGTM

I've not checked all the types are correct (someone should double-check that prior to commit), but it looks like GCC provides these __builtin_* functions, so we should too. The addition of the non-__builtin_ versions should improve our diagnostics but otherwise have no effect.

clang/lib/Lex/PPMacroExpansion.cpp

348 ↗

(On Diff #287573)

The changes to this file appear to be independent of the rest of the patch. Please go ahead and land this cleanup separately.

clang/test/CXX/over/over.oper/over.literal/p7.cpp

10 ↗

(On Diff #287573)

Doesn't this also need to be extern "C" to be recognized as the builtin?

[aaron.ballman]

clang/include/clang/Basic/Builtins.def

488

Should we be adding atexit() as well?

514

Should we also add a builtin for putc() (I know that's often a macro, so I'm not certain if it applies)?

[rsmith]

clang/include/clang/Basic/Builtins.def

488

GCC doesn't have a __builtin_atexit, so we'd need some reason to invent one.

514

Yes, GCC has a __builtin_putc, so it'd make sense for us to support that too.

[aaron.ballman]

clang/include/clang/Basic/Builtins.def

488

Ah, I didn't realize this was for GCC compatibility. Thanks!

[nickdesaulniers]

• rebase on master, precommitted getLangOpts() change, dropped p7.cpp test change

clang/include/clang/Basic/Builtins.def

514

Curious, putc isn't documented at https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html, which is what I was using. It looks like putc was a part of ANSI C, so I'm not sure what else might be missing from my implementation. Let me see if I can find a more complete list of C90 functions to verify.

clang/lib/Lex/PPMacroExpansion.cpp

348 ↗

(On Diff #287573)

done: 663f4f7edc2476231fa5bfc04519d5fd51a10112

clang/test/CXX/over/over.oper/over.literal/p7.cpp

10 ↗

(On Diff #287573)

Interesting, if I change this back to void, the test passes for me. I'm not sure why it ever failed then. Will drop this hunk from the diff.

[nickdesaulniers]

clang/include/clang/Basic/Builtins.def

514

(retrieves copy of The Standard C Library from P. J. Plauger)

[nickdesaulniers]

clang/include/clang/Basic/Builtins.def

514

Looks like I'm missing:

From stdlib.h:

• div
• ldiv
• bsearch
• qsort
• rand
• srand
• atof
• atoi
• atol
• mblen
• mbstowcs
• mbtowc
• wcstombs
• wctomb
• abort
• atexit
• getenv
• system

From string.h:

• strcoll

From stdio.h:

• remove
• rename
• tmpfile
• fclose
• fflush
• freopen
• setvbuf
• scanfwrite
• fgetc
• fgets
• fputc
• getc
• getchar
• gets
• putc
• ungetc
• fgetpos
• fseek
• fsetpos
• ftell
• rewind
• clearerr
• feof
• ferror
• perror

We look good on ctype.h and stdard.h. Shall I very those against GCC and implement what's missing here?

[nickdesaulniers]

clang/include/clang/Basic/Builtins.def

514

(abort should not have been in the above list; it's in GCC's docs and we implement the builtin for it)

From the above list, GCC has builtins for:

• fputc
• putc

We already support `abort. Let me:

1. file a docs bug against GCC for those 2 undocumented builtins.
2. add implementations of them to this change.
3. add a test case for pr/47387 just to be safe.

[nickdesaulniers]

• add putc and fputc builtins

[nickdesaulniers]

clang/include/clang/Basic/Builtins.def

514

1. Filed https://gcc.gnu.org/bugzilla/show_bug.cgi?id=96907.
2. done
3. as long as clang adds the no-builtin-puts attribute, then pr/47387 is fixed. It may not be interesting to add a test for properly emitting the builtin, since clang/test/CodeGen/libcalls-fno-builtin.c already covers that.

[nickdesaulniers]

clang/docs/LanguageExtensions.rst

2439

Let me triple check the docs look good.

[nickdesaulniers]

• improve docs

[nickdesaulniers]

Ok, this is ready for review. I plan to review the newer C standards than ISO C90 in follow up patches, so I'll likely be touching these file more. Figuring out a more maintainable sort order in particular is an itch I'd like to scratch.

[aaron.ballman]

This looks reasonable to me.

clang/docs/LanguageExtensions.rst

2370

Can you mention the deprecation issue here?

[rsmith]

clang/docs/LanguageExtensions.rst

2370–2398

Do we really provide constant evaluation support for all of these functions?

2381

Do we really provide __builtin_strerror? I don't see it below.

2425–2435

You've moved this from the section where we describe the constant evaluation rules for these functions to a section where we describe the constant evaluation rules for string functions; those rules are quite different.

2427–2428

We should say how these "builtin forms" are named and what they're for: that we provide a __builtin_-prefixed version of each of these functions that has the same signature and semantics as the function from the C standard library but doesn't require a header to be included.

[rsmith]

It seems to me that adding new __builtin_* functions for GCC compatibility and adding new LIBBUILTINs are unrelated changes, and it might be clearer to split them up into two commits.

[nickdesaulniers]

clang/docs/LanguageExtensions.rst

2370

LLVM will generate calls to bcmp, see commit 8e16d73346f8 ("[SelectionDAG] Allow the user to specify a memeq function.").

I don't think we should be doing that, if we're going to mention explicitly in our docs that bcmp is deprecated. It feels like a double standard to dissuade its use, but then go and generate calls to it that weren't written explicitly.

2370–2398

Is that what is meant by having "buitins" for these functions? (I'm not sure whether you're arguing that these should be listed somewhere else, or that the current patch is not enough to claim support for __has_builtin for these functions).

2381

We have the LIBBUILTIN rule for it, but not the corresponding BUILTIN rule. Should I add it?

clang/docs/LanguageExtensions.rst

 
 String builtins
 ---------------
 
 Clang provides constant expression evaluation support for builtins forms of
 the following functions from the C standard library headers
 ``<string.h>`` and ``<wchar.h>``:
 
+* ``bcmp``
 * ``memchr``
-* ``memcmp`` (and its deprecated BSD / POSIX alias ``bcmp``)
+* ``memcmp``
+* ``memcpy``
+* ``memmove``
+* ``memset``
+* ``strcat``
 * ``strchr``
 * ``strcmp``
+* ``strcpy``
+* ``strcspn``
+* ``strerror``
 * ``strlen``
+* ``strncat``
 * ``strncmp``
+* ``strncpy``
+* ``strpbrk``
+* ``strrchr``
+* ``strstr``
+* ``strtok``
+* ``strxfrm``
 * ``wcschr``
 * ``wcscmp``
 * ``wcslen``
 * ``wcsncmp``
 * ``wmemchr``
 * ``wmemcmp``
+* ``wmemcpy``
+* ``wmemmove``
 
 In each case, the builtin form has the name of the C library function prefixed
 by ``__builtin_``. Example:
 
 .. code-block:: c
 
   void *p = __builtin_memchr("foobar", 'b', 5);
 

 
 Constant evaluation support for the ``__builtin_mem*`` functions is provided
 only for arrays of ``char``, ``signed char``, ``unsigned char``, or ``char8_t``,
 despite these functions accepting an argument of type ``const void*``.
 
 Support for constant expression evaluation for the above builtins can be detected
 with ``__has_feature(cxx_constexpr_string_builtins)``.
 
+ctype.h builtins
+----------------
+Clang provides support for builtins forms of the following functions from the C
+standard library header ``<ctype.h>``:
+
+* ``isalnum``
+* ``isalpha``
+* ``isblank``
+* ``iscntrl``
+* ``isdigit``
+* ``isgraph``
+* ``islower``
+* ``isprint``
+* ``ispunct``
+* ``isspace``
+* ``isupper``
+* ``isxdigit``
+* ``tolower``
+* ``toupper``
+
+stdio.h builtins
+----------------
+Clang provides support for builtins forms of the following functions from the C
+standard library header ``<stdio.h>``:
+
+* ``fopen``
+* ``fprintf``
+* ``fputc``
+* ``fputs``
+* ``fread``
+* ``fscanf``
+* ``fwrite``
+* ``printf``
+* ``putc``
+* ``putchar``
+* ``puts``
+* ``scanf``
+* ``snprintf``
+* ``sprintf``
+* ``sscanf``
+* ``vfprintf``
+* ``vprintf``
+* ``vscanf``
+* ``vsnprintf``
+* ``vsprintf``
+* ``vsscanf``
+
+stdlib.h builtins
+-----------------
+Clang provides support for builtins forms of the following functions from the C
+standard library header ``<stdlib.h>``:
+
+* ``_Exit``
+* ``abort``
+* ``calloc``
+* ``exit``
+* ``free``
+* ``malloc``
+* ``realloc``
+* ``strtod``
+* ``strtof``
+* ``strtol``
+* ``strtold``
+* ``strtoll``
+* ``strtoul``
+* ``strtoull``
+
 Memory builtins
 ---------------
 
  * ``__builtin_memcpy_inline``
 
 .. code-block:: c
 
   void __builtin_memcpy_inline(void *dst, const void *src, size_t size);
 
 ``__builtin_memcpy_inline(dst, src, size)`` is identical to
 ``__builtin_memcpy(dst, src, size)`` except that the generated code is
 guaranteed not to call any external functions. See [LLVM IR ‘llvm.memcpy.inline’
 Intrinsic](https://llvm.org/docs/LangRef.html#llvm-memcpy-inline-intrinsic) for
 more information.
 
 Note that the `size` argument must be a compile time constant.
 
-Clang provides constant expression evaluation support for builtin forms of the
-following functions from the C standard library headers
-``<string.h>`` and ``<wchar.h>``:
-
-* ``memcpy``
-* ``memmove``
-* ``wmemcpy``
-* ``wmemmove``
-
-In each case, the builtin form has the name of the C library function prefixed
-by ``__builtin_``.
-
 Constant evaluation support is only provided when the source and destination
 are pointers to arrays with the same trivially copyable element type, and the
 given size is an exact multiple of the element size that is no greater than
 the number of elements accessible through the source and destination operands.
 
 Constant evaluation support is not yet provided for ``__builtin_memcpy_inline``.
 
 Atomic Min/Max builtins with memory ordering

clang/include/clang/Basic/Builtins.def

 BUILTIN(__builtin_va_start, "vA.", "nt")
 BUILTIN(__builtin_va_end, "vA", "n")
 BUILTIN(__builtin_va_copy, "vAA", "n")
 BUILTIN(__builtin_stdarg_start, "vA.", "nt")
 BUILTIN(__builtin_assume_aligned, "v*vC*z.", "nc")
 BUILTIN(__builtin_bcmp, "ivC*vC*z", "Fn")
 BUILTIN(__builtin_bcopy, "vv*v*z", "n")
 BUILTIN(__builtin_bzero, "vv*z", "nF")
+BUILTIN(__builtin_calloc, "v*zz", "F")
+BUILTIN(__builtin_exit, "vi", "Fr")
 BUILTIN(__builtin_fprintf, "iP*cC*.", "Fp:1:")
+BUILTIN(__builtin_fputc, "iiP*", "F")
+BUILTIN(__builtin_fputs, "icC*P*", "F")
+BUILTIN(__builtin_free, "vv*", "F")
+BUILTIN(__builtin_fscanf, "iP*RcC*R.", "Fs:1:")
+BUILTIN(__builtin_isalnum, "ii", "FnU")
+BUILTIN(__builtin_isalpha, "ii", "FnU")
+BUILTIN(__builtin_iscntrl, "ii", "FnU")
+BUILTIN(__builtin_isdigit, "ii", "FnU")
+BUILTIN(__builtin_isgraph, "ii", "FnU")
+BUILTIN(__builtin_islower, "ii", "FnU")
+BUILTIN(__builtin_isprint, "ii", "FnU")
+BUILTIN(__builtin_ispunct, "ii", "FnU")
+BUILTIN(__builtin_isspace, "ii", "FnU")
+BUILTIN(__builtin_isupper, "ii", "FnU")
+BUILTIN(__builtin_isxdigit, "ii", "FnU")
+BUILTIN(__builtin_malloc, "v*z", "F")
 BUILTIN(__builtin_memchr, "v*vC*iz", "nF")
 BUILTIN(__builtin_memcmp, "ivC*vC*z", "nF")
 BUILTIN(__builtin_memcpy, "v*v*vC*z", "nF")
 BUILTIN(__builtin_memcpy_inline, "vv*vC*Iz", "nt")
 BUILTIN(__builtin_memmove, "v*v*vC*z", "nF")
 BUILTIN(__builtin_mempcpy, "v*v*vC*z", "nF")
 BUILTIN(__builtin_memset, "v*v*iz", "nF")
 BUILTIN(__builtin_printf, "icC*.", "Fp:0:")
+BUILTIN(__builtin_putc, "iiP*", "F")
+BUILTIN(__builtin_putchar, "ii", "F")
+BUILTIN(__builtin_puts, "icC*", "nF")
+BUILTIN(__builtin_realloc, "v*v*z", "F")
+BUILTIN(__builtin_scanf, "icC*R.", "Fs:0:")
+BUILTIN(__builtin_sscanf, "icC*RcC*R.",  "Fs:1:")
+BUILTIN(__builtin_sprintf, "ic*cC*.", "Fp:1:")
 BUILTIN(__builtin_stpcpy, "c*c*cC*", "nF")
 BUILTIN(__builtin_stpncpy, "c*c*cC*z", "nF")
 BUILTIN(__builtin_strcasecmp, "icC*cC*", "nF")
 BUILTIN(__builtin_strcat, "c*c*cC*", "nF")
 BUILTIN(__builtin_strchr, "c*cC*i", "nF")
 BUILTIN(__builtin_strcmp, "icC*cC*", "nF")
 BUILTIN(__builtin_strcpy, "c*c*cC*", "nF")
 BUILTIN(__builtin_strcspn, "zcC*cC*", "nF")
 BUILTIN(__builtin_strdup, "c*cC*", "nF")
 BUILTIN(__builtin_strlen, "zcC*", "nF")
 BUILTIN(__builtin_strncasecmp, "icC*cC*z", "nF")
 BUILTIN(__builtin_strncat, "c*c*cC*z", "nF")
 BUILTIN(__builtin_strncmp, "icC*cC*z", "nF")
 BUILTIN(__builtin_strncpy, "c*c*cC*z", "nF")
 BUILTIN(__builtin_strndup, "c*cC*z", "nF")
 BUILTIN(__builtin_strpbrk, "c*cC*cC*", "nF")
 BUILTIN(__builtin_strrchr, "c*cC*i", "nF")
 BUILTIN(__builtin_strspn, "zcC*cC*", "nF")
 BUILTIN(__builtin_strstr, "c*cC*cC*", "nF")
+BUILTIN(__builtin_tolower, "ii", "FnU")
+BUILTIN(__builtin_toupper, "ii", "FnU")
 BUILTIN(__builtin_wcschr, "w*wC*w", "nF")
 BUILTIN(__builtin_wcscmp, "iwC*wC*", "nF")
 BUILTIN(__builtin_wcslen, "zwC*", "nF")
 BUILTIN(__builtin_wcsncmp, "iwC*wC*z", "nF")
 BUILTIN(__builtin_wmemchr, "w*wC*wz", "nF")
 BUILTIN(__builtin_wmemcmp, "iwC*wC*z", "nF")
 BUILTIN(__builtin_wmemcpy, "w*w*wC*z", "nF")
 BUILTIN(__builtin_wmemmove, "w*w*wC*z", "nF")
 BUILTIN(__builtin_return_address, "v*IUi", "n")
 BUILTIN(__builtin_extract_return_addr, "v*v*", "n")
 BUILTIN(__builtin_frame_address, "v*IUi", "n")
 BUILTIN(__builtin___clear_cache, "vc*c*", "n")
 BUILTIN(__builtin_setjmp, "iv**", "j")
 BUILTIN(__builtin_longjmp, "vv**i", "r")
 BUILTIN(__builtin_unwind_init, "v", "")
 BUILTIN(__builtin_eh_return_data_regno, "iIi", "nc")
 BUILTIN(__builtin_snprintf, "ic*zcC*.", "nFp:2:")
-BUILTIN(__builtin_vsprintf, "ic*cC*a", "nFP:1:")
+BUILTIN(__builtin_vfprintf, "iP*cC*a", "FP:1:")
+BUILTIN(__builtin_vprintf, "icC*a", "FP:0:")
 BUILTIN(__builtin_vsnprintf, "ic*zcC*a", "nFP:2:")
+BUILTIN(__builtin_vsprintf, "ic*cC*a", "nFP:1:")
 BUILTIN(__builtin_thread_pointer, "v*", "nc")
 BUILTIN(__builtin_launder, "v*v*", "nt")
 LANGBUILTIN(__builtin_is_constant_evaluated, "b", "n", CXX_LANG)
 
 // GCC exception builtins
 BUILTIN(__builtin_eh_return, "vzv*", "r") // FIXME: Takes intptr_t, not size_t!
 BUILTIN(__builtin_frob_return_addr, "v*v*", "n")
 BUILTIN(__builtin_dwarf_cfa, "v*", "n")

 LIBBUILTIN(va_start, "vA.",       "fn",    "stdarg.h", ALL_LANGUAGES)
 LIBBUILTIN(va_end, "vA",          "fn",    "stdarg.h", ALL_LANGUAGES)
 LIBBUILTIN(va_copy, "vAA",        "fn",    "stdarg.h", ALL_LANGUAGES)
 // C99 stdlib.h
 LIBBUILTIN(abort, "v",            "fr",    "stdlib.h", ALL_LANGUAGES)
 LIBBUILTIN(calloc, "v*zz",        "f",     "stdlib.h", ALL_LANGUAGES)
 LIBBUILTIN(exit, "vi",            "fr",    "stdlib.h", ALL_LANGUAGES)
 LIBBUILTIN(_Exit, "vi",           "fr",    "stdlib.h", ALL_LANGUAGES)
+LIBBUILTIN(free, "vv*",           "f",     "stdlib.h", ALL_LANGUAGES)
 LIBBUILTIN(malloc, "v*z",         "f",     "stdlib.h", ALL_LANGUAGES)
 LIBBUILTIN(realloc, "v*v*z",      "f",     "stdlib.h", ALL_LANGUAGES)
 LIBBUILTIN(strtod, "dcC*c**",     "f",     "stdlib.h", ALL_LANGUAGES)
 LIBBUILTIN(strtof, "fcC*c**",     "f",     "stdlib.h", ALL_LANGUAGES)
 LIBBUILTIN(strtold, "LdcC*c**",   "f",     "stdlib.h", ALL_LANGUAGES)
 LIBBUILTIN(strtol, "LicC*c**i",   "f",     "stdlib.h", ALL_LANGUAGES)
 LIBBUILTIN(strtoll, "LLicC*c**i", "f",     "stdlib.h", ALL_LANGUAGES)
 LIBBUILTIN(strtoul, "ULicC*c**i", "f",     "stdlib.h", ALL_LANGUAGES)

 LIBBUILTIN(strspn, "zcC*cC*",     "f",     "string.h", ALL_LANGUAGES)
 LIBBUILTIN(strstr, "c*cC*cC*",    "f",     "string.h", ALL_LANGUAGES)
 LIBBUILTIN(strtok, "c*c*cC*",     "f",     "string.h", ALL_LANGUAGES)
 LIBBUILTIN(memset, "v*v*iz",      "f",     "string.h", ALL_LANGUAGES)
 LIBBUILTIN(strerror, "c*i",       "f",     "string.h", ALL_LANGUAGES)
 LIBBUILTIN(strlen, "zcC*",        "f",     "string.h", ALL_LANGUAGES)
 // C99 stdio.h
 // FIXME: This list is incomplete.
-LIBBUILTIN(printf, "icC*.",       "fp:0:", "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(fopen, "P*cC*cC*",     "f",     "stdio.h", ALL_LANGUAGES)
 LIBBUILTIN(fprintf, "iP*cC*.",    "fp:1:", "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(fputc, "iiP*",         "f",     "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(fputs, "icC*P*",       "f",     "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(fread, "zv*zzP*",      "f",     "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(fscanf, "iP*RcC*R.",   "fs:1:", "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(fwrite, "zvC*zzP*",    "f",     "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(printf, "icC*.",       "fp:0:", "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(putc, "iiP*",          "f",     "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(putchar, "ii",         "f",     "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(puts, "icC*",          "f",     "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(scanf, "icC*R.",       "fs:0:", "stdio.h", ALL_LANGUAGES)
 LIBBUILTIN(snprintf, "ic*zcC*.",  "fp:2:", "stdio.h", ALL_LANGUAGES)
 LIBBUILTIN(sprintf, "ic*cC*.",    "fp:1:", "stdio.h", ALL_LANGUAGES)
-LIBBUILTIN(vprintf, "icC*a",      "fP:0:", "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(sscanf, "icC*RcC*R.",  "fs:1:", "stdio.h", ALL_LANGUAGES)
 LIBBUILTIN(vfprintf, "iP*cC*a",   "fP:1:", "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(vfscanf, "iP*RcC*Ra",  "fS:1:", "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(vprintf, "icC*a",      "fP:0:", "stdio.h", ALL_LANGUAGES)
+LIBBUILTIN(vscanf, "icC*Ra",      "fS:0:", "stdio.h", ALL_LANGUAGES)
 LIBBUILTIN(vsnprintf, "ic*zcC*a", "fP:2:", "stdio.h", ALL_LANGUAGES)
 LIBBUILTIN(vsprintf, "ic*cC*a",   "fP:1:", "stdio.h", ALL_LANGUAGES)
-LIBBUILTIN(scanf, "icC*R.",       "fs:0:", "stdio.h", ALL_LANGUAGES)
-LIBBUILTIN(fscanf, "iP*RcC*R.",   "fs:1:", "stdio.h", ALL_LANGUAGES)
-LIBBUILTIN(sscanf, "icC*RcC*R.",  "fs:1:", "stdio.h", ALL_LANGUAGES)
-LIBBUILTIN(vscanf, "icC*Ra",      "fS:0:", "stdio.h", ALL_LANGUAGES)
-LIBBUILTIN(vfscanf, "iP*RcC*Ra",  "fS:1:", "stdio.h", ALL_LANGUAGES)
 LIBBUILTIN(vsscanf, "icC*RcC*Ra", "fS:1:", "stdio.h", ALL_LANGUAGES)
-LIBBUILTIN(fopen, "P*cC*cC*",     "f",     "stdio.h", ALL_LANGUAGES)
-LIBBUILTIN(fread, "zv*zzP*",      "f",     "stdio.h", ALL_LANGUAGES)
-LIBBUILTIN(fwrite, "zvC*zzP*",    "f",     "stdio.h", ALL_LANGUAGES)
 
 // C99 ctype.h
 LIBBUILTIN(isalnum, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
 LIBBUILTIN(isalpha, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
 LIBBUILTIN(isblank, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
 LIBBUILTIN(iscntrl, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
 LIBBUILTIN(isdigit, "ii", "fnU", "ctype.h", ALL_LANGUAGES)
 LIBBUILTIN(isgraph, "ii", "fnU", "ctype.h", ALL_LANGUAGES)

clang/test/CodeGen/builtins.c

#define V(n,args) p(#n #args, (__builtin_##n args, 0))
   char s0[10], s1[] = "Hello";
   V(strcat, (s0, s1));
   V(strcmp, (s0, s1));
   V(strncat, (s0, s1, n));
   V(strchr, (s0, s1[0]));
   V(strrchr, (s0, s1[0]));
   V(strcpy, (s0, s1));
   V(strncpy, (s0, s1, n));
-  
+  V(puts, (s1));
   // Object size checking
   V(__memset_chk, (s0, 0, sizeof s0, n));
   V(__memcpy_chk, (s0, s1, sizeof s0, n));
   V(__memmove_chk, (s0, s1, sizeof s0, n));
   V(__mempcpy_chk, (s0, s1, sizeof s0, n));
   V(__strncpy_chk, (s0, s1, sizeof s0, n));
   V(__strcpy_chk, (s0, s1, n));
   s0[0] = 0;

clang/test/Preprocessor/has_builtin.c

+// RUN: %clang_cc1 -verify -E %s
+// expected-no-diagnostics
+
+// TODO: fill out this file
+// Please sort by https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html.
+
+// ISO C90
+#if !__has_builtin(abort)
+#warning "no builtin 'abort'"
+#endif
+#if !__has_builtin(__builtin_abort)
+#warning "no builtin '__builtin_abort'"
+#endif
+#if !__has_builtin(abs)
+#warning "no builtin 'abs'"
+#endif
+#if !__has_builtin(__builtin_abs)
+#warning "no builtin '__builtin_abs'"
+#endif
+#if !__has_builtin(acos)
+#warning "no builtin 'acos'"
+#endif
+#if !__has_builtin(__builtin_acos)
+#warning "no builtin '__builtin_acos'"
+#endif
+#if !__has_builtin(asin)
+#warning "no builtin 'asin'"
+#endif
+#if !__has_builtin(__builtin_asin)
+#warning "no builtin '__builtin_asin'"
+#endif
+#if !__has_builtin(atan2)
+#warning "no builtin 'atan2'"
+#endif
+#if !__has_builtin(__builtin_atan2)
+#warning "no builtin '__builtin_atan2'"
+#endif
+#if !__has_builtin(atan)
+#warning "no builtin 'atan'"
+#endif
+#if !__has_builtin(__builtin_atan)
+#warning "no builtin '__builtin_atan'"
+#endif
+#if !__has_builtin(calloc)
+#warning "no builtin 'calloc'"
+#endif
+#if !__has_builtin(__builtin_calloc)
+#warning "no builtin '__builtin_calloc'"
+#endif
+#if !__has_builtin(ceil)
+#warning "no builtin 'ceil'"
+#endif
+#if !__has_builtin(__builtin_ceil)
+#warning "no builtin '__builtin_ceil'"
+#endif
+#if !__has_builtin(cosh)
+#warning "no builtin 'cosh'"
+#endif
+#if !__has_builtin(__builtin_cosh)
+#warning "no builtin '__builtin_cosh'"
+#endif
+#if !__has_builtin(cos)
+#warning "no builtin 'cos'"
+#endif
+#if !__has_builtin(__builtin_cos)
+#warning "no builtin '__builtin_cos'"
+#endif
+#if !__has_builtin(exit)
+#warning "no builtin 'exit'"
+#endif
+#if !__has_builtin(__builtin_exit)
+#warning "no builtin '__builtin_exit'"
+#endif
+#if !__has_builtin(exp)
+#warning "no builtin 'exp'"
+#endif
+#if !__has_builtin(__builtin_exp)
+#warning "no builtin '__builtin_exp'"
+#endif
+#if !__has_builtin(fabs)
+#warning "no builtin 'fabs'"
+#endif
+#if !__has_builtin(__builtin_fabs)
+#warning "no builtin '__builtin_fabs'"
+#endif
+#if !__has_builtin(floor)
+#warning "no builtin 'floor'"
+#endif
+#if !__has_builtin(__builtin_floor)
+#warning "no builtin '__builtin_floor'"
+#endif
+#if !__has_builtin(fmod)
+#warning "no builtin 'fmod'"
+#endif
+#if !__has_builtin(__builtin_fmod)
+#warning "no builtin '__builtin_fmod'"
+#endif
+#if !__has_builtin(fprintf)
+#warning "no builtin 'fprintf'"
+#endif
+#if !__has_builtin(__builtin_fprintf)
+#warning "no builtin '__builtin_fprintf'"
+#endif
+#if !__has_builtin(fputc)
+#warning "no builtin 'fputc'"
+#endif
+#if !__has_builtin(__builtin_fputc)
+#warning "no builtin '__builtin_fputs'"
+#endif
+#if !__has_builtin(fputs)
+#warning "no builtin 'fputs'"
+#endif
+#if !__has_builtin(__builtin_fputs)
+#warning "no builtin '__builtin_fputs'"
+#endif
+#if !__has_builtin(free)
+#warning "no builtin 'free'"
+#endif
+#if !__has_builtin(__builtin_free)
+#warning "no builtin '__builtin_free'"
+#endif
+#if !__has_builtin(frexp)
+#warning "no builtin 'frexp'"
+#endif
+#if !__has_builtin(__builtin_frexp)
+#warning "no builtin '__builtin_frexp'"
+#endif
+#if !__has_builtin(fscanf)
+#warning "no builtin 'fscanf'"
+#endif
+#if !__has_builtin(__builtin_fscanf)
+#warning "no builtin '__builtin_fscanf'"
+#endif
+#if !__has_builtin(isalnum)
+#warning "no builtin 'isalnum'"
+#endif
+#if !__has_builtin(__builtin_isalnum)
+#warning "no builtin '__builtin_isalnum'"
+#endif
+#if !__has_builtin(isalpha)
+#warning "no builtin 'isalpha'"
+#endif
+#if !__has_builtin(__builtin_isalpha)
+#warning "no builtin '__builtin_isalpha'"
+#endif
+#if !__has_builtin(iscntrl)
+#warning "no builtin 'iscntrl'"
+#endif
+#if !__has_builtin(__builtin_iscntrl)
+#warning "no builtin '__builtin_iscntrl'"
+#endif
+#if !__has_builtin(isdigit)
+#warning "no builtin 'isdigit'"
+#endif
+#if !__has_builtin(__builtin_isdigit)
+#warning "no builtin '__builtin_isdigit'"
+#endif
+#if !__has_builtin(isgraph)
+#warning "no builtin 'isgraph'"
+#endif
+#if !__has_builtin(__builtin_isgraph)
+#warning "no builtin '__builtin_isgraph'"
+#endif
+#if !__has_builtin(islower)
+#warning "no builtin 'islower'"
+#endif
+#if !__has_builtin(__builtin_islower)
+#warning "no builtin '__builtin_islower'"
+#endif
+#if !__has_builtin(isprint)
+#warning "no builtin 'isprint'"
+#endif
+#if !__has_builtin(__builtin_isprint)
+#warning "no builtin '__builtin_isprint'"
+#endif
+#if !__has_builtin(ispunct)
+#warning "no builtin 'ispunct'"
+#endif
+#if !__has_builtin(__builtin_ispunct)
+#warning "no builtin '__builtin_ispunct'"
+#endif
+#if !__has_builtin(isspace)
+#warning "no builtin 'isspace'"
+#endif
+#if !__has_builtin(__builtin_isspace)
+#warning "no builtin '__builtin_isspace'"
+#endif
+#if !__has_builtin(isupper)
+#warning "no builtin 'isupper'"
+#endif
+#if !__has_builtin(__builtin_isupper)
+#warning "no builtin '__builtin_isupper'"
+#endif
+#if !__has_builtin(isxdigit)
+#warning "no builtin 'isxdigit'"
+#endif
+#if !__has_builtin(__builtin_isxdigit)
+#warning "no builtin '__builtin_isxdigit'"
+#endif
+#if !__has_builtin(tolower)
+#warning "no builtin 'tolower'"
+#endif
+#if !__has_builtin(__builtin_tolower)
+#warning "no builtin '__builtin_tolower'"
+#endif
+#if !__has_builtin(toupper)
+#warning "no builtin 'toupper'"
+#endif
+#if !__has_builtin(__builtin_toupper)
+#warning "no builtin '__builtin_toupper'"
+#endif
+#if !__has_builtin(labs)
+#warning "no builtin 'labs'"
+#endif
+#if !__has_builtin(__builtin_labs)
+#warning "no builtin '__builtin_labs'"
+#endif
+#if !__has_builtin(ldexp)
+#warning "no builtin 'ldexp'"
+#endif
+#if !__has_builtin(__builtin_ldexp)
+#warning "no builtin '__builtin_ldexp'"
+#endif
+#if !__has_builtin(log10)
+#warning "no builtin 'log10'"
+#endif
+#if !__has_builtin(__builtin_log10)
+#warning "no builtin '__builtin_log10'"
+#endif
+#if !__has_builtin(log)
+#warning "no builtin 'log'"
+#endif
+#if !__has_builtin(__builtin_log)
+#warning "no builtin '__builtin_log'"
+#endif
+#if !__has_builtin(malloc)
+#warning "no builtin 'malloc'"
+#endif
+#if !__has_builtin(__builtin_malloc)
+#warning "no builtin '__builtin_malloc'"
+#endif
+#if !__has_builtin(memchr)
+#warning "no builtin 'memchr'"
+#endif
+#if !__has_builtin(__builtin_memchr)
+#warning "no builtin '__builtin_memchr'"
+#endif
+#if !__has_builtin(memcmp)
+#warning "no builtin 'memcmp'"
+#endif
+#if !__has_builtin(__builtin_memcmp)
+#warning "no builtin '__builtin_memcmp'"
+#endif
+#if !__has_builtin(memcpy)
+#warning "no builtin 'memcpy'"
+#endif
+#if !__has_builtin(__builtin_memcpy)
+#warning "no builtin '__builtin_memcpy'"
+#endif
+#if !__has_builtin(memset)
+#warning "no builtin 'memset'"
+#endif
+#if !__has_builtin(__builtin_memset)
+#warning "no builtin '__builtin_memset'"
+#endif
+#if !__has_builtin(modf)
+#warning "no builtin 'modf'"
+#endif
+#if !__has_builtin(__builtin_modf)
+#warning "no builtin '__builtin_modf'"
+#endif
+#if !__has_builtin(pow)
+#warning "no builtin 'pow'"
+#endif
+#if !__has_builtin(__builtin_pow)
+#warning "no builtin '__builtin_pow'"
+#endif
+#if !__has_builtin(printf)
+#warning "no builtin 'printf'"
+#endif
+#if !__has_builtin(__builtin_printf)
+#warning "no builtin '__builtin_printf'"
+#endif
+#if !__has_builtin(putchar)
+#warning "no builtin 'putchar'"
+#endif
+#if !__has_builtin(__builtin_putchar)
+#warning "no builtin '__builtin_putchar'"
+#endif
+#if !__has_builtin(putc)
+#warning "no builtin 'putc'"
+#endif
+#if !__has_builtin(__builtin_putc)
+#warning "no builtin '__builtin_putc'"
+#endif
+#if !__has_builtin(puts)
+#warning "no builtin 'puts'"
+#endif
+#if !__has_builtin(__builtin_puts)
+#warning "no builtin '__builtin_puts'"
+#endif
+#if !__has_builtin(realloc)
+#warning "no builtin 'realloc'"
+#endif
+#if !__has_builtin(__builtin_realloc)
+#warning "no builtin '__builtin_realloc'"
+#endif
+#if !__has_builtin(scanf)
+#warning "no builtin 'scanf'"
+#endif
+#if !__has_builtin(__builtin_scanf)
+#warning "no builtin '__builtin_scanf'"
+#endif
+#if !__has_builtin(sinh)
+#warning "no builtin 'sinh'"
+#endif
+#if !__has_builtin(__builtin_sinh)
+#warning "no builtin '__builtin_sinh'"
+#endif
+#if !__has_builtin(sin)
+#warning "no builtin 'sin'"
+#endif
+#if !__has_builtin(__builtin_sin)
+#warning "no builtin '__builtin_sin'"
+#endif
+#if !__has_builtin(snprintf)
+#warning "no builtin 'snprintf'"
+#endif
+#if !__has_builtin(__builtin_snprintf)
+#warning "no builtin '__builtin_snprintf'"
+#endif
+#if !__has_builtin(sprintf)
+#warning "no builtin 'sprintf'"
+#endif
+#if !__has_builtin(__builtin_sprintf)
+#warning "no builtin '__builtin_sprintf'"
+#endif
+#if !__has_builtin(sqrt)
+#warning "no builtin 'sqrt'"
+#endif
+#if !__has_builtin(__builtin_sqrt)
+#warning "no builtin '__builtin_sqrt'"
+#endif
+#if !__has_builtin(sscanf)
+#warning "no builtin 'sscanf'"
+#endif
+#if !__has_builtin(__builtin_sscanf)
+#warning "no builtin '__builtin_sscanf'"
+#endif
+#if !__has_builtin(strcat)
+#warning "no builtin 'strcat'"
+#endif
+#if !__has_builtin(__builtin_strcat)
+#warning "no builtin '__builtin_strcat'"
+#endif
+#if !__has_builtin(strchr)
+#warning "no builtin 'strchr'"
+#endif
+#if !__has_builtin(__builtin_strchr)
+#warning "no builtin '__builtin_strchr'"
+#endif
+#if !__has_builtin(strcmp)
+#warning "no builtin 'strcmp'"
+#endif
+#if !__has_builtin(__builtin_strcmp)
+#warning "no builtin '__builtin_strcmp'"
+#endif
+#if !__has_builtin(strcpy)
+#warning "no builtin 'strcpy'"
+#endif
+#if !__has_builtin(__builtin_strcpy)
+#warning "no builtin '__builtin_strcpy'"
+#endif
+#if !__has_builtin(strcspn)
+#warning "no builtin 'strcspn'"
+#endif
+#if !__has_builtin(__builtin_strcspn)
+#warning "no builtin '__builtin_strcspn'"
+#endif
+#if !__has_builtin(strlen)
+#warning "no builtin 'strlen'"
+#endif
+#if !__has_builtin(__builtin_strlen)
+#warning "no builtin '__builtin_strlen'"
+#endif
+#if !__has_builtin(strncat)
+#warning "no builtin 'strncat'"
+#endif
+#if !__has_builtin(__builtin_strncat)
+#warning "no builtin '__builtin_strncat'"
+#endif
+#if !__has_builtin(strncmp)
+#warning "no builtin 'strncmp'"
+#endif
+#if !__has_builtin(__builtin_strncmp)
+#warning "no builtin '__builtin_strncmp'"
+#endif
+#if !__has_builtin(strncpy)
+#warning "no builtin 'strncpy'"
+#endif
+#if !__has_builtin(__builtin_strncpy)
+#warning "no builtin '__builtin_strncpy'"
+#endif
+#if !__has_builtin(strpbrk)
+#warning "no builtin 'strpbrk'"
+#endif
+#if !__has_builtin(__builtin_strpbrk)
+#warning "no builtin '__builtin_strpbrk'"
+#endif
+#if !__has_builtin(strrchr)
+#warning "no builtin 'strrchr'"
+#endif
+#if !__has_builtin(__builtin_strrchr)
+#warning "no builtin '__builtin_strrchr'"
+#endif
+#if !__has_builtin(strspn)
+#warning "no builtin 'strspn'"
+#endif
+#if !__has_builtin(__builtin_strspn)
+#warning "no builtin '__builtin_strspn'"
+#endif
+#if !__has_builtin(strstr)
+#warning "no builtin 'strstr'"
+#endif
+#if !__has_builtin(__builtin_strstr)
+#warning "no builtin '__builtin_strstr'"
+#endif
+#if !__has_builtin(tanh)
+#warning "no builtin 'tanh'"
+#endif
+#if !__has_builtin(__builtin_tanh)
+#warning "no builtin '__builtin_tanh'"
+#endif
+#if !__has_builtin(tan)
+#warning "no builtin 'tan'"
+#endif
+#if !__has_builtin(__builtin_tan)
+#warning "no builtin '__builtin_tan'"
+#endif
+#if !__has_builtin(vfprintf)
+#warning "no builtin 'vfprintf'"
+#endif
+#if !__has_builtin(__builtin_vfprintf)
+#warning "no builtin '__builtin_vfprintf'"
+#endif
+#if !__has_builtin(vprintf)
+#warning "no builtin 'vprintf'"
+#endif
+#if !__has_builtin(__builtin_vprintf)
+#warning "no builtin '__builtin_vprintf'"
+#endif
+#if !__has_builtin(vsprintf)
+#warning "no builtin 'vsprintf'"
+#endif
+#if !__has_builtin(__builtin_vsprintf)
+#warning "no builtin '__builtin_vsprintf'"
+#endif