Bug Summary

File:tools/clang/lib/Lex/ModuleMap.cpp
Warning:line 1140, column 7
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ModuleMap.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/lib/Lex -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn329677/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/lib/Lex -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-04-11-031539-24776-1 -x c++ /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp
1//===- ModuleMap.cpp - Describe the layout of modules ---------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the ModuleMap implementation, which describes the layout
11// of a module as it relates to headers.
12//
13//===----------------------------------------------------------------------===//
14
15#include "clang/Lex/ModuleMap.h"
16#include "clang/Basic/CharInfo.h"
17#include "clang/Basic/Diagnostic.h"
18#include "clang/Basic/FileManager.h"
19#include "clang/Basic/LLVM.h"
20#include "clang/Basic/LangOptions.h"
21#include "clang/Basic/Module.h"
22#include "clang/Basic/SourceLocation.h"
23#include "clang/Basic/SourceManager.h"
24#include "clang/Basic/TargetInfo.h"
25#include "clang/Basic/VirtualFileSystem.h"
26#include "clang/Lex/HeaderSearch.h"
27#include "clang/Lex/HeaderSearchOptions.h"
28#include "clang/Lex/LexDiagnostic.h"
29#include "clang/Lex/Lexer.h"
30#include "clang/Lex/LiteralSupport.h"
31#include "clang/Lex/Token.h"
32#include "llvm/ADT/DenseMap.h"
33#include "llvm/ADT/None.h"
34#include "llvm/ADT/STLExtras.h"
35#include "llvm/ADT/SmallPtrSet.h"
36#include "llvm/ADT/SmallString.h"
37#include "llvm/ADT/SmallVector.h"
38#include "llvm/ADT/StringMap.h"
39#include "llvm/ADT/StringRef.h"
40#include "llvm/ADT/StringSwitch.h"
41#include "llvm/Support/Allocator.h"
42#include "llvm/Support/Compiler.h"
43#include "llvm/Support/ErrorHandling.h"
44#include "llvm/Support/MemoryBuffer.h"
45#include "llvm/Support/Path.h"
46#include "llvm/Support/raw_ostream.h"
47#include <algorithm>
48#include <cassert>
49#include <cstdint>
50#include <cstring>
51#include <string>
52#include <system_error>
53#include <utility>
54
55using namespace clang;
56
57Module::HeaderKind ModuleMap::headerRoleToKind(ModuleHeaderRole Role) {
58 switch ((int)Role) {
59 default: llvm_unreachable("unknown header role")::llvm::llvm_unreachable_internal("unknown header role", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 59)
;
60 case NormalHeader:
61 return Module::HK_Normal;
62 case PrivateHeader:
63 return Module::HK_Private;
64 case TextualHeader:
65 return Module::HK_Textual;
66 case PrivateHeader | TextualHeader:
67 return Module::HK_PrivateTextual;
68 }
69}
70
71ModuleMap::ModuleHeaderRole
72ModuleMap::headerKindToRole(Module::HeaderKind Kind) {
73 switch ((int)Kind) {
74 case Module::HK_Normal:
75 return NormalHeader;
76 case Module::HK_Private:
77 return PrivateHeader;
78 case Module::HK_Textual:
79 return TextualHeader;
80 case Module::HK_PrivateTextual:
81 return ModuleHeaderRole(PrivateHeader | TextualHeader);
82 case Module::HK_Excluded:
83 llvm_unreachable("unexpected header kind")::llvm::llvm_unreachable_internal("unexpected header kind", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 83)
;
84 }
85 llvm_unreachable("unknown header kind")::llvm::llvm_unreachable_internal("unknown header kind", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 85)
;
86}
87
88Module::ExportDecl
89ModuleMap::resolveExport(Module *Mod,
90 const Module::UnresolvedExportDecl &Unresolved,
91 bool Complain) const {
92 // We may have just a wildcard.
93 if (Unresolved.Id.empty()) {
94 assert(Unresolved.Wildcard && "Invalid unresolved export")(static_cast <bool> (Unresolved.Wildcard && "Invalid unresolved export"
) ? void (0) : __assert_fail ("Unresolved.Wildcard && \"Invalid unresolved export\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 94, __extension__ __PRETTY_FUNCTION__))
;
95 return Module::ExportDecl(nullptr, true);
96 }
97
98 // Resolve the module-id.
99 Module *Context = resolveModuleId(Unresolved.Id, Mod, Complain);
100 if (!Context)
101 return {};
102
103 return Module::ExportDecl(Context, Unresolved.Wildcard);
104}
105
106Module *ModuleMap::resolveModuleId(const ModuleId &Id, Module *Mod,
107 bool Complain) const {
108 // Find the starting module.
109 Module *Context = lookupModuleUnqualified(Id[0].first, Mod);
110 if (!Context) {
111 if (Complain)
112 Diags.Report(Id[0].second, diag::err_mmap_missing_module_unqualified)
113 << Id[0].first << Mod->getFullModuleName();
114
115 return nullptr;
116 }
117
118 // Dig into the module path.
119 for (unsigned I = 1, N = Id.size(); I != N; ++I) {
120 Module *Sub = lookupModuleQualified(Id[I].first, Context);
121 if (!Sub) {
122 if (Complain)
123 Diags.Report(Id[I].second, diag::err_mmap_missing_module_qualified)
124 << Id[I].first << Context->getFullModuleName()
125 << SourceRange(Id[0].second, Id[I-1].second);
126
127 return nullptr;
128 }
129
130 Context = Sub;
131 }
132
133 return Context;
134}
135
136/// \brief Append to \p Paths the set of paths needed to get to the
137/// subframework in which the given module lives.
138static void appendSubframeworkPaths(Module *Mod,
139 SmallVectorImpl<char> &Path) {
140 // Collect the framework names from the given module to the top-level module.
141 SmallVector<StringRef, 2> Paths;
142 for (; Mod; Mod = Mod->Parent) {
143 if (Mod->IsFramework)
144 Paths.push_back(Mod->Name);
145 }
146
147 if (Paths.empty())
148 return;
149
150 // Add Frameworks/Name.framework for each subframework.
151 for (unsigned I = Paths.size() - 1; I != 0; --I)
152 llvm::sys::path::append(Path, "Frameworks", Paths[I-1] + ".framework");
153}
154
155const FileEntry *
156ModuleMap::findHeader(Module *M,
157 const Module::UnresolvedHeaderDirective &Header,
158 SmallVectorImpl<char> &RelativePathName) {
159 auto GetFile = [&](StringRef Filename) -> const FileEntry * {
160 auto *File = SourceMgr.getFileManager().getFile(Filename);
161 if (!File ||
162 (Header.Size && File->getSize() != *Header.Size) ||
163 (Header.ModTime && File->getModificationTime() != *Header.ModTime))
164 return nullptr;
165 return File;
166 };
167
168 if (llvm::sys::path::is_absolute(Header.FileName)) {
169 RelativePathName.clear();
170 RelativePathName.append(Header.FileName.begin(), Header.FileName.end());
171 return GetFile(Header.FileName);
172 }
173
174 // Search for the header file within the module's home directory.
175 auto *Directory = M->Directory;
176 SmallString<128> FullPathName(Directory->getName());
177 unsigned FullPathLength = FullPathName.size();
178
179 if (M->isPartOfFramework()) {
180 appendSubframeworkPaths(M, RelativePathName);
181 unsigned RelativePathLength = RelativePathName.size();
182
183 // Check whether this file is in the public headers.
184 llvm::sys::path::append(RelativePathName, "Headers", Header.FileName);
185 llvm::sys::path::append(FullPathName, RelativePathName);
186 if (auto *File = GetFile(FullPathName))
187 return File;
188
189 // Check whether this file is in the private headers.
190 // Ideally, private modules in the form 'FrameworkName.Private' should
191 // be defined as 'module FrameworkName.Private', and not as
192 // 'framework module FrameworkName.Private', since a 'Private.Framework'
193 // does not usually exist. However, since both are currently widely used
194 // for private modules, make sure we find the right path in both cases.
195 if (M->IsFramework && M->Name == "Private")
196 RelativePathName.clear();
197 else
198 RelativePathName.resize(RelativePathLength);
199 FullPathName.resize(FullPathLength);
200 llvm::sys::path::append(RelativePathName, "PrivateHeaders",
201 Header.FileName);
202 llvm::sys::path::append(FullPathName, RelativePathName);
203 return GetFile(FullPathName);
204 }
205
206 // Lookup for normal headers.
207 llvm::sys::path::append(RelativePathName, Header.FileName);
208 llvm::sys::path::append(FullPathName, RelativePathName);
209 return GetFile(FullPathName);
210}
211
212void ModuleMap::resolveHeader(Module *Mod,
213 const Module::UnresolvedHeaderDirective &Header) {
214 SmallString<128> RelativePathName;
215 if (const FileEntry *File = findHeader(Mod, Header, RelativePathName)) {
216 if (Header.IsUmbrella) {
217 const DirectoryEntry *UmbrellaDir = File->getDir();
218 if (Module *UmbrellaMod = UmbrellaDirs[UmbrellaDir])
219 Diags.Report(Header.FileNameLoc, diag::err_mmap_umbrella_clash)
220 << UmbrellaMod->getFullModuleName();
221 else
222 // Record this umbrella header.
223 setUmbrellaHeader(Mod, File, RelativePathName.str());
224 } else {
225 Module::Header H = {RelativePathName.str(), File};
226 if (Header.Kind == Module::HK_Excluded)
227 excludeHeader(Mod, H);
228 else
229 addHeader(Mod, H, headerKindToRole(Header.Kind));
230 }
231 } else if (Header.HasBuiltinHeader && !Header.Size && !Header.ModTime) {
232 // There's a builtin header but no corresponding on-disk header. Assume
233 // this was supposed to modularize the builtin header alone.
234 } else if (Header.Kind == Module::HK_Excluded) {
235 // Ignore missing excluded header files. They're optional anyway.
236 } else {
237 // If we find a module that has a missing header, we mark this module as
238 // unavailable and store the header directive for displaying diagnostics.
239 Mod->MissingHeaders.push_back(Header);
240 // A missing header with stat information doesn't make the module
241 // unavailable; this keeps our behavior consistent as headers are lazily
242 // resolved. (Such a module still can't be built though, except from
243 // preprocessed source.)
244 if (!Header.Size && !Header.ModTime)
245 Mod->markUnavailable();
246 }
247}
248
249bool ModuleMap::resolveAsBuiltinHeader(
250 Module *Mod, const Module::UnresolvedHeaderDirective &Header) {
251 if (Header.Kind == Module::HK_Excluded ||
252 llvm::sys::path::is_absolute(Header.FileName) ||
253 Mod->isPartOfFramework() || !Mod->IsSystem || Header.IsUmbrella ||
254 !BuiltinIncludeDir || BuiltinIncludeDir == Mod->Directory ||
255 !isBuiltinHeader(Header.FileName))
256 return false;
257
258 // This is a system module with a top-level header. This header
259 // may have a counterpart (or replacement) in the set of headers
260 // supplied by Clang. Find that builtin header.
261 SmallString<128> Path;
262 llvm::sys::path::append(Path, BuiltinIncludeDir->getName(), Header.FileName);
263 auto *File = SourceMgr.getFileManager().getFile(Path);
264 if (!File)
265 return false;
266
267 auto Role = headerKindToRole(Header.Kind);
268 Module::Header H = {Path.str(), File};
269 addHeader(Mod, H, Role);
270 return true;
271}
272
273ModuleMap::ModuleMap(SourceManager &SourceMgr, DiagnosticsEngine &Diags,
274 const LangOptions &LangOpts, const TargetInfo *Target,
275 HeaderSearch &HeaderInfo)
276 : SourceMgr(SourceMgr), Diags(Diags), LangOpts(LangOpts), Target(Target),
277 HeaderInfo(HeaderInfo) {
278 MMapLangOpts.LineComment = true;
279}
280
281ModuleMap::~ModuleMap() {
282 for (auto &M : Modules)
283 delete M.getValue();
284 for (auto *M : ShadowModules)
285 delete M;
286}
287
288void ModuleMap::setTarget(const TargetInfo &Target) {
289 assert((!this->Target || this->Target == &Target) &&(static_cast <bool> ((!this->Target || this->Target
== &Target) && "Improper target override") ? void
(0) : __assert_fail ("(!this->Target || this->Target == &Target) && \"Improper target override\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 290, __extension__ __PRETTY_FUNCTION__))
290 "Improper target override")(static_cast <bool> ((!this->Target || this->Target
== &Target) && "Improper target override") ? void
(0) : __assert_fail ("(!this->Target || this->Target == &Target) && \"Improper target override\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 290, __extension__ __PRETTY_FUNCTION__))
;
291 this->Target = &Target;
292}
293
294/// \brief "Sanitize" a filename so that it can be used as an identifier.
295static StringRef sanitizeFilenameAsIdentifier(StringRef Name,
296 SmallVectorImpl<char> &Buffer) {
297 if (Name.empty())
298 return Name;
299
300 if (!isValidIdentifier(Name)) {
301 // If we don't already have something with the form of an identifier,
302 // create a buffer with the sanitized name.
303 Buffer.clear();
304 if (isDigit(Name[0]))
305 Buffer.push_back('_');
306 Buffer.reserve(Buffer.size() + Name.size());
307 for (unsigned I = 0, N = Name.size(); I != N; ++I) {
308 if (isIdentifierBody(Name[I]))
309 Buffer.push_back(Name[I]);
310 else
311 Buffer.push_back('_');
312 }
313
314 Name = StringRef(Buffer.data(), Buffer.size());
315 }
316
317 while (llvm::StringSwitch<bool>(Name)
318#define KEYWORD(Keyword,Conditions) .Case(#Keyword, true)
319#define ALIAS(Keyword, AliasOf, Conditions) .Case(Keyword, true)
320#include "clang/Basic/TokenKinds.def"
321 .Default(false)) {
322 if (Name.data() != Buffer.data())
323 Buffer.append(Name.begin(), Name.end());
324 Buffer.push_back('_');
325 Name = StringRef(Buffer.data(), Buffer.size());
326 }
327
328 return Name;
329}
330
331/// \brief Determine whether the given file name is the name of a builtin
332/// header, supplied by Clang to replace, override, or augment existing system
333/// headers.
334bool ModuleMap::isBuiltinHeader(StringRef FileName) {
335 return llvm::StringSwitch<bool>(FileName)
336 .Case("float.h", true)
337 .Case("iso646.h", true)
338 .Case("limits.h", true)
339 .Case("stdalign.h", true)
340 .Case("stdarg.h", true)
341 .Case("stdatomic.h", true)
342 .Case("stdbool.h", true)
343 .Case("stddef.h", true)
344 .Case("stdint.h", true)
345 .Case("tgmath.h", true)
346 .Case("unwind.h", true)
347 .Default(false);
348}
349
350ModuleMap::HeadersMap::iterator
351ModuleMap::findKnownHeader(const FileEntry *File) {
352 resolveHeaderDirectives(File);
353 HeadersMap::iterator Known = Headers.find(File);
354 if (HeaderInfo.getHeaderSearchOpts().ImplicitModuleMaps &&
355 Known == Headers.end() && File->getDir() == BuiltinIncludeDir &&
356 ModuleMap::isBuiltinHeader(llvm::sys::path::filename(File->getName()))) {
357 HeaderInfo.loadTopLevelSystemModules();
358 return Headers.find(File);
359 }
360 return Known;
361}
362
363ModuleMap::KnownHeader
364ModuleMap::findHeaderInUmbrellaDirs(const FileEntry *File,
365 SmallVectorImpl<const DirectoryEntry *> &IntermediateDirs) {
366 if (UmbrellaDirs.empty())
367 return {};
368
369 const DirectoryEntry *Dir = File->getDir();
370 assert(Dir && "file in no directory")(static_cast <bool> (Dir && "file in no directory"
) ? void (0) : __assert_fail ("Dir && \"file in no directory\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 370, __extension__ __PRETTY_FUNCTION__))
;
371
372 // Note: as an egregious but useful hack we use the real path here, because
373 // frameworks moving from top-level frameworks to embedded frameworks tend
374 // to be symlinked from the top-level location to the embedded location,
375 // and we need to resolve lookups as if we had found the embedded location.
376 StringRef DirName = SourceMgr.getFileManager().getCanonicalName(Dir);
377
378 // Keep walking up the directory hierarchy, looking for a directory with
379 // an umbrella header.
380 do {
381 auto KnownDir = UmbrellaDirs.find(Dir);
382 if (KnownDir != UmbrellaDirs.end())
383 return KnownHeader(KnownDir->second, NormalHeader);
384
385 IntermediateDirs.push_back(Dir);
386
387 // Retrieve our parent path.
388 DirName = llvm::sys::path::parent_path(DirName);
389 if (DirName.empty())
390 break;
391
392 // Resolve the parent path to a directory entry.
393 Dir = SourceMgr.getFileManager().getDirectory(DirName);
394 } while (Dir);
395 return {};
396}
397
398static bool violatesPrivateInclude(Module *RequestingModule,
399 const FileEntry *IncFileEnt,
400 ModuleMap::KnownHeader Header) {
401#ifndef NDEBUG
402 if (Header.getRole() & ModuleMap::PrivateHeader) {
403 // Check for consistency between the module header role
404 // as obtained from the lookup and as obtained from the module.
405 // This check is not cheap, so enable it only for debugging.
406 bool IsPrivate = false;
407 SmallVectorImpl<Module::Header> *HeaderList[] = {
408 &Header.getModule()->Headers[Module::HK_Private],
409 &Header.getModule()->Headers[Module::HK_PrivateTextual]};
410 for (auto *Hs : HeaderList)
411 IsPrivate |=
412 std::find_if(Hs->begin(), Hs->end(), [&](const Module::Header &H) {
413 return H.Entry == IncFileEnt;
414 }) != Hs->end();
415 assert(IsPrivate && "inconsistent headers and roles")(static_cast <bool> (IsPrivate && "inconsistent headers and roles"
) ? void (0) : __assert_fail ("IsPrivate && \"inconsistent headers and roles\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 415, __extension__ __PRETTY_FUNCTION__))
;
416 }
417#endif
418 return !Header.isAccessibleFrom(RequestingModule);
419}
420
421static Module *getTopLevelOrNull(Module *M) {
422 return M ? M->getTopLevelModule() : nullptr;
423}
424
425void ModuleMap::diagnoseHeaderInclusion(Module *RequestingModule,
426 bool RequestingModuleIsModuleInterface,
427 SourceLocation FilenameLoc,
428 StringRef Filename,
429 const FileEntry *File) {
430 // No errors for indirect modules. This may be a bit of a problem for modules
431 // with no source files.
432 if (getTopLevelOrNull(RequestingModule) != getTopLevelOrNull(SourceModule))
433 return;
434
435 if (RequestingModule) {
436 resolveUses(RequestingModule, /*Complain=*/false);
437 resolveHeaderDirectives(RequestingModule);
438 }
439
440 bool Excluded = false;
441 Module *Private = nullptr;
442 Module *NotUsed = nullptr;
443
444 HeadersMap::iterator Known = findKnownHeader(File);
445 if (Known != Headers.end()) {
446 for (const KnownHeader &Header : Known->second) {
447 // Remember private headers for later printing of a diagnostic.
448 if (violatesPrivateInclude(RequestingModule, File, Header)) {
449 Private = Header.getModule();
450 continue;
451 }
452
453 // If uses need to be specified explicitly, we are only allowed to return
454 // modules that are explicitly used by the requesting module.
455 if (RequestingModule && LangOpts.ModulesDeclUse &&
456 !RequestingModule->directlyUses(Header.getModule())) {
457 NotUsed = Header.getModule();
458 continue;
459 }
460
461 // We have found a module that we can happily use.
462 return;
463 }
464
465 Excluded = true;
466 }
467
468 // We have found a header, but it is private.
469 if (Private) {
470 Diags.Report(FilenameLoc, diag::warn_use_of_private_header_outside_module)
471 << Filename;
472 return;
473 }
474
475 // We have found a module, but we don't use it.
476 if (NotUsed) {
477 Diags.Report(FilenameLoc, diag::err_undeclared_use_of_module)
478 << RequestingModule->getTopLevelModule()->Name << Filename;
479 return;
480 }
481
482 if (Excluded || isHeaderInUmbrellaDirs(File))
483 return;
484
485 // At this point, only non-modular includes remain.
486
487 if (LangOpts.ModulesStrictDeclUse) {
488 Diags.Report(FilenameLoc, diag::err_undeclared_use_of_module)
489 << RequestingModule->getTopLevelModule()->Name << Filename;
490 } else if (RequestingModule && RequestingModuleIsModuleInterface &&
491 LangOpts.isCompilingModule()) {
492 // Do not diagnose when we are not compiling a module.
493 diag::kind DiagID = RequestingModule->getTopLevelModule()->IsFramework ?
494 diag::warn_non_modular_include_in_framework_module :
495 diag::warn_non_modular_include_in_module;
496 Diags.Report(FilenameLoc, DiagID) << RequestingModule->getFullModuleName()
497 << File->getName();
498 }
499}
500
501static bool isBetterKnownHeader(const ModuleMap::KnownHeader &New,
502 const ModuleMap::KnownHeader &Old) {
503 // Prefer available modules.
504 if (New.getModule()->isAvailable() && !Old.getModule()->isAvailable())
505 return true;
506
507 // Prefer a public header over a private header.
508 if ((New.getRole() & ModuleMap::PrivateHeader) !=
509 (Old.getRole() & ModuleMap::PrivateHeader))
510 return !(New.getRole() & ModuleMap::PrivateHeader);
511
512 // Prefer a non-textual header over a textual header.
513 if ((New.getRole() & ModuleMap::TextualHeader) !=
514 (Old.getRole() & ModuleMap::TextualHeader))
515 return !(New.getRole() & ModuleMap::TextualHeader);
516
517 // Don't have a reason to choose between these. Just keep the first one.
518 return false;
519}
520
521ModuleMap::KnownHeader ModuleMap::findModuleForHeader(const FileEntry *File,
522 bool AllowTextual) {
523 auto MakeResult = [&](ModuleMap::KnownHeader R) -> ModuleMap::KnownHeader {
524 if (!AllowTextual && R.getRole() & ModuleMap::TextualHeader)
525 return {};
526 return R;
527 };
528
529 HeadersMap::iterator Known = findKnownHeader(File);
530 if (Known != Headers.end()) {
531 ModuleMap::KnownHeader Result;
532 // Iterate over all modules that 'File' is part of to find the best fit.
533 for (KnownHeader &H : Known->second) {
534 // Prefer a header from the source module over all others.
535 if (H.getModule()->getTopLevelModule() == SourceModule)
536 return MakeResult(H);
537 if (!Result || isBetterKnownHeader(H, Result))
538 Result = H;
539 }
540 return MakeResult(Result);
541 }
542
543 return MakeResult(findOrCreateModuleForHeaderInUmbrellaDir(File));
544}
545
546ModuleMap::KnownHeader
547ModuleMap::findOrCreateModuleForHeaderInUmbrellaDir(const FileEntry *File) {
548 assert(!Headers.count(File) && "already have a module for this header")(static_cast <bool> (!Headers.count(File) && "already have a module for this header"
) ? void (0) : __assert_fail ("!Headers.count(File) && \"already have a module for this header\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 548, __extension__ __PRETTY_FUNCTION__))
;
549
550 SmallVector<const DirectoryEntry *, 2> SkippedDirs;
551 KnownHeader H = findHeaderInUmbrellaDirs(File, SkippedDirs);
552 if (H) {
553 Module *Result = H.getModule();
554
555 // Search up the module stack until we find a module with an umbrella
556 // directory.
557 Module *UmbrellaModule = Result;
558 while (!UmbrellaModule->getUmbrellaDir() && UmbrellaModule->Parent)
559 UmbrellaModule = UmbrellaModule->Parent;
560
561 if (UmbrellaModule->InferSubmodules) {
562 const FileEntry *UmbrellaModuleMap =
563 getModuleMapFileForUniquing(UmbrellaModule);
564
565 // Infer submodules for each of the directories we found between
566 // the directory of the umbrella header and the directory where
567 // the actual header is located.
568 bool Explicit = UmbrellaModule->InferExplicitSubmodules;
569
570 for (unsigned I = SkippedDirs.size(); I != 0; --I) {
571 // Find or create the module that corresponds to this directory name.
572 SmallString<32> NameBuf;
573 StringRef Name = sanitizeFilenameAsIdentifier(
574 llvm::sys::path::stem(SkippedDirs[I-1]->getName()), NameBuf);
575 Result = findOrCreateModule(Name, Result, /*IsFramework=*/false,
576 Explicit).first;
577 InferredModuleAllowedBy[Result] = UmbrellaModuleMap;
578 Result->IsInferred = true;
579
580 // Associate the module and the directory.
581 UmbrellaDirs[SkippedDirs[I-1]] = Result;
582
583 // If inferred submodules export everything they import, add a
584 // wildcard to the set of exports.
585 if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
586 Result->Exports.push_back(Module::ExportDecl(nullptr, true));
587 }
588
589 // Infer a submodule with the same name as this header file.
590 SmallString<32> NameBuf;
591 StringRef Name = sanitizeFilenameAsIdentifier(
592 llvm::sys::path::stem(File->getName()), NameBuf);
593 Result = findOrCreateModule(Name, Result, /*IsFramework=*/false,
594 Explicit).first;
595 InferredModuleAllowedBy[Result] = UmbrellaModuleMap;
596 Result->IsInferred = true;
597 Result->addTopHeader(File);
598
599 // If inferred submodules export everything they import, add a
600 // wildcard to the set of exports.
601 if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
602 Result->Exports.push_back(Module::ExportDecl(nullptr, true));
603 } else {
604 // Record each of the directories we stepped through as being part of
605 // the module we found, since the umbrella header covers them all.
606 for (unsigned I = 0, N = SkippedDirs.size(); I != N; ++I)
607 UmbrellaDirs[SkippedDirs[I]] = Result;
608 }
609
610 KnownHeader Header(Result, NormalHeader);
611 Headers[File].push_back(Header);
612 return Header;
613 }
614
615 return {};
616}
617
618ArrayRef<ModuleMap::KnownHeader>
619ModuleMap::findAllModulesForHeader(const FileEntry *File) const {
620 resolveHeaderDirectives(File);
621 auto It = Headers.find(File);
622 if (It == Headers.end())
623 return None;
624 return It->second;
625}
626
627bool ModuleMap::isHeaderInUnavailableModule(const FileEntry *Header) const {
628 return isHeaderUnavailableInModule(Header, nullptr);
629}
630
631bool
632ModuleMap::isHeaderUnavailableInModule(const FileEntry *Header,
633 const Module *RequestingModule) const {
634 resolveHeaderDirectives(Header);
635 HeadersMap::const_iterator Known = Headers.find(Header);
636 if (Known != Headers.end()) {
637 for (SmallVectorImpl<KnownHeader>::const_iterator
638 I = Known->second.begin(),
639 E = Known->second.end();
640 I != E; ++I) {
641
642 if (I->isAvailable() &&
643 (!RequestingModule ||
644 I->getModule()->isSubModuleOf(RequestingModule))) {
645 // When no requesting module is available, the caller is looking if a
646 // header is part a module by only looking into the module map. This is
647 // done by warn_uncovered_module_header checks; don't consider textual
648 // headers part of it in this mode, otherwise we get misleading warnings
649 // that a umbrella header is not including a textual header.
650 if (!RequestingModule && I->getRole() == ModuleMap::TextualHeader)
651 continue;
652 return false;
653 }
654 }
655 return true;
656 }
657
658 const DirectoryEntry *Dir = Header->getDir();
659 SmallVector<const DirectoryEntry *, 2> SkippedDirs;
660 StringRef DirName = Dir->getName();
661
662 auto IsUnavailable = [&](const Module *M) {
663 return !M->isAvailable() && (!RequestingModule ||
664 M->isSubModuleOf(RequestingModule));
665 };
666
667 // Keep walking up the directory hierarchy, looking for a directory with
668 // an umbrella header.
669 do {
670 llvm::DenseMap<const DirectoryEntry *, Module *>::const_iterator KnownDir
671 = UmbrellaDirs.find(Dir);
672 if (KnownDir != UmbrellaDirs.end()) {
673 Module *Found = KnownDir->second;
674 if (IsUnavailable(Found))
675 return true;
676
677 // Search up the module stack until we find a module with an umbrella
678 // directory.
679 Module *UmbrellaModule = Found;
680 while (!UmbrellaModule->getUmbrellaDir() && UmbrellaModule->Parent)
681 UmbrellaModule = UmbrellaModule->Parent;
682
683 if (UmbrellaModule->InferSubmodules) {
684 for (unsigned I = SkippedDirs.size(); I != 0; --I) {
685 // Find or create the module that corresponds to this directory name.
686 SmallString<32> NameBuf;
687 StringRef Name = sanitizeFilenameAsIdentifier(
688 llvm::sys::path::stem(SkippedDirs[I-1]->getName()),
689 NameBuf);
690 Found = lookupModuleQualified(Name, Found);
691 if (!Found)
692 return false;
693 if (IsUnavailable(Found))
694 return true;
695 }
696
697 // Infer a submodule with the same name as this header file.
698 SmallString<32> NameBuf;
699 StringRef Name = sanitizeFilenameAsIdentifier(
700 llvm::sys::path::stem(Header->getName()),
701 NameBuf);
702 Found = lookupModuleQualified(Name, Found);
703 if (!Found)
704 return false;
705 }
706
707 return IsUnavailable(Found);
708 }
709
710 SkippedDirs.push_back(Dir);
711
712 // Retrieve our parent path.
713 DirName = llvm::sys::path::parent_path(DirName);
714 if (DirName.empty())
715 break;
716
717 // Resolve the parent path to a directory entry.
718 Dir = SourceMgr.getFileManager().getDirectory(DirName);
719 } while (Dir);
720
721 return false;
722}
723
724Module *ModuleMap::findModule(StringRef Name) const {
725 llvm::StringMap<Module *>::const_iterator Known = Modules.find(Name);
726 if (Known != Modules.end())
727 return Known->getValue();
728
729 return nullptr;
730}
731
732Module *ModuleMap::lookupModuleUnqualified(StringRef Name,
733 Module *Context) const {
734 for(; Context; Context = Context->Parent) {
735 if (Module *Sub = lookupModuleQualified(Name, Context))
736 return Sub;
737 }
738
739 return findModule(Name);
740}
741
742Module *ModuleMap::lookupModuleQualified(StringRef Name, Module *Context) const{
743 if (!Context)
744 return findModule(Name);
745
746 return Context->findSubmodule(Name);
747}
748
749std::pair<Module *, bool> ModuleMap::findOrCreateModule(StringRef Name,
750 Module *Parent,
751 bool IsFramework,
752 bool IsExplicit) {
753 // Try to find an existing module with this name.
754 if (Module *Sub = lookupModuleQualified(Name, Parent))
755 return std::make_pair(Sub, false);
756
757 // Create a new module with this name.
758 Module *Result = new Module(Name, SourceLocation(), Parent, IsFramework,
759 IsExplicit, NumCreatedModules++);
760 if (!Parent) {
761 if (LangOpts.CurrentModule == Name)
762 SourceModule = Result;
763 Modules[Name] = Result;
764 ModuleScopeIDs[Result] = CurrentModuleScopeID;
765 }
766 return std::make_pair(Result, true);
767}
768
769Module *ModuleMap::createGlobalModuleForInterfaceUnit(SourceLocation Loc) {
770 assert(!PendingGlobalModule && "created multiple global modules")(static_cast <bool> (!PendingGlobalModule && "created multiple global modules"
) ? void (0) : __assert_fail ("!PendingGlobalModule && \"created multiple global modules\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 770, __extension__ __PRETTY_FUNCTION__))
;
771 PendingGlobalModule.reset(
772 new Module("<global>", Loc, nullptr, /*IsFramework*/ false,
773 /*IsExplicit*/ true, NumCreatedModules++));
774 PendingGlobalModule->Kind = Module::GlobalModuleFragment;
775 return PendingGlobalModule.get();
776}
777
778Module *ModuleMap::createModuleForInterfaceUnit(SourceLocation Loc,
779 StringRef Name,
780 Module *GlobalModule) {
781 assert(LangOpts.CurrentModule == Name && "module name mismatch")(static_cast <bool> (LangOpts.CurrentModule == Name &&
"module name mismatch") ? void (0) : __assert_fail ("LangOpts.CurrentModule == Name && \"module name mismatch\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 781, __extension__ __PRETTY_FUNCTION__))
;
782 assert(!Modules[Name] && "redefining existing module")(static_cast <bool> (!Modules[Name] && "redefining existing module"
) ? void (0) : __assert_fail ("!Modules[Name] && \"redefining existing module\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 782, __extension__ __PRETTY_FUNCTION__))
;
783
784 auto *Result =
785 new Module(Name, Loc, nullptr, /*IsFramework*/ false,
786 /*IsExplicit*/ false, NumCreatedModules++);
787 Result->Kind = Module::ModuleInterfaceUnit;
788 Modules[Name] = SourceModule = Result;
789
790 // Reparent the current global module fragment as a submodule of this module.
791 assert(GlobalModule == PendingGlobalModule.get() &&(static_cast <bool> (GlobalModule == PendingGlobalModule
.get() && "unexpected global module") ? void (0) : __assert_fail
("GlobalModule == PendingGlobalModule.get() && \"unexpected global module\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 792, __extension__ __PRETTY_FUNCTION__))
792 "unexpected global module")(static_cast <bool> (GlobalModule == PendingGlobalModule
.get() && "unexpected global module") ? void (0) : __assert_fail
("GlobalModule == PendingGlobalModule.get() && \"unexpected global module\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 792, __extension__ __PRETTY_FUNCTION__))
;
793 GlobalModule->setParent(Result);
794 PendingGlobalModule.release(); // now owned by parent
795
796 // Mark the main source file as being within the newly-created module so that
797 // declarations and macros are properly visibility-restricted to it.
798 auto *MainFile = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());
799 assert(MainFile && "no input file for module interface")(static_cast <bool> (MainFile && "no input file for module interface"
) ? void (0) : __assert_fail ("MainFile && \"no input file for module interface\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 799, __extension__ __PRETTY_FUNCTION__))
;
800 Headers[MainFile].push_back(KnownHeader(Result, PrivateHeader));
801
802 return Result;
803}
804
805/// \brief For a framework module, infer the framework against which we
806/// should link.
807static void inferFrameworkLink(Module *Mod, const DirectoryEntry *FrameworkDir,
808 FileManager &FileMgr) {
809 assert(Mod->IsFramework && "Can only infer linking for framework modules")(static_cast <bool> (Mod->IsFramework && "Can only infer linking for framework modules"
) ? void (0) : __assert_fail ("Mod->IsFramework && \"Can only infer linking for framework modules\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 809, __extension__ __PRETTY_FUNCTION__))
;
810 assert(!Mod->isSubFramework() &&(static_cast <bool> (!Mod->isSubFramework() &&
"Can only infer linking for top-level frameworks") ? void (0
) : __assert_fail ("!Mod->isSubFramework() && \"Can only infer linking for top-level frameworks\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 811, __extension__ __PRETTY_FUNCTION__))
811 "Can only infer linking for top-level frameworks")(static_cast <bool> (!Mod->isSubFramework() &&
"Can only infer linking for top-level frameworks") ? void (0
) : __assert_fail ("!Mod->isSubFramework() && \"Can only infer linking for top-level frameworks\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 811, __extension__ __PRETTY_FUNCTION__))
;
812
813 SmallString<128> LibName;
814 LibName += FrameworkDir->getName();
815 llvm::sys::path::append(LibName, Mod->Name);
816
817 // The library name of a framework has more than one possible extension since
818 // the introduction of the text-based dynamic library format. We need to check
819 // for both before we give up.
820 for (const char *extension : {"", ".tbd"}) {
821 llvm::sys::path::replace_extension(LibName, extension);
822 if (FileMgr.getFile(LibName)) {
823 Mod->LinkLibraries.push_back(Module::LinkLibrary(Mod->Name,
824 /*IsFramework=*/true));
825 return;
826 }
827 }
828}
829
830Module *ModuleMap::inferFrameworkModule(const DirectoryEntry *FrameworkDir,
831 bool IsSystem, Module *Parent) {
832 Attributes Attrs;
833 Attrs.IsSystem = IsSystem;
834 return inferFrameworkModule(FrameworkDir, Attrs, Parent);
835}
836
837Module *ModuleMap::inferFrameworkModule(const DirectoryEntry *FrameworkDir,
838 Attributes Attrs, Module *Parent) {
839 // Note: as an egregious but useful hack we use the real path here, because
840 // we might be looking at an embedded framework that symlinks out to a
841 // top-level framework, and we need to infer as if we were naming the
842 // top-level framework.
843 StringRef FrameworkDirName =
844 SourceMgr.getFileManager().getCanonicalName(FrameworkDir);
845
846 // In case this is a case-insensitive filesystem, use the canonical
847 // directory name as the ModuleName, since modules are case-sensitive.
848 // FIXME: we should be able to give a fix-it hint for the correct spelling.
849 SmallString<32> ModuleNameStorage;
850 StringRef ModuleName = sanitizeFilenameAsIdentifier(
851 llvm::sys::path::stem(FrameworkDirName), ModuleNameStorage);
852
853 // Check whether we've already found this module.
854 if (Module *Mod = lookupModuleQualified(ModuleName, Parent))
855 return Mod;
856
857 FileManager &FileMgr = SourceMgr.getFileManager();
858
859 // If the framework has a parent path from which we're allowed to infer
860 // a framework module, do so.
861 const FileEntry *ModuleMapFile = nullptr;
862 if (!Parent) {
863 // Determine whether we're allowed to infer a module map.
864 bool canInfer = false;
865 if (llvm::sys::path::has_parent_path(FrameworkDirName)) {
866 // Figure out the parent path.
867 StringRef Parent = llvm::sys::path::parent_path(FrameworkDirName);
868 if (const DirectoryEntry *ParentDir = FileMgr.getDirectory(Parent)) {
869 // Check whether we have already looked into the parent directory
870 // for a module map.
871 llvm::DenseMap<const DirectoryEntry *, InferredDirectory>::const_iterator
872 inferred = InferredDirectories.find(ParentDir);
873 if (inferred == InferredDirectories.end()) {
874 // We haven't looked here before. Load a module map, if there is
875 // one.
876 bool IsFrameworkDir = Parent.endswith(".framework");
877 if (const FileEntry *ModMapFile =
878 HeaderInfo.lookupModuleMapFile(ParentDir, IsFrameworkDir)) {
879 parseModuleMapFile(ModMapFile, Attrs.IsSystem, ParentDir);
880 inferred = InferredDirectories.find(ParentDir);
881 }
882
883 if (inferred == InferredDirectories.end())
884 inferred = InferredDirectories.insert(
885 std::make_pair(ParentDir, InferredDirectory())).first;
886 }
887
888 if (inferred->second.InferModules) {
889 // We're allowed to infer for this directory, but make sure it's okay
890 // to infer this particular module.
891 StringRef Name = llvm::sys::path::stem(FrameworkDirName);
892 canInfer = std::find(inferred->second.ExcludedModules.begin(),
893 inferred->second.ExcludedModules.end(),
894 Name) == inferred->second.ExcludedModules.end();
895
896 Attrs.IsSystem |= inferred->second.Attrs.IsSystem;
897 Attrs.IsExternC |= inferred->second.Attrs.IsExternC;
898 Attrs.IsExhaustive |= inferred->second.Attrs.IsExhaustive;
899 Attrs.NoUndeclaredIncludes |=
900 inferred->second.Attrs.NoUndeclaredIncludes;
901 ModuleMapFile = inferred->second.ModuleMapFile;
902 }
903 }
904 }
905
906 // If we're not allowed to infer a framework module, don't.
907 if (!canInfer)
908 return nullptr;
909 } else
910 ModuleMapFile = getModuleMapFileForUniquing(Parent);
911
912
913 // Look for an umbrella header.
914 SmallString<128> UmbrellaName = StringRef(FrameworkDir->getName());
915 llvm::sys::path::append(UmbrellaName, "Headers", ModuleName + ".h");
916 const FileEntry *UmbrellaHeader = FileMgr.getFile(UmbrellaName);
917
918 // FIXME: If there's no umbrella header, we could probably scan the
919 // framework to load *everything*. But, it's not clear that this is a good
920 // idea.
921 if (!UmbrellaHeader)
922 return nullptr;
923
924 Module *Result = new Module(ModuleName, SourceLocation(), Parent,
925 /*IsFramework=*/true, /*IsExplicit=*/false,
926 NumCreatedModules++);
927 InferredModuleAllowedBy[Result] = ModuleMapFile;
928 Result->IsInferred = true;
929 if (!Parent) {
930 if (LangOpts.CurrentModule == ModuleName)
931 SourceModule = Result;
932 Modules[ModuleName] = Result;
933 ModuleScopeIDs[Result] = CurrentModuleScopeID;
934 }
935
936 Result->IsSystem |= Attrs.IsSystem;
937 Result->IsExternC |= Attrs.IsExternC;
938 Result->ConfigMacrosExhaustive |= Attrs.IsExhaustive;
939 Result->NoUndeclaredIncludes |= Attrs.NoUndeclaredIncludes;
940 Result->Directory = FrameworkDir;
941
942 // umbrella header "umbrella-header-name"
943 //
944 // The "Headers/" component of the name is implied because this is
945 // a framework module.
946 setUmbrellaHeader(Result, UmbrellaHeader, ModuleName + ".h");
947
948 // export *
949 Result->Exports.push_back(Module::ExportDecl(nullptr, true));
950
951 // module * { export * }
952 Result->InferSubmodules = true;
953 Result->InferExportWildcard = true;
954
955 // Look for subframeworks.
956 std::error_code EC;
957 SmallString<128> SubframeworksDirName
958 = StringRef(FrameworkDir->getName());
959 llvm::sys::path::append(SubframeworksDirName, "Frameworks");
960 llvm::sys::path::native(SubframeworksDirName);
961 vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
962 for (vfs::directory_iterator Dir = FS.dir_begin(SubframeworksDirName, EC),
963 DirEnd;
964 Dir != DirEnd && !EC; Dir.increment(EC)) {
965 if (!StringRef(Dir->getName()).endswith(".framework"))
966 continue;
967
968 if (const DirectoryEntry *SubframeworkDir =
969 FileMgr.getDirectory(Dir->getName())) {
970 // Note: as an egregious but useful hack, we use the real path here and
971 // check whether it is actually a subdirectory of the parent directory.
972 // This will not be the case if the 'subframework' is actually a symlink
973 // out to a top-level framework.
974 StringRef SubframeworkDirName = FileMgr.getCanonicalName(SubframeworkDir);
975 bool FoundParent = false;
976 do {
977 // Get the parent directory name.
978 SubframeworkDirName
979 = llvm::sys::path::parent_path(SubframeworkDirName);
980 if (SubframeworkDirName.empty())
981 break;
982
983 if (FileMgr.getDirectory(SubframeworkDirName) == FrameworkDir) {
984 FoundParent = true;
985 break;
986 }
987 } while (true);
988
989 if (!FoundParent)
990 continue;
991
992 // FIXME: Do we want to warn about subframeworks without umbrella headers?
993 inferFrameworkModule(SubframeworkDir, Attrs, Result);
994 }
995 }
996
997 // If the module is a top-level framework, automatically link against the
998 // framework.
999 if (!Result->isSubFramework()) {
1000 inferFrameworkLink(Result, FrameworkDir, FileMgr);
1001 }
1002
1003 return Result;
1004}
1005
1006Module *ModuleMap::createShadowedModule(StringRef Name, bool IsFramework,
1007 Module *ShadowingModule) {
1008
1009 // Create a new module with this name.
1010 Module *Result =
1011 new Module(Name, SourceLocation(), /*Parent=*/nullptr, IsFramework,
1012 /*IsExplicit=*/false, NumCreatedModules++);
1013 Result->ShadowingModule = ShadowingModule;
1014 Result->IsAvailable = false;
1015 ModuleScopeIDs[Result] = CurrentModuleScopeID;
1016 ShadowModules.push_back(Result);
1017
1018 return Result;
1019}
1020
1021void ModuleMap::setUmbrellaHeader(Module *Mod, const FileEntry *UmbrellaHeader,
1022 Twine NameAsWritten) {
1023 Headers[UmbrellaHeader].push_back(KnownHeader(Mod, NormalHeader));
1024 Mod->Umbrella = UmbrellaHeader;
1025 Mod->UmbrellaAsWritten = NameAsWritten.str();
1026 UmbrellaDirs[UmbrellaHeader->getDir()] = Mod;
1027
1028 // Notify callbacks that we just added a new header.
1029 for (const auto &Cb : Callbacks)
1030 Cb->moduleMapAddUmbrellaHeader(&SourceMgr.getFileManager(), UmbrellaHeader);
1031}
1032
1033void ModuleMap::setUmbrellaDir(Module *Mod, const DirectoryEntry *UmbrellaDir,
1034 Twine NameAsWritten) {
1035 Mod->Umbrella = UmbrellaDir;
1036 Mod->UmbrellaAsWritten = NameAsWritten.str();
1037 UmbrellaDirs[UmbrellaDir] = Mod;
1038}
1039
1040void ModuleMap::addUnresolvedHeader(Module *Mod,
1041 Module::UnresolvedHeaderDirective Header) {
1042 // If there is a builtin counterpart to this file, add it now so it can
1043 // wrap the system header.
1044 if (resolveAsBuiltinHeader(Mod, Header)) {
1045 // If we have both a builtin and system version of the file, the
1046 // builtin version may want to inject macros into the system header, so
1047 // force the system header to be treated as a textual header in this
1048 // case.
1049 Header.Kind = headerRoleToKind(ModuleMap::ModuleHeaderRole(
1050 headerKindToRole(Header.Kind) | ModuleMap::TextualHeader));
1051 Header.HasBuiltinHeader = true;
1052 }
1053
1054 // If possible, don't stat the header until we need to. This requires the
1055 // user to have provided us with some stat information about the file.
1056 // FIXME: Add support for lazily stat'ing umbrella headers and excluded
1057 // headers.
1058 if ((Header.Size || Header.ModTime) && !Header.IsUmbrella &&
1059 Header.Kind != Module::HK_Excluded) {
1060 // We expect more variation in mtime than size, so if we're given both,
1061 // use the mtime as the key.
1062 if (Header.ModTime)
1063 LazyHeadersByModTime[*Header.ModTime].push_back(Mod);
1064 else
1065 LazyHeadersBySize[*Header.Size].push_back(Mod);
1066 Mod->UnresolvedHeaders.push_back(Header);
1067 return;
1068 }
1069
1070 // We don't have stat information or can't defer looking this file up.
1071 // Perform the lookup now.
1072 resolveHeader(Mod, Header);
1073}
1074
1075void ModuleMap::resolveHeaderDirectives(const FileEntry *File) const {
1076 auto BySize = LazyHeadersBySize.find(File->getSize());
1077 if (BySize != LazyHeadersBySize.end()) {
1078 for (auto *M : BySize->second)
1079 resolveHeaderDirectives(M);
1080 LazyHeadersBySize.erase(BySize);
1081 }
1082
1083 auto ByModTime = LazyHeadersByModTime.find(File->getModificationTime());
1084 if (ByModTime != LazyHeadersByModTime.end()) {
1085 for (auto *M : ByModTime->second)
1086 resolveHeaderDirectives(M);
1087 LazyHeadersByModTime.erase(ByModTime);
1088 }
1089}
1090
1091void ModuleMap::resolveHeaderDirectives(Module *Mod) const {
1092 for (auto &Header : Mod->UnresolvedHeaders)
1093 // This operation is logically const; we're just changing how we represent
1094 // the header information for this file.
1095 const_cast<ModuleMap*>(this)->resolveHeader(Mod, Header);
1096 Mod->UnresolvedHeaders.clear();
1097}
1098
1099void ModuleMap::addHeader(Module *Mod, Module::Header Header,
1100 ModuleHeaderRole Role, bool Imported) {
1101 KnownHeader KH(Mod, Role);
1102
1103 // Only add each header to the headers list once.
1104 // FIXME: Should we diagnose if a header is listed twice in the
1105 // same module definition?
1106 auto &HeaderList = Headers[Header.Entry];
1107 for (auto H : HeaderList)
1108 if (H == KH)
1109 return;
1110
1111 HeaderList.push_back(KH);
1112 Mod->Headers[headerRoleToKind(Role)].push_back(Header);
1113
1114 bool isCompilingModuleHeader =
1115 LangOpts.isCompilingModule() && Mod->getTopLevelModule() == SourceModule;
1116 if (!Imported || isCompilingModuleHeader) {
1117 // When we import HeaderFileInfo, the external source is expected to
1118 // set the isModuleHeader flag itself.
1119 HeaderInfo.MarkFileModuleHeader(Header.Entry, Role,
1120 isCompilingModuleHeader);
1121 }
1122
1123 // Notify callbacks that we just added a new header.
1124 for (const auto &Cb : Callbacks)
1125 Cb->moduleMapAddHeader(Header.Entry->getName());
1126}
1127
1128void ModuleMap::excludeHeader(Module *Mod, Module::Header Header) {
1129 // Add this as a known header so we won't implicitly add it to any
1130 // umbrella directory module.
1131 // FIXME: Should we only exclude it from umbrella modules within the
1132 // specified module?
1133 (void) Headers[Header.Entry];
1134
1135 Mod->Headers[Module::HK_Excluded].push_back(std::move(Header));
1136}
1137
1138const FileEntry *
1139ModuleMap::getContainingModuleMapFile(const Module *Module) const {
1140 if (Module->DefinitionLoc.isInvalid())
17
Called C++ object pointer is null
1141 return nullptr;
1142
1143 return SourceMgr.getFileEntryForID(
1144 SourceMgr.getFileID(Module->DefinitionLoc));
1145}
1146
1147const FileEntry *ModuleMap::getModuleMapFileForUniquing(const Module *M) const {
1148 if (M->IsInferred) {
1149 assert(InferredModuleAllowedBy.count(M) && "missing inferred module map")(static_cast <bool> (InferredModuleAllowedBy.count(M) &&
"missing inferred module map") ? void (0) : __assert_fail ("InferredModuleAllowedBy.count(M) && \"missing inferred module map\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 1149, __extension__ __PRETTY_FUNCTION__))
;
1150 return InferredModuleAllowedBy.find(M)->second;
1151 }
1152 return getContainingModuleMapFile(M);
1153}
1154
1155void ModuleMap::setInferredModuleAllowedBy(Module *M, const FileEntry *ModMap) {
1156 assert(M->IsInferred && "module not inferred")(static_cast <bool> (M->IsInferred && "module not inferred"
) ? void (0) : __assert_fail ("M->IsInferred && \"module not inferred\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 1156, __extension__ __PRETTY_FUNCTION__))
;
1157 InferredModuleAllowedBy[M] = ModMap;
1158}
1159
1160LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void ModuleMap::dump() {
1161 llvm::errs() << "Modules:";
1162 for (llvm::StringMap<Module *>::iterator M = Modules.begin(),
1163 MEnd = Modules.end();
1164 M != MEnd; ++M)
1165 M->getValue()->print(llvm::errs(), 2);
1166
1167 llvm::errs() << "Headers:";
1168 for (HeadersMap::iterator H = Headers.begin(), HEnd = Headers.end();
1169 H != HEnd; ++H) {
1170 llvm::errs() << " \"" << H->first->getName() << "\" -> ";
1171 for (SmallVectorImpl<KnownHeader>::const_iterator I = H->second.begin(),
1172 E = H->second.end();
1173 I != E; ++I) {
1174 if (I != H->second.begin())
1175 llvm::errs() << ",";
1176 llvm::errs() << I->getModule()->getFullModuleName();
1177 }
1178 llvm::errs() << "\n";
1179 }
1180}
1181
1182bool ModuleMap::resolveExports(Module *Mod, bool Complain) {
1183 auto Unresolved = std::move(Mod->UnresolvedExports);
1184 Mod->UnresolvedExports.clear();
1185 for (auto &UE : Unresolved) {
1186 Module::ExportDecl Export = resolveExport(Mod, UE, Complain);
1187 if (Export.getPointer() || Export.getInt())
1188 Mod->Exports.push_back(Export);
1189 else
1190 Mod->UnresolvedExports.push_back(UE);
1191 }
1192 return !Mod->UnresolvedExports.empty();
1193}
1194
1195bool ModuleMap::resolveUses(Module *Mod, bool Complain) {
1196 auto Unresolved = std::move(Mod->UnresolvedDirectUses);
1197 Mod->UnresolvedDirectUses.clear();
1198 for (auto &UDU : Unresolved) {
1199 Module *DirectUse = resolveModuleId(UDU, Mod, Complain);
1200 if (DirectUse)
1201 Mod->DirectUses.push_back(DirectUse);
1202 else
1203 Mod->UnresolvedDirectUses.push_back(UDU);
1204 }
1205 return !Mod->UnresolvedDirectUses.empty();
1206}
1207
1208bool ModuleMap::resolveConflicts(Module *Mod, bool Complain) {
1209 auto Unresolved = std::move(Mod->UnresolvedConflicts);
1210 Mod->UnresolvedConflicts.clear();
1211 for (auto &UC : Unresolved) {
1212 if (Module *OtherMod = resolveModuleId(UC.Id, Mod, Complain)) {
1213 Module::Conflict Conflict;
1214 Conflict.Other = OtherMod;
1215 Conflict.Message = UC.Message;
1216 Mod->Conflicts.push_back(Conflict);
1217 } else
1218 Mod->UnresolvedConflicts.push_back(UC);
1219 }
1220 return !Mod->UnresolvedConflicts.empty();
1221}
1222
1223//----------------------------------------------------------------------------//
1224// Module map file parser
1225//----------------------------------------------------------------------------//
1226
1227namespace clang {
1228
1229 /// \brief A token in a module map file.
1230 struct MMToken {
1231 enum TokenKind {
1232 Comma,
1233 ConfigMacros,
1234 Conflict,
1235 EndOfFile,
1236 HeaderKeyword,
1237 Identifier,
1238 Exclaim,
1239 ExcludeKeyword,
1240 ExplicitKeyword,
1241 ExportKeyword,
1242 ExportAsKeyword,
1243 ExternKeyword,
1244 FrameworkKeyword,
1245 LinkKeyword,
1246 ModuleKeyword,
1247 Period,
1248 PrivateKeyword,
1249 UmbrellaKeyword,
1250 UseKeyword,
1251 RequiresKeyword,
1252 Star,
1253 StringLiteral,
1254 IntegerLiteral,
1255 TextualKeyword,
1256 LBrace,
1257 RBrace,
1258 LSquare,
1259 RSquare
1260 } Kind;
1261
1262 unsigned Location;
1263 unsigned StringLength;
1264 union {
1265 // If Kind != IntegerLiteral.
1266 const char *StringData;
1267
1268 // If Kind == IntegerLiteral.
1269 uint64_t IntegerValue;
1270 };
1271
1272 void clear() {
1273 Kind = EndOfFile;
1274 Location = 0;
1275 StringLength = 0;
1276 StringData = nullptr;
1277 }
1278
1279 bool is(TokenKind K) const { return Kind == K; }
1280
1281 SourceLocation getLocation() const {
1282 return SourceLocation::getFromRawEncoding(Location);
1283 }
1284
1285 uint64_t getInteger() const {
1286 return Kind == IntegerLiteral ? IntegerValue : 0;
1287 }
1288
1289 StringRef getString() const {
1290 return Kind == IntegerLiteral ? StringRef()
1291 : StringRef(StringData, StringLength);
1292 }
1293 };
1294
1295 class ModuleMapParser {
1296 Lexer &L;
1297 SourceManager &SourceMgr;
1298
1299 /// \brief Default target information, used only for string literal
1300 /// parsing.
1301 const TargetInfo *Target;
1302
1303 DiagnosticsEngine &Diags;
1304 ModuleMap &Map;
1305
1306 /// \brief The current module map file.
1307 const FileEntry *ModuleMapFile;
1308
1309 /// \brief The directory that file names in this module map file should
1310 /// be resolved relative to.
1311 const DirectoryEntry *Directory;
1312
1313 /// \brief Whether this module map is in a system header directory.
1314 bool IsSystem;
1315
1316 /// \brief Whether an error occurred.
1317 bool HadError = false;
1318
1319 /// \brief Stores string data for the various string literals referenced
1320 /// during parsing.
1321 llvm::BumpPtrAllocator StringData;
1322
1323 /// \brief The current token.
1324 MMToken Tok;
1325
1326 /// \brief The active module.
1327 Module *ActiveModule = nullptr;
1328
1329 /// \brief Whether a module uses the 'requires excluded' hack to mark its
1330 /// contents as 'textual'.
1331 ///
1332 /// On older Darwin SDK versions, 'requires excluded' is used to mark the
1333 /// contents of the Darwin.C.excluded (assert.h) and Tcl.Private modules as
1334 /// non-modular headers. For backwards compatibility, we continue to
1335 /// support this idiom for just these modules, and map the headers to
1336 /// 'textual' to match the original intent.
1337 llvm::SmallPtrSet<Module *, 2> UsesRequiresExcludedHack;
1338
1339 /// \brief Consume the current token and return its location.
1340 SourceLocation consumeToken();
1341
1342 /// \brief Skip tokens until we reach the a token with the given kind
1343 /// (or the end of the file).
1344 void skipUntil(MMToken::TokenKind K);
1345
1346 using ModuleId = SmallVector<std::pair<std::string, SourceLocation>, 2>;
1347
1348 bool parseModuleId(ModuleId &Id);
1349 void parseModuleDecl();
1350 void parseExternModuleDecl();
1351 void parseRequiresDecl();
1352 void parseHeaderDecl(MMToken::TokenKind, SourceLocation LeadingLoc);
1353 void parseUmbrellaDirDecl(SourceLocation UmbrellaLoc);
1354 void parseExportDecl();
1355 void parseExportAsDecl();
1356 void parseUseDecl();
1357 void parseLinkDecl();
1358 void parseConfigMacros();
1359 void parseConflict();
1360 void parseInferredModuleDecl(bool Framework, bool Explicit);
1361
1362 using Attributes = ModuleMap::Attributes;
1363
1364 bool parseOptionalAttributes(Attributes &Attrs);
1365
1366 public:
1367 explicit ModuleMapParser(Lexer &L, SourceManager &SourceMgr,
1368 const TargetInfo *Target, DiagnosticsEngine &Diags,
1369 ModuleMap &Map, const FileEntry *ModuleMapFile,
1370 const DirectoryEntry *Directory, bool IsSystem)
1371 : L(L), SourceMgr(SourceMgr), Target(Target), Diags(Diags), Map(Map),
1372 ModuleMapFile(ModuleMapFile), Directory(Directory),
1373 IsSystem(IsSystem) {
1374 Tok.clear();
1375 consumeToken();
1376 }
1377
1378 bool parseModuleMapFile();
1379
1380 bool terminatedByDirective() { return false; }
1381 SourceLocation getLocation() { return Tok.getLocation(); }
1382 };
1383
1384} // namespace clang
1385
1386SourceLocation ModuleMapParser::consumeToken() {
1387 SourceLocation Result = Tok.getLocation();
1388
1389retry:
1390 Tok.clear();
1391 Token LToken;
1392 L.LexFromRawLexer(LToken);
1393 Tok.Location = LToken.getLocation().getRawEncoding();
1394 switch (LToken.getKind()) {
1395 case tok::raw_identifier: {
1396 StringRef RI = LToken.getRawIdentifier();
1397 Tok.StringData = RI.data();
1398 Tok.StringLength = RI.size();
1399 Tok.Kind = llvm::StringSwitch<MMToken::TokenKind>(RI)
1400 .Case("config_macros", MMToken::ConfigMacros)
1401 .Case("conflict", MMToken::Conflict)
1402 .Case("exclude", MMToken::ExcludeKeyword)
1403 .Case("explicit", MMToken::ExplicitKeyword)
1404 .Case("export", MMToken::ExportKeyword)
1405 .Case("export_as", MMToken::ExportAsKeyword)
1406 .Case("extern", MMToken::ExternKeyword)
1407 .Case("framework", MMToken::FrameworkKeyword)
1408 .Case("header", MMToken::HeaderKeyword)
1409 .Case("link", MMToken::LinkKeyword)
1410 .Case("module", MMToken::ModuleKeyword)
1411 .Case("private", MMToken::PrivateKeyword)
1412 .Case("requires", MMToken::RequiresKeyword)
1413 .Case("textual", MMToken::TextualKeyword)
1414 .Case("umbrella", MMToken::UmbrellaKeyword)
1415 .Case("use", MMToken::UseKeyword)
1416 .Default(MMToken::Identifier);
1417 break;
1418 }
1419
1420 case tok::comma:
1421 Tok.Kind = MMToken::Comma;
1422 break;
1423
1424 case tok::eof:
1425 Tok.Kind = MMToken::EndOfFile;
1426 break;
1427
1428 case tok::l_brace:
1429 Tok.Kind = MMToken::LBrace;
1430 break;
1431
1432 case tok::l_square:
1433 Tok.Kind = MMToken::LSquare;
1434 break;
1435
1436 case tok::period:
1437 Tok.Kind = MMToken::Period;
1438 break;
1439
1440 case tok::r_brace:
1441 Tok.Kind = MMToken::RBrace;
1442 break;
1443
1444 case tok::r_square:
1445 Tok.Kind = MMToken::RSquare;
1446 break;
1447
1448 case tok::star:
1449 Tok.Kind = MMToken::Star;
1450 break;
1451
1452 case tok::exclaim:
1453 Tok.Kind = MMToken::Exclaim;
1454 break;
1455
1456 case tok::string_literal: {
1457 if (LToken.hasUDSuffix()) {
1458 Diags.Report(LToken.getLocation(), diag::err_invalid_string_udl);
1459 HadError = true;
1460 goto retry;
1461 }
1462
1463 // Parse the string literal.
1464 LangOptions LangOpts;
1465 StringLiteralParser StringLiteral(LToken, SourceMgr, LangOpts, *Target);
1466 if (StringLiteral.hadError)
1467 goto retry;
1468
1469 // Copy the string literal into our string data allocator.
1470 unsigned Length = StringLiteral.GetStringLength();
1471 char *Saved = StringData.Allocate<char>(Length + 1);
1472 memcpy(Saved, StringLiteral.GetString().data(), Length);
1473 Saved[Length] = 0;
1474
1475 // Form the token.
1476 Tok.Kind = MMToken::StringLiteral;
1477 Tok.StringData = Saved;
1478 Tok.StringLength = Length;
1479 break;
1480 }
1481
1482 case tok::numeric_constant: {
1483 // We don't support any suffixes or other complications.
1484 SmallString<32> SpellingBuffer;
1485 SpellingBuffer.resize(LToken.getLength() + 1);
1486 const char *Start = SpellingBuffer.data();
1487 unsigned Length =
1488 Lexer::getSpelling(LToken, Start, SourceMgr, L.getLangOpts());
1489 uint64_t Value;
1490 if (StringRef(Start, Length).getAsInteger(0, Value)) {
1491 Diags.Report(Tok.getLocation(), diag::err_mmap_unknown_token);
1492 HadError = true;
1493 goto retry;
1494 }
1495
1496 Tok.Kind = MMToken::IntegerLiteral;
1497 Tok.IntegerValue = Value;
1498 break;
1499 }
1500
1501 case tok::comment:
1502 goto retry;
1503
1504 case tok::hash:
1505 // A module map can be terminated prematurely by
1506 // #pragma clang module contents
1507 // When building the module, we'll treat the rest of the file as the
1508 // contents of the module.
1509 {
1510 auto NextIsIdent = [&](StringRef Str) -> bool {
1511 L.LexFromRawLexer(LToken);
1512 return !LToken.isAtStartOfLine() && LToken.is(tok::raw_identifier) &&
1513 LToken.getRawIdentifier() == Str;
1514 };
1515 if (NextIsIdent("pragma") && NextIsIdent("clang") &&
1516 NextIsIdent("module") && NextIsIdent("contents")) {
1517 Tok.Kind = MMToken::EndOfFile;
1518 break;
1519 }
1520 }
1521 LLVM_FALLTHROUGH[[clang::fallthrough]];
1522
1523 default:
1524 Diags.Report(Tok.getLocation(), diag::err_mmap_unknown_token);
1525 HadError = true;
1526 goto retry;
1527 }
1528
1529 return Result;
1530}
1531
1532void ModuleMapParser::skipUntil(MMToken::TokenKind K) {
1533 unsigned braceDepth = 0;
1534 unsigned squareDepth = 0;
1535 do {
1536 switch (Tok.Kind) {
1537 case MMToken::EndOfFile:
1538 return;
1539
1540 case MMToken::LBrace:
1541 if (Tok.is(K) && braceDepth == 0 && squareDepth == 0)
1542 return;
1543
1544 ++braceDepth;
1545 break;
1546
1547 case MMToken::LSquare:
1548 if (Tok.is(K) && braceDepth == 0 && squareDepth == 0)
1549 return;
1550
1551 ++squareDepth;
1552 break;
1553
1554 case MMToken::RBrace:
1555 if (braceDepth > 0)
1556 --braceDepth;
1557 else if (Tok.is(K))
1558 return;
1559 break;
1560
1561 case MMToken::RSquare:
1562 if (squareDepth > 0)
1563 --squareDepth;
1564 else if (Tok.is(K))
1565 return;
1566 break;
1567
1568 default:
1569 if (braceDepth == 0 && squareDepth == 0 && Tok.is(K))
1570 return;
1571 break;
1572 }
1573
1574 consumeToken();
1575 } while (true);
1576}
1577
1578/// \brief Parse a module-id.
1579///
1580/// module-id:
1581/// identifier
1582/// identifier '.' module-id
1583///
1584/// \returns true if an error occurred, false otherwise.
1585bool ModuleMapParser::parseModuleId(ModuleId &Id) {
1586 Id.clear();
1587 do {
1588 if (Tok.is(MMToken::Identifier) || Tok.is(MMToken::StringLiteral)) {
1589 Id.push_back(std::make_pair(Tok.getString(), Tok.getLocation()));
1590 consumeToken();
1591 } else {
1592 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module_name);
1593 return true;
1594 }
1595
1596 if (!Tok.is(MMToken::Period))
1597 break;
1598
1599 consumeToken();
1600 } while (true);
1601
1602 return false;
1603}
1604
1605namespace {
1606
1607 /// \brief Enumerates the known attributes.
1608 enum AttributeKind {
1609 /// \brief An unknown attribute.
1610 AT_unknown,
1611
1612 /// \brief The 'system' attribute.
1613 AT_system,
1614
1615 /// \brief The 'extern_c' attribute.
1616 AT_extern_c,
1617
1618 /// \brief The 'exhaustive' attribute.
1619 AT_exhaustive,
1620
1621 /// \brief The 'no_undeclared_includes' attribute.
1622 AT_no_undeclared_includes
1623 };
1624
1625} // namespace
1626
1627/// Private modules are canonicalized as Foo_Private. Clang provides extra
1628/// module map search logic to find the appropriate private module when PCH
1629/// is used with implicit module maps. Warn when private modules are written
1630/// in other ways (FooPrivate and Foo.Private), providing notes and fixits.
1631static void diagnosePrivateModules(const ModuleMap &Map,
1632 DiagnosticsEngine &Diags,
1633 const Module *ActiveModule,
1634 SourceLocation InlineParent) {
1635
1636 auto GenNoteAndFixIt = [&](StringRef BadName, StringRef Canonical,
1637 const Module *M, SourceRange ReplLoc) {
1638 auto D = Diags.Report(ActiveModule->DefinitionLoc,
1639 diag::note_mmap_rename_top_level_private_module);
1640 D << BadName << M->Name;
1641 D << FixItHint::CreateReplacement(ReplLoc, Canonical);
1642 };
1643
1644 for (auto E = Map.module_begin(); E != Map.module_end(); ++E) {
1645 auto const *M = E->getValue();
1646 if (M->Directory != ActiveModule->Directory)
1647 continue;
1648
1649 SmallString<128> FullName(ActiveModule->getFullModuleName());
1650 if (!FullName.startswith(M->Name) && !FullName.endswith("Private"))
1651 continue;
1652 SmallString<128> Canonical(M->Name);
1653 Canonical.append("_Private");
1654
1655 // Foo.Private -> Foo_Private
1656 if (ActiveModule->Parent && ActiveModule->Name == "Private" && !M->Parent &&
1657 M->Name == ActiveModule->Parent->Name) {
1658 Diags.Report(ActiveModule->DefinitionLoc,
1659 diag::warn_mmap_mismatched_private_submodule)
1660 << FullName;
1661 GenNoteAndFixIt(FullName, Canonical, M,
1662 SourceRange(InlineParent, ActiveModule->DefinitionLoc));
1663 continue;
1664 }
1665
1666 // FooPrivate and whatnots -> Foo_Private
1667 if (!ActiveModule->Parent && !M->Parent && M->Name != ActiveModule->Name &&
1668 ActiveModule->Name != Canonical) {
1669 Diags.Report(ActiveModule->DefinitionLoc,
1670 diag::warn_mmap_mismatched_private_module_name)
1671 << ActiveModule->Name;
1672 GenNoteAndFixIt(ActiveModule->Name, Canonical, M,
1673 SourceRange(ActiveModule->DefinitionLoc));
1674 }
1675 }
1676}
1677
1678/// \brief Parse a module declaration.
1679///
1680/// module-declaration:
1681/// 'extern' 'module' module-id string-literal
1682/// 'explicit'[opt] 'framework'[opt] 'module' module-id attributes[opt]
1683/// { module-member* }
1684///
1685/// module-member:
1686/// requires-declaration
1687/// header-declaration
1688/// submodule-declaration
1689/// export-declaration
1690/// export-as-declaration
1691/// link-declaration
1692///
1693/// submodule-declaration:
1694/// module-declaration
1695/// inferred-submodule-declaration
1696void ModuleMapParser::parseModuleDecl() {
1697 assert(Tok.is(MMToken::ExplicitKeyword) || Tok.is(MMToken::ModuleKeyword) ||(static_cast <bool> (Tok.is(MMToken::ExplicitKeyword) ||
Tok.is(MMToken::ModuleKeyword) || Tok.is(MMToken::FrameworkKeyword
) || Tok.is(MMToken::ExternKeyword)) ? void (0) : __assert_fail
("Tok.is(MMToken::ExplicitKeyword) || Tok.is(MMToken::ModuleKeyword) || Tok.is(MMToken::FrameworkKeyword) || Tok.is(MMToken::ExternKeyword)"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 1698, __extension__ __PRETTY_FUNCTION__))
1698 Tok.is(MMToken::FrameworkKeyword) || Tok.is(MMToken::ExternKeyword))(static_cast <bool> (Tok.is(MMToken::ExplicitKeyword) ||
Tok.is(MMToken::ModuleKeyword) || Tok.is(MMToken::FrameworkKeyword
) || Tok.is(MMToken::ExternKeyword)) ? void (0) : __assert_fail
("Tok.is(MMToken::ExplicitKeyword) || Tok.is(MMToken::ModuleKeyword) || Tok.is(MMToken::FrameworkKeyword) || Tok.is(MMToken::ExternKeyword)"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 1698, __extension__ __PRETTY_FUNCTION__))
;
1699 if (Tok.is(MMToken::ExternKeyword)) {
1
Taking false branch
1700 parseExternModuleDecl();
1701 return;
1702 }
1703
1704 // Parse 'explicit' or 'framework' keyword, if present.
1705 SourceLocation ExplicitLoc;
1706 bool Explicit = false;
1707 bool Framework = false;
1708
1709 // Parse 'explicit' keyword, if present.
1710 if (Tok.is(MMToken::ExplicitKeyword)) {
2
Taking false branch
1711 ExplicitLoc = consumeToken();
1712 Explicit = true;
1713 }
1714
1715 // Parse 'framework' keyword, if present.
1716 if (Tok.is(MMToken::FrameworkKeyword)) {
3
Taking true branch
1717 consumeToken();
1718 Framework = true;
1719 }
1720
1721 // Parse 'module' keyword.
1722 if (!Tok.is(MMToken::ModuleKeyword)) {
4
Taking false branch
1723 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module);
1724 consumeToken();
1725 HadError = true;
1726 return;
1727 }
1728 consumeToken(); // 'module' keyword
1729
1730 // If we have a wildcard for the module name, this is an inferred submodule.
1731 // Parse it.
1732 if (Tok.is(MMToken::Star))
5
Taking false branch
1733 return parseInferredModuleDecl(Framework, Explicit);
1734
1735 // Parse the module name.
1736 ModuleId Id;
1737 if (parseModuleId(Id)) {
6
Taking false branch
1738 HadError = true;
1739 return;
1740 }
1741
1742 if (ActiveModule) {
7
Assuming the condition is false
8
Taking false branch
1743 if (Id.size() > 1) {
1744 Diags.Report(Id.front().second, diag::err_mmap_nested_submodule_id)
1745 << SourceRange(Id.front().second, Id.back().second);
1746
1747 HadError = true;
1748 return;
1749 }
1750 } else if (Id.size() == 1 && Explicit) {
9
Assuming the condition is false
1751 // Top-level modules can't be explicit.
1752 Diags.Report(ExplicitLoc, diag::err_mmap_explicit_top_level);
1753 Explicit = false;
1754 ExplicitLoc = SourceLocation();
1755 HadError = true;
1756 }
1757
1758 Module *PreviousActiveModule = ActiveModule;
1759 SourceLocation LastInlineParentLoc = SourceLocation();
1760 if (Id.size() > 1) {
10
Assuming the condition is true
11
Taking true branch
1761 // This module map defines a submodule. Go find the module of which it
1762 // is a submodule.
1763 ActiveModule = nullptr;
1764 const Module *TopLevelModule = nullptr;
12
'TopLevelModule' initialized to a null pointer value
1765 for (unsigned I = 0, N = Id.size() - 1; I != N; ++I) {
13
Assuming 'I' is equal to 'N'
14
Loop condition is false. Execution continues on line 1785
1766 if (Module *Next = Map.lookupModuleQualified(Id[I].first, ActiveModule)) {
1767 if (I == 0)
1768 TopLevelModule = Next;
1769 ActiveModule = Next;
1770 LastInlineParentLoc = Id[I].second;
1771 continue;
1772 }
1773
1774 if (ActiveModule) {
1775 Diags.Report(Id[I].second, diag::err_mmap_missing_module_qualified)
1776 << Id[I].first
1777 << ActiveModule->getTopLevelModule()->getFullModuleName();
1778 } else {
1779 Diags.Report(Id[I].second, diag::err_mmap_expected_module_name);
1780 }
1781 HadError = true;
1782 return;
1783 }
1784
1785 if (ModuleMapFile != Map.getContainingModuleMapFile(TopLevelModule)) {
15
Passing null pointer value via 1st parameter 'Module'
16
Calling 'ModuleMap::getContainingModuleMapFile'
1786 assert(ModuleMapFile != Map.getModuleMapFileForUniquing(TopLevelModule) &&(static_cast <bool> (ModuleMapFile != Map.getModuleMapFileForUniquing
(TopLevelModule) && "submodule defined in same file as 'module *' that allowed its "
"top-level module") ? void (0) : __assert_fail ("ModuleMapFile != Map.getModuleMapFileForUniquing(TopLevelModule) && \"submodule defined in same file as 'module *' that allowed its \" \"top-level module\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 1788, __extension__ __PRETTY_FUNCTION__))
1787 "submodule defined in same file as 'module *' that allowed its "(static_cast <bool> (ModuleMapFile != Map.getModuleMapFileForUniquing
(TopLevelModule) && "submodule defined in same file as 'module *' that allowed its "
"top-level module") ? void (0) : __assert_fail ("ModuleMapFile != Map.getModuleMapFileForUniquing(TopLevelModule) && \"submodule defined in same file as 'module *' that allowed its \" \"top-level module\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 1788, __extension__ __PRETTY_FUNCTION__))
1788 "top-level module")(static_cast <bool> (ModuleMapFile != Map.getModuleMapFileForUniquing
(TopLevelModule) && "submodule defined in same file as 'module *' that allowed its "
"top-level module") ? void (0) : __assert_fail ("ModuleMapFile != Map.getModuleMapFileForUniquing(TopLevelModule) && \"submodule defined in same file as 'module *' that allowed its \" \"top-level module\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 1788, __extension__ __PRETTY_FUNCTION__))
;
1789 Map.addAdditionalModuleMapFile(TopLevelModule, ModuleMapFile);
1790 }
1791 }
1792
1793 StringRef ModuleName = Id.back().first;
1794 SourceLocation ModuleNameLoc = Id.back().second;
1795
1796 // Parse the optional attribute list.
1797 Attributes Attrs;
1798 if (parseOptionalAttributes(Attrs))
1799 return;
1800
1801 // Parse the opening brace.
1802 if (!Tok.is(MMToken::LBrace)) {
1803 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace)
1804 << ModuleName;
1805 HadError = true;
1806 return;
1807 }
1808 SourceLocation LBraceLoc = consumeToken();
1809
1810 // Determine whether this (sub)module has already been defined.
1811 Module *ShadowingModule = nullptr;
1812 if (Module *Existing = Map.lookupModuleQualified(ModuleName, ActiveModule)) {
1813 // We might see a (re)definition of a module that we already have a
1814 // definition for in two cases:
1815 // - If we loaded one definition from an AST file and we've just found a
1816 // corresponding definition in a module map file, or
1817 bool LoadedFromASTFile = Existing->DefinitionLoc.isInvalid();
1818 // - If we're building a (preprocessed) module and we've just loaded the
1819 // module map file from which it was created.
1820 bool ParsedAsMainInput =
1821 Map.LangOpts.getCompilingModule() == LangOptions::CMK_ModuleMap &&
1822 Map.LangOpts.CurrentModule == ModuleName &&
1823 SourceMgr.getDecomposedLoc(ModuleNameLoc).first !=
1824 SourceMgr.getDecomposedLoc(Existing->DefinitionLoc).first;
1825 if (!ActiveModule && (LoadedFromASTFile || ParsedAsMainInput)) {
1826 // Skip the module definition.
1827 skipUntil(MMToken::RBrace);
1828 if (Tok.is(MMToken::RBrace))
1829 consumeToken();
1830 else {
1831 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
1832 Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
1833 HadError = true;
1834 }
1835 return;
1836 }
1837
1838 if (!Existing->Parent && Map.mayShadowNewModule(Existing)) {
1839 ShadowingModule = Existing;
1840 } else {
1841 // This is not a shawdowed module decl, it is an illegal redefinition.
1842 Diags.Report(ModuleNameLoc, diag::err_mmap_module_redefinition)
1843 << ModuleName;
1844 Diags.Report(Existing->DefinitionLoc, diag::note_mmap_prev_definition);
1845
1846 // Skip the module definition.
1847 skipUntil(MMToken::RBrace);
1848 if (Tok.is(MMToken::RBrace))
1849 consumeToken();
1850
1851 HadError = true;
1852 return;
1853 }
1854 }
1855
1856 // Start defining this module.
1857 if (ShadowingModule) {
1858 ActiveModule =
1859 Map.createShadowedModule(ModuleName, Framework, ShadowingModule);
1860 } else {
1861 ActiveModule =
1862 Map.findOrCreateModule(ModuleName, ActiveModule, Framework, Explicit)
1863 .first;
1864 }
1865
1866 ActiveModule->DefinitionLoc = ModuleNameLoc;
1867 if (Attrs.IsSystem || IsSystem)
1868 ActiveModule->IsSystem = true;
1869 if (Attrs.IsExternC)
1870 ActiveModule->IsExternC = true;
1871 if (Attrs.NoUndeclaredIncludes ||
1872 (!ActiveModule->Parent && ModuleName == "Darwin"))
1873 ActiveModule->NoUndeclaredIncludes = true;
1874 ActiveModule->Directory = Directory;
1875
1876
1877 // Private modules named as FooPrivate, Foo.Private or similar are likely a
1878 // user error; provide warnings, notes and fixits to direct users to use
1879 // Foo_Private instead.
1880 SourceLocation StartLoc =
1881 SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1882 StringRef MapFileName(ModuleMapFile->getName());
1883 if (Map.HeaderInfo.getHeaderSearchOpts().ImplicitModuleMaps &&
1884 !Diags.isIgnored(diag::warn_mmap_mismatched_private_submodule,
1885 StartLoc) &&
1886 !Diags.isIgnored(diag::warn_mmap_mismatched_private_module_name,
1887 StartLoc) &&
1888 (MapFileName.endswith("module.private.modulemap") ||
1889 MapFileName.endswith("module_private.map")))
1890 diagnosePrivateModules(Map, Diags, ActiveModule, LastInlineParentLoc);
1891
1892 bool Done = false;
1893 do {
1894 switch (Tok.Kind) {
1895 case MMToken::EndOfFile:
1896 case MMToken::RBrace:
1897 Done = true;
1898 break;
1899
1900 case MMToken::ConfigMacros:
1901 parseConfigMacros();
1902 break;
1903
1904 case MMToken::Conflict:
1905 parseConflict();
1906 break;
1907
1908 case MMToken::ExplicitKeyword:
1909 case MMToken::ExternKeyword:
1910 case MMToken::FrameworkKeyword:
1911 case MMToken::ModuleKeyword:
1912 parseModuleDecl();
1913 break;
1914
1915 case MMToken::ExportKeyword:
1916 parseExportDecl();
1917 break;
1918
1919 case MMToken::ExportAsKeyword:
1920 parseExportAsDecl();
1921 break;
1922
1923 case MMToken::UseKeyword:
1924 parseUseDecl();
1925 break;
1926
1927 case MMToken::RequiresKeyword:
1928 parseRequiresDecl();
1929 break;
1930
1931 case MMToken::TextualKeyword:
1932 parseHeaderDecl(MMToken::TextualKeyword, consumeToken());
1933 break;
1934
1935 case MMToken::UmbrellaKeyword: {
1936 SourceLocation UmbrellaLoc = consumeToken();
1937 if (Tok.is(MMToken::HeaderKeyword))
1938 parseHeaderDecl(MMToken::UmbrellaKeyword, UmbrellaLoc);
1939 else
1940 parseUmbrellaDirDecl(UmbrellaLoc);
1941 break;
1942 }
1943
1944 case MMToken::ExcludeKeyword:
1945 parseHeaderDecl(MMToken::ExcludeKeyword, consumeToken());
1946 break;
1947
1948 case MMToken::PrivateKeyword:
1949 parseHeaderDecl(MMToken::PrivateKeyword, consumeToken());
1950 break;
1951
1952 case MMToken::HeaderKeyword:
1953 parseHeaderDecl(MMToken::HeaderKeyword, consumeToken());
1954 break;
1955
1956 case MMToken::LinkKeyword:
1957 parseLinkDecl();
1958 break;
1959
1960 default:
1961 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_member);
1962 consumeToken();
1963 break;
1964 }
1965 } while (!Done);
1966
1967 if (Tok.is(MMToken::RBrace))
1968 consumeToken();
1969 else {
1970 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
1971 Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
1972 HadError = true;
1973 }
1974
1975 // If the active module is a top-level framework, and there are no link
1976 // libraries, automatically link against the framework.
1977 if (ActiveModule->IsFramework && !ActiveModule->isSubFramework() &&
1978 ActiveModule->LinkLibraries.empty()) {
1979 inferFrameworkLink(ActiveModule, Directory, SourceMgr.getFileManager());
1980 }
1981
1982 // If the module meets all requirements but is still unavailable, mark the
1983 // whole tree as unavailable to prevent it from building.
1984 if (!ActiveModule->IsAvailable && !ActiveModule->IsMissingRequirement &&
1985 ActiveModule->Parent) {
1986 ActiveModule->getTopLevelModule()->markUnavailable();
1987 ActiveModule->getTopLevelModule()->MissingHeaders.append(
1988 ActiveModule->MissingHeaders.begin(), ActiveModule->MissingHeaders.end());
1989 }
1990
1991 // We're done parsing this module. Pop back to the previous module.
1992 ActiveModule = PreviousActiveModule;
1993}
1994
1995/// \brief Parse an extern module declaration.
1996///
1997/// extern module-declaration:
1998/// 'extern' 'module' module-id string-literal
1999void ModuleMapParser::parseExternModuleDecl() {
2000 assert(Tok.is(MMToken::ExternKeyword))(static_cast <bool> (Tok.is(MMToken::ExternKeyword)) ? void
(0) : __assert_fail ("Tok.is(MMToken::ExternKeyword)", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 2000, __extension__ __PRETTY_FUNCTION__))
;
2001 SourceLocation ExternLoc = consumeToken(); // 'extern' keyword
2002
2003 // Parse 'module' keyword.
2004 if (!Tok.is(MMToken::ModuleKeyword)) {
2005 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module);
2006 consumeToken();
2007 HadError = true;
2008 return;
2009 }
2010 consumeToken(); // 'module' keyword
2011
2012 // Parse the module name.
2013 ModuleId Id;
2014 if (parseModuleId(Id)) {
2015 HadError = true;
2016 return;
2017 }
2018
2019 // Parse the referenced module map file name.
2020 if (!Tok.is(MMToken::StringLiteral)) {
2021 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_mmap_file);
2022 HadError = true;
2023 return;
2024 }
2025 std::string FileName = Tok.getString();
2026 consumeToken(); // filename
2027
2028 StringRef FileNameRef = FileName;
2029 SmallString<128> ModuleMapFileName;
2030 if (llvm::sys::path::is_relative(FileNameRef)) {
2031 ModuleMapFileName += Directory->getName();
2032 llvm::sys::path::append(ModuleMapFileName, FileName);
2033 FileNameRef = ModuleMapFileName;
2034 }
2035 if (const FileEntry *File = SourceMgr.getFileManager().getFile(FileNameRef))
2036 Map.parseModuleMapFile(
2037 File, /*IsSystem=*/false,
2038 Map.HeaderInfo.getHeaderSearchOpts().ModuleMapFileHomeIsCwd
2039 ? Directory
2040 : File->getDir(),
2041 FileID(), nullptr, ExternLoc);
2042}
2043
2044/// Whether to add the requirement \p Feature to the module \p M.
2045///
2046/// This preserves backwards compatibility for two hacks in the Darwin system
2047/// module map files:
2048///
2049/// 1. The use of 'requires excluded' to make headers non-modular, which
2050/// should really be mapped to 'textual' now that we have this feature. We
2051/// drop the 'excluded' requirement, and set \p IsRequiresExcludedHack to
2052/// true. Later, this bit will be used to map all the headers inside this
2053/// module to 'textual'.
2054///
2055/// This affects Darwin.C.excluded (for assert.h) and Tcl.Private.
2056///
2057/// 2. Removes a bogus cplusplus requirement from IOKit.avc. This requirement
2058/// was never correct and causes issues now that we check it, so drop it.
2059static bool shouldAddRequirement(Module *M, StringRef Feature,
2060 bool &IsRequiresExcludedHack) {
2061 if (Feature == "excluded" &&
2062 (M->fullModuleNameIs({"Darwin", "C", "excluded"}) ||
2063 M->fullModuleNameIs({"Tcl", "Private"}))) {
2064 IsRequiresExcludedHack = true;
2065 return false;
2066 } else if (Feature == "cplusplus" && M->fullModuleNameIs({"IOKit", "avc"})) {
2067 return false;
2068 }
2069
2070 return true;
2071}
2072
2073/// \brief Parse a requires declaration.
2074///
2075/// requires-declaration:
2076/// 'requires' feature-list
2077///
2078/// feature-list:
2079/// feature ',' feature-list
2080/// feature
2081///
2082/// feature:
2083/// '!'[opt] identifier
2084void ModuleMapParser::parseRequiresDecl() {
2085 assert(Tok.is(MMToken::RequiresKeyword))(static_cast <bool> (Tok.is(MMToken::RequiresKeyword)) ?
void (0) : __assert_fail ("Tok.is(MMToken::RequiresKeyword)"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 2085, __extension__ __PRETTY_FUNCTION__))
;
2086
2087 // Parse 'requires' keyword.
2088 consumeToken();
2089
2090 // Parse the feature-list.
2091 do {
2092 bool RequiredState = true;
2093 if (Tok.is(MMToken::Exclaim)) {
2094 RequiredState = false;
2095 consumeToken();
2096 }
2097
2098 if (!Tok.is(MMToken::Identifier)) {
2099 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_feature);
2100 HadError = true;
2101 return;
2102 }
2103
2104 // Consume the feature name.
2105 std::string Feature = Tok.getString();
2106 consumeToken();
2107
2108 bool IsRequiresExcludedHack = false;
2109 bool ShouldAddRequirement =
2110 shouldAddRequirement(ActiveModule, Feature, IsRequiresExcludedHack);
2111
2112 if (IsRequiresExcludedHack)
2113 UsesRequiresExcludedHack.insert(ActiveModule);
2114
2115 if (ShouldAddRequirement) {
2116 // Add this feature.
2117 ActiveModule->addRequirement(Feature, RequiredState, Map.LangOpts,
2118 *Map.Target);
2119 }
2120
2121 if (!Tok.is(MMToken::Comma))
2122 break;
2123
2124 // Consume the comma.
2125 consumeToken();
2126 } while (true);
2127}
2128
2129/// \brief Parse a header declaration.
2130///
2131/// header-declaration:
2132/// 'textual'[opt] 'header' string-literal
2133/// 'private' 'textual'[opt] 'header' string-literal
2134/// 'exclude' 'header' string-literal
2135/// 'umbrella' 'header' string-literal
2136///
2137/// FIXME: Support 'private textual header'.
2138void ModuleMapParser::parseHeaderDecl(MMToken::TokenKind LeadingToken,
2139 SourceLocation LeadingLoc) {
2140 // We've already consumed the first token.
2141 ModuleMap::ModuleHeaderRole Role = ModuleMap::NormalHeader;
2142 if (LeadingToken == MMToken::PrivateKeyword) {
2143 Role = ModuleMap::PrivateHeader;
2144 // 'private' may optionally be followed by 'textual'.
2145 if (Tok.is(MMToken::TextualKeyword)) {
2146 LeadingToken = Tok.Kind;
2147 consumeToken();
2148 }
2149 }
2150
2151 if (LeadingToken == MMToken::TextualKeyword)
2152 Role = ModuleMap::ModuleHeaderRole(Role | ModuleMap::TextualHeader);
2153
2154 if (UsesRequiresExcludedHack.count(ActiveModule)) {
2155 // Mark this header 'textual' (see doc comment for
2156 // Module::UsesRequiresExcludedHack).
2157 Role = ModuleMap::ModuleHeaderRole(Role | ModuleMap::TextualHeader);
2158 }
2159
2160 if (LeadingToken != MMToken::HeaderKeyword) {
2161 if (!Tok.is(MMToken::HeaderKeyword)) {
2162 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header)
2163 << (LeadingToken == MMToken::PrivateKeyword ? "private" :
2164 LeadingToken == MMToken::ExcludeKeyword ? "exclude" :
2165 LeadingToken == MMToken::TextualKeyword ? "textual" : "umbrella");
2166 return;
2167 }
2168 consumeToken();
2169 }
2170
2171 // Parse the header name.
2172 if (!Tok.is(MMToken::StringLiteral)) {
2173 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header)
2174 << "header";
2175 HadError = true;
2176 return;
2177 }
2178 Module::UnresolvedHeaderDirective Header;
2179 Header.FileName = Tok.getString();
2180 Header.FileNameLoc = consumeToken();
2181 Header.IsUmbrella = LeadingToken == MMToken::UmbrellaKeyword;
2182 Header.Kind =
2183 (LeadingToken == MMToken::ExcludeKeyword ? Module::HK_Excluded
2184 : Map.headerRoleToKind(Role));
2185
2186 // Check whether we already have an umbrella.
2187 if (Header.IsUmbrella && ActiveModule->Umbrella) {
2188 Diags.Report(Header.FileNameLoc, diag::err_mmap_umbrella_clash)
2189 << ActiveModule->getFullModuleName();
2190 HadError = true;
2191 return;
2192 }
2193
2194 // If we were given stat information, parse it so we can skip looking for
2195 // the file.
2196 if (Tok.is(MMToken::LBrace)) {
2197 SourceLocation LBraceLoc = consumeToken();
2198
2199 while (!Tok.is(MMToken::RBrace) && !Tok.is(MMToken::EndOfFile)) {
2200 enum Attribute { Size, ModTime, Unknown };
2201 StringRef Str = Tok.getString();
2202 SourceLocation Loc = consumeToken();
2203 switch (llvm::StringSwitch<Attribute>(Str)
2204 .Case("size", Size)
2205 .Case("mtime", ModTime)
2206 .Default(Unknown)) {
2207 case Size:
2208 if (Header.Size)
2209 Diags.Report(Loc, diag::err_mmap_duplicate_header_attribute) << Str;
2210 if (!Tok.is(MMToken::IntegerLiteral)) {
2211 Diags.Report(Tok.getLocation(),
2212 diag::err_mmap_invalid_header_attribute_value) << Str;
2213 skipUntil(MMToken::RBrace);
2214 break;
2215 }
2216 Header.Size = Tok.getInteger();
2217 consumeToken();
2218 break;
2219
2220 case ModTime:
2221 if (Header.ModTime)
2222 Diags.Report(Loc, diag::err_mmap_duplicate_header_attribute) << Str;
2223 if (!Tok.is(MMToken::IntegerLiteral)) {
2224 Diags.Report(Tok.getLocation(),
2225 diag::err_mmap_invalid_header_attribute_value) << Str;
2226 skipUntil(MMToken::RBrace);
2227 break;
2228 }
2229 Header.ModTime = Tok.getInteger();
2230 consumeToken();
2231 break;
2232
2233 case Unknown:
2234 Diags.Report(Loc, diag::err_mmap_expected_header_attribute);
2235 skipUntil(MMToken::RBrace);
2236 break;
2237 }
2238 }
2239
2240 if (Tok.is(MMToken::RBrace))
2241 consumeToken();
2242 else {
2243 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
2244 Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
2245 HadError = true;
2246 }
2247 }
2248
2249 Map.addUnresolvedHeader(ActiveModule, std::move(Header));
2250}
2251
2252static int compareModuleHeaders(const Module::Header *A,
2253 const Module::Header *B) {
2254 return A->NameAsWritten.compare(B->NameAsWritten);
2255}
2256
2257/// \brief Parse an umbrella directory declaration.
2258///
2259/// umbrella-dir-declaration:
2260/// umbrella string-literal
2261void ModuleMapParser::parseUmbrellaDirDecl(SourceLocation UmbrellaLoc) {
2262 // Parse the directory name.
2263 if (!Tok.is(MMToken::StringLiteral)) {
2264 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header)
2265 << "umbrella";
2266 HadError = true;
2267 return;
2268 }
2269
2270 std::string DirName = Tok.getString();
2271 SourceLocation DirNameLoc = consumeToken();
2272
2273 // Check whether we already have an umbrella.
2274 if (ActiveModule->Umbrella) {
2275 Diags.Report(DirNameLoc, diag::err_mmap_umbrella_clash)
2276 << ActiveModule->getFullModuleName();
2277 HadError = true;
2278 return;
2279 }
2280
2281 // Look for this file.
2282 const DirectoryEntry *Dir = nullptr;
2283 if (llvm::sys::path::is_absolute(DirName))
2284 Dir = SourceMgr.getFileManager().getDirectory(DirName);
2285 else {
2286 SmallString<128> PathName;
2287 PathName = Directory->getName();
2288 llvm::sys::path::append(PathName, DirName);
2289 Dir = SourceMgr.getFileManager().getDirectory(PathName);
2290 }
2291
2292 if (!Dir) {
2293 Diags.Report(DirNameLoc, diag::warn_mmap_umbrella_dir_not_found)
2294 << DirName;
2295 return;
2296 }
2297
2298 if (UsesRequiresExcludedHack.count(ActiveModule)) {
2299 // Mark this header 'textual' (see doc comment for
2300 // ModuleMapParser::UsesRequiresExcludedHack). Although iterating over the
2301 // directory is relatively expensive, in practice this only applies to the
2302 // uncommonly used Tcl module on Darwin platforms.
2303 std::error_code EC;
2304 SmallVector<Module::Header, 6> Headers;
2305 vfs::FileSystem &FS = *SourceMgr.getFileManager().getVirtualFileSystem();
2306 for (vfs::recursive_directory_iterator I(FS, Dir->getName(), EC), E;
2307 I != E && !EC; I.increment(EC)) {
2308 if (const FileEntry *FE =
2309 SourceMgr.getFileManager().getFile(I->getName())) {
2310
2311 Module::Header Header = {I->getName(), FE};
2312 Headers.push_back(std::move(Header));
2313 }
2314 }
2315
2316 // Sort header paths so that the pcm doesn't depend on iteration order.
2317 llvm::array_pod_sort(Headers.begin(), Headers.end(), compareModuleHeaders);
2318
2319 for (auto &Header : Headers)
2320 Map.addHeader(ActiveModule, std::move(Header), ModuleMap::TextualHeader);
2321 return;
2322 }
2323
2324 if (Module *OwningModule = Map.UmbrellaDirs[Dir]) {
2325 Diags.Report(UmbrellaLoc, diag::err_mmap_umbrella_clash)
2326 << OwningModule->getFullModuleName();
2327 HadError = true;
2328 return;
2329 }
2330
2331 // Record this umbrella directory.
2332 Map.setUmbrellaDir(ActiveModule, Dir, DirName);
2333}
2334
2335/// \brief Parse a module export declaration.
2336///
2337/// export-declaration:
2338/// 'export' wildcard-module-id
2339///
2340/// wildcard-module-id:
2341/// identifier
2342/// '*'
2343/// identifier '.' wildcard-module-id
2344void ModuleMapParser::parseExportDecl() {
2345 assert(Tok.is(MMToken::ExportKeyword))(static_cast <bool> (Tok.is(MMToken::ExportKeyword)) ? void
(0) : __assert_fail ("Tok.is(MMToken::ExportKeyword)", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 2345, __extension__ __PRETTY_FUNCTION__))
;
2346 SourceLocation ExportLoc = consumeToken();
2347
2348 // Parse the module-id with an optional wildcard at the end.
2349 ModuleId ParsedModuleId;
2350 bool Wildcard = false;
2351 do {
2352 // FIXME: Support string-literal module names here.
2353 if (Tok.is(MMToken::Identifier)) {
2354 ParsedModuleId.push_back(std::make_pair(Tok.getString(),
2355 Tok.getLocation()));
2356 consumeToken();
2357
2358 if (Tok.is(MMToken::Period)) {
2359 consumeToken();
2360 continue;
2361 }
2362
2363 break;
2364 }
2365
2366 if(Tok.is(MMToken::Star)) {
2367 Wildcard = true;
2368 consumeToken();
2369 break;
2370 }
2371
2372 Diags.Report(Tok.getLocation(), diag::err_mmap_module_id);
2373 HadError = true;
2374 return;
2375 } while (true);
2376
2377 Module::UnresolvedExportDecl Unresolved = {
2378 ExportLoc, ParsedModuleId, Wildcard
2379 };
2380 ActiveModule->UnresolvedExports.push_back(Unresolved);
2381}
2382
2383/// \brief Parse a module export_as declaration.
2384///
2385/// export-as-declaration:
2386/// 'export_as' identifier
2387void ModuleMapParser::parseExportAsDecl() {
2388 assert(Tok.is(MMToken::ExportAsKeyword))(static_cast <bool> (Tok.is(MMToken::ExportAsKeyword)) ?
void (0) : __assert_fail ("Tok.is(MMToken::ExportAsKeyword)"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 2388, __extension__ __PRETTY_FUNCTION__))
;
2389 consumeToken();
2390
2391 if (!Tok.is(MMToken::Identifier)) {
2392 Diags.Report(Tok.getLocation(), diag::err_mmap_module_id);
2393 HadError = true;
2394 return;
2395 }
2396
2397 if (ActiveModule->Parent) {
2398 Diags.Report(Tok.getLocation(), diag::err_mmap_submodule_export_as);
2399 consumeToken();
2400 return;
2401 }
2402
2403 if (!ActiveModule->ExportAsModule.empty()) {
2404 if (ActiveModule->ExportAsModule == Tok.getString()) {
2405 Diags.Report(Tok.getLocation(), diag::warn_mmap_redundant_export_as)
2406 << ActiveModule->Name << Tok.getString();
2407 } else {
2408 Diags.Report(Tok.getLocation(), diag::err_mmap_conflicting_export_as)
2409 << ActiveModule->Name << ActiveModule->ExportAsModule
2410 << Tok.getString();
2411 }
2412 }
2413
2414 ActiveModule->ExportAsModule = Tok.getString();
2415 consumeToken();
2416}
2417
2418/// \brief Parse a module use declaration.
2419///
2420/// use-declaration:
2421/// 'use' wildcard-module-id
2422void ModuleMapParser::parseUseDecl() {
2423 assert(Tok.is(MMToken::UseKeyword))(static_cast <bool> (Tok.is(MMToken::UseKeyword)) ? void
(0) : __assert_fail ("Tok.is(MMToken::UseKeyword)", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 2423, __extension__ __PRETTY_FUNCTION__))
;
2424 auto KWLoc = consumeToken();
2425 // Parse the module-id.
2426 ModuleId ParsedModuleId;
2427 parseModuleId(ParsedModuleId);
2428
2429 if (ActiveModule->Parent)
2430 Diags.Report(KWLoc, diag::err_mmap_use_decl_submodule);
2431 else
2432 ActiveModule->UnresolvedDirectUses.push_back(ParsedModuleId);
2433}
2434
2435/// \brief Parse a link declaration.
2436///
2437/// module-declaration:
2438/// 'link' 'framework'[opt] string-literal
2439void ModuleMapParser::parseLinkDecl() {
2440 assert(Tok.is(MMToken::LinkKeyword))(static_cast <bool> (Tok.is(MMToken::LinkKeyword)) ? void
(0) : __assert_fail ("Tok.is(MMToken::LinkKeyword)", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 2440, __extension__ __PRETTY_FUNCTION__))
;
2441 SourceLocation LinkLoc = consumeToken();
2442
2443 // Parse the optional 'framework' keyword.
2444 bool IsFramework = false;
2445 if (Tok.is(MMToken::FrameworkKeyword)) {
2446 consumeToken();
2447 IsFramework = true;
2448 }
2449
2450 // Parse the library name
2451 if (!Tok.is(MMToken::StringLiteral)) {
2452 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_library_name)
2453 << IsFramework << SourceRange(LinkLoc);
2454 HadError = true;
2455 return;
2456 }
2457
2458 std::string LibraryName = Tok.getString();
2459 consumeToken();
2460 ActiveModule->LinkLibraries.push_back(Module::LinkLibrary(LibraryName,
2461 IsFramework));
2462}
2463
2464/// \brief Parse a configuration macro declaration.
2465///
2466/// module-declaration:
2467/// 'config_macros' attributes[opt] config-macro-list?
2468///
2469/// config-macro-list:
2470/// identifier (',' identifier)?
2471void ModuleMapParser::parseConfigMacros() {
2472 assert(Tok.is(MMToken::ConfigMacros))(static_cast <bool> (Tok.is(MMToken::ConfigMacros)) ? void
(0) : __assert_fail ("Tok.is(MMToken::ConfigMacros)", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 2472, __extension__ __PRETTY_FUNCTION__))
;
2473 SourceLocation ConfigMacrosLoc = consumeToken();
2474
2475 // Only top-level modules can have configuration macros.
2476 if (ActiveModule->Parent) {
2477 Diags.Report(ConfigMacrosLoc, diag::err_mmap_config_macro_submodule);
2478 }
2479
2480 // Parse the optional attributes.
2481 Attributes Attrs;
2482 if (parseOptionalAttributes(Attrs))
2483 return;
2484
2485 if (Attrs.IsExhaustive && !ActiveModule->Parent) {
2486 ActiveModule->ConfigMacrosExhaustive = true;
2487 }
2488
2489 // If we don't have an identifier, we're done.
2490 // FIXME: Support macros with the same name as a keyword here.
2491 if (!Tok.is(MMToken::Identifier))
2492 return;
2493
2494 // Consume the first identifier.
2495 if (!ActiveModule->Parent) {
2496 ActiveModule->ConfigMacros.push_back(Tok.getString().str());
2497 }
2498 consumeToken();
2499
2500 do {
2501 // If there's a comma, consume it.
2502 if (!Tok.is(MMToken::Comma))
2503 break;
2504 consumeToken();
2505
2506 // We expect to see a macro name here.
2507 // FIXME: Support macros with the same name as a keyword here.
2508 if (!Tok.is(MMToken::Identifier)) {
2509 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_config_macro);
2510 break;
2511 }
2512
2513 // Consume the macro name.
2514 if (!ActiveModule->Parent) {
2515 ActiveModule->ConfigMacros.push_back(Tok.getString().str());
2516 }
2517 consumeToken();
2518 } while (true);
2519}
2520
2521/// \brief Format a module-id into a string.
2522static std::string formatModuleId(const ModuleId &Id) {
2523 std::string result;
2524 {
2525 llvm::raw_string_ostream OS(result);
2526
2527 for (unsigned I = 0, N = Id.size(); I != N; ++I) {
2528 if (I)
2529 OS << ".";
2530 OS << Id[I].first;
2531 }
2532 }
2533
2534 return result;
2535}
2536
2537/// \brief Parse a conflict declaration.
2538///
2539/// module-declaration:
2540/// 'conflict' module-id ',' string-literal
2541void ModuleMapParser::parseConflict() {
2542 assert(Tok.is(MMToken::Conflict))(static_cast <bool> (Tok.is(MMToken::Conflict)) ? void (
0) : __assert_fail ("Tok.is(MMToken::Conflict)", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 2542, __extension__ __PRETTY_FUNCTION__))
;
2543 SourceLocation ConflictLoc = consumeToken();
2544 Module::UnresolvedConflict Conflict;
2545
2546 // Parse the module-id.
2547 if (parseModuleId(Conflict.Id))
2548 return;
2549
2550 // Parse the ','.
2551 if (!Tok.is(MMToken::Comma)) {
2552 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_conflicts_comma)
2553 << SourceRange(ConflictLoc);
2554 return;
2555 }
2556 consumeToken();
2557
2558 // Parse the message.
2559 if (!Tok.is(MMToken::StringLiteral)) {
2560 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_conflicts_message)
2561 << formatModuleId(Conflict.Id);
2562 return;
2563 }
2564 Conflict.Message = Tok.getString().str();
2565 consumeToken();
2566
2567 // Add this unresolved conflict.
2568 ActiveModule->UnresolvedConflicts.push_back(Conflict);
2569}
2570
2571/// \brief Parse an inferred module declaration (wildcard modules).
2572///
2573/// module-declaration:
2574/// 'explicit'[opt] 'framework'[opt] 'module' * attributes[opt]
2575/// { inferred-module-member* }
2576///
2577/// inferred-module-member:
2578/// 'export' '*'
2579/// 'exclude' identifier
2580void ModuleMapParser::parseInferredModuleDecl(bool Framework, bool Explicit) {
2581 assert(Tok.is(MMToken::Star))(static_cast <bool> (Tok.is(MMToken::Star)) ? void (0) :
__assert_fail ("Tok.is(MMToken::Star)", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 2581, __extension__ __PRETTY_FUNCTION__))
;
2582 SourceLocation StarLoc = consumeToken();
2583 bool Failed = false;
2584
2585 // Inferred modules must be submodules.
2586 if (!ActiveModule && !Framework) {
2587 Diags.Report(StarLoc, diag::err_mmap_top_level_inferred_submodule);
2588 Failed = true;
2589 }
2590
2591 if (ActiveModule) {
2592 // Inferred modules must have umbrella directories.
2593 if (!Failed && ActiveModule->IsAvailable &&
2594 !ActiveModule->getUmbrellaDir()) {
2595 Diags.Report(StarLoc, diag::err_mmap_inferred_no_umbrella);
2596 Failed = true;
2597 }
2598
2599 // Check for redefinition of an inferred module.
2600 if (!Failed && ActiveModule->InferSubmodules) {
2601 Diags.Report(StarLoc, diag::err_mmap_inferred_redef);
2602 if (ActiveModule->InferredSubmoduleLoc.isValid())
2603 Diags.Report(ActiveModule->InferredSubmoduleLoc,
2604 diag::note_mmap_prev_definition);
2605 Failed = true;
2606 }
2607
2608 // Check for the 'framework' keyword, which is not permitted here.
2609 if (Framework) {
2610 Diags.Report(StarLoc, diag::err_mmap_inferred_framework_submodule);
2611 Framework = false;
2612 }
2613 } else if (Explicit) {
2614 Diags.Report(StarLoc, diag::err_mmap_explicit_inferred_framework);
2615 Explicit = false;
2616 }
2617
2618 // If there were any problems with this inferred submodule, skip its body.
2619 if (Failed) {
2620 if (Tok.is(MMToken::LBrace)) {
2621 consumeToken();
2622 skipUntil(MMToken::RBrace);
2623 if (Tok.is(MMToken::RBrace))
2624 consumeToken();
2625 }
2626 HadError = true;
2627 return;
2628 }
2629
2630 // Parse optional attributes.
2631 Attributes Attrs;
2632 if (parseOptionalAttributes(Attrs))
2633 return;
2634
2635 if (ActiveModule) {
2636 // Note that we have an inferred submodule.
2637 ActiveModule->InferSubmodules = true;
2638 ActiveModule->InferredSubmoduleLoc = StarLoc;
2639 ActiveModule->InferExplicitSubmodules = Explicit;
2640 } else {
2641 // We'll be inferring framework modules for this directory.
2642 Map.InferredDirectories[Directory].InferModules = true;
2643 Map.InferredDirectories[Directory].Attrs = Attrs;
2644 Map.InferredDirectories[Directory].ModuleMapFile = ModuleMapFile;
2645 // FIXME: Handle the 'framework' keyword.
2646 }
2647
2648 // Parse the opening brace.
2649 if (!Tok.is(MMToken::LBrace)) {
2650 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace_wildcard);
2651 HadError = true;
2652 return;
2653 }
2654 SourceLocation LBraceLoc = consumeToken();
2655
2656 // Parse the body of the inferred submodule.
2657 bool Done = false;
2658 do {
2659 switch (Tok.Kind) {
2660 case MMToken::EndOfFile:
2661 case MMToken::RBrace:
2662 Done = true;
2663 break;
2664
2665 case MMToken::ExcludeKeyword:
2666 if (ActiveModule) {
2667 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member)
2668 << (ActiveModule != nullptr);
2669 consumeToken();
2670 break;
2671 }
2672
2673 consumeToken();
2674 // FIXME: Support string-literal module names here.
2675 if (!Tok.is(MMToken::Identifier)) {
2676 Diags.Report(Tok.getLocation(), diag::err_mmap_missing_exclude_name);
2677 break;
2678 }
2679
2680 Map.InferredDirectories[Directory].ExcludedModules
2681 .push_back(Tok.getString());
2682 consumeToken();
2683 break;
2684
2685 case MMToken::ExportKeyword:
2686 if (!ActiveModule) {
2687 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member)
2688 << (ActiveModule != nullptr);
2689 consumeToken();
2690 break;
2691 }
2692
2693 consumeToken();
2694 if (Tok.is(MMToken::Star))
2695 ActiveModule->InferExportWildcard = true;
2696 else
2697 Diags.Report(Tok.getLocation(),
2698 diag::err_mmap_expected_export_wildcard);
2699 consumeToken();
2700 break;
2701
2702 case MMToken::ExplicitKeyword:
2703 case MMToken::ModuleKeyword:
2704 case MMToken::HeaderKeyword:
2705 case MMToken::PrivateKeyword:
2706 case MMToken::UmbrellaKeyword:
2707 default:
2708 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member)
2709 << (ActiveModule != nullptr);
2710 consumeToken();
2711 break;
2712 }
2713 } while (!Done);
2714
2715 if (Tok.is(MMToken::RBrace))
2716 consumeToken();
2717 else {
2718 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
2719 Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
2720 HadError = true;
2721 }
2722}
2723
2724/// \brief Parse optional attributes.
2725///
2726/// attributes:
2727/// attribute attributes
2728/// attribute
2729///
2730/// attribute:
2731/// [ identifier ]
2732///
2733/// \param Attrs Will be filled in with the parsed attributes.
2734///
2735/// \returns true if an error occurred, false otherwise.
2736bool ModuleMapParser::parseOptionalAttributes(Attributes &Attrs) {
2737 bool HadError = false;
2738
2739 while (Tok.is(MMToken::LSquare)) {
2740 // Consume the '['.
2741 SourceLocation LSquareLoc = consumeToken();
2742
2743 // Check whether we have an attribute name here.
2744 if (!Tok.is(MMToken::Identifier)) {
2745 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_attribute);
2746 skipUntil(MMToken::RSquare);
2747 if (Tok.is(MMToken::RSquare))
2748 consumeToken();
2749 HadError = true;
2750 }
2751
2752 // Decode the attribute name.
2753 AttributeKind Attribute
2754 = llvm::StringSwitch<AttributeKind>(Tok.getString())
2755 .Case("exhaustive", AT_exhaustive)
2756 .Case("extern_c", AT_extern_c)
2757 .Case("no_undeclared_includes", AT_no_undeclared_includes)
2758 .Case("system", AT_system)
2759 .Default(AT_unknown);
2760 switch (Attribute) {
2761 case AT_unknown:
2762 Diags.Report(Tok.getLocation(), diag::warn_mmap_unknown_attribute)
2763 << Tok.getString();
2764 break;
2765
2766 case AT_system:
2767 Attrs.IsSystem = true;
2768 break;
2769
2770 case AT_extern_c:
2771 Attrs.IsExternC = true;
2772 break;
2773
2774 case AT_exhaustive:
2775 Attrs.IsExhaustive = true;
2776 break;
2777
2778 case AT_no_undeclared_includes:
2779 Attrs.NoUndeclaredIncludes = true;
2780 break;
2781 }
2782 consumeToken();
2783
2784 // Consume the ']'.
2785 if (!Tok.is(MMToken::RSquare)) {
2786 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rsquare);
2787 Diags.Report(LSquareLoc, diag::note_mmap_lsquare_match);
2788 skipUntil(MMToken::RSquare);
2789 HadError = true;
2790 }
2791
2792 if (Tok.is(MMToken::RSquare))
2793 consumeToken();
2794 }
2795
2796 return HadError;
2797}
2798
2799/// \brief Parse a module map file.
2800///
2801/// module-map-file:
2802/// module-declaration*
2803bool ModuleMapParser::parseModuleMapFile() {
2804 do {
2805 switch (Tok.Kind) {
2806 case MMToken::EndOfFile:
2807 return HadError;
2808
2809 case MMToken::ExplicitKeyword:
2810 case MMToken::ExternKeyword:
2811 case MMToken::ModuleKeyword:
2812 case MMToken::FrameworkKeyword:
2813 parseModuleDecl();
2814 break;
2815
2816 case MMToken::Comma:
2817 case MMToken::ConfigMacros:
2818 case MMToken::Conflict:
2819 case MMToken::Exclaim:
2820 case MMToken::ExcludeKeyword:
2821 case MMToken::ExportKeyword:
2822 case MMToken::ExportAsKeyword:
2823 case MMToken::HeaderKeyword:
2824 case MMToken::Identifier:
2825 case MMToken::LBrace:
2826 case MMToken::LinkKeyword:
2827 case MMToken::LSquare:
2828 case MMToken::Period:
2829 case MMToken::PrivateKeyword:
2830 case MMToken::RBrace:
2831 case MMToken::RSquare:
2832 case MMToken::RequiresKeyword:
2833 case MMToken::Star:
2834 case MMToken::StringLiteral:
2835 case MMToken::IntegerLiteral:
2836 case MMToken::TextualKeyword:
2837 case MMToken::UmbrellaKeyword:
2838 case MMToken::UseKeyword:
2839 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module);
2840 HadError = true;
2841 consumeToken();
2842 break;
2843 }
2844 } while (true);
2845}
2846
2847bool ModuleMap::parseModuleMapFile(const FileEntry *File, bool IsSystem,
2848 const DirectoryEntry *Dir, FileID ID,
2849 unsigned *Offset,
2850 SourceLocation ExternModuleLoc) {
2851 assert(Target && "Missing target information")(static_cast <bool> (Target && "Missing target information"
) ? void (0) : __assert_fail ("Target && \"Missing target information\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 2851, __extension__ __PRETTY_FUNCTION__))
;
2852 llvm::DenseMap<const FileEntry *, bool>::iterator Known
2853 = ParsedModuleMap.find(File);
2854 if (Known != ParsedModuleMap.end())
2855 return Known->second;
2856
2857 // If the module map file wasn't already entered, do so now.
2858 if (ID.isInvalid()) {
2859 auto FileCharacter =
2860 IsSystem ? SrcMgr::C_System_ModuleMap : SrcMgr::C_User_ModuleMap;
2861 ID = SourceMgr.createFileID(File, ExternModuleLoc, FileCharacter);
2862 }
2863
2864 assert(Target && "Missing target information")(static_cast <bool> (Target && "Missing target information"
) ? void (0) : __assert_fail ("Target && \"Missing target information\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 2864, __extension__ __PRETTY_FUNCTION__))
;
2865 const llvm::MemoryBuffer *Buffer = SourceMgr.getBuffer(ID);
2866 if (!Buffer)
2867 return ParsedModuleMap[File] = true;
2868 assert((!Offset || *Offset <= Buffer->getBufferSize()) &&(static_cast <bool> ((!Offset || *Offset <= Buffer->
getBufferSize()) && "invalid buffer offset") ? void (
0) : __assert_fail ("(!Offset || *Offset <= Buffer->getBufferSize()) && \"invalid buffer offset\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 2869, __extension__ __PRETTY_FUNCTION__))
2869 "invalid buffer offset")(static_cast <bool> ((!Offset || *Offset <= Buffer->
getBufferSize()) && "invalid buffer offset") ? void (
0) : __assert_fail ("(!Offset || *Offset <= Buffer->getBufferSize()) && \"invalid buffer offset\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 2869, __extension__ __PRETTY_FUNCTION__))
;
2870
2871 // Parse this module map file.
2872 Lexer L(SourceMgr.getLocForStartOfFile(ID), MMapLangOpts,
2873 Buffer->getBufferStart(),
2874 Buffer->getBufferStart() + (Offset ? *Offset : 0),
2875 Buffer->getBufferEnd());
2876 SourceLocation Start = L.getSourceLocation();
2877 ModuleMapParser Parser(L, SourceMgr, Target, Diags, *this, File, Dir,
2878 IsSystem);
2879 bool Result = Parser.parseModuleMapFile();
2880 ParsedModuleMap[File] = Result;
2881
2882 if (Offset) {
2883 auto Loc = SourceMgr.getDecomposedLoc(Parser.getLocation());
2884 assert(Loc.first == ID && "stopped in a different file?")(static_cast <bool> (Loc.first == ID && "stopped in a different file?"
) ? void (0) : __assert_fail ("Loc.first == ID && \"stopped in a different file?\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Lex/ModuleMap.cpp"
, 2884, __extension__ __PRETTY_FUNCTION__))
;
2885 *Offset = Loc.second;
2886 }
2887
2888 // Notify callbacks that we parsed it.
2889 for (const auto &Cb : Callbacks)
2890 Cb->moduleMapFileRead(Start, *File, IsSystem);
2891
2892 return Result;
2893}