[include-mapping] Allow multiple headers for the same symbol. Choose the first header of available ones.

[VitaNuo]

Remove variant logic in generator.

[VitaNuo]

Restore variant logic for overloads. Remove broken logic for accepted variants.

[VitaNuo]

Fix typo.

[hokein]

since we modify the python script, could you please update its artifacts (StdSymbolMap.inc, CSymbolMap) as well?

[VitaNuo]

Add re-generated symbol maps.

[VitaNuo]

Added the re-generated symbol maps to this patch as per @hokein's request.

[hokein]

In D142092#4068792, @VitaNuo wrote:

Added the re-generated symbol maps to this patch as per @hokein's request.

Sorry for not being cleared. My suggestion was to generate the maps on the old data (2018-10-28), the reason is that we can see the diffs caused by the change of the python script, it would make the review easier. We plan to update the symbol mappings to latest version, I think we should do it in a followup patch.

clang/tools/include-mapping/gen_std.py

17

nit: std::swap doesn't have variants, it is provided by multiple headers.

[VitaNuo]

Update the 20181028 archive maps.

[VitaNuo]

Address review comment.

[VitaNuo]

Oh I misunderstood your comment regarding which maps need to be regenerated as part of this patch. Regenerated the 2018 ones now. As expected, there are only added symbols now.

[kadircet]

clang/tools/include-mapping/cppreference_parser.py

174

this is actually checking for something else (sorry for the confusing naming).

the variant here refers to library name mentioned in parentheses (this is same problem as std::move) on the std symbol index page https://en.cppreference.com/w/cpp/symbol_index (e.g. remove<>() (algorithm)). by getting rid of this we're introducing a regression, as previously std::remove wouldn't be recognized by the library, but now it'll be recognized and we'll keep suggesting <cstdio> for it.

so we should actually keep this around.

[hokein]

Can you add a unittest in the StandardLibraryTest.cpp?

clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc

100

Conceptually, this (and other atomic_* symbols) doesn't feel correct:

• <atomic> provides the generic template template<class T> struct atomic;
• <memory> provides partial template specializations for std::shared_ptr and std::weak_ptr

They are variant symbols (ideally, they should be treat as the std::move()). The issue here is that unlike std::move which has two individual entries in the index page, we only have one entry for std::atomic (extending the cppreference_parser.py script to perfectly distinguish these two cases in the page seems non-trivial). Some options:

1. treat them as multiple-header symbols (like what this patch does now)
2. special-case these symbols like std::move()
3. always prefer the header providing generic templates

@kadircet, what do you think?

326

this one as well, both headers provide different overloads.

1007

I think std::remove should not be in the scope of the patch, it has two variants:

• std::remove from <cstdio>
• and std::remove from <algorithm>.

clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp

21

int => unsigned.

Any reason to change it to a map? My understanding is that SymbolNames is a mapping from the SymbolID => {Scope, Name}, it should not be affected if we add multiple-header symbols.

70

int => unsigned.

71

Given the fact that multiple-header symbols are grouped in the .inc file, we could simplify the code of checking a new symbol by looking at the last available SymIndex:

if (NextAvailSymIndex > 0 && SymbolNames[NextAvailSymIndex-1].first == NS && SymbolNames[NextAvailSymIndex-1].second == Name) {
   // this is not a new symbol.
}

82

nit: inline the HeaderID.

101

The ID field is guaranteed to be valid, so no need to do the sanity check.

[VitaNuo]

Re-introduce the special std::remove handling for now.

clang/tools/include-mapping/cppreference_parser.py

174

Ok, I can keep this out of this patch, but we'll have to remove this logic evetually when we deal with overloads.

I have a slight suspicion that this code might be buggy, because it suggests that one _of_ the variants should be accepted. What is does in reality, though, is it keeps algorithm in the list of headers suitable for std::remove alongside cstdio, and then in the last step std::remove is ignored by the generator because of being defined in two headers.

With this patch, the result will be both {cstdio, algorithm}. Is this (more) satisfactory for now compared to skipping algorithm due to being an overload?

[VitaNuo]

Address review comments regarding data structure use and style.

[VitaNuo]

Fix formatting.

[VitaNuo]

clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp

21

Right. I am not sure what I was thinking. Possibly I was thinking that symbol IDs won't be continuous anymore after this change, but they actually are. Thanks!

71

I know this is easier in terms of code, but this heavily relies on the order in the generated files. I would prefer to keep the library and the generator as decoupled as possible, even if it means slightly more complex code here. Overall, it seems more future-proof in case of unrelated generator changes (bugs?) that might change the order.

101

This is all gone now, since the code is back to the array version of SymbolNames.

[kadircet]

clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc

100

right, i believe this patch is definitely adding keeping multiple headers for a symbol around, but mixing it with keeping headers for variants (e.g. overloads provided by different headers, or specializations as mentioned here).

we definitely need some more changes in parser to make sure we're only preserving alternatives for the same symbol and not for any other variants (overloads, specializations). IIRC there are currently 2 places these variants could come into play:

• first is the symbol index page itself, symbols that have (foo) next to them have variants and should still be ignored (e.g. std::remove variant of cstdio shouldn't be preserved in the scope of this patch)
• second is inside the detail pages for symbols, e.g. std::atomic, we can have headers for different declarations, they're clearly different variants so we shouldn't add such symbols into the mapping _ParseSymbolPage already does some detection of declarations in between headers.

in the scope of this patch, we should keep ignoring both.

clang/tools/include-mapping/cppreference_parser.py

174

Ok, I can keep this out of this patch, but we'll have to remove this logic evetually when we deal with overloads.

Surely, I wasn't saying this should stay here forever, i am just saying that what's done in the scope of this patch doesn't really address the issues "worked around" by this piece.

I have a slight suspicion that this code might be buggy, because it suggests that one _of_ the variants should be accepted. What is does in reality, though, is it keeps algorithm in the list of headers suitable for std::remove alongside cstdio, and then in the last step std::remove is ignored by the generator because of being defined in two headers.

right, it's because we have logic to prefer "non-variant" versions of symbols when available (i.e. in the absence of this logic, we'd prefer std::remove from cstdio). this logic enables us to preserve certain variants (in addition to non-variants). that way we treat std::remove as ambigious rather than always resolving to <cstdio>, hence it's marked as "missing", similar to std::move.

With this patch, the result will be both {cstdio, algorithm}. Is this (more) satisfactory for now compared to skipping algorithm due to being an overload?

in the end this should probably look like {algorithm, cstdio}, but as mentioned elsewhere, this is not the same problem as "same symbol being provided by multiple header" but rather "different symbols having same name and different headers". so treatment of it shouldn't change by this patch.

209

nit: formatting

[VitaNuo]

Special case the overloads for now.

[VitaNuo]

clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc

100

I suggest to special-case the overloads for now, just not to solve all the problems in the same patch.

326

I suggest to special-case the overloads for now, just not to solve all the problems in the same patch.

clang/tools/include-mapping/cppreference_parser.py

174

On second thought, I think we'd rather special-case the overloads for now (until we get to them). See the newest patch version.

[VitaNuo]

clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc

1007

Yes, agreed. Let's take care of the overloads going forward.

clang/tools/include-mapping/cppreference_parser.py

174

right, it's because we have logic to prefer "non-variant" versions of symbols when available (i.e. in the absence of this logic, we'd prefer std::remove from cstdio).

Where is this logic? AFAICS the generator in the current state doesn't generate anything for std::remove.

[VitaNuo]

clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc

100

The first group are already ignored. We need to take a lot at how to ignore the second one.

[hokein]

clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc

100

Ideally, we should tweak the _ParseSymbolPage to handle this case, but I don't see a easy way to do it (the atomic case is quite tricky where the symbol name is identical, only the template argument is different, and the simple text-match heuristic in _ParseSymbolPage fails in this case).

so specialcasing these (there are not too many of them) looks fine to me.

106

Looks like the regex filters too many symbols -- e.g. atomic_fetch_add is not a variant symbol, we should keep it instead. The same to other following symbols as well.

clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp

71

but this heavily relies on the order in the generated files.

Yeah, this is true. I actually think we should make it as an invariant (multiple-header symbols are grouped) of the generated .inc files. This invariant is important and useful, it is much easier for human to read and justify. We can probably guarantee it in the generator side.

clang/tools/include-mapping/gen_std.py

111

I'd use a list of exact symbol names (the number of them should not be huge), to avoid filtering out symbols by accident (see my other comment).

[kadircet]

clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc

100

I don't follow why we can't perform this detection directly, haven't been taking a look at the details but the page looks like:

Defined in header <atomic>
template< class T > struct atomic;
template< class U > struct atomic<U*>;
Defined in header <memory>
template< class U > struct atomic<std::shared_ptr<U>>;
template< class U > struct atomic<std::weak_ptr<U>>;
Defined in header <stdatomic.h>
#define _Atomic(T) /* see below */

So _ParseSymbolPage, first sees <atomic> then a bunch of decls, then <memory> then a bunch more decls and so on, and in the end it returns all the headers it has found.

Why can't we change the logic here to return nothing when there are different decls && headers? i.e. return empty if we see a new header after seeing some declarations.
does this result in undesired behaviour elsewhere?

[VitaNuo]

Add early return for found symbols.

[kadircet]

clang/tools/include-mapping/cppreference_parser.py

174

Where is this logic? AFAICS the generator in the current state doesn't generate anything for std::remove.

It's the logic that you're deleting:

if variant and variant not in variants_for_symbol:
    continue

we ignore any symbols that has a variant we shouldn't accept and always prefer the non-variant versions. to be more concrete when parsing c++ symbol index we'll see two alternatives for std::remove:

remove()
remove<>() (algorithm)

first one is a non-variant, hence it's accepted by default. second one is algorithm variant, and is accepted per this deleted logic. in the end we used to didn't generate anything because we now have multiple headers providing std::remove.

i think it creates more confusion to special case only std::remove down below, and not other symbols whose non-variant versions we accept, e.g. sin also has non-variant versions, but we don't "special case" it to keep it out of the map.

i'd suggest treating std::remove similar to other symbols with an accepted variant, rather than creating a divergence. so my suggestion is changing the logic above to only accept variants mentioned in the map when there's a mapping for the symbol (and reject the non-variant version). net effect will be that we'll now include the mapping from std::remove to <algorithm>, which is currently inline with our behaviour against other symbols with different variants. we try to pick the most common variant, and that's almost always the "non-variant" version, apart from std::remove.

that way we should get rid of the special casing below completely. does that make sense?

clang/tools/include-mapping/gen_std.py

111

different headers providing std::swap don't provide different variants of it, these are just ADL extension points, similar to std::begin (which also shouldn't be missing from the mapping).

for remove, i've provided more context in the discussion above, about keeping a different variant of std::remove around.

[VitaNuo]

Refactor the symbol parsing loop.

[VitaNuo]

Refine C parsing.

[VitaNuo]

Sort the C symbol map.

[VitaNuo]

Fix "atomic" and "div" overloads programmatically. Add a FIXME for future proper handling of overloads.

[VitaNuo]

clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc

100

Ok, I've fixed (or hacked :) this programmatically.
The parsing of constants in https://en.cppreference.com/w/cpp/locale/codecvt_mode is not complete now, everything is attributed to the "codecvt" header, the "locale" header is ignored. Hope it's OK.
If not, then I'm afraid I can only special-case the "atomic.*" symbols.

106

They're all back now.

326

Should be fixed now, together with "atomic.*" cases.

[VitaNuo]

Remove special casing from gen_std.py. Re-introduce special handling for std::remove.

[VitaNuo]

Formatting.

[VitaNuo]

Formatting.

[VitaNuo]

Rely on alphabetic ordering to determine whether the symbol is new.

[VitaNuo]

Thank you all for comments! The patch should be ready for the next review now.

clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc

1007

The latest version keeps the std::remove overload from <algorithm>.

clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp

71

Ok, sure. Sorted the symbols in the generator now and also applied the snippet from above. I'm not 100% sure the code became much simpler but this version seems fine too :)

clang/tools/include-mapping/cppreference_parser.py

174

Ok, I've tweaked the logic to keep std::remove from <algorithm> now.

clang/tools/include-mapping/gen_std.py

111

Thank you. The latest version should take care both of the overloads that have accidentally made it to this patch and of the std::remove case.

[VitaNuo]

Remove extra import.

[hokein]

I haven't read though all the change of _ParseSymbolPage, left some comments.

I think we need to update&add proper tests in include-mapping/test.py as we has changed the parser.

clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc

1162

Is this intended? it seems to me the cppparser doesn't handle this case correctly, in the swap symbol page, we have two headers in a single t-dsc-header tr, the parser should consider both (like the above size_t).

Defined in header <algorithm>
Defined in header <utility>

clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp

57

We can avoid a local variable by

auto Add = [.. SymIndex(-1)] (....) {
if (SymIndex >=0 &&
    SymbolNames[SymIndex].first == NS && ...) {
} else {
    // the first symbol, or new symbol.
    ++SymIndex;
}

SymbolNames[SymIndex] = {NS, Name};
....
}

clang/tools/include-mapping/cppreference_parser.py

39

If the header_to_accept is set, I think we can just return {header_to_accept} directly.

96

IIUC, this is the major and intended change of the function, this is not a FIXME.

105

The comment doesn't match the current behavior. IIUC, iof the symbol was never named, we only consider the first header now.

107

why sort the headers?

[kadircet]

clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc

205

i think we should have other providers here, https://en.cppreference.com/w/cpp/iterator/begin. do we know why they're dropped?

clang/tools/include-mapping/cppreference_parser.py

165

variant is not necessarily the header, eg:

acos()
acos<>() (std::complex) (since C++11)
acos<>() (std::valarray)

in this case variants are std::complex and std::valarray.

hence we're not trying to "infer" the header we want to preserve but rather decide on which symbol page we want to parse. we should still accept "all the headers" mentioned in that variant symbol page.

[VitaNuo]

Address review comments. No new tests in this version.

[VitaNuo]

Fix tests.

[VitaNuo]

Thanks for the comments! AFAICS I've addressed all of them.
Re tests, thanks for the reminder @hokein! I've fixed them now, everything is green.

clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc

205

Yes, this list is the regeneration of the 2018 html book. It's explicitly _not_ generated from the 2022 book in order to have a clear diff related to the topic of this patch.
In the 2018 book, the only provider for std::begin is iterator.

1162

You're right. There's another random class name (t-dcl-rev-aux) that needs to be skipped. I've changed the condition in line 81 of cppreference_parser.py (the loop that skips unneeded rows between the header block and the symbol block) to negation in order to make it more robust and avoid listing all these unneeded classes unnecessarily.

clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp

57

Ok, sure.

clang/tools/include-mapping/cppreference_parser.py

39

We'd need to add <> then. It needs a couple of extra lines here or there anyways, I don't think it makes a difference.

96

I guess it depends on how you view it: I meant it as FIXME in the context of overloads, i.e., we might want to remove this and add infrastructure to differentiate between overloads explicitly.
I can remove the FIXME part, no problem.

105

I've removed all the hacking with all_headers now, so the comment is valid again.

107

This was a hack to make the generator return atomic rather than memory for std::atomic.* symbols. But I've noticed now that this adds some trouble to the C symbol map. I think now that cutting all_headers to the first element is wrong.
I will special-case the std::atomic.* symbols instead, because so far I don't see a way to solve this programmatically without other collateral effects.

Note that the problem is not std::atomic itself (for which Kadir extensively described the solution in some of the other comments), but rather atomic_bool, atomic_char etc. mentioned further in the page. The headers for them come from all_headers rather than symbol_headers, and there seems to be no way to limit them to <atomic> without other collateral effects.

165

Ah ok, I was mostly looking at std::remove (algorithm). Ok, I will use the term "variant" as before. Thanks.

[kadircet]

clang/tools/include-mapping/cppreference_parser.py

107

I think now that cutting all_headers to the first element is wrong.

What's exactly breaking once you do that? (I guess by first element you still mean "all the headers we've seen until the first declaration in the page")

but rather atomic_bool, atomic_char etc. mentioned further in the page. The headers for them come from all_headers rather than symbol_headers, and there seems to be no way to limit them to <atomic> without other collateral effects.

I guess this is happening because we're trying to find headers that are for the declaration block containing the interesting symbol name. Any idea if that logic is winning us anything? e.g. if we dropped the if symbol_name in found_symbols: what does change?

165

sorry i wasn't just trying to nitpick on the name of the variable/parameters.

i was trying to say _ReadSymbolPage should not be a function of variant_to_accept.
we should "completely skip" parsing of symbol pages for variants we don't want to take in (that's what this continue here is trying to achieve)

later on when we're parsing a symbol page, the name of the variant shouldn't effect the headers we're picking in any way (especially in the way you're relying right now that says variant name and the header name will be the same, as i pointed out this might as well be std::complex).

Is this trying to work around a different problem? (especially around std::atomic_.* I assume, i'll follow up on that thread)

200

there's no variant of "std::atomic.*" called "atomic", in https://en.cppreference.com/w/cpp/symbol_index. is it something in 2018 version of the html book? otherwise there's only the unnamed variant and std::shared_ptr variant, and we should be preferring unnamed variant.

[VitaNuo]

Remove all special-casing, skip all variant pages.

[VitaNuo]

Thanks for the comments!

clang/tools/include-mapping/cppreference_parser.py

107

I guess by first element you still mean "all the headers we've seen until the first declaration in the page"

No, I mean the first element of the all_headers collection. all_headers is a collection that collects _all_ the headers in the page and, in case a symbol is not defined in a table with an individual header block, all_headers in the page are returned as an approximation.

What's exactly breaking once you do that?

It is essentially arbitrary to limit all_headers to the first element (at the moment it would be the first element alphabetically). E.g., for the INT8_C and other constants here, the result would be inttypes.h and stdint.h would be cut, so this result doesn't make sense.

if we dropped the if symbol_name in found_symbols what does change?

Then all the headers in the table will be attributed to all the symbols in the table. Consider this page: std::imaxdiv would be reported as defined both in cstdlib and cinttypes, which is wrong.

I guess this is happening because we're trying to find headers that are for the declaration block containing the interesting symbol name.

Not really. Headers for atomic_bool, atomic_char etc. come from all_headers rather than symbol_headers. The reason for that is they are defined in a table which doesn't have its own header block, so we are trying to approximate the headers by naming all the headers in the file.

165

This is obsolete. As discussed offline, I've removed all the special-casing logic. All the variants are skipped now without exceptions.

200

This is obsolete. As discussed offline, I've removed all the special-casing logic. All the variants are skipped now without exceptions.

[VitaNuo]

Remove a FIXME.

[hokein]

As discussed offline, we decided to stop spending effort on improving the cppreference_parser.py, instead, we allow human edits in the generated StdSymbolMap.inc and CSymbolMap.inc, it gives us more flexibility: sort the headers for multi-header symbol in a humn-desired order rather than suboptimal alphabet order; symbols (e.g. std::experimental::filesystem) that are not available in cppreference website; symbols (e.g. PRIX16) from a complicated cppreference HTML page which is hard to parse in cppreference_parser.py etc.

We have two major things in this patch:

1. extend the Stdlib API to support multiple-header symbols
2. emits multiple-header symbols in the *.inc files

For 1), this change is good. We need to make sure the change not break other users of the .inc files. clangd is the main user, the behavior will be changed in https://github.com/llvm/llvm-project/blob/main/clang-tools-extra/clangd/index/CanonicalIncludes.cpp#L736 as now we have duplicated qualified names (the ideal solution is to ignore multiple-header symbols, I think it is fine now if we just add a single std::size_t symbol, see my comment below)
For 2), I have some concerns, it looks like some multiple-headers symbols that are handled incorrectly by the cppreference_parser.py (see my other comments). I think the best way for us is to list them manually (no action required, I will make a followup)

I'd suggest to narrow the scope of the patch:

• keep 1) and add a unittest in llvm-project/clang/unittests/Tooling/StandardLibraryTest.cpp;
• drop all generated multi-header symbols in *.inc files, instead, we manually add a single one std::size_t symbol to the StdSymbolMap.inc for the StandardLibrary unittest. This means we need to revert the current change of gen_std.py;

clang/include/clang/Tooling/Inclusions/CSymbolMap.inc

80

These symbols seem to only have a single header, I think it is an improvement effect of the new change of parsing logic in cppreference_parser.py.

96

This type of symbol (INTX_C) seems not correct, they are only from <stdint.h> -- (this is a limitation of our current cppreference parser (it can not handle the complex page: https://en.cppreference.com/w/c/types/integer)

172

I think this kind of symbol (PRIdN, PRIdLEASTN, PRIdFASTN, PRIdMAX, PRIdPTR etc) is only from <inttypes.h> (another limitation of the cppreference parser).

clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp

33

It is sad that we're allocating more memory for these two arrays now (as we have multiple SYMBOLs for the same qualified name). No action needed, can you add a comment saying that we're allocate more space here?

clang/tools/include-mapping/test.py

56 ↗

(On Diff #493565)

The test needs to update as well, as you remove the change of _ParseSymbolPage.

[VitaNuo]

Add comment.

[VitaNuo]

Revert all changes to generator.

[VitaNuo]

Revert more.

[VitaNuo]

Reverted everything apart from library support.

[hokein]

Thanks, it looks mostly good. This needs some work on rebase (as we have landed a few patches that change StandardLibrary.cpp file). I will rebase it and land it for you.

[hokein]

• Rebase to main, and some small tweaks
• unittest will be added when landing the https://reviews.llvm.org/D143280

clang/include/clang/Tooling/Inclusions/CSymbolMap.inc

 SYMBOL(FLT_MAX_EXP, None, <float.h>)
 SYMBOL(FLT_MIN, None, <float.h>)
 SYMBOL(FLT_MIN_10_EXP, None, <float.h>)
 SYMBOL(FLT_MIN_EXP, None, <float.h>)
 SYMBOL(FLT_RADIX, None, <float.h>)
 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>)
 SYMBOL(FP_SUBNORMAL, None, <math.h>)
 SYMBOL(FP_ZERO, None, <math.h>)
 SYMBOL(HUGE_VAL, None, <math.h>)
 SYMBOL(HUGE_VALF, None, <math.h>)
 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>)
 SYMBOL(INTPTR_MIN, None, <stdint.h>)
 SYMBOL(INT_FAST16_MAX, None, <stdint.h>)
 SYMBOL(INT_FAST16_MIN, None, <stdint.h>)
 SYMBOL(INT_FAST32_MAX, None, <stdint.h>)
 SYMBOL(INT_FAST32_MIN, None, <stdint.h>)

 SYMBOL(LONG_MIN, None, <limits.h>)
 SYMBOL(L_tmpnam, None, <stdio.h>)
 SYMBOL(L_tmpnam_s, None, <stdio.h>)
 SYMBOL(MATH_ERREXCEPT, None, <math.h>)
 SYMBOL(MATH_ERRNO, None, <math.h>)
 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>)
 SYMBOL(SHRT_MAX, None, <limits.h>)
 SYMBOL(SHRT_MIN, None, <limits.h>)
 SYMBOL(SIGABRT, None, <signal.h>)
 SYMBOL(SIGFPE, None, <signal.h>)
 SYMBOL(SIGILL, None, <signal.h>)
 SYMBOL(SIGINT, None, <signal.h>)
 SYMBOL(SIGSEGV, None, <signal.h>)
 SYMBOL(SIGTERM, None, <signal.h>)
 SYMBOL(SIG_ATOMIC_MAX, None, <stdint.h>)
 SYMBOL(SIG_ATOMIC_MIN, None, <stdint.h>)
 SYMBOL(SIG_DFL, None, <signal.h>)
 SYMBOL(SIG_ERR, None, <signal.h>)
 SYMBOL(SIG_IGN, None, <signal.h>)
 SYMBOL(SIZE_MAX, None, <stdint.h>)
 SYMBOL(TIME_UTC, None, <time.h>)
 SYMBOL(TMP_MAX, None, <stdio.h>)
 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>)
 SYMBOL(UINT_FAST32_MAX, None, <stdint.h>)
 SYMBOL(UINT_FAST64_MAX, None, <stdint.h>)
 SYMBOL(UINT_FAST8_MAX, None, <stdint.h>)
 SYMBOL(UINT_LEAST16_MAX, None, <stdint.h>)
 SYMBOL(UINT_LEAST32_MAX, None, <stdint.h>)

 SYMBOL(ctanf, None, <complex.h>)
 SYMBOL(ctanh, None, <complex.h>)
 SYMBOL(ctanhf, None, <complex.h>)
 SYMBOL(ctanhl, None, <complex.h>)
 SYMBOL(ctanl, None, <complex.h>)
 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>)
 SYMBOL(erfcf, None, <math.h>)
 SYMBOL(erfcl, None, <math.h>)
 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>)
 SYMBOL(exp2f, None, <math.h>)
 SYMBOL(exp2l, None, <math.h>)
 SYMBOL(expf, None, <math.h>)
 SYMBOL(expl, None, <math.h>)
 SYMBOL(expm1, None, <math.h>)

 SYMBOL(hypotf, None, <math.h>)
 SYMBOL(hypotl, None, <math.h>)
 SYMBOL(ignore_handler_s, None, <stdlib.h>)
 SYMBOL(ilogb, None, <math.h>)
 SYMBOL(ilogbf, None, <math.h>)
 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>)
 SYMBOL(int8_t, None, <stdint.h>)
 SYMBOL(int_fast16_t, None, <stdint.h>)
 SYMBOL(int_fast32_t, None, <stdint.h>)
 SYMBOL(int_fast64_t, None, <stdint.h>)
 SYMBOL(int_fast8_t, None, <stdint.h>)

 SYMBOL(isxdigit, None, <ctype.h>)
 SYMBOL(jmp_buf, None, <setjmp.h>)
 SYMBOL(kill_dependency, None, <stdatomic.h>)
 SYMBOL(labs, None, <stdlib.h>)
 SYMBOL(lconv, None, <locale.h>)
 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>)
 SYMBOL(llround, None, <math.h>)
 SYMBOL(llroundf, None, <math.h>)
 SYMBOL(llroundl, None, <math.h>)
 SYMBOL(localeconv, None, <locale.h>)
 SYMBOL(localtime, None, <time.h>)

 SYMBOL(mblen, None, <stdlib.h>)
 SYMBOL(mbrlen, None, <wchar.h>)
 SYMBOL(mbrtoc16, None, <uchar.h>)
 SYMBOL(mbrtoc32, None, <uchar.h>)
 SYMBOL(mbrtowc, None, <wchar.h>)
 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>)
 SYMBOL(memchr, None, <string.h>)
 SYMBOL(memcmp, None, <string.h>)
 SYMBOL(memcpy, None, <string.h>)
 SYMBOL(memcpy_s, None, <string.h>)
 SYMBOL(memmove, None, <string.h>)

 SYMBOL(signal, None, <signal.h>)
 SYMBOL(signbit, None, <math.h>)
 SYMBOL(sin, None, <math.h>)
 SYMBOL(sinf, None, <math.h>)
 SYMBOL(sinh, None, <math.h>)
 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>)
 SYMBOL(sprintf, None, <stdio.h>)
 SYMBOL(sprintf_s, None, <stdio.h>)
 SYMBOL(sqrt, None, <math.h>)
 SYMBOL(sqrtf, None, <math.h>)
 SYMBOL(sqrtl, None, <math.h>)

clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc

 SYMBOL(atan, std::, <cmath>)
 SYMBOL(atan2, std::, <cmath>)
 SYMBOL(atanh, std::, <cmath>)
 SYMBOL(atexit, std::, <cstdlib>)
 SYMBOL(atof, std::, <cstdlib>)
 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>)
 SYMBOL(atomic_compare_exchange_weak_explicit, std::, <atomic>)
 SYMBOL(atomic_exchange, std::, <atomic>)
 SYMBOL(atomic_exchange_explicit, std::, <atomic>)
 SYMBOL(atomic_fetch_add, std::, <atomic>)
 SYMBOL(atomic_fetch_add_explicit, std::, <atomic>)
 SYMBOL(atomic_fetch_and, std::, <atomic>)
 SYMBOL(atomic_fetch_and_explicit, std::, <atomic>)
 SYMBOL(atomic_fetch_or, std::, <atomic>)
 SYMBOL(atomic_fetch_or_explicit, std::, <atomic>)
 SYMBOL(atomic_fetch_sub, std::, <atomic>)
 SYMBOL(atomic_fetch_sub_explicit, std::, <atomic>)
 SYMBOL(atomic_fetch_xor, std::, <atomic>)
 SYMBOL(atomic_fetch_xor_explicit, std::, <atomic>)
 SYMBOL(atomic_flag, std::, <atomic>)
 SYMBOL(atomic_flag_clear, std::, <atomic>)
 SYMBOL(atomic_flag_clear_explicit, std::, <atomic>)
 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>)
 SYMBOL(back_inserter, std::, <iterator>)
 SYMBOL(bad_alloc, std::, <new>)
 SYMBOL(bad_any_cast, std::, <any>)
 SYMBOL(bad_array_new_length, std::, <new>)
 SYMBOL(bad_cast, std::, <typeinfo>)

 SYMBOL(basic_osyncstream, std::, <syncstream>)
 SYMBOL(basic_regex, std::, <regex>)
 SYMBOL(basic_streambuf, std::, <streambuf>)
 SYMBOL(basic_string, std::, <string>)
 SYMBOL(basic_string_view, std::, <string_view>)
 SYMBOL(basic_stringbuf, std::, <sstream>)
 SYMBOL(basic_stringstream, std::, <sstream>)
 SYMBOL(basic_syncbuf, std::, <syncstream>)
 SYMBOL(begin, std::, <iterator>)
 SYMBOL(bernoulli_distribution, std::, <random>)
 SYMBOL(bidirectional_iterator_tag, std::, <iterator>)
 SYMBOL(binary_search, std::, <algorithm>)
 SYMBOL(bind, std::, <functional>)
 SYMBOL(binomial_distribution, std::, <random>)
 SYMBOL(bit_and, std::, <functional>)
 SYMBOL(bit_cast, std::, <bit>)
 SYMBOL(bit_not, std::, <functional>)

 SYMBOL(condition_variable, std::, <condition_variable>)
 SYMBOL(condition_variable_any, std::, <condition_variable>)
 SYMBOL(conditional, std::, <type_traits>)
 SYMBOL(conditional_t, std::, <type_traits>)
 SYMBOL(conj, std::, <complex>)
 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>)
 SYMBOL(copy_if, std::, <algorithm>)
 SYMBOL(copy_n, std::, <algorithm>)
 SYMBOL(copysign, std::, <cmath>)
 SYMBOL(cos, std::, <cmath>)
 SYMBOL(cosh, std::, <cmath>)

 SYMBOL(destroying_delete, std::, <new>)
 SYMBOL(destroying_delete_t, std::, <new>)
 SYMBOL(difftime, std::, <ctime>)
 SYMBOL(discard_block_engine, std::, <random>)
 SYMBOL(discrete_distribution, std::, <random>)
 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>)
 SYMBOL(double_t, std::, <cmath>)
 SYMBOL(dynamic_extent, std::, <span>)
 SYMBOL(dynamic_pointer_cast, std::, <memory>)
 SYMBOL(emit_on_flush, std::, <ostream>)
 SYMBOL(empty, std::, <iterator>)
 SYMBOL(enable_if, std::, <type_traits>)

 SYMBOL(fwide, std::, <cwchar>)
 SYMBOL(fwprintf, std::, <cwchar>)
 SYMBOL(fwrite, std::, <cstdio>)
 SYMBOL(fwscanf, std::, <cwchar>)
 SYMBOL(gamma_distribution, std::, <random>)
 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>)
 SYMBOL(get_if, std::, <variant>)
 SYMBOL(get_money, std::, <iomanip>)
 SYMBOL(get_new_handler, std::, <new>)
 SYMBOL(get_pointer_safety, std::, <memory>)
 SYMBOL(get_terminate, std::, <exception>)

 SYMBOL(length_error, std::, <stdexcept>)
 SYMBOL(less, std::, <functional>)
 SYMBOL(less_equal, std::, <functional>)
 SYMBOL(lexicographical_compare, std::, <algorithm>)
 SYMBOL(lexicographical_compare_3way, std::, <algorithm>)
 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>)
 SYMBOL(llrint, std::, <cmath>)
 SYMBOL(llround, std::, <cmath>)
 SYMBOL(locale, std::, <locale>)
 SYMBOL(localeconv, std::, <clocale>)
 SYMBOL(localtime, std::, <ctime>)

 SYMBOL(max_element, std::, <algorithm>)
 SYMBOL(mblen, std::, <cstdlib>)
 SYMBOL(mbrlen, std::, <cwchar>)
 SYMBOL(mbrtoc16, std::, <cuchar>)
 SYMBOL(mbrtoc32, std::, <cuchar>)
 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>)
 SYMBOL(mem_fn, std::, <functional>)
 SYMBOL(memchr, std::, <cstring>)
 SYMBOL(memcmp, std::, <cstring>)
 SYMBOL(memcpy, std::, <cstring>)
 SYMBOL(memmove, std::, <cstring>)

 SYMBOL(regex_iterator, std::, <regex>)
 SYMBOL(regex_match, std::, <regex>)
 SYMBOL(regex_replace, std::, <regex>)
 SYMBOL(regex_search, std::, <regex>)
 SYMBOL(regex_token_iterator, std::, <regex>)
 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>)
 SYMBOL(remove_const_t, std::, <type_traits>)
 SYMBOL(remove_copy, std::, <algorithm>)
 SYMBOL(remove_copy_if, std::, <algorithm>)
 SYMBOL(remove_cv, std::, <type_traits>)
 SYMBOL(remove_cv_t, std::, <type_traits>)

 SYMBOL(shuffle, std::, <algorithm>)
 SYMBOL(shuffle_order_engine, std::, <random>)
 SYMBOL(sig_atomic_t, std::, <csignal>)
 SYMBOL(signal, std::, <csignal>)
 SYMBOL(signbit, std::, <cmath>)
 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>)
 SYMBOL(smatch, std::, <regex>)
 SYMBOL(snprintf, std::, <cstdio>)
 SYMBOL(sort, std::, <algorithm>)
 SYMBOL(sort_heap, std::, <algorithm>)
 SYMBOL(span, std::, <span>)

 SYMBOL(strtoll, std::, <cstdlib>)
 SYMBOL(strtoul, std::, <cstdlib>)
 SYMBOL(strtoull, std::, <cstdlib>)
 SYMBOL(strtoumax, std::, <cinttypes>)
 SYMBOL(strxfrm, std::, <cstring>)
 SYMBOL(student_t_distribution, std::, <random>)
 SYMBOL(sub_match, std::, <regex>)
 SYMBOL(subtract_with_carry_engine, std::, <random>)
+SYMBOL(swap, std::, <algorithm>)
 SYMBOL(swap_ranges, std::, <algorithm>)
 SYMBOL(swprintf, std::, <cwchar>)
 SYMBOL(swscanf, std::, <cwchar>)
 SYMBOL(syncbuf, std::, <syncstream>)
 SYMBOL(system, std::, <cstdlib>)
 SYMBOL(system_category, std::, <system_error>)
 SYMBOL(system_error, std::, <system_error>)
 SYMBOL(tan, std::, <cmath>)

 SYMBOL(weak_equality, std::, <compare>)
 SYMBOL(weak_order, std::, <compare>)
 SYMBOL(weak_ordering, std::, <compare>)
 SYMBOL(weak_ptr, std::, <memory>)
 SYMBOL(weibull_distribution, std::, <random>)
 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>)
 SYMBOL(wistringstream, std::, <sstream>)
 SYMBOL(wmemchr, std::, <cwchar>)
 SYMBOL(wmemcmp, std::, <cwchar>)
 SYMBOL(wmemcpy, std::, <cwchar>)
 SYMBOL(wmemmove, std::, <cwchar>)

clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp

 //===--- StandardLibrary.cpp ------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #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"
 
 namespace clang {
 namespace tooling {
 namespace stdlib {
 
 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>;
 static llvm::DenseMap<llvm::StringRef, NSSymbolMap *> *NamespaceSymbols;
 
 static int initialize() {
   unsigned SymCount = 0;
 #define SYMBOL(Name, NS, Header) ++SymCount;
 #include "clang/Tooling/Inclusions/CSymbolMap.inc"
 #include "clang/Tooling/Inclusions/StdSymbolMap.inc"
 #undef SYMBOL
   SymbolNames = new std::remove_reference_t<decltype(*SymbolNames)>[SymCount];
   SymbolHeaderIDs =
       new std::remove_reference_t<decltype(*SymbolHeaderIDs)>[SymCount];
   NamespaceSymbols = new std::remove_reference_t<decltype(*NamespaceSymbols)>;
   HeaderIDs = new std::remove_reference_t<decltype(*HeaderIDs)>;
 
   auto AddNS = [&](llvm::StringRef NS) -> NSSymbolMap & {
     auto R = NamespaceSymbols->try_emplace(NS, nullptr);
     if (R.second)
       R.first->second = new NSSymbolMap();
     return *R.first->second;
   };
 
   auto AddHeader = [&](llvm::StringRef Header) -> unsigned {
     return HeaderIDs->try_emplace(Header, HeaderIDs->size()).first->second;
   };
 
-  auto Add = [&, SymIndex(0)](llvm::StringRef Name, llvm::StringRef NS,
+  auto Add = [&, NextAvailSymIndex(0)](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.
+    unsigned SymIndex = NextAvailSymIndex;
+    if (NextAvailSymIndex > 0 &&
+        SymbolNames[NextAvailSymIndex - 1].first == NS &&
+        SymbolNames[NextAvailSymIndex - 1].second == Name) {
+      // Not a new symbol, use the same index.
+      SymIndex = NextAvailSymIndex - 1;
+    } else {
+      // New symbol, increment next available index.
+      ++NextAvailSymIndex;
+    }
+
     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"
 #include "clang/Tooling/Inclusions/StdSymbolMap.inc"
 #undef SYMBOL
 
   HeaderNames = new llvm::StringRef[HeaderIDs->size()];
   for (const auto &E : *HeaderIDs)
     HeaderNames[E.second] = E.first;
 
   return 0;
 }
 
 static void ensureInitialized() {
   static int Dummy = initialize();
   (void)Dummy;
 }
 
 std::optional<Header> Header::named(llvm::StringRef Name) {
   ensureInitialized();
   auto It = HeaderIDs->find(Name);
   if (It == HeaderIDs->end())
     return std::nullopt;
   return Header(It->second);
 }
 llvm::StringRef Header::name() const { return HeaderNames[ID]; }
 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) {
   ensureInitialized();
   if (NSSymbolMap *NSSymbols = NamespaceSymbols->lookup(Scope)) {
     auto It = NSSymbols->find(Name);
     if (It != NSSymbols->end())
       return Symbol(It->second);
   }
   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(); }
 
 NSSymbolMap *Recognizer::namespaceSymbols(const NamespaceDecl *D) {
   auto It = NamespaceCache.find(D);
   if (It != NamespaceCache.end())
     return It->second;

clang/tools/include-mapping/cppreference_parser.py

 
 def _HasClass(tag, *classes):
   for c in tag.get('class', []):
     if c in classes:
       return True
   return False
 
 
-def _ParseSymbolPage(symbol_page_html, symbol_name):
+def _ParseSymbolPage(symbol_page_html, symbol_name, header_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:
 
   <tr class="t-dsc-header">
     <td colspan="2"> <div>Defined in header <code>&lt;ratio&gt;</code> </div>
   </td></tr>
 
   Returns a list of headers.
   """
-  headers = set()
+  symbol_headers = set()
   all_headers = set()
 
   soup = BeautifulSoup(symbol_page_html, "html.parser")
   # Rows in table are like:
   #   Defined in header <foo>      .t-dsc-header
   #   Defined in header <bar>      .t-dsc-header
   #   decl1                        .t-dcl
   #   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 header_to_accept != "" and header_code.text.strip("<>") != header_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 _HasClass(rows[i], 't-dsc-hitem'):
+        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:
+          # FIXME: 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
+
+  # If the symbol was never named, consider all named headers.      
+  # FIXME: only consider first symbol, assume further symbols are overloads
+  all_headers = sorted(list(all_headers))
+  if len(all_headers) > 0:
+    all_headers = [all_headers[0]]
 
+  return symbol_headers or all_headers
 
 def _ParseIndexPage(index_page_html):
   """Parse index page.
   The index page lists all std symbols and hrefs to their detailed pages
   (which contain the defined header). An example:
 
   <a href="abs.html" title="abs"><tt>abs()</tt></a> (int) <br>
   <a href="acos.html" title="acos"><tt>acos()</tt></a> <br>
if isinstance(caption, NavigableString) and "(" in caption:
       variant = caption.text.strip(" ()")
     symbol_tt = symbol_href.find("tt")
     if symbol_tt:
       symbols.append((symbol_tt.text.rstrip("<>()"), # strip any trailing <>()
                       symbol_href["href"], variant))
   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):
   """Get all symbols listed in the index page. All symbols should be in the
   given namespace.
 
   Returns a list of Symbols.
   """
 
   # Workflow steps:
   #   1. Parse index page which lists all symbols to get symbol
   #      name (unqualified name) and its href link to the symbol page which
   #      contains the defined header.
   #   2. Parse the symbol page to get the defined header.
   index_page_path = os.path.join(root_dir, index_page_name)
   with open(index_page_path, "r") as f:
     # Read each symbol page in parallel.
     results = [] # (symbol_name, promise of [header...])
     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:
+      header_to_accept = variants_to_accept.get(
+          (namespace or "") + symbol_name, "")
+      if variant and variant != header_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, header_to_accept))))
       else:
         sys.stderr.write("Discarding information for symbol: %s. Page %s does not exist.\n" 
           % (symbol_name, path))                
 
     # Build map from symbol name to a set of headers.
     symbol_headers = collections.defaultdict(set)
     for symbol_name, lazy_headers in results:
       symbol_headers[symbol_name].update(lazy_headers.get())
def GetSymbols(parse_pages):
   Args:
     parse_pages: a list of tuples (page_root_dir, index_page_name, namespace)
   """
   # By default we prefer the non-variant versions, as they're more common. But
   # there are some symbols, whose variant is more common. This list describes
   # those symbols.
   variants_to_accept = {
       # std::remove<> has variant algorithm.
-      "std::remove": ("algorithm"),
+      "std::remove": "algorithm",
   }
   symbols = []
   # Run many workers to process individual symbol pages under the symbol index.
   # Don't allow workers to capture Ctrl-C.
   pool = multiprocessing.Pool(
       initializer=lambda: signal.signal(signal.SIGINT, signal.SIG_IGN))
   try:
     for root_dir, page_name, namespace in parse_pages:
       symbols.extend(_GetSymbols(pool, root_dir, page_name, namespace,
                                  variants_to_accept))
   finally:
     pool.terminate()
     pool.join()
   return symbols

clang/tools/include-mapping/gen_std.py

 #!/usr/bin/env python
 #===- gen_std.py -  ------------------------------------------*- python -*--===#
 #
 # 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
 #
 #===------------------------------------------------------------------------===#
 
 """gen_std.py is a tool to generate a lookup table (from qualified names to
 include headers) for C/C++ Standard Library symbols by parsing archived HTML
 files from cppreference.
 
 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:
        https://www.crummy.com/software/BeautifulSoup/bs4/doc/#installing-beautiful-soup
   2. Download cppreference offline HTML files (e.g. html_book_20181028.zip) at
        https://en.cppreference.com/w/Cppreference:Archives
   3. Unzip the zip file from step 2 (e.g., to a "cppreference" directory). You should
      get a "cppreference/reference" directory.
def main():
   symbols = cppreference_parser.GetSymbols(parse_pages)
   
   # We don't have version information from the unzipped offline HTML files.
   # so we use the modified time of the symbol_index.html as the version.
   index_page_path = os.path.join(page_root, "index.html")
   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()