[llvm] [Analysis] Move TargetLibraryInfo data to TableGen (PR #165009)

[Kai Nacke via llvm-commits]

https://github.com/redstar created https://github.com/llvm/llvm-project/pull/165009

The collection of library function names in TargetLibraryInfo faces similar challenges as RuntimeLibCalls in the IR component. The number of function names is large, there are numerous customizations based on the triple (including alternate names), and there is a lot of replicated data in the signature table.

The ultimate goal would be to capture all lbrary function related information in a .td file. This PR brings the current .def file to TableGen, almost as a 1:1 replacement. However, there are some improvements which are not possible in the current implementation:

- the function names are now stored as a long string together with an offset table.
- the table of signatures is now deduplicated, using an offset table for access.

The size of the object file decreases about 34kB with these changes. The hash table of all function names is still constructed dynamically. A static table like for RuntimeLibCalls is the next logical step.

The main motivation for this change is that I have to add a large number of custom names for z/OS (like in RuntimeLibCalls.td), and the current infrastructur does not support this very well.

>From b20c203ec370702e7104e2695aa753efad4e77bb Mon Sep 17 00:00:00 2001
From: Kai Nacke <kai.peter.nacke at ibm.com>
Date: Wed, 22 Oct 2025 16:34:40 -0400
Subject: [PATCH] [Analysis] Move TargetLibraryInfo data to TableGen

The collection of library function names in TargetLibraryInfo faces
similar challenges as RuntimeLibCalls in the IR component. The number
of function names is large, there are numerous customizations based
on the triple (including alternate names), and there is a lot of
replicated data in the signature table.

The ultimate goal would be to capture all lbrary function related
information in a .td file. This PR brings the current .def file to
TableGen, almost as a 1:1 replacement. However, there are some
improvements which are not possible in the current implementation:

- the function names are now stored as a long string together with
  an offset table.
- the table of signatures is now deduplicated, using an offset table
  for access.

The size of the object file decreases about 34kB with these changes.
The hash table of all function names is still constructed dynamically.
A static table like for RuntimeLibCalls is the next logical step.

The main motivation for this change is that I have to add a large
number of custom names for z/OS (like in RuntimeLibCalls.td), and
the current infrastructur does not support this very well.
---
 llvm/include/llvm/Analysis/CMakeLists.txt     |    3 +
 .../llvm/Analysis/TargetLibraryInfo.def       | 2698 -----------------
 .../include/llvm/Analysis/TargetLibraryInfo.h |   21 +-
 .../llvm/Analysis/TargetLibraryInfo.td        | 1599 ++++++++++
 .../llvm/Analysis/TargetLibraryInfoImpl.td    |   42 +
 llvm/include/llvm/CMakeLists.txt              |    1 +
 .../llvm/TableGen/StringToOffsetTable.h       |    7 +-
 llvm/lib/Analysis/BranchProbabilityInfo.cpp   |    2 +-
 llvm/lib/Analysis/CMakeLists.txt              |    1 +
 llvm/lib/Analysis/TargetLibraryInfo.cpp       |   70 +-
 llvm/lib/LTO/UpdateCompilerUsed.cpp           |    4 +-
 llvm/lib/TableGen/StringToOffsetTable.cpp     |    3 +-
 .../NumericalStabilitySanitizer.cpp           |    2 +-
 .../lib/Transforms/Utils/SimplifyLibCalls.cpp |    2 +-
 llvm/test/TableGen/TargetLibraryInfo.td       |  101 +
 .../llvm-tli-checker/llvm-tli-checker.cpp     |   13 +-
 .../Analysis/TargetLibraryInfoTest.cpp        |    4 +-
 llvm/utils/TableGen/Basic/CMakeLists.txt      |    1 +
 .../Basic/TargetLibraryInfoEmitter.cpp        |  166 +
 19 files changed, 1963 insertions(+), 2777 deletions(-)
 create mode 100644 llvm/include/llvm/Analysis/CMakeLists.txt
 delete mode 100644 llvm/include/llvm/Analysis/TargetLibraryInfo.def
 create mode 100644 llvm/include/llvm/Analysis/TargetLibraryInfo.td
 create mode 100644 llvm/include/llvm/Analysis/TargetLibraryInfoImpl.td
 create mode 100644 llvm/test/TableGen/TargetLibraryInfo.td
 create mode 100644 llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp

diff --git a/llvm/include/llvm/Analysis/CMakeLists.txt b/llvm/include/llvm/Analysis/CMakeLists.txt
new file mode 100644
index 0000000000000..036f7ff00ce86
--- /dev/null
+++ b/llvm/include/llvm/Analysis/CMakeLists.txt
@@ -0,0 +1,3 @@
+set(LLVM_TARGET_DEFINITIONS TargetLibraryInfo.td)
+tablegen(LLVM TargetLibraryInfo.inc -gen-target-library-info)
+add_public_tablegen_target(analysis_gen)
diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.def b/llvm/include/llvm/Analysis/TargetLibraryInfo.def
deleted file mode 100644
index 014988299d37f..0000000000000
--- a/llvm/include/llvm/Analysis/TargetLibraryInfo.def
+++ /dev/null
@@ -1,2698 +0,0 @@
-//===-- TargetLibraryInfo.def - Library information -------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// This .def file will either fill in the enum definition or fill in the
-// string representation array definition for TargetLibraryInfo.
-// Which is defined depends on whether TLI_DEFINE_ENUM is defined or
-// TLI_DEFINE_STRING is defined. Only one should be defined at a time.
-
-// NOTE: The nofree attribute is added to Libfuncs which are not
-// listed as free or realloc functions in MemoryBuiltins.cpp
-//
-// When adding a function which frees memory include the LibFunc
-// in lib/Analysis/MemoryBuiltins.cpp "isLibFreeFunction".
-//
-// When adding a LibFunc which reallocates memory include the LibFunc
-// in lib/Analysis/MemoryBuiltins.cpp "AllocationFnData[]".
-
-#if (defined(TLI_DEFINE_ENUM) +                 \
-     defined(TLI_DEFINE_STRING) +               \
-     defined(TLI_DEFINE_SIG) != 1)
-#error "Must define exactly one of TLI_DEFINE_ENUM, TLI_DEFINE_STRING, or TLI_DEFINE_SIG for TLI .def."
-#else
-// Exactly one of TLI_DEFINE_ENUM/STRING/SIG is defined.
-
-#if defined(TLI_DEFINE_ENUM)
-#define TLI_DEFINE_ENUM_INTERNAL(enum_variant) LibFunc_##enum_variant,
-#define TLI_DEFINE_STRING_INTERNAL(string_repr)
-#define TLI_DEFINE_SIG_INTERNAL(...)
-#elif defined(TLI_DEFINE_STRING)
-#define TLI_DEFINE_ENUM_INTERNAL(enum_variant)
-#define TLI_DEFINE_STRING_INTERNAL(string_repr) string_repr,
-#define TLI_DEFINE_SIG_INTERNAL(...)
-#else
-#define TLI_DEFINE_ENUM_INTERNAL(enum_variant)
-#define TLI_DEFINE_STRING_INTERNAL(string_repr)
-#define TLI_DEFINE_SIG_INTERNAL(...) { __VA_ARGS__ },
-#endif
-
-/// void *operator new(unsigned int);
-TLI_DEFINE_ENUM_INTERNAL(msvc_new_int)
-TLI_DEFINE_STRING_INTERNAL("??2 at YAPAXI@Z")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Int)
-
-/// void *operator new(unsigned int, const std::nothrow_t&);
-TLI_DEFINE_ENUM_INTERNAL(msvc_new_int_nothrow)
-TLI_DEFINE_STRING_INTERNAL("??2 at YAPAXIABUnothrow_t@std@@@Z")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr)
-
-/// void *operator new(unsigned long long);
-TLI_DEFINE_ENUM_INTERNAL(msvc_new_longlong)
-TLI_DEFINE_STRING_INTERNAL("??2 at YAPEAX_K@Z")
-TLI_DEFINE_SIG_INTERNAL(Ptr, LLong)
-
-/// void *operator new(unsigned long long, const std::nothrow_t&);
-TLI_DEFINE_ENUM_INTERNAL(msvc_new_longlong_nothrow)
-TLI_DEFINE_STRING_INTERNAL("??2 at YAPEAX_KAEBUnothrow_t@std@@@Z")
-TLI_DEFINE_SIG_INTERNAL(Ptr, LLong, Ptr)
-
-/// void operator delete(void*);
-TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr32)
-TLI_DEFINE_STRING_INTERNAL("??3 at YAXPAX@Z")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// void operator delete(void*, const std::nothrow_t&);
-TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr32_nothrow)
-TLI_DEFINE_STRING_INTERNAL("??3 at YAXPAXABUnothrow_t@std@@@Z")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr)
-
-/// void operator delete(void*, unsigned int);
-TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr32_int)
-TLI_DEFINE_STRING_INTERNAL("??3 at YAXPAXI@Z")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int)
-
-/// void operator delete(void*);
-TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr64)
-TLI_DEFINE_STRING_INTERNAL("??3 at YAXPEAX@Z")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// void operator delete(void*, const std::nothrow_t&);
-TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr64_nothrow)
-TLI_DEFINE_STRING_INTERNAL("??3 at YAXPEAXAEBUnothrow_t@std@@@Z")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr)
-
-/// void operator delete(void*, unsigned long long);
-TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr64_longlong)
-TLI_DEFINE_STRING_INTERNAL("??3 at YAXPEAX_K@Z")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, LLong)
-
-/// void *operator new[](unsigned int);
-TLI_DEFINE_ENUM_INTERNAL(msvc_new_array_int)
-TLI_DEFINE_STRING_INTERNAL("??_U at YAPAXI@Z")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Int)
-
-/// void *operator new[](unsigned int, const std::nothrow_t&);
-TLI_DEFINE_ENUM_INTERNAL(msvc_new_array_int_nothrow)
-TLI_DEFINE_STRING_INTERNAL("??_U at YAPAXIABUnothrow_t@std@@@Z")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr)
-
-/// void *operator new[](unsigned long long);
-TLI_DEFINE_ENUM_INTERNAL(msvc_new_array_longlong)
-TLI_DEFINE_STRING_INTERNAL("??_U at YAPEAX_K@Z")
-TLI_DEFINE_SIG_INTERNAL(Ptr, LLong)
-
-/// void *operator new[](unsigned long long, const std::nothrow_t&);
-TLI_DEFINE_ENUM_INTERNAL(msvc_new_array_longlong_nothrow)
-TLI_DEFINE_STRING_INTERNAL("??_U at YAPEAX_KAEBUnothrow_t@std@@@Z")
-TLI_DEFINE_SIG_INTERNAL(Ptr, LLong, Ptr)
-
-/// void operator delete[](void*);
-TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr32)
-TLI_DEFINE_STRING_INTERNAL("??_V at YAXPAX@Z")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// void operator delete[](void*, const std::nothrow_t&);
-TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr32_nothrow)
-TLI_DEFINE_STRING_INTERNAL("??_V at YAXPAXABUnothrow_t@std@@@Z")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr)
-
-/// void operator delete[](void*, unsigned int);
-TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr32_int)
-TLI_DEFINE_STRING_INTERNAL("??_V at YAXPAXI@Z")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int)
-
-/// void operator delete[](void*);
-TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr64)
-TLI_DEFINE_STRING_INTERNAL("??_V at YAXPEAX@Z")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// void operator delete[](void*, const std::nothrow_t&);
-TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr64_nothrow)
-TLI_DEFINE_STRING_INTERNAL("??_V at YAXPEAXAEBUnothrow_t@std@@@Z")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr)
-
-/// void operator delete[](void*, unsigned long long);
-TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr64_longlong)
-TLI_DEFINE_STRING_INTERNAL("??_V at YAXPEAX_K@Z")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, LLong)
-
-/// int _IO_getc(_IO_FILE * __fp);
-TLI_DEFINE_ENUM_INTERNAL(under_IO_getc)
-TLI_DEFINE_STRING_INTERNAL("_IO_getc")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// int _IO_putc(int __c, _IO_FILE * __fp);
-TLI_DEFINE_ENUM_INTERNAL(under_IO_putc)
-TLI_DEFINE_STRING_INTERNAL("_IO_putc")
-TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
-
-/// void operator delete[](void*);
-TLI_DEFINE_ENUM_INTERNAL(ZdaPv)
-TLI_DEFINE_STRING_INTERNAL("_ZdaPv")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// void operator delete[](void*, const std::nothrow_t&);
-TLI_DEFINE_ENUM_INTERNAL(ZdaPvRKSt9nothrow_t)
-TLI_DEFINE_STRING_INTERNAL("_ZdaPvRKSt9nothrow_t")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr)
-
-/// void operator delete[](void*, std::align_val_t);
-TLI_DEFINE_ENUM_INTERNAL(ZdaPvSt11align_val_t)
-TLI_DEFINE_STRING_INTERNAL("_ZdaPvSt11align_val_t")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, IntPlus)
-
-/// void operator delete[](void*, std::align_val_t, const std::nothrow_t&)
-TLI_DEFINE_ENUM_INTERNAL(ZdaPvSt11align_val_tRKSt9nothrow_t)
-TLI_DEFINE_STRING_INTERNAL("_ZdaPvSt11align_val_tRKSt9nothrow_t")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, IntPlus, Ptr)
-
-/// void operator delete[](void*, unsigned int);
-TLI_DEFINE_ENUM_INTERNAL(ZdaPvj)
-TLI_DEFINE_STRING_INTERNAL("_ZdaPvj")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int)
-
-/// void operator delete[](void*, unsigned int, std::align_val_t);
-TLI_DEFINE_ENUM_INTERNAL(ZdaPvjSt11align_val_t)
-TLI_DEFINE_STRING_INTERNAL("_ZdaPvjSt11align_val_t")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int, Int)
-
-/// void operator delete[](void*, unsigned long);
-TLI_DEFINE_ENUM_INTERNAL(ZdaPvm)
-TLI_DEFINE_STRING_INTERNAL("_ZdaPvm")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Long)
-
-/// void operator delete[](void*, unsigned long, std::align_val_t);
-TLI_DEFINE_ENUM_INTERNAL(ZdaPvmSt11align_val_t)
-TLI_DEFINE_STRING_INTERNAL("_ZdaPvmSt11align_val_t")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Long, Long)
-
-/// void operator delete(void*);
-TLI_DEFINE_ENUM_INTERNAL(ZdlPv)
-TLI_DEFINE_STRING_INTERNAL("_ZdlPv")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// void operator delete(void*, const std::nothrow_t&);
-TLI_DEFINE_ENUM_INTERNAL(ZdlPvRKSt9nothrow_t)
-TLI_DEFINE_STRING_INTERNAL("_ZdlPvRKSt9nothrow_t")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr)
-
-/// void operator delete(void*, std::align_val_t)
-TLI_DEFINE_ENUM_INTERNAL(ZdlPvSt11align_val_t)
-TLI_DEFINE_STRING_INTERNAL("_ZdlPvSt11align_val_t")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, IntPlus)
-
-/// void operator delete(void*, std::align_val_t, const std::nothrow_t&)
-TLI_DEFINE_ENUM_INTERNAL(ZdlPvSt11align_val_tRKSt9nothrow_t)
-TLI_DEFINE_STRING_INTERNAL("_ZdlPvSt11align_val_tRKSt9nothrow_t")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, IntPlus, Ptr)
-
-/// void operator delete(void*, unsigned int);
-TLI_DEFINE_ENUM_INTERNAL(ZdlPvj)
-TLI_DEFINE_STRING_INTERNAL("_ZdlPvj")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int)
-
-/// void operator delete(void*, unsigned int, std::align_val_t)
-TLI_DEFINE_ENUM_INTERNAL(ZdlPvjSt11align_val_t)
-TLI_DEFINE_STRING_INTERNAL("_ZdlPvjSt11align_val_t")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int, Int)
-
-/// void operator delete(void*, unsigned long);
-TLI_DEFINE_ENUM_INTERNAL(ZdlPvm)
-TLI_DEFINE_STRING_INTERNAL("_ZdlPvm")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Long)
-
-/// void operator delete(void*, unsigned long, std::align_val_t)
-TLI_DEFINE_ENUM_INTERNAL(ZdlPvmSt11align_val_t)
-TLI_DEFINE_STRING_INTERNAL("_ZdlPvmSt11align_val_t")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Long, Long)
-
-/// void *operator new[](unsigned int);
-TLI_DEFINE_ENUM_INTERNAL(Znaj)
-TLI_DEFINE_STRING_INTERNAL("_Znaj")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Int)
-
-/// void *operator new[](unsigned int, const std::nothrow_t&);
-TLI_DEFINE_ENUM_INTERNAL(ZnajRKSt9nothrow_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnajRKSt9nothrow_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr)
-
-/// void *operator new[](unsigned int, std::align_val_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnajSt11align_val_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnajSt11align_val_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Int)
-
-/// void *operator new[](unsigned int, std::align_val_t, const std::nothrow_t&)
-TLI_DEFINE_ENUM_INTERNAL(ZnajSt11align_val_tRKSt9nothrow_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnajSt11align_val_tRKSt9nothrow_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Int, Ptr)
-
-/// void *operator new[](unsigned long);
-TLI_DEFINE_ENUM_INTERNAL(Znam)
-TLI_DEFINE_STRING_INTERNAL("_Znam")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long)
-
-/// void *operator new[](unsigned long, __hot_cold_t)
-/// Currently this and other operator new interfaces that take a __hot_cold_t
-/// hint are supported by the open source version of tcmalloc, see:
-/// https://github.com/google/tcmalloc/blob/master/tcmalloc/new_extension.h
-/// and for the definition of the __hot_cold_t parameter see:
-/// https://github.com/google/tcmalloc/blob/master/tcmalloc/malloc_extension.h
-TLI_DEFINE_ENUM_INTERNAL(Znam12__hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_Znam12__hot_cold_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Bool)
-
-/// void *operator new[](unsigned long, const std::nothrow_t&);
-TLI_DEFINE_ENUM_INTERNAL(ZnamRKSt9nothrow_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnamRKSt9nothrow_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Ptr)
-
-/// void *operator new[](unsigned long, const std::nothrow_t&, __hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnamRKSt9nothrow_t12__hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnamRKSt9nothrow_t12__hot_cold_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Ptr, Bool)
-
-/// void *operator new[](unsigned long, std::align_val_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long)
-
-/// void *operator new[](unsigned long, std::align_val_t, __hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_t12__hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_t12__hot_cold_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Bool)
-
-/// void *operator new[](unsigned long, std::align_val_t, const std::nothrow_t&)
-TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_tRKSt9nothrow_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_tRKSt9nothrow_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Ptr)
-
-/// void *operator new[](unsigned long, std::align_val_t, const std::nothrow_t&, __hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Ptr, Bool)
-
-/// void *operator new(unsigned int);
-TLI_DEFINE_ENUM_INTERNAL(Znwj)
-TLI_DEFINE_STRING_INTERNAL("_Znwj")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Int)
-
-/// void *operator new(unsigned int, const std::nothrow_t&);
-TLI_DEFINE_ENUM_INTERNAL(ZnwjRKSt9nothrow_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnwjRKSt9nothrow_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr)
-
-/// void *operator new(unsigned int, std::align_val_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnwjSt11align_val_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnwjSt11align_val_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Int)
-
-/// void *operator new(unsigned int, std::align_val_t, const std::nothrow_t&)
-TLI_DEFINE_ENUM_INTERNAL(ZnwjSt11align_val_tRKSt9nothrow_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnwjSt11align_val_tRKSt9nothrow_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Int, Ptr)
-
-/// void *operator new(unsigned long);
-TLI_DEFINE_ENUM_INTERNAL(Znwm)
-TLI_DEFINE_STRING_INTERNAL("_Znwm")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long)
-
-/// void *operator new(unsigned long, __hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(Znwm12__hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_Znwm12__hot_cold_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Bool)
-
-/// void *operator new(unsigned long, const std::nothrow_t&);
-TLI_DEFINE_ENUM_INTERNAL(ZnwmRKSt9nothrow_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnwmRKSt9nothrow_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Ptr)
-
-/// void *operator new(unsigned long, const std::nothrow_t&, __hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnwmRKSt9nothrow_t12__hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnwmRKSt9nothrow_t12__hot_cold_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Ptr, Bool)
-
-/// void *operator new(unsigned long, std::align_val_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long)
-
-/// void *operator new(unsigned long, std::align_val_t, __hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_t12__hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_t12__hot_cold_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Bool)
-
-/// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&)
-TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_tRKSt9nothrow_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_tRKSt9nothrow_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Ptr)
-
-/// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&, __hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Ptr, Bool)
-
-/// The following are variants of operator new which return the actual size
-/// reserved by the allocator proposed in P0901R5 (Size feedback in operator new).
-/// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0901r5.html
-/// They are implemented by tcmalloc, see source at
-/// https://github.com/google/tcmalloc/blob/master/tcmalloc/malloc_extension.h
-
-/// __sized_ptr_t __size_returning_new(size_t size)
-TLI_DEFINE_ENUM_INTERNAL(size_returning_new)
-TLI_DEFINE_STRING_INTERNAL("__size_returning_new")
-TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
-
-/// __sized_ptr_t __size_returning_new_hot_cold(size_t, __hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(size_returning_new_hot_cold)
-TLI_DEFINE_STRING_INTERNAL("__size_returning_new_hot_cold")
-TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
-
-/// __sized_ptr_t __size_returning_new_aligned(size_t, std::align_val_t)
-TLI_DEFINE_ENUM_INTERNAL(size_returning_new_aligned)
-TLI_DEFINE_STRING_INTERNAL("__size_returning_new_aligned")
-TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
-
-/// __sized_ptr_t __size_returning_new_aligned(size_t, std::align_val_t, __hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(size_returning_new_aligned_hot_cold)
-TLI_DEFINE_STRING_INTERNAL("__size_returning_new_aligned_hot_cold")
-TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
-
-/// double __acos_finite(double x);
-TLI_DEFINE_ENUM_INTERNAL(acos_finite)
-TLI_DEFINE_STRING_INTERNAL("__acos_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float __acosf_finite(float x);
-TLI_DEFINE_ENUM_INTERNAL(acosf_finite)
-TLI_DEFINE_STRING_INTERNAL("__acosf_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// double __acosh_finite(double x);
-TLI_DEFINE_ENUM_INTERNAL(acosh_finite)
-TLI_DEFINE_STRING_INTERNAL("__acosh_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float __acoshf_finite(float x);
-TLI_DEFINE_ENUM_INTERNAL(acoshf_finite)
-TLI_DEFINE_STRING_INTERNAL("__acoshf_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double __acoshl_finite(long double x);
-TLI_DEFINE_ENUM_INTERNAL(acoshl_finite)
-TLI_DEFINE_STRING_INTERNAL("__acoshl_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// long double __acosl_finite(long double x);
-TLI_DEFINE_ENUM_INTERNAL(acosl_finite)
-TLI_DEFINE_STRING_INTERNAL("__acosl_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double __asin_finite(double x);
-TLI_DEFINE_ENUM_INTERNAL(asin_finite)
-TLI_DEFINE_STRING_INTERNAL("__asin_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float __asinf_finite(float x);
-TLI_DEFINE_ENUM_INTERNAL(asinf_finite)
-TLI_DEFINE_STRING_INTERNAL("__asinf_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double __asinl_finite(long double x);
-TLI_DEFINE_ENUM_INTERNAL(asinl_finite)
-TLI_DEFINE_STRING_INTERNAL("__asinl_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double atan2_finite(double y, double x);
-TLI_DEFINE_ENUM_INTERNAL(atan2_finite)
-TLI_DEFINE_STRING_INTERNAL("__atan2_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
-
-/// float atan2f_finite(float y, float x);
-TLI_DEFINE_ENUM_INTERNAL(atan2f_finite)
-TLI_DEFINE_STRING_INTERNAL("__atan2f_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
-
-/// long double atan2l_finite(long double y, long double x);
-TLI_DEFINE_ENUM_INTERNAL(atan2l_finite)
-TLI_DEFINE_STRING_INTERNAL("__atan2l_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
-
-/// double __atanh_finite(double x);
-TLI_DEFINE_ENUM_INTERNAL(atanh_finite)
-TLI_DEFINE_STRING_INTERNAL("__atanh_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float __atanhf_finite(float x);
-TLI_DEFINE_ENUM_INTERNAL(atanhf_finite)
-TLI_DEFINE_STRING_INTERNAL("__atanhf_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double __atanhl_finite(long double x);
-TLI_DEFINE_ENUM_INTERNAL(atanhl_finite)
-TLI_DEFINE_STRING_INTERNAL("__atanhl_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// void __atomic_load(size_t size, void *mptr, void *vptr, int smodel);
-TLI_DEFINE_ENUM_INTERNAL(atomic_load)
-TLI_DEFINE_STRING_INTERNAL("__atomic_load")
-TLI_DEFINE_SIG_INTERNAL(Void, SizeT, Ptr, Ptr, Int)
-
-/// void __atomic_store(size_t size, void *mptr, void *vptr, int smodel);
-TLI_DEFINE_ENUM_INTERNAL(atomic_store)
-TLI_DEFINE_STRING_INTERNAL("__atomic_store")
-TLI_DEFINE_SIG_INTERNAL(Void, SizeT, Ptr, Ptr, Int)
-
-/// double __cosh_finite(double x);
-TLI_DEFINE_ENUM_INTERNAL(cosh_finite)
-TLI_DEFINE_STRING_INTERNAL("__cosh_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float __coshf_finite(float x);
-TLI_DEFINE_ENUM_INTERNAL(coshf_finite)
-TLI_DEFINE_STRING_INTERNAL("__coshf_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double __coshl_finite(long double x);
-TLI_DEFINE_ENUM_INTERNAL(coshl_finite)
-TLI_DEFINE_STRING_INTERNAL("__coshl_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double __cospi(double x);
-TLI_DEFINE_ENUM_INTERNAL(cospi)
-TLI_DEFINE_STRING_INTERNAL("__cospi")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float __cospif(float x);
-TLI_DEFINE_ENUM_INTERNAL(cospif)
-TLI_DEFINE_STRING_INTERNAL("__cospif")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// int __cxa_atexit(void (*f)(void *), void *p, void *d);
-TLI_DEFINE_ENUM_INTERNAL(cxa_atexit)
-TLI_DEFINE_STRING_INTERNAL("__cxa_atexit")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
-
-/// int atexit(void (*f)(void));
-TLI_DEFINE_ENUM_INTERNAL(atexit)
-TLI_DEFINE_STRING_INTERNAL("atexit")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// void abort(void)
-TLI_DEFINE_ENUM_INTERNAL(abort)
-TLI_DEFINE_STRING_INTERNAL("abort")
-TLI_DEFINE_SIG_INTERNAL(Void)
-
-/// void exit(int)
-TLI_DEFINE_ENUM_INTERNAL(exit)
-TLI_DEFINE_STRING_INTERNAL("exit")
-TLI_DEFINE_SIG_INTERNAL(Void, Int)
-
-/// void _Exit(int)
-TLI_DEFINE_ENUM_INTERNAL(Exit)
-TLI_DEFINE_STRING_INTERNAL("_Exit")
-TLI_DEFINE_SIG_INTERNAL(Void, Int)
-
-/// void std::terminate();
-TLI_DEFINE_ENUM_INTERNAL(terminate)
-TLI_DEFINE_STRING_INTERNAL("_ZSt9terminatev")
-TLI_DEFINE_SIG_INTERNAL(Void)
-
-/// void __cxa_throw(void *, void *, void (*)(void *));
-TLI_DEFINE_ENUM_INTERNAL(cxa_throw)
-TLI_DEFINE_STRING_INTERNAL("__cxa_throw")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr, Ptr)
-
-/// void __cxa_guard_abort(guard_t *guard);
-/// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi.
-TLI_DEFINE_ENUM_INTERNAL(cxa_guard_abort)
-TLI_DEFINE_STRING_INTERNAL("__cxa_guard_abort")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// int __cxa_guard_acquire(guard_t *guard);
-TLI_DEFINE_ENUM_INTERNAL(cxa_guard_acquire)
-TLI_DEFINE_STRING_INTERNAL("__cxa_guard_acquire")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// void __cxa_guard_release(guard_t *guard);
-TLI_DEFINE_ENUM_INTERNAL(cxa_guard_release)
-TLI_DEFINE_STRING_INTERNAL("__cxa_guard_release")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// double __exp10_finite(double x);
-TLI_DEFINE_ENUM_INTERNAL(exp10_finite)
-TLI_DEFINE_STRING_INTERNAL("__exp10_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float __exp10f_finite(float x);
-TLI_DEFINE_ENUM_INTERNAL(exp10f_finite)
-TLI_DEFINE_STRING_INTERNAL("__exp10f_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double __exp10l_finite(long double x);
-TLI_DEFINE_ENUM_INTERNAL(exp10l_finite)
-TLI_DEFINE_STRING_INTERNAL("__exp10l_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double __exp2_finite(double x);
-TLI_DEFINE_ENUM_INTERNAL(exp2_finite)
-TLI_DEFINE_STRING_INTERNAL("__exp2_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float __exp2f_finite(float x);
-TLI_DEFINE_ENUM_INTERNAL(exp2f_finite)
-TLI_DEFINE_STRING_INTERNAL("__exp2f_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double __exp2l_finite(long double x);
-TLI_DEFINE_ENUM_INTERNAL(exp2l_finite)
-TLI_DEFINE_STRING_INTERNAL("__exp2l_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double __exp_finite(double x);
-TLI_DEFINE_ENUM_INTERNAL(exp_finite)
-TLI_DEFINE_STRING_INTERNAL("__exp_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float __expf_finite(float x);
-TLI_DEFINE_ENUM_INTERNAL(expf_finite)
-TLI_DEFINE_STRING_INTERNAL("__expf_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double __expl_finite(long double x);
-TLI_DEFINE_ENUM_INTERNAL(expl_finite)
-TLI_DEFINE_STRING_INTERNAL("__expl_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// int __isoc99_scanf (const char *format, ...)
-TLI_DEFINE_ENUM_INTERNAL(dunder_isoc99_scanf)
-TLI_DEFINE_STRING_INTERNAL("__isoc99_scanf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip)
-
-/// int __isoc99_sscanf(const char *s, const char *format, ...)
-TLI_DEFINE_ENUM_INTERNAL(dunder_isoc99_sscanf)
-TLI_DEFINE_STRING_INTERNAL("__isoc99_sscanf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
-
-/// void* __kmpc_alloc_shared(size_t nbyte);
-TLI_DEFINE_ENUM_INTERNAL(__kmpc_alloc_shared)
-TLI_DEFINE_STRING_INTERNAL("__kmpc_alloc_shared")
-TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT)
-
-/// void __kmpc_free_shared(void *ptr, size_t nbyte);
-TLI_DEFINE_ENUM_INTERNAL(__kmpc_free_shared)
-TLI_DEFINE_STRING_INTERNAL("__kmpc_free_shared")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, SizeT)
-
-/// double __log10_finite(double x);
-TLI_DEFINE_ENUM_INTERNAL(log10_finite)
-TLI_DEFINE_STRING_INTERNAL("__log10_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float __log10f_finite(float x);
-TLI_DEFINE_ENUM_INTERNAL(log10f_finite)
-TLI_DEFINE_STRING_INTERNAL("__log10f_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double __log10l_finite(long double x);
-TLI_DEFINE_ENUM_INTERNAL(log10l_finite)
-TLI_DEFINE_STRING_INTERNAL("__log10l_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double __log2_finite(double x);
-TLI_DEFINE_ENUM_INTERNAL(log2_finite)
-TLI_DEFINE_STRING_INTERNAL("__log2_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float __log2f_finite(float x);
-TLI_DEFINE_ENUM_INTERNAL(log2f_finite)
-TLI_DEFINE_STRING_INTERNAL("__log2f_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double __log2l_finite(long double x);
-TLI_DEFINE_ENUM_INTERNAL(log2l_finite)
-TLI_DEFINE_STRING_INTERNAL("__log2l_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double __log_finite(double x);
-TLI_DEFINE_ENUM_INTERNAL(log_finite)
-TLI_DEFINE_STRING_INTERNAL("__log_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float __logf_finite(float x);
-TLI_DEFINE_ENUM_INTERNAL(logf_finite)
-TLI_DEFINE_STRING_INTERNAL("__logf_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double __logl_finite(long double x);
-TLI_DEFINE_ENUM_INTERNAL(logl_finite)
-TLI_DEFINE_STRING_INTERNAL("__logl_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// void *__memccpy_chk(void *dst, const void *src, int c, size_t n,
-///                     size_t dstsize)
-TLI_DEFINE_ENUM_INTERNAL(memccpy_chk)
-TLI_DEFINE_STRING_INTERNAL("__memccpy_chk")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, Int, SizeT, SizeT)
-
-/// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
-TLI_DEFINE_ENUM_INTERNAL(memcpy_chk)
-TLI_DEFINE_STRING_INTERNAL("__memcpy_chk")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT)
-
-/// void *__memmove_chk(void *s1, const void *s2, size_t n, size_t s1size);
-TLI_DEFINE_ENUM_INTERNAL(memmove_chk)
-TLI_DEFINE_STRING_INTERNAL("__memmove_chk")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT)
-
-/// void *__mempcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
-TLI_DEFINE_ENUM_INTERNAL(mempcpy_chk)
-TLI_DEFINE_STRING_INTERNAL("__mempcpy_chk")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT)
-
-/// void *__memset_chk(void *s, int v, size_t n, size_t s1size);
-TLI_DEFINE_ENUM_INTERNAL(memset_chk)
-TLI_DEFINE_STRING_INTERNAL("__memset_chk")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, SizeT, SizeT)
-
-// int __nvvm_reflect(const char *)
-TLI_DEFINE_ENUM_INTERNAL(nvvm_reflect)
-TLI_DEFINE_STRING_INTERNAL("__nvvm_reflect")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// double __pow_finite(double x, double y);
-TLI_DEFINE_ENUM_INTERNAL(pow_finite)
-TLI_DEFINE_STRING_INTERNAL("__pow_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
-
-/// float _powf_finite(float x, float y);
-TLI_DEFINE_ENUM_INTERNAL(powf_finite)
-TLI_DEFINE_STRING_INTERNAL("__powf_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
-
-/// long double __powl_finite(long double x, long double y);
-TLI_DEFINE_ENUM_INTERNAL(powl_finite)
-TLI_DEFINE_STRING_INTERNAL("__powl_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
-
-/// double __sincospi_stret(double x);
-TLI_DEFINE_ENUM_INTERNAL(sincospi_stret)
-TLI_DEFINE_STRING_INTERNAL("__sincospi_stret")
-TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
-
-/// float __sincospif_stret(float x);
-TLI_DEFINE_ENUM_INTERNAL(sincospif_stret)
-TLI_DEFINE_STRING_INTERNAL("__sincospif_stret")
-TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
-
-/// double __sinh_finite(double x);
-TLI_DEFINE_ENUM_INTERNAL(sinh_finite)
-TLI_DEFINE_STRING_INTERNAL("__sinh_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float _sinhf_finite(float x);
-TLI_DEFINE_ENUM_INTERNAL(sinhf_finite)
-TLI_DEFINE_STRING_INTERNAL("__sinhf_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double __sinhl_finite(long double x);
-TLI_DEFINE_ENUM_INTERNAL(sinhl_finite)
-TLI_DEFINE_STRING_INTERNAL("__sinhl_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double __sinpi(double x);
-TLI_DEFINE_ENUM_INTERNAL(sinpi)
-TLI_DEFINE_STRING_INTERNAL("__sinpi")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float __sinpif(float x);
-TLI_DEFINE_ENUM_INTERNAL(sinpif)
-TLI_DEFINE_STRING_INTERNAL("__sinpif")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// int __small_fprintf(FILE *stream, const char *format, ...);
-TLI_DEFINE_ENUM_INTERNAL(small_fprintf)
-TLI_DEFINE_STRING_INTERNAL("__small_fprintf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
-
-/// int __small_printf(const char *format, ...);
-TLI_DEFINE_ENUM_INTERNAL(small_printf)
-TLI_DEFINE_STRING_INTERNAL("__small_printf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip)
-
-/// int __small_sprintf(char *str, const char *format, ...);
-TLI_DEFINE_ENUM_INTERNAL(small_sprintf)
-TLI_DEFINE_STRING_INTERNAL("__small_sprintf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
-
-/// int __snprintf_chk(char *s, size_t n, int flags, size_t slen,
-///                    const char *format, ...);
-TLI_DEFINE_ENUM_INTERNAL(snprintf_chk)
-TLI_DEFINE_STRING_INTERNAL("__snprintf_chk")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, Int, SizeT, Ptr, Ellip)
-
-/// int __sprintf_chk(char *str, int flags, size_t str_len,
-///                   const char *format, ...);
-TLI_DEFINE_ENUM_INTERNAL(sprintf_chk)
-TLI_DEFINE_STRING_INTERNAL("__sprintf_chk")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int, SizeT, Ptr, Ellip)
-
-/// double __sqrt_finite(double x);
-TLI_DEFINE_ENUM_INTERNAL(sqrt_finite)
-TLI_DEFINE_STRING_INTERNAL("__sqrt_finite")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float __sqrt_finite(float x);
-TLI_DEFINE_ENUM_INTERNAL(sqrtf_finite)
-TLI_DEFINE_STRING_INTERNAL("__sqrtf_finite")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double __sqrt_finite(long double x);
-TLI_DEFINE_ENUM_INTERNAL(sqrtl_finite)
-TLI_DEFINE_STRING_INTERNAL("__sqrtl_finite")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// char *__stpcpy_chk(char *s1, const char *s2, size_t s1size);
-TLI_DEFINE_ENUM_INTERNAL(stpcpy_chk)
-TLI_DEFINE_STRING_INTERNAL("__stpcpy_chk")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
-
-/// char *__stpncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);
-TLI_DEFINE_ENUM_INTERNAL(stpncpy_chk)
-TLI_DEFINE_STRING_INTERNAL("__stpncpy_chk")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT)
-
-/// char *__strcat_chk(char *s1, const char *s2, size_t s1size);
-TLI_DEFINE_ENUM_INTERNAL(strcat_chk)
-TLI_DEFINE_STRING_INTERNAL("__strcat_chk")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
-
-/// char *__strcpy_chk(char *s1, const char *s2, size_t s1size);
-TLI_DEFINE_ENUM_INTERNAL(strcpy_chk)
-TLI_DEFINE_STRING_INTERNAL("__strcpy_chk")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
-
-/// char * __strdup(const char *s);
-TLI_DEFINE_ENUM_INTERNAL(dunder_strdup)
-TLI_DEFINE_STRING_INTERNAL("__strdup")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr)
-
-/// size_t __strlcat_chk(char *dst, const char *src, size_t size,
-///                      size_t dstsize);
-TLI_DEFINE_ENUM_INTERNAL(strlcat_chk)
-TLI_DEFINE_STRING_INTERNAL("__strlcat_chk")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT, SizeT)
-
-/// size_t __strlcpy_chk(char *dst, const char *src, size_t size,
-///                      size_t dstsize);
-TLI_DEFINE_ENUM_INTERNAL(strlcpy_chk)
-TLI_DEFINE_STRING_INTERNAL("__strlcpy_chk")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT, SizeT)
-
-/// size_t __strlen_chk(const char *s1, size_t s1size);
-TLI_DEFINE_ENUM_INTERNAL(strlen_chk)
-TLI_DEFINE_STRING_INTERNAL("__strlen_chk")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT)
-
-/// char *strncat_chk(char *s1, const char *s2, size_t n, size_t s1size);
-TLI_DEFINE_ENUM_INTERNAL(strncat_chk)
-TLI_DEFINE_STRING_INTERNAL("__strncat_chk")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT)
-
-/// char *__strncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);
-TLI_DEFINE_ENUM_INTERNAL(strncpy_chk)
-TLI_DEFINE_STRING_INTERNAL("__strncpy_chk")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT)
-
-/// char *__strndup(const char *s, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(dunder_strndup)
-TLI_DEFINE_STRING_INTERNAL("__strndup")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT)
-
-/// char * __strtok_r(char *s, const char *delim, char **save_ptr);
-TLI_DEFINE_ENUM_INTERNAL(dunder_strtok_r)
-TLI_DEFINE_STRING_INTERNAL("__strtok_r")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, Ptr)
-
-/// int __vsnprintf_chk(char *s, size_t n, int flags, size_t slen,
-///                     const char *format, va_list ap);
-TLI_DEFINE_ENUM_INTERNAL(vsnprintf_chk)
-TLI_DEFINE_STRING_INTERNAL("__vsnprintf_chk")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, Int, SizeT, Ptr, Ptr)
-
-/// int __vsprintf_chk(char *s, int flags, size_t slen, const char *format,
-///                    va_list ap);
-TLI_DEFINE_ENUM_INTERNAL(vsprintf_chk)
-TLI_DEFINE_STRING_INTERNAL("__vsprintf_chk")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int, SizeT, Ptr, Ptr)
-
-/// int abs(int j);
-TLI_DEFINE_ENUM_INTERNAL(abs)
-TLI_DEFINE_STRING_INTERNAL("abs")
-TLI_DEFINE_SIG_INTERNAL(Int, Int)
-
-/// int access(const char *path, int amode);
-TLI_DEFINE_ENUM_INTERNAL(access)
-TLI_DEFINE_STRING_INTERNAL("access")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int)
-
-/// double acos(double x);
-TLI_DEFINE_ENUM_INTERNAL(acos)
-TLI_DEFINE_STRING_INTERNAL("acos")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float acosf(float x);
-TLI_DEFINE_ENUM_INTERNAL(acosf)
-TLI_DEFINE_STRING_INTERNAL("acosf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// double acosh(double x);
-TLI_DEFINE_ENUM_INTERNAL(acosh)
-TLI_DEFINE_STRING_INTERNAL("acosh")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float acoshf(float x);
-TLI_DEFINE_ENUM_INTERNAL(acoshf)
-TLI_DEFINE_STRING_INTERNAL("acoshf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double acoshl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(acoshl)
-TLI_DEFINE_STRING_INTERNAL("acoshl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// long double acosl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(acosl)
-TLI_DEFINE_STRING_INTERNAL("acosl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// void *aligned_alloc(size_t alignment, size_t size);
-TLI_DEFINE_ENUM_INTERNAL(aligned_alloc)
-TLI_DEFINE_STRING_INTERNAL("aligned_alloc")
-TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT, SizeT)
-
-/// double asin(double x);
-TLI_DEFINE_ENUM_INTERNAL(asin)
-TLI_DEFINE_STRING_INTERNAL("asin")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float asinf(float x);
-TLI_DEFINE_ENUM_INTERNAL(asinf)
-TLI_DEFINE_STRING_INTERNAL("asinf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// double asinh(double x);
-TLI_DEFINE_ENUM_INTERNAL(asinh)
-TLI_DEFINE_STRING_INTERNAL("asinh")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float asinhf(float x);
-TLI_DEFINE_ENUM_INTERNAL(asinhf)
-TLI_DEFINE_STRING_INTERNAL("asinhf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double asinhl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(asinhl)
-TLI_DEFINE_STRING_INTERNAL("asinhl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// long double asinl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(asinl)
-TLI_DEFINE_STRING_INTERNAL("asinl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double atan(double x);
-TLI_DEFINE_ENUM_INTERNAL(atan)
-TLI_DEFINE_STRING_INTERNAL("atan")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// double atan2(double y, double x);
-TLI_DEFINE_ENUM_INTERNAL(atan2)
-TLI_DEFINE_STRING_INTERNAL("atan2")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
-
-/// float atan2f(float y, float x);
-TLI_DEFINE_ENUM_INTERNAL(atan2f)
-TLI_DEFINE_STRING_INTERNAL("atan2f")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
-
-/// long double atan2l(long double y, long double x);
-TLI_DEFINE_ENUM_INTERNAL(atan2l)
-TLI_DEFINE_STRING_INTERNAL("atan2l")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
-
-/// float atanf(float x);
-TLI_DEFINE_ENUM_INTERNAL(atanf)
-TLI_DEFINE_STRING_INTERNAL("atanf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// double atanh(double x);
-TLI_DEFINE_ENUM_INTERNAL(atanh)
-TLI_DEFINE_STRING_INTERNAL("atanh")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float atanhf(float x);
-TLI_DEFINE_ENUM_INTERNAL(atanhf)
-TLI_DEFINE_STRING_INTERNAL("atanhf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double atanhl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(atanhl)
-TLI_DEFINE_STRING_INTERNAL("atanhl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// long double atanl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(atanl)
-TLI_DEFINE_STRING_INTERNAL("atanl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double atof(const char *str);
-TLI_DEFINE_ENUM_INTERNAL(atof)
-TLI_DEFINE_STRING_INTERNAL("atof")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Ptr)
-
-/// int atoi(const char *str);
-TLI_DEFINE_ENUM_INTERNAL(atoi)
-TLI_DEFINE_STRING_INTERNAL("atoi")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// long atol(const char *str);
-TLI_DEFINE_ENUM_INTERNAL(atol)
-TLI_DEFINE_STRING_INTERNAL("atol")
-TLI_DEFINE_SIG_INTERNAL(Long, Ptr)
-
-/// long long atoll(const char *nptr);
-TLI_DEFINE_ENUM_INTERNAL(atoll)
-TLI_DEFINE_STRING_INTERNAL("atoll")
-TLI_DEFINE_SIG_INTERNAL(LLong, Ptr)
-
-/// int bcmp(const void *s1, const void *s2, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(bcmp)
-TLI_DEFINE_STRING_INTERNAL("bcmp")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, SizeT)
-
-/// void bcopy(const void *s1, void *s2, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(bcopy)
-TLI_DEFINE_STRING_INTERNAL("bcopy")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr, SizeT)
-
-/// void bzero(void *s, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(bzero)
-TLI_DEFINE_STRING_INTERNAL("bzero")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, SizeT)
-
-/// double cabs(double complex z)
-TLI_DEFINE_ENUM_INTERNAL(cabs)
-TLI_DEFINE_STRING_INTERNAL("cabs")
-TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
-
-/// float cabs(float complex z)
-TLI_DEFINE_ENUM_INTERNAL(cabsf)
-TLI_DEFINE_STRING_INTERNAL("cabsf")
-TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
-
-/// long double cabs(long double complex z)
-TLI_DEFINE_ENUM_INTERNAL(cabsl)
-TLI_DEFINE_STRING_INTERNAL("cabsl")
-TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
-
-/// void *calloc(size_t count, size_t size);
-TLI_DEFINE_ENUM_INTERNAL(calloc)
-TLI_DEFINE_STRING_INTERNAL("calloc")
-TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT, SizeT)
-
-/// double cbrt(double x);
-TLI_DEFINE_ENUM_INTERNAL(cbrt)
-TLI_DEFINE_STRING_INTERNAL("cbrt")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float cbrtf(float x);
-TLI_DEFINE_ENUM_INTERNAL(cbrtf)
-TLI_DEFINE_STRING_INTERNAL("cbrtf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double cbrtl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(cbrtl)
-TLI_DEFINE_STRING_INTERNAL("cbrtl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double ceil(double x);
-TLI_DEFINE_ENUM_INTERNAL(ceil)
-TLI_DEFINE_STRING_INTERNAL("ceil")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float ceilf(float x);
-TLI_DEFINE_ENUM_INTERNAL(ceilf)
-TLI_DEFINE_STRING_INTERNAL("ceilf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double ceill(long double x);
-TLI_DEFINE_ENUM_INTERNAL(ceill)
-TLI_DEFINE_STRING_INTERNAL("ceill")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// int chmod(const char *path, mode_t mode);
-TLI_DEFINE_ENUM_INTERNAL(chmod)
-TLI_DEFINE_STRING_INTERNAL("chmod")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX)
-
-/// int chown(const char *path, uid_t owner, gid_t group);
-TLI_DEFINE_ENUM_INTERNAL(chown)
-TLI_DEFINE_STRING_INTERNAL("chown")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX, IntX)
-
-/// void clearerr(FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(clearerr)
-TLI_DEFINE_STRING_INTERNAL("clearerr")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// int closedir(DIR *dirp);
-TLI_DEFINE_ENUM_INTERNAL(closedir)
-TLI_DEFINE_STRING_INTERNAL("closedir")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// double copysign(double x, double y);
-TLI_DEFINE_ENUM_INTERNAL(copysign)
-TLI_DEFINE_STRING_INTERNAL("copysign")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
-
-/// float copysignf(float x, float y);
-TLI_DEFINE_ENUM_INTERNAL(copysignf)
-TLI_DEFINE_STRING_INTERNAL("copysignf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
-
-/// long double copysignl(long double x, long double y);
-TLI_DEFINE_ENUM_INTERNAL(copysignl)
-TLI_DEFINE_STRING_INTERNAL("copysignl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
-
-/// double cos(double x);
-TLI_DEFINE_ENUM_INTERNAL(cos)
-TLI_DEFINE_STRING_INTERNAL("cos")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float cosf(float x);
-TLI_DEFINE_ENUM_INTERNAL(cosf)
-TLI_DEFINE_STRING_INTERNAL("cosf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// double cosh(double x);
-TLI_DEFINE_ENUM_INTERNAL(cosh)
-TLI_DEFINE_STRING_INTERNAL("cosh")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float coshf(float x);
-TLI_DEFINE_ENUM_INTERNAL(coshf)
-TLI_DEFINE_STRING_INTERNAL("coshf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double coshl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(coshl)
-TLI_DEFINE_STRING_INTERNAL("coshl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// long double cosl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(cosl)
-TLI_DEFINE_STRING_INTERNAL("cosl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// char *ctermid(char *s);
-TLI_DEFINE_ENUM_INTERNAL(ctermid)
-TLI_DEFINE_STRING_INTERNAL("ctermid")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr)
-
-/// double erf(double x);
-TLI_DEFINE_ENUM_INTERNAL(erf)
-TLI_DEFINE_STRING_INTERNAL("erf")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float erff(float x);
-TLI_DEFINE_ENUM_INTERNAL(erff)
-TLI_DEFINE_STRING_INTERNAL("erff")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double erfl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(erfl)
-TLI_DEFINE_STRING_INTERNAL("erfl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double tgamma(double x);
-TLI_DEFINE_ENUM_INTERNAL(tgamma)
-TLI_DEFINE_STRING_INTERNAL("tgamma")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float tgammaf(float x);
-TLI_DEFINE_ENUM_INTERNAL(tgammaf)
-TLI_DEFINE_STRING_INTERNAL("tgammaf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double tgammal(long double x);
-TLI_DEFINE_ENUM_INTERNAL(tgammal)
-TLI_DEFINE_STRING_INTERNAL("tgammal")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// int execl(const char *path, const char *arg, ...);
-TLI_DEFINE_ENUM_INTERNAL(execl)
-TLI_DEFINE_STRING_INTERNAL("execl")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
-
-/// int execle(const char *file, const char *arg, ..., char * const envp[]);
-TLI_DEFINE_ENUM_INTERNAL(execle)
-TLI_DEFINE_STRING_INTERNAL("execle")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
-
-/// int execlp(const char *file, const char *arg, ...);
-TLI_DEFINE_ENUM_INTERNAL(execlp)
-TLI_DEFINE_STRING_INTERNAL("execlp")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
-
-/// int execv(const char *path, char *const argv[]);
-TLI_DEFINE_ENUM_INTERNAL(execv)
-TLI_DEFINE_STRING_INTERNAL("execv")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// int execvP(const char *file, const char *search_path, char *const argv[]);
-TLI_DEFINE_ENUM_INTERNAL(execvP)
-TLI_DEFINE_STRING_INTERNAL("execvP")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
-
-/// int execve(const char *filename, char *const argv[], char *const envp[]);
-TLI_DEFINE_ENUM_INTERNAL(execve)
-TLI_DEFINE_STRING_INTERNAL("execve")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
-
-/// int execvp(const char *file, char *const argv[]);
-TLI_DEFINE_ENUM_INTERNAL(execvp)
-TLI_DEFINE_STRING_INTERNAL("execvp")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// int execvpe(const char *file, char *const argv[], char *const envp[]);
-TLI_DEFINE_ENUM_INTERNAL(execvpe)
-TLI_DEFINE_STRING_INTERNAL("execvpe")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
-
-/// double exp(double x);
-TLI_DEFINE_ENUM_INTERNAL(exp)
-TLI_DEFINE_STRING_INTERNAL("exp")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// double exp10(double x);
-TLI_DEFINE_ENUM_INTERNAL(exp10)
-TLI_DEFINE_STRING_INTERNAL("exp10")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float exp10f(float x);
-TLI_DEFINE_ENUM_INTERNAL(exp10f)
-TLI_DEFINE_STRING_INTERNAL("exp10f")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double exp10l(long double x);
-TLI_DEFINE_ENUM_INTERNAL(exp10l)
-TLI_DEFINE_STRING_INTERNAL("exp10l")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double exp2(double x);
-TLI_DEFINE_ENUM_INTERNAL(exp2)
-TLI_DEFINE_STRING_INTERNAL("exp2")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float exp2f(float x);
-TLI_DEFINE_ENUM_INTERNAL(exp2f)
-TLI_DEFINE_STRING_INTERNAL("exp2f")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double exp2l(long double x);
-TLI_DEFINE_ENUM_INTERNAL(exp2l)
-TLI_DEFINE_STRING_INTERNAL("exp2l")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// float expf(float x);
-TLI_DEFINE_ENUM_INTERNAL(expf)
-TLI_DEFINE_STRING_INTERNAL("expf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double expl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(expl)
-TLI_DEFINE_STRING_INTERNAL("expl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double expm1(double x);
-TLI_DEFINE_ENUM_INTERNAL(expm1)
-TLI_DEFINE_STRING_INTERNAL("expm1")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float expm1f(float x);
-TLI_DEFINE_ENUM_INTERNAL(expm1f)
-TLI_DEFINE_STRING_INTERNAL("expm1f")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double expm1l(long double x);
-TLI_DEFINE_ENUM_INTERNAL(expm1l)
-TLI_DEFINE_STRING_INTERNAL("expm1l")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double fabs(double x);
-TLI_DEFINE_ENUM_INTERNAL(fabs)
-TLI_DEFINE_STRING_INTERNAL("fabs")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float fabsf(float x);
-TLI_DEFINE_ENUM_INTERNAL(fabsf)
-TLI_DEFINE_STRING_INTERNAL("fabsf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double fabsl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(fabsl)
-TLI_DEFINE_STRING_INTERNAL("fabsl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// int fclose(FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fclose)
-TLI_DEFINE_STRING_INTERNAL("fclose")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// FILE *fdopen(int fildes, const char *mode);
-TLI_DEFINE_ENUM_INTERNAL(fdopen)
-TLI_DEFINE_STRING_INTERNAL("fdopen")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr)
-
-/// int feof(FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(feof)
-TLI_DEFINE_STRING_INTERNAL("feof")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// int ferror(FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(ferror)
-TLI_DEFINE_STRING_INTERNAL("ferror")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// int fflush(FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fflush)
-TLI_DEFINE_STRING_INTERNAL("fflush")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// int ffs(int i);
-TLI_DEFINE_ENUM_INTERNAL(ffs)
-TLI_DEFINE_STRING_INTERNAL("ffs")
-TLI_DEFINE_SIG_INTERNAL(Int, Int)
-
-/// int ffsl(long int i);
-TLI_DEFINE_ENUM_INTERNAL(ffsl)
-TLI_DEFINE_STRING_INTERNAL("ffsl")
-TLI_DEFINE_SIG_INTERNAL(Int, Long)
-
-/// int ffsll(long long int i);
-TLI_DEFINE_ENUM_INTERNAL(ffsll)
-TLI_DEFINE_STRING_INTERNAL("ffsll")
-TLI_DEFINE_SIG_INTERNAL(Int, LLong)
-
-/// int fgetc(FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fgetc)
-TLI_DEFINE_STRING_INTERNAL("fgetc")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// int fgetc_unlocked(FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fgetc_unlocked)
-TLI_DEFINE_STRING_INTERNAL("fgetc_unlocked")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// int fgetpos(FILE *stream, fpos_t *pos);
-TLI_DEFINE_ENUM_INTERNAL(fgetpos)
-TLI_DEFINE_STRING_INTERNAL("fgetpos")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// char *fgets(char *s, int n, FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fgets)
-TLI_DEFINE_STRING_INTERNAL("fgets")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, Ptr)
-
-/// char *fgets_unlocked(char *s, int n, FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fgets_unlocked)
-TLI_DEFINE_STRING_INTERNAL("fgets_unlocked")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, Ptr)
-
-/// int fileno(FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fileno)
-TLI_DEFINE_STRING_INTERNAL("fileno")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// int fiprintf(FILE *stream, const char *format, ...);
-TLI_DEFINE_ENUM_INTERNAL(fiprintf)
-TLI_DEFINE_STRING_INTERNAL("fiprintf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
-
-/// void flockfile(FILE *file);
-TLI_DEFINE_ENUM_INTERNAL(flockfile)
-TLI_DEFINE_STRING_INTERNAL("flockfile")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// double floor(double x);
-TLI_DEFINE_ENUM_INTERNAL(floor)
-TLI_DEFINE_STRING_INTERNAL("floor")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float floorf(float x);
-TLI_DEFINE_ENUM_INTERNAL(floorf)
-TLI_DEFINE_STRING_INTERNAL("floorf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double floorl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(floorl)
-TLI_DEFINE_STRING_INTERNAL("floorl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// int fls(int i);
-TLI_DEFINE_ENUM_INTERNAL(fls)
-TLI_DEFINE_STRING_INTERNAL("fls")
-TLI_DEFINE_SIG_INTERNAL(Int, Int)
-
-/// int flsl(long int i);
-TLI_DEFINE_ENUM_INTERNAL(flsl)
-TLI_DEFINE_STRING_INTERNAL("flsl")
-TLI_DEFINE_SIG_INTERNAL(Int, Long)
-
-/// int flsll(long long int i);
-TLI_DEFINE_ENUM_INTERNAL(flsll)
-TLI_DEFINE_STRING_INTERNAL("flsll")
-TLI_DEFINE_SIG_INTERNAL(Int, LLong)
-
-// Calls to fmax and fmin library functions expand to the llvm.maxnnum and
-// llvm.minnum intrinsics with the correct parameter types for the arguments
-// (all types must match).
-/// double fmax(double x, double y);
-TLI_DEFINE_ENUM_INTERNAL(fmax)
-TLI_DEFINE_STRING_INTERNAL("fmax")
-TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
-
-/// float fmaxf(float x, float y);
-TLI_DEFINE_ENUM_INTERNAL(fmaxf)
-TLI_DEFINE_STRING_INTERNAL("fmaxf")
-TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
-
-/// long double fmaxl(long double x, long double y);
-TLI_DEFINE_ENUM_INTERNAL(fmaxl)
-TLI_DEFINE_STRING_INTERNAL("fmaxl")
-TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
-
-/// double fmin(double x, double y);
-TLI_DEFINE_ENUM_INTERNAL(fmin)
-TLI_DEFINE_STRING_INTERNAL("fmin")
-TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
-
-/// float fminf(float x, float y);
-TLI_DEFINE_ENUM_INTERNAL(fminf)
-TLI_DEFINE_STRING_INTERNAL("fminf")
-TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
-
-/// long double fminl(long double x, long double y);
-TLI_DEFINE_ENUM_INTERNAL(fminl)
-TLI_DEFINE_STRING_INTERNAL("fminl")
-TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
-
-// Calls to fmaximum_num and fminimum_num library functions expand to the llvm.maximumnum and
-// llvm.minimumnum intrinsics with the correct parameter types for the arguments
-// (all types must match).
-/// double fmaximum_num(double x, double y);
-TLI_DEFINE_ENUM_INTERNAL(fmaximum_num)
-TLI_DEFINE_STRING_INTERNAL("fmaximum_num")
-TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
-
-/// float fmaximum_numf(float x, float y);
-TLI_DEFINE_ENUM_INTERNAL(fmaximum_numf)
-TLI_DEFINE_STRING_INTERNAL("fmaximum_numf")
-TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
-
-/// long double fmaximum_numl(long double x, long double y);
-TLI_DEFINE_ENUM_INTERNAL(fmaximum_numl)
-TLI_DEFINE_STRING_INTERNAL("fmaximum_numl")
-TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
-
-/// double fminimum_num(double x, double y);
-TLI_DEFINE_ENUM_INTERNAL(fminimum_num)
-TLI_DEFINE_STRING_INTERNAL("fminimum_num")
-TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
-
-/// float fminimum_numf(float x, float y);
-TLI_DEFINE_ENUM_INTERNAL(fminimum_numf)
-TLI_DEFINE_STRING_INTERNAL("fminimum_numf")
-TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
-
-/// long double fminimum_numl(long double x, long double y);
-TLI_DEFINE_ENUM_INTERNAL(fminimum_numl)
-TLI_DEFINE_STRING_INTERNAL("fminimum_numl")
-TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
-
-/// double fmod(double x, double y);
-TLI_DEFINE_ENUM_INTERNAL(fmod)
-TLI_DEFINE_STRING_INTERNAL("fmod")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
-
-/// float fmodf(float x, float y);
-TLI_DEFINE_ENUM_INTERNAL(fmodf)
-TLI_DEFINE_STRING_INTERNAL("fmodf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
-
-/// long double fmodl(long double x, long double y);
-TLI_DEFINE_ENUM_INTERNAL(fmodl)
-TLI_DEFINE_STRING_INTERNAL("fmodl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
-
-/// FILE *fopen(const char *filename, const char *mode);
-TLI_DEFINE_ENUM_INTERNAL(fopen)
-TLI_DEFINE_STRING_INTERNAL("fopen")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
-
-/// FILE *fopen64(const char *filename, const char *opentype)
-TLI_DEFINE_ENUM_INTERNAL(fopen64)
-TLI_DEFINE_STRING_INTERNAL("fopen64")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
-
-/// int fork();
-TLI_DEFINE_ENUM_INTERNAL(fork)
-TLI_DEFINE_STRING_INTERNAL("fork")
-TLI_DEFINE_SIG_INTERNAL(Int)
-
-/// int fprintf(FILE *stream, const char *format, ...);
-TLI_DEFINE_ENUM_INTERNAL(fprintf)
-TLI_DEFINE_STRING_INTERNAL("fprintf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
-
-/// int fputc(int c, FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fputc)
-TLI_DEFINE_STRING_INTERNAL("fputc")
-TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
-
-/// int fputc_unlocked(int c, FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fputc_unlocked)
-TLI_DEFINE_STRING_INTERNAL("fputc_unlocked")
-TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
-
-/// int fputs(const char *s, FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fputs)
-TLI_DEFINE_STRING_INTERNAL("fputs")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// int fputs_unlocked(const char *s, FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fputs_unlocked)
-TLI_DEFINE_STRING_INTERNAL("fputs_unlocked")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fread)
-TLI_DEFINE_STRING_INTERNAL("fread")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT, SizeT, Ptr)
-
-/// size_t fread_unlocked(void *ptr, size_t size, size_t nitems, FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fread_unlocked)
-TLI_DEFINE_STRING_INTERNAL("fread_unlocked")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT, SizeT, Ptr)
-
-/// void free(void *ptr);
-TLI_DEFINE_ENUM_INTERNAL(free)
-TLI_DEFINE_STRING_INTERNAL("free")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// double frexp(double num, int *exp);
-TLI_DEFINE_ENUM_INTERNAL(frexp)
-TLI_DEFINE_STRING_INTERNAL("frexp")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Ptr)
-
-/// float frexpf(float num, int *exp);
-TLI_DEFINE_ENUM_INTERNAL(frexpf)
-TLI_DEFINE_STRING_INTERNAL("frexpf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Ptr)
-
-/// long double frexpl(long double num, int *exp);
-TLI_DEFINE_ENUM_INTERNAL(frexpl)
-TLI_DEFINE_STRING_INTERNAL("frexpl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, Ptr)
-
-/// int fscanf(FILE *stream, const char *format, ... );
-TLI_DEFINE_ENUM_INTERNAL(fscanf)
-TLI_DEFINE_STRING_INTERNAL("fscanf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
-
-/// int fseek(FILE *stream, long offset, int whence);
-TLI_DEFINE_ENUM_INTERNAL(fseek)
-TLI_DEFINE_STRING_INTERNAL("fseek")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Long, Int)
-
-/// int fseeko(FILE *stream, off_t offset, int whence);
-TLI_DEFINE_ENUM_INTERNAL(fseeko)
-TLI_DEFINE_STRING_INTERNAL("fseeko")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX, Int)
-
-/// int fseeko64(FILE *stream, off64_t offset, int whence)
-TLI_DEFINE_ENUM_INTERNAL(fseeko64)
-TLI_DEFINE_STRING_INTERNAL("fseeko64")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int64, Int)
-
-/// int fsetpos(FILE *stream, const fpos_t *pos);
-TLI_DEFINE_ENUM_INTERNAL(fsetpos)
-TLI_DEFINE_STRING_INTERNAL("fsetpos")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// int fstat(int fildes, struct stat *buf);
-TLI_DEFINE_ENUM_INTERNAL(fstat)
-TLI_DEFINE_STRING_INTERNAL("fstat")
-TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
-
-/// int fstat64(int filedes, struct stat64 *buf)
-TLI_DEFINE_ENUM_INTERNAL(fstat64)
-TLI_DEFINE_STRING_INTERNAL("fstat64")
-TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
-
-/// int fstatvfs(int fildes, struct statvfs *buf);
-TLI_DEFINE_ENUM_INTERNAL(fstatvfs)
-TLI_DEFINE_STRING_INTERNAL("fstatvfs")
-TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
-
-/// int fstatvfs64(int fildes, struct statvfs64 *buf);
-TLI_DEFINE_ENUM_INTERNAL(fstatvfs64)
-TLI_DEFINE_STRING_INTERNAL("fstatvfs64")
-TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
-
-/// long ftell(FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(ftell)
-TLI_DEFINE_STRING_INTERNAL("ftell")
-TLI_DEFINE_SIG_INTERNAL(Long, Ptr)
-
-/// off_t ftello(FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(ftello)
-TLI_DEFINE_STRING_INTERNAL("ftello")
-TLI_DEFINE_SIG_INTERNAL(IntPlus, Ptr)
-
-/// off64_t ftello64(FILE *stream)
-TLI_DEFINE_ENUM_INTERNAL(ftello64)
-TLI_DEFINE_STRING_INTERNAL("ftello64")
-TLI_DEFINE_SIG_INTERNAL(Int64, Ptr)
-
-/// int ftrylockfile(FILE *file);
-TLI_DEFINE_ENUM_INTERNAL(ftrylockfile)
-TLI_DEFINE_STRING_INTERNAL("ftrylockfile")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// void funlockfile(FILE *file);
-TLI_DEFINE_ENUM_INTERNAL(funlockfile)
-TLI_DEFINE_STRING_INTERNAL("funlockfile")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fwrite)
-TLI_DEFINE_STRING_INTERNAL("fwrite")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT, SizeT, Ptr)
-
-/// size_t fwrite_unlocked(const void *ptr, size_t size, size_t nitems, FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(fwrite_unlocked)
-TLI_DEFINE_STRING_INTERNAL("fwrite_unlocked")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT, SizeT, Ptr)
-
-/// int getc(FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(getc)
-TLI_DEFINE_STRING_INTERNAL("getc")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// int getc_unlocked(FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(getc_unlocked)
-TLI_DEFINE_STRING_INTERNAL("getc_unlocked")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// int getchar(void);
-TLI_DEFINE_ENUM_INTERNAL(getchar)
-TLI_DEFINE_STRING_INTERNAL("getchar")
-TLI_DEFINE_SIG_INTERNAL(Int)
-
-/// int getchar_unlocked(void);
-TLI_DEFINE_ENUM_INTERNAL(getchar_unlocked)
-TLI_DEFINE_STRING_INTERNAL("getchar_unlocked")
-TLI_DEFINE_SIG_INTERNAL(Int)
-
-/// char *getenv(const char *name);
-TLI_DEFINE_ENUM_INTERNAL(getenv)
-TLI_DEFINE_STRING_INTERNAL("getenv")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr)
-
-/// int getitimer(int which, struct itimerval *value);
-TLI_DEFINE_ENUM_INTERNAL(getitimer)
-TLI_DEFINE_STRING_INTERNAL("getitimer")
-TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
-
-/// int getlogin_r(char *name, size_t namesize);
-TLI_DEFINE_ENUM_INTERNAL(getlogin_r)
-TLI_DEFINE_STRING_INTERNAL("getlogin_r")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT)
-
-/// struct passwd *getpwnam(const char *name);
-TLI_DEFINE_ENUM_INTERNAL(getpwnam)
-TLI_DEFINE_STRING_INTERNAL("getpwnam")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr)
-
-/// char *gets(char *s);
-TLI_DEFINE_ENUM_INTERNAL(gets)
-TLI_DEFINE_STRING_INTERNAL("gets")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr)
-
-/// int gettimeofday(struct timeval *tp, void *tzp);
-TLI_DEFINE_ENUM_INTERNAL(gettimeofday)
-TLI_DEFINE_STRING_INTERNAL("gettimeofday")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// uint32_t htonl(uint32_t hostlong);
-TLI_DEFINE_ENUM_INTERNAL(htonl)
-TLI_DEFINE_STRING_INTERNAL("htonl")
-TLI_DEFINE_SIG_INTERNAL(Int32, Int32)
-
-/// uint16_t htons(uint16_t hostshort);
-TLI_DEFINE_ENUM_INTERNAL(htons)
-TLI_DEFINE_STRING_INTERNAL("htons")
-TLI_DEFINE_SIG_INTERNAL(Int16, Int16)
-
-/// double hypot(double x, double y);
-TLI_DEFINE_ENUM_INTERNAL(hypot)
-TLI_DEFINE_STRING_INTERNAL("hypot")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
-
-/// float hypotf(float x, float y);
-TLI_DEFINE_ENUM_INTERNAL(hypotf)
-TLI_DEFINE_STRING_INTERNAL("hypotf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
-
-/// long double hypotl(long double x, long double y);
-TLI_DEFINE_ENUM_INTERNAL(hypotl)
-TLI_DEFINE_STRING_INTERNAL("hypotl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
-
-/// int iprintf(const char *format, ...);
-TLI_DEFINE_ENUM_INTERNAL(iprintf)
-TLI_DEFINE_STRING_INTERNAL("iprintf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip)
-
-/// int isascii(int c);
-TLI_DEFINE_ENUM_INTERNAL(isascii)
-TLI_DEFINE_STRING_INTERNAL("isascii")
-TLI_DEFINE_SIG_INTERNAL(Int, Int)
-
-/// int isdigit(int c);
-TLI_DEFINE_ENUM_INTERNAL(isdigit)
-TLI_DEFINE_STRING_INTERNAL("isdigit")
-TLI_DEFINE_SIG_INTERNAL(Int, Int)
-
-/// long int labs(long int j);
-TLI_DEFINE_ENUM_INTERNAL(labs)
-TLI_DEFINE_STRING_INTERNAL("labs")
-TLI_DEFINE_SIG_INTERNAL(Long, Same)
-
-/// int lchown(const char *path, uid_t owner, gid_t group);
-TLI_DEFINE_ENUM_INTERNAL(lchown)
-TLI_DEFINE_STRING_INTERNAL("lchown")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX, IntX)
-
-/// double ldexp(double x, int n);
-TLI_DEFINE_ENUM_INTERNAL(ldexp)
-TLI_DEFINE_STRING_INTERNAL("ldexp")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Int)
-
-/// float ldexpf(float x, int n);
-TLI_DEFINE_ENUM_INTERNAL(ldexpf)
-TLI_DEFINE_STRING_INTERNAL("ldexpf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Int)
-
-/// long double ldexpl(long double x, int n);
-TLI_DEFINE_ENUM_INTERNAL(ldexpl)
-TLI_DEFINE_STRING_INTERNAL("ldexpl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, Int)
-
-/// long long int llabs(long long int j);
-TLI_DEFINE_ENUM_INTERNAL(llabs)
-TLI_DEFINE_STRING_INTERNAL("llabs")
-TLI_DEFINE_SIG_INTERNAL(LLong, LLong)
-
-/// double log(double x);
-TLI_DEFINE_ENUM_INTERNAL(log)
-TLI_DEFINE_STRING_INTERNAL("log")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// double log10(double x);
-TLI_DEFINE_ENUM_INTERNAL(log10)
-TLI_DEFINE_STRING_INTERNAL("log10")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float log10f(float x);
-TLI_DEFINE_ENUM_INTERNAL(log10f)
-TLI_DEFINE_STRING_INTERNAL("log10f")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double log10l(long double x);
-TLI_DEFINE_ENUM_INTERNAL(log10l)
-TLI_DEFINE_STRING_INTERNAL("log10l")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double log1p(double x);
-TLI_DEFINE_ENUM_INTERNAL(log1p)
-TLI_DEFINE_STRING_INTERNAL("log1p")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float log1pf(float x);
-TLI_DEFINE_ENUM_INTERNAL(log1pf)
-TLI_DEFINE_STRING_INTERNAL("log1pf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double log1pl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(log1pl)
-TLI_DEFINE_STRING_INTERNAL("log1pl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double log2(double x);
-TLI_DEFINE_ENUM_INTERNAL(log2)
-TLI_DEFINE_STRING_INTERNAL("log2")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float log2f(float x);
-TLI_DEFINE_ENUM_INTERNAL(log2f)
-TLI_DEFINE_STRING_INTERNAL("log2f")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// double long double log2l(long double x);
-TLI_DEFINE_ENUM_INTERNAL(log2l)
-TLI_DEFINE_STRING_INTERNAL("log2l")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// int ilogb(double x);
-TLI_DEFINE_ENUM_INTERNAL(ilogb)
-TLI_DEFINE_STRING_INTERNAL("ilogb")
-TLI_DEFINE_SIG_INTERNAL(Int, Dbl)
-
-/// int ilogbf(float x);
-TLI_DEFINE_ENUM_INTERNAL(ilogbf)
-TLI_DEFINE_STRING_INTERNAL("ilogbf")
-TLI_DEFINE_SIG_INTERNAL(Int, Flt)
-
-/// int ilogbl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(ilogbl)
-TLI_DEFINE_STRING_INTERNAL("ilogbl")
-TLI_DEFINE_SIG_INTERNAL(Int, LDbl)
-
-/// double logb(double x);
-TLI_DEFINE_ENUM_INTERNAL(logb)
-TLI_DEFINE_STRING_INTERNAL("logb")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float logbf(float x);
-TLI_DEFINE_ENUM_INTERNAL(logbf)
-TLI_DEFINE_STRING_INTERNAL("logbf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double logbl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(logbl)
-TLI_DEFINE_STRING_INTERNAL("logbl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// float logf(float x);
-TLI_DEFINE_ENUM_INTERNAL(logf)
-TLI_DEFINE_STRING_INTERNAL("logf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double logl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(logl)
-TLI_DEFINE_STRING_INTERNAL("logl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// int lstat(const char *path, struct stat *buf);
-TLI_DEFINE_ENUM_INTERNAL(lstat)
-TLI_DEFINE_STRING_INTERNAL("lstat")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// int lstat64(const char *path, struct stat64 *buf);
-TLI_DEFINE_ENUM_INTERNAL(lstat64)
-TLI_DEFINE_STRING_INTERNAL("lstat64")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// void *malloc(size_t size);
-TLI_DEFINE_ENUM_INTERNAL(malloc)
-TLI_DEFINE_STRING_INTERNAL("malloc")
-TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT)
-
-/// void *memalign(size_t boundary, size_t size);
-TLI_DEFINE_ENUM_INTERNAL(memalign)
-TLI_DEFINE_STRING_INTERNAL("memalign")
-TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT, SizeT)
-
-/// void *memccpy(void *s1, const void *s2, int c, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(memccpy)
-TLI_DEFINE_STRING_INTERNAL("memccpy")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, Int, SizeT)
-
-/// void *memchr(const void *s, int c, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(memchr)
-TLI_DEFINE_STRING_INTERNAL("memchr")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, SizeT)
-
-/// int memcmp(const void *s1, const void *s2, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(memcmp)
-TLI_DEFINE_STRING_INTERNAL("memcmp")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, SizeT)
-
-/// void *memcpy(void *s1, const void *s2, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(memcpy)
-TLI_DEFINE_STRING_INTERNAL("memcpy")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
-
-/// void *memmove(void *s1, const void *s2, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(memmove)
-TLI_DEFINE_STRING_INTERNAL("memmove")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
-
-/// void *mempcpy(void *s1, const void *s2, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(mempcpy)
-TLI_DEFINE_STRING_INTERNAL("mempcpy")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
-
-/// void *memrchr(const void *s, int c, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(memrchr)
-TLI_DEFINE_STRING_INTERNAL("memrchr")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, SizeT)
-
-/// void *memset(void *b, int c, size_t len);
-TLI_DEFINE_ENUM_INTERNAL(memset)
-TLI_DEFINE_STRING_INTERNAL("memset")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, SizeT)
-
-/// void memset_pattern16(void *b, const void *pattern16, size_t len);
-TLI_DEFINE_ENUM_INTERNAL(memset_pattern16)
-TLI_DEFINE_STRING_INTERNAL("memset_pattern16")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr, SizeT)
-
-/// void memset_pattern4(void *b, const void *pattern4, size_t len);
-TLI_DEFINE_ENUM_INTERNAL(memset_pattern4)
-TLI_DEFINE_STRING_INTERNAL("memset_pattern4")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr, SizeT)
-
-/// void memset_pattern8(void *b, const void *pattern8, size_t len);
-TLI_DEFINE_ENUM_INTERNAL(memset_pattern8)
-TLI_DEFINE_STRING_INTERNAL("memset_pattern8")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr, SizeT)
-
-/// int mkdir(const char *path, mode_t mode);
-TLI_DEFINE_ENUM_INTERNAL(mkdir)
-TLI_DEFINE_STRING_INTERNAL("mkdir")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX)
-
-/// time_t mktime(struct tm *timeptr);
-TLI_DEFINE_ENUM_INTERNAL(mktime)
-TLI_DEFINE_STRING_INTERNAL("mktime")
-TLI_DEFINE_SIG_INTERNAL(IntPlus, Ptr)
-
-/// double modf(double x, double *iptr);
-TLI_DEFINE_ENUM_INTERNAL(modf)
-TLI_DEFINE_STRING_INTERNAL("modf")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Ptr)
-
-/// float modff(float, float *iptr);
-TLI_DEFINE_ENUM_INTERNAL(modff)
-TLI_DEFINE_STRING_INTERNAL("modff")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Ptr)
-
-/// long double modfl(long double value, long double *iptr);
-TLI_DEFINE_ENUM_INTERNAL(modfl)
-TLI_DEFINE_STRING_INTERNAL("modfl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, Ptr)
-
-/// double nan(const char *arg);
-TLI_DEFINE_ENUM_INTERNAL(nan)
-TLI_DEFINE_STRING_INTERNAL("nan")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Ptr)
-
-/// float nanf(const char *arg);
-TLI_DEFINE_ENUM_INTERNAL(nanf)
-TLI_DEFINE_STRING_INTERNAL("nanf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Ptr)
-
-/// long double nanl(const char *arg);
-TLI_DEFINE_ENUM_INTERNAL(nanl)
-TLI_DEFINE_STRING_INTERNAL("nanl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, Ptr)
-
-/// double nearbyint(double x);
-TLI_DEFINE_ENUM_INTERNAL(nearbyint)
-TLI_DEFINE_STRING_INTERNAL("nearbyint")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float nearbyintf(float x);
-TLI_DEFINE_ENUM_INTERNAL(nearbyintf)
-TLI_DEFINE_STRING_INTERNAL("nearbyintf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double nearbyintl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(nearbyintl)
-TLI_DEFINE_STRING_INTERNAL("nearbyintl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// uint32_t ntohl(uint32_t netlong);
-TLI_DEFINE_ENUM_INTERNAL(ntohl)
-TLI_DEFINE_STRING_INTERNAL("ntohl")
-TLI_DEFINE_SIG_INTERNAL(Int32, Int32)
-
-/// uint16_t ntohs(uint16_t netshort);
-TLI_DEFINE_ENUM_INTERNAL(ntohs)
-TLI_DEFINE_STRING_INTERNAL("ntohs")
-TLI_DEFINE_SIG_INTERNAL(Int16, Int16)
-
-/// int open(const char *path, int oflag, ... );
-TLI_DEFINE_ENUM_INTERNAL(open)
-TLI_DEFINE_STRING_INTERNAL("open")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int, Ellip)
-
-/// int open64(const char *filename, int flags[, mode_t mode])
-TLI_DEFINE_ENUM_INTERNAL(open64)
-TLI_DEFINE_STRING_INTERNAL("open64")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int, Ellip)
-
-/// DIR *opendir(const char *dirname);
-TLI_DEFINE_ENUM_INTERNAL(opendir)
-TLI_DEFINE_STRING_INTERNAL("opendir")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr)
-
-/// int pclose(FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(pclose)
-TLI_DEFINE_STRING_INTERNAL("pclose")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// void perror(const char *s);
-TLI_DEFINE_ENUM_INTERNAL(perror)
-TLI_DEFINE_STRING_INTERNAL("perror")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// FILE *popen(const char *command, const char *mode);
-TLI_DEFINE_ENUM_INTERNAL(popen)
-TLI_DEFINE_STRING_INTERNAL("popen")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
-
-/// int posix_memalign(void **memptr, size_t alignment, size_t size);
-TLI_DEFINE_ENUM_INTERNAL(posix_memalign)
-TLI_DEFINE_STRING_INTERNAL("posix_memalign")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, SizeT)
-
-/// double pow(double x, double y);
-TLI_DEFINE_ENUM_INTERNAL(pow)
-TLI_DEFINE_STRING_INTERNAL("pow")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
-
-/// float powf(float x, float y);
-TLI_DEFINE_ENUM_INTERNAL(powf)
-TLI_DEFINE_STRING_INTERNAL("powf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
-
-/// long double powl(long double x, long double y);
-TLI_DEFINE_ENUM_INTERNAL(powl)
-TLI_DEFINE_STRING_INTERNAL("powl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
-
-/// ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
-TLI_DEFINE_ENUM_INTERNAL(pread)
-TLI_DEFINE_STRING_INTERNAL("pread")
-TLI_DEFINE_SIG_INTERNAL(SSizeT, Int, Ptr, SizeT, IntPlus)
-
-/// int printf(const char *format, ...);
-TLI_DEFINE_ENUM_INTERNAL(printf)
-TLI_DEFINE_STRING_INTERNAL("printf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip)
-
-/// int putc(int c, FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(putc)
-TLI_DEFINE_STRING_INTERNAL("putc")
-TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
-
-/// int putc_unlocked(int c, FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(putc_unlocked)
-TLI_DEFINE_STRING_INTERNAL("putc_unlocked")
-TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
-
-/// int putchar(int c);
-TLI_DEFINE_ENUM_INTERNAL(putchar)
-TLI_DEFINE_STRING_INTERNAL("putchar")
-TLI_DEFINE_SIG_INTERNAL(Int, Int)
-
-/// int putchar_unlocked(int c);
-TLI_DEFINE_ENUM_INTERNAL(putchar_unlocked)
-TLI_DEFINE_STRING_INTERNAL("putchar_unlocked")
-TLI_DEFINE_SIG_INTERNAL(Int, Int)
-
-/// int puts(const char *s);
-TLI_DEFINE_ENUM_INTERNAL(puts)
-TLI_DEFINE_STRING_INTERNAL("puts")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// void *pvalloc(size_t size);
-TLI_DEFINE_ENUM_INTERNAL(pvalloc)
-TLI_DEFINE_STRING_INTERNAL("pvalloc")
-TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT)
-
-/// ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
-TLI_DEFINE_ENUM_INTERNAL(pwrite)
-TLI_DEFINE_STRING_INTERNAL("pwrite")
-TLI_DEFINE_SIG_INTERNAL(SSizeT, Int, Ptr, SizeT, IntPlus)
-
-/// void qsort(void *base, size_t nel, size_t width,
-///            int (*compar)(const void *, const void *));
-TLI_DEFINE_ENUM_INTERNAL(qsort)
-TLI_DEFINE_STRING_INTERNAL("qsort")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, SizeT, SizeT, Ptr)
-
-/// ssize_t read(int fildes, void *buf, size_t nbyte);
-TLI_DEFINE_ENUM_INTERNAL(read)
-TLI_DEFINE_STRING_INTERNAL("read")
-TLI_DEFINE_SIG_INTERNAL(SSizeT, Int, Ptr, SizeT)
-
-/// ssize_t readlink(const char *path, char *buf, size_t bufsize);
-TLI_DEFINE_ENUM_INTERNAL(readlink)
-TLI_DEFINE_STRING_INTERNAL("readlink")
-TLI_DEFINE_SIG_INTERNAL(SSizeT, Ptr, Ptr, SizeT)
-
-/// void *realloc(void *ptr, size_t size);
-TLI_DEFINE_ENUM_INTERNAL(realloc)
-TLI_DEFINE_STRING_INTERNAL("realloc")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT)
-
-/// void *reallocf(void *ptr, size_t size);
-TLI_DEFINE_ENUM_INTERNAL(reallocf)
-TLI_DEFINE_STRING_INTERNAL("reallocf")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT)
-
-/// void *reallocarray(void *ptr, size_t nmemb, size_t size);
-TLI_DEFINE_ENUM_INTERNAL(reallocarray)
-TLI_DEFINE_STRING_INTERNAL("reallocarray")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT, SizeT)
-
-/// char *realpath(const char *file_name, char *resolved_name);
-TLI_DEFINE_ENUM_INTERNAL(realpath)
-TLI_DEFINE_STRING_INTERNAL("realpath")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
-
-/// double remainder(double x, double y);
-TLI_DEFINE_ENUM_INTERNAL(remainder)
-TLI_DEFINE_STRING_INTERNAL("remainder")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
-
-/// float remainderf(float x, float y);
-TLI_DEFINE_ENUM_INTERNAL(remainderf)
-TLI_DEFINE_STRING_INTERNAL("remainderf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
-
-/// long double remainderl(long double x, long double y);
-TLI_DEFINE_ENUM_INTERNAL(remainderl)
-TLI_DEFINE_STRING_INTERNAL("remainderl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
-
-/// double remquo(double x, double y, int *quo);
-TLI_DEFINE_ENUM_INTERNAL(remquo)
-TLI_DEFINE_STRING_INTERNAL("remquo")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl, Ptr)
-
-/// float remquof(float x, float y, int *quo);
-TLI_DEFINE_ENUM_INTERNAL(remquof)
-TLI_DEFINE_STRING_INTERNAL("remquof")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt, Ptr)
-
-/// long double remquol(long double x, long double y, int *quo);
-TLI_DEFINE_ENUM_INTERNAL(remquol)
-TLI_DEFINE_STRING_INTERNAL("remquol")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl, Ptr)
-
-/// double fdim(double x, double y);
-TLI_DEFINE_ENUM_INTERNAL(fdim)
-TLI_DEFINE_STRING_INTERNAL("fdim")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
-
-/// float fdimf(float x, float y);
-TLI_DEFINE_ENUM_INTERNAL(fdimf)
-TLI_DEFINE_STRING_INTERNAL("fdimf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
-
-/// long double fdiml(long double x, long double y);
-TLI_DEFINE_ENUM_INTERNAL(fdiml)
-TLI_DEFINE_STRING_INTERNAL("fdiml")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
-
-/// int remove(const char *path);
-TLI_DEFINE_ENUM_INTERNAL(remove)
-TLI_DEFINE_STRING_INTERNAL("remove")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// int rename(const char *old, const char *new);
-TLI_DEFINE_ENUM_INTERNAL(rename)
-TLI_DEFINE_STRING_INTERNAL("rename")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// void rewind(FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(rewind)
-TLI_DEFINE_STRING_INTERNAL("rewind")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// double rint(double x);
-TLI_DEFINE_ENUM_INTERNAL(rint)
-TLI_DEFINE_STRING_INTERNAL("rint")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float rintf(float x);
-TLI_DEFINE_ENUM_INTERNAL(rintf)
-TLI_DEFINE_STRING_INTERNAL("rintf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double rintl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(rintl)
-TLI_DEFINE_STRING_INTERNAL("rintl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// int rmdir(const char *path);
-TLI_DEFINE_ENUM_INTERNAL(rmdir)
-TLI_DEFINE_STRING_INTERNAL("rmdir")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// double round(double x);
-TLI_DEFINE_ENUM_INTERNAL(round)
-TLI_DEFINE_STRING_INTERNAL("round")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// double roundeven(double x);
-TLI_DEFINE_ENUM_INTERNAL(roundeven)
-TLI_DEFINE_STRING_INTERNAL("roundeven")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float roundevenf(float x);
-TLI_DEFINE_ENUM_INTERNAL(roundevenf)
-TLI_DEFINE_STRING_INTERNAL("roundevenf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double roundevenl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(roundevenl)
-TLI_DEFINE_STRING_INTERNAL("roundevenl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// float roundf(float x);
-TLI_DEFINE_ENUM_INTERNAL(roundf)
-TLI_DEFINE_STRING_INTERNAL("roundf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double roundl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(roundl)
-TLI_DEFINE_STRING_INTERNAL("roundl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// double scalbln(double arg, long exp);
-TLI_DEFINE_ENUM_INTERNAL(scalbln)
-TLI_DEFINE_STRING_INTERNAL("scalbln")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Long)
-
-/// float scalblnf(float arg, long exp);
-TLI_DEFINE_ENUM_INTERNAL(scalblnf)
-TLI_DEFINE_STRING_INTERNAL("scalblnf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Long)
-
-/// long double scalblnl(long double arg, long exp);
-TLI_DEFINE_ENUM_INTERNAL(scalblnl)
-TLI_DEFINE_STRING_INTERNAL("scalblnl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, Long)
-
-/// double scalbn(double arg, int exp);
-TLI_DEFINE_ENUM_INTERNAL(scalbn)
-TLI_DEFINE_STRING_INTERNAL("scalbn")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Int)
-
-/// float scalbnf(float arg, int exp);
-TLI_DEFINE_ENUM_INTERNAL(scalbnf)
-TLI_DEFINE_STRING_INTERNAL("scalbnf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Int)
-
-/// long double scalbnl(long double arg, int exp);
-TLI_DEFINE_ENUM_INTERNAL(scalbnl)
-TLI_DEFINE_STRING_INTERNAL("scalbnl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, Int)
-
-/// int scanf(const char *restrict format, ... );
-TLI_DEFINE_ENUM_INTERNAL(scanf)
-TLI_DEFINE_STRING_INTERNAL("scanf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip)
-
-/// void setbuf(FILE *stream, char *buf);
-TLI_DEFINE_ENUM_INTERNAL(setbuf)
-TLI_DEFINE_STRING_INTERNAL("setbuf")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr)
-
-/// int setitimer(int which, const struct itimerval *value,
-///               struct itimerval *ovalue);
-TLI_DEFINE_ENUM_INTERNAL(setitimer)
-TLI_DEFINE_STRING_INTERNAL("setitimer")
-TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr, Ptr)
-
-/// int setvbuf(FILE *stream, char *buf, int type, size_t size);
-TLI_DEFINE_ENUM_INTERNAL(setvbuf)
-TLI_DEFINE_STRING_INTERNAL("setvbuf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Int, SizeT)
-
-/// double sin(double x);
-TLI_DEFINE_ENUM_INTERNAL(sin)
-TLI_DEFINE_STRING_INTERNAL("sin")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float sinf(float x);
-TLI_DEFINE_ENUM_INTERNAL(sinf)
-TLI_DEFINE_STRING_INTERNAL("sinf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// double sinh(double x);
-TLI_DEFINE_ENUM_INTERNAL(sinh)
-TLI_DEFINE_STRING_INTERNAL("sinh")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float sinhf(float x);
-TLI_DEFINE_ENUM_INTERNAL(sinhf)
-TLI_DEFINE_STRING_INTERNAL("sinhf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double sinhl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(sinhl)
-TLI_DEFINE_STRING_INTERNAL("sinhl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// long double sinl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(sinl)
-TLI_DEFINE_STRING_INTERNAL("sinl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// void sincos(double x, double *sin_out, double *cos_out);
-TLI_DEFINE_ENUM_INTERNAL(sincos)
-TLI_DEFINE_STRING_INTERNAL("sincos")
-TLI_DEFINE_SIG_INTERNAL(Void, Dbl, Ptr, Ptr)
-
-/// void sincosf(float x, float *sin_out, float *cos_out);
-TLI_DEFINE_ENUM_INTERNAL(sincosf)
-TLI_DEFINE_STRING_INTERNAL("sincosf")
-TLI_DEFINE_SIG_INTERNAL(Void, Flt, Ptr, Ptr)
-
-/// void sincosl(long double x, long double *sin_out, long double *cos_out);
-TLI_DEFINE_ENUM_INTERNAL(sincosl)
-TLI_DEFINE_STRING_INTERNAL("sincosl")
-TLI_DEFINE_SIG_INTERNAL(Void, LDbl, Ptr, Ptr)
-
-/// int siprintf(char *str, const char *format, ...);
-TLI_DEFINE_ENUM_INTERNAL(siprintf)
-TLI_DEFINE_STRING_INTERNAL("siprintf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
-
-/// int snprintf(char *s, size_t n, const char *format, ...);
-TLI_DEFINE_ENUM_INTERNAL(snprintf)
-TLI_DEFINE_STRING_INTERNAL("snprintf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, Ptr, Ellip)
-
-/// int sprintf(char *str, const char *format, ...);
-TLI_DEFINE_ENUM_INTERNAL(sprintf)
-TLI_DEFINE_STRING_INTERNAL("sprintf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
-
-/// double sqrt(double x);
-TLI_DEFINE_ENUM_INTERNAL(sqrt)
-TLI_DEFINE_STRING_INTERNAL("sqrt")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float sqrtf(float x);
-TLI_DEFINE_ENUM_INTERNAL(sqrtf)
-TLI_DEFINE_STRING_INTERNAL("sqrtf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double sqrtl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(sqrtl)
-TLI_DEFINE_STRING_INTERNAL("sqrtl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// int sscanf(const char *s, const char *format, ... );
-TLI_DEFINE_ENUM_INTERNAL(sscanf)
-TLI_DEFINE_STRING_INTERNAL("sscanf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
-
-/// int stat(const char *path, struct stat *buf);
-TLI_DEFINE_ENUM_INTERNAL(stat)
-TLI_DEFINE_STRING_INTERNAL("stat")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// int stat64(const char *path, struct stat64 *buf);
-TLI_DEFINE_ENUM_INTERNAL(stat64)
-TLI_DEFINE_STRING_INTERNAL("stat64")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// int statvfs(const char *path, struct statvfs *buf);
-TLI_DEFINE_ENUM_INTERNAL(statvfs)
-TLI_DEFINE_STRING_INTERNAL("statvfs")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// int statvfs64(const char *path, struct statvfs64 *buf)
-TLI_DEFINE_ENUM_INTERNAL(statvfs64)
-TLI_DEFINE_STRING_INTERNAL("statvfs64")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// char *stpcpy(char *s1, const char *s2);
-TLI_DEFINE_ENUM_INTERNAL(stpcpy)
-TLI_DEFINE_STRING_INTERNAL("stpcpy")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
-
-/// char *stpncpy(char *s1, const char *s2, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(stpncpy)
-TLI_DEFINE_STRING_INTERNAL("stpncpy")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
-
-/// int strcasecmp(const char *s1, const char *s2);
-TLI_DEFINE_ENUM_INTERNAL(strcasecmp)
-TLI_DEFINE_STRING_INTERNAL("strcasecmp")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// char *strcat(char *s1, const char *s2);
-TLI_DEFINE_ENUM_INTERNAL(strcat)
-TLI_DEFINE_STRING_INTERNAL("strcat")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
-
-/// char *strchr(const char *s, int c);
-TLI_DEFINE_ENUM_INTERNAL(strchr)
-TLI_DEFINE_STRING_INTERNAL("strchr")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int)
-
-/// int strcmp(const char *s1, const char *s2);
-TLI_DEFINE_ENUM_INTERNAL(strcmp)
-TLI_DEFINE_STRING_INTERNAL("strcmp")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// int strcoll(const char *s1, const char *s2);
-TLI_DEFINE_ENUM_INTERNAL(strcoll)
-TLI_DEFINE_STRING_INTERNAL("strcoll")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// char *strcpy(char *s1, const char *s2);
-TLI_DEFINE_ENUM_INTERNAL(strcpy)
-TLI_DEFINE_STRING_INTERNAL("strcpy")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
-
-/// size_t strcspn(const char *s1, const char *s2);
-TLI_DEFINE_ENUM_INTERNAL(strcspn)
-TLI_DEFINE_STRING_INTERNAL("strcspn")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr)
-
-/// char *strdup(const char *s1);
-TLI_DEFINE_ENUM_INTERNAL(strdup)
-TLI_DEFINE_STRING_INTERNAL("strdup")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr)
-
-/// size_t strlcat(char *dst, const char *src, size_t size);
-TLI_DEFINE_ENUM_INTERNAL(strlcat)
-TLI_DEFINE_STRING_INTERNAL("strlcat")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT)
-
-/// size_t strlcpy(char *dst, const char *src, size_t size);
-TLI_DEFINE_ENUM_INTERNAL(strlcpy)
-TLI_DEFINE_STRING_INTERNAL("strlcpy")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT)
-
-/// size_t strlen(const char *s);
-TLI_DEFINE_ENUM_INTERNAL(strlen)
-TLI_DEFINE_STRING_INTERNAL("strlen")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr)
-
-/// int strncasecmp(const char *s1, const char *s2, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(strncasecmp)
-TLI_DEFINE_STRING_INTERNAL("strncasecmp")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, SizeT)
-
-/// char *strncat(char *s1, const char *s2, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(strncat)
-TLI_DEFINE_STRING_INTERNAL("strncat")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
-
-/// int strncmp(const char *s1, const char *s2, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(strncmp)
-TLI_DEFINE_STRING_INTERNAL("strncmp")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, SizeT)
-
-/// char *strncpy(char *s1, const char *s2, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(strncpy)
-TLI_DEFINE_STRING_INTERNAL("strncpy")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
-
-/// char *strndup(const char *s1, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(strndup)
-TLI_DEFINE_STRING_INTERNAL("strndup")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT)
-
-/// size_t strnlen(const char *s, size_t maxlen);
-TLI_DEFINE_ENUM_INTERNAL(strnlen)
-TLI_DEFINE_STRING_INTERNAL("strnlen")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT)
-
-/// char *strpbrk(const char *s1, const char *s2);
-TLI_DEFINE_ENUM_INTERNAL(strpbrk)
-TLI_DEFINE_STRING_INTERNAL("strpbrk")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
-
-/// char *strrchr(const char *s, int c);
-TLI_DEFINE_ENUM_INTERNAL(strrchr)
-TLI_DEFINE_STRING_INTERNAL("strrchr")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int)
-
-/// size_t strspn(const char *s1, const char *s2);
-TLI_DEFINE_ENUM_INTERNAL(strspn)
-TLI_DEFINE_STRING_INTERNAL("strspn")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr)
-
-/// char *strstr(const char *s1, const char *s2);
-TLI_DEFINE_ENUM_INTERNAL(strstr)
-TLI_DEFINE_STRING_INTERNAL("strstr")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
-
-/// double strtod(const char *nptr, char **endptr);
-TLI_DEFINE_ENUM_INTERNAL(strtod)
-TLI_DEFINE_STRING_INTERNAL("strtod")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Ptr, Ptr)
-
-/// float strtof(const char *nptr, char **endptr);
-TLI_DEFINE_ENUM_INTERNAL(strtof)
-TLI_DEFINE_STRING_INTERNAL("strtof")
-TLI_DEFINE_SIG_INTERNAL(Flt, Ptr, Ptr)
-
-/// char *strtok(char *s1, const char *s2);
-TLI_DEFINE_ENUM_INTERNAL(strtok)
-TLI_DEFINE_STRING_INTERNAL("strtok")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
-
-/// char *strtok_r(char *s, const char *sep, char **lasts);
-TLI_DEFINE_ENUM_INTERNAL(strtok_r)
-TLI_DEFINE_STRING_INTERNAL("strtok_r")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, Ptr)
-
-/// long int strtol(const char *nptr, char **endptr, int base);
-TLI_DEFINE_ENUM_INTERNAL(strtol)
-TLI_DEFINE_STRING_INTERNAL("strtol")
-TLI_DEFINE_SIG_INTERNAL(Long, Ptr, Ptr, Int)
-
-/// long double strtold(const char *nptr, char **endptr);
-TLI_DEFINE_ENUM_INTERNAL(strtold)
-TLI_DEFINE_STRING_INTERNAL("strtold")
-TLI_DEFINE_SIG_INTERNAL(LDbl, Ptr, Ptr)
-
-/// long long int strtoll(const char *nptr, char **endptr, int base);
-TLI_DEFINE_ENUM_INTERNAL(strtoll)
-TLI_DEFINE_STRING_INTERNAL("strtoll")
-TLI_DEFINE_SIG_INTERNAL(LLong, Ptr, Ptr, Int)
-
-/// unsigned long int strtoul(const char *nptr, char **endptr, int base);
-TLI_DEFINE_ENUM_INTERNAL(strtoul)
-TLI_DEFINE_STRING_INTERNAL("strtoul")
-TLI_DEFINE_SIG_INTERNAL(Long, Ptr, Ptr, Int)
-
-/// unsigned long long int strtoull(const char *nptr, char **endptr, int base);
-TLI_DEFINE_ENUM_INTERNAL(strtoull)
-TLI_DEFINE_STRING_INTERNAL("strtoull")
-TLI_DEFINE_SIG_INTERNAL(LLong, Ptr, Ptr, Int)
-
-/// size_t strxfrm(char *s1, const char *s2, size_t n);
-TLI_DEFINE_ENUM_INTERNAL(strxfrm)
-TLI_DEFINE_STRING_INTERNAL("strxfrm")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT)
-
-/// int system(const char *command);
-TLI_DEFINE_ENUM_INTERNAL(system)
-TLI_DEFINE_STRING_INTERNAL("system")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// double tan(double x);
-TLI_DEFINE_ENUM_INTERNAL(tan)
-TLI_DEFINE_STRING_INTERNAL("tan")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float tanf(float x);
-TLI_DEFINE_ENUM_INTERNAL(tanf)
-TLI_DEFINE_STRING_INTERNAL("tanf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// double tanh(double x);
-TLI_DEFINE_ENUM_INTERNAL(tanh)
-TLI_DEFINE_STRING_INTERNAL("tanh")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float tanhf(float x);
-TLI_DEFINE_ENUM_INTERNAL(tanhf)
-TLI_DEFINE_STRING_INTERNAL("tanhf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double tanhl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(tanhl)
-TLI_DEFINE_STRING_INTERNAL("tanhl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// long double tanl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(tanl)
-TLI_DEFINE_STRING_INTERNAL("tanl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// clock_t times(struct tms *buffer);
-TLI_DEFINE_ENUM_INTERNAL(times)
-TLI_DEFINE_STRING_INTERNAL("times")
-TLI_DEFINE_SIG_INTERNAL(IntPlus, Ptr)
-
-/// FILE *tmpfile(void);
-TLI_DEFINE_ENUM_INTERNAL(tmpfile)
-TLI_DEFINE_STRING_INTERNAL("tmpfile")
-TLI_DEFINE_SIG_INTERNAL(Ptr)
-
-/// FILE *tmpfile64(void)
-TLI_DEFINE_ENUM_INTERNAL(tmpfile64)
-TLI_DEFINE_STRING_INTERNAL("tmpfile64")
-TLI_DEFINE_SIG_INTERNAL(Ptr)
-
-/// int toascii(int c);
-TLI_DEFINE_ENUM_INTERNAL(toascii)
-TLI_DEFINE_STRING_INTERNAL("toascii")
-TLI_DEFINE_SIG_INTERNAL(Int, Int)
-
-/// double trunc(double x);
-TLI_DEFINE_ENUM_INTERNAL(trunc)
-TLI_DEFINE_STRING_INTERNAL("trunc")
-TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
-
-/// float truncf(float x);
-TLI_DEFINE_ENUM_INTERNAL(truncf)
-TLI_DEFINE_STRING_INTERNAL("truncf")
-TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
-
-/// long double truncl(long double x);
-TLI_DEFINE_ENUM_INTERNAL(truncl)
-TLI_DEFINE_STRING_INTERNAL("truncl")
-TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
-
-/// int uname(struct utsname *name);
-TLI_DEFINE_ENUM_INTERNAL(uname)
-TLI_DEFINE_STRING_INTERNAL("uname")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// int ungetc(int c, FILE *stream);
-TLI_DEFINE_ENUM_INTERNAL(ungetc)
-TLI_DEFINE_STRING_INTERNAL("ungetc")
-TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
-
-/// int unlink(const char *path);
-TLI_DEFINE_ENUM_INTERNAL(unlink)
-TLI_DEFINE_STRING_INTERNAL("unlink")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// int unsetenv(const char *name);
-TLI_DEFINE_ENUM_INTERNAL(unsetenv)
-TLI_DEFINE_STRING_INTERNAL("unsetenv")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
-
-/// int utime(const char *path, const struct utimbuf *times);
-TLI_DEFINE_ENUM_INTERNAL(utime)
-TLI_DEFINE_STRING_INTERNAL("utime")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// int utimes(const char *path, const struct timeval times[2]);
-TLI_DEFINE_ENUM_INTERNAL(utimes)
-TLI_DEFINE_STRING_INTERNAL("utimes")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// void *valloc(size_t size);
-TLI_DEFINE_ENUM_INTERNAL(valloc)
-TLI_DEFINE_STRING_INTERNAL("valloc")
-TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT)
-
-/// void *vec_calloc(size_t count, size_t size);
-TLI_DEFINE_ENUM_INTERNAL(vec_calloc)
-TLI_DEFINE_STRING_INTERNAL("vec_calloc")
-TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT, SizeT)
-
-/// void vec_free(void *ptr);
-TLI_DEFINE_ENUM_INTERNAL(vec_free)
-TLI_DEFINE_STRING_INTERNAL("vec_free")
-TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
-
-/// void *vec_malloc(size_t size);
-TLI_DEFINE_ENUM_INTERNAL(vec_malloc)
-TLI_DEFINE_STRING_INTERNAL("vec_malloc")
-TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT)
-
-/// void *vec_realloc(void *ptr, size_t size);
-TLI_DEFINE_ENUM_INTERNAL(vec_realloc)
-TLI_DEFINE_STRING_INTERNAL("vec_realloc")
-TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT)
-
-/// int vfprintf(FILE *stream, const char *format, va_list ap);
-TLI_DEFINE_ENUM_INTERNAL(vfprintf)
-TLI_DEFINE_STRING_INTERNAL("vfprintf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
-
-/// int vfscanf(FILE *stream, const char *format, va_list arg);
-TLI_DEFINE_ENUM_INTERNAL(vfscanf)
-TLI_DEFINE_STRING_INTERNAL("vfscanf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
-
-/// int vprintf(const char *restrict format, va_list ap);
-TLI_DEFINE_ENUM_INTERNAL(vprintf)
-TLI_DEFINE_STRING_INTERNAL("vprintf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// int vscanf(const char *format, va_list arg);
-TLI_DEFINE_ENUM_INTERNAL(vscanf)
-TLI_DEFINE_STRING_INTERNAL("vscanf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
-
-/// int vsnprintf(char *s, size_t n, const char *format, va_list ap);
-TLI_DEFINE_ENUM_INTERNAL(vsnprintf)
-TLI_DEFINE_STRING_INTERNAL("vsnprintf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, Ptr, Ptr)
-
-/// int vsprintf(char *s, const char *format, va_list ap);
-TLI_DEFINE_ENUM_INTERNAL(vsprintf)
-TLI_DEFINE_STRING_INTERNAL("vsprintf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
-
-/// int vsscanf(const char *s, const char *format, va_list arg);
-TLI_DEFINE_ENUM_INTERNAL(vsscanf)
-TLI_DEFINE_STRING_INTERNAL("vsscanf")
-TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
-
-/// size_t wcslen (const wchar_t* wcs);
-TLI_DEFINE_ENUM_INTERNAL(wcslen)
-TLI_DEFINE_STRING_INTERNAL("wcslen")
-TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr)
-
-/// ssize_t write(int fildes, const void *buf, size_t nbyte);
-TLI_DEFINE_ENUM_INTERNAL(write)
-TLI_DEFINE_STRING_INTERNAL("write")
-TLI_DEFINE_SIG_INTERNAL(SSizeT, Int, Ptr, SizeT)
-
-#undef TLI_DEFINE_ENUM_INTERNAL
-#undef TLI_DEFINE_STRING_INTERNAL
-#undef TLI_DEFINE_SIG_INTERNAL
-#endif  // One of TLI_DEFINE_ENUM/STRING are defined.
-
-#undef TLI_DEFINE_ENUM
-#undef TLI_DEFINE_STRING
-#undef TLI_DEFINE_SIG
diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.h b/llvm/include/llvm/Analysis/TargetLibraryInfo.h
index 3f39b4787eb11..a5de3564d632a 100644
--- a/llvm/include/llvm/Analysis/TargetLibraryInfo.h
+++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.h
@@ -10,6 +10,7 @@
 #define LLVM_ANALYSIS_TARGETLIBRARYINFO_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/StringTable.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Module.h"
@@ -69,13 +70,8 @@ class VecDesc {
   LLVM_ABI std::string getVectorFunctionABIVariantString() const;
 };
 
-  enum LibFunc : unsigned {
-#define TLI_DEFINE_ENUM
-#include "llvm/Analysis/TargetLibraryInfo.def"
-
-    NumLibFuncs,
-    NotLibFunc
-  };
+#define GET_TARGET_LIBRARY_INFO_ENUM
+#include "llvm/Analysis/TargetLibraryInfo.inc"
 
 /// Implementation of the target library information.
 ///
@@ -88,7 +84,8 @@ class TargetLibraryInfoImpl {
 
   unsigned char AvailableArray[(NumLibFuncs+3)/4];
   DenseMap<unsigned, std::string> CustomNames;
-  LLVM_ABI static StringLiteral const StandardNames[NumLibFuncs];
+#define GET_TARGET_LIBRARY_INFO_IMPL_DECL
+#include "llvm/Analysis/TargetLibraryInfo.inc"
   bool ShouldExtI32Param, ShouldExtI32Return, ShouldSignExtI32Param, ShouldSignExtI32Return;
   unsigned SizeOfInt;
 
@@ -177,7 +174,7 @@ class TargetLibraryInfoImpl {
   /// Forces a function to be marked as available and provide an alternate name
   /// that must be used.
   void setAvailableWithName(LibFunc F, StringRef Name) {
-    if (StandardNames[F] != Name) {
+    if (StandardNamesStrTable.getCString(StandardNamesOffsets[F]) != Name) {
       setState(F, CustomName);
       CustomNames[F] = std::string(Name);
       assert(CustomNames.contains(F));
@@ -455,7 +452,8 @@ class TargetLibraryInfo {
   /// Return the canonical name for a LibFunc. This should not be used for
   /// semantic purposes, use getName instead.
   static StringRef getStandardName(LibFunc F) {
-    return TargetLibraryInfoImpl::StandardNames[F];
+    return TargetLibraryInfoImpl::StandardNamesStrTable.getCString(
+        TargetLibraryInfoImpl::StandardNamesOffsets[F]);
   }
 
   StringRef getName(LibFunc F) const {
@@ -463,7 +461,8 @@ class TargetLibraryInfo {
     if (State == TargetLibraryInfoImpl::Unavailable)
       return StringRef();
     if (State == TargetLibraryInfoImpl::StandardName)
-      return Impl->StandardNames[F];
+      return Impl->StandardNamesStrTable.getCString(
+          Impl->StandardNamesOffsets[F]);
     assert(State == TargetLibraryInfoImpl::CustomName);
     return Impl->CustomNames.find(F)->second;
   }
diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.td b/llvm/include/llvm/Analysis/TargetLibraryInfo.td
new file mode 100644
index 0000000000000..e2511adb26b14
--- /dev/null
+++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.td
@@ -0,0 +1,1599 @@
+//===-- TargetLibraryInfo.td - File that describes library functions ------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+include "llvm/Analysis/TargetLibraryInfoImpl.td"
+
+/// void *operator new(unsigned int);
+def msvc_new_int : TargetLibCall< "??2 at YAPAXI@Z", [Ptr, Int]>;
+
+/// void *operator new(unsigned int, const std::nothrow_t&);
+def msvc_new_int_nothrow : TargetLibCall< "??2 at YAPAXIABUnothrow_t@std@@@Z", [Ptr, Int, Ptr]>;
+
+/// void *operator new(unsigned long long);
+def msvc_new_longlong : TargetLibCall< "??2 at YAPEAX_K@Z", [Ptr, LLong]>;
+
+/// void *operator new(unsigned long long, const std::nothrow_t&);
+def msvc_new_longlong_nothrow : TargetLibCall< "??2 at YAPEAX_KAEBUnothrow_t@std@@@Z", [Ptr, LLong, Ptr]>;
+
+/// void operator delete(void*);
+def msvc_delete_ptr32 : TargetLibCall< "??3 at YAXPAX@Z", [Void, Ptr]>;
+
+/// void operator delete(void*, const std::nothrow_t&);
+def msvc_delete_ptr32_nothrow : TargetLibCall< "??3 at YAXPAXABUnothrow_t@std@@@Z", [Void, Ptr, Ptr]>;
+
+/// void operator delete(void*, unsigned int);
+def msvc_delete_ptr32_int : TargetLibCall< "??3 at YAXPAXI@Z", [Void, Ptr, Int]>;
+
+/// void operator delete(void*);
+def msvc_delete_ptr64 : TargetLibCall< "??3 at YAXPEAX@Z", [Void, Ptr]>;
+
+/// void operator delete(void*, const std::nothrow_t&);
+def msvc_delete_ptr64_nothrow : TargetLibCall< "??3 at YAXPEAXAEBUnothrow_t@std@@@Z", [Void, Ptr, Ptr]>;
+
+/// void operator delete(void*, unsigned long long);
+def msvc_delete_ptr64_longlong : TargetLibCall< "??3 at YAXPEAX_K@Z", [Void, Ptr, LLong]>;
+
+/// void *operator new[](unsigned int);
+def msvc_new_array_int : TargetLibCall< "??_U at YAPAXI@Z", [Ptr, Int]>;
+
+/// void *operator new[](unsigned int, const std::nothrow_t&);
+def msvc_new_array_int_nothrow : TargetLibCall< "??_U at YAPAXIABUnothrow_t@std@@@Z", [Ptr, Int, Ptr]>;
+
+/// void *operator new[](unsigned long long);
+def msvc_new_array_longlong : TargetLibCall< "??_U at YAPEAX_K@Z", [Ptr, LLong]>;
+
+/// void *operator new[](unsigned long long, const std::nothrow_t&);
+def msvc_new_array_longlong_nothrow : TargetLibCall< "??_U at YAPEAX_KAEBUnothrow_t@std@@@Z", [Ptr, LLong, Ptr]>;
+
+/// void operator delete[](void*);
+def msvc_delete_array_ptr32 : TargetLibCall< "??_V at YAXPAX@Z", [Void, Ptr]>;
+
+/// void operator delete[](void*, const std::nothrow_t&);
+def msvc_delete_array_ptr32_nothrow : TargetLibCall< "??_V at YAXPAXABUnothrow_t@std@@@Z", [Void, Ptr, Ptr]>;
+
+/// void operator delete[](void*, unsigned int);
+def msvc_delete_array_ptr32_int : TargetLibCall< "??_V at YAXPAXI@Z", [Void, Ptr, Int]>;
+
+/// void operator delete[](void*);
+def msvc_delete_array_ptr64 : TargetLibCall< "??_V at YAXPEAX@Z", [Void, Ptr]>;
+
+/// void operator delete[](void*, const std::nothrow_t&);
+def msvc_delete_array_ptr64_nothrow : TargetLibCall< "??_V at YAXPEAXAEBUnothrow_t@std@@@Z", [Void, Ptr, Ptr]>;
+
+/// void operator delete[](void*, unsigned long long);
+def msvc_delete_array_ptr64_longlong : TargetLibCall< "??_V at YAXPEAX_K@Z", [Void, Ptr, LLong]>;
+
+/// int _IO_getc(_IO_FILE * __fp);
+def under_IO_getc : TargetLibCall< "_IO_getc", [Int, Ptr]>;
+
+/// int _IO_putc(int __c, _IO_FILE * __fp);
+def under_IO_putc : TargetLibCall< "_IO_putc", [Int, Int, Ptr]>;
+
+/// void operator delete[](void*);
+def ZdaPv : TargetLibCall< "_ZdaPv", [Void, Ptr]>;
+
+/// void operator delete[](void*, const std::nothrow_t&);
+def ZdaPvRKSt9nothrow_t : TargetLibCall< "_ZdaPvRKSt9nothrow_t", [Void, Ptr, Ptr]>;
+
+/// void operator delete[](void*, std::align_val_t);
+def ZdaPvSt11align_val_t : TargetLibCall< "_ZdaPvSt11align_val_t", [Void, Ptr, IntPlus]>;
+
+/// void operator delete[](void*, std::align_val_t, const std::nothrow_t&)
+def ZdaPvSt11align_val_tRKSt9nothrow_t : TargetLibCall< "_ZdaPvSt11align_val_tRKSt9nothrow_t", [Void, Ptr, IntPlus, Ptr]>;
+
+/// void operator delete[](void*, unsigned int);
+def ZdaPvj : TargetLibCall< "_ZdaPvj", [Void, Ptr, Int]>;
+
+/// void operator delete[](void*, unsigned int, std::align_val_t);
+def ZdaPvjSt11align_val_t : TargetLibCall< "_ZdaPvjSt11align_val_t", [Void, Ptr, Int, Int]>;
+
+/// void operator delete[](void*, unsigned long);
+def ZdaPvm : TargetLibCall< "_ZdaPvm", [Void, Ptr, Long]>;
+
+/// void operator delete[](void*, unsigned long, std::align_val_t);
+def ZdaPvmSt11align_val_t : TargetLibCall< "_ZdaPvmSt11align_val_t", [Void, Ptr, Long, Long]>;
+
+/// void operator delete(void*);
+def ZdlPv : TargetLibCall< "_ZdlPv", [Void, Ptr]>;
+
+/// void operator delete(void*, const std::nothrow_t&);
+def ZdlPvRKSt9nothrow_t : TargetLibCall< "_ZdlPvRKSt9nothrow_t", [Void, Ptr, Ptr]>;
+
+/// void operator delete(void*, std::align_val_t)
+def ZdlPvSt11align_val_t : TargetLibCall< "_ZdlPvSt11align_val_t", [Void, Ptr, IntPlus]>;
+
+/// void operator delete(void*, std::align_val_t, const std::nothrow_t&)
+def ZdlPvSt11align_val_tRKSt9nothrow_t : TargetLibCall< "_ZdlPvSt11align_val_tRKSt9nothrow_t", [Void, Ptr, IntPlus, Ptr]>;
+
+/// void operator delete(void*, unsigned int);
+def ZdlPvj : TargetLibCall< "_ZdlPvj", [Void, Ptr, Int]>;
+
+/// void operator delete(void*, unsigned int, std::align_val_t)
+def ZdlPvjSt11align_val_t : TargetLibCall< "_ZdlPvjSt11align_val_t", [Void, Ptr, Int, Int]>;
+
+/// void operator delete(void*, unsigned long);
+def ZdlPvm : TargetLibCall< "_ZdlPvm", [Void, Ptr, Long]>;
+
+/// void operator delete(void*, unsigned long, std::align_val_t)
+def ZdlPvmSt11align_val_t : TargetLibCall< "_ZdlPvmSt11align_val_t", [Void, Ptr, Long, Long]>;
+
+/// void *operator new[](unsigned int);
+def Znaj : TargetLibCall< "_Znaj", [Ptr, Int]>;
+
+/// void *operator new[](unsigned int, const std::nothrow_t&);
+def ZnajRKSt9nothrow_t : TargetLibCall< "_ZnajRKSt9nothrow_t", [Ptr, Int, Ptr]>;
+
+/// void *operator new[](unsigned int, std::align_val_t)
+def ZnajSt11align_val_t : TargetLibCall< "_ZnajSt11align_val_t", [Ptr, Int, Int]>;
+
+/// void *operator new[](unsigned int, std::align_val_t, const std::nothrow_t&)
+def ZnajSt11align_val_tRKSt9nothrow_t : TargetLibCall< "_ZnajSt11align_val_tRKSt9nothrow_t", [Ptr, Int, Int, Ptr]>;
+
+/// void *operator new[](unsigned long);
+def Znam : TargetLibCall< "_Znam", [Ptr, Long]>;
+
+/// void *operator new[](unsigned long, __hot_cold_t)
+/// Currently this and other operator new interfaces that take a __hot_cold_t
+/// hint are supported by the open source version of tcmalloc, see:
+/// https://github.com/google/tcmalloc/blob/master/tcmalloc/new_extension.h
+/// and for the definition of the __hot_cold_t parameter see:
+/// https://github.com/google/tcmalloc/blob/master/tcmalloc/malloc_extension.h
+def Znam12__hot_cold_t : TargetLibCall< "_Znam12__hot_cold_t", [Ptr, Long, Bool]>;
+
+/// void *operator new[](unsigned long, const std::nothrow_t&);
+def ZnamRKSt9nothrow_t : TargetLibCall< "_ZnamRKSt9nothrow_t", [Ptr, Long, Ptr]>;
+
+/// void *operator new[](unsigned long, const std::nothrow_t&, __hot_cold_t)
+def ZnamRKSt9nothrow_t12__hot_cold_t : TargetLibCall< "_ZnamRKSt9nothrow_t12__hot_cold_t", [Ptr, Long, Ptr, Bool]>;
+
+/// void *operator new[](unsigned long, std::align_val_t)
+def ZnamSt11align_val_t : TargetLibCall< "_ZnamSt11align_val_t", [Ptr, Long, Long]>;
+
+/// void *operator new[](unsigned long, std::align_val_t, __hot_cold_t)
+def ZnamSt11align_val_t12__hot_cold_t : TargetLibCall< "_ZnamSt11align_val_t12__hot_cold_t", [Ptr, Long, Long, Bool]>;
+
+/// void *operator new[](unsigned long, std::align_val_t, const std::nothrow_t&)
+def ZnamSt11align_val_tRKSt9nothrow_t : TargetLibCall< "_ZnamSt11align_val_tRKSt9nothrow_t", [Ptr, Long, Long, Ptr]>;
+
+/// void *operator new[](unsigned long, std::align_val_t, const std::nothrow_t&, __hot_cold_t)
+def ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t : TargetLibCall< "_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t", [Ptr, Long, Long, Ptr, Bool]>;
+
+/// void *operator new(unsigned int);
+def Znwj : TargetLibCall< "_Znwj", [Ptr, Int]>;
+
+/// void *operator new(unsigned int, const std::nothrow_t&);
+def ZnwjRKSt9nothrow_t : TargetLibCall< "_ZnwjRKSt9nothrow_t", [Ptr, Int, Ptr]>;
+
+/// void *operator new(unsigned int, std::align_val_t)
+def ZnwjSt11align_val_t : TargetLibCall< "_ZnwjSt11align_val_t", [Ptr, Int, Int]>;
+
+/// void *operator new(unsigned int, std::align_val_t, const std::nothrow_t&)
+def ZnwjSt11align_val_tRKSt9nothrow_t : TargetLibCall< "_ZnwjSt11align_val_tRKSt9nothrow_t", [Ptr, Int, Int, Ptr]>;
+
+/// void *operator new(unsigned long);
+def Znwm : TargetLibCall< "_Znwm", [Ptr, Long]>;
+
+/// void *operator new(unsigned long, __hot_cold_t)
+def Znwm12__hot_cold_t : TargetLibCall< "_Znwm12__hot_cold_t", [Ptr, Long, Bool]>;
+
+/// void *operator new(unsigned long, const std::nothrow_t&);
+def ZnwmRKSt9nothrow_t : TargetLibCall< "_ZnwmRKSt9nothrow_t", [Ptr, Long, Ptr]>;
+
+/// void *operator new(unsigned long, const std::nothrow_t&, __hot_cold_t)
+def ZnwmRKSt9nothrow_t12__hot_cold_t : TargetLibCall< "_ZnwmRKSt9nothrow_t12__hot_cold_t", [Ptr, Long, Ptr, Bool]>;
+
+/// void *operator new(unsigned long, std::align_val_t)
+def ZnwmSt11align_val_t : TargetLibCall< "_ZnwmSt11align_val_t", [Ptr, Long, Long]>;
+
+/// void *operator new(unsigned long, std::align_val_t, __hot_cold_t)
+def ZnwmSt11align_val_t12__hot_cold_t : TargetLibCall< "_ZnwmSt11align_val_t12__hot_cold_t", [Ptr, Long, Long, Bool]>;
+
+/// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&)
+def ZnwmSt11align_val_tRKSt9nothrow_t : TargetLibCall< "_ZnwmSt11align_val_tRKSt9nothrow_t", [Ptr, Long, Long, Ptr]>;
+
+/// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&, __hot_cold_t)
+def ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t : TargetLibCall< "_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t", [Ptr, Long, Long, Ptr, Bool]>;
+
+/// The following are variants of operator new which return the actual size
+/// reserved by the allocator proposed in P0901R5 (Size feedback in operator new).
+/// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0901r5.html
+/// They are implemented by tcmalloc, see source at
+/// https://github.com/google/tcmalloc/blob/master/tcmalloc/malloc_extension.h
+
+/// __sized_ptr_t __size_returning_new(size_t size)
+def size_returning_new : TargetLibCall< "__size_returning_new", [/* Checked manually. */]>;
+
+/// __sized_ptr_t __size_returning_new_hot_cold(size_t, __hot_cold_t)
+def size_returning_new_hot_cold : TargetLibCall< "__size_returning_new_hot_cold", [/* Checked manually. */]>;
+
+/// __sized_ptr_t __size_returning_new_aligned(size_t, std::align_val_t)
+def size_returning_new_aligned : TargetLibCall< "__size_returning_new_aligned", [/* Checked manually. */]>;
+
+/// __sized_ptr_t __size_returning_new_aligned(size_t, std::align_val_t, __hot_cold_t)
+def size_returning_new_aligned_hot_cold : TargetLibCall< "__size_returning_new_aligned_hot_cold", [/* Checked manually. */]>;
+
+/// double __acos_finite(double x);
+def acos_finite : TargetLibCall< "__acos_finite", [Dbl, Dbl]>;
+
+/// float __acosf_finite(float x);
+def acosf_finite : TargetLibCall< "__acosf_finite", [Flt, Flt]>;
+
+/// double __acosh_finite(double x);
+def acosh_finite : TargetLibCall< "__acosh_finite", [Dbl, Dbl]>;
+
+/// float __acoshf_finite(float x);
+def acoshf_finite : TargetLibCall< "__acoshf_finite", [Flt, Flt]>;
+
+/// long double __acoshl_finite(long double x);
+def acoshl_finite : TargetLibCall< "__acoshl_finite", [LDbl, LDbl]>;
+
+/// long double __acosl_finite(long double x);
+def acosl_finite : TargetLibCall< "__acosl_finite", [LDbl, LDbl]>;
+
+/// double __asin_finite(double x);
+def asin_finite : TargetLibCall< "__asin_finite", [Dbl, Dbl]>;
+
+/// float __asinf_finite(float x);
+def asinf_finite : TargetLibCall< "__asinf_finite", [Flt, Flt]>;
+
+/// long double __asinl_finite(long double x);
+def asinl_finite : TargetLibCall< "__asinl_finite", [LDbl, LDbl]>;
+
+/// double atan2_finite(double y, double x);
+def atan2_finite : TargetLibCall< "__atan2_finite", [Dbl, Dbl, Dbl]>;
+
+/// float atan2f_finite(float y, float x);
+def atan2f_finite : TargetLibCall< "__atan2f_finite", [Flt, Flt, Flt]>;
+
+/// long double atan2l_finite(long double y, long double x);
+def atan2l_finite : TargetLibCall< "__atan2l_finite", [LDbl, LDbl, LDbl]>;
+
+/// double __atanh_finite(double x);
+def atanh_finite : TargetLibCall< "__atanh_finite", [Dbl, Dbl]>;
+
+/// float __atanhf_finite(float x);
+def atanhf_finite : TargetLibCall< "__atanhf_finite", [Flt, Flt]>;
+
+/// long double __atanhl_finite(long double x);
+def atanhl_finite : TargetLibCall< "__atanhl_finite", [LDbl, LDbl]>;
+
+/// void __atomic_load(size_t size, void *mptr, void *vptr, int smodel);
+def atomic_load : TargetLibCall< "__atomic_load", [Void, SizeT, Ptr, Ptr, Int]>;
+
+/// void __atomic_store(size_t size, void *mptr, void *vptr, int smodel);
+def atomic_store : TargetLibCall< "__atomic_store", [Void, SizeT, Ptr, Ptr, Int]>;
+
+/// double __cosh_finite(double x);
+def cosh_finite : TargetLibCall< "__cosh_finite", [Dbl, Dbl]>;
+
+/// float __coshf_finite(float x);
+def coshf_finite : TargetLibCall< "__coshf_finite", [Flt, Flt]>;
+
+/// long double __coshl_finite(long double x);
+def coshl_finite : TargetLibCall< "__coshl_finite", [LDbl, LDbl]>;
+
+/// double __cospi(double x);
+def cospi : TargetLibCall< "__cospi", [Dbl, Dbl]>;
+
+/// float __cospif(float x);
+def cospif : TargetLibCall< "__cospif", [Flt, Flt]>;
+
+/// int __cxa_atexit(void (*f)(void *), void *p, void *d);
+def cxa_atexit : TargetLibCall< "__cxa_atexit", [Int, Ptr, Ptr, Ptr]>;
+
+/// int atexit(void (*f)(void));
+def atexit : TargetLibCall< "atexit", [Int, Ptr]>;
+
+/// void abort(void)
+def abort : TargetLibCall< "abort", [Void]>;
+
+/// void exit(int)
+def exit : TargetLibCall< "exit", [Void, Int]>;
+
+/// void _Exit(int)
+def Exit : TargetLibCall< "_Exit", [Void, Int]>;
+
+/// void std::terminate();
+def terminate : TargetLibCall< "_ZSt9terminatev", [Void]>;
+
+/// void __cxa_throw(void *, void *, void (*)(void *));
+def cxa_throw : TargetLibCall< "__cxa_throw", [Void, Ptr, Ptr, Ptr]>;
+
+/// void __cxa_guard_abort(guard_t *guard);
+/// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi.
+def cxa_guard_abort : TargetLibCall< "__cxa_guard_abort", [Void, Ptr]>;
+
+/// int __cxa_guard_acquire(guard_t *guard);
+def cxa_guard_acquire : TargetLibCall< "__cxa_guard_acquire", [Int, Ptr]>;
+
+/// void __cxa_guard_release(guard_t *guard);
+def cxa_guard_release : TargetLibCall< "__cxa_guard_release", [Void, Ptr]>;
+
+/// double __exp10_finite(double x);
+def exp10_finite : TargetLibCall< "__exp10_finite", [Dbl, Dbl]>;
+
+/// float __exp10f_finite(float x);
+def exp10f_finite : TargetLibCall< "__exp10f_finite", [Flt, Flt]>;
+
+/// long double __exp10l_finite(long double x);
+def exp10l_finite : TargetLibCall< "__exp10l_finite", [LDbl, LDbl]>;
+
+/// double __exp2_finite(double x);
+def exp2_finite : TargetLibCall< "__exp2_finite", [Dbl, Dbl]>;
+
+/// float __exp2f_finite(float x);
+def exp2f_finite : TargetLibCall< "__exp2f_finite", [Flt, Flt]>;
+
+/// long double __exp2l_finite(long double x);
+def exp2l_finite : TargetLibCall< "__exp2l_finite", [LDbl, LDbl]>;
+
+/// double __exp_finite(double x);
+def exp_finite : TargetLibCall< "__exp_finite", [Dbl, Dbl]>;
+
+/// float __expf_finite(float x);
+def expf_finite : TargetLibCall< "__expf_finite", [Flt, Flt]>;
+
+/// long double __expl_finite(long double x);
+def expl_finite : TargetLibCall< "__expl_finite", [LDbl, LDbl]>;
+
+/// int __isoc99_scanf (const char *format, ...)
+def dunder_isoc99_scanf : TargetLibCall< "__isoc99_scanf", [Int, Ptr, Ellip]>;
+
+/// int __isoc99_sscanf(const char *s, const char *format, ...)
+def dunder_isoc99_sscanf : TargetLibCall< "__isoc99_sscanf", [Int, Ptr, Ptr, Ellip]>;
+
+/// void* __kmpc_alloc_shared(size_t nbyte);
+def __kmpc_alloc_shared : TargetLibCall< "__kmpc_alloc_shared", [Ptr, SizeT]>;
+
+/// void __kmpc_free_shared(void *ptr, size_t nbyte);
+def __kmpc_free_shared : TargetLibCall< "__kmpc_free_shared", [Void, Ptr, SizeT]>;
+
+/// double __log10_finite(double x);
+def log10_finite : TargetLibCall< "__log10_finite", [Dbl, Dbl]>;
+
+/// float __log10f_finite(float x);
+def log10f_finite : TargetLibCall< "__log10f_finite", [Flt, Flt]>;
+
+/// long double __log10l_finite(long double x);
+def log10l_finite : TargetLibCall< "__log10l_finite", [LDbl, LDbl]>;
+
+/// double __log2_finite(double x);
+def log2_finite : TargetLibCall< "__log2_finite", [Dbl, Dbl]>;
+
+/// float __log2f_finite(float x);
+def log2f_finite : TargetLibCall< "__log2f_finite", [Flt, Flt]>;
+
+/// long double __log2l_finite(long double x);
+def log2l_finite : TargetLibCall< "__log2l_finite", [LDbl, LDbl]>;
+
+/// double __log_finite(double x);
+def log_finite : TargetLibCall< "__log_finite", [Dbl, Dbl]>;
+
+/// float __logf_finite(float x);
+def logf_finite : TargetLibCall< "__logf_finite", [Flt, Flt]>;
+
+/// long double __logl_finite(long double x);
+def logl_finite : TargetLibCall< "__logl_finite", [LDbl, LDbl]>;
+
+/// void *__memccpy_chk(void *dst, const void *src, int c, size_t n, ///                     size_t dstsize)
+def memccpy_chk : TargetLibCall< "__memccpy_chk", [Ptr, Ptr, Ptr, Int, SizeT, SizeT]>;
+
+/// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
+def memcpy_chk : TargetLibCall< "__memcpy_chk", [Ptr, Ptr, Ptr, SizeT, SizeT]>;
+
+/// void *__memmove_chk(void *s1, const void *s2, size_t n, size_t s1size);
+def memmove_chk : TargetLibCall< "__memmove_chk", [Ptr, Ptr, Ptr, SizeT, SizeT]>;
+
+/// void *__mempcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
+def mempcpy_chk : TargetLibCall< "__mempcpy_chk", [Ptr, Ptr, Ptr, SizeT, SizeT]>;
+
+/// void *__memset_chk(void *s, int v, size_t n, size_t s1size);
+def memset_chk : TargetLibCall< "__memset_chk", [Ptr, Ptr, Int, SizeT, SizeT]>;
+
+// int __nvvm_reflect(const char *)
+def nvvm_reflect : TargetLibCall< "__nvvm_reflect", [Int, Ptr]>;
+
+/// double __pow_finite(double x, double y);
+def pow_finite : TargetLibCall< "__pow_finite", [Dbl, Dbl, Dbl]>;
+
+/// float _powf_finite(float x, float y);
+def powf_finite : TargetLibCall< "__powf_finite", [Flt, Flt, Flt]>;
+
+/// long double __powl_finite(long double x, long double y);
+def powl_finite : TargetLibCall< "__powl_finite", [LDbl, LDbl, LDbl]>;
+
+/// double __sincospi_stret(double x);
+def sincospi_stret : TargetLibCall< "__sincospi_stret", [/* Checked manually. */]>;
+
+/// float __sincospif_stret(float x);
+def sincospif_stret : TargetLibCall< "__sincospif_stret", [/* Checked manually. */]>;
+
+/// double __sinh_finite(double x);
+def sinh_finite : TargetLibCall< "__sinh_finite", [Dbl, Dbl]>;
+
+/// float _sinhf_finite(float x);
+def sinhf_finite : TargetLibCall< "__sinhf_finite", [Flt, Flt]>;
+
+/// long double __sinhl_finite(long double x);
+def sinhl_finite : TargetLibCall< "__sinhl_finite", [LDbl, LDbl]>;
+
+/// double __sinpi(double x);
+def sinpi : TargetLibCall< "__sinpi", [Dbl, Dbl]>;
+
+/// float __sinpif(float x);
+def sinpif : TargetLibCall< "__sinpif", [Flt, Flt]>;
+
+/// int __small_fprintf(FILE *stream, const char *format, ...);
+def small_fprintf : TargetLibCall< "__small_fprintf", [Int, Ptr, Ptr, Ellip]>;
+
+/// int __small_printf(const char *format, ...);
+def small_printf : TargetLibCall< "__small_printf", [Int, Ptr, Ellip]>;
+
+/// int __small_sprintf(char *str, const char *format, ...);
+def small_sprintf : TargetLibCall< "__small_sprintf", [Int, Ptr, Ptr, Ellip]>;
+
+/// int __snprintf_chk(char *s, size_t n, int flags, size_t slen, ///                    const char *format, ...);
+def snprintf_chk : TargetLibCall< "__snprintf_chk", [Int, Ptr, SizeT, Int, SizeT, Ptr, Ellip]>;
+
+/// int __sprintf_chk(char *str, int flags, size_t str_len, ///                   const char *format, ...);
+def sprintf_chk : TargetLibCall< "__sprintf_chk", [Int, Ptr, Int, SizeT, Ptr, Ellip]>;
+
+/// double __sqrt_finite(double x);
+def sqrt_finite : TargetLibCall< "__sqrt_finite", [Dbl, Dbl]>;
+
+/// float __sqrt_finite(float x);
+def sqrtf_finite : TargetLibCall< "__sqrtf_finite", [Flt, Flt]>;
+
+/// long double __sqrt_finite(long double x);
+def sqrtl_finite : TargetLibCall< "__sqrtl_finite", [LDbl, LDbl]>;
+
+/// char *__stpcpy_chk(char *s1, const char *s2, size_t s1size);
+def stpcpy_chk : TargetLibCall< "__stpcpy_chk", [Ptr, Ptr, Ptr, SizeT]>;
+
+/// char *__stpncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);
+def stpncpy_chk : TargetLibCall< "__stpncpy_chk", [Ptr, Ptr, Ptr, SizeT, SizeT]>;
+
+/// char *__strcat_chk(char *s1, const char *s2, size_t s1size);
+def strcat_chk : TargetLibCall< "__strcat_chk", [Ptr, Ptr, Ptr, SizeT]>;
+
+/// char *__strcpy_chk(char *s1, const char *s2, size_t s1size);
+def strcpy_chk : TargetLibCall< "__strcpy_chk", [Ptr, Ptr, Ptr, SizeT]>;
+
+/// char * __strdup(const char *s);
+def dunder_strdup : TargetLibCall< "__strdup", [Ptr, Ptr]>;
+
+/// size_t __strlcat_chk(char *dst, const char *src, size_t size, ///                      size_t dstsize);
+def strlcat_chk : TargetLibCall< "__strlcat_chk", [SizeT, Ptr, Ptr, SizeT, SizeT]>;
+
+/// size_t __strlcpy_chk(char *dst, const char *src, size_t size, ///                      size_t dstsize);
+def strlcpy_chk : TargetLibCall< "__strlcpy_chk", [SizeT, Ptr, Ptr, SizeT, SizeT]>;
+
+/// size_t __strlen_chk(const char *s1, size_t s1size);
+def strlen_chk : TargetLibCall< "__strlen_chk", [SizeT, Ptr, SizeT]>;
+
+/// char *strncat_chk(char *s1, const char *s2, size_t n, size_t s1size);
+def strncat_chk : TargetLibCall< "__strncat_chk", [Ptr, Ptr, Ptr, SizeT, SizeT]>;
+
+/// char *__strncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);
+def strncpy_chk : TargetLibCall< "__strncpy_chk", [Ptr, Ptr, Ptr, SizeT, SizeT]>;
+
+/// char *__strndup(const char *s, size_t n);
+def dunder_strndup : TargetLibCall< "__strndup", [Ptr, Ptr, SizeT]>;
+
+/// char * __strtok_r(char *s, const char *delim, char **save_ptr);
+def dunder_strtok_r : TargetLibCall< "__strtok_r", [Ptr, Ptr, Ptr, Ptr]>;
+
+/// int __vsnprintf_chk(char *s, size_t n, int flags, size_t slen, ///                     const char *format, va_list ap);
+def vsnprintf_chk : TargetLibCall< "__vsnprintf_chk", [Int, Ptr, SizeT, Int, SizeT, Ptr, Ptr]>;
+
+/// int __vsprintf_chk(char *s, int flags, size_t slen, const char *format, ///                    va_list ap);
+def vsprintf_chk : TargetLibCall< "__vsprintf_chk", [Int, Ptr, Int, SizeT, Ptr, Ptr]>;
+
+/// int abs(int j);
+def abs : TargetLibCall< "abs", [Int, Int]>;
+
+/// int access(const char *path, int amode);
+def access : TargetLibCall< "access", [Int, Ptr, Int]>;
+
+/// double acos(double x);
+def acos : TargetLibCall< "acos", [Dbl, Dbl]>;
+
+/// float acosf(float x);
+def acosf : TargetLibCall< "acosf", [Flt, Flt]>;
+
+/// double acosh(double x);
+def acosh : TargetLibCall< "acosh", [Dbl, Dbl]>;
+
+/// float acoshf(float x);
+def acoshf : TargetLibCall< "acoshf", [Flt, Flt]>;
+
+/// long double acoshl(long double x);
+def acoshl : TargetLibCall< "acoshl", [LDbl, LDbl]>;
+
+/// long double acosl(long double x);
+def acosl : TargetLibCall< "acosl", [LDbl, LDbl]>;
+
+/// void *aligned_alloc(size_t alignment, size_t size);
+def aligned_alloc : TargetLibCall< "aligned_alloc", [Ptr, SizeT, SizeT]>;
+
+/// double asin(double x);
+def asin : TargetLibCall< "asin", [Dbl, Dbl]>;
+
+/// float asinf(float x);
+def asinf : TargetLibCall< "asinf", [Flt, Flt]>;
+
+/// double asinh(double x);
+def asinh : TargetLibCall< "asinh", [Dbl, Dbl]>;
+
+/// float asinhf(float x);
+def asinhf : TargetLibCall< "asinhf", [Flt, Flt]>;
+
+/// long double asinhl(long double x);
+def asinhl : TargetLibCall< "asinhl", [LDbl, LDbl]>;
+
+/// long double asinl(long double x);
+def asinl : TargetLibCall< "asinl", [LDbl, LDbl]>;
+
+/// double atan(double x);
+def atan : TargetLibCall< "atan", [Dbl, Dbl]>;
+
+/// double atan2(double y, double x);
+def atan2 : TargetLibCall< "atan2", [Dbl, Dbl, Dbl]>;
+
+/// float atan2f(float y, float x);
+def atan2f : TargetLibCall< "atan2f", [Flt, Flt, Flt]>;
+
+/// long double atan2l(long double y, long double x);
+def atan2l : TargetLibCall< "atan2l", [LDbl, LDbl, LDbl]>;
+
+/// float atanf(float x);
+def atanf : TargetLibCall< "atanf", [Flt, Flt]>;
+
+/// double atanh(double x);
+def atanh : TargetLibCall< "atanh", [Dbl, Dbl]>;
+
+/// float atanhf(float x);
+def atanhf : TargetLibCall< "atanhf", [Flt, Flt]>;
+
+/// long double atanhl(long double x);
+def atanhl : TargetLibCall< "atanhl", [LDbl, LDbl]>;
+
+/// long double atanl(long double x);
+def atanl : TargetLibCall< "atanl", [LDbl, LDbl]>;
+
+/// double atof(const char *str);
+def atof : TargetLibCall< "atof", [Dbl, Ptr]>;
+
+/// int atoi(const char *str);
+def atoi : TargetLibCall< "atoi", [Int, Ptr]>;
+
+/// long atol(const char *str);
+def atol : TargetLibCall< "atol", [Long, Ptr]>;
+
+/// long long atoll(const char *nptr);
+def atoll : TargetLibCall< "atoll", [LLong, Ptr]>;
+
+/// int bcmp(const void *s1, const void *s2, size_t n);
+def bcmp : TargetLibCall< "bcmp", [Int, Ptr, Ptr, SizeT]>;
+
+/// void bcopy(const void *s1, void *s2, size_t n);
+def bcopy : TargetLibCall< "bcopy", [Void, Ptr, Ptr, SizeT]>;
+
+/// void bzero(void *s, size_t n);
+def bzero : TargetLibCall< "bzero", [Void, Ptr, SizeT]>;
+
+/// double cabs(double complex z)
+def cabs : TargetLibCall< "cabs", [/* Checked manually. */]>;
+
+/// float cabs(float complex z)
+def cabsf : TargetLibCall< "cabsf", [/* Checked manually. */]>;
+
+/// long double cabs(long double complex z)
+def cabsl : TargetLibCall< "cabsl", [/* Checked manually. */]>;
+
+/// void *calloc(size_t count, size_t size);
+def calloc : TargetLibCall< "calloc", [Ptr, SizeT, SizeT]>;
+
+/// double cbrt(double x);
+def cbrt : TargetLibCall< "cbrt", [Dbl, Dbl]>;
+
+/// float cbrtf(float x);
+def cbrtf : TargetLibCall< "cbrtf", [Flt, Flt]>;
+
+/// long double cbrtl(long double x);
+def cbrtl : TargetLibCall< "cbrtl", [LDbl, LDbl]>;
+
+/// double ceil(double x);
+def ceil : TargetLibCall< "ceil", [Dbl, Dbl]>;
+
+/// float ceilf(float x);
+def ceilf : TargetLibCall< "ceilf", [Flt, Flt]>;
+
+/// long double ceill(long double x);
+def ceill : TargetLibCall< "ceill", [LDbl, LDbl]>;
+
+/// int chmod(const char *path, mode_t mode);
+def chmod : TargetLibCall< "chmod", [Int, Ptr, IntX]>;
+
+/// int chown(const char *path, uid_t owner, gid_t group);
+def chown : TargetLibCall< "chown", [Int, Ptr, IntX, IntX]>;
+
+/// void clearerr(FILE *stream);
+def clearerr : TargetLibCall< "clearerr", [Void, Ptr]>;
+
+/// int closedir(DIR *dirp);
+def closedir : TargetLibCall< "closedir", [Int, Ptr]>;
+
+/// double copysign(double x, double y);
+def copysign : TargetLibCall< "copysign", [Dbl, Dbl, Dbl]>;
+
+/// float copysignf(float x, float y);
+def copysignf : TargetLibCall< "copysignf", [Flt, Flt, Flt]>;
+
+/// long double copysignl(long double x, long double y);
+def copysignl : TargetLibCall< "copysignl", [LDbl, LDbl, LDbl]>;
+
+/// double cos(double x);
+def cos : TargetLibCall< "cos", [Dbl, Dbl]>;
+
+/// float cosf(float x);
+def cosf : TargetLibCall< "cosf", [Flt, Flt]>;
+
+/// double cosh(double x);
+def cosh : TargetLibCall< "cosh", [Dbl, Dbl]>;
+
+/// float coshf(float x);
+def coshf : TargetLibCall< "coshf", [Flt, Flt]>;
+
+/// long double coshl(long double x);
+def coshl : TargetLibCall< "coshl", [LDbl, LDbl]>;
+
+/// long double cosl(long double x);
+def cosl : TargetLibCall< "cosl", [LDbl, LDbl]>;
+
+/// char *ctermid(char *s);
+def ctermid : TargetLibCall< "ctermid", [Ptr, Ptr]>;
+
+/// double erf(double x);
+def erf : TargetLibCall< "erf", [Dbl, Dbl]>;
+
+/// float erff(float x);
+def erff : TargetLibCall< "erff", [Flt, Flt]>;
+
+/// long double erfl(long double x);
+def erfl : TargetLibCall< "erfl", [LDbl, LDbl]>;
+
+/// double tgamma(double x);
+def tgamma : TargetLibCall< "tgamma", [Dbl, Dbl]>;
+
+/// float tgammaf(float x);
+def tgammaf : TargetLibCall< "tgammaf", [Flt, Flt]>;
+
+/// long double tgammal(long double x);
+def tgammal : TargetLibCall< "tgammal", [LDbl, LDbl]>;
+
+/// int execl(const char *path, const char *arg, ...);
+def execl : TargetLibCall< "execl", [Int, Ptr, Ptr, Ellip]>;
+
+/// int execle(const char *file, const char *arg, ..., char * const envp[]);
+def execle : TargetLibCall< "execle", [Int, Ptr, Ptr, Ellip]>;
+
+/// int execlp(const char *file, const char *arg, ...);
+def execlp : TargetLibCall< "execlp", [Int, Ptr, Ptr, Ellip]>;
+
+/// int execv(const char *path, char *const argv[]);
+def execv : TargetLibCall< "execv", [Int, Ptr, Ptr]>;
+
+/// int execvP(const char *file, const char *search_path, char *const argv[]);
+def execvP : TargetLibCall< "execvP", [Int, Ptr, Ptr, Ptr]>;
+
+/// int execve(const char *filename, char *const argv[], char *const envp[]);
+def execve : TargetLibCall< "execve", [Int, Ptr, Ptr, Ptr]>;
+
+/// int execvp(const char *file, char *const argv[]);
+def execvp : TargetLibCall< "execvp", [Int, Ptr, Ptr]>;
+
+/// int execvpe(const char *file, char *const argv[], char *const envp[]);
+def execvpe : TargetLibCall< "execvpe", [Int, Ptr, Ptr, Ptr]>;
+
+/// double exp(double x);
+def exp : TargetLibCall< "exp", [Dbl, Dbl]>;
+
+/// double exp10(double x);
+def exp10 : TargetLibCall< "exp10", [Dbl, Dbl]>;
+
+/// float exp10f(float x);
+def exp10f : TargetLibCall< "exp10f", [Flt, Flt]>;
+
+/// long double exp10l(long double x);
+def exp10l : TargetLibCall< "exp10l", [LDbl, LDbl]>;
+
+/// double exp2(double x);
+def exp2 : TargetLibCall< "exp2", [Dbl, Dbl]>;
+
+/// float exp2f(float x);
+def exp2f : TargetLibCall< "exp2f", [Flt, Flt]>;
+
+/// long double exp2l(long double x);
+def exp2l : TargetLibCall< "exp2l", [LDbl, LDbl]>;
+
+/// float expf(float x);
+def expf : TargetLibCall< "expf", [Flt, Flt]>;
+
+/// long double expl(long double x);
+def expl : TargetLibCall< "expl", [LDbl, LDbl]>;
+
+/// double expm1(double x);
+def expm1 : TargetLibCall< "expm1", [Dbl, Dbl]>;
+
+/// float expm1f(float x);
+def expm1f : TargetLibCall< "expm1f", [Flt, Flt]>;
+
+/// long double expm1l(long double x);
+def expm1l : TargetLibCall< "expm1l", [LDbl, LDbl]>;
+
+/// double fabs(double x);
+def fabs : TargetLibCall< "fabs", [Dbl, Dbl]>;
+
+/// float fabsf(float x);
+def fabsf : TargetLibCall< "fabsf", [Flt, Flt]>;
+
+/// long double fabsl(long double x);
+def fabsl : TargetLibCall< "fabsl", [LDbl, LDbl]>;
+
+/// int fclose(FILE *stream);
+def fclose : TargetLibCall< "fclose", [Int, Ptr]>;
+
+/// FILE *fdopen(int fildes, const char *mode);
+def fdopen : TargetLibCall< "fdopen", [Ptr, Int, Ptr]>;
+
+/// int feof(FILE *stream);
+def feof : TargetLibCall< "feof", [Int, Ptr]>;
+
+/// int ferror(FILE *stream);
+def ferror : TargetLibCall< "ferror", [Int, Ptr]>;
+
+/// int fflush(FILE *stream);
+def fflush : TargetLibCall< "fflush", [Int, Ptr]>;
+
+/// int ffs(int i);
+def ffs : TargetLibCall< "ffs", [Int, Int]>;
+
+/// int ffsl(long int i);
+def ffsl : TargetLibCall< "ffsl", [Int, Long]>;
+
+/// int ffsll(long long int i);
+def ffsll : TargetLibCall< "ffsll", [Int, LLong]>;
+
+/// int fgetc(FILE *stream);
+def fgetc : TargetLibCall< "fgetc", [Int, Ptr]>;
+
+/// int fgetc_unlocked(FILE *stream);
+def fgetc_unlocked : TargetLibCall< "fgetc_unlocked", [Int, Ptr]>;
+
+/// int fgetpos(FILE *stream, fpos_t *pos);
+def fgetpos : TargetLibCall< "fgetpos", [Int, Ptr, Ptr]>;
+
+/// char *fgets(char *s, int n, FILE *stream);
+def fgets : TargetLibCall< "fgets", [Ptr, Ptr, Int, Ptr]>;
+
+/// char *fgets_unlocked(char *s, int n, FILE *stream);
+def fgets_unlocked : TargetLibCall< "fgets_unlocked", [Ptr, Ptr, Int, Ptr]>;
+
+/// int fileno(FILE *stream);
+def fileno : TargetLibCall< "fileno", [Int, Ptr]>;
+
+/// int fiprintf(FILE *stream, const char *format, ...);
+def fiprintf : TargetLibCall< "fiprintf", [Int, Ptr, Ptr, Ellip]>;
+
+/// void flockfile(FILE *file);
+def flockfile : TargetLibCall< "flockfile", [Void, Ptr]>;
+
+/// double floor(double x);
+def floor : TargetLibCall< "floor", [Dbl, Dbl]>;
+
+/// float floorf(float x);
+def floorf : TargetLibCall< "floorf", [Flt, Flt]>;
+
+/// long double floorl(long double x);
+def floorl : TargetLibCall< "floorl", [LDbl, LDbl]>;
+
+/// int fls(int i);
+def fls : TargetLibCall< "fls", [Int, Int]>;
+
+/// int flsl(long int i);
+def flsl : TargetLibCall< "flsl", [Int, Long]>;
+
+/// int flsll(long long int i);
+def flsll : TargetLibCall< "flsll", [Int, LLong]>;
+
+// Calls to fmax and fmin library functions expand to the llvm.maxnnum and
+// llvm.minnum intrinsics with the correct parameter types for the arguments
+// (all types must match).
+/// double fmax(double x, double y);
+def fmax : TargetLibCall< "fmax", [Floating, Same, Same]>;
+
+/// float fmaxf(float x, float y);
+def fmaxf : TargetLibCall< "fmaxf", [Floating, Same, Same]>;
+
+/// long double fmaxl(long double x, long double y);
+def fmaxl : TargetLibCall< "fmaxl", [Floating, Same, Same]>;
+
+/// double fmin(double x, double y);
+def fmin : TargetLibCall< "fmin", [Floating, Same, Same]>;
+
+/// float fminf(float x, float y);
+def fminf : TargetLibCall< "fminf", [Floating, Same, Same]>;
+
+/// long double fminl(long double x, long double y);
+def fminl : TargetLibCall< "fminl", [Floating, Same, Same]>;
+
+// Calls to fmaximum_num and fminimum_num library functions expand to the llvm.maximumnum and
+// llvm.minimumnum intrinsics with the correct parameter types for the arguments
+// (all types must match).
+/// double fmaximum_num(double x, double y);
+def fmaximum_num : TargetLibCall< "fmaximum_num", [Floating, Same, Same]>;
+
+/// float fmaximum_numf(float x, float y);
+def fmaximum_numf : TargetLibCall< "fmaximum_numf", [Floating, Same, Same]>;
+
+/// long double fmaximum_numl(long double x, long double y);
+def fmaximum_numl : TargetLibCall< "fmaximum_numl", [Floating, Same, Same]>;
+
+/// double fminimum_num(double x, double y);
+def fminimum_num : TargetLibCall< "fminimum_num", [Floating, Same, Same]>;
+
+/// float fminimum_numf(float x, float y);
+def fminimum_numf : TargetLibCall< "fminimum_numf", [Floating, Same, Same]>;
+
+/// long double fminimum_numl(long double x, long double y);
+def fminimum_numl : TargetLibCall< "fminimum_numl", [Floating, Same, Same]>;
+
+/// double fmod(double x, double y);
+def fmod : TargetLibCall< "fmod", [Dbl, Dbl, Dbl]>;
+
+/// float fmodf(float x, float y);
+def fmodf : TargetLibCall< "fmodf", [Flt, Flt, Flt]>;
+
+/// long double fmodl(long double x, long double y);
+def fmodl : TargetLibCall< "fmodl", [LDbl, LDbl, LDbl]>;
+
+/// FILE *fopen(const char *filename, const char *mode);
+def fopen : TargetLibCall< "fopen", [Ptr, Ptr, Ptr]>;
+
+/// FILE *fopen64(const char *filename, const char *opentype)
+def fopen64 : TargetLibCall< "fopen64", [Ptr, Ptr, Ptr]>;
+
+/// int fork();
+def fork : TargetLibCall< "fork", [Int]>;
+
+/// int fprintf(FILE *stream, const char *format, ...);
+def fprintf : TargetLibCall< "fprintf", [Int, Ptr, Ptr, Ellip]>;
+
+/// int fputc(int c, FILE *stream);
+def fputc : TargetLibCall< "fputc", [Int, Int, Ptr]>;
+
+/// int fputc_unlocked(int c, FILE *stream);
+def fputc_unlocked : TargetLibCall< "fputc_unlocked", [Int, Int, Ptr]>;
+
+/// int fputs(const char *s, FILE *stream);
+def fputs : TargetLibCall< "fputs", [Int, Ptr, Ptr]>;
+
+/// int fputs_unlocked(const char *s, FILE *stream);
+def fputs_unlocked : TargetLibCall< "fputs_unlocked", [Int, Ptr, Ptr]>;
+
+/// size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
+def fread : TargetLibCall< "fread", [SizeT, Ptr, SizeT, SizeT, Ptr]>;
+
+/// size_t fread_unlocked(void *ptr, size_t size, size_t nitems, FILE *stream);
+def fread_unlocked : TargetLibCall< "fread_unlocked", [SizeT, Ptr, SizeT, SizeT, Ptr]>;
+
+/// void free(void *ptr);
+def free : TargetLibCall< "free", [Void, Ptr]>;
+
+/// double frexp(double num, int *exp);
+def frexp : TargetLibCall< "frexp", [Dbl, Dbl, Ptr]>;
+
+/// float frexpf(float num, int *exp);
+def frexpf : TargetLibCall< "frexpf", [Flt, Flt, Ptr]>;
+
+/// long double frexpl(long double num, int *exp);
+def frexpl : TargetLibCall< "frexpl", [LDbl, LDbl, Ptr]>;
+
+/// int fscanf(FILE *stream, const char *format, ... );
+def fscanf : TargetLibCall< "fscanf", [Int, Ptr, Ptr, Ellip]>;
+
+/// int fseek(FILE *stream, long offset, int whence);
+def fseek : TargetLibCall< "fseek", [Int, Ptr, Long, Int]>;
+
+/// int fseeko(FILE *stream, off_t offset, int whence);
+def fseeko : TargetLibCall< "fseeko", [Int, Ptr, IntX, Int]>;
+
+/// int fseeko64(FILE *stream, off64_t offset, int whence)
+def fseeko64 : TargetLibCall< "fseeko64", [Int, Ptr, Int64, Int]>;
+
+/// int fsetpos(FILE *stream, const fpos_t *pos);
+def fsetpos : TargetLibCall< "fsetpos", [Int, Ptr, Ptr]>;
+
+/// int fstat(int fildes, struct stat *buf);
+def fstat : TargetLibCall< "fstat", [Int, Int, Ptr]>;
+
+/// int fstat64(int filedes, struct stat64 *buf)
+def fstat64 : TargetLibCall< "fstat64", [Int, Int, Ptr]>;
+
+/// int fstatvfs(int fildes, struct statvfs *buf);
+def fstatvfs : TargetLibCall< "fstatvfs", [Int, Int, Ptr]>;
+
+/// int fstatvfs64(int fildes, struct statvfs64 *buf);
+def fstatvfs64 : TargetLibCall< "fstatvfs64", [Int, Int, Ptr]>;
+
+/// long ftell(FILE *stream);
+def ftell : TargetLibCall< "ftell", [Long, Ptr]>;
+
+/// off_t ftello(FILE *stream);
+def ftello : TargetLibCall< "ftello", [IntPlus, Ptr]>;
+
+/// off64_t ftello64(FILE *stream)
+def ftello64 : TargetLibCall< "ftello64", [Int64, Ptr]>;
+
+/// int ftrylockfile(FILE *file);
+def ftrylockfile : TargetLibCall< "ftrylockfile", [Int, Ptr]>;
+
+/// void funlockfile(FILE *file);
+def funlockfile : TargetLibCall< "funlockfile", [Void, Ptr]>;
+
+/// size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
+def fwrite : TargetLibCall< "fwrite", [SizeT, Ptr, SizeT, SizeT, Ptr]>;
+
+/// size_t fwrite_unlocked(const void *ptr, size_t size, size_t nitems, FILE *stream);
+def fwrite_unlocked : TargetLibCall< "fwrite_unlocked", [SizeT, Ptr, SizeT, SizeT, Ptr]>;
+
+/// int getc(FILE *stream);
+def getc : TargetLibCall< "getc", [Int, Ptr]>;
+
+/// int getc_unlocked(FILE *stream);
+def getc_unlocked : TargetLibCall< "getc_unlocked", [Int, Ptr]>;
+
+/// int getchar(void);
+def getchar : TargetLibCall< "getchar", [Int]>;
+
+/// int getchar_unlocked(void);
+def getchar_unlocked : TargetLibCall< "getchar_unlocked", [Int]>;
+
+/// char *getenv(const char *name);
+def getenv : TargetLibCall< "getenv", [Ptr, Ptr]>;
+
+/// int getitimer(int which, struct itimerval *value);
+def getitimer : TargetLibCall< "getitimer", [Int, Int, Ptr]>;
+
+/// int getlogin_r(char *name, size_t namesize);
+def getlogin_r : TargetLibCall< "getlogin_r", [Int, Ptr, SizeT]>;
+
+/// struct passwd *getpwnam(const char *name);
+def getpwnam : TargetLibCall< "getpwnam", [Ptr, Ptr]>;
+
+/// char *gets(char *s);
+def gets : TargetLibCall< "gets", [Ptr, Ptr]>;
+
+/// int gettimeofday(struct timeval *tp, void *tzp);
+def gettimeofday : TargetLibCall< "gettimeofday", [Int, Ptr, Ptr]>;
+
+/// uint32_t htonl(uint32_t hostlong);
+def htonl : TargetLibCall< "htonl", [Int32, Int32]>;
+
+/// uint16_t htons(uint16_t hostshort);
+def htons : TargetLibCall< "htons", [Int16, Int16]>;
+
+/// double hypot(double x, double y);
+def hypot : TargetLibCall< "hypot", [Dbl, Dbl, Dbl]>;
+
+/// float hypotf(float x, float y);
+def hypotf : TargetLibCall< "hypotf", [Flt, Flt, Flt]>;
+
+/// long double hypotl(long double x, long double y);
+def hypotl : TargetLibCall< "hypotl", [LDbl, LDbl, LDbl]>;
+
+/// int iprintf(const char *format, ...);
+def iprintf : TargetLibCall< "iprintf", [Int, Ptr, Ellip]>;
+
+/// int isascii(int c);
+def isascii : TargetLibCall< "isascii", [Int, Int]>;
+
+/// int isdigit(int c);
+def isdigit : TargetLibCall< "isdigit", [Int, Int]>;
+
+/// long int labs(long int j);
+def labs : TargetLibCall< "labs", [Long, Same]>;
+
+/// int lchown(const char *path, uid_t owner, gid_t group);
+def lchown : TargetLibCall< "lchown", [Int, Ptr, IntX, IntX]>;
+
+/// double ldexp(double x, int n);
+def ldexp : TargetLibCall< "ldexp", [Dbl, Dbl, Int]>;
+
+/// float ldexpf(float x, int n);
+def ldexpf : TargetLibCall< "ldexpf", [Flt, Flt, Int]>;
+
+/// long double ldexpl(long double x, int n);
+def ldexpl : TargetLibCall< "ldexpl", [LDbl, LDbl, Int]>;
+
+/// long long int llabs(long long int j);
+def llabs : TargetLibCall< "llabs", [LLong, LLong]>;
+
+/// double log(double x);
+def log : TargetLibCall< "log", [Dbl, Dbl]>;
+
+/// double log10(double x);
+def log10 : TargetLibCall< "log10", [Dbl, Dbl]>;
+
+/// float log10f(float x);
+def log10f : TargetLibCall< "log10f", [Flt, Flt]>;
+
+/// long double log10l(long double x);
+def log10l : TargetLibCall< "log10l", [LDbl, LDbl]>;
+
+/// double log1p(double x);
+def log1p : TargetLibCall< "log1p", [Dbl, Dbl]>;
+
+/// float log1pf(float x);
+def log1pf : TargetLibCall< "log1pf", [Flt, Flt]>;
+
+/// long double log1pl(long double x);
+def log1pl : TargetLibCall< "log1pl", [LDbl, LDbl]>;
+
+/// double log2(double x);
+def log2 : TargetLibCall< "log2", [Dbl, Dbl]>;
+
+/// float log2f(float x);
+def log2f : TargetLibCall< "log2f", [Flt, Flt]>;
+
+/// double long double log2l(long double x);
+def log2l : TargetLibCall< "log2l", [LDbl, LDbl]>;
+
+/// int ilogb(double x);
+def ilogb : TargetLibCall< "ilogb", [Int, Dbl]>;
+
+/// int ilogbf(float x);
+def ilogbf : TargetLibCall< "ilogbf", [Int, Flt]>;
+
+/// int ilogbl(long double x);
+def ilogbl : TargetLibCall< "ilogbl", [Int, LDbl]>;
+
+/// double logb(double x);
+def logb : TargetLibCall< "logb", [Dbl, Dbl]>;
+
+/// float logbf(float x);
+def logbf : TargetLibCall< "logbf", [Flt, Flt]>;
+
+/// long double logbl(long double x);
+def logbl : TargetLibCall< "logbl", [LDbl, LDbl]>;
+
+/// float logf(float x);
+def logf : TargetLibCall< "logf", [Flt, Flt]>;
+
+/// long double logl(long double x);
+def logl : TargetLibCall< "logl", [LDbl, LDbl]>;
+
+/// int lstat(const char *path, struct stat *buf);
+def lstat : TargetLibCall< "lstat", [Int, Ptr, Ptr]>;
+
+/// int lstat64(const char *path, struct stat64 *buf);
+def lstat64 : TargetLibCall< "lstat64", [Int, Ptr, Ptr]>;
+
+/// void *malloc(size_t size);
+def malloc : TargetLibCall< "malloc", [Ptr, SizeT]>;
+
+/// void *memalign(size_t boundary, size_t size);
+def memalign : TargetLibCall< "memalign", [Ptr, SizeT, SizeT]>;
+
+/// void *memccpy(void *s1, const void *s2, int c, size_t n);
+def memccpy : TargetLibCall< "memccpy", [Ptr, Ptr, Ptr, Int, SizeT]>;
+
+/// void *memchr(const void *s, int c, size_t n);
+def memchr : TargetLibCall< "memchr", [Ptr, Ptr, Int, SizeT]>;
+
+/// int memcmp(const void *s1, const void *s2, size_t n);
+def memcmp : TargetLibCall< "memcmp", [Int, Ptr, Ptr, SizeT]>;
+
+/// void *memcpy(void *s1, const void *s2, size_t n);
+def memcpy : TargetLibCall< "memcpy", [Ptr, Ptr, Ptr, SizeT]>;
+
+/// void *memmove(void *s1, const void *s2, size_t n);
+def memmove : TargetLibCall< "memmove", [Ptr, Ptr, Ptr, SizeT]>;
+
+/// void *mempcpy(void *s1, const void *s2, size_t n);
+def mempcpy : TargetLibCall< "mempcpy", [Ptr, Ptr, Ptr, SizeT]>;
+
+/// void *memrchr(const void *s, int c, size_t n);
+def memrchr : TargetLibCall< "memrchr", [Ptr, Ptr, Int, SizeT]>;
+
+/// void *memset(void *b, int c, size_t len);
+def memset : TargetLibCall< "memset", [Ptr, Ptr, Int, SizeT]>;
+
+/// void memset_pattern16(void *b, const void *pattern16, size_t len);
+def memset_pattern16 : TargetLibCall< "memset_pattern16", [Void, Ptr, Ptr, SizeT]>;
+
+/// void memset_pattern4(void *b, const void *pattern4, size_t len);
+def memset_pattern4 : TargetLibCall< "memset_pattern4", [Void, Ptr, Ptr, SizeT]>;
+
+/// void memset_pattern8(void *b, const void *pattern8, size_t len);
+def memset_pattern8 : TargetLibCall< "memset_pattern8", [Void, Ptr, Ptr, SizeT]>;
+
+/// int mkdir(const char *path, mode_t mode);
+def mkdir : TargetLibCall< "mkdir", [Int, Ptr, IntX]>;
+
+/// time_t mktime(struct tm *timeptr);
+def mktime : TargetLibCall< "mktime", [IntPlus, Ptr]>;
+
+/// double modf(double x, double *iptr);
+def modf : TargetLibCall< "modf", [Dbl, Dbl, Ptr]>;
+
+/// float modff(float, float *iptr);
+def modff : TargetLibCall< "modff", [Flt, Flt, Ptr]>;
+
+/// long double modfl(long double value, long double *iptr);
+def modfl : TargetLibCall< "modfl", [LDbl, LDbl, Ptr]>;
+
+/// double nan(const char *arg);
+def nan : TargetLibCall< "nan", [Dbl, Ptr]>;
+
+/// float nanf(const char *arg);
+def nanf : TargetLibCall< "nanf", [Flt, Ptr]>;
+
+/// long double nanl(const char *arg);
+def nanl : TargetLibCall< "nanl", [LDbl, Ptr]>;
+
+/// double nearbyint(double x);
+def nearbyint : TargetLibCall< "nearbyint", [Dbl, Dbl]>;
+
+/// float nearbyintf(float x);
+def nearbyintf : TargetLibCall< "nearbyintf", [Flt, Flt]>;
+
+/// long double nearbyintl(long double x);
+def nearbyintl : TargetLibCall< "nearbyintl", [LDbl, LDbl]>;
+
+/// uint32_t ntohl(uint32_t netlong);
+def ntohl : TargetLibCall< "ntohl", [Int32, Int32]>;
+
+/// uint16_t ntohs(uint16_t netshort);
+def ntohs : TargetLibCall< "ntohs", [Int16, Int16]>;
+
+/// int open(const char *path, int oflag, ... );
+def open : TargetLibCall< "open", [Int, Ptr, Int, Ellip]>;
+
+/// int open64(const char *filename, int flags[, mode_t mode])
+def open64 : TargetLibCall< "open64", [Int, Ptr, Int, Ellip]>;
+
+/// DIR *opendir(const char *dirname);
+def opendir : TargetLibCall< "opendir", [Ptr, Ptr]>;
+
+/// int pclose(FILE *stream);
+def pclose : TargetLibCall< "pclose", [Int, Ptr]>;
+
+/// void perror(const char *s);
+def perror : TargetLibCall< "perror", [Void, Ptr]>;
+
+/// FILE *popen(const char *command, const char *mode);
+def popen : TargetLibCall< "popen", [Ptr, Ptr, Ptr]>;
+
+/// int posix_memalign(void **memptr, size_t alignment, size_t size);
+def posix_memalign : TargetLibCall< "posix_memalign", [Int, Ptr, SizeT, SizeT]>;
+
+/// double pow(double x, double y);
+def pow : TargetLibCall< "pow", [Dbl, Dbl, Dbl]>;
+
+/// float powf(float x, float y);
+def powf : TargetLibCall< "powf", [Flt, Flt, Flt]>;
+
+/// long double powl(long double x, long double y);
+def powl : TargetLibCall< "powl", [LDbl, LDbl, LDbl]>;
+
+/// ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
+def pread : TargetLibCall< "pread", [SSizeT, Int, Ptr, SizeT, IntPlus]>;
+
+/// int printf(const char *format, ...);
+def printf : TargetLibCall< "printf", [Int, Ptr, Ellip]>;
+
+/// int putc(int c, FILE *stream);
+def putc : TargetLibCall< "putc", [Int, Int, Ptr]>;
+
+/// int putc_unlocked(int c, FILE *stream);
+def putc_unlocked : TargetLibCall< "putc_unlocked", [Int, Int, Ptr]>;
+
+/// int putchar(int c);
+def putchar : TargetLibCall< "putchar", [Int, Int]>;
+
+/// int putchar_unlocked(int c);
+def putchar_unlocked : TargetLibCall< "putchar_unlocked", [Int, Int]>;
+
+/// int puts(const char *s);
+def puts : TargetLibCall< "puts", [Int, Ptr]>;
+
+/// void *pvalloc(size_t size);
+def pvalloc : TargetLibCall< "pvalloc", [Ptr, SizeT]>;
+
+/// ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
+def pwrite : TargetLibCall< "pwrite", [SSizeT, Int, Ptr, SizeT, IntPlus]>;
+
+/// void qsort(void *base, size_t nel, size_t width, ///            int (*compar)(const void *, const void *));
+def qsort : TargetLibCall< "qsort", [Void, Ptr, SizeT, SizeT, Ptr]>;
+
+/// ssize_t read(int fildes, void *buf, size_t nbyte);
+def read : TargetLibCall< "read", [SSizeT, Int, Ptr, SizeT]>;
+
+/// ssize_t readlink(const char *path, char *buf, size_t bufsize);
+def readlink : TargetLibCall< "readlink", [SSizeT, Ptr, Ptr, SizeT]>;
+
+/// void *realloc(void *ptr, size_t size);
+def realloc : TargetLibCall< "realloc", [Ptr, Ptr, SizeT]>;
+
+/// void *reallocf(void *ptr, size_t size);
+def reallocf : TargetLibCall< "reallocf", [Ptr, Ptr, SizeT]>;
+
+/// void *reallocarray(void *ptr, size_t nmemb, size_t size);
+def reallocarray : TargetLibCall< "reallocarray", [Ptr, Ptr, SizeT, SizeT]>;
+
+/// char *realpath(const char *file_name, char *resolved_name);
+def realpath : TargetLibCall< "realpath", [Ptr, Ptr, Ptr]>;
+
+/// double remainder(double x, double y);
+def remainder : TargetLibCall< "remainder", [Dbl, Dbl, Dbl]>;
+
+/// float remainderf(float x, float y);
+def remainderf : TargetLibCall< "remainderf", [Flt, Flt, Flt]>;
+
+/// long double remainderl(long double x, long double y);
+def remainderl : TargetLibCall< "remainderl", [LDbl, LDbl, LDbl]>;
+
+/// double remquo(double x, double y, int *quo);
+def remquo : TargetLibCall< "remquo", [Dbl, Dbl, Dbl, Ptr]>;
+
+/// float remquof(float x, float y, int *quo);
+def remquof : TargetLibCall< "remquof", [Flt, Flt, Flt, Ptr]>;
+
+/// long double remquol(long double x, long double y, int *quo);
+def remquol : TargetLibCall< "remquol", [LDbl, LDbl, LDbl, Ptr]>;
+
+/// double fdim(double x, double y);
+def fdim : TargetLibCall< "fdim", [Dbl, Dbl, Dbl]>;
+
+/// float fdimf(float x, float y);
+def fdimf : TargetLibCall< "fdimf", [Flt, Flt, Flt]>;
+
+/// long double fdiml(long double x, long double y);
+def fdiml : TargetLibCall< "fdiml", [LDbl, LDbl, LDbl]>;
+
+/// int remove(const char *path);
+def remove : TargetLibCall< "remove", [Int, Ptr]>;
+
+/// int rename(const char *old, const char *new);
+def rename : TargetLibCall< "rename", [Int, Ptr, Ptr]>;
+
+/// void rewind(FILE *stream);
+def rewind : TargetLibCall< "rewind", [Void, Ptr]>;
+
+/// double rint(double x);
+def rint : TargetLibCall< "rint", [Dbl, Dbl]>;
+
+/// float rintf(float x);
+def rintf : TargetLibCall< "rintf", [Flt, Flt]>;
+
+/// long double rintl(long double x);
+def rintl : TargetLibCall< "rintl", [LDbl, LDbl]>;
+
+/// int rmdir(const char *path);
+def rmdir : TargetLibCall< "rmdir", [Int, Ptr]>;
+
+/// double round(double x);
+def round : TargetLibCall< "round", [Dbl, Dbl]>;
+
+/// double roundeven(double x);
+def roundeven : TargetLibCall< "roundeven", [Dbl, Dbl]>;
+
+/// float roundevenf(float x);
+def roundevenf : TargetLibCall< "roundevenf", [Flt, Flt]>;
+
+/// long double roundevenl(long double x);
+def roundevenl : TargetLibCall< "roundevenl", [LDbl, LDbl]>;
+
+/// float roundf(float x);
+def roundf : TargetLibCall< "roundf", [Flt, Flt]>;
+
+/// long double roundl(long double x);
+def roundl : TargetLibCall< "roundl", [LDbl, LDbl]>;
+
+/// double scalbln(double arg, long exp);
+def scalbln : TargetLibCall< "scalbln", [Dbl, Dbl, Long]>;
+
+/// float scalblnf(float arg, long exp);
+def scalblnf : TargetLibCall< "scalblnf", [Flt, Flt, Long]>;
+
+/// long double scalblnl(long double arg, long exp);
+def scalblnl : TargetLibCall< "scalblnl", [LDbl, LDbl, Long]>;
+
+/// double scalbn(double arg, int exp);
+def scalbn : TargetLibCall< "scalbn", [Dbl, Dbl, Int]>;
+
+/// float scalbnf(float arg, int exp);
+def scalbnf : TargetLibCall< "scalbnf", [Flt, Flt, Int]>;
+
+/// long double scalbnl(long double arg, int exp);
+def scalbnl : TargetLibCall< "scalbnl", [LDbl, LDbl, Int]>;
+
+/// int scanf(const char *restrict format, ... );
+def scanf : TargetLibCall< "scanf", [Int, Ptr, Ellip]>;
+
+/// void setbuf(FILE *stream, char *buf);
+def setbuf : TargetLibCall< "setbuf", [Void, Ptr, Ptr]>;
+
+/// int setitimer(int which, const struct itimerval *value, ///               struct itimerval *ovalue);
+def setitimer : TargetLibCall< "setitimer", [Int, Int, Ptr, Ptr]>;
+
+/// int setvbuf(FILE *stream, char *buf, int type, size_t size);
+def setvbuf : TargetLibCall< "setvbuf", [Int, Ptr, Ptr, Int, SizeT]>;
+
+/// double sin(double x);
+def sin : TargetLibCall< "sin", [Dbl, Dbl]>;
+
+/// float sinf(float x);
+def sinf : TargetLibCall< "sinf", [Flt, Flt]>;
+
+/// double sinh(double x);
+def sinh : TargetLibCall< "sinh", [Dbl, Dbl]>;
+
+/// float sinhf(float x);
+def sinhf : TargetLibCall< "sinhf", [Flt, Flt]>;
+
+/// long double sinhl(long double x);
+def sinhl : TargetLibCall< "sinhl", [LDbl, LDbl]>;
+
+/// long double sinl(long double x);
+def sinl : TargetLibCall< "sinl", [LDbl, LDbl]>;
+
+/// void sincos(double x, double *sin_out, double *cos_out);
+def sincos : TargetLibCall< "sincos", [Void, Dbl, Ptr, Ptr]>;
+
+/// void sincosf(float x, float *sin_out, float *cos_out);
+def sincosf : TargetLibCall< "sincosf", [Void, Flt, Ptr, Ptr]>;
+
+/// void sincosl(long double x, long double *sin_out, long double *cos_out);
+def sincosl : TargetLibCall< "sincosl", [Void, LDbl, Ptr, Ptr]>;
+
+/// int siprintf(char *str, const char *format, ...);
+def siprintf : TargetLibCall< "siprintf", [Int, Ptr, Ptr, Ellip]>;
+
+/// int snprintf(char *s, size_t n, const char *format, ...);
+def snprintf : TargetLibCall< "snprintf", [Int, Ptr, SizeT, Ptr, Ellip]>;
+
+/// int sprintf(char *str, const char *format, ...);
+def sprintf : TargetLibCall< "sprintf", [Int, Ptr, Ptr, Ellip]>;
+
+/// double sqrt(double x);
+def sqrt : TargetLibCall< "sqrt", [Dbl, Dbl]>;
+
+/// float sqrtf(float x);
+def sqrtf : TargetLibCall< "sqrtf", [Flt, Flt]>;
+
+/// long double sqrtl(long double x);
+def sqrtl : TargetLibCall< "sqrtl", [LDbl, LDbl]>;
+
+/// int sscanf(const char *s, const char *format, ... );
+def sscanf : TargetLibCall< "sscanf", [Int, Ptr, Ptr, Ellip]>;
+
+/// int stat(const char *path, struct stat *buf);
+def stat : TargetLibCall< "stat", [Int, Ptr, Ptr]>;
+
+/// int stat64(const char *path, struct stat64 *buf);
+def stat64 : TargetLibCall< "stat64", [Int, Ptr, Ptr]>;
+
+/// int statvfs(const char *path, struct statvfs *buf);
+def statvfs : TargetLibCall< "statvfs", [Int, Ptr, Ptr]>;
+
+/// int statvfs64(const char *path, struct statvfs64 *buf)
+def statvfs64 : TargetLibCall< "statvfs64", [Int, Ptr, Ptr]>;
+
+/// char *stpcpy(char *s1, const char *s2);
+def stpcpy : TargetLibCall< "stpcpy", [Ptr, Ptr, Ptr]>;
+
+/// char *stpncpy(char *s1, const char *s2, size_t n);
+def stpncpy : TargetLibCall< "stpncpy", [Ptr, Ptr, Ptr, SizeT]>;
+
+/// int strcasecmp(const char *s1, const char *s2);
+def strcasecmp : TargetLibCall< "strcasecmp", [Int, Ptr, Ptr]>;
+
+/// char *strcat(char *s1, const char *s2);
+def strcat : TargetLibCall< "strcat", [Ptr, Ptr, Ptr]>;
+
+/// char *strchr(const char *s, int c);
+def strchr : TargetLibCall< "strchr", [Ptr, Ptr, Int]>;
+
+/// int strcmp(const char *s1, const char *s2);
+def strcmp : TargetLibCall< "strcmp", [Int, Ptr, Ptr]>;
+
+/// int strcoll(const char *s1, const char *s2);
+def strcoll : TargetLibCall< "strcoll", [Int, Ptr, Ptr]>;
+
+/// char *strcpy(char *s1, const char *s2);
+def strcpy : TargetLibCall< "strcpy", [Ptr, Ptr, Ptr]>;
+
+/// size_t strcspn(const char *s1, const char *s2);
+def strcspn : TargetLibCall< "strcspn", [SizeT, Ptr, Ptr]>;
+
+/// char *strdup(const char *s1);
+def strdup : TargetLibCall< "strdup", [Ptr, Ptr]>;
+
+/// size_t strlcat(char *dst, const char *src, size_t size);
+def strlcat : TargetLibCall< "strlcat", [SizeT, Ptr, Ptr, SizeT]>;
+
+/// size_t strlcpy(char *dst, const char *src, size_t size);
+def strlcpy : TargetLibCall< "strlcpy", [SizeT, Ptr, Ptr, SizeT]>;
+
+/// size_t strlen(const char *s);
+def strlen : TargetLibCall< "strlen", [SizeT, Ptr]>;
+
+/// int strncasecmp(const char *s1, const char *s2, size_t n);
+def strncasecmp : TargetLibCall< "strncasecmp", [Int, Ptr, Ptr, SizeT]>;
+
+/// char *strncat(char *s1, const char *s2, size_t n);
+def strncat : TargetLibCall< "strncat", [Ptr, Ptr, Ptr, SizeT]>;
+
+/// int strncmp(const char *s1, const char *s2, size_t n);
+def strncmp : TargetLibCall< "strncmp", [Int, Ptr, Ptr, SizeT]>;
+
+/// char *strncpy(char *s1, const char *s2, size_t n);
+def strncpy : TargetLibCall< "strncpy", [Ptr, Ptr, Ptr, SizeT]>;
+
+/// char *strndup(const char *s1, size_t n);
+def strndup : TargetLibCall< "strndup", [Ptr, Ptr, SizeT]>;
+
+/// size_t strnlen(const char *s, size_t maxlen);
+def strnlen : TargetLibCall< "strnlen", [SizeT, Ptr, SizeT]>;
+
+/// char *strpbrk(const char *s1, const char *s2);
+def strpbrk : TargetLibCall< "strpbrk", [Ptr, Ptr, Ptr]>;
+
+/// char *strrchr(const char *s, int c);
+def strrchr : TargetLibCall< "strrchr", [Ptr, Ptr, Int]>;
+
+/// size_t strspn(const char *s1, const char *s2);
+def strspn : TargetLibCall< "strspn", [SizeT, Ptr, Ptr]>;
+
+/// char *strstr(const char *s1, const char *s2);
+def strstr : TargetLibCall< "strstr", [Ptr, Ptr, Ptr]>;
+
+/// double strtod(const char *nptr, char **endptr);
+def strtod : TargetLibCall< "strtod", [Dbl, Ptr, Ptr]>;
+
+/// float strtof(const char *nptr, char **endptr);
+def strtof : TargetLibCall< "strtof", [Flt, Ptr, Ptr]>;
+
+/// char *strtok(char *s1, const char *s2);
+def strtok : TargetLibCall< "strtok", [Ptr, Ptr, Ptr]>;
+
+/// char *strtok_r(char *s, const char *sep, char **lasts);
+def strtok_r : TargetLibCall< "strtok_r", [Ptr, Ptr, Ptr, Ptr]>;
+
+/// long int strtol(const char *nptr, char **endptr, int base);
+def strtol : TargetLibCall< "strtol", [Long, Ptr, Ptr, Int]>;
+
+/// long double strtold(const char *nptr, char **endptr);
+def strtold : TargetLibCall< "strtold", [LDbl, Ptr, Ptr]>;
+
+/// long long int strtoll(const char *nptr, char **endptr, int base);
+def strtoll : TargetLibCall< "strtoll", [LLong, Ptr, Ptr, Int]>;
+
+/// unsigned long int strtoul(const char *nptr, char **endptr, int base);
+def strtoul : TargetLibCall< "strtoul", [Long, Ptr, Ptr, Int]>;
+
+/// unsigned long long int strtoull(const char *nptr, char **endptr, int base);
+def strtoull : TargetLibCall< "strtoull", [LLong, Ptr, Ptr, Int]>;
+
+/// size_t strxfrm(char *s1, const char *s2, size_t n);
+def strxfrm : TargetLibCall< "strxfrm", [SizeT, Ptr, Ptr, SizeT]>;
+
+/// int system(const char *command);
+def system : TargetLibCall< "system", [Int, Ptr]>;
+
+/// double tan(double x);
+def tan : TargetLibCall< "tan", [Dbl, Dbl]>;
+
+/// float tanf(float x);
+def tanf : TargetLibCall< "tanf", [Flt, Flt]>;
+
+/// double tanh(double x);
+def tanh : TargetLibCall< "tanh", [Dbl, Dbl]>;
+
+/// float tanhf(float x);
+def tanhf : TargetLibCall< "tanhf", [Flt, Flt]>;
+
+/// long double tanhl(long double x);
+def tanhl : TargetLibCall< "tanhl", [LDbl, LDbl]>;
+
+/// long double tanl(long double x);
+def tanl : TargetLibCall< "tanl", [LDbl, LDbl]>;
+
+/// clock_t times(struct tms *buffer);
+def times : TargetLibCall< "times", [IntPlus, Ptr]>;
+
+/// FILE *tmpfile(void);
+def tmpfile : TargetLibCall< "tmpfile", [Ptr]>;
+
+/// FILE *tmpfile64(void)
+def tmpfile64 : TargetLibCall< "tmpfile64", [Ptr]>;
+
+/// int toascii(int c);
+def toascii : TargetLibCall< "toascii", [Int, Int]>;
+
+/// double trunc(double x);
+def trunc : TargetLibCall< "trunc", [Dbl, Dbl]>;
+
+/// float truncf(float x);
+def truncf : TargetLibCall< "truncf", [Flt, Flt]>;
+
+/// long double truncl(long double x);
+def truncl : TargetLibCall< "truncl", [LDbl, LDbl]>;
+
+/// int uname(struct utsname *name);
+def uname : TargetLibCall< "uname", [Int, Ptr]>;
+
+/// int ungetc(int c, FILE *stream);
+def ungetc : TargetLibCall< "ungetc", [Int, Int, Ptr]>;
+
+/// int unlink(const char *path);
+def unlink : TargetLibCall< "unlink", [Int, Ptr]>;
+
+/// int unsetenv(const char *name);
+def unsetenv : TargetLibCall< "unsetenv", [Int, Ptr]>;
+
+/// int utime(const char *path, const struct utimbuf *times);
+def utime : TargetLibCall< "utime", [Int, Ptr, Ptr]>;
+
+/// int utimes(const char *path, const struct timeval times[2]);
+def utimes : TargetLibCall< "utimes", [Int, Ptr, Ptr]>;
+
+/// void *valloc(size_t size);
+def valloc : TargetLibCall< "valloc", [Ptr, SizeT]>;
+
+/// void *vec_calloc(size_t count, size_t size);
+def vec_calloc : TargetLibCall< "vec_calloc", [Ptr, SizeT, SizeT]>;
+
+/// void vec_free(void *ptr);
+def vec_free : TargetLibCall< "vec_free", [Void, Ptr]>;
+
+/// void *vec_malloc(size_t size);
+def vec_malloc : TargetLibCall< "vec_malloc", [Ptr, SizeT]>;
+
+/// void *vec_realloc(void *ptr, size_t size);
+def vec_realloc : TargetLibCall< "vec_realloc", [Ptr, Ptr, SizeT]>;
+
+/// int vfprintf(FILE *stream, const char *format, va_list ap);
+def vfprintf : TargetLibCall< "vfprintf", [Int, Ptr, Ptr, Ptr]>;
+
+/// int vfscanf(FILE *stream, const char *format, va_list arg);
+def vfscanf : TargetLibCall< "vfscanf", [Int, Ptr, Ptr, Ptr]>;
+
+/// int vprintf(const char *restrict format, va_list ap);
+def vprintf : TargetLibCall< "vprintf", [Int, Ptr, Ptr]>;
+
+/// int vscanf(const char *format, va_list arg);
+def vscanf : TargetLibCall< "vscanf", [Int, Ptr, Ptr]>;
+
+/// int vsnprintf(char *s, size_t n, const char *format, va_list ap);
+def vsnprintf : TargetLibCall< "vsnprintf", [Int, Ptr, SizeT, Ptr, Ptr]>;
+
+/// int vsprintf(char *s, const char *format, va_list ap);
+def vsprintf : TargetLibCall< "vsprintf", [Int, Ptr, Ptr, Ptr]>;
+
+/// int vsscanf(const char *s, const char *format, va_list arg);
+def vsscanf : TargetLibCall< "vsscanf", [Int, Ptr, Ptr, Ptr]>;
+
+/// size_t wcslen (const wchar_t* wcs);
+def wcslen : TargetLibCall< "wcslen", [SizeT, Ptr]>;
+
+/// ssize_t write(int fildes, const void *buf, size_t nbyte);
+def write : TargetLibCall< "write", [SSizeT, Int, Ptr, SizeT]>;
diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfoImpl.td b/llvm/include/llvm/Analysis/TargetLibraryInfoImpl.td
new file mode 100644
index 0000000000000..1e3235f258851
--- /dev/null
+++ b/llvm/include/llvm/Analysis/TargetLibraryInfoImpl.td
@@ -0,0 +1,42 @@
+//===-- TargetLibraryInfoImpl.td - File that describes library functions --===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Return type or argument type of library function.
+class FuncArgType {
+  string Name = NAME;
+}
+
+// Recognized types of library function arguments and return types.
+def Void : FuncArgType;
+def Bool : FuncArgType;     // 8 bits on all targets
+def Int16 : FuncArgType;
+def Int32 : FuncArgType;
+def Int : FuncArgType;
+def IntPlus : FuncArgType;  // Int or bigger.
+def Long : FuncArgType;     // Either 32 or 64 bits.
+def IntX : FuncArgType;     // Any integer type.
+def Int64 : FuncArgType;
+def LLong : FuncArgType;    // 64 bits on all targets.
+def SizeT : FuncArgType;    // size_t.
+def SSizeT : FuncArgType;   // POSIX ssize_t.
+def Flt : FuncArgType;      // IEEE float.
+def Dbl : FuncArgType;      // IEEE double.
+def LDbl : FuncArgType;     // Any floating type (TODO: tighten this up).
+def Floating : FuncArgType; // Any floating type.
+def Ptr : FuncArgType;      // Any pointer type.
+def Struct : FuncArgType;   // Any struct type.
+def Ellip : FuncArgType;    // The ellipsis (...).
+def Same : FuncArgType;     // Same argument type as the previous one.
+
+
+// Definition of library function.
+class TargetLibCall<string Str, list<FuncArgType> Sig> {
+  string Name = NAME;
+  string String = Str;
+  list<FuncArgType> Signature = Sig;
+}
diff --git a/llvm/include/llvm/CMakeLists.txt b/llvm/include/llvm/CMakeLists.txt
index ac6b96a68ab92..81da4f6cb9a90 100644
--- a/llvm/include/llvm/CMakeLists.txt
+++ b/llvm/include/llvm/CMakeLists.txt
@@ -2,6 +2,7 @@
 # LLVM_HEADERS_TABLEGEN points to `llvm-min-tblgen`
 set(LLVM_TABLEGEN_PROJECT LLVM_HEADERS)
 
+add_subdirectory(Analysis)
 add_subdirectory(CodeGen)
 add_subdirectory(IR)
 add_subdirectory(Support)
diff --git a/llvm/include/llvm/TableGen/StringToOffsetTable.h b/llvm/include/llvm/TableGen/StringToOffsetTable.h
index 154ded8e94d7f..5ee5fb538f3eb 100644
--- a/llvm/include/llvm/TableGen/StringToOffsetTable.h
+++ b/llvm/include/llvm/TableGen/StringToOffsetTable.h
@@ -28,10 +28,13 @@ class StringToOffsetTable {
   /// plus ::)
   const StringRef ClassPrefix;
   const bool AppendZero;
+  const bool UsePrefixForStorageMember;
 
 public:
-  StringToOffsetTable(bool AppendZero = true, StringRef ClassPrefix = "")
-      : ClassPrefix(ClassPrefix), AppendZero(AppendZero) {
+  StringToOffsetTable(bool AppendZero = true, StringRef ClassPrefix = "",
+                      bool UsePrefixForStorageMember = true)
+      : ClassPrefix(ClassPrefix), AppendZero(AppendZero),
+        UsePrefixForStorageMember(UsePrefixForStorageMember) {
     // Ensure we always put the empty string at offset zero. That lets empty
     // initialization also be zero initialization for offsets into the table.
     GetOrAddStringOffset("");
diff --git a/llvm/lib/Analysis/BranchProbabilityInfo.cpp b/llvm/lib/Analysis/BranchProbabilityInfo.cpp
index 671e023415a6e..4a99a40e0d2cc 100644
--- a/llvm/lib/Analysis/BranchProbabilityInfo.cpp
+++ b/llvm/lib/Analysis/BranchProbabilityInfo.cpp
@@ -987,7 +987,7 @@ bool BranchProbabilityInfo::calcZeroHeuristics(const BasicBlock *BB,
           return false;
 
   // Check if the LHS is the return value of a library function
-  LibFunc Func = NumLibFuncs;
+  LibFunc Func = LibFunc::NotLibFunc;
   if (TLI)
     if (CallInst *Call = dyn_cast<CallInst>(CI->getOperand(0)))
       if (Function *CalledFn = Call->getCalledFunction())
diff --git a/llvm/lib/Analysis/CMakeLists.txt b/llvm/lib/Analysis/CMakeLists.txt
index 16dd6f8b86006..b803c441a8341 100644
--- a/llvm/lib/Analysis/CMakeLists.txt
+++ b/llvm/lib/Analysis/CMakeLists.txt
@@ -166,6 +166,7 @@ add_llvm_component_library(LLVMAnalysis
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Analysis
 
   DEPENDS
+  analysis_gen
   intrinsics_gen
   ${MLDeps}
 
diff --git a/llvm/lib/Analysis/TargetLibraryInfo.cpp b/llvm/lib/Analysis/TargetLibraryInfo.cpp
index 813632c375308..2b8c8ae296097 100644
--- a/llvm/lib/Analysis/TargetLibraryInfo.cpp
+++ b/llvm/lib/Analysis/TargetLibraryInfo.cpp
@@ -13,6 +13,7 @@
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringTable.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Module.h"
 #include "llvm/InitializePasses.h"
@@ -42,11 +43,8 @@ static cl::opt<TargetLibraryInfoImpl::VectorLibrary> ClVectorLibrary(
                clEnumValN(TargetLibraryInfoImpl::AMDLIBM, "AMDLIBM",
                           "AMD vector math library")));
 
-StringLiteral const TargetLibraryInfoImpl::StandardNames[LibFunc::NumLibFuncs] =
-    {
-#define TLI_DEFINE_STRING
-#include "llvm/Analysis/TargetLibraryInfo.def"
-};
+#define GET_TARGET_LIBRARY_INFO_STRING_TABLE
+#include "llvm/Analysis/TargetLibraryInfo.inc"
 
 std::string VecDesc::getVectorFunctionABIVariantString() const {
   assert(!VectorFnName.empty() && "Vector function name must not be empty.");
@@ -56,39 +54,8 @@ std::string VecDesc::getVectorFunctionABIVariantString() const {
   return std::string(Out.str());
 }
 
-// Recognized types of library function arguments and return types.
-enum FuncArgTypeID : char {
-  Void = 0, // Must be zero.
-  Bool,     // 8 bits on all targets
-  Int16,
-  Int32,
-  Int,
-  IntPlus, // Int or bigger.
-  Long,    // Either 32 or 64 bits.
-  IntX,    // Any integer type.
-  Int64,
-  LLong,    // 64 bits on all targets.
-  SizeT,    // size_t.
-  SSizeT,   // POSIX ssize_t.
-  Flt,      // IEEE float.
-  Dbl,      // IEEE double.
-  LDbl,     // Any floating type (TODO: tighten this up).
-  Floating, // Any floating type.
-  Ptr,      // Any pointer type.
-  Struct,   // Any struct type.
-  Ellip,    // The ellipsis (...).
-  Same,     // Same argument type as the previous one.
-};
-
-typedef std::array<FuncArgTypeID, 8> FuncProtoTy;
-
-static const FuncProtoTy Signatures[] = {
-#define TLI_DEFINE_SIG
-#include "llvm/Analysis/TargetLibraryInfo.def"
-};
-
-static_assert(sizeof Signatures / sizeof *Signatures == LibFunc::NumLibFuncs,
-              "Missing library function signatures");
+#define GET_TARGET_LIBRARY_INFO_SIGNATURE_TABLE
+#include "llvm/Analysis/TargetLibraryInfo.inc"
 
 static bool hasSinCosPiStret(const Triple &T) {
   // Only Darwin variants have _stret versions of combined trig functions.
@@ -182,7 +149,7 @@ static void initializeBase(TargetLibraryInfoImpl &TLI, const Triple &T) {
 /// target triple. This should be carefully written so that a missing target
 /// triple gets a sane set of defaults.
 static void initializeLibCalls(TargetLibraryInfoImpl &TLI, const Triple &T,
-                               ArrayRef<StringLiteral> StandardNames) {
+                               const llvm::StringTable &StandardNames) {
   // Set IO unlocked variants as unavailable
   // Set them as available per system below
   TLI.setUnavailable(LibFunc_getc_unlocked);
@@ -947,7 +914,7 @@ static void initializeLibCalls(TargetLibraryInfoImpl &TLI, const Triple &T,
 /// target triple. This should be carefully written so that a missing target
 /// triple gets a sane set of defaults.
 static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
-                       ArrayRef<StringLiteral> StandardNames) {
+                       const llvm::StringTable &StandardNames) {
   initializeBase(TLI, T);
   initializeLibCalls(TLI, T, StandardNames);
 }
@@ -956,7 +923,7 @@ TargetLibraryInfoImpl::TargetLibraryInfoImpl(const Triple &T) {
   // Default to everything being available.
   memset(AvailableArray, -1, sizeof(AvailableArray));
 
-  initialize(*this, T, StandardNames);
+  initialize(*this, T, StandardNamesStrTable);
 }
 
 TargetLibraryInfoImpl::TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI)
@@ -1018,7 +985,7 @@ static StringRef sanitizeFunctionName(StringRef funcName) {
 }
 
 static DenseMap<StringRef, LibFunc>
-buildIndexMap(ArrayRef<StringLiteral> StandardNames) {
+buildIndexMap(const llvm::StringTable &StandardNames) {
   DenseMap<StringRef, LibFunc> Indices;
   unsigned Idx = 0;
   Indices.reserve(LibFunc::NumLibFuncs);
@@ -1033,7 +1000,7 @@ bool TargetLibraryInfoImpl::getLibFunc(StringRef funcName, LibFunc &F) const {
     return false;
 
   static const DenseMap<StringRef, LibFunc> Indices =
-      buildIndexMap(StandardNames);
+      buildIndexMap(StandardNamesStrTable);
 
   if (auto Loc = Indices.find(funcName); Loc != Indices.end()) {
     F = Loc->second;
@@ -1203,18 +1170,18 @@ bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy,
   // against the function's type FTy, starting with its return type.
   // Return true if both match in number and kind, inclduing the ellipsis.
   Type *Ty = FTy.getReturnType(), *LastTy = Ty;
-  const auto &ProtoTypes = Signatures[F];
-  for (auto TyID : ProtoTypes) {
-    if (Idx && TyID == Void)
-      // Except in the first position where it designates the function's
-      // return type Void ends the argument list.
+  const auto *ProtoTypes = &SignatureTable[SignatureOffset[F]];
+  for (auto TyID = ProtoTypes[Idx]; TyID != NoFuncArgType;
+       TyID = ProtoTypes[++Idx]) {
+    if (TyID == NoFuncArgType)
       break;
 
     if (TyID == Ellip) {
       // The ellipsis ends the protoype list but is not a part of FTy's
       // argument list.  Except when it's last it must be followed by
-      // Void.
-      assert(Idx == ProtoTypes.size() - 1 || ProtoTypes[Idx + 1] == Void);
+      // NoFuncArgType.
+      assert(ProtoTypes[Idx] == NoFuncArgType ||
+             ProtoTypes[Idx + 1] == NoFuncArgType);
       return FTy.isFunctionVarArg();
     }
 
@@ -1232,11 +1199,10 @@ bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy,
       // There's at least one and at most two more type ids than there are
       // arguments in FTy's argument list.
       Ty = nullptr;
-      ++Idx;
       continue;
     }
 
-    Ty = FTy.getParamType(Idx++);
+    Ty = FTy.getParamType(Idx);
   }
 
   // Return success only if all entries on both lists have been processed
diff --git a/llvm/lib/LTO/UpdateCompilerUsed.cpp b/llvm/lib/LTO/UpdateCompilerUsed.cpp
index c95aaaf30bf80..1889c2b762ff7 100644
--- a/llvm/lib/LTO/UpdateCompilerUsed.cpp
+++ b/llvm/lib/LTO/UpdateCompilerUsed.cpp
@@ -62,8 +62,8 @@ class PreserveLibCallsAndAsmUsed {
 
     // TargetLibraryInfo has info on C runtime library calls on the current
     // target.
-    for (unsigned I = 0, E = static_cast<unsigned>(LibFunc::NumLibFuncs);
-         I != E; ++I) {
+    for (unsigned I = LibFunc::Begin_LibFunc, E = LibFunc::End_LibFunc; I != E;
+         ++I) {
       LibFunc F = static_cast<LibFunc>(I);
       if (TLI.has(F))
         Libcalls.insert(TLI.getName(F));
diff --git a/llvm/lib/TableGen/StringToOffsetTable.cpp b/llvm/lib/TableGen/StringToOffsetTable.cpp
index 41f82caa12f82..06d8240486245 100644
--- a/llvm/lib/TableGen/StringToOffsetTable.cpp
+++ b/llvm/lib/TableGen/StringToOffsetTable.cpp
@@ -39,7 +39,8 @@ void StringToOffsetTable::EmitStringTableDef(raw_ostream &OS,
 #pragma GCC diagnostic ignored "-Woverlength-strings"
 #endif
 {} constexpr char {}{}Storage[] =)",
-                ClassPrefix.empty() ? "static" : "", ClassPrefix, Name);
+                ClassPrefix.empty() ? "static" : "",
+                UsePrefixForStorageMember ? ClassPrefix : "", Name);
 
   // MSVC silently miscompiles string literals longer than 64k in some
   // circumstances. The build system sets EmitLongStrLiterals to false when it
diff --git a/llvm/lib/Transforms/Instrumentation/NumericalStabilitySanitizer.cpp b/llvm/lib/Transforms/Instrumentation/NumericalStabilitySanitizer.cpp
index 80e77e099c695..85e25a0732ff6 100644
--- a/llvm/lib/Transforms/Instrumentation/NumericalStabilitySanitizer.cpp
+++ b/llvm/lib/Transforms/Instrumentation/NumericalStabilitySanitizer.cpp
@@ -811,7 +811,7 @@ static bool shouldCheckArgs(CallBase &CI, const TargetLibraryInfo &TLI,
     return false;
 
   const auto ID = Fn->getIntrinsicID();
-  LibFunc LFunc = LibFunc::NumLibFuncs;
+  LibFunc LFunc = LibFunc::NotLibFunc;
   // Always check args of unknown functions.
   if (ID == Intrinsic::ID() && !TLI.getLibFunc(*Fn, LFunc))
     return true;
diff --git a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
index 4a1565977b91c..4f4e64b1c7b70 100644
--- a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
+++ b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
@@ -2921,7 +2921,7 @@ Value *LibCallSimplifier::optimizeTrigInversionPairs(CallInst *CI,
                               .Case("asinh", LibFunc_sinh)
                               .Case("asinhf", LibFunc_sinhf)
                               .Case("asinhl", LibFunc_sinhl)
-                              .Default(NumLibFuncs); // Used as error value
+                              .Default(NotLibFunc); // Used as error value
     if (Func == inverseFunc)
       Ret = OpC->getArgOperand(0);
   }
diff --git a/llvm/test/TableGen/TargetLibraryInfo.td b/llvm/test/TableGen/TargetLibraryInfo.td
new file mode 100644
index 0000000000000..4b756af35ecf5
--- /dev/null
+++ b/llvm/test/TableGen/TargetLibraryInfo.td
@@ -0,0 +1,101 @@
+// RUN: llvm-tblgen -gen-target-library-info -I %p/../../include %s | FileCheck %s
+
+include "llvm/Analysis/TargetLibraryInfoImpl.td"
+
+def cosf : TargetLibCall< "cosf", [Flt, Flt]>;
+def sinf : TargetLibCall< "sinf", [Flt, Flt]>;
+
+def fmaxf : TargetLibCall< "fmaxf", [Floating, Same, Same]>;
+
+def printf : TargetLibCall< "printf", [Int, Ptr, Ellip]>;
+
+
+// CHECK:      #ifdef GET_TARGET_LIBRARY_INFO_ENUM
+// CHECK-NEXT: #undef GET_TARGET_LIBRARY_INFO_ENUM
+// CHECK-NEXT: enum LibFunc : unsigned {
+// CHECK-NEXT:   NotLibFunc = 0,
+// CHECK-NEXT:   LibFunc_cosf,
+// CHECK-NEXT:   LibFunc_sinf,
+// CHECK-NEXT:   LibFunc_fmaxf,
+// CHECK-NEXT:   LibFunc_printf,
+// CHECK-NEXT:   NumLibFuncs,
+// CHECK-NEXT:   End_LibFunc = NumLibFuncs,
+// CHECK-NEXT:   Begin_LibFunc = LibFunc_cosf,
+// CHECK-NEXT: };
+// CHECK-NEXT: #endif
+
+// CHECK:      #ifdef GET_TARGET_LIBRARY_INFO_STRING_TABLE
+// CHECK-NEXT: #undef GET_TARGET_LIBRARY_INFO_STRING_TABLE
+
+// CHECK:      #ifdef __GNUC__
+// CHECK-NEXT: #pragma GCC diagnostic push
+// CHECK-NEXT: #pragma GCC diagnostic ignored "-Woverlength-strings"
+// CHECK-NEXT: #endif
+// CHECK-NEXT:  constexpr char StandardNamesStrTableStorage[] =
+// CHECK-NEXT:   "\0"
+// CHECK-NEXT:   "cosf\0"
+// CHECK-NEXT:   "sinf\0"
+// CHECK-NEXT:   "fmaxf\0"
+// CHECK-NEXT:   "printf\0"
+// CHECK-NEXT:   ;
+// CHECK-NEXT: #ifdef __GNUC__
+// CHECK-NEXT: #pragma GCC diagnostic pop
+// CHECK-NEXT: #endif
+
+// CHECK:      const llvm::StringTable
+// CHECK-NEXT: TargetLibraryInfoImpl::StandardNamesStrTable = StandardNamesStrTableStorage;
+
+// CHECK:      const llvm::StringTable::Offset TargetLibraryInfoImpl::StandardNamesOffsets[5] = {
+// CHECK-NEXT:   0, //
+// CHECK-NEXT:   1, // cosf
+// CHECK-NEXT:   6, // sinf
+// CHECK-NEXT:   11, // fmaxf
+// CHECK-NEXT:   17, // printf
+// CHECK-NEXT: };
+// CHECK-NEXT: #endif
+
+// CHECK:      #ifdef GET_TARGET_LIBRARY_INFO_IMPL_DECL
+// CHECK-NEXT: #undef GET_TARGET_LIBRARY_INFO_IMPL_DECL
+// CHECK-NEXT: LLVM_ABI static const llvm::StringTable StandardNamesStrTable;
+// CHECK-NEXT: LLVM_ABI static const llvm::StringTable::Offset StandardNamesOffsets[5];
+// CHECK-NEXT: #endif
+
+// CHECK:      #ifdef GET_TARGET_LIBRARY_INFO_SIGNATURE_TABLE
+// CHECK-NEXT: #undef GET_TARGET_LIBRARY_INFO_SIGNATURE_TABLE
+// CHECK-NEXT: enum FuncArgTypeID : char {
+// CHECK-NEXT:   NoFuncArgType = 0,
+// CHECK-NEXT:   Void,
+// CHECK-NEXT:   Bool,
+// CHECK-NEXT:   Int16,
+// CHECK-NEXT:   Int32,
+// CHECK-NEXT:   Int,
+// CHECK-NEXT:   IntPlus,
+// CHECK-NEXT:   Long,
+// CHECK-NEXT:   IntX,
+// CHECK-NEXT:   Int64,
+// CHECK-NEXT:   LLong,
+// CHECK-NEXT:   SizeT,
+// CHECK-NEXT:   SSizeT,
+// CHECK-NEXT:   Flt,
+// CHECK-NEXT:   Dbl,
+// CHECK-NEXT:   LDbl,
+// CHECK-NEXT:   Floating,
+// CHECK-NEXT:   Ptr,
+// CHECK-NEXT:   Struct,
+// CHECK-NEXT:   Ellip,
+// CHECK-NEXT:   Same,
+// CHECK-NEXT: };
+// CHECK-NEXT: static const FuncArgTypeID SignatureTable[] = {
+// CHECK-NEXT:   /* 0 */ Int, Ptr, Ellip, NoFuncArgType,
+// CHECK-NEXT:   /* 4 */ Flt, Flt, NoFuncArgType,
+// CHECK-NEXT:   /* 7 */ Floating, Same, Same, NoFuncArgType,
+// CHECK-NEXT:   /* 11 */ Void, NoFuncArgType,
+// CHECK-NEXT: };
+// CHECK-NEXT: static const unsigned short SignatureOffset[] = {
+// CHECK-NEXT:   11, //
+// CHECK-NEXT:   4, // cosf
+// CHECK-NEXT:   4, // sinf
+// CHECK-NEXT:   7, // fmaxf
+// CHECK-NEXT:   0, // printf
+// CHECK-NEXT: };
+// CHECK-NEXT: #endif
diff --git a/llvm/tools/llvm-tli-checker/llvm-tli-checker.cpp b/llvm/tools/llvm-tli-checker/llvm-tli-checker.cpp
index 0cf8c5c63bef2..26fb2cb9f497a 100644
--- a/llvm/tools/llvm-tli-checker/llvm-tli-checker.cpp
+++ b/llvm/tools/llvm-tli-checker/llvm-tli-checker.cpp
@@ -113,19 +113,20 @@ static void reportNumberOfEntries(const TargetLibraryInfo &TLI,
 
   // Assume this gets called after initialize(), so we have the above line of
   // output as a header.  So, for example, no need to repeat the triple.
-  for (unsigned FI = 0; FI != LibFunc::NumLibFuncs; ++FI) {
+  for (unsigned FI = LibFunc::Begin_LibFunc; FI != LibFunc::End_LibFunc; ++FI) {
     if (TLI.has(static_cast<LibFunc>(FI)))
       ++NumAvailable;
   }
 
-  outs() << "TLI knows " << LibFunc::NumLibFuncs << " symbols, " << NumAvailable
-         << " available for '" << TargetTriple << "'\n";
+  outs() << "TLI knows " << (LibFunc::End_LibFunc - LibFunc::Begin_LibFunc)
+         << " symbols, " << NumAvailable << " available for '" << TargetTriple
+         << "'\n";
 }
 
 static void dumpTLIEntries(const TargetLibraryInfo &TLI) {
   // Assume this gets called after initialize(), so we have the above line of
   // output as a header.  So, for example, no need to repeat the triple.
-  for (unsigned FI = 0; FI != LibFunc::NumLibFuncs; ++FI) {
+  for (unsigned FI = LibFunc::Begin_LibFunc; FI != LibFunc::End_LibFunc; ++FI) {
     LibFunc LF = static_cast<LibFunc>(FI);
     bool IsAvailable = TLI.has(LF);
     StringRef FuncName = TargetLibraryInfo::getStandardName(LF);
@@ -316,7 +317,7 @@ int main(int argc, char *argv[]) {
     unsigned TLIandSDKboth = 0;
     unsigned TLIandSDKneither = 0;
 
-    for (unsigned FI = 0; FI != LibFunc::NumLibFuncs; ++FI) {
+    for (unsigned FI = LibFunc::Begin_LibFunc; FI != LibFunc::End_LibFunc; ++FI) {
       LibFunc LF = static_cast<LibFunc>(FI);
 
       StringRef TLIName = TLI.getStandardName(LF);
@@ -344,7 +345,7 @@ int main(int argc, char *argv[]) {
 
     assert(TLIandSDKboth + TLIandSDKneither + TLIdoesSDKdoesnt +
                TLIdoesntSDKdoes ==
-           LibFunc::NumLibFuncs);
+           LibFunc::End_LibFunc - LibFunc::Begin_LibFunc);
     (void) TLIandSDKneither;
     outs() << "<< Total TLI yes SDK no:  " << TLIdoesSDKdoesnt
            << "\n>> Total TLI no  SDK yes: " << TLIdoesntSDKdoes
diff --git a/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp b/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp
index b33419545efa8..f1c599b335dcc 100644
--- a/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp
+++ b/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp
@@ -64,7 +64,7 @@ TEST_F(TargetLibraryInfoTest, InvalidProto) {
   auto *StructTy = StructType::getTypeByName(Context, "foo");
   auto *InvalidFTy = FunctionType::get(StructTy, /*isVarArg=*/false);
 
-  for (unsigned FI = 0; FI != LibFunc::NumLibFuncs; ++FI) {
+  for (unsigned FI = LibFunc::Begin_LibFunc; FI != LibFunc::End_LibFunc; ++FI) {
     LibFunc LF = (LibFunc)FI;
     auto *F = cast<Function>(
         M->getOrInsertFunction(TLI.getName(LF), InvalidFTy).getCallee());
@@ -688,7 +688,7 @@ TEST_F(TargetLibraryInfoTest, ValidProto) {
       "declare i8* @__kmpc_alloc_shared(i64)\n"
       "declare void @__kmpc_free_shared(i8*, i64)\n");
 
-  for (unsigned FI = 0; FI != LibFunc::NumLibFuncs; ++FI) {
+  for (unsigned FI = LibFunc::Begin_LibFunc; FI != LibFunc::End_LibFunc; ++FI) {
     LibFunc LF = (LibFunc)FI;
     // Make sure everything is available; we're not testing target defaults.
     TLII.setAvailable(LF);
diff --git a/llvm/utils/TableGen/Basic/CMakeLists.txt b/llvm/utils/TableGen/Basic/CMakeLists.txt
index b4a66ecce6440..ec4e158b61a50 100644
--- a/llvm/utils/TableGen/Basic/CMakeLists.txt
+++ b/llvm/utils/TableGen/Basic/CMakeLists.txt
@@ -19,6 +19,7 @@ add_llvm_library(LLVMTableGenBasic OBJECT EXCLUDE_FROM_ALL DISABLE_LLVM_LINK_LLV
   SDNodeProperties.cpp
   TableGen.cpp
   TargetFeaturesEmitter.cpp
+  TargetLibraryInfoEmitter.cpp
   VTEmitter.cpp
 )
 
diff --git a/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp b/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp
new file mode 100644
index 0000000000000..9c7dd44df2f57
--- /dev/null
+++ b/llvm/utils/TableGen/Basic/TargetLibraryInfoEmitter.cpp
@@ -0,0 +1,166 @@
+//===- TargetLibraryInfoEmitter.cpp - Properties from TargetLibraryInfo.td ===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <cstddef>
+#define DEBUG_TYPE "target-library-info-emitter"
+
+#include "SequenceToOffsetTable.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/SetTheory.h"
+#include "llvm/TableGen/StringToOffsetTable.h"
+#include "llvm/TableGen/TableGenBackend.h"
+
+using namespace llvm;
+
+namespace {
+class TargetLibraryInfoEmitter {
+private:
+  const RecordKeeper &Records;
+  SmallVector<const Record *, 1024> AllTargetLibcalls;
+
+private:
+  void emitTargetLibraryInfoEnum(raw_ostream &OS) const;
+  void emitTargetLibraryInfoStringTable(raw_ostream &OS) const;
+  void emitTargetLibraryInfoSignatureTable(raw_ostream &OS) const;
+
+public:
+  TargetLibraryInfoEmitter(const RecordKeeper &R);
+
+  void run(raw_ostream &OS);
+};
+
+} // End anonymous namespace.
+
+TargetLibraryInfoEmitter::TargetLibraryInfoEmitter(const RecordKeeper &R)
+    : Records(R) {
+  ArrayRef<const Record *> All =
+      Records.getAllDerivedDefinitions("TargetLibCall");
+  AllTargetLibcalls.append(All.begin(), All.end());
+  // Make sure that the records are in the same order as the input.
+  // TODO Find a better sorting order when all is migrated.
+  sort(AllTargetLibcalls, [](const Record *A, const Record *B) {
+    return A->getID() < B->getID();
+  });
+}
+
+void TargetLibraryInfoEmitter::emitTargetLibraryInfoEnum(
+    raw_ostream &OS) const {
+  OS << "#ifdef GET_TARGET_LIBRARY_INFO_ENUM\n";
+  OS << "#undef GET_TARGET_LIBRARY_INFO_ENUM\n";
+  OS << "enum LibFunc : unsigned {\n";
+  OS.indent(2) << "NotLibFunc = 0,\n";
+  for (const auto *R : AllTargetLibcalls) {
+    OS.indent(2) << "LibFunc_" << R->getName() << ",\n";
+  }
+  OS.indent(2) << "NumLibFuncs,\n";
+  OS.indent(2) << "End_LibFunc = NumLibFuncs,\n";
+  if (AllTargetLibcalls.size()) {
+    OS.indent(2) << "Begin_LibFunc = LibFunc_"
+                 << AllTargetLibcalls[0]->getName() << ",\n";
+  } else {
+    OS.indent(2) << "Begin_LibFunc = NotLibFunc,\n";
+  }
+  OS << "};\n";
+  OS << "#endif\n\n";
+}
+
+void TargetLibraryInfoEmitter::emitTargetLibraryInfoStringTable(
+    raw_ostream &OS) const {
+  llvm::StringToOffsetTable Table(
+      /*AppendZero=*/true,
+      "TargetLibraryInfoImpl::", /*UsePrefixForStorageMember=*/false);
+  for (const auto *R : AllTargetLibcalls)
+    Table.GetOrAddStringOffset(R->getValueAsString("String"));
+
+  OS << "#ifdef GET_TARGET_LIBRARY_INFO_STRING_TABLE\n";
+  OS << "#undef GET_TARGET_LIBRARY_INFO_STRING_TABLE\n";
+  Table.EmitStringTableDef(OS, "StandardNamesStrTable");
+  OS << "\n";
+  size_t NumEl = AllTargetLibcalls.size() + 1;
+  OS << "const llvm::StringTable::Offset "
+        "TargetLibraryInfoImpl::StandardNamesOffsets["
+     << NumEl
+     << "] = "
+        "{\n";
+  OS.indent(2) << "0, //\n";
+  for (const auto *R : AllTargetLibcalls) {
+    StringRef Str = R->getValueAsString("String");
+    OS.indent(2) << Table.GetStringOffset(Str) << ", // " << Str << "\n";
+  }
+  OS << "};\n";
+  OS << "#endif\n\n";
+  OS << "#ifdef GET_TARGET_LIBRARY_INFO_IMPL_DECL\n";
+  OS << "#undef GET_TARGET_LIBRARY_INFO_IMPL_DECL\n";
+  OS << "LLVM_ABI static const llvm::StringTable StandardNamesStrTable;\n";
+  OS << "LLVM_ABI static const llvm::StringTable::Offset StandardNamesOffsets["
+     << NumEl << "];\n";
+  OS << "#endif\n\n";
+}
+
+void TargetLibraryInfoEmitter::emitTargetLibraryInfoSignatureTable(
+    raw_ostream &OS) const {
+  SmallVector<const Record *, 1024> FuncTypeArgs(
+      Records.getAllDerivedDefinitions("FuncArgType"));
+
+  // Sort the records by ID.
+  sort(FuncTypeArgs, [](const Record *A, const Record *B) {
+    return A->getID() < B->getID();
+  });
+
+  using Signature = std::vector<StringRef>;
+  SequenceToOffsetTable<Signature> SignatureTable("NoFuncArgType");
+  auto GetSignature = [](const Record *R) -> Signature {
+    const auto *Tys = R->getValueAsListInit("Signature");
+    Signature Sig;
+    for (unsigned I = 0, E = Tys->size(); I < E; ++I) {
+      Sig.push_back(Tys->getElementAsRecord(I)->getName());
+    }
+    return Sig;
+  };
+  DenseMap<unsigned, Signature> SignatureMap;
+  Signature NoFuncSig({StringRef("Void")});
+  SignatureTable.add(NoFuncSig);
+  for (const auto *R : AllTargetLibcalls)
+    SignatureTable.add(GetSignature(R));
+  SignatureTable.layout();
+
+  OS << "#ifdef GET_TARGET_LIBRARY_INFO_SIGNATURE_TABLE\n";
+  OS << "#undef GET_TARGET_LIBRARY_INFO_SIGNATURE_TABLE\n";
+  OS << "enum FuncArgTypeID : char {\n";
+  OS.indent(2) << "NoFuncArgType = 0,\n";
+  for (const auto *R : FuncTypeArgs) {
+    OS.indent(2) << R->getName() << ",\n";
+  }
+  OS << "};\n";
+  OS << "static const FuncArgTypeID SignatureTable[] = {\n";
+  SignatureTable.emit(OS, [](raw_ostream &OS, StringRef E) { OS << E; });
+  OS << "};\n";
+  OS << "static const unsigned short SignatureOffset[] = {\n";
+  OS.indent(2) << SignatureTable.get(NoFuncSig) << ", //\n";
+  for (const auto *R : AllTargetLibcalls) {
+    OS.indent(2) << SignatureTable.get(GetSignature(R)) << ", // "
+                 << R->getName() << "\n";
+  }
+  OS << "};\n";
+  OS << "#endif\n\n";
+}
+
+void TargetLibraryInfoEmitter::run(raw_ostream &OS) {
+  emitSourceFileHeader("Target Library Info Source Fragment", OS, Records);
+
+  emitTargetLibraryInfoEnum(OS);
+  emitTargetLibraryInfoStringTable(OS);
+  emitTargetLibraryInfoSignatureTable(OS);
+}
+
+static TableGen::Emitter::OptClass<TargetLibraryInfoEmitter>
+    X("gen-target-library-info", "Generate TargetLibraryInfo");