VitaNuo updated this revision to Diff 492774.
VitaNuo marked 6 inline comments as done.
VitaNuo added a comment.
Address review comments. No new tests in this version.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D142092/new/
https://reviews.llvm.org/D142092
Files:
clang/include/clang/Tooling/Inclusions/CSymbolMap.inc
clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc
clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
clang/tools/include-mapping/cppreference_parser.py
clang/tools/include-mapping/gen_std.py
Index: clang/tools/include-mapping/gen_std.py
===================================================================
--- clang/tools/include-mapping/gen_std.py
+++ clang/tools/include-mapping/gen_std.py
@@ -14,10 +14,7 @@
The generated files are located in clang/include/Tooling/Inclusions.
Caveats and FIXMEs:
- - only symbols directly in "std" namespace are added, we should also add std's
- subnamespace symbols (e.g. chrono).
- - symbols with multiple variants or defined in multiple headers aren't added,
- e.g. std::move, std::swap
+ - symbols with multiple variants aren't added, e.g., std::move
Usage:
1. Install BeautifulSoup dependency, see instruction:
@@ -109,18 +106,15 @@
cppreference_modified_date = datetime.datetime.fromtimestamp(
os.stat(index_page_path).st_mtime).strftime('%Y-%m-%d')
print(CODE_PREFIX % (args.symbols.upper(), cppreference_modified_date))
+ # FIXME: take care of overloads
for symbol in symbols:
- if len(symbol.headers) == 1:
- # SYMBOL(unqualified_name, namespace, header)
- print("SYMBOL(%s, %s, %s)" % (symbol.name, symbol.namespace,
- symbol.headers[0]))
- elif len(symbol.headers) == 0:
+ if len(symbol.headers) == 0:
sys.stderr.write("No header found for symbol %s\n" % symbol.name)
else:
- # FIXME: support symbols with multiple headers (e.g. std::move).
- sys.stderr.write("Ambiguous header for symbol %s: %s\n" % (
- symbol.name, ', '.join(symbol.headers)))
-
-
+ symbol.headers = sorted(symbol.headers)
+ for header in symbol.headers:
+ # SYMBOL(unqualified_name, namespace, header)
+ print("SYMBOL(%s, %s, %s)" % (symbol.name, symbol.namespace,
+ header))
if __name__ == '__main__':
main()
Index: clang/tools/include-mapping/cppreference_parser.py
===================================================================
--- clang/tools/include-mapping/cppreference_parser.py
+++ clang/tools/include-mapping/cppreference_parser.py
@@ -36,7 +36,7 @@
return False
-def _ParseSymbolPage(symbol_page_html, symbol_name):
+def _ParseSymbolPage(symbol_page_html, symbol_name, variant_to_accept):
"""Parse symbol page and retrieve the include header defined in this page.
The symbol page provides header for the symbol, specifically in
"Defined in header <header>" section. An example:
@@ -47,7 +47,7 @@
Returns a list of headers.
"""
- headers = set()
+ symbol_headers = set()
all_headers = set()
soup = BeautifulSoup(symbol_page_html, "html.parser")
@@ -58,32 +58,51 @@
# Defined in header <baz> .t-dsc-header
# decl2 .t-dcl
for table in soup.select('table.t-dcl-begin, table.t-dsc-begin'):
- current_headers = []
- was_decl = False
- for row in table.select('tr'):
- if _HasClass(row, 't-dcl', 't-dsc'):
- was_decl = True
- # Symbols are in the first cell.
- found_symbols = row.find('td').stripped_strings
- if not symbol_name in found_symbols:
- continue
- headers.update(current_headers)
- elif _HasClass(row, 't-dsc-header'):
- # If we saw a decl since the last header, this is a new block of headers
- # for a new block of decls.
- if was_decl:
- current_headers = []
- was_decl = False
+ rows = table.select('tr')
+ i = 0
+ while i < len(rows):
+ start = i
+ current_headers = set()
+ while i < len(rows) and _HasClass(rows[i], 't-dsc-header'):
+ row = rows[i]
# There are also .t-dsc-header for "defined in namespace".
if not "Defined in header " in row.text:
+ i = i + 1
continue
# The interesting header content (e.g. <cstdlib>) is wrapped in <code>.
for header_code in row.find_all("code"):
- current_headers.append(header_code.text)
+ # FIXME: replace with proper handling of overloads
+ if variant_to_accept != "" and header_code.text.strip("<>") != variant_to_accept:
+ continue
all_headers.add(header_code.text)
- # If the symbol was never named, consider all named headers.
- return headers or all_headers
-
+ current_headers.add(header_code.text)
+ i = i + 1
+ # Some tables have header rows, skip them.
+ while i < len(rows) and not _HasClass(rows[i], 't-dsc', 't-dcl', 't-dsc-header'):
+ i = i + 1
+ while i < len(rows) and (_HasClass(rows[i], 't-dcl', 't-dsc')
+ or not rows[i].has_attr("class")):
+ row = rows[i]
+ # Symbols are in the first cell.
+ raw_symbols = row.find('td').stripped_strings
+ found_symbols = []
+ # Finding all text in <td> is not enough, some strings contain more than
+ # one symbol (e.g., "div_t div" is parsed as single symbol).
+ for raw_symbol in raw_symbols:
+ symbols = raw_symbol.split(' ')
+ for symbol in symbols:
+ found_symbols.append(symbol.strip())
+ if symbol_name in found_symbols:
+ # Only update symbol headers on first symbol discovery, assume
+ # same symbol occurence in a subsequent header block is an overload.
+ if len(symbol_headers) == 0:
+ symbol_headers.update(current_headers)
+ i = i + 1
+ # No headers or symbols in this block
+ if i == start:
+ i = i + 1
+
+ return symbol_headers or all_headers
def _ParseIndexPage(index_page_html):
"""Parse index page.
@@ -113,9 +132,9 @@
return symbols
-def _ReadSymbolPage(path, name):
+def _ReadSymbolPage(path, name, header_to_accept):
with open(path) as f:
- return _ParseSymbolPage(f.read(), name)
+ return _ParseSymbolPage(f.read(), name, header_to_accept)
def _GetSymbols(pool, root_dir, index_page_name, namespace, variants_to_accept):
@@ -137,14 +156,16 @@
for symbol_name, symbol_page_path, variant in _ParseIndexPage(f.read()):
# Variant symbols (e.g. the std::locale version of isalpha) add ambiguity.
# FIXME: use these as a fallback rather than ignoring entirely.
- variants_for_symbol = variants_to_accept.get(
- (namespace or "") + symbol_name, ())
- if variant and variant not in variants_for_symbol:
+ variant_to_accept = ""
+ for symbol_regex in variants_to_accept:
+ if re.match(symbol_regex, (namespace or "") + symbol_name):
+ variant_to_accept = variants_to_accept.get(symbol_regex)
+ if variant and variant != variant_to_accept:
continue
path = os.path.join(root_dir, symbol_page_path)
if os.path.isfile(path):
- results.append((symbol_name,
- pool.apply_async(_ReadSymbolPage, (path, symbol_name))))
+ results.append((symbol_name, pool.apply_async(_ReadSymbolPage,
+ (path, symbol_name, variant_to_accept))))
else:
sys.stderr.write("Discarding information for symbol: %s. Page %s does not exist.\n"
% (symbol_name, path))
@@ -171,7 +192,9 @@
# those symbols.
variants_to_accept = {
# std::remove<> has variant algorithm.
- "std::remove": ("algorithm"),
+ "std::remove$": "algorithm",
+ "std::atomic.*": "atomic",
+
}
symbols = []
# Run many workers to process individual symbol pages under the symbol index.
Index: clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
===================================================================
--- clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
+++ clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
@@ -8,6 +8,7 @@
#include "clang/Tooling/Inclusions/StandardLibrary.h"
#include "clang/AST/Decl.h"
+#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Casting.h"
@@ -17,7 +18,7 @@
static llvm::StringRef *HeaderNames;
static std::pair<llvm::StringRef, llvm::StringRef> *SymbolNames;
-static unsigned *SymbolHeaderIDs;
+static llvm::SmallVector<unsigned> *SymbolHeaderIDs;
static llvm::DenseMap<llvm::StringRef, unsigned> *HeaderIDs;
// Maps symbol name -> Symbol::ID, within a namespace.
using NSSymbolMap = llvm::DenseMap<llvm::StringRef, unsigned>;
@@ -46,18 +47,26 @@
return HeaderIDs->try_emplace(Header, HeaderIDs->size()).first->second;
};
- auto Add = [&, SymIndex(0)](llvm::StringRef Name, llvm::StringRef NS,
- llvm::StringRef HeaderName) mutable {
+ auto Add = [&, SymIndex(-1)](llvm::StringRef Name, llvm::StringRef NS,
+ llvm::StringRef HeaderName) mutable {
if (NS == "None")
NS = "";
+ // Determine whether the symbol is new. This relies on symbols being
+ // ordered alpahbetically in the map.
+ if (SymIndex >= 0 && SymbolNames[SymIndex].first == NS &&
+ SymbolNames[SymIndex].second == Name) {
+ // Not a new symbol, use the same index.
+ } else {
+ // First symbol or new symbol, increment next available index.
+ ++SymIndex;
+ }
+
SymbolNames[SymIndex] = {NS, Name};
- SymbolHeaderIDs[SymIndex] = AddHeader(HeaderName);
+ SymbolHeaderIDs[SymIndex].emplace_back(AddHeader(HeaderName));
NSSymbolMap &NSSymbols = AddNS(NS);
NSSymbols.try_emplace(Name, SymIndex);
-
- ++SymIndex;
};
#define SYMBOL(Name, NS, Header) Add(#Name, #NS, #Header);
#include "clang/Tooling/Inclusions/CSymbolMap.inc"
@@ -87,7 +96,7 @@
llvm::StringRef Symbol::scope() const { return SymbolNames[ID].first; }
llvm::StringRef Symbol::name() const { return SymbolNames[ID].second; }
std::optional<Symbol> Symbol::named(llvm::StringRef Scope,
- llvm::StringRef Name) {
+ llvm::StringRef Name) {
ensureInitialized();
if (NSSymbolMap *NSSymbols = NamespaceSymbols->lookup(Scope)) {
auto It = NSSymbols->find(Name);
@@ -96,9 +105,14 @@
}
return std::nullopt;
}
-Header Symbol::header() const { return Header(SymbolHeaderIDs[ID]); }
+
+Header Symbol::header() const { return Header(SymbolHeaderIDs[ID][0]); }
llvm::SmallVector<Header> Symbol::headers() const {
- return {header()}; // FIXME: multiple in case of ambiguity
+ llvm::SmallVector<Header> result;
+ for (auto HeaderID : SymbolHeaderIDs[ID]) {
+ result.emplace_back(Header(HeaderID));
+ }
+ return result;
}
Recognizer::Recognizer() { ensureInitialized(); }
Index: clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc
===================================================================
--- clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc
+++ clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc
@@ -97,6 +97,11 @@
SYMBOL(atoi, std::, <cstdlib>)
SYMBOL(atol, std::, <cstdlib>)
SYMBOL(atoll, std::, <cstdlib>)
+SYMBOL(atomic, std::, <atomic>)
+SYMBOL(atomic_bool, std::, <atomic>)
+SYMBOL(atomic_char, std::, <atomic>)
+SYMBOL(atomic_char16_t, std::, <atomic>)
+SYMBOL(atomic_char32_t, std::, <atomic>)
SYMBOL(atomic_compare_exchange_strong, std::, <atomic>)
SYMBOL(atomic_compare_exchange_strong_explicit, std::, <atomic>)
SYMBOL(atomic_compare_exchange_weak, std::, <atomic>)
@@ -119,14 +124,51 @@
SYMBOL(atomic_flag_test_and_set, std::, <atomic>)
SYMBOL(atomic_flag_test_and_set_explicit, std::, <atomic>)
SYMBOL(atomic_init, std::, <atomic>)
+SYMBOL(atomic_int, std::, <atomic>)
+SYMBOL(atomic_int16_t, std::, <atomic>)
+SYMBOL(atomic_int32_t, std::, <atomic>)
+SYMBOL(atomic_int64_t, std::, <atomic>)
+SYMBOL(atomic_int8_t, std::, <atomic>)
+SYMBOL(atomic_int_fast16_t, std::, <atomic>)
+SYMBOL(atomic_int_fast32_t, std::, <atomic>)
+SYMBOL(atomic_int_fast64_t, std::, <atomic>)
+SYMBOL(atomic_int_fast8_t, std::, <atomic>)
+SYMBOL(atomic_intmax_t, std::, <atomic>)
+SYMBOL(atomic_intptr_t, std::, <atomic>)
SYMBOL(atomic_is_lockfree, std::, <atomic>)
+SYMBOL(atomic_llong, std::, <atomic>)
SYMBOL(atomic_load, std::, <atomic>)
SYMBOL(atomic_load_explicit, std::, <atomic>)
+SYMBOL(atomic_long, std::, <atomic>)
+SYMBOL(atomic_ptrdiff_t, std::, <atomic>)
SYMBOL(atomic_ref, std::, <atomic>)
+SYMBOL(atomic_schar, std::, <atomic>)
+SYMBOL(atomic_short, std::, <atomic>)
SYMBOL(atomic_signal_fence, std::, <atomic>)
+SYMBOL(atomic_size_t, std::, <atomic>)
SYMBOL(atomic_store, std::, <atomic>)
SYMBOL(atomic_store_explicit, std::, <atomic>)
SYMBOL(atomic_thread_fence, std::, <atomic>)
+SYMBOL(atomic_uchar, std::, <atomic>)
+SYMBOL(atomic_uint, std::, <atomic>)
+SYMBOL(atomic_uint16_t, std::, <atomic>)
+SYMBOL(atomic_uint32_t, std::, <atomic>)
+SYMBOL(atomic_uint64_t, std::, <atomic>)
+SYMBOL(atomic_uint8_t, std::, <atomic>)
+SYMBOL(atomic_uint_fast16_t, std::, <atomic>)
+SYMBOL(atomic_uint_fast32_t, std::, <atomic>)
+SYMBOL(atomic_uint_fast64_t, std::, <atomic>)
+SYMBOL(atomic_uint_fast8_t, std::, <atomic>)
+SYMBOL(atomic_uint_least16_t, std::, <atomic>)
+SYMBOL(atomic_uint_least32_t, std::, <atomic>)
+SYMBOL(atomic_uint_least64_t, std::, <atomic>)
+SYMBOL(atomic_uint_least8_t, std::, <atomic>)
+SYMBOL(atomic_uintmax_t, std::, <atomic>)
+SYMBOL(atomic_uintptr_t, std::, <atomic>)
+SYMBOL(atomic_ullong, std::, <atomic>)
+SYMBOL(atomic_ulong, std::, <atomic>)
+SYMBOL(atomic_ushort, std::, <atomic>)
+SYMBOL(atomic_wchar_t, std::, <atomic>)
SYMBOL(atto, std::, <ratio>)
SYMBOL(auto_ptr, std::, <memory>)
SYMBOL(back_insert_iterator, std::, <iterator>)
@@ -226,6 +268,7 @@
SYMBOL(conjunction, std::, <type_traits>)
SYMBOL(conjunction_v, std::, <type_traits>)
SYMBOL(const_pointer_cast, std::, <memory>)
+SYMBOL(consume_header, std::, <codecvt>)
SYMBOL(contract_violation, std::, <contract>)
SYMBOL(copy, std::, <algorithm>)
SYMBOL(copy_backward, std::, <algorithm>)
@@ -279,6 +322,7 @@
SYMBOL(disjunction, std::, <type_traits>)
SYMBOL(disjunction_v, std::, <type_traits>)
SYMBOL(distance, std::, <iterator>)
+SYMBOL(div, std::, <cstdlib>)
SYMBOL(div_t, std::, <cstdlib>)
SYMBOL(divides, std::, <functional>)
SYMBOL(domain_error, std::, <stdexcept>)
@@ -403,6 +447,7 @@
SYMBOL(gcd, std::, <numeric>)
SYMBOL(generate, std::, <algorithm>)
SYMBOL(generate_canonical, std::, <random>)
+SYMBOL(generate_header, std::, <codecvt>)
SYMBOL(generate_n, std::, <algorithm>)
SYMBOL(generic_category, std::, <system_error>)
SYMBOL(geometric_distribution, std::, <random>)
@@ -711,6 +756,7 @@
SYMBOL(lgamma, std::, <cmath>)
SYMBOL(linear_congruential_engine, std::, <random>)
SYMBOL(list, std::, <list>)
+SYMBOL(little_endian, std::, <codecvt>)
SYMBOL(llabs, std::, <cstdlib>)
SYMBOL(lldiv, std::, <cstdlib>)
SYMBOL(lldiv_t, std::, <cstdlib>)
@@ -764,6 +810,8 @@
SYMBOL(mbrtowc, std::, <cwchar>)
SYMBOL(mbsinit, std::, <cwchar>)
SYMBOL(mbsrtowcs, std::, <cwchar>)
+SYMBOL(mbstate_t, std::, <cuchar>)
+SYMBOL(mbstate_t, std::, <cwchar>)
SYMBOL(mbstowcs, std::, <cstdlib>)
SYMBOL(mbtowc, std::, <cstdlib>)
SYMBOL(mega, std::, <ratio>)
@@ -956,6 +1004,7 @@
SYMBOL(regex_traits, std::, <regex>)
SYMBOL(reinterpret_pointer_cast, std::, <memory>)
SYMBOL(remainder, std::, <cmath>)
+SYMBOL(remove, std::, <algorithm>)
SYMBOL(remove_all_extents, std::, <type_traits>)
SYMBOL(remove_all_extents_t, std::, <type_traits>)
SYMBOL(remove_const, std::, <type_traits>)
@@ -1043,6 +1092,12 @@
SYMBOL(sin, std::, <cmath>)
SYMBOL(sinh, std::, <cmath>)
SYMBOL(size, std::, <iterator>)
+SYMBOL(size_t, std::, <cstddef>)
+SYMBOL(size_t, std::, <cstdio>)
+SYMBOL(size_t, std::, <cstdlib>)
+SYMBOL(size_t, std::, <cstring>)
+SYMBOL(size_t, std::, <ctime>)
+SYMBOL(size_t, std::, <cwchar>)
SYMBOL(skipws, std::, <ios>)
SYMBOL(slice, std::, <valarray>)
SYMBOL(slice_array, std::, <valarray>)
@@ -1104,6 +1159,8 @@
SYMBOL(student_t_distribution, std::, <random>)
SYMBOL(sub_match, std::, <regex>)
SYMBOL(subtract_with_carry_engine, std::, <random>)
+SYMBOL(swap, std::, <algorithm>)
+SYMBOL(swap, std::, <utility>)
SYMBOL(swap_ranges, std::, <algorithm>)
SYMBOL(swprintf, std::, <cwchar>)
SYMBOL(swscanf, std::, <cwchar>)
@@ -1288,6 +1345,8 @@
SYMBOL(wfilebuf, std::, <streambuf>)
SYMBOL(wfstream, std::, <fstream>)
SYMBOL(wifstream, std::, <fstream>)
+SYMBOL(wint_t, std::, <cwchar>)
+SYMBOL(wint_t, std::, <cwctype>)
SYMBOL(wios, std::, <ios>)
SYMBOL(wiostream, std::, <istream>)
SYMBOL(wistream, std::, <istream>)
Index: clang/include/clang/Tooling/Inclusions/CSymbolMap.inc
===================================================================
--- clang/include/clang/Tooling/Inclusions/CSymbolMap.inc
+++ clang/include/clang/Tooling/Inclusions/CSymbolMap.inc
@@ -77,6 +77,11 @@
SYMBOL(FLT_ROUNDS, None, <float.h>)
SYMBOL(FLT_TRUE_MIN, None, <float.h>)
SYMBOL(FOPEN_MAX, None, <stdio.h>)
+SYMBOL(FP_FAST_FMA, None, <math.h>)
+SYMBOL(FP_FAST_FMAF, None, <math.h>)
+SYMBOL(FP_FAST_FMAL, None, <math.h>)
+SYMBOL(FP_ILOGB0, None, <math.h>)
+SYMBOL(FP_ILOGBNAN, None, <math.h>)
SYMBOL(FP_INFINITE, None, <math.h>)
SYMBOL(FP_NAN, None, <math.h>)
SYMBOL(FP_NORNAL, None, <math.h>)
@@ -87,14 +92,24 @@
SYMBOL(HUGE_VALL, None, <math.h>)
SYMBOL(I, None, <complex.h>)
SYMBOL(INFINITY, None, <math.h>)
+SYMBOL(INT16_C, None, <inttypes.h>)
+SYMBOL(INT16_C, None, <stdint.h>)
SYMBOL(INT16_MAX, None, <stdint.h>)
SYMBOL(INT16_MIN, None, <stdint.h>)
+SYMBOL(INT32_C, None, <inttypes.h>)
+SYMBOL(INT32_C, None, <stdint.h>)
SYMBOL(INT32_MAX, None, <stdint.h>)
SYMBOL(INT32_MIN, None, <stdint.h>)
+SYMBOL(INT64_C, None, <inttypes.h>)
+SYMBOL(INT64_C, None, <stdint.h>)
SYMBOL(INT64_MAX, None, <stdint.h>)
SYMBOL(INT64_MIN, None, <stdint.h>)
+SYMBOL(INT8_C, None, <inttypes.h>)
+SYMBOL(INT8_C, None, <stdint.h>)
SYMBOL(INT8_MAX, None, <stdint.h>)
SYMBOL(INT8_MIN, None, <stdint.h>)
+SYMBOL(INTMAX_C, None, <inttypes.h>)
+SYMBOL(INTMAX_C, None, <stdint.h>)
SYMBOL(INTMAX_MAX, None, <stdint.h>)
SYMBOL(INTMAX_MIN, None, <stdint.h>)
SYMBOL(INTPTR_MAX, None, <stdint.h>)
@@ -146,13 +161,328 @@
SYMBOL(MB_CUR_MAX, None, <stdlib.h>)
SYMBOL(MB_LEN_MAX, None, <limits.h>)
SYMBOL(NAN, None, <math.h>)
+SYMBOL(NULL, None, <locale.h>)
+SYMBOL(NULL, None, <stddef.h>)
+SYMBOL(NULL, None, <stdio.h>)
+SYMBOL(NULL, None, <stdlib.h>)
+SYMBOL(NULL, None, <string.h>)
+SYMBOL(NULL, None, <time.h>)
+SYMBOL(NULL, None, <wchar.h>)
SYMBOL(ONCE_FLAG_INIT, None, <threads.h>)
+SYMBOL(PRIX16, None, <inttypes.h>)
+SYMBOL(PRIX16, None, <stdint.h>)
+SYMBOL(PRIX32, None, <inttypes.h>)
+SYMBOL(PRIX32, None, <stdint.h>)
+SYMBOL(PRIX64, None, <inttypes.h>)
+SYMBOL(PRIX64, None, <stdint.h>)
+SYMBOL(PRIX8, None, <inttypes.h>)
+SYMBOL(PRIX8, None, <stdint.h>)
+SYMBOL(PRIXFAST16, None, <inttypes.h>)
+SYMBOL(PRIXFAST16, None, <stdint.h>)
+SYMBOL(PRIXFAST32, None, <inttypes.h>)
+SYMBOL(PRIXFAST32, None, <stdint.h>)
+SYMBOL(PRIXFAST64, None, <inttypes.h>)
+SYMBOL(PRIXFAST64, None, <stdint.h>)
+SYMBOL(PRIXFAST8, None, <inttypes.h>)
+SYMBOL(PRIXFAST8, None, <stdint.h>)
+SYMBOL(PRIXLEAST16, None, <inttypes.h>)
+SYMBOL(PRIXLEAST16, None, <stdint.h>)
+SYMBOL(PRIXLEAST32, None, <inttypes.h>)
+SYMBOL(PRIXLEAST32, None, <stdint.h>)
+SYMBOL(PRIXLEAST64, None, <inttypes.h>)
+SYMBOL(PRIXLEAST64, None, <stdint.h>)
+SYMBOL(PRIXLEAST8, None, <inttypes.h>)
+SYMBOL(PRIXLEAST8, None, <stdint.h>)
+SYMBOL(PRIXMAX, None, <inttypes.h>)
+SYMBOL(PRIXMAX, None, <stdint.h>)
+SYMBOL(PRIXPTR, None, <inttypes.h>)
+SYMBOL(PRIXPTR, None, <stdint.h>)
+SYMBOL(PRId16, None, <inttypes.h>)
+SYMBOL(PRId16, None, <stdint.h>)
+SYMBOL(PRId32, None, <inttypes.h>)
+SYMBOL(PRId32, None, <stdint.h>)
+SYMBOL(PRId64, None, <inttypes.h>)
+SYMBOL(PRId64, None, <stdint.h>)
+SYMBOL(PRId8, None, <inttypes.h>)
+SYMBOL(PRId8, None, <stdint.h>)
+SYMBOL(PRIdFAST16, None, <inttypes.h>)
+SYMBOL(PRIdFAST16, None, <stdint.h>)
+SYMBOL(PRIdFAST32, None, <inttypes.h>)
+SYMBOL(PRIdFAST32, None, <stdint.h>)
+SYMBOL(PRIdFAST64, None, <inttypes.h>)
+SYMBOL(PRIdFAST64, None, <stdint.h>)
+SYMBOL(PRIdFAST8, None, <inttypes.h>)
+SYMBOL(PRIdFAST8, None, <stdint.h>)
+SYMBOL(PRIdLEAST16, None, <inttypes.h>)
+SYMBOL(PRIdLEAST16, None, <stdint.h>)
+SYMBOL(PRIdLEAST32, None, <inttypes.h>)
+SYMBOL(PRIdLEAST32, None, <stdint.h>)
+SYMBOL(PRIdLEAST64, None, <inttypes.h>)
+SYMBOL(PRIdLEAST64, None, <stdint.h>)
+SYMBOL(PRIdLEAST8, None, <inttypes.h>)
+SYMBOL(PRIdLEAST8, None, <stdint.h>)
+SYMBOL(PRIdMAX, None, <inttypes.h>)
+SYMBOL(PRIdMAX, None, <stdint.h>)
+SYMBOL(PRIdPTR, None, <inttypes.h>)
+SYMBOL(PRIdPTR, None, <stdint.h>)
+SYMBOL(PRIi16, None, <inttypes.h>)
+SYMBOL(PRIi16, None, <stdint.h>)
+SYMBOL(PRIi32, None, <inttypes.h>)
+SYMBOL(PRIi32, None, <stdint.h>)
+SYMBOL(PRIi64, None, <inttypes.h>)
+SYMBOL(PRIi64, None, <stdint.h>)
+SYMBOL(PRIi8, None, <inttypes.h>)
+SYMBOL(PRIi8, None, <stdint.h>)
+SYMBOL(PRIiFAST16, None, <inttypes.h>)
+SYMBOL(PRIiFAST16, None, <stdint.h>)
+SYMBOL(PRIiFAST32, None, <inttypes.h>)
+SYMBOL(PRIiFAST32, None, <stdint.h>)
+SYMBOL(PRIiFAST64, None, <inttypes.h>)
+SYMBOL(PRIiFAST64, None, <stdint.h>)
+SYMBOL(PRIiFAST8, None, <inttypes.h>)
+SYMBOL(PRIiFAST8, None, <stdint.h>)
+SYMBOL(PRIiLEAST16, None, <inttypes.h>)
+SYMBOL(PRIiLEAST16, None, <stdint.h>)
+SYMBOL(PRIiLEAST32, None, <inttypes.h>)
+SYMBOL(PRIiLEAST32, None, <stdint.h>)
+SYMBOL(PRIiLEAST64, None, <inttypes.h>)
+SYMBOL(PRIiLEAST64, None, <stdint.h>)
+SYMBOL(PRIiLEAST8, None, <inttypes.h>)
+SYMBOL(PRIiLEAST8, None, <stdint.h>)
+SYMBOL(PRIiMAX, None, <inttypes.h>)
+SYMBOL(PRIiMAX, None, <stdint.h>)
+SYMBOL(PRIiPTR, None, <inttypes.h>)
+SYMBOL(PRIiPTR, None, <stdint.h>)
+SYMBOL(PRIo16, None, <inttypes.h>)
+SYMBOL(PRIo16, None, <stdint.h>)
+SYMBOL(PRIo32, None, <inttypes.h>)
+SYMBOL(PRIo32, None, <stdint.h>)
+SYMBOL(PRIo64, None, <inttypes.h>)
+SYMBOL(PRIo64, None, <stdint.h>)
+SYMBOL(PRIo8, None, <inttypes.h>)
+SYMBOL(PRIo8, None, <stdint.h>)
+SYMBOL(PRIoFAST16, None, <inttypes.h>)
+SYMBOL(PRIoFAST16, None, <stdint.h>)
+SYMBOL(PRIoFAST32, None, <inttypes.h>)
+SYMBOL(PRIoFAST32, None, <stdint.h>)
+SYMBOL(PRIoFAST64, None, <inttypes.h>)
+SYMBOL(PRIoFAST64, None, <stdint.h>)
+SYMBOL(PRIoFAST8, None, <inttypes.h>)
+SYMBOL(PRIoFAST8, None, <stdint.h>)
+SYMBOL(PRIoLEAST16, None, <inttypes.h>)
+SYMBOL(PRIoLEAST16, None, <stdint.h>)
+SYMBOL(PRIoLEAST32, None, <inttypes.h>)
+SYMBOL(PRIoLEAST32, None, <stdint.h>)
+SYMBOL(PRIoLEAST64, None, <inttypes.h>)
+SYMBOL(PRIoLEAST64, None, <stdint.h>)
+SYMBOL(PRIoLEAST8, None, <inttypes.h>)
+SYMBOL(PRIoLEAST8, None, <stdint.h>)
+SYMBOL(PRIoMAX, None, <inttypes.h>)
+SYMBOL(PRIoMAX, None, <stdint.h>)
+SYMBOL(PRIoPTR, None, <inttypes.h>)
+SYMBOL(PRIoPTR, None, <stdint.h>)
+SYMBOL(PRIu16, None, <inttypes.h>)
+SYMBOL(PRIu16, None, <stdint.h>)
+SYMBOL(PRIu32, None, <inttypes.h>)
+SYMBOL(PRIu32, None, <stdint.h>)
+SYMBOL(PRIu64, None, <inttypes.h>)
+SYMBOL(PRIu64, None, <stdint.h>)
+SYMBOL(PRIu8, None, <inttypes.h>)
+SYMBOL(PRIu8, None, <stdint.h>)
+SYMBOL(PRIuFAST16, None, <inttypes.h>)
+SYMBOL(PRIuFAST16, None, <stdint.h>)
+SYMBOL(PRIuFAST32, None, <inttypes.h>)
+SYMBOL(PRIuFAST32, None, <stdint.h>)
+SYMBOL(PRIuFAST64, None, <inttypes.h>)
+SYMBOL(PRIuFAST64, None, <stdint.h>)
+SYMBOL(PRIuFAST8, None, <inttypes.h>)
+SYMBOL(PRIuFAST8, None, <stdint.h>)
+SYMBOL(PRIuLEAST16, None, <inttypes.h>)
+SYMBOL(PRIuLEAST16, None, <stdint.h>)
+SYMBOL(PRIuLEAST32, None, <inttypes.h>)
+SYMBOL(PRIuLEAST32, None, <stdint.h>)
+SYMBOL(PRIuLEAST64, None, <inttypes.h>)
+SYMBOL(PRIuLEAST64, None, <stdint.h>)
+SYMBOL(PRIuLEAST8, None, <inttypes.h>)
+SYMBOL(PRIuLEAST8, None, <stdint.h>)
+SYMBOL(PRIuMAX, None, <inttypes.h>)
+SYMBOL(PRIuMAX, None, <stdint.h>)
+SYMBOL(PRIuPTR, None, <inttypes.h>)
+SYMBOL(PRIuPTR, None, <stdint.h>)
+SYMBOL(PRIx16, None, <inttypes.h>)
+SYMBOL(PRIx16, None, <stdint.h>)
+SYMBOL(PRIx32, None, <inttypes.h>)
+SYMBOL(PRIx32, None, <stdint.h>)
+SYMBOL(PRIx64, None, <inttypes.h>)
+SYMBOL(PRIx64, None, <stdint.h>)
+SYMBOL(PRIx8, None, <inttypes.h>)
+SYMBOL(PRIx8, None, <stdint.h>)
+SYMBOL(PRIxFAST16, None, <inttypes.h>)
+SYMBOL(PRIxFAST16, None, <stdint.h>)
+SYMBOL(PRIxFAST32, None, <inttypes.h>)
+SYMBOL(PRIxFAST32, None, <stdint.h>)
+SYMBOL(PRIxFAST64, None, <inttypes.h>)
+SYMBOL(PRIxFAST64, None, <stdint.h>)
+SYMBOL(PRIxFAST8, None, <inttypes.h>)
+SYMBOL(PRIxFAST8, None, <stdint.h>)
+SYMBOL(PRIxLEAST16, None, <inttypes.h>)
+SYMBOL(PRIxLEAST16, None, <stdint.h>)
+SYMBOL(PRIxLEAST32, None, <inttypes.h>)
+SYMBOL(PRIxLEAST32, None, <stdint.h>)
+SYMBOL(PRIxLEAST64, None, <inttypes.h>)
+SYMBOL(PRIxLEAST64, None, <stdint.h>)
+SYMBOL(PRIxLEAST8, None, <inttypes.h>)
+SYMBOL(PRIxLEAST8, None, <stdint.h>)
+SYMBOL(PRIxMAX, None, <inttypes.h>)
+SYMBOL(PRIxMAX, None, <stdint.h>)
+SYMBOL(PRIxPTR, None, <inttypes.h>)
+SYMBOL(PRIxPTR, None, <stdint.h>)
SYMBOL(PTRDIFF_MAX, None, <stdint.h>)
SYMBOL(PTRDIFF_MIN, None, <stdint.h>)
SYMBOL(RAND_MAX, None, <stdlib.h>)
SYMBOL(RSIZE_MAX, None, <stdint.h>)
SYMBOL(SCHAR_MAX, None, <limits.h>)
SYMBOL(SCHAR_MIN, None, <limits.h>)
+SYMBOL(SCNd16, None, <inttypes.h>)
+SYMBOL(SCNd16, None, <stdint.h>)
+SYMBOL(SCNd32, None, <inttypes.h>)
+SYMBOL(SCNd32, None, <stdint.h>)
+SYMBOL(SCNd64, None, <inttypes.h>)
+SYMBOL(SCNd64, None, <stdint.h>)
+SYMBOL(SCNd8, None, <inttypes.h>)
+SYMBOL(SCNd8, None, <stdint.h>)
+SYMBOL(SCNdFAST16, None, <inttypes.h>)
+SYMBOL(SCNdFAST16, None, <stdint.h>)
+SYMBOL(SCNdFAST32, None, <inttypes.h>)
+SYMBOL(SCNdFAST32, None, <stdint.h>)
+SYMBOL(SCNdFAST64, None, <inttypes.h>)
+SYMBOL(SCNdFAST64, None, <stdint.h>)
+SYMBOL(SCNdFAST8, None, <inttypes.h>)
+SYMBOL(SCNdFAST8, None, <stdint.h>)
+SYMBOL(SCNdLEAST16, None, <inttypes.h>)
+SYMBOL(SCNdLEAST16, None, <stdint.h>)
+SYMBOL(SCNdLEAST32, None, <inttypes.h>)
+SYMBOL(SCNdLEAST32, None, <stdint.h>)
+SYMBOL(SCNdLEAST64, None, <inttypes.h>)
+SYMBOL(SCNdLEAST64, None, <stdint.h>)
+SYMBOL(SCNdLEAST8, None, <inttypes.h>)
+SYMBOL(SCNdLEAST8, None, <stdint.h>)
+SYMBOL(SCNdMAX, None, <inttypes.h>)
+SYMBOL(SCNdMAX, None, <stdint.h>)
+SYMBOL(SCNdPTR, None, <inttypes.h>)
+SYMBOL(SCNdPTR, None, <stdint.h>)
+SYMBOL(SCNi16, None, <inttypes.h>)
+SYMBOL(SCNi16, None, <stdint.h>)
+SYMBOL(SCNi32, None, <inttypes.h>)
+SYMBOL(SCNi32, None, <stdint.h>)
+SYMBOL(SCNi64, None, <inttypes.h>)
+SYMBOL(SCNi64, None, <stdint.h>)
+SYMBOL(SCNi8, None, <inttypes.h>)
+SYMBOL(SCNi8, None, <stdint.h>)
+SYMBOL(SCNiFAST16, None, <inttypes.h>)
+SYMBOL(SCNiFAST16, None, <stdint.h>)
+SYMBOL(SCNiFAST32, None, <inttypes.h>)
+SYMBOL(SCNiFAST32, None, <stdint.h>)
+SYMBOL(SCNiFAST64, None, <inttypes.h>)
+SYMBOL(SCNiFAST64, None, <stdint.h>)
+SYMBOL(SCNiFAST8, None, <inttypes.h>)
+SYMBOL(SCNiFAST8, None, <stdint.h>)
+SYMBOL(SCNiLEAST16, None, <inttypes.h>)
+SYMBOL(SCNiLEAST16, None, <stdint.h>)
+SYMBOL(SCNiLEAST32, None, <inttypes.h>)
+SYMBOL(SCNiLEAST32, None, <stdint.h>)
+SYMBOL(SCNiLEAST64, None, <inttypes.h>)
+SYMBOL(SCNiLEAST64, None, <stdint.h>)
+SYMBOL(SCNiLEAST8, None, <inttypes.h>)
+SYMBOL(SCNiLEAST8, None, <stdint.h>)
+SYMBOL(SCNiMAX, None, <inttypes.h>)
+SYMBOL(SCNiMAX, None, <stdint.h>)
+SYMBOL(SCNiPTR, None, <inttypes.h>)
+SYMBOL(SCNiPTR, None, <stdint.h>)
+SYMBOL(SCNo16, None, <inttypes.h>)
+SYMBOL(SCNo16, None, <stdint.h>)
+SYMBOL(SCNo32, None, <inttypes.h>)
+SYMBOL(SCNo32, None, <stdint.h>)
+SYMBOL(SCNo64, None, <inttypes.h>)
+SYMBOL(SCNo64, None, <stdint.h>)
+SYMBOL(SCNo8, None, <inttypes.h>)
+SYMBOL(SCNo8, None, <stdint.h>)
+SYMBOL(SCNoFAST16, None, <inttypes.h>)
+SYMBOL(SCNoFAST16, None, <stdint.h>)
+SYMBOL(SCNoFAST32, None, <inttypes.h>)
+SYMBOL(SCNoFAST32, None, <stdint.h>)
+SYMBOL(SCNoFAST64, None, <inttypes.h>)
+SYMBOL(SCNoFAST64, None, <stdint.h>)
+SYMBOL(SCNoFAST8, None, <inttypes.h>)
+SYMBOL(SCNoFAST8, None, <stdint.h>)
+SYMBOL(SCNoLEAST16, None, <inttypes.h>)
+SYMBOL(SCNoLEAST16, None, <stdint.h>)
+SYMBOL(SCNoLEAST32, None, <inttypes.h>)
+SYMBOL(SCNoLEAST32, None, <stdint.h>)
+SYMBOL(SCNoLEAST64, None, <inttypes.h>)
+SYMBOL(SCNoLEAST64, None, <stdint.h>)
+SYMBOL(SCNoLEAST8, None, <inttypes.h>)
+SYMBOL(SCNoLEAST8, None, <stdint.h>)
+SYMBOL(SCNoMAX, None, <inttypes.h>)
+SYMBOL(SCNoMAX, None, <stdint.h>)
+SYMBOL(SCNoPTR, None, <inttypes.h>)
+SYMBOL(SCNoPTR, None, <stdint.h>)
+SYMBOL(SCNu16, None, <inttypes.h>)
+SYMBOL(SCNu16, None, <stdint.h>)
+SYMBOL(SCNu32, None, <inttypes.h>)
+SYMBOL(SCNu32, None, <stdint.h>)
+SYMBOL(SCNu64, None, <inttypes.h>)
+SYMBOL(SCNu64, None, <stdint.h>)
+SYMBOL(SCNu8, None, <inttypes.h>)
+SYMBOL(SCNu8, None, <stdint.h>)
+SYMBOL(SCNuFAST16, None, <inttypes.h>)
+SYMBOL(SCNuFAST16, None, <stdint.h>)
+SYMBOL(SCNuFAST32, None, <inttypes.h>)
+SYMBOL(SCNuFAST32, None, <stdint.h>)
+SYMBOL(SCNuFAST64, None, <inttypes.h>)
+SYMBOL(SCNuFAST64, None, <stdint.h>)
+SYMBOL(SCNuFAST8, None, <inttypes.h>)
+SYMBOL(SCNuFAST8, None, <stdint.h>)
+SYMBOL(SCNuLEAST16, None, <inttypes.h>)
+SYMBOL(SCNuLEAST16, None, <stdint.h>)
+SYMBOL(SCNuLEAST32, None, <inttypes.h>)
+SYMBOL(SCNuLEAST32, None, <stdint.h>)
+SYMBOL(SCNuLEAST64, None, <inttypes.h>)
+SYMBOL(SCNuLEAST64, None, <stdint.h>)
+SYMBOL(SCNuLEAST8, None, <inttypes.h>)
+SYMBOL(SCNuLEAST8, None, <stdint.h>)
+SYMBOL(SCNuMAX, None, <inttypes.h>)
+SYMBOL(SCNuMAX, None, <stdint.h>)
+SYMBOL(SCNuPTR, None, <inttypes.h>)
+SYMBOL(SCNuPTR, None, <stdint.h>)
+SYMBOL(SCNx16, None, <inttypes.h>)
+SYMBOL(SCNx16, None, <stdint.h>)
+SYMBOL(SCNx32, None, <inttypes.h>)
+SYMBOL(SCNx32, None, <stdint.h>)
+SYMBOL(SCNx64, None, <inttypes.h>)
+SYMBOL(SCNx64, None, <stdint.h>)
+SYMBOL(SCNx8, None, <inttypes.h>)
+SYMBOL(SCNx8, None, <stdint.h>)
+SYMBOL(SCNxFAST16, None, <inttypes.h>)
+SYMBOL(SCNxFAST16, None, <stdint.h>)
+SYMBOL(SCNxFAST32, None, <inttypes.h>)
+SYMBOL(SCNxFAST32, None, <stdint.h>)
+SYMBOL(SCNxFAST64, None, <inttypes.h>)
+SYMBOL(SCNxFAST64, None, <stdint.h>)
+SYMBOL(SCNxFAST8, None, <inttypes.h>)
+SYMBOL(SCNxFAST8, None, <stdint.h>)
+SYMBOL(SCNxLEAST16, None, <inttypes.h>)
+SYMBOL(SCNxLEAST16, None, <stdint.h>)
+SYMBOL(SCNxLEAST32, None, <inttypes.h>)
+SYMBOL(SCNxLEAST32, None, <stdint.h>)
+SYMBOL(SCNxLEAST64, None, <inttypes.h>)
+SYMBOL(SCNxLEAST64, None, <stdint.h>)
+SYMBOL(SCNxLEAST8, None, <inttypes.h>)
+SYMBOL(SCNxLEAST8, None, <stdint.h>)
+SYMBOL(SCNxMAX, None, <inttypes.h>)
+SYMBOL(SCNxMAX, None, <stdint.h>)
+SYMBOL(SCNxPTR, None, <inttypes.h>)
+SYMBOL(SCNxPTR, None, <stdint.h>)
SYMBOL(SEEK_CUR, None, <stdio.h>)
SYMBOL(SEEK_END, None, <stdio.h>)
SYMBOL(SEEK_SET, None, <stdio.h>)
@@ -175,10 +505,20 @@
SYMBOL(TMP_MAX_S, None, <stdio.h>)
SYMBOL(TSS_DTOR_ITERATIONS, None, <threads.h>)
SYMBOL(UCHAR_MAX, None, <limits.h>)
+SYMBOL(UINT16_C, None, <inttypes.h>)
+SYMBOL(UINT16_C, None, <stdint.h>)
SYMBOL(UINT16_MAX, None, <stdint.h>)
+SYMBOL(UINT32_C, None, <inttypes.h>)
+SYMBOL(UINT32_C, None, <stdint.h>)
SYMBOL(UINT32_MAX, None, <stdint.h>)
+SYMBOL(UINT64_C, None, <inttypes.h>)
+SYMBOL(UINT64_C, None, <stdint.h>)
SYMBOL(UINT64_MAX, None, <stdint.h>)
+SYMBOL(UINT8_C, None, <inttypes.h>)
+SYMBOL(UINT8_C, None, <stdint.h>)
SYMBOL(UINT8_MAX, None, <stdint.h>)
+SYMBOL(UINTMAX_C, None, <inttypes.h>)
+SYMBOL(UINTMAX_C, None, <stdint.h>)
SYMBOL(UINTMAX_MAX, None, <stdint.h>)
SYMBOL(UINTPTR_MAX, None, <stdint.h>)
SYMBOL(UINT_FAST16_MAX, None, <stdint.h>)
@@ -416,6 +756,8 @@
SYMBOL(ctime, None, <time.h>)
SYMBOL(ctime_s, None, <time.h>)
SYMBOL(difftime, None, <time.h>)
+SYMBOL(div, None, <stdlib.h>)
+SYMBOL(div_t, None, <stdlib.h>)
SYMBOL(double_t, None, <math.h>)
SYMBOL(erf, None, <math.h>)
SYMBOL(erfc, None, <math.h>)
@@ -424,6 +766,8 @@
SYMBOL(erff, None, <math.h>)
SYMBOL(erfl, None, <math.h>)
SYMBOL(errno, None, <errno.h>)
+SYMBOL(errno_t, None, <errno.h>)
+SYMBOL(errno_t, None, <stdio.h>)
SYMBOL(exit, None, <stdlib.h>)
SYMBOL(exp, None, <math.h>)
SYMBOL(exp2, None, <math.h>)
@@ -525,6 +869,8 @@
SYMBOL(ilogbl, None, <math.h>)
SYMBOL(imaginary, None, <complex.h>)
SYMBOL(imaxabs, None, <inttypes.h>)
+SYMBOL(imaxdiv, None, <inttypes.h>)
+SYMBOL(imaxdiv_t, None, <inttypes.h>)
SYMBOL(int16_t, None, <stdint.h>)
SYMBOL(int32_t, None, <stdint.h>)
SYMBOL(int64_t, None, <stdint.h>)
@@ -581,10 +927,14 @@
SYMBOL(ldexp, None, <math.h>)
SYMBOL(ldexpf, None, <math.h>)
SYMBOL(ldexpl, None, <math.h>)
+SYMBOL(ldiv, None, <stdlib.h>)
+SYMBOL(ldiv_t, None, <stdlib.h>)
SYMBOL(lgamma, None, <math.h>)
SYMBOL(lgammaf, None, <math.h>)
SYMBOL(lgammal, None, <math.h>)
SYMBOL(llabs, None, <stdlib.h>)
+SYMBOL(lldiv, None, <stdlib.h>)
+SYMBOL(lldiv_t, None, <stdlib.h>)
SYMBOL(llrint, None, <math.h>)
SYMBOL(llrintf, None, <math.h>)
SYMBOL(llrintl, None, <math.h>)
@@ -627,6 +977,8 @@
SYMBOL(mbsinit, None, <wchar.h>)
SYMBOL(mbsrtowcs, None, <wchar.h>)
SYMBOL(mbsrtowcs_s, None, <wchar.h>)
+SYMBOL(mbstate_t, None, <uchar.h>)
+SYMBOL(mbstate_t, None, <wchar.h>)
SYMBOL(mbstowcs, None, <stdlib.h>)
SYMBOL(mbstowcs_s, None, <stdlib.h>)
SYMBOL(mbtowc, None, <stdlib.h>)
@@ -734,6 +1086,13 @@
SYMBOL(sinhf, None, <math.h>)
SYMBOL(sinhl, None, <math.h>)
SYMBOL(sinl, None, <math.h>)
+SYMBOL(size_t, None, <stddef.h>)
+SYMBOL(size_t, None, <stdio.h>)
+SYMBOL(size_t, None, <stdlib.h>)
+SYMBOL(size_t, None, <string.h>)
+SYMBOL(size_t, None, <time.h>)
+SYMBOL(size_t, None, <uchar.h>)
+SYMBOL(size_t, None, <wchar.h>)
SYMBOL(snprintf, None, <stdio.h>)
SYMBOL(snprintf_s, None, <stdio.h>)
SYMBOL(snwprintf_s, None, <wchar.h>)
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
