clang: lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp Source File (original) (raw)

1

2

3

4

5

6

7

8

12#include "llvm/ADT/ArrayRef.h"

13#include "llvm/ADT/DenseSet.h"

14#include "llvm/ADT/STLExtras.h"

15#include "llvm/ADT/StringRef.h"

16#include "llvm/Support/Casting.h"

17#include

18

22

23namespace {

24

25using NSSymbolMap = llvm::DenseMap<llvm::StringRef, unsigned>;

26

27

28struct SymbolHeaderMapping {

29 llvm::StringRef *HeaderNames = nullptr;

30

31 llvm::DenseMap<llvm::StringRef, unsigned> *HeaderIDs;

32

33 unsigned SymbolCount = 0;

34

35 struct SymbolName {

36 const char *Data;

37 unsigned ScopeLen;

38 unsigned NameLen;

39 StringRef scope() const { return StringRef(Data, ScopeLen); }

40 StringRef name() const { return StringRef(Data + ScopeLen, NameLen); }

41 StringRef qualifiedName() const {

42 return StringRef(Data, ScopeLen + NameLen);

43 }

44 } *SymbolNames = nullptr;

45

46 llvm::DenseMap<llvm::StringRef, NSSymbolMap *> *NamespaceSymbols = nullptr;

47

48 llvm::SmallVector *SymbolHeaderIDs = nullptr;

49};

50}

51static SymbolHeaderMapping

56

59#define SYMBOL(Name, NS, Header) #NS #Name,

62 static constexpr const char *CSymbols[] = {

65 };

66 Symbols = CSymbols;

67 break;

68 }

70 static constexpr const char *CXXSymbols[] = {

74 };

75 Symbols = CXXSymbols;

76 break;

77 }

78 }

79#undef SYMBOL

80 return llvm::DenseSet(llvm::from_range, Symbols).size();

81}

82

84 SymbolHeaderMapping *Mapping = new SymbolHeaderMapping();

86

88 Mapping->SymbolCount = SymCount;

89 Mapping->SymbolNames =

90 new std::remove_reference_t<decltype(*Mapping->SymbolNames)>[SymCount];

91 Mapping->SymbolHeaderIDs = new std::remove_reference_t<

92 decltype(*Mapping->SymbolHeaderIDs)>[SymCount];

93 Mapping->NamespaceSymbols =

94 new std::remove_reference_t<decltype(*Mapping->NamespaceSymbols)>;

95 Mapping->HeaderIDs =

96 new std::remove_reference_t<decltype(*Mapping->HeaderIDs)>;

97 auto AddNS = [&](llvm::StringRef NS) -> NSSymbolMap & {

98 auto R = Mapping->NamespaceSymbols->try_emplace(NS, nullptr);

99 if (R.second)

100 R.first->second = new NSSymbolMap();

101 return *R.first->second;

102 };

103

104 auto AddHeader = [&](llvm::StringRef Header) -> unsigned {

105 return Mapping->HeaderIDs->try_emplace(Header, Mapping->HeaderIDs->size())

106 .first->second;

107 };

108

109 auto Add = [&, SymIndex(-1)](llvm::StringRef QName, unsigned NSLen,

110 llvm::StringRef HeaderName) mutable {

111

112

113 if (QName.take_front(NSLen) == "None") {

114 QName = QName.drop_front(NSLen);

115 NSLen = 0;

116 }

117

118 if (SymIndex > 0) {

119 assert(llvm::none_of(llvm::ArrayRef(Mapping->SymbolNames, SymIndex),

120 [&QName](const SymbolHeaderMapping::SymbolName &S) {

121 return S.qualifiedName() == QName;

122 }) &&

123 "The symbol has been added before, make sure entries in the .inc "

124 "file are grouped by symbol name!");

125 }

126 if (SymIndex < 0 ||

127 Mapping->SymbolNames[SymIndex].qualifiedName() != QName) {

128

129 ++SymIndex;

130 }

131 Mapping->SymbolNames[SymIndex] = {

132 QName.data(), NSLen, static_cast<unsigned int>(QName.size() - NSLen)};

133 if (!HeaderName.empty())

134 Mapping->SymbolHeaderIDs[SymIndex].push_back(AddHeader(HeaderName));

135

136 NSSymbolMap &NSSymbols = AddNS(QName.take_front(NSLen));

137 NSSymbols.try_emplace(QName.drop_front(NSLen), SymIndex);

138 };

139

141 const char *QName;

142 unsigned NSLen;

143 const char *HeaderName;

144 };

145#define SYMBOL(Name, NS, Header) \

146 {#NS #Name, static_cast<decltype(Symbol::NSLen)>(StringRef(#NS).size()), \

147 #Header},

150 static constexpr Symbol CSymbols[] = {

153 };

154 for (const Symbol &S : CSymbols)

155 Add(S.QName, S.NSLen, S.HeaderName);

156 break;

157 }

159 static constexpr Symbol CXXSymbols[] = {

163 };

164 for (const Symbol &S : CXXSymbols)

165 Add(S.QName, S.NSLen, S.HeaderName);

166 break;

167 }

168 }

169#undef SYMBOL

170

171 Mapping->HeaderNames = new llvm::StringRef[Mapping->HeaderIDs->size()];

172 for (const auto &E : *Mapping->HeaderIDs)

173 Mapping->HeaderNames[E.second] = E.first;

174

175 return 0;

176}

177

179 static int Dummy = []() {

180 for (unsigned L = 0; L <= static_cast(Lang::LastValue); ++L)

182 return 0;

183 }();

184 (void)Dummy;

185}

186

189 std::vector