Bug Summary

File:tools/clang/lib/Frontend/CompilerInstance.cpp
Warning:line 1604, column 5
Use of memory after it is freed

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 CompilerInstance.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~svn338205/build-llvm/tools/clang/lib/Frontend -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn338205/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/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/lib/gcc/x86_64-linux-gnu/8/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-class-memaccess -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/lib/Frontend -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-07-29-043837-17923-1 -x c++ /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp -faddrsig

/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp

1//===--- CompilerInstance.cpp ---------------------------------------------===//
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#include "clang/Frontend/CompilerInstance.h"
11#include "clang/AST/ASTConsumer.h"
12#include "clang/AST/ASTContext.h"
13#include "clang/AST/Decl.h"
14#include "clang/Basic/CharInfo.h"
15#include "clang/Basic/Diagnostic.h"
16#include "clang/Basic/FileManager.h"
17#include "clang/Basic/MemoryBufferCache.h"
18#include "clang/Basic/SourceManager.h"
19#include "clang/Basic/Stack.h"
20#include "clang/Basic/TargetInfo.h"
21#include "clang/Basic/Version.h"
22#include "clang/Config/config.h"
23#include "clang/Frontend/ChainedDiagnosticConsumer.h"
24#include "clang/Frontend/FrontendAction.h"
25#include "clang/Frontend/FrontendActions.h"
26#include "clang/Frontend/FrontendDiagnostic.h"
27#include "clang/Frontend/LogDiagnosticPrinter.h"
28#include "clang/Frontend/SerializedDiagnosticPrinter.h"
29#include "clang/Frontend/TextDiagnosticPrinter.h"
30#include "clang/Frontend/Utils.h"
31#include "clang/Frontend/VerifyDiagnosticConsumer.h"
32#include "clang/Lex/HeaderSearch.h"
33#include "clang/Lex/PTHManager.h"
34#include "clang/Lex/Preprocessor.h"
35#include "clang/Lex/PreprocessorOptions.h"
36#include "clang/Sema/CodeCompleteConsumer.h"
37#include "clang/Sema/Sema.h"
38#include "clang/Serialization/ASTReader.h"
39#include "clang/Serialization/GlobalModuleIndex.h"
40#include "llvm/ADT/Statistic.h"
41#include "llvm/Support/CrashRecoveryContext.h"
42#include "llvm/Support/Errc.h"
43#include "llvm/Support/FileSystem.h"
44#include "llvm/Support/Host.h"
45#include "llvm/Support/LockFileManager.h"
46#include "llvm/Support/MemoryBuffer.h"
47#include "llvm/Support/Path.h"
48#include "llvm/Support/Program.h"
49#include "llvm/Support/Signals.h"
50#include "llvm/Support/Timer.h"
51#include "llvm/Support/raw_ostream.h"
52#include <sys/stat.h>
53#include <system_error>
54#include <time.h>
55#include <utility>
56
57using namespace clang;
58
59CompilerInstance::CompilerInstance(
60 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
61 MemoryBufferCache *SharedPCMCache)
62 : ModuleLoader(/* BuildingModule = */ SharedPCMCache),
63 Invocation(new CompilerInvocation()),
64 PCMCache(SharedPCMCache ? SharedPCMCache : new MemoryBufferCache),
65 ThePCHContainerOperations(std::move(PCHContainerOps)) {
66 // Don't allow this to invalidate buffers in use by others.
67 if (SharedPCMCache)
68 getPCMCache().finalizeCurrentBuffers();
69}
70
71CompilerInstance::~CompilerInstance() {
72 assert(OutputFiles.empty() && "Still output files in flight?")(static_cast <bool> (OutputFiles.empty() && "Still output files in flight?"
) ? void (0) : __assert_fail ("OutputFiles.empty() && \"Still output files in flight?\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 72, __extension__ __PRETTY_FUNCTION__))
;
73}
74
75void CompilerInstance::setInvocation(
76 std::shared_ptr<CompilerInvocation> Value) {
77 Invocation = std::move(Value);
78}
79
80bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
81 return (BuildGlobalModuleIndex ||
82 (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
83 getFrontendOpts().GenerateGlobalModuleIndex)) &&
84 !ModuleBuildFailed;
85}
86
87void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
88 Diagnostics = Value;
89}
90
91void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; }
92void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; }
93
94void CompilerInstance::setFileManager(FileManager *Value) {
95 FileMgr = Value;
96 if (Value)
97 VirtualFileSystem = Value->getVirtualFileSystem();
98 else
99 VirtualFileSystem.reset();
100}
101
102void CompilerInstance::setSourceManager(SourceManager *Value) {
103 SourceMgr = Value;
104}
105
106void CompilerInstance::setPreprocessor(std::shared_ptr<Preprocessor> Value) {
107 PP = std::move(Value);
108}
109
110void CompilerInstance::setASTContext(ASTContext *Value) {
111 Context = Value;
112
113 if (Context && Consumer)
114 getASTConsumer().Initialize(getASTContext());
115}
116
117void CompilerInstance::setSema(Sema *S) {
118 TheSema.reset(S);
119}
120
121void CompilerInstance::setASTConsumer(std::unique_ptr<ASTConsumer> Value) {
122 Consumer = std::move(Value);
123
124 if (Context && Consumer)
125 getASTConsumer().Initialize(getASTContext());
126}
127
128void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
129 CompletionConsumer.reset(Value);
130}
131
132std::unique_ptr<Sema> CompilerInstance::takeSema() {
133 return std::move(TheSema);
134}
135
136IntrusiveRefCntPtr<ASTReader> CompilerInstance::getModuleManager() const {
137 return ModuleManager;
138}
139void CompilerInstance::setModuleManager(IntrusiveRefCntPtr<ASTReader> Reader) {
140 assert(PCMCache.get() == &Reader->getModuleManager().getPCMCache() &&(static_cast <bool> (PCMCache.get() == &Reader->
getModuleManager().getPCMCache() && "Expected ASTReader to use the same PCM cache"
) ? void (0) : __assert_fail ("PCMCache.get() == &Reader->getModuleManager().getPCMCache() && \"Expected ASTReader to use the same PCM cache\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 141, __extension__ __PRETTY_FUNCTION__))
141 "Expected ASTReader to use the same PCM cache")(static_cast <bool> (PCMCache.get() == &Reader->
getModuleManager().getPCMCache() && "Expected ASTReader to use the same PCM cache"
) ? void (0) : __assert_fail ("PCMCache.get() == &Reader->getModuleManager().getPCMCache() && \"Expected ASTReader to use the same PCM cache\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 141, __extension__ __PRETTY_FUNCTION__))
;
142 ModuleManager = std::move(Reader);
143}
144
145std::shared_ptr<ModuleDependencyCollector>
146CompilerInstance::getModuleDepCollector() const {
147 return ModuleDepCollector;
148}
149
150void CompilerInstance::setModuleDepCollector(
151 std::shared_ptr<ModuleDependencyCollector> Collector) {
152 ModuleDepCollector = std::move(Collector);
153}
154
155static void collectHeaderMaps(const HeaderSearch &HS,
156 std::shared_ptr<ModuleDependencyCollector> MDC) {
157 SmallVector<std::string, 4> HeaderMapFileNames;
158 HS.getHeaderMapFileNames(HeaderMapFileNames);
159 for (auto &Name : HeaderMapFileNames)
160 MDC->addFile(Name);
161}
162
163static void collectIncludePCH(CompilerInstance &CI,
164 std::shared_ptr<ModuleDependencyCollector> MDC) {
165 const PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
166 if (PPOpts.ImplicitPCHInclude.empty())
167 return;
168
169 StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
170 FileManager &FileMgr = CI.getFileManager();
171 const DirectoryEntry *PCHDir = FileMgr.getDirectory(PCHInclude);
172 if (!PCHDir) {
173 MDC->addFile(PCHInclude);
174 return;
175 }
176
177 std::error_code EC;
178 SmallString<128> DirNative;
179 llvm::sys::path::native(PCHDir->getName(), DirNative);
180 vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
181 SimpleASTReaderListener Validator(CI.getPreprocessor());
182 for (vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd;
183 Dir != DirEnd && !EC; Dir.increment(EC)) {
184 // Check whether this is an AST file. ASTReader::isAcceptableASTFile is not
185 // used here since we're not interested in validating the PCH at this time,
186 // but only to check whether this is a file containing an AST.
187 if (!ASTReader::readASTFileControlBlock(
188 Dir->getName(), FileMgr, CI.getPCHContainerReader(),
189 /*FindModuleFileExtensions=*/false, Validator,
190 /*ValidateDiagnosticOptions=*/false))
191 MDC->addFile(Dir->getName());
192 }
193}
194
195static void collectVFSEntries(CompilerInstance &CI,
196 std::shared_ptr<ModuleDependencyCollector> MDC) {
197 if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
198 return;
199
200 // Collect all VFS found.
201 SmallVector<vfs::YAMLVFSEntry, 16> VFSEntries;
202 for (const std::string &VFSFile : CI.getHeaderSearchOpts().VFSOverlayFiles) {
203 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
204 llvm::MemoryBuffer::getFile(VFSFile);
205 if (!Buffer)
206 return;
207 vfs::collectVFSFromYAML(std::move(Buffer.get()), /*DiagHandler*/ nullptr,
208 VFSFile, VFSEntries);
209 }
210
211 for (auto &E : VFSEntries)
212 MDC->addFile(E.VPath, E.RPath);
213}
214
215// Diagnostics
216static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
217 const CodeGenOptions *CodeGenOpts,
218 DiagnosticsEngine &Diags) {
219 std::error_code EC;
220 std::unique_ptr<raw_ostream> StreamOwner;
221 raw_ostream *OS = &llvm::errs();
222 if (DiagOpts->DiagnosticLogFile != "-") {
223 // Create the output stream.
224 auto FileOS = llvm::make_unique<llvm::raw_fd_ostream>(
225 DiagOpts->DiagnosticLogFile, EC,
226 llvm::sys::fs::F_Append | llvm::sys::fs::F_Text);
227 if (EC) {
228 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
229 << DiagOpts->DiagnosticLogFile << EC.message();
230 } else {
231 FileOS->SetUnbuffered();
232 OS = FileOS.get();
233 StreamOwner = std::move(FileOS);
234 }
235 }
236
237 // Chain in the diagnostic client which will log the diagnostics.
238 auto Logger = llvm::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
239 std::move(StreamOwner));
240 if (CodeGenOpts)
241 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
242 assert(Diags.ownsClient())(static_cast <bool> (Diags.ownsClient()) ? void (0) : __assert_fail
("Diags.ownsClient()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 242, __extension__ __PRETTY_FUNCTION__))
;
243 Diags.setClient(
244 new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger)));
245}
246
247static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
248 DiagnosticsEngine &Diags,
249 StringRef OutputFile) {
250 auto SerializedConsumer =
251 clang::serialized_diags::create(OutputFile, DiagOpts);
252
253 if (Diags.ownsClient()) {
254 Diags.setClient(new ChainedDiagnosticConsumer(
255 Diags.takeClient(), std::move(SerializedConsumer)));
256 } else {
257 Diags.setClient(new ChainedDiagnosticConsumer(
258 Diags.getClient(), std::move(SerializedConsumer)));
259 }
260}
261
262void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
263 bool ShouldOwnClient) {
264 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
265 ShouldOwnClient, &getCodeGenOpts());
266}
267
268IntrusiveRefCntPtr<DiagnosticsEngine>
269CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
270 DiagnosticConsumer *Client,
271 bool ShouldOwnClient,
272 const CodeGenOptions *CodeGenOpts) {
273 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
274 IntrusiveRefCntPtr<DiagnosticsEngine>
275 Diags(new DiagnosticsEngine(DiagID, Opts));
276
277 // Create the diagnostic client for reporting errors or for
278 // implementing -verify.
279 if (Client) {
280 Diags->setClient(Client, ShouldOwnClient);
281 } else
282 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
283
284 // Chain in -verify checker, if requested.
285 if (Opts->VerifyDiagnostics)
286 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
287
288 // Chain in -diagnostic-log-file dumper, if requested.
289 if (!Opts->DiagnosticLogFile.empty())
290 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
291
292 if (!Opts->DiagnosticSerializationFile.empty())
293 SetupSerializedDiagnostics(Opts, *Diags,
294 Opts->DiagnosticSerializationFile);
295
296 // Configure our handling of diagnostics.
297 ProcessWarningOptions(*Diags, *Opts);
298
299 return Diags;
300}
301
302// File Manager
303
304FileManager *CompilerInstance::createFileManager() {
305 if (!hasVirtualFileSystem()) {
306 IntrusiveRefCntPtr<vfs::FileSystem> VFS =
307 createVFSFromCompilerInvocation(getInvocation(), getDiagnostics());
308 setVirtualFileSystem(VFS);
309 }
310 FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem);
311 return FileMgr.get();
312}
313
314// Source Manager
315
316void CompilerInstance::createSourceManager(FileManager &FileMgr) {
317 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
318}
319
320// Initialize the remapping of files to alternative contents, e.g.,
321// those specified through other files.
322static void InitializeFileRemapping(DiagnosticsEngine &Diags,
323 SourceManager &SourceMgr,
324 FileManager &FileMgr,
325 const PreprocessorOptions &InitOpts) {
326 // Remap files in the source manager (with buffers).
327 for (const auto &RB : InitOpts.RemappedFileBuffers) {
328 // Create the file entry for the file that we're mapping from.
329 const FileEntry *FromFile =
330 FileMgr.getVirtualFile(RB.first, RB.second->getBufferSize(), 0);
331 if (!FromFile) {
332 Diags.Report(diag::err_fe_remap_missing_from_file) << RB.first;
333 if (!InitOpts.RetainRemappedFileBuffers)
334 delete RB.second;
335 continue;
336 }
337
338 // Override the contents of the "from" file with the contents of
339 // the "to" file.
340 SourceMgr.overrideFileContents(FromFile, RB.second,
341 InitOpts.RetainRemappedFileBuffers);
342 }
343
344 // Remap files in the source manager (with other files).
345 for (const auto &RF : InitOpts.RemappedFiles) {
346 // Find the file that we're mapping to.
347 const FileEntry *ToFile = FileMgr.getFile(RF.second);
348 if (!ToFile) {
349 Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
350 continue;
351 }
352
353 // Create the file entry for the file that we're mapping from.
354 const FileEntry *FromFile =
355 FileMgr.getVirtualFile(RF.first, ToFile->getSize(), 0);
356 if (!FromFile) {
357 Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first;
358 continue;
359 }
360
361 // Override the contents of the "from" file with the contents of
362 // the "to" file.
363 SourceMgr.overrideFileContents(FromFile, ToFile);
364 }
365
366 SourceMgr.setOverridenFilesKeepOriginalName(
367 InitOpts.RemappedFilesKeepOriginalName);
368}
369
370// Preprocessor
371
372void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
373 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
374
375 // Create a PTH manager if we are using some form of a token cache.
376 PTHManager *PTHMgr = nullptr;
377 if (!PPOpts.TokenCache.empty())
378 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
379
380 // Create the Preprocessor.
381 HeaderSearch *HeaderInfo =
382 new HeaderSearch(getHeaderSearchOptsPtr(), getSourceManager(),
383 getDiagnostics(), getLangOpts(), &getTarget());
384 PP = std::make_shared<Preprocessor>(
385 Invocation->getPreprocessorOptsPtr(), getDiagnostics(), getLangOpts(),
386 getSourceManager(), getPCMCache(), *HeaderInfo, *this, PTHMgr,
387 /*OwnsHeaderSearch=*/true, TUKind);
388 getTarget().adjust(getLangOpts());
389 PP->Initialize(getTarget(), getAuxTarget());
390
391 // Note that this is different then passing PTHMgr to Preprocessor's ctor.
392 // That argument is used as the IdentifierInfoLookup argument to
393 // IdentifierTable's ctor.
394 if (PTHMgr) {
395 PTHMgr->setPreprocessor(&*PP);
396 PP->setPTHManager(PTHMgr);
397 }
398
399 if (PPOpts.DetailedRecord)
400 PP->createPreprocessingRecord();
401
402 // Apply remappings to the source manager.
403 InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
404 PP->getFileManager(), PPOpts);
405
406 // Predefine macros and configure the preprocessor.
407 InitializePreprocessor(*PP, PPOpts, getPCHContainerReader(),
408 getFrontendOpts());
409
410 // Initialize the header search object. In CUDA compilations, we use the aux
411 // triple (the host triple) to initialize our header search, since we need to
412 // find the host headers in order to compile the CUDA code.
413 const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple();
414 if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&
415 PP->getAuxTargetInfo())
416 HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();
417
418 ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
419 PP->getLangOpts(), *HeaderSearchTriple);
420
421 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
422
423 if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules)
424 PP->getHeaderSearchInfo().setModuleCachePath(getSpecificModuleCachePath());
425
426 // Handle generating dependencies, if requested.
427 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
428 if (!DepOpts.OutputFile.empty())
429 TheDependencyFileGenerator.reset(
430 DependencyFileGenerator::CreateAndAttachToPreprocessor(*PP, DepOpts));
431 if (!DepOpts.DOTOutputFile.empty())
432 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
433 getHeaderSearchOpts().Sysroot);
434
435 // If we don't have a collector, but we are collecting module dependencies,
436 // then we're the top level compiler instance and need to create one.
437 if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) {
438 ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
439 DepOpts.ModuleDependencyOutputDir);
440 }
441
442 // If there is a module dep collector, register with other dep collectors
443 // and also (a) collect header maps and (b) TODO: input vfs overlay files.
444 if (ModuleDepCollector) {
445 addDependencyCollector(ModuleDepCollector);
446 collectHeaderMaps(PP->getHeaderSearchInfo(), ModuleDepCollector);
447 collectIncludePCH(*this, ModuleDepCollector);
448 collectVFSEntries(*this, ModuleDepCollector);
449 }
450
451 for (auto &Listener : DependencyCollectors)
452 Listener->attachToPreprocessor(*PP);
453
454 // Handle generating header include information, if requested.
455 if (DepOpts.ShowHeaderIncludes)
456 AttachHeaderIncludeGen(*PP, DepOpts);
457 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
458 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
459 if (OutputPath == "-")
460 OutputPath = "";
461 AttachHeaderIncludeGen(*PP, DepOpts,
462 /*ShowAllHeaders=*/true, OutputPath,
463 /*ShowDepth=*/false);
464 }
465
466 if (DepOpts.ShowIncludesDest != ShowIncludesDestination::None) {
467 AttachHeaderIncludeGen(*PP, DepOpts,
468 /*ShowAllHeaders=*/true, /*OutputPath=*/"",
469 /*ShowDepth=*/true, /*MSStyle=*/true);
470 }
471}
472
473std::string CompilerInstance::getSpecificModuleCachePath() {
474 // Set up the module path, including the hash for the
475 // module-creation options.
476 SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath);
477 if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash)
478 llvm::sys::path::append(SpecificModuleCache,
479 getInvocation().getModuleHash());
480 return SpecificModuleCache.str();
481}
482
483// ASTContext
484
485void CompilerInstance::createASTContext() {
486 Preprocessor &PP = getPreprocessor();
487 auto *Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
488 PP.getIdentifierTable(), PP.getSelectorTable(),
489 PP.getBuiltinInfo());
490 Context->InitBuiltinTypes(getTarget(), getAuxTarget());
491 setASTContext(Context);
492}
493
494// ExternalASTSource
495
496void CompilerInstance::createPCHExternalASTSource(
497 StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors,
498 void *DeserializationListener, bool OwnDeserializationListener) {
499 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
500 ModuleManager = createPCHExternalASTSource(
501 Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation,
502 AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(),
503 getPCHContainerReader(),
504 getFrontendOpts().ModuleFileExtensions,
505 TheDependencyFileGenerator.get(),
506 DependencyCollectors,
507 DeserializationListener,
508 OwnDeserializationListener, Preamble,
509 getFrontendOpts().UseGlobalModuleIndex);
510}
511
512IntrusiveRefCntPtr<ASTReader> CompilerInstance::createPCHExternalASTSource(
513 StringRef Path, StringRef Sysroot, bool DisablePCHValidation,
514 bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context,
515 const PCHContainerReader &PCHContainerRdr,
516 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
517 DependencyFileGenerator *DependencyFile,
518 ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
519 void *DeserializationListener, bool OwnDeserializationListener,
520 bool Preamble, bool UseGlobalModuleIndex) {
521 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
522
523 IntrusiveRefCntPtr<ASTReader> Reader(new ASTReader(
524 PP, &Context, PCHContainerRdr, Extensions,
525 Sysroot.empty() ? "" : Sysroot.data(), DisablePCHValidation,
526 AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/ false,
527 HSOpts.ModulesValidateSystemHeaders, UseGlobalModuleIndex));
528
529 // We need the external source to be set up before we read the AST, because
530 // eagerly-deserialized declarations may use it.
531 Context.setExternalSource(Reader.get());
532
533 Reader->setDeserializationListener(
534 static_cast<ASTDeserializationListener *>(DeserializationListener),
535 /*TakeOwnership=*/OwnDeserializationListener);
536
537 if (DependencyFile)
538 DependencyFile->AttachToASTReader(*Reader);
539 for (auto &Listener : DependencyCollectors)
540 Listener->attachToASTReader(*Reader);
541
542 switch (Reader->ReadAST(Path,
543 Preamble ? serialization::MK_Preamble
544 : serialization::MK_PCH,
545 SourceLocation(),
546 ASTReader::ARR_None)) {
547 case ASTReader::Success:
548 // Set the predefines buffer as suggested by the PCH reader. Typically, the
549 // predefines buffer will be empty.
550 PP.setPredefines(Reader->getSuggestedPredefines());
551 return Reader;
552
553 case ASTReader::Failure:
554 // Unrecoverable failure: don't even try to process the input file.
555 break;
556
557 case ASTReader::Missing:
558 case ASTReader::OutOfDate:
559 case ASTReader::VersionMismatch:
560 case ASTReader::ConfigurationMismatch:
561 case ASTReader::HadErrors:
562 // No suitable PCH file could be found. Return an error.
563 break;
564 }
565
566 Context.setExternalSource(nullptr);
567 return nullptr;
568}
569
570// Code Completion
571
572static bool EnableCodeCompletion(Preprocessor &PP,
573 StringRef Filename,
574 unsigned Line,
575 unsigned Column) {
576 // Tell the source manager to chop off the given file at a specific
577 // line and column.
578 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
579 if (!Entry) {
580 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
581 << Filename;
582 return true;
583 }
584
585 // Truncate the named file at the given line/column.
586 PP.SetCodeCompletionPoint(Entry, Line, Column);
587 return false;
588}
589
590void CompilerInstance::createCodeCompletionConsumer() {
591 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
592 if (!CompletionConsumer) {
593 setCodeCompletionConsumer(
594 createCodeCompletionConsumer(getPreprocessor(),
595 Loc.FileName, Loc.Line, Loc.Column,
596 getFrontendOpts().CodeCompleteOpts,
597 llvm::outs()));
598 if (!CompletionConsumer)
599 return;
600 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
601 Loc.Line, Loc.Column)) {
602 setCodeCompletionConsumer(nullptr);
603 return;
604 }
605
606 if (CompletionConsumer->isOutputBinary() &&
607 llvm::sys::ChangeStdoutToBinary()) {
608 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
609 setCodeCompletionConsumer(nullptr);
610 }
611}
612
613void CompilerInstance::createFrontendTimer() {
614 FrontendTimerGroup.reset(
615 new llvm::TimerGroup("frontend", "Clang front-end time report"));
616 FrontendTimer.reset(
617 new llvm::Timer("frontend", "Clang front-end timer",
618 *FrontendTimerGroup));
619}
620
621CodeCompleteConsumer *
622CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
623 StringRef Filename,
624 unsigned Line,
625 unsigned Column,
626 const CodeCompleteOptions &Opts,
627 raw_ostream &OS) {
628 if (EnableCodeCompletion(PP, Filename, Line, Column))
629 return nullptr;
630
631 // Set up the creation routine for code-completion.
632 return new PrintingCodeCompleteConsumer(Opts, OS);
633}
634
635void CompilerInstance::createSema(TranslationUnitKind TUKind,
636 CodeCompleteConsumer *CompletionConsumer) {
637 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
638 TUKind, CompletionConsumer));
639 // Attach the external sema source if there is any.
640 if (ExternalSemaSrc) {
641 TheSema->addExternalSource(ExternalSemaSrc.get());
642 ExternalSemaSrc->InitializeSema(*TheSema);
643 }
644}
645
646// Output Files
647
648void CompilerInstance::addOutputFile(OutputFile &&OutFile) {
649 OutputFiles.push_back(std::move(OutFile));
650}
651
652void CompilerInstance::clearOutputFiles(bool EraseFiles) {
653 for (OutputFile &OF : OutputFiles) {
654 if (!OF.TempFilename.empty()) {
655 if (EraseFiles) {
656 llvm::sys::fs::remove(OF.TempFilename);
657 } else {
658 SmallString<128> NewOutFile(OF.Filename);
659
660 // If '-working-directory' was passed, the output filename should be
661 // relative to that.
662 FileMgr->FixupRelativePath(NewOutFile);
663 if (std::error_code ec =
664 llvm::sys::fs::rename(OF.TempFilename, NewOutFile)) {
665 getDiagnostics().Report(diag::err_unable_to_rename_temp)
666 << OF.TempFilename << OF.Filename << ec.message();
667
668 llvm::sys::fs::remove(OF.TempFilename);
669 }
670 }
671 } else if (!OF.Filename.empty() && EraseFiles)
672 llvm::sys::fs::remove(OF.Filename);
673 }
674 OutputFiles.clear();
675 if (DeleteBuiltModules) {
676 for (auto &Module : BuiltModules)
677 llvm::sys::fs::remove(Module.second);
678 BuiltModules.clear();
679 }
680 NonSeekStream.reset();
681}
682
683std::unique_ptr<raw_pwrite_stream>
684CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile,
685 StringRef Extension) {
686 return createOutputFile(getFrontendOpts().OutputFile, Binary,
687 /*RemoveFileOnSignal=*/true, InFile, Extension,
688 /*UseTemporary=*/true);
689}
690
691std::unique_ptr<raw_pwrite_stream> CompilerInstance::createNullOutputFile() {
692 return llvm::make_unique<llvm::raw_null_ostream>();
693}
694
695std::unique_ptr<raw_pwrite_stream>
696CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
697 bool RemoveFileOnSignal, StringRef InFile,
698 StringRef Extension, bool UseTemporary,
699 bool CreateMissingDirectories) {
700 std::string OutputPathName, TempPathName;
701 std::error_code EC;
702 std::unique_ptr<raw_pwrite_stream> OS = createOutputFile(
703 OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
704 UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
705 if (!OS) {
706 getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath
707 << EC.message();
708 return nullptr;
709 }
710
711 // Add the output file -- but don't try to remove "-", since this means we are
712 // using stdin.
713 addOutputFile(
714 OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName));
715
716 return OS;
717}
718
719std::unique_ptr<llvm::raw_pwrite_stream> CompilerInstance::createOutputFile(
720 StringRef OutputPath, std::error_code &Error, bool Binary,
721 bool RemoveFileOnSignal, StringRef InFile, StringRef Extension,
722 bool UseTemporary, bool CreateMissingDirectories,
723 std::string *ResultPathName, std::string *TempPathName) {
724 assert((!CreateMissingDirectories || UseTemporary) &&(static_cast <bool> ((!CreateMissingDirectories || UseTemporary
) && "CreateMissingDirectories is only allowed when using temporary files"
) ? void (0) : __assert_fail ("(!CreateMissingDirectories || UseTemporary) && \"CreateMissingDirectories is only allowed when using temporary files\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 725, __extension__ __PRETTY_FUNCTION__))
725 "CreateMissingDirectories is only allowed when using temporary files")(static_cast <bool> ((!CreateMissingDirectories || UseTemporary
) && "CreateMissingDirectories is only allowed when using temporary files"
) ? void (0) : __assert_fail ("(!CreateMissingDirectories || UseTemporary) && \"CreateMissingDirectories is only allowed when using temporary files\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 725, __extension__ __PRETTY_FUNCTION__))
;
726
727 std::string OutFile, TempFile;
728 if (!OutputPath.empty()) {
729 OutFile = OutputPath;
730 } else if (InFile == "-") {
731 OutFile = "-";
732 } else if (!Extension.empty()) {
733 SmallString<128> Path(InFile);
734 llvm::sys::path::replace_extension(Path, Extension);
735 OutFile = Path.str();
736 } else {
737 OutFile = "-";
738 }
739
740 std::unique_ptr<llvm::raw_fd_ostream> OS;
741 std::string OSFile;
742
743 if (UseTemporary) {
744 if (OutFile == "-")
745 UseTemporary = false;
746 else {
747 llvm::sys::fs::file_status Status;
748 llvm::sys::fs::status(OutputPath, Status);
749 if (llvm::sys::fs::exists(Status)) {
750 // Fail early if we can't write to the final destination.
751 if (!llvm::sys::fs::can_write(OutputPath)) {
752 Error = make_error_code(llvm::errc::operation_not_permitted);
753 return nullptr;
754 }
755
756 // Don't use a temporary if the output is a special file. This handles
757 // things like '-o /dev/null'
758 if (!llvm::sys::fs::is_regular_file(Status))
759 UseTemporary = false;
760 }
761 }
762 }
763
764 if (UseTemporary) {
765 // Create a temporary file.
766 // Insert -%%%%%%%% before the extension (if any), and because some tools
767 // (noticeable, clang's own GlobalModuleIndex.cpp) glob for build
768 // artifacts, also append .tmp.
769 StringRef OutputExtension = llvm::sys::path::extension(OutFile);
770 SmallString<128> TempPath =
771 StringRef(OutFile).drop_back(OutputExtension.size());
772 TempPath += "-%%%%%%%%";
773 TempPath += OutputExtension;
774 TempPath += ".tmp";
775 int fd;
776 std::error_code EC =
777 llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
778
779 if (CreateMissingDirectories &&
780 EC == llvm::errc::no_such_file_or_directory) {
781 StringRef Parent = llvm::sys::path::parent_path(OutputPath);
782 EC = llvm::sys::fs::create_directories(Parent);
783 if (!EC) {
784 EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
785 }
786 }
787
788 if (!EC) {
789 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
790 OSFile = TempFile = TempPath.str();
791 }
792 // If we failed to create the temporary, fallback to writing to the file
793 // directly. This handles the corner case where we cannot write to the
794 // directory, but can write to the file.
795 }
796
797 if (!OS) {
798 OSFile = OutFile;
799 OS.reset(new llvm::raw_fd_ostream(
800 OSFile, Error,
801 (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
802 if (Error)
803 return nullptr;
804 }
805
806 // Make sure the out stream file gets removed if we crash.
807 if (RemoveFileOnSignal)
808 llvm::sys::RemoveFileOnSignal(OSFile);
809
810 if (ResultPathName)
811 *ResultPathName = OutFile;
812 if (TempPathName)
813 *TempPathName = TempFile;
814
815 if (!Binary || OS->supportsSeeking())
816 return std::move(OS);
817
818 auto B = llvm::make_unique<llvm::buffer_ostream>(*OS);
819 assert(!NonSeekStream)(static_cast <bool> (!NonSeekStream) ? void (0) : __assert_fail
("!NonSeekStream", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 819, __extension__ __PRETTY_FUNCTION__))
;
820 NonSeekStream = std::move(OS);
821 return std::move(B);
822}
823
824// Initialization Utilities
825
826bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
827 return InitializeSourceManager(
828 Input, getDiagnostics(), getFileManager(), getSourceManager(),
829 hasPreprocessor() ? &getPreprocessor().getHeaderSearchInfo() : nullptr,
830 getDependencyOutputOpts(), getFrontendOpts());
831}
832
833// static
834bool CompilerInstance::InitializeSourceManager(
835 const FrontendInputFile &Input, DiagnosticsEngine &Diags,
836 FileManager &FileMgr, SourceManager &SourceMgr, HeaderSearch *HS,
837 DependencyOutputOptions &DepOpts, const FrontendOptions &Opts) {
838 SrcMgr::CharacteristicKind Kind =
839 Input.getKind().getFormat() == InputKind::ModuleMap
840 ? Input.isSystem() ? SrcMgr::C_System_ModuleMap
841 : SrcMgr::C_User_ModuleMap
842 : Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
843
844 if (Input.isBuffer()) {
845 SourceMgr.setMainFileID(SourceMgr.createFileID(SourceManager::Unowned,
846 Input.getBuffer(), Kind));
847 assert(SourceMgr.getMainFileID().isValid() &&(static_cast <bool> (SourceMgr.getMainFileID().isValid(
) && "Couldn't establish MainFileID!") ? void (0) : __assert_fail
("SourceMgr.getMainFileID().isValid() && \"Couldn't establish MainFileID!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 848, __extension__ __PRETTY_FUNCTION__))
848 "Couldn't establish MainFileID!")(static_cast <bool> (SourceMgr.getMainFileID().isValid(
) && "Couldn't establish MainFileID!") ? void (0) : __assert_fail
("SourceMgr.getMainFileID().isValid() && \"Couldn't establish MainFileID!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 848, __extension__ __PRETTY_FUNCTION__))
;
849 return true;
850 }
851
852 StringRef InputFile = Input.getFile();
853
854 // Figure out where to get and map in the main file.
855 if (InputFile != "-") {
856 const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
857 if (!File) {
858 Diags.Report(diag::err_fe_error_reading) << InputFile;
859 return false;
860 }
861
862 // The natural SourceManager infrastructure can't currently handle named
863 // pipes, but we would at least like to accept them for the main
864 // file. Detect them here, read them with the volatile flag so FileMgr will
865 // pick up the correct size, and simply override their contents as we do for
866 // STDIN.
867 if (File->isNamedPipe()) {
868 auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true);
869 if (MB) {
870 // Create a new virtual file that will have the correct size.
871 File = FileMgr.getVirtualFile(InputFile, (*MB)->getBufferSize(), 0);
872 SourceMgr.overrideFileContents(File, std::move(*MB));
873 } else {
874 Diags.Report(diag::err_cannot_open_file) << InputFile
875 << MB.getError().message();
876 return false;
877 }
878 }
879
880 SourceMgr.setMainFileID(
881 SourceMgr.createFileID(File, SourceLocation(), Kind));
882 } else {
883 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> SBOrErr =
884 llvm::MemoryBuffer::getSTDIN();
885 if (std::error_code EC = SBOrErr.getError()) {
886 Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
887 return false;
888 }
889 std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
890
891 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
892 SB->getBufferSize(), 0);
893 SourceMgr.setMainFileID(
894 SourceMgr.createFileID(File, SourceLocation(), Kind));
895 SourceMgr.overrideFileContents(File, std::move(SB));
896 }
897
898 assert(SourceMgr.getMainFileID().isValid() &&(static_cast <bool> (SourceMgr.getMainFileID().isValid(
) && "Couldn't establish MainFileID!") ? void (0) : __assert_fail
("SourceMgr.getMainFileID().isValid() && \"Couldn't establish MainFileID!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 899, __extension__ __PRETTY_FUNCTION__))
899 "Couldn't establish MainFileID!")(static_cast <bool> (SourceMgr.getMainFileID().isValid(
) && "Couldn't establish MainFileID!") ? void (0) : __assert_fail
("SourceMgr.getMainFileID().isValid() && \"Couldn't establish MainFileID!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 899, __extension__ __PRETTY_FUNCTION__))
;
900 return true;
901}
902
903// High-Level Operations
904
905bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
906 assert(hasDiagnostics() && "Diagnostics engine is not initialized!")(static_cast <bool> (hasDiagnostics() && "Diagnostics engine is not initialized!"
) ? void (0) : __assert_fail ("hasDiagnostics() && \"Diagnostics engine is not initialized!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 906, __extension__ __PRETTY_FUNCTION__))
;
907 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!")(static_cast <bool> (!getFrontendOpts().ShowHelp &&
"Client must handle '-help'!") ? void (0) : __assert_fail ("!getFrontendOpts().ShowHelp && \"Client must handle '-help'!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 907, __extension__ __PRETTY_FUNCTION__))
;
908 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!")(static_cast <bool> (!getFrontendOpts().ShowVersion &&
"Client must handle '-version'!") ? void (0) : __assert_fail
("!getFrontendOpts().ShowVersion && \"Client must handle '-version'!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 908, __extension__ __PRETTY_FUNCTION__))
;
909
910 // FIXME: Take this as an argument, once all the APIs we used have moved to
911 // taking it as an input instead of hard-coding llvm::errs.
912 raw_ostream &OS = llvm::errs();
913
914 // Create the target instance.
915 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(),
916 getInvocation().TargetOpts));
917 if (!hasTarget())
918 return false;
919
920 // Create TargetInfo for the other side of CUDA and OpenMP compilation.
921 if ((getLangOpts().CUDA || getLangOpts().OpenMPIsDevice) &&
922 !getFrontendOpts().AuxTriple.empty()) {
923 auto TO = std::make_shared<TargetOptions>();
924 TO->Triple = getFrontendOpts().AuxTriple;
925 TO->HostTriple = getTarget().getTriple().str();
926 setAuxTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), TO));
927 }
928
929 // Inform the target of the language options.
930 //
931 // FIXME: We shouldn't need to do this, the target should be immutable once
932 // created. This complexity should be lifted elsewhere.
933 getTarget().adjust(getLangOpts());
934
935 // Adjust target options based on codegen options.
936 getTarget().adjustTargetOptions(getCodeGenOpts(), getTargetOpts());
937
938 // rewriter project will change target built-in bool type from its default.
939 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
940 getTarget().noSignedCharForObjCBool();
941
942 // Validate/process some options.
943 if (getHeaderSearchOpts().Verbose)
944 OS << "clang -cc1 version " CLANG_VERSION_STRING"7.0.0"
945 << " based upon " << BACKEND_PACKAGE_STRING"LLVM 7.0.0"
946 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
947
948 if (getFrontendOpts().ShowTimers)
949 createFrontendTimer();
950
951 if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty())
952 llvm::EnableStatistics(false);
953
954 for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
955 // Reset the ID tables if we are reusing the SourceManager and parsing
956 // regular files.
957 if (hasSourceManager() && !Act.isModelParsingAction())
958 getSourceManager().clearIDTables();
959
960 if (Act.BeginSourceFile(*this, FIF)) {
961 Act.Execute();
962 Act.EndSourceFile();
963 }
964 }
965
966 // Notify the diagnostic client that all files were processed.
967 getDiagnostics().getClient()->finish();
968
969 if (getDiagnosticOpts().ShowCarets) {
970 // We can have multiple diagnostics sharing one diagnostic client.
971 // Get the total number of warnings/errors from the client.
972 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
973 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
974
975 if (NumWarnings)
976 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
977 if (NumWarnings && NumErrors)
978 OS << " and ";
979 if (NumErrors)
980 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
981 if (NumWarnings || NumErrors) {
982 OS << " generated";
983 if (getLangOpts().CUDA) {
984 if (!getLangOpts().CUDAIsDevice) {
985 OS << " when compiling for host";
986 } else {
987 OS << " when compiling for " << getTargetOpts().CPU;
988 }
989 }
990 OS << ".\n";
991 }
992 }
993
994 if (getFrontendOpts().ShowStats) {
995 if (hasFileManager()) {
996 getFileManager().PrintStats();
997 OS << '\n';
998 }
999 llvm::PrintStatistics(OS);
1000 }
1001 StringRef StatsFile = getFrontendOpts().StatsFile;
1002 if (!StatsFile.empty()) {
1003 std::error_code EC;
1004 auto StatS = llvm::make_unique<llvm::raw_fd_ostream>(StatsFile, EC,
1005 llvm::sys::fs::F_Text);
1006 if (EC) {
1007 getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file)
1008 << StatsFile << EC.message();
1009 } else {
1010 llvm::PrintStatisticsJSON(*StatS);
1011 }
1012 }
1013
1014 return !getDiagnostics().getClient()->getNumErrors();
1015}
1016
1017/// Determine the appropriate source input kind based on language
1018/// options.
1019static InputKind::Language getLanguageFromOptions(const LangOptions &LangOpts) {
1020 if (LangOpts.OpenCL)
1021 return InputKind::OpenCL;
1022 if (LangOpts.CUDA)
1023 return InputKind::CUDA;
1024 if (LangOpts.ObjC1)
1025 return LangOpts.CPlusPlus ? InputKind::ObjCXX : InputKind::ObjC;
1026 return LangOpts.CPlusPlus ? InputKind::CXX : InputKind::C;
1027}
1028
1029/// Compile a module file for the given module, using the options
1030/// provided by the importing compiler instance. Returns true if the module
1031/// was built without errors.
1032static bool
1033compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
1034 StringRef ModuleName, FrontendInputFile Input,
1035 StringRef OriginalModuleMapFile, StringRef ModuleFileName,
1036 llvm::function_ref<void(CompilerInstance &)> PreBuildStep =
1037 [](CompilerInstance &) {},
1038 llvm::function_ref<void(CompilerInstance &)> PostBuildStep =
1039 [](CompilerInstance &) {}) {
1040 // Construct a compiler invocation for creating this module.
1041 auto Invocation =
1042 std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
1043
1044 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1045
1046 // For any options that aren't intended to affect how a module is built,
1047 // reset them to their default values.
1048 Invocation->getLangOpts()->resetNonModularOptions();
1049 PPOpts.resetNonModularOptions();
1050
1051 // Remove any macro definitions that are explicitly ignored by the module.
1052 // They aren't supposed to affect how the module is built anyway.
1053 HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
1054 PPOpts.Macros.erase(
1055 std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
1056 [&HSOpts](const std::pair<std::string, bool> &def) {
1057 StringRef MacroDef = def.first;
1058 return HSOpts.ModulesIgnoreMacros.count(
1059 llvm::CachedHashString(MacroDef.split('=').first)) > 0;
1060 }),
1061 PPOpts.Macros.end());
1062
1063 // If the original compiler invocation had -fmodule-name, pass it through.
1064 Invocation->getLangOpts()->ModuleName =
1065 ImportingInstance.getInvocation().getLangOpts()->ModuleName;
1066
1067 // Note the name of the module we're building.
1068 Invocation->getLangOpts()->CurrentModule = ModuleName;
1069
1070 // Make sure that the failed-module structure has been allocated in
1071 // the importing instance, and propagate the pointer to the newly-created
1072 // instance.
1073 PreprocessorOptions &ImportingPPOpts
1074 = ImportingInstance.getInvocation().getPreprocessorOpts();
1075 if (!ImportingPPOpts.FailedModules)
1076 ImportingPPOpts.FailedModules =
1077 std::make_shared<PreprocessorOptions::FailedModulesSet>();
1078 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
1079
1080 // If there is a module map file, build the module using the module map.
1081 // Set up the inputs/outputs so that we build the module from its umbrella
1082 // header.
1083 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
1084 FrontendOpts.OutputFile = ModuleFileName.str();
1085 FrontendOpts.DisableFree = false;
1086 FrontendOpts.GenerateGlobalModuleIndex = false;
1087 FrontendOpts.BuildingImplicitModule = true;
1088 FrontendOpts.OriginalModuleMap = OriginalModuleMapFile;
1089 // Force implicitly-built modules to hash the content of the module file.
1090 HSOpts.ModulesHashContent = true;
1091 FrontendOpts.Inputs = {Input};
1092
1093 // Don't free the remapped file buffers; they are owned by our caller.
1094 PPOpts.RetainRemappedFileBuffers = true;
1095
1096 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
1097 assert(ImportingInstance.getInvocation().getModuleHash() ==(static_cast <bool> (ImportingInstance.getInvocation().
getModuleHash() == Invocation->getModuleHash() && "Module hash mismatch!"
) ? void (0) : __assert_fail ("ImportingInstance.getInvocation().getModuleHash() == Invocation->getModuleHash() && \"Module hash mismatch!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1098, __extension__ __PRETTY_FUNCTION__))
1098 Invocation->getModuleHash() && "Module hash mismatch!")(static_cast <bool> (ImportingInstance.getInvocation().
getModuleHash() == Invocation->getModuleHash() && "Module hash mismatch!"
) ? void (0) : __assert_fail ("ImportingInstance.getInvocation().getModuleHash() == Invocation->getModuleHash() && \"Module hash mismatch!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1098, __extension__ __PRETTY_FUNCTION__))
;
1099
1100 // Construct a compiler instance that will be used to actually create the
1101 // module. Since we're sharing a PCMCache,
1102 // CompilerInstance::CompilerInstance is responsible for finalizing the
1103 // buffers to prevent use-after-frees.
1104 CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
1105 &ImportingInstance.getPreprocessor().getPCMCache());
1106 auto &Inv = *Invocation;
1107 Instance.setInvocation(std::move(Invocation));
1108
1109 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
1110 ImportingInstance.getDiagnosticClient()),
1111 /*ShouldOwnClient=*/true);
1112
1113 Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
1114
1115 // Note that this module is part of the module build stack, so that we
1116 // can detect cycles in the module graph.
1117 Instance.setFileManager(&ImportingInstance.getFileManager());
1118 Instance.createSourceManager(Instance.getFileManager());
1119 SourceManager &SourceMgr = Instance.getSourceManager();
1120 SourceMgr.setModuleBuildStack(
1121 ImportingInstance.getSourceManager().getModuleBuildStack());
1122 SourceMgr.pushModuleBuildStack(ModuleName,
1123 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
1124
1125 // If we're collecting module dependencies, we need to share a collector
1126 // between all of the module CompilerInstances. Other than that, we don't
1127 // want to produce any dependency output from the module build.
1128 Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
1129 Inv.getDependencyOutputOpts() = DependencyOutputOptions();
1130
1131 ImportingInstance.getDiagnostics().Report(ImportLoc,
1132 diag::remark_module_build)
1133 << ModuleName << ModuleFileName;
1134
1135 PreBuildStep(Instance);
1136
1137 // Execute the action to actually build the module in-place. Use a separate
1138 // thread so that we get a stack large enough.
1139 llvm::CrashRecoveryContext CRC;
1140 CRC.RunSafelyOnThread(
1141 [&]() {
1142 GenerateModuleFromModuleMapAction Action;
1143 Instance.ExecuteAction(Action);
1144 },
1145 DesiredStackSize);
1146
1147 PostBuildStep(Instance);
1148
1149 ImportingInstance.getDiagnostics().Report(ImportLoc,
1150 diag::remark_module_build_done)
1151 << ModuleName;
1152
1153 // Delete the temporary module map file.
1154 // FIXME: Even though we're executing under crash protection, it would still
1155 // be nice to do this with RemoveFileOnSignal when we can. However, that
1156 // doesn't make sense for all clients, so clean this up manually.
1157 Instance.clearOutputFiles(/*EraseFiles=*/true);
1158
1159 return !Instance.getDiagnostics().hasErrorOccurred();
1160}
1161
1162static const FileEntry *getPublicModuleMap(const FileEntry *File,
1163 FileManager &FileMgr) {
1164 StringRef Filename = llvm::sys::path::filename(File->getName());
1165 SmallString<128> PublicFilename(File->getDir()->getName());
1166 if (Filename == "module_private.map")
1167 llvm::sys::path::append(PublicFilename, "module.map");
1168 else if (Filename == "module.private.modulemap")
1169 llvm::sys::path::append(PublicFilename, "module.modulemap");
1170 else
1171 return nullptr;
1172 return FileMgr.getFile(PublicFilename);
1173}
1174
1175/// Compile a module file for the given module, using the options
1176/// provided by the importing compiler instance. Returns true if the module
1177/// was built without errors.
1178static bool compileModuleImpl(CompilerInstance &ImportingInstance,
1179 SourceLocation ImportLoc,
1180 Module *Module,
1181 StringRef ModuleFileName) {
1182 InputKind IK(getLanguageFromOptions(ImportingInstance.getLangOpts()),
1183 InputKind::ModuleMap);
1184
1185 // Get or create the module map that we'll use to build this module.
1186 ModuleMap &ModMap
1187 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1188 bool Result;
1189 if (const FileEntry *ModuleMapFile =
1190 ModMap.getContainingModuleMapFile(Module)) {
1191 // Canonicalize compilation to start with the public module map. This is
1192 // vital for submodules declarations in the private module maps to be
1193 // correctly parsed when depending on a top level module in the public one.
1194 if (const FileEntry *PublicMMFile = getPublicModuleMap(
1195 ModuleMapFile, ImportingInstance.getFileManager()))
1196 ModuleMapFile = PublicMMFile;
1197
1198 // Use the module map where this module resides.
1199 Result = compileModuleImpl(
1200 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1201 FrontendInputFile(ModuleMapFile->getName(), IK, +Module->IsSystem),
1202 ModMap.getModuleMapFileForUniquing(Module)->getName(),
1203 ModuleFileName);
1204 } else {
1205 // FIXME: We only need to fake up an input file here as a way of
1206 // transporting the module's directory to the module map parser. We should
1207 // be able to do that more directly, and parse from a memory buffer without
1208 // inventing this file.
1209 SmallString<128> FakeModuleMapFile(Module->Directory->getName());
1210 llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
1211
1212 std::string InferredModuleMapContent;
1213 llvm::raw_string_ostream OS(InferredModuleMapContent);
1214 Module->print(OS);
1215 OS.flush();
1216
1217 Result = compileModuleImpl(
1218 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1219 FrontendInputFile(FakeModuleMapFile, IK, +Module->IsSystem),
1220 ModMap.getModuleMapFileForUniquing(Module)->getName(),
1221 ModuleFileName,
1222 [&](CompilerInstance &Instance) {
1223 std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
1224 llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
1225 ModuleMapFile = Instance.getFileManager().getVirtualFile(
1226 FakeModuleMapFile, InferredModuleMapContent.size(), 0);
1227 Instance.getSourceManager().overrideFileContents(
1228 ModuleMapFile, std::move(ModuleMapBuffer));
1229 });
1230 }
1231
1232 // We've rebuilt a module. If we're allowed to generate or update the global
1233 // module index, record that fact in the importing compiler instance.
1234 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
1235 ImportingInstance.setBuildGlobalModuleIndex(true);
1236 }
1237
1238 return Result;
1239}
1240
1241static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
1242 SourceLocation ImportLoc,
1243 SourceLocation ModuleNameLoc, Module *Module,
1244 StringRef ModuleFileName) {
1245 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1246
1247 auto diagnoseBuildFailure = [&] {
1248 Diags.Report(ModuleNameLoc, diag::err_module_not_built)
1249 << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1250 };
1251
1252 // FIXME: have LockFileManager return an error_code so that we can
1253 // avoid the mkdir when the directory already exists.
1254 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1255 llvm::sys::fs::create_directories(Dir);
1256
1257 while (1) {
1258 unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
1259 llvm::LockFileManager Locked(ModuleFileName);
1260 switch (Locked) {
1261 case llvm::LockFileManager::LFS_Error:
1262 // PCMCache takes care of correctness and locks are only necessary for
1263 // performance. Fallback to building the module in case of any lock
1264 // related errors.
1265 Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
1266 << Module->Name << Locked.getErrorMessage();
1267 // Clear out any potential leftover.
1268 Locked.unsafeRemoveLockFile();
1269 // FALLTHROUGH
1270 case llvm::LockFileManager::LFS_Owned:
1271 // We're responsible for building the module ourselves.
1272 if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1273 ModuleFileName)) {
1274 diagnoseBuildFailure();
1275 return false;
1276 }
1277 break;
1278
1279 case llvm::LockFileManager::LFS_Shared:
1280 // Someone else is responsible for building the module. Wait for them to
1281 // finish.
1282 switch (Locked.waitForUnlock()) {
1283 case llvm::LockFileManager::Res_Success:
1284 ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1285 break;
1286 case llvm::LockFileManager::Res_OwnerDied:
1287 continue; // try again to get the lock.
1288 case llvm::LockFileManager::Res_Timeout:
1289 // Since PCMCache takes care of correctness, we try waiting for another
1290 // process to complete the build so clang does not do it done twice. If
1291 // case of timeout, build it ourselves.
1292 Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
1293 << Module->Name;
1294 // Clear the lock file so that future invocations can make progress.
1295 Locked.unsafeRemoveLockFile();
1296 continue;
1297 }
1298 break;
1299 }
1300
1301 // Try to read the module file, now that we've compiled it.
1302 ASTReader::ASTReadResult ReadResult =
1303 ImportingInstance.getModuleManager()->ReadAST(
1304 ModuleFileName, serialization::MK_ImplicitModule, ImportLoc,
1305 ModuleLoadCapabilities);
1306
1307 if (ReadResult == ASTReader::OutOfDate &&
1308 Locked == llvm::LockFileManager::LFS_Shared) {
1309 // The module may be out of date in the presence of file system races,
1310 // or if one of its imports depends on header search paths that are not
1311 // consistent with this ImportingInstance. Try again...
1312 continue;
1313 } else if (ReadResult == ASTReader::Missing) {
1314 diagnoseBuildFailure();
1315 } else if (ReadResult != ASTReader::Success &&
1316 !Diags.hasErrorOccurred()) {
1317 // The ASTReader didn't diagnose the error, so conservatively report it.
1318 diagnoseBuildFailure();
1319 }
1320 return ReadResult == ASTReader::Success;
1321 }
1322}
1323
1324/// Diagnose differences between the current definition of the given
1325/// configuration macro and the definition provided on the command line.
1326static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1327 Module *Mod, SourceLocation ImportLoc) {
1328 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1329 SourceManager &SourceMgr = PP.getSourceManager();
1330
1331 // If this identifier has never had a macro definition, then it could
1332 // not have changed.
1333 if (!Id->hadMacroDefinition())
1334 return;
1335 auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
1336
1337 // Find the macro definition from the command line.
1338 MacroInfo *CmdLineDefinition = nullptr;
1339 for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
1340 // We only care about the predefines buffer.
1341 FileID FID = SourceMgr.getFileID(MD->getLocation());
1342 if (FID.isInvalid() || FID != PP.getPredefinesFileID())
1343 continue;
1344 if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1345 CmdLineDefinition = DMD->getMacroInfo();
1346 break;
1347 }
1348
1349 auto *CurrentDefinition = PP.getMacroInfo(Id);
1350 if (CurrentDefinition == CmdLineDefinition) {
1351 // Macro matches. Nothing to do.
1352 } else if (!CurrentDefinition) {
1353 // This macro was defined on the command line, then #undef'd later.
1354 // Complain.
1355 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1356 << true << ConfigMacro << Mod->getFullModuleName();
1357 auto LatestDef = LatestLocalMD->getDefinition();
1358 assert(LatestDef.isUndefined() &&(static_cast <bool> (LatestDef.isUndefined() &&
"predefined macro went away with no #undef?") ? void (0) : __assert_fail
("LatestDef.isUndefined() && \"predefined macro went away with no #undef?\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1359, __extension__ __PRETTY_FUNCTION__))
1359 "predefined macro went away with no #undef?")(static_cast <bool> (LatestDef.isUndefined() &&
"predefined macro went away with no #undef?") ? void (0) : __assert_fail
("LatestDef.isUndefined() && \"predefined macro went away with no #undef?\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1359, __extension__ __PRETTY_FUNCTION__))
;
1360 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1361 << true;
1362 return;
1363 } else if (!CmdLineDefinition) {
1364 // There was no definition for this macro in the predefines buffer,
1365 // but there was a local definition. Complain.
1366 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1367 << false << ConfigMacro << Mod->getFullModuleName();
1368 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1369 diag::note_module_def_undef_here)
1370 << false;
1371 } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1372 /*Syntactically=*/true)) {
1373 // The macro definitions differ.
1374 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1375 << false << ConfigMacro << Mod->getFullModuleName();
1376 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1377 diag::note_module_def_undef_here)
1378 << false;
1379 }
1380}
1381
1382/// Write a new timestamp file with the given path.
1383static void writeTimestampFile(StringRef TimestampFile) {
1384 std::error_code EC;
1385 llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
1386}
1387
1388/// Prune the module cache of modules that haven't been accessed in
1389/// a long time.
1390static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1391 struct stat StatBuf;
1392 llvm::SmallString<128> TimestampFile;
1393 TimestampFile = HSOpts.ModuleCachePath;
1394 assert(!TimestampFile.empty())(static_cast <bool> (!TimestampFile.empty()) ? void (0)
: __assert_fail ("!TimestampFile.empty()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1394, __extension__ __PRETTY_FUNCTION__))
;
1395 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1396
1397 // Try to stat() the timestamp file.
1398 if (::stat(TimestampFile.c_str(), &StatBuf)) {
1399 // If the timestamp file wasn't there, create one now.
1400 if (errno(*__errno_location ()) == ENOENT2) {
1401 writeTimestampFile(TimestampFile);
1402 }
1403 return;
1404 }
1405
1406 // Check whether the time stamp is older than our pruning interval.
1407 // If not, do nothing.
1408 time_t TimeStampModTime = StatBuf.st_mtimest_mtim.tv_sec;
1409 time_t CurrentTime = time(nullptr);
1410 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1411 return;
1412
1413 // Write a new timestamp file so that nobody else attempts to prune.
1414 // There is a benign race condition here, if two Clang instances happen to
1415 // notice at the same time that the timestamp is out-of-date.
1416 writeTimestampFile(TimestampFile);
1417
1418 // Walk the entire module cache, looking for unused module files and module
1419 // indices.
1420 std::error_code EC;
1421 SmallString<128> ModuleCachePathNative;
1422 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1423 for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
1424 Dir != DirEnd && !EC; Dir.increment(EC)) {
1425 // If we don't have a directory, there's nothing to look into.
1426 if (!llvm::sys::fs::is_directory(Dir->path()))
1427 continue;
1428
1429 // Walk all of the files within this directory.
1430 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1431 File != FileEnd && !EC; File.increment(EC)) {
1432 // We only care about module and global module index files.
1433 StringRef Extension = llvm::sys::path::extension(File->path());
1434 if (Extension != ".pcm" && Extension != ".timestamp" &&
1435 llvm::sys::path::filename(File->path()) != "modules.idx")
1436 continue;
1437
1438 // Look at this file. If we can't stat it, there's nothing interesting
1439 // there.
1440 if (::stat(File->path().c_str(), &StatBuf))
1441 continue;
1442
1443 // If the file has been used recently enough, leave it there.
1444 time_t FileAccessTime = StatBuf.st_atimest_atim.tv_sec;
1445 if (CurrentTime - FileAccessTime <=
1446 time_t(HSOpts.ModuleCachePruneAfter)) {
1447 continue;
1448 }
1449
1450 // Remove the file.
1451 llvm::sys::fs::remove(File->path());
1452
1453 // Remove the timestamp file.
1454 std::string TimpestampFilename = File->path() + ".timestamp";
1455 llvm::sys::fs::remove(TimpestampFilename);
1456 }
1457
1458 // If we removed all of the files in the directory, remove the directory
1459 // itself.
1460 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1461 llvm::sys::fs::directory_iterator() && !EC)
1462 llvm::sys::fs::remove(Dir->path());
1463 }
1464}
1465
1466void CompilerInstance::createModuleManager() {
1467 if (!ModuleManager) {
1468 if (!hasASTContext())
1469 createASTContext();
1470
1471 // If we're implicitly building modules but not currently recursively
1472 // building a module, check whether we need to prune the module cache.
1473 if (getSourceManager().getModuleBuildStack().empty() &&
1474 !getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() &&
1475 getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1476 getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1477 pruneModuleCache(getHeaderSearchOpts());
1478 }
1479
1480 HeaderSearchOptions &HSOpts = getHeaderSearchOpts();
1481 std::string Sysroot = HSOpts.Sysroot;
1482 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1483 std::unique_ptr<llvm::Timer> ReadTimer;
1484 if (FrontendTimerGroup)
1485 ReadTimer = llvm::make_unique<llvm::Timer>("reading_modules",
1486 "Reading modules",
1487 *FrontendTimerGroup);
1488 ModuleManager = new ASTReader(
1489 getPreprocessor(), &getASTContext(), getPCHContainerReader(),
1490 getFrontendOpts().ModuleFileExtensions,
1491 Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation,
1492 /*AllowASTWithCompilerErrors=*/false,
1493 /*AllowConfigurationMismatch=*/false,
1494 HSOpts.ModulesValidateSystemHeaders,
1495 getFrontendOpts().UseGlobalModuleIndex,
1496 std::move(ReadTimer));
1497 if (hasASTConsumer()) {
1498 ModuleManager->setDeserializationListener(
1499 getASTConsumer().GetASTDeserializationListener());
1500 getASTContext().setASTMutationListener(
1501 getASTConsumer().GetASTMutationListener());
1502 }
1503 getASTContext().setExternalSource(ModuleManager);
1504 if (hasSema())
1505 ModuleManager->InitializeSema(getSema());
1506 if (hasASTConsumer())
1507 ModuleManager->StartTranslationUnit(&getASTConsumer());
1508
1509 if (TheDependencyFileGenerator)
1510 TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1511 for (auto &Listener : DependencyCollectors)
1512 Listener->attachToASTReader(*ModuleManager);
1513 }
1514}
1515
1516bool CompilerInstance::loadModuleFile(StringRef FileName) {
1517 llvm::Timer Timer;
1518 if (FrontendTimerGroup)
1
Taking false branch
1519 Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(),
1520 *FrontendTimerGroup);
1521 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
2
'?' condition is false
1522
1523 // Helper to recursively read the module names for all modules we're adding.
1524 // We mark these as known and redirect any attempt to load that module to
1525 // the files we were handed.
1526 struct ReadModuleNames : ASTReaderListener {
1527 CompilerInstance &CI;
1528 llvm::SmallVector<IdentifierInfo*, 8> LoadedModules;
1529
1530 ReadModuleNames(CompilerInstance &CI) : CI(CI) {}
1531
1532 void ReadModuleName(StringRef ModuleName) override {
1533 LoadedModules.push_back(
1534 CI.getPreprocessor().getIdentifierInfo(ModuleName));
1535 }
1536
1537 void registerAll() {
1538 for (auto *II : LoadedModules) {
1539 CI.KnownModules[II] = CI.getPreprocessor()
1540 .getHeaderSearchInfo()
1541 .getModuleMap()
1542 .findModule(II->getName());
1543 }
1544 LoadedModules.clear();
1545 }
1546
1547 void markAllUnavailable() {
1548 for (auto *II : LoadedModules) {
1549 if (Module *M = CI.getPreprocessor()
1550 .getHeaderSearchInfo()
1551 .getModuleMap()
1552 .findModule(II->getName())) {
1553 M->HasIncompatibleModuleFile = true;
1554
1555 // Mark module as available if the only reason it was unavailable
1556 // was missing headers.
1557 SmallVector<Module *, 2> Stack;
1558 Stack.push_back(M);
1559 while (!Stack.empty()) {
1560 Module *Current = Stack.pop_back_val();
1561 if (Current->IsMissingRequirement) continue;
1562 Current->IsAvailable = true;
1563 Stack.insert(Stack.end(),
1564 Current->submodule_begin(), Current->submodule_end());
1565 }
1566 }
1567 }
1568 LoadedModules.clear();
1569 }
1570 };
1571
1572 // If we don't already have an ASTReader, create one now.
1573 if (!ModuleManager)
3
Assuming the condition is false
4
Taking false branch
1574 createModuleManager();
1575
1576 // If -Wmodule-file-config-mismatch is mapped as an error or worse, allow the
1577 // ASTReader to diagnose it, since it can produce better errors that we can.
1578 bool ConfigMismatchIsRecoverable =
1579 getDiagnostics().getDiagnosticLevel(diag::warn_module_config_mismatch,
5
Assuming the condition is true
1580 SourceLocation())
1581 <= DiagnosticsEngine::Warning;
1582
1583 auto Listener = llvm::make_unique<ReadModuleNames>(*this);
6
Calling 'make_unique<ReadModuleNames, clang::CompilerInstance &>'
8
Returned allocated memory
1584 auto &ListenerRef = *Listener;
1585 ASTReader::ListenerScope ReadModuleNamesListener(*ModuleManager,
1586 std::move(Listener));
9
Calling '~unique_ptr'
14
Returning from '~unique_ptr'
1587
1588 // Try to load the module file.
1589 switch (ModuleManager->ReadAST(
16
Control jumps to 'case ConfigurationMismatch:' at line 1598
1590 FileName, serialization::MK_ExplicitModule, SourceLocation(),
1591 ConfigMismatchIsRecoverable ? ASTReader::ARR_ConfigurationMismatch : 0)) {
15
'?' condition is true
1592 case ASTReader::Success:
1593 // We successfully loaded the module file; remember the set of provided
1594 // modules so that we don't try to load implicit modules for them.
1595 ListenerRef.registerAll();
1596 return true;
1597
1598 case ASTReader::ConfigurationMismatch:
1599 // Ignore unusable module files.
1600 getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch)
1601 << FileName;
1602 // All modules provided by any files we tried and failed to load are now
1603 // unavailable; includes of those modules should now be handled textually.
1604 ListenerRef.markAllUnavailable();
17
Use of memory after it is freed
1605 return true;
1606
1607 default:
1608 return false;
1609 }
1610}
1611
1612ModuleLoadResult
1613CompilerInstance::loadModule(SourceLocation ImportLoc,
1614 ModuleIdPath Path,
1615 Module::NameVisibilityKind Visibility,
1616 bool IsInclusionDirective) {
1617 // Determine what file we're searching from.
1618 // FIXME: Should we be deciding whether this is a submodule (here and
1619 // below) based on -fmodules-ts or should we pass a flag and make the
1620 // caller decide?
1621 std::string ModuleName;
1622 if (getLangOpts().ModulesTS) {
1623 // FIXME: Same code as Sema::ActOnModuleDecl() so there is probably a
1624 // better place/way to do this.
1625 for (auto &Piece : Path) {
1626 if (!ModuleName.empty())
1627 ModuleName += ".";
1628 ModuleName += Piece.first->getName();
1629 }
1630 }
1631 else
1632 ModuleName = Path[0].first->getName();
1633
1634 SourceLocation ModuleNameLoc = Path[0].second;
1635
1636 // If we've already handled this import, just return the cached result.
1637 // This one-element cache is important to eliminate redundant diagnostics
1638 // when both the preprocessor and parser see the same import declaration.
1639 if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
1640 // Make the named module visible.
1641 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
1642 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1643 ImportLoc);
1644 return LastModuleImportResult;
1645 }
1646
1647 clang::Module *Module = nullptr;
1648
1649 // If we don't already have information on this module, load the module now.
1650 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
1651 = KnownModules.find(Path[0].first);
1652 if (Known != KnownModules.end()) {
1653 // Retrieve the cached top-level module.
1654 Module = Known->second;
1655 } else if (ModuleName == getLangOpts().CurrentModule) {
1656 // This is the module we're building.
1657 Module = PP->getHeaderSearchInfo().lookupModule(
1658 ModuleName, /*AllowSearch*/ true,
1659 /*AllowExtraModuleMapSearch*/ !IsInclusionDirective);
1660 /// FIXME: perhaps we should (a) look for a module using the module name
1661 // to file map (PrebuiltModuleFiles) and (b) diagnose if still not found?
1662 //if (Module == nullptr) {
1663 // getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1664 // << ModuleName;
1665 // ModuleBuildFailed = true;
1666 // return ModuleLoadResult();
1667 //}
1668 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1669 } else {
1670 // Search for a module with the given name.
1671 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName, true,
1672 !IsInclusionDirective);
1673 HeaderSearchOptions &HSOpts =
1674 PP->getHeaderSearchInfo().getHeaderSearchOpts();
1675
1676 std::string ModuleFileName;
1677 enum ModuleSource {
1678 ModuleNotFound, ModuleCache, PrebuiltModulePath, ModuleBuildPragma
1679 } Source = ModuleNotFound;
1680
1681 // Check to see if the module has been built as part of this compilation
1682 // via a module build pragma.
1683 auto BuiltModuleIt = BuiltModules.find(ModuleName);
1684 if (BuiltModuleIt != BuiltModules.end()) {
1685 ModuleFileName = BuiltModuleIt->second;
1686 Source = ModuleBuildPragma;
1687 }
1688
1689 // Try to load the module from the prebuilt module path.
1690 if (Source == ModuleNotFound && (!HSOpts.PrebuiltModuleFiles.empty() ||
1691 !HSOpts.PrebuiltModulePaths.empty())) {
1692 ModuleFileName =
1693 PP->getHeaderSearchInfo().getPrebuiltModuleFileName(ModuleName);
1694 if (!ModuleFileName.empty())
1695 Source = PrebuiltModulePath;
1696 }
1697
1698 // Try to load the module from the module cache.
1699 if (Source == ModuleNotFound && Module) {
1700 ModuleFileName = PP->getHeaderSearchInfo().getCachedModuleFileName(Module);
1701 Source = ModuleCache;
1702 }
1703
1704 if (Source == ModuleNotFound) {
1705 // We can't find a module, error out here.
1706 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1707 << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
1708 ModuleBuildFailed = true;
1709 return ModuleLoadResult();
1710 }
1711
1712 if (ModuleFileName.empty()) {
1713 if (Module && Module->HasIncompatibleModuleFile) {
1714 // We tried and failed to load a module file for this module. Fall
1715 // back to textual inclusion for its headers.
1716 return ModuleLoadResult::ConfigMismatch;
1717 }
1718
1719 getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1720 << ModuleName;
1721 ModuleBuildFailed = true;
1722 return ModuleLoadResult();
1723 }
1724
1725 // If we don't already have an ASTReader, create one now.
1726 if (!ModuleManager)
1727 createModuleManager();
1728
1729 llvm::Timer Timer;
1730 if (FrontendTimerGroup)
1731 Timer.init("loading." + ModuleFileName, "Loading " + ModuleFileName,
1732 *FrontendTimerGroup);
1733 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1734
1735 // Try to load the module file. If we are not trying to load from the
1736 // module cache, we don't know how to rebuild modules.
1737 unsigned ARRFlags = Source == ModuleCache ?
1738 ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing :
1739 ASTReader::ARR_ConfigurationMismatch;
1740 switch (ModuleManager->ReadAST(ModuleFileName,
1741 Source == PrebuiltModulePath
1742 ? serialization::MK_PrebuiltModule
1743 : Source == ModuleBuildPragma
1744 ? serialization::MK_ExplicitModule
1745 : serialization::MK_ImplicitModule,
1746 ImportLoc, ARRFlags)) {
1747 case ASTReader::Success: {
1748 if (Source != ModuleCache && !Module) {
1749 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName, true,
1750 !IsInclusionDirective);
1751 if (!Module || !Module->getASTFile() ||
1752 FileMgr->getFile(ModuleFileName) != Module->getASTFile()) {
1753 // Error out if Module does not refer to the file in the prebuilt
1754 // module path.
1755 getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt)
1756 << ModuleName;
1757 ModuleBuildFailed = true;
1758 KnownModules[Path[0].first] = nullptr;
1759 return ModuleLoadResult();
1760 }
1761 }
1762 break;
1763 }
1764
1765 case ASTReader::OutOfDate:
1766 case ASTReader::Missing: {
1767 if (Source != ModuleCache) {
1768 // We don't know the desired configuration for this module and don't
1769 // necessarily even have a module map. Since ReadAST already produces
1770 // diagnostics for these two cases, we simply error out here.
1771 ModuleBuildFailed = true;
1772 KnownModules[Path[0].first] = nullptr;
1773 return ModuleLoadResult();
1774 }
1775
1776 // The module file is missing or out-of-date. Build it.
1777 assert(Module && "missing module file")(static_cast <bool> (Module && "missing module file"
) ? void (0) : __assert_fail ("Module && \"missing module file\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1777, __extension__ __PRETTY_FUNCTION__))
;
1778 // Check whether there is a cycle in the module graph.
1779 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1780 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1781 for (; Pos != PosEnd; ++Pos) {
1782 if (Pos->first == ModuleName)
1783 break;
1784 }
1785
1786 if (Pos != PosEnd) {
1787 SmallString<256> CyclePath;
1788 for (; Pos != PosEnd; ++Pos) {
1789 CyclePath += Pos->first;
1790 CyclePath += " -> ";
1791 }
1792 CyclePath += ModuleName;
1793
1794 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1795 << ModuleName << CyclePath;
1796 return ModuleLoadResult();
1797 }
1798
1799 // Check whether we have already attempted to build this module (but
1800 // failed).
1801 if (getPreprocessorOpts().FailedModules &&
1802 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1803 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1804 << ModuleName
1805 << SourceRange(ImportLoc, ModuleNameLoc);
1806 ModuleBuildFailed = true;
1807 return ModuleLoadResult();
1808 }
1809
1810 // Try to compile and then load the module.
1811 if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1812 ModuleFileName)) {
1813 assert(getDiagnostics().hasErrorOccurred() &&(static_cast <bool> (getDiagnostics().hasErrorOccurred(
) && "undiagnosed error in compileAndLoadModule") ? void
(0) : __assert_fail ("getDiagnostics().hasErrorOccurred() && \"undiagnosed error in compileAndLoadModule\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1814, __extension__ __PRETTY_FUNCTION__))
1814 "undiagnosed error in compileAndLoadModule")(static_cast <bool> (getDiagnostics().hasErrorOccurred(
) && "undiagnosed error in compileAndLoadModule") ? void
(0) : __assert_fail ("getDiagnostics().hasErrorOccurred() && \"undiagnosed error in compileAndLoadModule\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1814, __extension__ __PRETTY_FUNCTION__))
;
1815 if (getPreprocessorOpts().FailedModules)
1816 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
1817 KnownModules[Path[0].first] = nullptr;
1818 ModuleBuildFailed = true;
1819 return ModuleLoadResult();
1820 }
1821
1822 // Okay, we've rebuilt and now loaded the module.
1823 break;
1824 }
1825
1826 case ASTReader::ConfigurationMismatch:
1827 if (Source == PrebuiltModulePath)
1828 // FIXME: We shouldn't be setting HadFatalFailure below if we only
1829 // produce a warning here!
1830 getDiagnostics().Report(SourceLocation(),
1831 diag::warn_module_config_mismatch)
1832 << ModuleFileName;
1833 // Fall through to error out.
1834 LLVM_FALLTHROUGH[[clang::fallthrough]];
1835 case ASTReader::VersionMismatch:
1836 case ASTReader::HadErrors:
1837 ModuleLoader::HadFatalFailure = true;
1838 // FIXME: The ASTReader will already have complained, but can we shoehorn
1839 // that diagnostic information into a more useful form?
1840 KnownModules[Path[0].first] = nullptr;
1841 return ModuleLoadResult();
1842
1843 case ASTReader::Failure:
1844 ModuleLoader::HadFatalFailure = true;
1845 // Already complained, but note now that we failed.
1846 KnownModules[Path[0].first] = nullptr;
1847 ModuleBuildFailed = true;
1848 return ModuleLoadResult();
1849 }
1850
1851 // Cache the result of this top-level module lookup for later.
1852 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1853 }
1854
1855 // If we never found the module, fail.
1856 if (!Module)
1857 return ModuleLoadResult();
1858
1859 // Verify that the rest of the module path actually corresponds to
1860 // a submodule.
1861 bool MapPrivateSubModToTopLevel = false;
1862 if (!getLangOpts().ModulesTS && Path.size() > 1) {
1863 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1864 StringRef Name = Path[I].first->getName();
1865 clang::Module *Sub = Module->findSubmodule(Name);
1866
1867 // If the user is requesting Foo.Private and it doesn't exist, try to
1868 // match Foo_Private and emit a warning asking for the user to write
1869 // @import Foo_Private instead. FIXME: remove this when existing clients
1870 // migrate off of Foo.Private syntax.
1871 if (!Sub && PP->getLangOpts().ImplicitModules && Name == "Private" &&
1872 Module == Module->getTopLevelModule()) {
1873 SmallString<128> PrivateModule(Module->Name);
1874 PrivateModule.append("_Private");
1875
1876 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> PrivPath;
1877 auto &II = PP->getIdentifierTable().get(
1878 PrivateModule, PP->getIdentifierInfo(Module->Name)->getTokenID());
1879 PrivPath.push_back(std::make_pair(&II, Path[0].second));
1880
1881 if (PP->getHeaderSearchInfo().lookupModule(PrivateModule, true,
1882 !IsInclusionDirective))
1883 Sub =
1884 loadModule(ImportLoc, PrivPath, Visibility, IsInclusionDirective);
1885 if (Sub) {
1886 MapPrivateSubModToTopLevel = true;
1887 if (!getDiagnostics().isIgnored(
1888 diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) {
1889 getDiagnostics().Report(Path[I].second,
1890 diag::warn_no_priv_submodule_use_toplevel)
1891 << Path[I].first << Module->getFullModuleName() << PrivateModule
1892 << SourceRange(Path[0].second, Path[I].second)
1893 << FixItHint::CreateReplacement(SourceRange(Path[0].second),
1894 PrivateModule);
1895 getDiagnostics().Report(Sub->DefinitionLoc,
1896 diag::note_private_top_level_defined);
1897 }
1898 }
1899 }
1900
1901 if (!Sub) {
1902 // Attempt to perform typo correction to find a module name that works.
1903 SmallVector<StringRef, 2> Best;
1904 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1905
1906 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1907 JEnd = Module->submodule_end();
1908 J != JEnd; ++J) {
1909 unsigned ED = Name.edit_distance((*J)->Name,
1910 /*AllowReplacements=*/true,
1911 BestEditDistance);
1912 if (ED <= BestEditDistance) {
1913 if (ED < BestEditDistance) {
1914 Best.clear();
1915 BestEditDistance = ED;
1916 }
1917
1918 Best.push_back((*J)->Name);
1919 }
1920 }
1921
1922 // If there was a clear winner, user it.
1923 if (Best.size() == 1) {
1924 getDiagnostics().Report(Path[I].second,
1925 diag::err_no_submodule_suggest)
1926 << Path[I].first << Module->getFullModuleName() << Best[0]
1927 << SourceRange(Path[0].second, Path[I-1].second)
1928 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1929 Best[0]);
1930
1931 Sub = Module->findSubmodule(Best[0]);
1932 }
1933 }
1934
1935 if (!Sub) {
1936 // No submodule by this name. Complain, and don't look for further
1937 // submodules.
1938 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1939 << Path[I].first << Module->getFullModuleName()
1940 << SourceRange(Path[0].second, Path[I-1].second);
1941 break;
1942 }
1943
1944 Module = Sub;
1945 }
1946 }
1947
1948 // Make the named module visible, if it's not already part of the module
1949 // we are parsing.
1950 if (ModuleName != getLangOpts().CurrentModule) {
1951 if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
1952 // We have an umbrella header or directory that doesn't actually include
1953 // all of the headers within the directory it covers. Complain about
1954 // this missing submodule and recover by forgetting that we ever saw
1955 // this submodule.
1956 // FIXME: Should we detect this at module load time? It seems fairly
1957 // expensive (and rare).
1958 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1959 << Module->getFullModuleName()
1960 << SourceRange(Path.front().second, Path.back().second);
1961
1962 return ModuleLoadResult::MissingExpected;
1963 }
1964
1965 // Check whether this module is available.
1966 if (Preprocessor::checkModuleIsAvailable(getLangOpts(), getTarget(),
1967 getDiagnostics(), Module)) {
1968 getDiagnostics().Report(ImportLoc, diag::note_module_import_here)
1969 << SourceRange(Path.front().second, Path.back().second);
1970 LastModuleImportLoc = ImportLoc;
1971 LastModuleImportResult = ModuleLoadResult();
1972 return ModuleLoadResult();
1973 }
1974
1975 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
1976 }
1977
1978 // Check for any configuration macros that have changed.
1979 clang::Module *TopModule = Module->getTopLevelModule();
1980 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1981 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1982 Module, ImportLoc);
1983 }
1984
1985 // Resolve any remaining module using export_as for this one.
1986 getPreprocessor()
1987 .getHeaderSearchInfo()
1988 .getModuleMap()
1989 .resolveLinkAsDependencies(TopModule);
1990
1991 LastModuleImportLoc = ImportLoc;
1992 LastModuleImportResult = ModuleLoadResult(Module);
1993 return LastModuleImportResult;
1994}
1995
1996void CompilerInstance::loadModuleFromSource(SourceLocation ImportLoc,
1997 StringRef ModuleName,
1998 StringRef Source) {
1999 // Avoid creating filenames with special characters.
2000 SmallString<128> CleanModuleName(ModuleName);
2001 for (auto &C : CleanModuleName)
2002 if (!isAlphanumeric(C))
2003 C = '_';
2004
2005 // FIXME: Using a randomized filename here means that our intermediate .pcm
2006 // output is nondeterministic (as .pcm files refer to each other by name).
2007 // Can this affect the output in any way?
2008 SmallString<128> ModuleFileName;
2009 if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
2010 CleanModuleName, "pcm", ModuleFileName)) {
2011 getDiagnostics().Report(ImportLoc, diag::err_fe_unable_to_open_output)
2012 << ModuleFileName << EC.message();
2013 return;
2014 }
2015 std::string ModuleMapFileName = (CleanModuleName + ".map").str();
2016
2017 FrontendInputFile Input(
2018 ModuleMapFileName,
2019 InputKind(getLanguageFromOptions(*Invocation->getLangOpts()),
2020 InputKind::ModuleMap, /*Preprocessed*/true));
2021
2022 std::string NullTerminatedSource(Source.str());
2023
2024 auto PreBuildStep = [&](CompilerInstance &Other) {
2025 // Create a virtual file containing our desired source.
2026 // FIXME: We shouldn't need to do this.
2027 const FileEntry *ModuleMapFile = Other.getFileManager().getVirtualFile(
2028 ModuleMapFileName, NullTerminatedSource.size(), 0);
2029 Other.getSourceManager().overrideFileContents(
2030 ModuleMapFile,
2031 llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource.c_str()));
2032
2033 Other.BuiltModules = std::move(BuiltModules);
2034 Other.DeleteBuiltModules = false;
2035 };
2036
2037 auto PostBuildStep = [this](CompilerInstance &Other) {
2038 BuiltModules = std::move(Other.BuiltModules);
2039 };
2040
2041 // Build the module, inheriting any modules that we've built locally.
2042 if (compileModuleImpl(*this, ImportLoc, ModuleName, Input, StringRef(),
2043 ModuleFileName, PreBuildStep, PostBuildStep)) {
2044 BuiltModules[ModuleName] = ModuleFileName.str();
2045 llvm::sys::RemoveFileOnSignal(ModuleFileName);
2046 }
2047}
2048
2049void CompilerInstance::makeModuleVisible(Module *Mod,
2050 Module::NameVisibilityKind Visibility,
2051 SourceLocation ImportLoc) {
2052 if (!ModuleManager)
2053 createModuleManager();
2054 if (!ModuleManager)
2055 return;
2056
2057 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
2058}
2059
2060GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex(
2061 SourceLocation TriggerLoc) {
2062 if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
2063 return nullptr;
2064 if (!ModuleManager)
2065 createModuleManager();
2066 // Can't do anything if we don't have the module manager.
2067 if (!ModuleManager)
2068 return nullptr;
2069 // Get an existing global index. This loads it if not already
2070 // loaded.
2071 ModuleManager->loadGlobalIndex();
2072 GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
2073 // If the global index doesn't exist, create it.
2074 if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
2075 hasPreprocessor()) {
2076 llvm::sys::fs::create_directories(
2077 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2078 GlobalModuleIndex::writeIndex(
2079 getFileManager(), getPCHContainerReader(),
2080 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2081 ModuleManager->resetForReload();
2082 ModuleManager->loadGlobalIndex();
2083 GlobalIndex = ModuleManager->getGlobalIndex();
2084 }
2085 // For finding modules needing to be imported for fixit messages,
2086 // we need to make the global index cover all modules, so we do that here.
2087 if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
2088 ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap();
2089 bool RecreateIndex = false;
2090 for (ModuleMap::module_iterator I = MMap.module_begin(),
2091 E = MMap.module_end(); I != E; ++I) {
2092 Module *TheModule = I->second;
2093 const FileEntry *Entry = TheModule->getASTFile();
2094 if (!Entry) {
2095 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
2096 Path.push_back(std::make_pair(
2097 getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
2098 std::reverse(Path.begin(), Path.end());
2099 // Load a module as hidden. This also adds it to the global index.
2100 loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false);
2101 RecreateIndex = true;
2102 }
2103 }
2104 if (RecreateIndex) {
2105 GlobalModuleIndex::writeIndex(
2106 getFileManager(), getPCHContainerReader(),
2107 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2108 ModuleManager->resetForReload();
2109 ModuleManager->loadGlobalIndex();
2110 GlobalIndex = ModuleManager->getGlobalIndex();
2111 }
2112 HaveFullGlobalModuleIndex = true;
2113 }
2114 return GlobalIndex;
2115}
2116
2117// Check global module index for missing imports.
2118bool
2119CompilerInstance::lookupMissingImports(StringRef Name,
2120 SourceLocation TriggerLoc) {
2121 // Look for the symbol in non-imported modules, but only if an error
2122 // actually occurred.
2123 if (!buildingModule()) {
2124 // Load global module index, or retrieve a previously loaded one.
2125 GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex(
2126 TriggerLoc);
2127
2128 // Only if we have a global index.
2129 if (GlobalIndex) {
2130 GlobalModuleIndex::HitSet FoundModules;
2131
2132 // Find the modules that reference the identifier.
2133 // Note that this only finds top-level modules.
2134 // We'll let diagnoseTypo find the actual declaration module.
2135 if (GlobalIndex->lookupIdentifier(Name, FoundModules))
2136 return true;
2137 }
2138 }
2139
2140 return false;
2141}
2142void CompilerInstance::resetAndLeakSema() { BuryPointer(takeSema()); }
2143
2144void CompilerInstance::setExternalSemaSource(
2145 IntrusiveRefCntPtr<ExternalSemaSource> ESS) {
2146 ExternalSemaSrc = std::move(ESS);
2147}

/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/ADT/STLExtras.h

1//===- llvm/ADT/STLExtras.h - Useful STL related functions ------*- C++ -*-===//
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 contains some templates that are useful if you are working with the
11// STL at all.
12//
13// No library is required when using these functions.
14//
15//===----------------------------------------------------------------------===//
16
17#ifndef LLVM_ADT_STLEXTRAS_H
18#define LLVM_ADT_STLEXTRAS_H
19
20#include "llvm/ADT/Optional.h"
21#include "llvm/ADT/SmallVector.h"
22#include "llvm/ADT/iterator.h"
23#include "llvm/ADT/iterator_range.h"
24#include "llvm/Support/ErrorHandling.h"
25#include <algorithm>
26#include <cassert>
27#include <cstddef>
28#include <cstdint>
29#include <cstdlib>
30#include <functional>
31#include <initializer_list>
32#include <iterator>
33#include <limits>
34#include <memory>
35#include <tuple>
36#include <type_traits>
37#include <utility>
38
39#ifdef EXPENSIVE_CHECKS
40#include <random> // for std::mt19937
41#endif
42
43namespace llvm {
44
45// Only used by compiler if both template types are the same. Useful when
46// using SFINAE to test for the existence of member functions.
47template <typename T, T> struct SameType;
48
49namespace detail {
50
51template <typename RangeT>
52using IterOfRange = decltype(std::begin(std::declval<RangeT &>()));
53
54template <typename RangeT>
55using ValueOfRange = typename std::remove_reference<decltype(
56 *std::begin(std::declval<RangeT &>()))>::type;
57
58} // end namespace detail
59
60//===----------------------------------------------------------------------===//
61// Extra additions to <type_traits>
62//===----------------------------------------------------------------------===//
63
64template <typename T>
65struct negation : std::integral_constant<bool, !bool(T::value)> {};
66
67template <typename...> struct conjunction : std::true_type {};
68template <typename B1> struct conjunction<B1> : B1 {};
69template <typename B1, typename... Bn>
70struct conjunction<B1, Bn...>
71 : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
72
73//===----------------------------------------------------------------------===//
74// Extra additions to <functional>
75//===----------------------------------------------------------------------===//
76
77template <class Ty> struct identity {
78 using argument_type = Ty;
79
80 Ty &operator()(Ty &self) const {
81 return self;
82 }
83 const Ty &operator()(const Ty &self) const {
84 return self;
85 }
86};
87
88template <class Ty> struct less_ptr {
89 bool operator()(const Ty* left, const Ty* right) const {
90 return *left < *right;
91 }
92};
93
94template <class Ty> struct greater_ptr {
95 bool operator()(const Ty* left, const Ty* right) const {
96 return *right < *left;
97 }
98};
99
100/// An efficient, type-erasing, non-owning reference to a callable. This is
101/// intended for use as the type of a function parameter that is not used
102/// after the function in question returns.
103///
104/// This class does not own the callable, so it is not in general safe to store
105/// a function_ref.
106template<typename Fn> class function_ref;
107
108template<typename Ret, typename ...Params>
109class function_ref<Ret(Params...)> {
110 Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
111 intptr_t callable;
112
113 template<typename Callable>
114 static Ret callback_fn(intptr_t callable, Params ...params) {
115 return (*reinterpret_cast<Callable*>(callable))(
116 std::forward<Params>(params)...);
117 }
118
119public:
120 function_ref() = default;
121 function_ref(std::nullptr_t) {}
122
123 template <typename Callable>
124 function_ref(Callable &&callable,
125 typename std::enable_if<
126 !std::is_same<typename std::remove_reference<Callable>::type,
127 function_ref>::value>::type * = nullptr)
128 : callback(callback_fn<typename std::remove_reference<Callable>::type>),
129 callable(reinterpret_cast<intptr_t>(&callable)) {}
130
131 Ret operator()(Params ...params) const {
132 return callback(callable, std::forward<Params>(params)...);
133 }
134
135 operator bool() const { return callback; }
136};
137
138// deleter - Very very very simple method that is used to invoke operator
139// delete on something. It is used like this:
140//
141// for_each(V.begin(), B.end(), deleter<Interval>);
142template <class T>
143inline void deleter(T *Ptr) {
144 delete Ptr;
145}
146
147//===----------------------------------------------------------------------===//
148// Extra additions to <iterator>
149//===----------------------------------------------------------------------===//
150
151namespace adl_detail {
152
153using std::begin;
154
155template <typename ContainerTy>
156auto adl_begin(ContainerTy &&container)
157 -> decltype(begin(std::forward<ContainerTy>(container))) {
158 return begin(std::forward<ContainerTy>(container));
159}
160
161using std::end;
162
163template <typename ContainerTy>
164auto adl_end(ContainerTy &&container)
165 -> decltype(end(std::forward<ContainerTy>(container))) {
166 return end(std::forward<ContainerTy>(container));
167}
168
169using std::swap;
170
171template <typename T>
172void adl_swap(T &&lhs, T &&rhs) noexcept(noexcept(swap(std::declval<T>(),
173 std::declval<T>()))) {
174 swap(std::forward<T>(lhs), std::forward<T>(rhs));
175}
176
177} // end namespace adl_detail
178
179template <typename ContainerTy>
180auto adl_begin(ContainerTy &&container)
181 -> decltype(adl_detail::adl_begin(std::forward<ContainerTy>(container))) {
182 return adl_detail::adl_begin(std::forward<ContainerTy>(container));
183}
184
185template <typename ContainerTy>
186auto adl_end(ContainerTy &&container)
187 -> decltype(adl_detail::adl_end(std::forward<ContainerTy>(container))) {
188 return adl_detail::adl_end(std::forward<ContainerTy>(container));
189}
190
191template <typename T>
192void adl_swap(T &&lhs, T &&rhs) noexcept(
193 noexcept(adl_detail::adl_swap(std::declval<T>(), std::declval<T>()))) {
194 adl_detail::adl_swap(std::forward<T>(lhs), std::forward<T>(rhs));
195}
196
197// mapped_iterator - This is a simple iterator adapter that causes a function to
198// be applied whenever operator* is invoked on the iterator.
199
200template <typename ItTy, typename FuncTy,
201 typename FuncReturnTy =
202 decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
203class mapped_iterator
204 : public iterator_adaptor_base<
205 mapped_iterator<ItTy, FuncTy>, ItTy,
206 typename std::iterator_traits<ItTy>::iterator_category,
207 typename std::remove_reference<FuncReturnTy>::type> {
208public:
209 mapped_iterator(ItTy U, FuncTy F)
210 : mapped_iterator::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
211
212 ItTy getCurrent() { return this->I; }
213
214 FuncReturnTy operator*() { return F(*this->I); }
215
216private:
217 FuncTy F;
218};
219
220// map_iterator - Provide a convenient way to create mapped_iterators, just like
221// make_pair is useful for creating pairs...
222template <class ItTy, class FuncTy>
223inline mapped_iterator<ItTy, FuncTy> map_iterator(ItTy I, FuncTy F) {
224 return mapped_iterator<ItTy, FuncTy>(std::move(I), std::move(F));
225}
226
227/// Helper to determine if type T has a member called rbegin().
228template <typename Ty> class has_rbegin_impl {
229 using yes = char[1];
230 using no = char[2];
231
232 template <typename Inner>
233 static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
234
235 template <typename>
236 static no& test(...);
237
238public:
239 static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
240};
241
242/// Metafunction to determine if T& or T has a member called rbegin().
243template <typename Ty>
244struct has_rbegin : has_rbegin_impl<typename std::remove_reference<Ty>::type> {
245};
246
247// Returns an iterator_range over the given container which iterates in reverse.
248// Note that the container must have rbegin()/rend() methods for this to work.
249template <typename ContainerTy>
250auto reverse(ContainerTy &&C,
251 typename std::enable_if<has_rbegin<ContainerTy>::value>::type * =
252 nullptr) -> decltype(make_range(C.rbegin(), C.rend())) {
253 return make_range(C.rbegin(), C.rend());
254}
255
256// Returns a std::reverse_iterator wrapped around the given iterator.
257template <typename IteratorTy>
258std::reverse_iterator<IteratorTy> make_reverse_iterator(IteratorTy It) {
259 return std::reverse_iterator<IteratorTy>(It);
260}
261
262// Returns an iterator_range over the given container which iterates in reverse.
263// Note that the container must have begin()/end() methods which return
264// bidirectional iterators for this to work.
265template <typename ContainerTy>
266auto reverse(
267 ContainerTy &&C,
268 typename std::enable_if<!has_rbegin<ContainerTy>::value>::type * = nullptr)
269 -> decltype(make_range(llvm::make_reverse_iterator(std::end(C)),
270 llvm::make_reverse_iterator(std::begin(C)))) {
271 return make_range(llvm::make_reverse_iterator(std::end(C)),
272 llvm::make_reverse_iterator(std::begin(C)));
273}
274
275/// An iterator adaptor that filters the elements of given inner iterators.
276///
277/// The predicate parameter should be a callable object that accepts the wrapped
278/// iterator's reference type and returns a bool. When incrementing or
279/// decrementing the iterator, it will call the predicate on each element and
280/// skip any where it returns false.
281///
282/// \code
283/// int A[] = { 1, 2, 3, 4 };
284/// auto R = make_filter_range(A, [](int N) { return N % 2 == 1; });
285/// // R contains { 1, 3 }.
286/// \endcode
287///
288/// Note: filter_iterator_base implements support for forward iteration.
289/// filter_iterator_impl exists to provide support for bidirectional iteration,
290/// conditional on whether the wrapped iterator supports it.
291template <typename WrappedIteratorT, typename PredicateT, typename IterTag>
292class filter_iterator_base
293 : public iterator_adaptor_base<
294 filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
295 WrappedIteratorT,
296 typename std::common_type<
297 IterTag, typename std::iterator_traits<
298 WrappedIteratorT>::iterator_category>::type> {
299 using BaseT = iterator_adaptor_base<
300 filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
301 WrappedIteratorT,
302 typename std::common_type<
303 IterTag, typename std::iterator_traits<
304 WrappedIteratorT>::iterator_category>::type>;
305
306protected:
307 WrappedIteratorT End;
308 PredicateT Pred;
309
310 void findNextValid() {
311 while (this->I != End && !Pred(*this->I))
312 BaseT::operator++();
313 }
314
315 // Construct the iterator. The begin iterator needs to know where the end
316 // is, so that it can properly stop when it gets there. The end iterator only
317 // needs the predicate to support bidirectional iteration.
318 filter_iterator_base(WrappedIteratorT Begin, WrappedIteratorT End,
319 PredicateT Pred)
320 : BaseT(Begin), End(End), Pred(Pred) {
321 findNextValid();
322 }
323
324public:
325 using BaseT::operator++;
326
327 filter_iterator_base &operator++() {
328 BaseT::operator++();
329 findNextValid();
330 return *this;
331 }
332};
333
334/// Specialization of filter_iterator_base for forward iteration only.
335template <typename WrappedIteratorT, typename PredicateT,
336 typename IterTag = std::forward_iterator_tag>
337class filter_iterator_impl
338 : public filter_iterator_base<WrappedIteratorT, PredicateT, IterTag> {
339 using BaseT = filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>;
340
341public:
342 filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
343 PredicateT Pred)
344 : BaseT(Begin, End, Pred) {}
345};
346
347/// Specialization of filter_iterator_base for bidirectional iteration.
348template <typename WrappedIteratorT, typename PredicateT>
349class filter_iterator_impl<WrappedIteratorT, PredicateT,
350 std::bidirectional_iterator_tag>
351 : public filter_iterator_base<WrappedIteratorT, PredicateT,
352 std::bidirectional_iterator_tag> {
353 using BaseT = filter_iterator_base<WrappedIteratorT, PredicateT,
354 std::bidirectional_iterator_tag>;
355 void findPrevValid() {
356 while (!this->Pred(*this->I))
357 BaseT::operator--();
358 }
359
360public:
361 using BaseT::operator--;
362
363 filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
364 PredicateT Pred)
365 : BaseT(Begin, End, Pred) {}
366
367 filter_iterator_impl &operator--() {
368 BaseT::operator--();
369 findPrevValid();
370 return *this;
371 }
372};
373
374namespace detail {
375
376template <bool is_bidirectional> struct fwd_or_bidi_tag_impl {
377 using type = std::forward_iterator_tag;
378};
379
380template <> struct fwd_or_bidi_tag_impl<true> {
381 using type = std::bidirectional_iterator_tag;
382};
383
384/// Helper which sets its type member to forward_iterator_tag if the category
385/// of \p IterT does not derive from bidirectional_iterator_tag, and to
386/// bidirectional_iterator_tag otherwise.
387template <typename IterT> struct fwd_or_bidi_tag {
388 using type = typename fwd_or_bidi_tag_impl<std::is_base_of<
389 std::bidirectional_iterator_tag,
390 typename std::iterator_traits<IterT>::iterator_category>::value>::type;
391};
392
393} // namespace detail
394
395/// Defines filter_iterator to a suitable specialization of
396/// filter_iterator_impl, based on the underlying iterator's category.
397template <typename WrappedIteratorT, typename PredicateT>
398using filter_iterator = filter_iterator_impl<
399 WrappedIteratorT, PredicateT,
400 typename detail::fwd_or_bidi_tag<WrappedIteratorT>::type>;
401
402/// Convenience function that takes a range of elements and a predicate,
403/// and return a new filter_iterator range.
404///
405/// FIXME: Currently if RangeT && is a rvalue reference to a temporary, the
406/// lifetime of that temporary is not kept by the returned range object, and the
407/// temporary is going to be dropped on the floor after the make_iterator_range
408/// full expression that contains this function call.
409template <typename RangeT, typename PredicateT>
410iterator_range<filter_iterator<detail::IterOfRange<RangeT>, PredicateT>>
411make_filter_range(RangeT &&Range, PredicateT Pred) {
412 using FilterIteratorT =
413 filter_iterator<detail::IterOfRange<RangeT>, PredicateT>;
414 return make_range(
415 FilterIteratorT(std::begin(std::forward<RangeT>(Range)),
416 std::end(std::forward<RangeT>(Range)), Pred),
417 FilterIteratorT(std::end(std::forward<RangeT>(Range)),
418 std::end(std::forward<RangeT>(Range)), Pred));
419}
420
421// forward declarations required by zip_shortest/zip_first
422template <typename R, typename UnaryPredicate>
423bool all_of(R &&range, UnaryPredicate P);
424
425template <size_t... I> struct index_sequence;
426
427template <class... Ts> struct index_sequence_for;
428
429namespace detail {
430
431using std::declval;
432
433// We have to alias this since inlining the actual type at the usage site
434// in the parameter list of iterator_facade_base<> below ICEs MSVC 2017.
435template<typename... Iters> struct ZipTupleType {
436 using type = std::tuple<decltype(*declval<Iters>())...>;
437};
438
439template <typename ZipType, typename... Iters>
440using zip_traits = iterator_facade_base<
441 ZipType, typename std::common_type<std::bidirectional_iterator_tag,
442 typename std::iterator_traits<
443 Iters>::iterator_category...>::type,
444 // ^ TODO: Implement random access methods.
445 typename ZipTupleType<Iters...>::type,
446 typename std::iterator_traits<typename std::tuple_element<
447 0, std::tuple<Iters...>>::type>::difference_type,
448 // ^ FIXME: This follows boost::make_zip_iterator's assumption that all
449 // inner iterators have the same difference_type. It would fail if, for
450 // instance, the second field's difference_type were non-numeric while the
451 // first is.
452 typename ZipTupleType<Iters...>::type *,
453 typename ZipTupleType<Iters...>::type>;
454
455template <typename ZipType, typename... Iters>
456struct zip_common : public zip_traits<ZipType, Iters...> {
457 using Base = zip_traits<ZipType, Iters...>;
458 using value_type = typename Base::value_type;
459
460 std::tuple<Iters...> iterators;
461
462protected:
463 template <size_t... Ns> value_type deref(index_sequence<Ns...>) const {
464 return value_type(*std::get<Ns>(iterators)...);
465 }
466
467 template <size_t... Ns>
468 decltype(iterators) tup_inc(index_sequence<Ns...>) const {
469 return std::tuple<Iters...>(std::next(std::get<Ns>(iterators))...);
470 }
471
472 template <size_t... Ns>
473 decltype(iterators) tup_dec(index_sequence<Ns...>) const {
474 return std::tuple<Iters...>(std::prev(std::get<Ns>(iterators))...);
475 }
476
477public:
478 zip_common(Iters &&... ts) : iterators(std::forward<Iters>(ts)...) {}
479
480 value_type operator*() { return deref(index_sequence_for<Iters...>{}); }
481
482 const value_type operator*() const {
483 return deref(index_sequence_for<Iters...>{});
484 }
485
486 ZipType &operator++() {
487 iterators = tup_inc(index_sequence_for<Iters...>{});
488 return *reinterpret_cast<ZipType *>(this);
489 }
490
491 ZipType &operator--() {
492 static_assert(Base::IsBidirectional,
493 "All inner iterators must be at least bidirectional.");
494 iterators = tup_dec(index_sequence_for<Iters...>{});
495 return *reinterpret_cast<ZipType *>(this);
496 }
497};
498
499template <typename... Iters>
500struct zip_first : public zip_common<zip_first<Iters...>, Iters...> {
501 using Base = zip_common<zip_first<Iters...>, Iters...>;
502
503 bool operator==(const zip_first<Iters...> &other) const {
504 return std::get<0>(this->iterators) == std::get<0>(other.iterators);
505 }
506
507 zip_first(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
508};
509
510template <typename... Iters>
511class zip_shortest : public zip_common<zip_shortest<Iters...>, Iters...> {
512 template <size_t... Ns>
513 bool test(const zip_shortest<Iters...> &other, index_sequence<Ns...>) const {
514 return all_of(std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
515 std::get<Ns>(other.iterators)...},
516 identity<bool>{});
517 }
518
519public:
520 using Base = zip_common<zip_shortest<Iters...>, Iters...>;
521
522 zip_shortest(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
523
524 bool operator==(const zip_shortest<Iters...> &other) const {
525 return !test(other, index_sequence_for<Iters...>{});
526 }
527};
528
529template <template <typename...> class ItType, typename... Args> class zippy {
530public:
531 using iterator = ItType<decltype(std::begin(std::declval<Args>()))...>;
532 using iterator_category = typename iterator::iterator_category;
533 using value_type = typename iterator::value_type;
534 using difference_type = typename iterator::difference_type;
535 using pointer = typename iterator::pointer;
536 using reference = typename iterator::reference;
537
538private:
539 std::tuple<Args...> ts;
540
541 template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) const {
542 return iterator(std::begin(std::get<Ns>(ts))...);
543 }
544 template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) const {
545 return iterator(std::end(std::get<Ns>(ts))...);
546 }
547
548public:
549 zippy(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
550
551 iterator begin() const { return begin_impl(index_sequence_for<Args...>{}); }
552 iterator end() const { return end_impl(index_sequence_for<Args...>{}); }
553};
554
555} // end namespace detail
556
557/// zip iterator for two or more iteratable types.
558template <typename T, typename U, typename... Args>
559detail::zippy<detail::zip_shortest, T, U, Args...> zip(T &&t, U &&u,
560 Args &&... args) {
561 return detail::zippy<detail::zip_shortest, T, U, Args...>(
562 std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
563}
564
565/// zip iterator that, for the sake of efficiency, assumes the first iteratee to
566/// be the shortest.
567template <typename T, typename U, typename... Args>
568detail::zippy<detail::zip_first, T, U, Args...> zip_first(T &&t, U &&u,
569 Args &&... args) {
570 return detail::zippy<detail::zip_first, T, U, Args...>(
571 std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
572}
573
574/// Iterator wrapper that concatenates sequences together.
575///
576/// This can concatenate different iterators, even with different types, into
577/// a single iterator provided the value types of all the concatenated
578/// iterators expose `reference` and `pointer` types that can be converted to
579/// `ValueT &` and `ValueT *` respectively. It doesn't support more
580/// interesting/customized pointer or reference types.
581///
582/// Currently this only supports forward or higher iterator categories as
583/// inputs and always exposes a forward iterator interface.
584template <typename ValueT, typename... IterTs>
585class concat_iterator
586 : public iterator_facade_base<concat_iterator<ValueT, IterTs...>,
587 std::forward_iterator_tag, ValueT> {
588 using BaseT = typename concat_iterator::iterator_facade_base;
589
590 /// We store both the current and end iterators for each concatenated
591 /// sequence in a tuple of pairs.
592 ///
593 /// Note that something like iterator_range seems nice at first here, but the
594 /// range properties are of little benefit and end up getting in the way
595 /// because we need to do mutation on the current iterators.
596 std::tuple<std::pair<IterTs, IterTs>...> IterPairs;
597
598 /// Attempts to increment a specific iterator.
599 ///
600 /// Returns true if it was able to increment the iterator. Returns false if
601 /// the iterator is already at the end iterator.
602 template <size_t Index> bool incrementHelper() {
603 auto &IterPair = std::get<Index>(IterPairs);
604 if (IterPair.first == IterPair.second)
605 return false;
606
607 ++IterPair.first;
608 return true;
609 }
610
611 /// Increments the first non-end iterator.
612 ///
613 /// It is an error to call this with all iterators at the end.
614 template <size_t... Ns> void increment(index_sequence<Ns...>) {
615 // Build a sequence of functions to increment each iterator if possible.
616 bool (concat_iterator::*IncrementHelperFns[])() = {
617 &concat_iterator::incrementHelper<Ns>...};
618
619 // Loop over them, and stop as soon as we succeed at incrementing one.
620 for (auto &IncrementHelperFn : IncrementHelperFns)
621 if ((this->*IncrementHelperFn)())
622 return;
623
624 llvm_unreachable("Attempted to increment an end concat iterator!")::llvm::llvm_unreachable_internal("Attempted to increment an end concat iterator!"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/ADT/STLExtras.h"
, 624)
;
625 }
626
627 /// Returns null if the specified iterator is at the end. Otherwise,
628 /// dereferences the iterator and returns the address of the resulting
629 /// reference.
630 template <size_t Index> ValueT *getHelper() const {
631 auto &IterPair = std::get<Index>(IterPairs);
632 if (IterPair.first == IterPair.second)
633 return nullptr;
634
635 return &*IterPair.first;
636 }
637
638 /// Finds the first non-end iterator, dereferences, and returns the resulting
639 /// reference.
640 ///
641 /// It is an error to call this with all iterators at the end.
642 template <size_t... Ns> ValueT &get(index_sequence<Ns...>) const {
643 // Build a sequence of functions to get from iterator if possible.
644 ValueT *(concat_iterator::*GetHelperFns[])() const = {
645 &concat_iterator::getHelper<Ns>...};
646
647 // Loop over them, and return the first result we find.
648 for (auto &GetHelperFn : GetHelperFns)
649 if (ValueT *P = (this->*GetHelperFn)())
650 return *P;
651
652 llvm_unreachable("Attempted to get a pointer from an end concat iterator!")::llvm::llvm_unreachable_internal("Attempted to get a pointer from an end concat iterator!"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/ADT/STLExtras.h"
, 652)
;
653 }
654
655public:
656 /// Constructs an iterator from a squence of ranges.
657 ///
658 /// We need the full range to know how to switch between each of the
659 /// iterators.
660 template <typename... RangeTs>
661 explicit concat_iterator(RangeTs &&... Ranges)
662 : IterPairs({std::begin(Ranges), std::end(Ranges)}...) {}
663
664 using BaseT::operator++;
665
666 concat_iterator &operator++() {
667 increment(index_sequence_for<IterTs...>());
668 return *this;
669 }
670
671 ValueT &operator*() const { return get(index_sequence_for<IterTs...>()); }
672
673 bool operator==(const concat_iterator &RHS) const {
674 return IterPairs == RHS.IterPairs;
675 }
676};
677
678namespace detail {
679
680/// Helper to store a sequence of ranges being concatenated and access them.
681///
682/// This is designed to facilitate providing actual storage when temporaries
683/// are passed into the constructor such that we can use it as part of range
684/// based for loops.
685template <typename ValueT, typename... RangeTs> class concat_range {
686public:
687 using iterator =
688 concat_iterator<ValueT,
689 decltype(std::begin(std::declval<RangeTs &>()))...>;
690
691private:
692 std::tuple<RangeTs...> Ranges;
693
694 template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) {
695 return iterator(std::get<Ns>(Ranges)...);
696 }
697 template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) {
698 return iterator(make_range(std::end(std::get<Ns>(Ranges)),
699 std::end(std::get<Ns>(Ranges)))...);
700 }
701
702public:
703 concat_range(RangeTs &&... Ranges)
704 : Ranges(std::forward<RangeTs>(Ranges)...) {}
705
706 iterator begin() { return begin_impl(index_sequence_for<RangeTs...>{}); }
707 iterator end() { return end_impl(index_sequence_for<RangeTs...>{}); }
708};
709
710} // end namespace detail
711
712/// Concatenated range across two or more ranges.
713///
714/// The desired value type must be explicitly specified.
715template <typename ValueT, typename... RangeTs>
716detail::concat_range<ValueT, RangeTs...> concat(RangeTs &&... Ranges) {
717 static_assert(sizeof...(RangeTs) > 1,
718 "Need more than one range to concatenate!");
719 return detail::concat_range<ValueT, RangeTs...>(
720 std::forward<RangeTs>(Ranges)...);
721}
722
723//===----------------------------------------------------------------------===//
724// Extra additions to <utility>
725//===----------------------------------------------------------------------===//
726
727/// Function object to check whether the first component of a std::pair
728/// compares less than the first component of another std::pair.
729struct less_first {
730 template <typename T> bool operator()(const T &lhs, const T &rhs) const {
731 return lhs.first < rhs.first;
732 }
733};
734
735/// Function object to check whether the second component of a std::pair
736/// compares less than the second component of another std::pair.
737struct less_second {
738 template <typename T> bool operator()(const T &lhs, const T &rhs) const {
739 return lhs.second < rhs.second;
740 }
741};
742
743// A subset of N3658. More stuff can be added as-needed.
744
745/// Represents a compile-time sequence of integers.
746template <class T, T... I> struct integer_sequence {
747 using value_type = T;
748
749 static constexpr size_t size() { return sizeof...(I); }
750};
751
752/// Alias for the common case of a sequence of size_ts.
753template <size_t... I>
754struct index_sequence : integer_sequence<std::size_t, I...> {};
755
756template <std::size_t N, std::size_t... I>
757struct build_index_impl : build_index_impl<N - 1, N - 1, I...> {};
758template <std::size_t... I>
759struct build_index_impl<0, I...> : index_sequence<I...> {};
760
761/// Creates a compile-time integer sequence for a parameter pack.
762template <class... Ts>
763struct index_sequence_for : build_index_impl<sizeof...(Ts)> {};
764
765/// Utility type to build an inheritance chain that makes it easy to rank
766/// overload candidates.
767template <int N> struct rank : rank<N - 1> {};
768template <> struct rank<0> {};
769
770/// traits class for checking whether type T is one of any of the given
771/// types in the variadic list.
772template <typename T, typename... Ts> struct is_one_of {
773 static const bool value = false;
774};
775
776template <typename T, typename U, typename... Ts>
777struct is_one_of<T, U, Ts...> {
778 static const bool value =
779 std::is_same<T, U>::value || is_one_of<T, Ts...>::value;
780};
781
782/// traits class for checking whether type T is a base class for all
783/// the given types in the variadic list.
784template <typename T, typename... Ts> struct are_base_of {
785 static const bool value = true;
786};
787
788template <typename T, typename U, typename... Ts>
789struct are_base_of<T, U, Ts...> {
790 static const bool value =
791 std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
792};
793
794//===----------------------------------------------------------------------===//
795// Extra additions for arrays
796//===----------------------------------------------------------------------===//
797
798/// Find the length of an array.
799template <class T, std::size_t N>
800constexpr inline size_t array_lengthof(T (&)[N]) {
801 return N;
802}
803
804/// Adapt std::less<T> for array_pod_sort.
805template<typename T>
806inline int array_pod_sort_comparator(const void *P1, const void *P2) {
807 if (std::less<T>()(*reinterpret_cast<const T*>(P1),
808 *reinterpret_cast<const T*>(P2)))
809 return -1;
810 if (std::less<T>()(*reinterpret_cast<const T*>(P2),
811 *reinterpret_cast<const T*>(P1)))
812 return 1;
813 return 0;
814}
815
816/// get_array_pod_sort_comparator - This is an internal helper function used to
817/// get type deduction of T right.
818template<typename T>
819inline int (*get_array_pod_sort_comparator(const T &))
820 (const void*, const void*) {
821 return array_pod_sort_comparator<T>;
822}
823
824/// array_pod_sort - This sorts an array with the specified start and end
825/// extent. This is just like std::sort, except that it calls qsort instead of
826/// using an inlined template. qsort is slightly slower than std::sort, but
827/// most sorts are not performance critical in LLVM and std::sort has to be
828/// template instantiated for each type, leading to significant measured code
829/// bloat. This function should generally be used instead of std::sort where
830/// possible.
831///
832/// This function assumes that you have simple POD-like types that can be
833/// compared with std::less and can be moved with memcpy. If this isn't true,
834/// you should use std::sort.
835///
836/// NOTE: If qsort_r were portable, we could allow a custom comparator and
837/// default to std::less.
838template<class IteratorTy>
839inline void array_pod_sort(IteratorTy Start, IteratorTy End) {
840 // Don't inefficiently call qsort with one element or trigger undefined
841 // behavior with an empty sequence.
842 auto NElts = End - Start;
843 if (NElts <= 1) return;
844#ifdef EXPENSIVE_CHECKS
845 std::mt19937 Generator(std::random_device{}());
846 std::shuffle(Start, End, Generator);
847#endif
848 qsort(&*Start, NElts, sizeof(*Start), get_array_pod_sort_comparator(*Start));
849}
850
851template <class IteratorTy>
852inline void array_pod_sort(
853 IteratorTy Start, IteratorTy End,
854 int (*Compare)(
855 const typename std::iterator_traits<IteratorTy>::value_type *,
856 const typename std::iterator_traits<IteratorTy>::value_type *)) {
857 // Don't inefficiently call qsort with one element or trigger undefined
858 // behavior with an empty sequence.
859 auto NElts = End - Start;
860 if (NElts <= 1) return;
861#ifdef EXPENSIVE_CHECKS
862 std::mt19937 Generator(std::random_device{}());
863 std::shuffle(Start, End, Generator);
864#endif
865 qsort(&*Start, NElts, sizeof(*Start),
866 reinterpret_cast<int (*)(const void *, const void *)>(Compare));
867}
868
869// Provide wrappers to std::sort which shuffle the elements before sorting
870// to help uncover non-deterministic behavior (PR35135).
871template <typename IteratorTy>
872inline void sort(IteratorTy Start, IteratorTy End) {
873#ifdef EXPENSIVE_CHECKS
874 std::mt19937 Generator(std::random_device{}());
875 std::shuffle(Start, End, Generator);
876#endif
877 std::sort(Start, End);
878}
879
880template <typename IteratorTy, typename Compare>
881inline void sort(IteratorTy Start, IteratorTy End, Compare Comp) {
882#ifdef EXPENSIVE_CHECKS
883 std::mt19937 Generator(std::random_device{}());
884 std::shuffle(Start, End, Generator);
885#endif
886 std::sort(Start, End, Comp);
887}
888
889//===----------------------------------------------------------------------===//
890// Extra additions to <algorithm>
891//===----------------------------------------------------------------------===//
892
893/// For a container of pointers, deletes the pointers and then clears the
894/// container.
895template<typename Container>
896void DeleteContainerPointers(Container &C) {
897 for (auto V : C)
898 delete V;
899 C.clear();
900}
901
902/// In a container of pairs (usually a map) whose second element is a pointer,
903/// deletes the second elements and then clears the container.
904template<typename Container>
905void DeleteContainerSeconds(Container &C) {
906 for (auto &V : C)
907 delete V.second;
908 C.clear();
909}
910
911/// Provide wrappers to std::for_each which take ranges instead of having to
912/// pass begin/end explicitly.
913template <typename R, typename UnaryPredicate>
914UnaryPredicate for_each(R &&Range, UnaryPredicate P) {
915 return std::for_each(adl_begin(Range), adl_end(Range), P);
916}
917
918/// Provide wrappers to std::all_of which take ranges instead of having to pass
919/// begin/end explicitly.
920template <typename R, typename UnaryPredicate>
921bool all_of(R &&Range, UnaryPredicate P) {
922 return std::all_of(adl_begin(Range), adl_end(Range), P);
923}
924
925/// Provide wrappers to std::any_of which take ranges instead of having to pass
926/// begin/end explicitly.
927template <typename R, typename UnaryPredicate>
928bool any_of(R &&Range, UnaryPredicate P) {
929 return std::any_of(adl_begin(Range), adl_end(Range), P);
930}
931
932/// Provide wrappers to std::none_of which take ranges instead of having to pass
933/// begin/end explicitly.
934template <typename R, typename UnaryPredicate>
935bool none_of(R &&Range, UnaryPredicate P) {
936 return std::none_of(adl_begin(Range), adl_end(Range), P);
937}
938
939/// Provide wrappers to std::find which take ranges instead of having to pass
940/// begin/end explicitly.
941template <typename R, typename T>
942auto find(R &&Range, const T &Val) -> decltype(adl_begin(Range)) {
943 return std::find(adl_begin(Range), adl_end(Range), Val);
944}
945
946/// Provide wrappers to std::find_if which take ranges instead of having to pass
947/// begin/end explicitly.
948template <typename R, typename UnaryPredicate>
949auto find_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
950 return std::find_if(adl_begin(Range), adl_end(Range), P);
951}
952
953template <typename R, typename UnaryPredicate>
954auto find_if_not(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
955 return std::find_if_not(adl_begin(Range), adl_end(Range), P);
956}
957
958/// Provide wrappers to std::remove_if which take ranges instead of having to
959/// pass begin/end explicitly.
960template <typename R, typename UnaryPredicate>
961auto remove_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
962 return std::remove_if(adl_begin(Range), adl_end(Range), P);
963}
964
965/// Provide wrappers to std::copy_if which take ranges instead of having to
966/// pass begin/end explicitly.
967template <typename R, typename OutputIt, typename UnaryPredicate>
968OutputIt copy_if(R &&Range, OutputIt Out, UnaryPredicate P) {
969 return std::copy_if(adl_begin(Range), adl_end(Range), Out, P);
970}
971
972template <typename R, typename OutputIt>
973OutputIt copy(R &&Range, OutputIt Out) {
974 return std::copy(adl_begin(Range), adl_end(Range), Out);
975}
976
977/// Wrapper function around std::find to detect if an element exists
978/// in a container.
979template <typename R, typename E>
980bool is_contained(R &&Range, const E &Element) {
981 return std::find(adl_begin(Range), adl_end(Range), Element) != adl_end(Range);
982}
983
984/// Wrapper function around std::count to count the number of times an element
985/// \p Element occurs in the given range \p Range.
986template <typename R, typename E>
987auto count(R &&Range, const E &Element) ->
988 typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
989 return std::count(adl_begin(Range), adl_end(Range), Element);
990}
991
992/// Wrapper function around std::count_if to count the number of times an
993/// element satisfying a given predicate occurs in a range.
994template <typename R, typename UnaryPredicate>
995auto count_if(R &&Range, UnaryPredicate P) ->
996 typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
997 return std::count_if(adl_begin(Range), adl_end(Range), P);
998}
999
1000/// Wrapper function around std::transform to apply a function to a range and
1001/// store the result elsewhere.
1002template <typename R, typename OutputIt, typename UnaryPredicate>
1003OutputIt transform(R &&Range, OutputIt d_first, UnaryPredicate P) {
1004 return std::transform(adl_begin(Range), adl_end(Range), d_first, P);
1005}
1006
1007/// Provide wrappers to std::partition which take ranges instead of having to
1008/// pass begin/end explicitly.
1009template <typename R, typename UnaryPredicate>
1010auto partition(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
1011 return std::partition(adl_begin(Range), adl_end(Range), P);
1012}
1013
1014/// Provide wrappers to std::lower_bound which take ranges instead of having to
1015/// pass begin/end explicitly.
1016template <typename R, typename ForwardIt>
1017auto lower_bound(R &&Range, ForwardIt I) -> decltype(adl_begin(Range)) {
1018 return std::lower_bound(adl_begin(Range), adl_end(Range), I);
1019}
1020
1021/// Given a range of type R, iterate the entire range and return a
1022/// SmallVector with elements of the vector. This is useful, for example,
1023/// when you want to iterate a range and then sort the results.
1024template <unsigned Size, typename R>
1025SmallVector<typename std::remove_const<detail::ValueOfRange<R>>::type, Size>
1026to_vector(R &&Range) {
1027 return {adl_begin(Range), adl_end(Range)};
1028}
1029
1030/// Provide a container algorithm similar to C++ Library Fundamentals v2's
1031/// `erase_if` which is equivalent to:
1032///
1033/// C.erase(remove_if(C, pred), C.end());
1034///
1035/// This version works for any container with an erase method call accepting
1036/// two iterators.
1037template <typename Container, typename UnaryPredicate>
1038void erase_if(Container &C, UnaryPredicate P) {
1039 C.erase(remove_if(C, P), C.end());
1040}
1041
1042/// Get the size of a range. This is a wrapper function around std::distance
1043/// which is only enabled when the operation is O(1).
1044template <typename R>
1045auto size(R &&Range, typename std::enable_if<
1046 std::is_same<typename std::iterator_traits<decltype(
1047 Range.begin())>::iterator_category,
1048 std::random_access_iterator_tag>::value,
1049 void>::type * = nullptr)
1050 -> decltype(std::distance(Range.begin(), Range.end())) {
1051 return std::distance(Range.begin(), Range.end());
1052}
1053
1054//===----------------------------------------------------------------------===//
1055// Extra additions to <memory>
1056//===----------------------------------------------------------------------===//
1057
1058// Implement make_unique according to N3656.
1059
1060/// Constructs a `new T()` with the given args and returns a
1061/// `unique_ptr<T>` which owns the object.
1062///
1063/// Example:
1064///
1065/// auto p = make_unique<int>();
1066/// auto p = make_unique<std::tuple<int, int>>(0, 1);
1067template <class T, class... Args>
1068typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
1069make_unique(Args &&... args) {
1070 return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
7
Memory is allocated
1071}
1072
1073/// Constructs a `new T[n]` with the given args and returns a
1074/// `unique_ptr<T[]>` which owns the object.
1075///
1076/// \param n size of the new array.
1077///
1078/// Example:
1079///
1080/// auto p = make_unique<int[]>(2); // value-initializes the array with 0's.
1081template <class T>
1082typename std::enable_if<std::is_array<T>::value && std::extent<T>::value == 0,
1083 std::unique_ptr<T>>::type
1084make_unique(size_t n) {
1085 return std::unique_ptr<T>(new typename std::remove_extent<T>::type[n]());
1086}
1087
1088/// This function isn't used and is only here to provide better compile errors.
1089template <class T, class... Args>
1090typename std::enable_if<std::extent<T>::value != 0>::type
1091make_unique(Args &&...) = delete;
1092
1093struct FreeDeleter {
1094 void operator()(void* v) {
1095 ::free(v);
1096 }
1097};
1098
1099template<typename First, typename Second>
1100struct pair_hash {
1101 size_t operator()(const std::pair<First, Second> &P) const {
1102 return std::hash<First>()(P.first) * 31 + std::hash<Second>()(P.second);
1103 }
1104};
1105
1106/// A functor like C++14's std::less<void> in its absence.
1107struct less {
1108 template <typename A, typename B> bool operator()(A &&a, B &&b) const {
1109 return std::forward<A>(a) < std::forward<B>(b);
1110 }
1111};
1112
1113/// A functor like C++14's std::equal<void> in its absence.
1114struct equal {
1115 template <typename A, typename B> bool operator()(A &&a, B &&b) const {
1116 return std::forward<A>(a) == std::forward<B>(b);
1117 }
1118};
1119
1120/// Binary functor that adapts to any other binary functor after dereferencing
1121/// operands.
1122template <typename T> struct deref {
1123 T func;
1124
1125 // Could be further improved to cope with non-derivable functors and
1126 // non-binary functors (should be a variadic template member function
1127 // operator()).
1128 template <typename A, typename B>
1129 auto operator()(A &lhs, B &rhs) const -> decltype(func(*lhs, *rhs)) {
1130 assert(lhs)(static_cast <bool> (lhs) ? void (0) : __assert_fail ("lhs"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/ADT/STLExtras.h"
, 1130, __extension__ __PRETTY_FUNCTION__))
;
1131 assert(rhs)(static_cast <bool> (rhs) ? void (0) : __assert_fail ("rhs"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/ADT/STLExtras.h"
, 1131, __extension__ __PRETTY_FUNCTION__))
;
1132 return func(*lhs, *rhs);
1133 }
1134};
1135
1136namespace detail {
1137
1138template <typename R> class enumerator_iter;
1139
1140template <typename R> struct result_pair {
1141 friend class enumerator_iter<R>;
1142
1143 result_pair() = default;
1144 result_pair(std::size_t Index, IterOfRange<R> Iter)
1145 : Index(Index), Iter(Iter) {}
1146
1147 result_pair<R> &operator=(const result_pair<R> &Other) {
1148 Index = Other.Index;
1149 Iter = Other.Iter;
1150 return *this;
1151 }
1152
1153 std::size_t index() const { return Index; }
1154 const ValueOfRange<R> &value() const { return *Iter; }
1155 ValueOfRange<R> &value() { return *Iter; }
1156
1157private:
1158 std::size_t Index = std::numeric_limits<std::size_t>::max();
1159 IterOfRange<R> Iter;
1160};
1161
1162template <typename R>
1163class enumerator_iter
1164 : public iterator_facade_base<
1165 enumerator_iter<R>, std::forward_iterator_tag, result_pair<R>,
1166 typename std::iterator_traits<IterOfRange<R>>::difference_type,
1167 typename std::iterator_traits<IterOfRange<R>>::pointer,
1168 typename std::iterator_traits<IterOfRange<R>>::reference> {
1169 using result_type = result_pair<R>;
1170
1171public:
1172 explicit enumerator_iter(IterOfRange<R> EndIter)
1173 : Result(std::numeric_limits<size_t>::max(), EndIter) {}
1174
1175 enumerator_iter(std::size_t Index, IterOfRange<R> Iter)
1176 : Result(Index, Iter) {}
1177
1178 result_type &operator*() { return Result; }
1179 const result_type &operator*() const { return Result; }
1180
1181 enumerator_iter<R> &operator++() {
1182 assert(Result.Index != std::numeric_limits<size_t>::max())(static_cast <bool> (Result.Index != std::numeric_limits
<size_t>::max()) ? void (0) : __assert_fail ("Result.Index != std::numeric_limits<size_t>::max()"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/ADT/STLExtras.h"
, 1182, __extension__ __PRETTY_FUNCTION__))
;
1183 ++Result.Iter;
1184 ++Result.Index;
1185 return *this;
1186 }
1187
1188 bool operator==(const enumerator_iter<R> &RHS) const {
1189 // Don't compare indices here, only iterators. It's possible for an end
1190 // iterator to have different indices depending on whether it was created
1191 // by calling std::end() versus incrementing a valid iterator.
1192 return Result.Iter == RHS.Result.Iter;
1193 }
1194
1195 enumerator_iter<R> &operator=(const enumerator_iter<R> &Other) {
1196 Result = Other.Result;
1197 return *this;
1198 }
1199
1200private:
1201 result_type Result;
1202};
1203
1204template <typename R> class enumerator {
1205public:
1206 explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}
1207
1208 enumerator_iter<R> begin() {
1209 return enumerator_iter<R>(0, std::begin(TheRange));
1210 }
1211
1212 enumerator_iter<R> end() {
1213 return enumerator_iter<R>(std::end(TheRange));
1214 }
1215
1216private:
1217 R TheRange;
1218};
1219
1220} // end namespace detail
1221
1222/// Given an input range, returns a new range whose values are are pair (A,B)
1223/// such that A is the 0-based index of the item in the sequence, and B is
1224/// the value from the original sequence. Example:
1225///
1226/// std::vector<char> Items = {'A', 'B', 'C', 'D'};
1227/// for (auto X : enumerate(Items)) {
1228/// printf("Item %d - %c\n", X.index(), X.value());
1229/// }
1230///
1231/// Output:
1232/// Item 0 - A
1233/// Item 1 - B
1234/// Item 2 - C
1235/// Item 3 - D
1236///
1237template <typename R> detail::enumerator<R> enumerate(R &&TheRange) {
1238 return detail::enumerator<R>(std::forward<R>(TheRange));
1239}
1240
1241namespace detail {
1242
1243template <typename F, typename Tuple, std::size_t... I>
1244auto apply_tuple_impl(F &&f, Tuple &&t, index_sequence<I...>)
1245 -> decltype(std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...)) {
1246 return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
1247}
1248
1249} // end namespace detail
1250
1251/// Given an input tuple (a1, a2, ..., an), pass the arguments of the
1252/// tuple variadically to f as if by calling f(a1, a2, ..., an) and
1253/// return the result.
1254template <typename F, typename Tuple>
1255auto apply_tuple(F &&f, Tuple &&t) -> decltype(detail::apply_tuple_impl(
1256 std::forward<F>(f), std::forward<Tuple>(t),
1257 build_index_impl<
1258 std::tuple_size<typename std::decay<Tuple>::type>::value>{})) {
1259 using Indices = build_index_impl<
1260 std::tuple_size<typename std::decay<Tuple>::type>::value>;
1261
1262 return detail::apply_tuple_impl(std::forward<F>(f), std::forward<Tuple>(t),
1263 Indices{});
1264}
1265
1266} // end namespace llvm
1267
1268#endif // LLVM_ADT_STLEXTRAS_H

/usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/bits/unique_ptr.h

1// unique_ptr implementation -*- C++ -*-
2
3// Copyright (C) 2008-2018 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/** @file bits/unique_ptr.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{memory}
28 */
29
30#ifndef _UNIQUE_PTR_H1
31#define _UNIQUE_PTR_H1 1
32
33#include <bits/c++config.h>
34#include <debug/assertions.h>
35#include <type_traits>
36#include <utility>
37#include <tuple>
38#include <bits/stl_function.h>
39#include <bits/functional_hash.h>
40
41namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
42{
43_GLIBCXX_BEGIN_NAMESPACE_VERSION
44
45 /**
46 * @addtogroup pointer_abstractions
47 * @{
48 */
49
50#if _GLIBCXX_USE_DEPRECATED1
51#pragma GCC diagnostic push
52#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
53 template<typename> class auto_ptr;
54#pragma GCC diagnostic pop
55#endif
56
57 /// Primary template of default_delete, used by unique_ptr
58 template<typename _Tp>
59 struct default_delete
60 {
61 /// Default constructor
62 constexpr default_delete() noexcept = default;
63
64 /** @brief Converting constructor.
65 *
66 * Allows conversion from a deleter for arrays of another type, @p _Up,
67 * only if @p _Up* is convertible to @p _Tp*.
68 */
69 template<typename _Up, typename = typename
70 enable_if<is_convertible<_Up*, _Tp*>::value>::type>
71 default_delete(const default_delete<_Up>&) noexcept { }
72
73 /// Calls @c delete @p __ptr
74 void
75 operator()(_Tp* __ptr) const
76 {
77 static_assert(!is_void<_Tp>::value,
78 "can't delete pointer to incomplete type");
79 static_assert(sizeof(_Tp)>0,
80 "can't delete pointer to incomplete type");
81 delete __ptr;
12
Memory is released
82 }
83 };
84
85 // _GLIBCXX_RESOLVE_LIB_DEFECTS
86 // DR 740 - omit specialization for array objects with a compile time length
87 /// Specialization for arrays, default_delete.
88 template<typename _Tp>
89 struct default_delete<_Tp[]>
90 {
91 public:
92 /// Default constructor
93 constexpr default_delete() noexcept = default;
94
95 /** @brief Converting constructor.
96 *
97 * Allows conversion from a deleter for arrays of another type, such as
98 * a const-qualified version of @p _Tp.
99 *
100 * Conversions from types derived from @c _Tp are not allowed because
101 * it is unsafe to @c delete[] an array of derived types through a
102 * pointer to the base type.
103 */
104 template<typename _Up, typename = typename
105 enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type>
106 default_delete(const default_delete<_Up[]>&) noexcept { }
107
108 /// Calls @c delete[] @p __ptr
109 template<typename _Up>
110 typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
111 operator()(_Up* __ptr) const
112 {
113 static_assert(sizeof(_Tp)>0,
114 "can't delete pointer to incomplete type");
115 delete [] __ptr;
116 }
117 };
118
119 template <typename _Tp, typename _Dp>
120 class __uniq_ptr_impl
121 {
122 template <typename _Up, typename _Ep, typename = void>
123 struct _Ptr
124 {
125 using type = _Up*;
126 };
127
128 template <typename _Up, typename _Ep>
129 struct
130 _Ptr<_Up, _Ep, __void_t<typename remove_reference<_Ep>::type::pointer>>
131 {
132 using type = typename remove_reference<_Ep>::type::pointer;
133 };
134
135 public:
136 using _DeleterConstraint = enable_if<
137 __and_<__not_<is_pointer<_Dp>>,
138 is_default_constructible<_Dp>>::value>;
139
140 using pointer = typename _Ptr<_Tp, _Dp>::type;
141
142 __uniq_ptr_impl() = default;
143 __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }
144
145 template<typename _Del>
146 __uniq_ptr_impl(pointer __p, _Del&& __d)
147 : _M_t(__p, std::forward<_Del>(__d)) { }
148
149 pointer& _M_ptr() { return std::get<0>(_M_t); }
150 pointer _M_ptr() const { return std::get<0>(_M_t); }
151 _Dp& _M_deleter() { return std::get<1>(_M_t); }
152 const _Dp& _M_deleter() const { return std::get<1>(_M_t); }
153
154 private:
155 tuple<pointer, _Dp> _M_t;
156 };
157
158 /// 20.7.1.2 unique_ptr for single objects.
159 template <typename _Tp, typename _Dp = default_delete<_Tp>>
160 class unique_ptr
161 {
162 template <class _Up>
163 using _DeleterConstraint =
164 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
165
166 __uniq_ptr_impl<_Tp, _Dp> _M_t;
167
168 public:
169 using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
170 using element_type = _Tp;
171 using deleter_type = _Dp;
172
173 // helper template for detecting a safe conversion from another
174 // unique_ptr
175 template<typename _Up, typename _Ep>
176 using __safe_conversion_up = __and_<
177 is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
178 __not_<is_array<_Up>>,
179 __or_<__and_<is_reference<deleter_type>,
180 is_same<deleter_type, _Ep>>,
181 __and_<__not_<is_reference<deleter_type>>,
182 is_convertible<_Ep, deleter_type>>
183 >
184 >;
185
186 // Constructors.
187
188 /// Default constructor, creates a unique_ptr that owns nothing.
189 template <typename _Up = _Dp,
190 typename = _DeleterConstraint<_Up>>
191 constexpr unique_ptr() noexcept
192 : _M_t()
193 { }
194
195 /** Takes ownership of a pointer.
196 *
197 * @param __p A pointer to an object of @c element_type
198 *
199 * The deleter will be value-initialized.
200 */
201 template <typename _Up = _Dp,
202 typename = _DeleterConstraint<_Up>>
203 explicit
204 unique_ptr(pointer __p) noexcept
205 : _M_t(__p)
206 { }
207
208 /** Takes ownership of a pointer.
209 *
210 * @param __p A pointer to an object of @c element_type
211 * @param __d A reference to a deleter.
212 *
213 * The deleter will be initialized with @p __d
214 */
215 unique_ptr(pointer __p,
216 typename conditional<is_reference<deleter_type>::value,
217 deleter_type, const deleter_type&>::type __d) noexcept
218 : _M_t(__p, __d) { }
219
220 /** Takes ownership of a pointer.
221 *
222 * @param __p A pointer to an object of @c element_type
223 * @param __d An rvalue reference to a deleter.
224 *
225 * The deleter will be initialized with @p std::move(__d)
226 */
227 unique_ptr(pointer __p,
228 typename remove_reference<deleter_type>::type&& __d) noexcept
229 : _M_t(std::move(__p), std::move(__d))
230 { static_assert(!std::is_reference<deleter_type>::value,
231 "rvalue deleter bound to reference"); }
232
233 /// Creates a unique_ptr that owns nothing.
234 template <typename _Up = _Dp,
235 typename = _DeleterConstraint<_Up>>
236 constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
237
238 // Move constructors.
239
240 /// Move constructor.
241 unique_ptr(unique_ptr&& __u) noexcept
242 : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
243
244 /** @brief Converting constructor from another type
245 *
246 * Requires that the pointer owned by @p __u is convertible to the
247 * type of pointer owned by this object, @p __u does not own an array,
248 * and @p __u has a compatible deleter type.
249 */
250 template<typename _Up, typename _Ep, typename = _Require<
251 __safe_conversion_up<_Up, _Ep>,
252 typename conditional<is_reference<_Dp>::value,
253 is_same<_Ep, _Dp>,
254 is_convertible<_Ep, _Dp>>::type>>
255 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
256 : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
257 { }
258
259#if _GLIBCXX_USE_DEPRECATED1
260#pragma GCC diagnostic push
261#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
262 /// Converting constructor from @c auto_ptr
263 template<typename _Up, typename = _Require<
264 is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
265 unique_ptr(auto_ptr<_Up>&& __u) noexcept;
266#pragma GCC diagnostic pop
267#endif
268
269 /// Destructor, invokes the deleter if the stored pointer is not null.
270 ~unique_ptr() noexcept
271 {
272 auto& __ptr = _M_t._M_ptr();
273 if (__ptr != nullptr)
10
Taking true branch
274 get_deleter()(__ptr);
11
Calling 'default_delete::operator()'
13
Returning; memory was released via 2nd parameter
275 __ptr = pointer();
276 }
277
278 // Assignment.
279
280 /** @brief Move assignment operator.
281 *
282 * @param __u The object to transfer ownership from.
283 *
284 * Invokes the deleter first if this object owns a pointer.
285 */
286 unique_ptr&
287 operator=(unique_ptr&& __u) noexcept
288 {
289 reset(__u.release());
290 get_deleter() = std::forward<deleter_type>(__u.get_deleter());
291 return *this;
292 }
293
294 /** @brief Assignment from another type.
295 *
296 * @param __u The object to transfer ownership from, which owns a
297 * convertible pointer to a non-array object.
298 *
299 * Invokes the deleter first if this object owns a pointer.
300 */
301 template<typename _Up, typename _Ep>
302 typename enable_if< __and_<
303 __safe_conversion_up<_Up, _Ep>,
304 is_assignable<deleter_type&, _Ep&&>
305 >::value,
306 unique_ptr&>::type
307 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
308 {
309 reset(__u.release());
310 get_deleter() = std::forward<_Ep>(__u.get_deleter());
311 return *this;
312 }
313
314 /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
315 unique_ptr&
316 operator=(nullptr_t) noexcept
317 {
318 reset();
319 return *this;
320 }
321
322 // Observers.
323
324 /// Dereference the stored pointer.
325 typename add_lvalue_reference<element_type>::type
326 operator*() const
327 {
328 __glibcxx_assert(get() != pointer());
329 return *get();
330 }
331
332 /// Return the stored pointer.
333 pointer
334 operator->() const noexcept
335 {
336 _GLIBCXX_DEBUG_PEDASSERT(get() != pointer());
337 return get();
338 }
339
340 /// Return the stored pointer.
341 pointer
342 get() const noexcept
343 { return _M_t._M_ptr(); }
344
345 /// Return a reference to the stored deleter.
346 deleter_type&
347 get_deleter() noexcept
348 { return _M_t._M_deleter(); }
349
350 /// Return a reference to the stored deleter.
351 const deleter_type&
352 get_deleter() const noexcept
353 { return _M_t._M_deleter(); }
354
355 /// Return @c true if the stored pointer is not null.
356 explicit operator bool() const noexcept
357 { return get() == pointer() ? false : true; }
358
359 // Modifiers.
360
361 /// Release ownership of any stored pointer.
362 pointer
363 release() noexcept
364 {
365 pointer __p = get();
366 _M_t._M_ptr() = pointer();
367 return __p;
368 }
369
370 /** @brief Replace the stored pointer.
371 *
372 * @param __p The new pointer to store.
373 *
374 * The deleter will be invoked if a pointer is already owned.
375 */
376 void
377 reset(pointer __p = pointer()) noexcept
378 {
379 using std::swap;
380 swap(_M_t._M_ptr(), __p);
381 if (__p != pointer())
382 get_deleter()(__p);
383 }
384
385 /// Exchange the pointer and deleter with another object.
386 void
387 swap(unique_ptr& __u) noexcept
388 {
389 using std::swap;
390 swap(_M_t, __u._M_t);
391 }
392
393 // Disable copy from lvalue.
394 unique_ptr(const unique_ptr&) = delete;
395 unique_ptr& operator=(const unique_ptr&) = delete;
396 };
397
398 /// 20.7.1.3 unique_ptr for array objects with a runtime length
399 // [unique.ptr.runtime]
400 // _GLIBCXX_RESOLVE_LIB_DEFECTS
401 // DR 740 - omit specialization for array objects with a compile time length
402 template<typename _Tp, typename _Dp>
403 class unique_ptr<_Tp[], _Dp>
404 {
405 template <typename _Up>
406 using _DeleterConstraint =
407 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
408
409 __uniq_ptr_impl<_Tp, _Dp> _M_t;
410
411 template<typename _Up>
412 using __remove_cv = typename remove_cv<_Up>::type;
413
414 // like is_base_of<_Tp, _Up> but false if unqualified types are the same
415 template<typename _Up>
416 using __is_derived_Tp
417 = __and_< is_base_of<_Tp, _Up>,
418 __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
419
420 public:
421 using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
422 using element_type = _Tp;
423 using deleter_type = _Dp;
424
425 // helper template for detecting a safe conversion from another
426 // unique_ptr
427 template<typename _Up, typename _Ep,
428 typename _Up_up = unique_ptr<_Up, _Ep>,
429 typename _Up_element_type = typename _Up_up::element_type>
430 using __safe_conversion_up = __and_<
431 is_array<_Up>,
432 is_same<pointer, element_type*>,
433 is_same<typename _Up_up::pointer, _Up_element_type*>,
434 is_convertible<_Up_element_type(*)[], element_type(*)[]>,
435 __or_<__and_<is_reference<deleter_type>, is_same<deleter_type, _Ep>>,
436 __and_<__not_<is_reference<deleter_type>>,
437 is_convertible<_Ep, deleter_type>>>
438 >;
439
440 // helper template for detecting a safe conversion from a raw pointer
441 template<typename _Up>
442 using __safe_conversion_raw = __and_<
443 __or_<__or_<is_same<_Up, pointer>,
444 is_same<_Up, nullptr_t>>,
445 __and_<is_pointer<_Up>,
446 is_same<pointer, element_type*>,
447 is_convertible<
448 typename remove_pointer<_Up>::type(*)[],
449 element_type(*)[]>
450 >
451 >
452 >;
453
454 // Constructors.
455
456 /// Default constructor, creates a unique_ptr that owns nothing.
457 template <typename _Up = _Dp,
458 typename = _DeleterConstraint<_Up>>
459 constexpr unique_ptr() noexcept
460 : _M_t()
461 { }
462
463 /** Takes ownership of a pointer.
464 *
465 * @param __p A pointer to an array of a type safely convertible
466 * to an array of @c element_type
467 *
468 * The deleter will be value-initialized.
469 */
470 template<typename _Up,
471 typename _Vp = _Dp,
472 typename = _DeleterConstraint<_Vp>,
473 typename = typename enable_if<
474 __safe_conversion_raw<_Up>::value, bool>::type>
475 explicit
476 unique_ptr(_Up __p) noexcept
477 : _M_t(__p)
478 { }
479
480 /** Takes ownership of a pointer.
481 *
482 * @param __p A pointer to an array of a type safely convertible
483 * to an array of @c element_type
484 * @param __d A reference to a deleter.
485 *
486 * The deleter will be initialized with @p __d
487 */
488 template<typename _Up,
489 typename = typename enable_if<
490 __safe_conversion_raw<_Up>::value, bool>::type>
491 unique_ptr(_Up __p,
492 typename conditional<is_reference<deleter_type>::value,
493 deleter_type, const deleter_type&>::type __d) noexcept
494 : _M_t(__p, __d) { }
495
496 /** Takes ownership of a pointer.
497 *
498 * @param __p A pointer to an array of a type safely convertible
499 * to an array of @c element_type
500 * @param __d A reference to a deleter.
501 *
502 * The deleter will be initialized with @p std::move(__d)
503 */
504 template<typename _Up,
505 typename = typename enable_if<
506 __safe_conversion_raw<_Up>::value, bool>::type>
507 unique_ptr(_Up __p, typename
508 remove_reference<deleter_type>::type&& __d) noexcept
509 : _M_t(std::move(__p), std::move(__d))
510 { static_assert(!is_reference<deleter_type>::value,
511 "rvalue deleter bound to reference"); }
512
513 /// Move constructor.
514 unique_ptr(unique_ptr&& __u) noexcept
515 : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
516
517 /// Creates a unique_ptr that owns nothing.
518 template <typename _Up = _Dp,
519 typename = _DeleterConstraint<_Up>>
520 constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
521
522 template<typename _Up, typename _Ep,
523 typename = _Require<__safe_conversion_up<_Up, _Ep>>>
524 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
525 : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
526 { }
527
528 /// Destructor, invokes the deleter if the stored pointer is not null.
529 ~unique_ptr()
530 {
531 auto& __ptr = _M_t._M_ptr();
532 if (__ptr != nullptr)
533 get_deleter()(__ptr);
534 __ptr = pointer();
535 }
536
537 // Assignment.
538
539 /** @brief Move assignment operator.
540 *
541 * @param __u The object to transfer ownership from.
542 *
543 * Invokes the deleter first if this object owns a pointer.
544 */
545 unique_ptr&
546 operator=(unique_ptr&& __u) noexcept
547 {
548 reset(__u.release());
549 get_deleter() = std::forward<deleter_type>(__u.get_deleter());
550 return *this;
551 }
552
553 /** @brief Assignment from another type.
554 *
555 * @param __u The object to transfer ownership from, which owns a
556 * convertible pointer to an array object.
557 *
558 * Invokes the deleter first if this object owns a pointer.
559 */
560 template<typename _Up, typename _Ep>
561 typename
562 enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
563 is_assignable<deleter_type&, _Ep&&>
564 >::value,
565 unique_ptr&>::type
566 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
567 {
568 reset(__u.release());
569 get_deleter() = std::forward<_Ep>(__u.get_deleter());
570 return *this;
571 }
572
573 /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
574 unique_ptr&
575 operator=(nullptr_t) noexcept
576 {
577 reset();
578 return *this;
579 }
580
581 // Observers.
582
583 /// Access an element of owned array.
584 typename std::add_lvalue_reference<element_type>::type
585 operator[](size_t __i) const
586 {
587 __glibcxx_assert(get() != pointer());
588 return get()[__i];
589 }
590
591 /// Return the stored pointer.
592 pointer
593 get() const noexcept
594 { return _M_t._M_ptr(); }
595
596 /// Return a reference to the stored deleter.
597 deleter_type&
598 get_deleter() noexcept
599 { return _M_t._M_deleter(); }
600
601 /// Return a reference to the stored deleter.
602 const deleter_type&
603 get_deleter() const noexcept
604 { return _M_t._M_deleter(); }
605
606 /// Return @c true if the stored pointer is not null.
607 explicit operator bool() const noexcept
608 { return get() == pointer() ? false : true; }
609
610 // Modifiers.
611
612 /// Release ownership of any stored pointer.
613 pointer
614 release() noexcept
615 {
616 pointer __p = get();
617 _M_t._M_ptr() = pointer();
618 return __p;
619 }
620
621 /** @brief Replace the stored pointer.
622 *
623 * @param __p The new pointer to store.
624 *
625 * The deleter will be invoked if a pointer is already owned.
626 */
627 template <typename _Up,
628 typename = _Require<
629 __or_<is_same<_Up, pointer>,
630 __and_<is_same<pointer, element_type*>,
631 is_pointer<_Up>,
632 is_convertible<
633 typename remove_pointer<_Up>::type(*)[],
634 element_type(*)[]
635 >
636 >
637 >
638 >>
639 void
640 reset(_Up __p) noexcept
641 {
642 pointer __ptr = __p;
643 using std::swap;
644 swap(_M_t._M_ptr(), __ptr);
645 if (__ptr != nullptr)
646 get_deleter()(__ptr);
647 }
648
649 void reset(nullptr_t = nullptr) noexcept
650 {
651 reset(pointer());
652 }
653
654 /// Exchange the pointer and deleter with another object.
655 void
656 swap(unique_ptr& __u) noexcept
657 {
658 using std::swap;
659 swap(_M_t, __u._M_t);
660 }
661
662 // Disable copy from lvalue.
663 unique_ptr(const unique_ptr&) = delete;
664 unique_ptr& operator=(const unique_ptr&) = delete;
665 };
666
667 template<typename _Tp, typename _Dp>
668 inline
669#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
670 // Constrained free swap overload, see p0185r1
671 typename enable_if<__is_swappable<_Dp>::value>::type
672#else
673 void
674#endif
675 swap(unique_ptr<_Tp, _Dp>& __x,
676 unique_ptr<_Tp, _Dp>& __y) noexcept
677 { __x.swap(__y); }
678
679#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
680 template<typename _Tp, typename _Dp>
681 typename enable_if<!__is_swappable<_Dp>::value>::type
682 swap(unique_ptr<_Tp, _Dp>&,
683 unique_ptr<_Tp, _Dp>&) = delete;
684#endif
685
686 template<typename _Tp, typename _Dp,
687 typename _Up, typename _Ep>
688 inline bool
689 operator==(const unique_ptr<_Tp, _Dp>& __x,
690 const unique_ptr<_Up, _Ep>& __y)
691 { return __x.get() == __y.get(); }
692
693 template<typename _Tp, typename _Dp>
694 inline bool
695 operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
696 { return !__x; }
697
698 template<typename _Tp, typename _Dp>
699 inline bool
700 operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
701 { return !__x; }
702
703 template<typename _Tp, typename _Dp,
704 typename _Up, typename _Ep>
705 inline bool
706 operator!=(const unique_ptr<_Tp, _Dp>& __x,
707 const unique_ptr<_Up, _Ep>& __y)
708 { return __x.get() != __y.get(); }
709
710 template<typename _Tp, typename _Dp>
711 inline bool
712 operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
713 { return (bool)__x; }
714
715 template<typename _Tp, typename _Dp>
716 inline bool
717 operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
718 { return (bool)__x; }
719
720 template<typename _Tp, typename _Dp,
721 typename _Up, typename _Ep>
722 inline bool
723 operator<(const unique_ptr<_Tp, _Dp>& __x,
724 const unique_ptr<_Up, _Ep>& __y)
725 {
726 typedef typename
727 std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
728 typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
729 return std::less<_CT>()(__x.get(), __y.get());
730 }
731
732 template<typename _Tp, typename _Dp>
733 inline bool
734 operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
735 { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
736 nullptr); }
737
738 template<typename _Tp, typename _Dp>
739 inline bool
740 operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
741 { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
742 __x.get()); }
743
744 template<typename _Tp, typename _Dp,
745 typename _Up, typename _Ep>
746 inline bool
747 operator<=(const unique_ptr<_Tp, _Dp>& __x,
748 const unique_ptr<_Up, _Ep>& __y)
749 { return !(__y < __x); }
750
751 template<typename _Tp, typename _Dp>
752 inline bool
753 operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
754 { return !(nullptr < __x); }
755
756 template<typename _Tp, typename _Dp>
757 inline bool
758 operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
759 { return !(__x < nullptr); }
760
761 template<typename _Tp, typename _Dp,
762 typename _Up, typename _Ep>
763 inline bool
764 operator>(const unique_ptr<_Tp, _Dp>& __x,
765 const unique_ptr<_Up, _Ep>& __y)
766 { return (__y < __x); }
767
768 template<typename _Tp, typename _Dp>
769 inline bool
770 operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
771 { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
772 __x.get()); }
773
774 template<typename _Tp, typename _Dp>
775 inline bool
776 operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
777 { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
778 nullptr); }
779
780 template<typename _Tp, typename _Dp,
781 typename _Up, typename _Ep>
782 inline bool
783 operator>=(const unique_ptr<_Tp, _Dp>& __x,
784 const unique_ptr<_Up, _Ep>& __y)
785 { return !(__x < __y); }
786
787 template<typename _Tp, typename _Dp>
788 inline bool
789 operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
790 { return !(__x < nullptr); }
791
792 template<typename _Tp, typename _Dp>
793 inline bool
794 operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
795 { return !(nullptr < __x); }
796
797 /// std::hash specialization for unique_ptr.
798 template<typename _Tp, typename _Dp>
799 struct hash<unique_ptr<_Tp, _Dp>>
800 : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>,
801 private __poison_hash<typename unique_ptr<_Tp, _Dp>::pointer>
802 {
803 size_t
804 operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
805 {
806 typedef unique_ptr<_Tp, _Dp> _UP;
807 return std::hash<typename _UP::pointer>()(__u.get());
808 }
809 };
810
811#if __cplusplus201103L > 201103L
812
813#define __cpp_lib_make_unique 201304
814
815 template<typename _Tp>
816 struct _MakeUniq
817 { typedef unique_ptr<_Tp> __single_object; };
818
819 template<typename _Tp>
820 struct _MakeUniq<_Tp[]>
821 { typedef unique_ptr<_Tp[]> __array; };
822
823 template<typename _Tp, size_t _Bound>
824 struct _MakeUniq<_Tp[_Bound]>
825 { struct __invalid_type { }; };
826
827 /// std::make_unique for single objects
828 template<typename _Tp, typename... _Args>
829 inline typename _MakeUniq<_Tp>::__single_object
830 make_unique(_Args&&... __args)
831 { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
832
833 /// std::make_unique for arrays of unknown bound
834 template<typename _Tp>
835 inline typename _MakeUniq<_Tp>::__array
836 make_unique(size_t __num)
837 { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }
838
839 /// Disable std::make_unique for arrays of known bound
840 template<typename _Tp, typename... _Args>
841 inline typename _MakeUniq<_Tp>::__invalid_type
842 make_unique(_Args&&...) = delete;
843#endif
844
845 // @} group pointer_abstractions
846
847_GLIBCXX_END_NAMESPACE_VERSION
848} // namespace
849
850#endif /* _UNIQUE_PTR_H */