|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
include/llvm/Support/VirtualFileSystem.h 375 return FS->status(Path);
379 return FS->openFileForRead(Path);
382 return FS->dir_begin(Dir, EC);
385 return FS->getCurrentWorkingDirectory();
388 return FS->setCurrentWorkingDirectory(Path);
392 return FS->getRealPath(Path, Output);
395 return FS->isLocal(Path, Result);
lib/Support/FileCollector.cpp 200 auto Result = FS->status(Path);
208 auto Result = FS->openFileForRead(Path);
216 auto It = FS->dir_begin(Dir, EC);
231 return FS->dir_begin(Dir, EC);
236 auto EC = FS->getRealPath(Path, Output);
246 return FS->isLocal(Path, Result);
250 return FS->getCurrentWorkingDirectory();
254 return FS->setCurrentWorkingDirectory(Path);
lib/Support/VirtualFileSystem.cpp 397 FS->setCurrentWorkingDirectory(getCurrentWorkingDirectory().get());
403 ErrorOr<Status> Status = (*I)->status(Path);
414 auto Result = (*I)->openFileForRead(Path);
424 return FSList.front()->getCurrentWorkingDirectory();
430 if (std::error_code EC = FS->setCurrentWorkingDirectory(Path))
437 if (FS->exists(Path))
438 return FS->isLocal(Path, Result);
446 if (FS->exists(Path))
447 return FS->getRealPath(Path, Output);
467 CurrentDirIter = (*CurrentFS)->dir_begin(Path, EC);
506 CurrentDirIter = (*CurrentFS)->dir_begin(Path, EC);
996 ExternalFS->getCurrentWorkingDirectory()) {
1059 auto EC = ExternalFS->setCurrentWorkingDirectory(Path);
1073 return ExternalFS->isLocal(Path, Result);
1082 return ExternalFS->dir_begin(Dir, EC);
1714 ErrorOr<Status> S = ExternalFS->status(F->getExternalContentsPath());
1731 return ExternalFS->status(Path);
1769 return ExternalFS->openFileForRead(Path);
1778 auto Result = ExternalFS->openFileForRead(F->getExternalContentsPath());
1800 return ExternalFS->getRealPath(Path, Output);
1807 return ExternalFS->getRealPath(F->getExternalContentsPath(), Output);
1811 return shouldUseExternalFS() ? ExternalFS->getRealPath(Path, Output)
tools/clang/include/clang/Basic/Diagnostic.h 777 return Diags->getCustomDiagID((DiagnosticIDs::Level)L,
820 return Diags->getDiagnosticSeverity(DiagID, Loc, *this) ==
835 return (Level)Diags->getDiagnosticLevel(DiagID, Loc, *this);
969 return Diags->ProcessDiag(*this);
tools/clang/include/clang/Basic/DiagnosticOptions.def 46 SEMANTIC_DIAGOPT(IgnoreWarnings, 1, 0) /// -w
47 DIAGOPT(NoRewriteMacros, 1, 0) /// -Wno-rewrite-macros
48 DIAGOPT(Pedantic, 1, 0) /// -pedantic
49 DIAGOPT(PedanticErrors, 1, 0) /// -pedantic-errors
50 DIAGOPT(ShowColumn, 1, 1) /// Show column number on diagnostics.
51 DIAGOPT(ShowLocation, 1, 1) /// Show source location information.
52 DIAGOPT(ShowLevel, 1, 1) /// Show diagnostic level.
53 DIAGOPT(AbsolutePath, 1, 0) /// Use absolute paths.
54 DIAGOPT(ShowCarets, 1, 1) /// Show carets in diagnostics.
55 DIAGOPT(ShowFixits, 1, 1) /// Show fixit information.
56 DIAGOPT(ShowSourceRanges, 1, 0) /// Show source ranges in numeric form.
57 DIAGOPT(ShowParseableFixits, 1, 0) /// Show machine parseable fix-its.
58 DIAGOPT(ShowPresumedLoc, 1, 0) /// Show presumed location for diagnostics.
59 DIAGOPT(ShowOptionNames, 1, 0) /// Show the option name for mappable
61 DIAGOPT(ShowNoteIncludeStack, 1, 0) /// Show include stacks for notes.
62 VALUE_DIAGOPT(ShowCategories, 2, 0) /// Show categories: 0 -> none, 1 -> Number,
67 DIAGOPT(ShowColors, 1, 0) /// Show diagnostics with ANSI color sequences.
70 DIAGOPT(VerifyDiagnostics, 1, 0) /// Check that diagnostics match the expected
77 DIAGOPT(ElideType, 1, 0) /// Elide identical types in template diffing
78 DIAGOPT(ShowTemplateTree, 1, 0) /// Print a template tree when diffing
79 DIAGOPT(CLFallbackMode, 1, 0) /// Format for clang-cl fallback mode
81 VALUE_DIAGOPT(ErrorLimit, 32, 0) /// Limit # errors emitted.
83 VALUE_DIAGOPT(MacroBacktraceLimit, 32, DefaultMacroBacktraceLimit)
85 VALUE_DIAGOPT(TemplateBacktraceLimit, 32, DefaultTemplateBacktraceLimit)
87 VALUE_DIAGOPT(ConstexprBacktraceLimit, 32, DefaultConstexprBacktraceLimit)
89 VALUE_DIAGOPT(SpellCheckingLimit, 32, DefaultSpellCheckingLimit)
91 VALUE_DIAGOPT(SnippetLineLimit, 32, DefaultSnippetLineLimit)
93 VALUE_DIAGOPT(TabStop, 32, DefaultTabStop) /// The distance between tab stops.
95 VALUE_DIAGOPT(MessageLength, 32, 0)
tools/clang/include/clang/Frontend/CompilerInstance.h 350 assert(Diagnostics && Diagnostics->getClient() &&
352 return *Diagnostics->getClient();
540 Diagnostics->Report(diag::err_module_format_unhandled) << Format;
554 Diagnostics->Report(diag::err_module_format_unhandled) << Format;
tools/clang/include/clang/Rewrite/Core/RewriteRope.h 69 return StrData->Data[Offset+StartOffs];
72 return StrData->Data[Offset+StartOffs];
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h 183 return getState()->getSVal(S, getLocationContext());
242 getState()->getStateManager().getContext().getSourceManager();
1251 CallEventManager &Mgr = State->getStateManager().getCallEventManager();
1267 CallEventManager &Mgr = State->getStateManager().getCallEventManager();
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h 178 return getState()->getSVal(S, getLocationContext());
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h 553 StoreMgr->iterBindings(state->getStore(), F);
565 return S1->Env == S2->Env;
565 return S1->Env == S2->Env;
569 return S1->store == S2->store;
569 return S1->store == S2->store;
604 ProgramStateTrait<T>::MakeVoidPtr(ProgramStateTrait<T>::Set(st->get<T>(), K, V, C)));
612 ProgramStateTrait<T>::MakeVoidPtr(ProgramStateTrait<T>::Add(st->get<T>(), K, C)));
621 ProgramStateTrait<T>::MakeVoidPtr(ProgramStateTrait<T>::Remove(st->get<T>(), K, C)));
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h 201 auto CZ = State->get<ConstraintSMT>();
202 auto &CZFactory = State->get_context<ConstraintSMT>();
209 return State->set<ConstraintSMT>(CZ);
214 ConstraintSMTType Constraints = State->get<ConstraintSMT>();
242 return S1->get<ConstraintSMT>() == S2->get<ConstraintSMT>();
242 return S1->get<ConstraintSMT>() == S2->get<ConstraintSMT>();
300 return State->add<ConstraintSMT>(std::make_pair(Sym, Exp));
309 auto CZ = State->get<ConstraintSMT>();
329 State->add<ConstraintSMT>(std::make_pair(Sym, Exp));
332 NewState->get<ConstraintSMT>().Profile(ID);
tools/clang/lib/ARCMigrate/ARCMT.cpp 225 Diags->setSourceManager(&PP.getSourceManager());
268 Diags->setClient(&errRec, /*ShouldOwnClient=*/false);
278 Diags->setClient(DiagClient, /*ShouldOwnClient=*/false);
282 if (Diags->hasFatalErrorOccurred()) {
283 Diags->Reset();
319 Diags->setSeverity(diag::warn_arcmt_nsalloc_realloc, diag::Severity::Error,
541 Diags->setClient(&errRec, /*ShouldOwnClient=*/false);
557 Diags->setClient(DiagClient, /*ShouldOwnClient=*/false);
561 if (Diags->hasFatalErrorOccurred()) {
562 Diags->Reset();
tools/clang/lib/AST/ASTContext.cpp 280 ExternalSource->ReadComments();
1029 ExternalSource->PrintStats();
tools/clang/lib/ASTMatchers/ASTMatchersInternal.cpp 110 bool Result = InnerMatcher->dynMatches(DynNode, Finder, Builder);
215 Implementation->dynMatches(DynNode, Finder, Builder)) {
229 if (Implementation->dynMatches(DynNode, Finder, Builder)) {
tools/clang/lib/Basic/Diagnostic.cpp 345 assert((Diags->isBuiltinWarningOrExtension(Diag) ||
387 if (Diags->getDiagnosticsInGroup(Flavor, Group, GroupDiags))
410 if (Diags->getDiagnosticsInGroup(diag::Flavor::WarningOrError, Group,
441 if (Diags->getDiagnosticsInGroup(diag::Flavor::WarningOrError, Group,
467 if (Diags->isBuiltinWarningOrExtension(Diag))
506 = Diags->getDiagnosticLevel(Info.getID(), Info.getLocation(), *this);
511 Diags->EmitDiag(*this, DiagLevel);
769 getDiags()->getDiagnosticIDs()->getDescription(getID());
tools/clang/lib/Basic/FileManager.cpp 438 FS->makeAbsolute(Path);
482 return FS->getBufferForFile(Filename, FileSize,
487 return FS->getBufferForFile(FilePath, FileSize,
518 llvm::ErrorOr<llvm::vfs::Status> S = FS->status(FilePath.c_str());
556 if (!FS->getRealPath(Dir->getName(), CanonicalNameBuf))
tools/clang/lib/Basic/SourceManager.cpp 2175 InMemoryFileSystem->addFile(
tools/clang/lib/Basic/Warnings.cpp 154 } else if (DiagIDs->getDiagnosticsInGroup(Flavor, Specifier, _Diags)) {
182 } else if (DiagIDs->getDiagnosticsInGroup(Flavor, Specifier, _Diags)) {
189 if (DiagIDs->getDiagnosticsInGroup(Flavor, Opt, _Diags))
219 if (DiagIDs->getDiagnosticsInGroup(Flavor, Opt, _Diags))
tools/clang/lib/CrossTU/CrossTranslationUnit.cpp 367 ->CTUImportThreshold) {}
tools/clang/lib/Driver/Driver.cpp 1018 if (VFS->setCurrentWorkingDirectory(WD->getValue()))
tools/clang/lib/Frontend/ASTUnit.cpp 281 getDiagnostics().getClient()->BeginSourceFile(Ctx->getLangOpts(), PP.get());
394 R.Declaration, Ctx->getLangOpts(), IsNestedNameSpecifier);
407 = Ctx->getCanonicalType(UsageType.getUnqualifiedType());
590 Target->adjust(LangOpt);
737 auto Buffer = FileMgr->getBufferForFile(Filename, UserFilesAreVolatile);
751 Diags->setClient(new FilterAndStoreDiagnosticConsumer(
823 AST->Reader->setListener(std::make_unique<ASTInfoCollector>(
833 AST->Ctx->setExternalSource(AST->Reader);
835 switch (AST->Reader->ReadAST(Filename, serialization::MK_MainFile,
850 AST->OriginalSourceFile = AST->Reader->getOriginalSourceFile();
862 AST->Reader->InitializeSema(*AST->TheSema);
1106 assert(VFS == &FileMgr->getVirtualFileSystem() &&
1124 if (VFS && FileMgr && &FileMgr->getVirtualFileSystem() == VFS)
1475 FE = SourceMgr->getFileEntryForID(SourceMgr->getMainFileID()))
1475 FE = SourceMgr->getFileEntryForID(SourceMgr->getMainFileID()))
1487 Mod = Reader->getModuleManager().getPrimaryModule();
1724 &AST->FileMgr->getVirtualFileSystem()))
1833 VFS = &FileMgr->getVirtualFileSystem();
2457 if (SourceMgr->isLoadedFileID(File)) {
2458 assert(Ctx->getExternalSource() && "No external source!");
2459 return Ctx->getExternalSource()->FindFileRegionDecls(File, Offset, Length,
2515 PreambleID = SourceMgr->getPreambleFileID();
2521 if (SourceMgr->isInFileID(Loc, PreambleID, &Offs) && Offs < Preamble->getBounds().Size) {
2523 = SourceMgr->getLocForStartOfFile(SourceMgr->getMainFileID());
2523 = SourceMgr->getLocForStartOfFile(SourceMgr->getMainFileID());
2536 PreambleID = SourceMgr->getPreambleFileID();
2542 if (SourceMgr->isInFileID(Loc, SourceMgr->getMainFileID(), &Offs) &&
2542 if (SourceMgr->isInFileID(Loc, SourceMgr->getMainFileID(), &Offs) &&
2544 SourceLocation FileLoc = SourceMgr->getLocForStartOfFile(PreambleID);
2554 FID = SourceMgr->getPreambleFileID();
2559 return SourceMgr->isInFileID(Loc, FID);
2565 FID = SourceMgr->getMainFileID();
2570 return SourceMgr->isInFileID(Loc, FID);
2576 FID = SourceMgr->getPreambleFileID();
2581 return SourceMgr->getLocForEndOfFile(FID);
2587 FID = SourceMgr->getMainFileID();
2592 return SourceMgr->getLocForStartOfFile(FID);
2599 Mod = Reader->getModuleManager().getPrimaryModule();
2600 return Reader->getModulePreprocessedEntities(Mod);
2613 Mod = Reader->getModuleManager().getPrimaryModule();
2614 for (const auto *D : Reader->getModuleFileLevelDecls(Mod)) {
2637 Reader->getModuleManager().visit([&Mod](serialization::ModuleFile &M) {
tools/clang/lib/Frontend/CompilerInstance.cpp 78 (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
142 assert(ModuleCache.get() == &Reader->getModuleManager().getModuleCache() &&
286 Diags->setClient(Client, ShouldOwnClient);
288 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
292 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
313 VFS = FileMgr ? &FileMgr->getVirtualFileSystem()
528 Reader->setDeserializationListener(
535 switch (Reader->ReadAST(Path,
543 PP.setPredefines(Reader->getSuggestedPredefines());
629 ExternalSemaSrc->InitializeSema(*TheSema);
649 FileMgr->FixupRelativePath(NewOutFile);
1310 ImportingInstance.getModuleManager()->ReadAST(
1506 ModuleManager->setDeserializationListener(
1513 ModuleManager->InitializeSema(getSema());
1515 ModuleManager->StartTranslationUnit(&getASTConsumer());
1595 switch (ModuleManager->ReadAST(
1633 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1734 switch (ModuleManager->ReadAST(ModuleFileName,
1745 auto ModuleFile = FileMgr->getFile(ModuleFileName);
1970 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
2052 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
2066 ModuleManager->loadGlobalIndex();
2067 GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
2083 ModuleManager->resetForReload();
2084 ModuleManager->loadGlobalIndex();
2085 GlobalIndex = ModuleManager->getGlobalIndex();
2114 ModuleManager->resetForReload();
2115 ModuleManager->loadGlobalIndex();
2116 GlobalIndex = ModuleManager->getGlobalIndex();
tools/clang/lib/Frontend/CompilerInvocation.cpp 3702 Result->getBufferForFile(File);
tools/clang/lib/Frontend/CreateInvocationFromCommandLine.cpp 81 Diags->Report(diag::err_fe_expected_compiler_job) << OS.str();
87 Diags->Report(diag::err_fe_expected_clang_command);
tools/clang/lib/Frontend/DiagnosticRenderer.cpp 120 PresumedLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc);
177 if (!DiagOpts->ShowNoteIncludeStack && Level == DiagnosticsEngine::Note)
196 PresumedLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc);
237 PresumedLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc);
253 DiagOpts->ShowPresumedLoc),
561 unsigned MacroLimit = DiagOpts->MacroBacktraceLimit;
tools/clang/lib/Frontend/FrontendAction.cpp 558 new DiagnosticsEngine(Diags->getDiagnosticIDs(),
559 &Diags->getDiagnosticOptions()));
560 ASTDiags->setClient(Diags->getClient(), /*OwnsClient*/false);
560 ASTDiags->setClient(Diags->getClient(), /*OwnsClient*/false);
587 auto &MM = ASTReader->getModuleManager();
594 ASTReader->visitTopLevelModuleMaps(PrimaryModule,
874 CI.getModuleManager()->setDeserializationListener(DeserialListener,
tools/clang/lib/Frontend/FrontendActions.cpp 572 for (const std::string &Warning : DiagOpts->Warnings)
574 for (const std::string &Remark : DiagOpts->Remarks)
tools/clang/lib/Frontend/PrecompiledPreamble.cpp 59 PCHFS->addFile(PCHFilename, 0, std::move(PCHBuffer));
62 Overlay->pushOverlay(PCHFS);
735 if (VFS == RealFS || VFS->exists(PCHPath))
737 auto Buf = RealFS->getBufferForFile(PCHPath);
tools/clang/lib/Frontend/Rewrite/FrontendActions.cpp 223 CI.getModuleManager()->getModuleManager().lookup(*File);
297 CI.getModuleManager()->addListener(
tools/clang/lib/Frontend/TextDiagnostic.cpp 683 if (DiagOpts->ShowColors)
686 if (DiagOpts->ShowLevel)
687 printDiagnosticLevel(OS, Level, DiagOpts->ShowColors,
688 DiagOpts->CLFallbackMode);
692 DiagOpts->MessageLength, DiagOpts->ShowColors);
692 DiagOpts->MessageLength, DiagOpts->ShowColors);
765 if (DiagOpts->AbsolutePath) {
823 if (!DiagOpts->ShowLocation)
826 if (DiagOpts->ShowColors)
830 switch (DiagOpts->getFormat()) {
836 if (DiagOpts->ShowColumn)
839 if (DiagOpts->getFormat() == DiagnosticOptions::MSVC) {
849 switch (DiagOpts->getFormat()) {
863 if (DiagOpts->ShowSourceRanges && !Ranges.empty()) {
908 if (DiagOpts->ShowLocation && PLoc.isValid())
917 if (DiagOpts->ShowLocation && PLoc.isValid())
927 if (DiagOpts->ShowLocation && PLoc.isValid())
1150 if (!DiagOpts->ShowCarets)
1176 const unsigned MaxLines = DiagOpts->SnippetLineLimit;
1215 const SourceColumnMap sourceColMap(SourceLine, DiagOpts->TabStop);
1240 unsigned Columns = DiagOpts->MessageLength;
1249 if (DiagOpts->ShowSourceRanges) {
1262 if (DiagOpts->ShowColors)
1265 if (DiagOpts->ShowColors)
1270 if (DiagOpts->ShowColors)
1273 if (DiagOpts->ShowSourceRanges)
1276 if (DiagOpts->ShowColors)
1296 = printableTextForNextCharacter(line, &i, DiagOpts->TabStop);
1299 if (DiagOpts->ShowColors && was_printable == print_reversed) {
1304 if (DiagOpts->ShowColors)
1312 if (print_reversed && DiagOpts->ShowColors)
1315 if (print_reversed && DiagOpts->ShowColors)
1323 if (!DiagOpts->ShowParseableFixits)
tools/clang/lib/Frontend/TextDiagnosticPrinter.cpp 136 TextDiagnostic::printDiagnosticLevel(OS, Level, DiagOpts->ShowColors,
137 DiagOpts->CLFallbackMode);
140 DiagOpts->MessageLength,
141 DiagOpts->ShowColors);
tools/clang/lib/Lex/PPMacroExpansion.cpp 1744 return !getDiagnostics().getDiagnosticIDs()->
tools/clang/lib/Rewrite/RewriteRope.cpp 780 memcpy(AllocBuffer->Data+AllocOffs, Start, Len);
tools/clang/lib/Serialization/ASTReader.cpp 477 Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
5746 DiagOpts->Warnings.push_back(ReadString(Record, Idx));
5748 DiagOpts->Remarks.push_back(ReadString(Record, Idx));
tools/clang/lib/Serialization/ModuleManager.cpp 166 NewModule->Buffer = &ModuleCache->addBuiltPCM(FileName, std::move(Buffer));
tools/clang/lib/StaticAnalyzer/Checkers/AnalysisOrderChecker.cpp 57 AnalyzerOptions &Opts = State->getStateManager().getOwningEngine()
tools/clang/lib/StaticAnalyzer/Checkers/ArrayBoundChecker.cpp 61 ProgramStateRef StInBound = state->assumeInBound(Idx, NumElements, true);
62 ProgramStateRef StOutBound = state->assumeInBound(Idx, NumElements, false);
tools/clang/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp 164 state->assume(*lowerBoundToCheck);
204 state->assume(*upperboundToCheck);
tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp 141 if (State->isNull(C.getSVal(E)).isConstrainedTrue()) {
156 if (!State->isNull(msg.getArgSVal(Arg)).isConstrainedTrue())
566 std::tie(stateNonNull, stateNull) = state->assume(*DefArgVal);
867 std::tie(StNonNil, StNil) = State->assume(*KnownCollection);
898 ElementLoc = State->getLValue(ElemDecl, LCtx);
900 ElementLoc = State->getSVal(Element, LCtx).getAs<Loc>();
907 SVal Val = State->getSVal(*ElementLoc);
908 return State->assume(Val.castAs<DefinedOrUnknownSVal>(), true);
919 const SymbolRef *CountS = State->get<ContainerCountMap>(CollectionS);
921 const bool *KnownNonEmpty = State->get<ContainerNonEmptyMap>(CollectionS);
923 return State->set<ContainerNonEmptyMap>(CollectionS, Assumption);
941 return State->assume(*CountGreaterThanZero, Assumption);
1042 State = State->set<ContainerCountMap>(ContainerS, CountS);
1044 if (const bool *NonEmpty = State->get<ContainerNonEmptyMap>(ContainerS)) {
1045 State = State->remove<ContainerNonEmptyMap>(ContainerS);
1113 State = State->remove<ContainerCountMap>(Sym);
1114 State = State->remove<ContainerNonEmptyMap>(Sym);
1124 ContainerCountMapTy Tracked = State->get<ContainerCountMap>();
1129 State = State->remove<ContainerCountMap>(Sym);
1130 State = State->remove<ContainerNonEmptyMap>(Sym);
1181 return State->assume(*DV, true);
tools/clang/lib/StaticAnalyzer/Checkers/BlockInCriticalSectionChecker.cpp 153 unsigned mutexCount = State->get<MutexCounter>();
155 State = State->set<MutexCounter>(--mutexCount);
158 State = State->set<MutexCounter>(++mutexCount);
tools/clang/lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp 52 state = state->assume(Arg.castAs<DefinedOrUnknownSVal>(), true);
74 C.addTransition(state->BindExpr(CE, LCtx, Arg));
96 state = state->assume(extentMatchesSizeArg, true);
99 C.addTransition(state->BindExpr(CE, LCtx, loc::MemRegionVal(R)));
127 C.addTransition(state->BindExpr(CE, LCtx, V));
tools/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp 276 return state->assume(svalBuilder.evalEQ(state, *val, zero));
340 ProgramStateRef StInBound = state->assumeInBound(Idx, Size, true);
341 ProgramStateRef StOutBound = state->assumeInBound(Idx, Size, false);
430 BufVal = state->getSVal(SecondBuf, LCtx);
469 SVal firstVal = state->getSVal(First, LCtx);
470 SVal secondVal = state->getSVal(Second, LCtx);
483 state->assume(svalBuilder.evalEQ(state, *firstLoc, *secondLoc));
504 std::tie(stateTrue, stateFalse) = state->assume(*reverseTest);
519 SVal LengthVal = state->getSVal(Size, LCtx);
549 std::tie(stateTrue, stateFalse) = state->assume(*OverlapTest);
697 state->assume(willOverflow.castAs<DefinedOrUnknownSVal>());
748 return state->remove<CStringLength>(MR);
750 return state->set<CStringLength>(MR, strLength);
760 const SVal *Recorded = state->get<CStringLength>(MR);
784 state = state->assume(evalLength.castAs<DefinedOrUnknownSVal>(), true);
786 state = state->set<CStringLength>(MR, strLength);
901 SVal BufVal = state->getSVal(FirstBuf, LCtx);
903 SVal LengthVal = state->getSVal(Size, LCtx);
947 ProgramStateRef StInBound = state->assumeInBound(Idx, ExtentSize, true);
998 return state->invalidateRegions(R, E, C.blockCount(), LCtx,
1006 return state->killBinding(*L);
1079 State->assume(svalBuilder.evalEQ(State, Extent, *SizeNL));
1097 State = State->bindDefaultZero(svalBuilder.makeLoc(BR),
1122 State->assume(NewStrLenGESize.castAs<DefinedOrUnknownSVal>(), true),
1148 SVal sizeVal = state->getSVal(Size, LCtx);
1156 SVal destVal = state->getSVal(Dest, LCtx);
1161 stateZeroSize = stateZeroSize->BindExpr(CE, LCtx, destVal);
1177 SVal srcVal = state->getSVal(Source, LCtx);
1214 state = state->BindExpr(CE, LCtx, lastElement);
1218 state = state->BindExpr(CE, LCtx, destVal);
1286 SVal sizeVal = state->getSVal(Size, LCtx);
1297 state = state->BindExpr(CE, LCtx,
1309 state->getSVal(Left, LCtx).castAs<DefinedOrUnknownSVal>();
1311 state->getSVal(Right, LCtx).castAs<DefinedOrUnknownSVal>();
1316 std::tie(StSameBuf, StNotSameBuf) = state->assume(SameBuf);
1324 state = StSameBuf->BindExpr(CE, LCtx,
1339 state = state->BindExpr(CE, LCtx, CmpV);
1366 SVal maxlenVal = state->getSVal(maxlenExpr, LCtx);
1376 stateZeroSize = stateZeroSize->BindExpr(CE, LCtx, zero);
1390 SVal ArgVal = state->getSVal(Arg, LCtx);
1414 SVal maxlenVal = state->getSVal(maxlenExpr, LCtx);
1423 std::tie(stateStringTooLong, stateStringNotTooLong) = state->assume(
1447 state = state->assume(C.getSValBuilder().evalBinOpNN(
1453 state = state->assume(C.getSValBuilder().evalBinOpNN(
1473 state = state->BindExpr(CE, LCtx, result);
1548 SVal DstVal = state->getSVal(Dst, LCtx);
1556 SVal srcVal = state->getSVal(srcExpr, LCtx);
1588 SVal lenVal = state->getSVal(lenExpr, LCtx);
1604 std::tie(stateSourceTooLong, stateSourceNotTooLong) = state->assume(
1657 StateZeroSize = StateZeroSize->BindExpr(CE, LCtx, DstVal);
1659 StateZeroSize = StateZeroSize->BindExpr(CE, LCtx, *lenValNL);
1693 state = state->assume(
1705 state = state->assume(
1765 state = state->assume(sourceInResult.castAs<DefinedOrUnknownSVal>(),
1778 state->assume(destInResult.castAs<DefinedOrUnknownSVal>(), true);
1878 state = state->BindExpr(CE, LCtx, Result);
1912 SVal s1Val = state->getSVal(s1, LCtx);
1919 SVal s2Val = state->getSVal(s2, LCtx);
1944 std::tie(StSameBuf, StNotSameBuf) = state->assume(SameBuf);
1949 StSameBuf = StSameBuf->BindExpr(CE, LCtx,
1978 SVal lenVal = state->getSVal(lenExpr, LCtx);
2020 state = state->assume(compareWithZeroVal, true);
2025 state = state->BindExpr(CE, LCtx, resultVal);
2046 SVal SearchStrVal = State->getSVal(SearchStrPtr, LCtx);
2053 SVal DelimStrVal = State->getSVal(DelimStr, LCtx);
2062 Result = State->getSVal(*SearchStrLoc, CharPtrTy);
2071 State = State->bindLoc(*SearchStrLoc,
2085 State = State->BindExpr(CE, LCtx, Result);
2115 SVal DstVal = State->getSVal(Dst, LCtx);
2122 State = State->BindExpr(CE, LCtx, ResultVal);
2137 SVal SizeVal = State->getSVal(Size, LCtx);
2145 SVal MemVal = State->getSVal(Mem, LCtx);
2150 StateZeroSize = StateZeroSize->BindExpr(CE, LCtx, MemVal);
2171 State = State->BindExpr(CE, LCtx, MemVal);
2294 Loc VarLoc = state->getLValue(D, C.getLocationContext());
2304 state = state->set<CStringLength>(MR, strLength);
2317 CStringLengthTy Entries = state->get<CStringLength>();
2337 CStringLengthTy::Factory &F = state->get_context<CStringLength>();
2361 return state->set<CStringLength>(Entries);
2367 CStringLengthTy Entries = state->get<CStringLength>();
2382 CStringLengthTy Entries = state->get<CStringLength>();
2386 CStringLengthTy::Factory &F = state->get_context<CStringLength>();
2396 state = state->set<CStringLength>(Entries);
tools/clang/lib/StaticAnalyzer/Checkers/CXXSelfAssignmentChecker.cpp 50 State->getSVal(SVB.getCXXThis(MD, LCtx->getStackFrame()));
51 auto Param = SVB.makeLoc(State->getRegion(MD->getParamDecl(0), LCtx));
52 auto ParamVal = State->getSVal(Param);
54 ProgramStateRef SelfAssignState = State->bindLoc(Param, ThisVal, LCtx);
64 ProgramStateRef NonSelfAssignState = State->bindLoc(Param, ParamVal, LCtx);
tools/clang/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp 174 const SVal PSV = State->getSVal(SValMemRegion, C.getASTContext().CharTy);
270 FindUninitializedField F(C.getState()->getStateManager().getStoreManager(),
320 SVal L = State->getSVal(Callee, LCtx);
331 std::tie(StNonNull, StNull) = State->assume(L.castAs<DefinedOrUnknownSVal>());
386 State->assume(V.castAs<DefinedOrUnknownSVal>());
559 C.addTransition(state->BindExpr(Msg.getOriginExpr(), LCtx, V), &Tag);
597 C.addTransition(state->BindExpr(Msg.getOriginExpr(), LCtx, V), &Tag);
tools/clang/lib/StaticAnalyzer/Checkers/CastValueChecker.cpp 159 ProgramStateRef State = C.getState()->assume(DV, IsNonNullParam);
212 State->BindExpr(Call.getOriginExpr(), C.getLocationContext(), V, false),
252 State->BindExpr(Call.getOriginExpr(), C.getLocationContext(),
280 if (ProgramStateRef State = C.getState()->assume(DV, false))
281 C.addTransition(State->BindExpr(Call.getOriginExpr(),
353 std::tie(NonNullState, NullState) = C.getState()->assume(DV);
369 std::tie(NonNullState, NullState) = C.getState()->assume(DV);
tools/clang/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp 269 SymbolSet::Factory &F = State->getStateManager().get_context<SymbolSet>();
276 if (const SymbolSet *CurrSet = State->get<UnreleasedIvarMap>(SelfSymbol))
284 SVal LVal = State->getLValue(PropImpl->getPropertyIvarDecl(), SelfVal);
289 SVal InitialVal = State->getSVal(LValLoc.getValue());
299 State = State->set<UnreleasedIvarMap>(SelfSymbol, RequiredReleases);
406 if (State->get<UnreleasedIvarMap>().isEmpty())
451 if (State->get<UnreleasedIvarMap>().isEmpty())
471 State = State->remove<UnreleasedIvarMap>(Sym);
503 const SymbolSet *OldUnreleased = State->get<UnreleasedIvarMap>(SelfSym);
508 SymbolSet::Factory &F = State->getStateManager().get_context<SymbolSet>();
532 if (State->getStateManager()
585 State = State->remove<UnreleasedIvarMap>(SelfSym);
587 State = State->set<UnreleasedIvarMap>(SelfSym, NewUnreleased);
599 assert(!LCtx->inTopFrame() || State->get<UnreleasedIvarMap>().isEmpty());
861 const SymbolSet *Unreleased = State->get<UnreleasedIvarMap>(Instance);
866 SymbolSet::Factory &F = State->getStateManager().get_context<SymbolSet>();
877 return State->remove<UnreleasedIvarMap>(Instance);
880 return State->set<UnreleasedIvarMap>(Instance, NewUnreleased);
941 M.getState()->assume(Arg.castAs<DefinedOrUnknownSVal>());
955 SVal LVal = State->getLValue(PropIvarDecl, ReceiverVal);
960 SVal CurrentValInIvar = State->getSVal(LValLoc.getValue());
986 SelfValOut = State->getSVal(State->getRegion(SelfDecl, LCtx));
986 SelfValOut = State->getSVal(State->getRegion(SelfDecl, LCtx));
tools/clang/lib/StaticAnalyzer/Checkers/ChrootChecker.cpp 80 ProgramStateManager &Mgr = state->getStateManager();
90 ProgramStateManager &Mgr = state->getStateManager();
93 const void *k = state->FindGDM(ChrootChecker::getTag());
122 void *const* k = C.getState()->FindGDM(ChrootChecker::getTag());
tools/clang/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp 220 std::tie(notNullState, nullState) = state->assume(location);
263 std::tie(StNonNull, StNull) = State->assume(V.castAs<DefinedOrUnknownSVal>());
tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp 119 State->get<MostSpecializedTypeArgsMap>();
124 State = State->remove<MostSpecializedTypeArgsMap>(I->first);
478 State = State->set<MostSpecializedTypeArgsMap>(Sym, StaticLowerBound);
484 State = State->set<MostSpecializedTypeArgsMap>(Sym, WithMostInfo);
502 State = State->set<MostSpecializedTypeArgsMap>(Sym, WithMostInfo);
510 State = State->set<MostSpecializedTypeArgsMap>(Sym, WithMostInfo);
556 State->get<MostSpecializedTypeArgsMap>(Sym);
568 State = State->remove<MostSpecializedTypeArgsMap>(Sym);
712 State->get<MostSpecializedTypeArgsMap>(Sym);
789 State->get<MostSpecializedTypeArgsMap>(ArgSym);
840 State = State->set<MostSpecializedTypeArgsMap>(RetSym, InferredType);
851 State->get<MostSpecializedTypeArgsMap>(RecSym);
893 if (!State->get<MostSpecializedTypeArgsMap>(RetSym)) {
894 State = State->set<MostSpecializedTypeArgsMap>(RetSym, ResultPtrType);
930 state->get<MostSpecializedTypeArgsMap>(Sym);
932 statePrev->get<MostSpecializedTypeArgsMap>(Sym);
tools/clang/lib/StaticAnalyzer/Checkers/EnumCastOutOfRangeChecker.cpp 49 return static_cast<bool>(PS->assume(ElemEqualsValueToCast, true));
tools/clang/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp 113 SVal AssertionVal = State->getSVal(Assertion, LC);
120 State->assume(AssertionVal.castAs<DefinedOrUnknownSVal>());
237 State = State->BindExpr(CE, C.getLocationContext(),
244 C.getState()->dump();
257 State = State->add<MarkedSymbols>(Sym);
264 const MarkedSymbolsTy &Syms = State->get<MarkedSymbols>();
274 State = State->remove<MarkedSymbols>(Sym);
277 for (auto I : State->get<DenotedSymbols>()) {
280 State = State->remove<DenotedSymbols>(Sym);
336 C.addTransition(C.getState()->set<DenotedSymbols>(Sym, E));
348 if (const StringLiteral *const *SLPtr = State->get<DenotedSymbols>(S)) {
tools/clang/lib/StaticAnalyzer/Checkers/GTestChecker.cpp 140 BooleanArgVal = C.getState()->getSVal(BooleanArgVal.castAs<Loc>());
262 State->getLValue(SuccessField, Instance).getAs<Loc>();
266 return State->getSVal(*FieldLoc);
tools/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp 501 TaintArgsOnPostVisitTy TaintArgs = State->get<TaintArgsOnPostVisit>();
523 State = State->remove<TaintArgsOnPostVisit>();
580 return State->getSVal(*AddrLoc, ValTy);
617 State = State->add<TaintArgsOnPostVisit>(ReturnValueIndex);
625 State = State->add<TaintArgsOnPostVisit>(ArgNum);
641 State = State->add<TaintArgsOnPostVisit>(i);
tools/clang/lib/StaticAnalyzer/Checkers/InnerPointerChecker.cpp 64 RawPtrMapTy Map = State->get<RawPtrMap>();
137 if (const PtrSet *PS = State->get<RawPtrMap>(MR)) {
144 State = State->remove<RawPtrMap>(MR);
211 PtrSet::Factory &F = State->getStateManager().get_context<PtrSet>();
212 const PtrSet *SetPtr = State->get<RawPtrMap>(ObjRegion);
217 State = State->set<RawPtrMap>(ObjRegion, Set);
237 PtrSet::Factory &F = State->getStateManager().get_context<PtrSet>();
238 RawPtrMapTy RPM = State->get<RawPtrMap>();
243 State = State->remove<RawPtrMap>(Entry.first);
245 if (const PtrSet *OldSet = State->get<RawPtrMap>(Entry.first)) {
252 ? State->remove<RawPtrMap>(Entry.first)
253 : State->set<RawPtrMap>(Entry.first, CleanedUpSet);
268 RawPtrMapTy Map = State->get<RawPtrMap>();
tools/clang/lib/StaticAnalyzer/Checkers/IteratorChecker.cpp 781 auto RegionMap = State->get<IteratorRegionMap>();
789 auto SymbolMap = State->get<IteratorSymbolMap>();
797 auto ContMap = State->get<ContainerMap>();
818 auto RegionMap = State->get<IteratorRegionMap>();
824 if (!isBoundThroughLazyCompoundVal(State->getEnvironment(), Reg.first)) {
825 State = State->remove<IteratorRegionMap>(Reg.first);
830 auto SymbolMap = State->get<IteratorSymbolMap>();
833 State = State->remove<IteratorSymbolMap>(Sym.first);
837 auto ContMap = State->get<ContainerMap>();
843 State = State->remove<ContainerMap>(Cont.first);
914 StateTrue = StateTrue->assume(*ConditionVal, true);
919 StateFalse = StateFalse->assume(*ConditionVal, false);
999 const auto val = State->getRawSVal(*loc);
1036 Value = State->getRawSVal(*ValAsLoc);
1951 auto &SymMgr = State->getSymbolManager();
1974 auto &SymMgr = State->getSymbolManager();
1990 return State->get<ContainerMap>(Cont);
1995 return State->set<ContainerMap>(Cont, CData);
2002 return State->get<IteratorRegionMap>(Reg);
2004 return State->get<IteratorSymbolMap>(Sym);
2006 return State->get<IteratorRegionMap>(LCVal->getRegion());
2015 return State->set<IteratorRegionMap>(Reg, Pos);
2017 return State->set<IteratorSymbolMap>(Sym, Pos);
2019 return State->set<IteratorRegionMap>(LCVal->getRegion(), Pos);
2027 return State->remove<IteratorRegionMap>(Reg);
2029 return State->remove<IteratorSymbolMap>(Sym);
2031 return State->remove<IteratorRegionMap>(LCVal->getRegion());
2038 auto &SVB = State->getStateManager().getSValBuilder();
2052 auto NewState = State->assume(comparison.castAs<DefinedSVal>(), Equal);
2069 auto RegionMap = State->get<IteratorRegionMap>();
2075 auto SymbolMap = State->get<IteratorSymbolMap>();
2105 SValBuilder &SVB = State->getStateManager().getSValBuilder();
2119 NewState = NewState->assume(*DV, true);
2129 NewState = NewState->assume(*DV, true);
2140 auto &RegionMapFactory = State->get_context<IteratorRegionMap>();
2141 auto RegionMap = State->get<IteratorRegionMap>();
2151 State = State->set<IteratorRegionMap>(RegionMap);
2153 auto &SymbolMapFactory = State->get_context<IteratorSymbolMap>();
2154 auto SymbolMap = State->get<IteratorSymbolMap>();
2164 State = State->set<IteratorSymbolMap>(SymbolMap);
2284 auto &BVF = State->getBasicVals();
2357 auto &SVB = State->getStateManager().getSValBuilder();
2365 return !State->assume(comparison.castAs<DefinedSVal>(), false);
tools/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp 675 const LocalizedState *LS = C.getState()->get<LocalizedMemMap>(mt);
688 const LocalizedState *LS = C.getState()->get<LocalizedMemMap>(mt);
701 C.getState()->set<LocalizedMemMap>(mt, LocalizedState::getLocalized());
711 ProgramStateRef State = C.getState()->set<LocalizedMemMap>(
tools/clang/lib/StaticAnalyzer/Checkers/MIGChecker.cpp 190 C.addTransition(C.getState()->add<RefCountedParameters>(PVD));
209 if (!PVD || State->contains<RefCountedParameters>(PVD))
221 C.addTransition(State->set<ReleasedParameter>(true), T);
229 if (!State->isNull(V).isConstrainedFalse())
238 if (!State->isNull(V).isConstrainedTrue())
266 if (!State->get<ReleasedParameter>())
tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp 95 const Request *const Req = N->getState()->get<RequestMap>(RequestRegion);
99 N->getFirstPred()->getState()->get<RequestMap>(RequestRegion);
tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp 40 const Request *const Req = State->get<RequestMap>(MR);
51 State = State->set<RequestMap>(MR, Request::State::Nonblocking);
80 const Request *const Req = State->get<RequestMap>(ReqRegion);
81 State = State->set<RequestMap>(ReqRegion, Request::State::Wait);
103 const auto &Requests = State->get<RequestMap>();
110 auto ReqMap = State->get<RequestMap>();
122 State = State->remove<RequestMap>(Req.first);
tools/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp 215 SymbolRef sym = SM.getBinding(State->getStore(), *X).getAsLocSymbol();
229 State = State->remove<AllocatedData>(AP.first);
271 if (const AllocationState *AS = State->get<AllocatedData>(V)) {
274 State = State->remove<AllocatedData>(V);
325 const AllocationState *AS = State->get<AllocatedData>(ArgSM);
379 State = State->remove<AllocatedData>(ArgSM);
389 State = State->remove<AllocatedData>(ArgSM);
440 State = State->set<AllocatedData>(V, AllocationState(ArgExpr, idx,
458 if (!N->getState()->get<AllocatedData>(Sym))
508 AllocatedDataTy AMap = State->get<AllocatedData>();
535 State = State->remove<AllocatedData>(I->first);
544 AllocatedDataTy AMap = State->get<AllocatedData>();
555 State = State->remove<AllocatedData>(I->first);
557 ConstraintManager &CMgr = State->getConstraintManager();
590 for (auto I : State->get<AllocatedData>()) {
593 State = State->remove<AllocatedData>(Sym);
614 State = State->remove<AllocatedData>(Sym);
624 const AllocationState *AS = N->getState()->get<AllocatedData>(Sym);
628 N->getFirstPred()->getState()->get<AllocatedData>(Sym);
655 AllocatedDataTy AMap = State->get<AllocatedData>();
tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp 808 state = state->remove<RegionState>(sym);
1033 std::tie(TrueState, FalseState) = State->assume(MaskedFlags);
1267 State->assume(SvalBuilder.evalEQ(State, *DefArgVal, Zero));
1274 const RefState *RS = State->get<RegionState>(Sym);
1277 return TrueState->set<RegionState>(Sym,
1286 return TrueState->add<ReallocSizeZeroSymbols>(Sym);
1413 State = State->assume(extentMatchesSize, true);
1530 State = State->BindExpr(CE, C.getLocationContext(), RetVal);
1533 State = State->bindDefaultInitial(RetVal, Init, LCtx);
1547 State = State->assume(extentMatchesSize, true);
1575 return State->set<RegionState>(Sym, RefState::getAllocated(Family, E));
1618 const SymbolRef *Ret = State->get<FreeReturnValue>(Sym);
1621 ConstraintManager &CMgr = State->getConstraintManager();
1768 std::tie(notNullState, nullState) = State->assume(location);
1822 const RefState *RsBase = State->get<RegionState>(SymBase);
1878 State = State->remove<FreeReturnValue>(SymBase);
1887 State = State->set<FreeReturnValue>(SymBase, RetStatusSymbol);
1896 return State->set<RegionState>(SymBase,
1900 return State->set<RegionState>(SymBase,
1950 if (C.getState()->contains<ReallocSizeZeroSymbols>(Sym))
1953 const RefState *RS = C.getState()->get<RegionState>(Sym);
2250 C.getState()->get<RegionState>(Sym)->getAllocationFamily();
2432 std::tie(StatePtrIsNull, StatePtrNotNull) = State->assume(PtrEQ);
2434 std::tie(StateSizeIsZero, StateSizeNotZero) = State->assume(SizeZero);
2488 stateRealloc = stateRealloc->set<ReallocPairs>(ToPtr,
2523 if (!State->get<RegionState>(Sym))
2530 SVal Val = State->getSVal(MR);
2561 const RefState *RS = C.getState()->get<RegionState>(Sym);
2621 RegionStateTy OldRS = state->get<RegionState>();
2622 RegionStateTy::Factory &F = state->get_context<RegionState>();
2637 assert(state->get<ReallocPairs>() ==
2638 C.getState()->get<ReallocPairs>());
2639 assert(state->get<FreeReturnValue>() ==
2640 C.getState()->get<FreeReturnValue>());
2645 ReallocPairsTy RP = state->get<ReallocPairs>();
2649 state = state->remove<ReallocPairs>(I->first);
2654 FreeReturnValueTy FR = state->get<FreeReturnValue>();
2658 state = state->remove<FreeReturnValue>(I->first);
2675 C.addTransition(state->set<RegionState>(RS), N);
2797 state->scanReachableSymbols<StopTrackingCallback>(Regions).getState();
2803 const RefState *RS = C.getState()->get<RegionState>(Sym);
2829 if (const RefState *RS = State->get<RegionState>(Sym))
2830 State = State->set<RegionState>(Sym, RefState::getEscaped(RS));
2851 if (const RefState *RS = C.getState()->get<RegionState>(Sym)) {
2855 else if (C.getState()->contains<ReallocSizeZeroSymbols>(Sym)) {
2884 RegionStateTy RS = state->get<RegionState>();
2887 ConstraintManager &CMgr = state->getConstraintManager();
2890 state = state->remove<RegionState>(I.getKey());
2895 ReallocPairsTy RP = state->get<ReallocPairs>();
2898 ConstraintManager &CMgr = state->getConstraintManager();
2904 if (const RefState *RS = state->get<RegionState>(ReallocSym)) {
2908 state = state->set<RegionState>(ReallocSym,
2912 state = state->remove<RegionState>(ReallocSym);
2919 state = state->remove<ReallocPairs>(I.getKey());
2995 ASTContext &ASTC = State->getStateManager().getContext();
3135 if (const RefState *RS = State->get<RegionState>(sym))
3138 State = State->set<RegionState>(sym, RefState::getEscaped(RS));
3145 ReallocPairsTy currMap = currState->get<ReallocPairs>();
3146 ReallocPairsTy prevMap = prevState->get<ReallocPairs>();
3176 const RefState *RSCurr = state->get<RegionState>(Sym);
3177 const RefState *RSPrev = statePrev->get<RegionState>(Sym);
3254 const auto *D = dyn_cast_or_null<NamedDecl>(Call->getDecl());
3320 if (!statePrev->get<RegionState>(FailedReallocSymbol)) {
3359 RegionStateTy RS = State->get<RegionState>();
3364 const RefState *RefS = State->get<RegionState>(I.getKey());
3387 return State->set<RegionState>(Sym, RefState::getReleased(Family, Origin));
tools/clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp 235 const RegionState *RS = State->get<TrackedRegionMap>(Region);
247 for (auto &E : State->get<TrackedRegionMap>()) {
249 State = State->remove<TrackedRegionMap>(E.first);
256 for (auto &E : State->get<TrackedRegionMap>()) {
283 const RegionState *TrackedObject = State->get<TrackedRegionMap>(Region);
285 StatePrev->get<TrackedRegionMap>(Region);
341 if (!State->get<TrackedRegionMap>(Region))
353 const RegionState *RS = State->get<TrackedRegionMap>(Region);
386 State = State->set<TrackedRegionMap>(Region, RegionState::getReported());
483 if (State->get<TrackedRegionMap>(ArgRegion))
490 State = State->set<TrackedRegionMap>(ArgRegion, RegionState::getMoved());
687 TrackedRegionMapTy TrackedRegions = State->get<TrackedRegionMap>();
694 State = State->remove<TrackedRegionMap>(Region);
739 TrackedRegionMapTy RS = State->get<TrackedRegionMap>();
tools/clang/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp 175 if (const unsigned *attachedFlags = state->get<T>(sym))
184 C.addTransition(state->set<T>(sym, true));
228 setFlag<NSErrorOut>(state, state->getSVal(loc.castAs<Loc>()), C);
233 setFlag<CFErrorOut>(state, state->getSVal(loc.castAs<Loc>()), C);
tools/clang/lib/StaticAnalyzer/Checkers/NonnullGlobalConstantsChecker.cpp 77 SVal V = State->getSVal(location.castAs<Loc>());
83 ProgramStateRef OutputState = State->assume(*Constr, true);
tools/clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp 264 ConditionTruthVal Nullness = State->isNull(Val);
299 const NullabilityState *TrackedNullab = State->get<NullabilityMap>(Region);
301 StatePrev->get<NullabilityMap>(Region);
346 auto StoredVal = State->getSVal(*RegionVal).getAs<loc::MemRegionVal>();
364 SVal LV = State->getLValue(ParamDecl, LocCtxt);
384 SVal SelfVal = State->getSVal(State->getRegion(SelfDecl, LocCtxt));
384 SVal SelfVal = State->getSVal(State->getRegion(SelfDecl, LocCtxt));
396 SVal LV = State->getLValue(IvarDecl, SelfVal);
406 if (State->get<InvariantViolated>())
427 C.addTransition(State->set<InvariantViolated>(true), N);
441 OriginalState = OriginalState->set<InvariantViolated>(true);
452 NullabilityMapTy Nullabilities = State->get<NullabilityMap>();
459 State = State->remove<NullabilityMap>(I->first);
475 if (Event.SinkNode->getState()->get<InvariantViolated>())
485 State->get<NullabilityMap>(Region);
532 if (State->get<InvariantViolated>())
599 State = State->set<InvariantViolated>(true);
609 State->get<NullabilityMap>(Region);
631 State = State->set<NullabilityMap>(Region,
646 if (State->get<InvariantViolated>())
701 State->get<NullabilityMap>(Region);
734 State = State->set<NullabilityMap>(
757 if (State->get<InvariantViolated>())
769 State = State->set<NullabilityMap>(Region, Nullability::Contradicted);
775 State->get<NullabilityMap>(Region);
779 State = State->set<NullabilityMap>(Region, Nullability::Nullable);
806 State->get<NullabilityMap>(SelfRegion);
826 if (State->get<InvariantViolated>())
849 State->set<NullabilityMap>(ReturnRegion, Nullability::Contradicted);
859 State->set<NullabilityMap>(ReturnRegion, Nullability::Contradicted);
871 State = State->set<NullabilityMap>(ReturnRegion,
884 State->get<NullabilityMap>(ReturnRegion);
899 State = State->set<NullabilityMap>(
921 State = State->set<NullabilityMap>(
941 if (State->get<InvariantViolated>())
960 State = State->set<NullabilityMap>(Region, Nullability::Contradicted);
967 State->get<NullabilityMap>(Region);
972 State = State->set<NullabilityMap>(Region,
980 State = State->set<NullabilityMap>(Region, Nullability::Contradicted);
1065 if (State->get<InvariantViolated>())
1119 State = State->set<InvariantViolated>(true);
1132 State->get<NullabilityMap>(ValueRegion);
1156 State = State->set<NullabilityMap>(
1164 State = State->set<NullabilityMap>(
1173 NullabilityMapTy B = State->get<NullabilityMap>();
1175 if (State->get<InvariantViolated>())
1182 if (!State->get<InvariantViolated>())
tools/clang/lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp 62 std::tie(notNullState, nullState) = state->assume(V.castAs<DefinedSVal>());
tools/clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp 83 State->set<ArraySizeMap>(ArraySym, SizeV.castAs<DefinedSVal>()));
126 const DefinedSVal *Size = State->get<ArraySizeMap>(ArraySym);
140 ProgramStateRef StInBound = State->assumeInBound(Idx, *Size, true, T);
141 ProgramStateRef StOutBound = State->assumeInBound(Idx, *Size, false, T);
169 State = State->remove<ArraySizeMap>(Sym);
176 ArraySizeMapTy Map = State->get<ArraySizeMap>();
tools/clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp 108 if (const unsigned *attachedFlags = state->get<SelfFlag>(sym))
121 state = state->set<SelfFlag>(sym, getSelfFlags(val, state) | flag);
148 if (!C.getState()->get<CalledInit>())
183 state = state->set<CalledInit>(true);
254 unsigned selfFlags = getSelfFlags(state->getSVal(argV.castAs<Loc>()), C);
255 C.addTransition(state->set<PreCallSelfFlags>(selfFlags));
259 C.addTransition(state->set<PreCallSelfFlags>(selfFlags));
273 SelfFlagEnum prevFlags = (SelfFlagEnum)state->get<PreCallSelfFlags>();
276 state = state->remove<PreCallSelfFlags>();
285 addSelfFlag(state, state->getSVal(argV.castAs<Loc>()), prevFlags, C);
311 addSelfFlag(state, state->getSVal(location.castAs<Loc>()), SelfFlag_Self,
330 State = State->remove<CalledInit>();
332 State = State->remove<SelfFlag>(sym);
339 SelfFlagTy FlagMap = State->get<SelfFlag>();
340 bool DidCallInit = State->get<CalledInit>();
341 SelfFlagEnum PreCallFlags = (SelfFlagEnum)State->get<PreCallSelfFlags>();
tools/clang/lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp 92 bool AlreadyCalled = State->contains<CalledSuperDealloc>(ReceiverSymbol);
125 State = State->add<CalledSuperDealloc>(ReceiverSymbol);
137 if (!State->contains<CalledSuperDealloc>(BaseSym))
208 if (State->contains<CalledSuperDealloc>(Sym)) {
239 ASTContext &Ctx = M.getState()->getStateManager().getContext();
255 Succ->getState()->contains<CalledSuperDealloc>(ReceiverSymbol);
257 Succ->getFirstPred()->getState()->contains<CalledSuperDealloc>(
tools/clang/lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp 109 SVal S = State->getSVal(Region);
131 if (const AllocKind *Kind = State->get<RegionState>(Region)) {
236 State = State->set<RegionState>(Region, AllocKind::Array);
253 State = State->set<RegionState>(Region, Kind);
271 State = State->set<RegionState>(Region, AllocKind::Reinterpreted);
288 if (const AllocKind *Kind = State->get<RegionState>(Region)) {
292 State = State->set<RegionState>(Region, AllocKind::Array);
329 if (State->isNull(RHSVal).isConstrainedTrue())
336 if (State->isNull(LHSVal).isConstrainedTrue())
tools/clang/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp 160 const LockState *lstate = state->get<LockMap>(lockR);
167 ConstraintManager &CMgr = state->getConstraintManager();
171 state = state->remove<LockMap>(lockR);
173 state = state->set<LockMap>(lockR, LockState::getUnlocked());
175 state = state->set<LockMap>(lockR, LockState::getDestroyed());
179 state = state->remove<DestroyRetVal>(lockR);
185 LockMapTy LM = State->get<LockMap>();
204 LockSetTy LS = State->get<LockSet>();
225 const SymbolRef *sym = state->get<DestroyRetVal>(lockR);
235 if (const LockState *LState = state->get<LockMap>(lockR)) {
260 std::tie(lockFail, lockSucc) = state->assume(retVal);
263 std::tie(lockSucc, lockFail) = state->assume(retVal);
273 lockSucc = state->assume(retVal, false);
283 lockSucc = lockSucc->add<LockSet>(lockR);
284 lockSucc = lockSucc->set<LockMap>(lockR, LockState::getLocked());
296 const SymbolRef *sym = state->get<DestroyRetVal>(lockR);
300 if (const LockState *LState = state->get<LockMap>(lockR)) {
319 LockSetTy LS = state->get<LockSet>();
339 state = state->set<LockSet>(LS.getTail());
342 state = state->set<LockMap>(lockR, LockState::getUnlocked());
356 const SymbolRef *sym = State->get<DestroyRetVal>(LockR);
360 const LockState *LState = State->get<LockMap>(LockR);
367 State = State->remove<LockMap>(LockR);
371 State = State->set<DestroyRetVal>(LockR, sym);
373 State = State->set<LockMap>(
376 State = State->set<LockMap>(
383 State = State->set<LockMap>(LockR, LockState::getDestroyed());
417 const SymbolRef *sym = State->get<DestroyRetVal>(LockR);
421 const struct LockState *LState = State->get<LockMap>(LockR);
423 State = State->set<LockMap>(LockR, LockState::getUnlocked());
468 DestroyRetValTy TrackedSymbols = State->get<DestroyRetVal>();
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp 29 return State->get<RefBindings>(Sym);
39 return State->set<RefBindings>(Sym, Val);
43 return State->remove<RefBindings>(Sym);
178 state = state->scanReachableSymbols<StopTrackingCallback>(Regions).getState();
250 state->getSVal(Ex, pred->getLocationContext()).getAsSymbol()) {
292 SymbolRef Sym = State->getSVal(*IVarLoc).getAsSymbol();
309 ConstraintManager &CMgr = State->getConstraintManager();
546 AssumeNonZeroReturn = AssumeNonZeroReturn->assume(*DL, true);
547 AssumeZeroReturn = AssumeZeroReturn->assume(*DL, false);
560 SVal PointeeVal = State->getSVal(ArgRegion);
926 SVal RetVal = state->getSVal(BindReturnTo, LCtx);
940 state = state->BindExpr(CE, LCtx, RetVal, /*Invalidate=*/false);
947 NullOutputState = NullOutputState->BindExpr(
954 state = state->assume(*L, /*assumption=*/true);
985 SymbolRef Sym = state->getSValAsScalarOrLoc(RetE, C.getLocationContext())
1145 state = state->scanReachableSymbols<StopTrackingCallback>(val).getState();
1159 RefBindingsTy B = state->get<RefBindings>();
1165 RefBindingsTy::Factory &RefBFactory = state->get_context<RefBindings>();
1166 ConstraintManager &CMgr = state->getConstraintManager();
1178 state = state->set<RefBindings>(B);
1349 SymbolRef Sym = state->getSVal(state->getRegion(Param, LCtx)).getAsSymbol();
1349 SymbolRef Sym = state->getSVal(state->getRegion(Param, LCtx)).getAsSymbol();
1377 RefBindingsTy B = state->get<RefBindings>();
1400 B = state->get<RefBindings>();
1417 for (const auto &I: state->get<RefBindings>()) {
1445 RefBindingsTy::Factory &F = state->get_context<RefBindings>();
1446 RefBindingsTy B = state->get<RefBindings>();
1451 state = state->set<RefBindings>(B);
1458 RefBindingsTy B = State->get<RefBindings>();
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp 176 for (unsigned Idx = 0; Idx < (*CE)->getNumArgs(); Idx++)
177 if (const MemRegion *MR = (*CE)->getArgSVal(Idx).getAsRegion())
179 if (CurrSt->getSVal(MR, TR->getValueType()).getAsSymExpr() == Sym)
215 CallEventManager &Mgr = CurrSt->getStateManager().getCallEventManager();
219 SVal X = CurrSt->getSValAsScalarOrLoc(CE->getCallee(), LCtx);
240 switch (Call->getMessageKind()) {
293 const ParmVarDecl *PVD = (*CE)->parameters()[*Idx];
298 QualType RT = (*CE)->getResultType();
300 SVal RV = (*CE)->getReturnValue();
301 if (CurrSt->isNull(RV).isConstrainedTrue()) {
303 } else if (CurrSt->isNonNull(RV).isConstrainedTrue()) {
385 ArrayRef<const ParmVarDecl *> Parameters = Call->parameters();
386 for (unsigned I=0; I < Call->getNumArgs() && I < Parameters.size(); ++I) {
392 if (SymbolRef SR = Call->getArgSVal(I).getAsLocSymbol()) {
566 if (CurrSt->getSValAsScalarOrLoc(*AI, LCtx).getAsLocSymbol() != Sym)
574 if (CurrSt->getSValAsScalarOrLoc(receiver, LCtx)
598 if (CurrSt->getSValAsScalarOrLoc(Exp, LCtx).getAsLocSymbol() == Sym) {
682 SVal RecV = St->getSVal(RecExpr, NContext);
tools/clang/lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp 61 ProgramStateRef StInBound = state->assumeInBound(Idx, NumElements, true);
62 ProgramStateRef StOutBound = state->assumeInBound(Idx, NumElements, false);
tools/clang/lib/StaticAnalyzer/Checkers/ReturnUndefChecker.cpp 106 std::tie(StNonNull, StNull) = C.getState()->assume(RetVal);
tools/clang/lib/StaticAnalyzer/Checkers/ReturnValueChecker.cpp 79 return C.getState()->isNull(*ReturnDV).isConstrainedTrue();
81 return C.getState()->isNull(*ReturnDV).isConstrainedFalse();
113 State = State->assume(ReturnV.castAs<DefinedOrUnknownSVal>(), ExpectedValue);
137 SVal ReturnV = State->getSVal(RS->getRetValue(), C.getLocationContext());
tools/clang/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp 99 state = state->remove<StreamMap>(sym);
132 State = State->set<StreamMap>(FileDesc, StreamState::getOpened());
151 const StreamState *SS = State->get<StreamMap>(FileDesc);
158 State = State->set<StreamMap>(FileDesc, StreamState::getClosed());
167 ConstraintManager &CMgr = State->getConstraintManager();
178 StreamMapTy TrackedStreams = State->get<StreamMap>();
190 State = State->remove<StreamMap>(Sym);
264 State = State->remove<StreamMap>(Sym);
tools/clang/lib/StaticAnalyzer/Checkers/SmartPtrModeling.cpp 61 State->BindExpr(Call.getOriginExpr(), C.getLocationContext(),
tools/clang/lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp 143 SVal Val = C.getState()->getSVal(I.getCapturedRegion());
323 State->getStateManager().getStoreManager().iterBindings(State->getStore(),
323 State->getStateManager().getStoreManager().iterBindings(State->getStore(),
tools/clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp 242 ProgramStateManager &Mgr = State->getStateManager();
270 ProgramStateManager &Mgr = State->getStateManager();
321 ProgramStateManager &Mgr = State->getStateManager();
335 State = State->assume(*CompV, true);
391 State = State->BindExpr(CE, LC, V);
tools/clang/lib/StaticAnalyzer/Checkers/StreamChecker.cpp 221 state = state->BindExpr(CE, C.getLocationContext(), RetVal);
232 stateNotNull->set<StreamMap>(Sym,StreamState::getOpened(CE));
234 stateNull->set<StreamMap>(Sym, StreamState::getOpenFailed(CE));
264 SVal Whence = state->getSVal(CE->getArg(2), C.getLocationContext());
363 const StreamState *SS = state->get<StreamMap>(Sym);
385 return state->set<StreamMap>(Sym, StreamState::getClosed(CE));
393 const StreamMapTy &Map = state->get<StreamMap>();
tools/clang/lib/StaticAnalyzer/Checkers/Taint.cpp 31 TaintMapTy TM = State->get<TaintMap>();
47 return addTaint(State, State->getSVal(S, LCtx), Kind);
67 State->getStateManager().getStoreManager()
92 ProgramStateRef NewState = State->set<TaintMap>(Sym, Kind);
102 if (const TaintTagType *T = State->get<TaintMap>(ParentSym))
110 const TaintedSubRegions *SavedRegs = State->get<DerivedSymTaint>(ParentSym);
111 TaintedSubRegions::Factory &F = State->get_context<TaintedSubRegions>();
115 ProgramStateRef NewState = State->set<DerivedSymTaint>(ParentSym, Regs);
122 SVal val = State->getSVal(S, LCtx);
164 if (const TaintTagType *Tag = State->get<TaintMap>(*SI)) {
178 State->get<DerivedSymTaint>(SD->getParentSymbol())) {
tools/clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp 151 State->add<DivZeroMap>(ZeroState(SR, C.getBlockID(), C.getStackFrame()));
162 return C.getState()->contains<DivZeroMap>(ZS);
185 DivZeroMapTy DivZeroes = State->get<DivZeroMap>();
189 DivZeroMapTy::Factory &F = State->get_context<DivZeroMap>();
197 C.addTransition(State->set<DivZeroMap>(DivZeroes));
tools/clang/lib/StaticAnalyzer/Checkers/TrustNonnullChecker.cpp 90 State = State->assume(*L, /*assumption=*/true);
109 State = State->assume(*L, /*assumption=*/true);
122 State = State->set<NonNullImplicationMap>(RetS, ArgS);
126 State = State->set<NullImplicationMap>(ArgS, RetS);
149 for (const std::pair<SymbolRef, SymbolRef> &P : State->get<MapName>())
151 State = State->remove<MapName>(P.first);
188 ConditionTruthVal TV = C.getState()->isNonNull(Receiver);
218 SValBuilder &SVB = InputState->getStateManager().getSValBuilder();
220 Negated ? InputState->get<NonNullImplicationMap>(Antecedent)
221 : InputState->get<NullImplicationMap>(Antecedent);
228 if ((Negated && InputState->isNonNull(AntecedentV).isConstrainedTrue())
229 || (!Negated && InputState->isNull(AntecedentV).isConstrainedTrue())) {
231 State = InputState->assume(ConsequentS.castAs<DefinedSVal>(), Negated);
237 State = State->remove<NonNullImplicationMap>(Antecedent);
238 State = State->remove<NullImplicationMap>(*Consequent);
240 State = State->remove<NullImplicationMap>(Antecedent);
241 State = State->remove<NonNullImplicationMap>(*Consequent);
tools/clang/lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp 49 return St->getSVal(Ex, LCtx).isUndef();
tools/clang/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp 73 state->getSVal(I.getOriginalRegion()).getAs<UndefinedVal>()) {
tools/clang/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp 55 ProgramStateRef StInBound = state->assumeInBound(Idx, NumElements, true);
56 ProgramStateRef StOutBound = state->assumeInBound(Idx, NumElements, false);
tools/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObjectChecker.cpp 219 for (const MemRegion *R : State->get<AnalyzedRegions>()) {
221 State = State->remove<AnalyzedRegions>(R);
250 if (State->getStateManager().getContext().getSourceManager().isInSystemHeader(
257 if (State->contains<AnalyzedRegions>(FR))
261 if (State->contains<AnalyzedRegions>(PointeeR)) {
264 State = State->add<AnalyzedRegions>(PointeeR);
267 State = State->add<AnalyzedRegions>(FR);
301 State->getLValue(I, loc::MemRegionVal(R)).castAs<loc::MemRegionVal>();
331 SVal V = State->getSVal(FieldVal);
357 const auto *BaseRegion = State->getLValue(BaseSpec, R)
464 SVal ObjectV = Context.getState()->getSVal(ThisLoc);
539 ASTContext &AC = State->getStateManager().getContext();
tools/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedPointee.cpp 141 SVal V = State->getSVal(FR);
206 SVal PointeeV = State->getSVal(R);
227 SVal V = State->getSVal(FR);
246 while (const MemRegion *Tmp = State->getSVal(R, DynT).getAsRegion()) {
tools/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp 249 std::tie(trueState, falseState) = state->assume(maskedFlags);
328 state->assume(argVal.castAs<DefinedSVal>());
tools/clang/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp 121 std::tie(stateNotZero, stateZero) = state->assume(sizeD);
171 state->getRegion(VD, LC)->getExtent(svalBuilder);
175 state = state->assume(sizeIsKnown, true);
tools/clang/lib/StaticAnalyzer/Checkers/ValistChecker.cpp 146 if (C.getState()->contains<InitializedVALists>(VAList))
178 Reg = C.getState()->getSVal(SV.castAs<Loc>()).getAsRegion();
198 if (!State->contains<InitializedVALists>(VAList))
206 InitializedVAListsTy TrackedVALists = State->get<InitializedVALists>();
212 State = State->remove<InitializedVALists>(Reg);
233 if (!State->contains<InitializedVALists>(Reg)) {
328 } else if (!State->contains<InitializedVALists>(Arg2) && !Symbolic) {
329 if (State->contains<InitializedVALists>(VAList)) {
330 State = State->remove<InitializedVALists>(VAList);
343 if (State->contains<InitializedVALists>(VAList)) {
351 State = State->add<InitializedVALists>(VAList);
368 if (!C.getState()->contains<InitializedVALists>(VAList)) {
374 State = State->remove<InitializedVALists>(VAList);
388 if (State->contains<InitializedVALists>(Reg) &&
389 !StatePrev->contains<InitializedVALists>(Reg))
391 else if (!State->contains<InitializedVALists>(Reg) &&
392 StatePrev->contains<InitializedVALists>(Reg))
tools/clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp 79 return State->get<VforkResultRegion>() != VFORK_RESULT_INVALID;
175 std::tie(ParentState, ChildState) = C.getState()->assume(*DVal);
177 ChildState = ChildState->set<VforkResultRegion>(LhsDeclReg);
198 static_cast<const MemRegion *>(State->get<VforkResultRegion>());
tools/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp 114 const ObjectState *ObState = State->get<CtorDtorMap>(Reg);
177 State->getSVal(SVB.getCXXThis(MD, LCtx->getStackFrame()));
180 State = State->set<CtorDtorMap>(Reg, ObjectState::CtorCalled);
182 State = State->remove<CtorDtorMap>(Reg);
191 State->getSVal(SVB.getCXXThis(MD, LCtx->getStackFrame()));
194 State = State->set<CtorDtorMap>(Reg, ObjectState::DtorCalled);
196 State = State->remove<CtorDtorMap>(Reg);
tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp 310 SVal PSV = N->getState()->getSVal(Reg->getRegion());
2344 ErrorNode->getState()->getStateManager().getContext().getSourceManager();
tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp 179 LLCV->getStore() == LeftNode->getState()->getStore() &&
180 RLCV->getStore() == RightNode->getState()->getStore();
197 return State->getSVal(State->getLValue(VD, LCtx));
197 return State->getSVal(State->getLValue(VD, LCtx));
201 if (auto FieldL = State->getSVal(ME, LCtx).getAs<Loc>())
202 return State->getRawSVal(*FieldL, FD->getType());
269 ProgramStateManager &Mgr = N->getState()->getStateManager();
283 SVal ValueAtN = N->getState()->getSVal(RegionOfInterest);
471 RuntimeDefinition RD = Call->getRuntimeDefinition();
477 return Call->parameters();
517 const SVal V = State->getSVal(FR);
566 potentiallyWritesIntoIvar(Call->getRuntimeDefinition().getDecl(),
586 for (unsigned I = 0; I < Call->getNumArgs() && I < parameters.size(); ++I) {
588 SVal V = Call->getArgSVal(I);
609 V = State->getSVal(MR, PT);
621 SVal ValueAtReturn = LastReturnState->getSVal(RegionOfInterest);
630 ValueAtReturn = LastReturnState->getSVal(RegionOfInterest);
833 AnalyzerOptions &Options = N->getState()->getAnalysisManager().options;
863 State->getLValue(VD, LCtx).getAsRegion()))
987 RetVal = State->getSVal(*LValue);
990 AnalyzerOptions &Options = State->getAnalysisManager().options;
996 EnableNullFPSuppression = State->isNull(*RetLoc).isConstrainedTrue();
1021 SVal V = State->getSVal(Ret, CalleeSFC);
1035 SVal RValue = State->getRawSVal(*LValue, RetE->getType());
1058 if (State->isNull(V).isConstrainedTrue()) {
1153 for (unsigned I = 0, E = Call->getNumArgs(); I != E; ++I) {
1154 Optional<Loc> ArgV = Call->getArgSVal(I).getAs<Loc>();
1158 const Expr *ArgE = Call->getArgExpr(I);
1163 if (!State->isNull(*ArgV).isConstrainedTrue())
1396 if (Succ->getState()->getSVal(R) != V)
1399 if (hasVisibleUpdate(Pred, Pred->getState()->getSVal(R), Succ, V)) {
1427 InitE = Call->getArgExpr(Param->getFunctionScopeIndex());
1486 if (auto KV = State->getSVal(OriginalR).getAs<KnownSVal>())
1542 return N->getState()->isNull(Constraint).isUnderconstrained();
1543 return (bool)N->getState()->assume(Constraint, !Assumption);
1606 AnalyzerOptions &Options = N->getState()->getAnalysisManager().options;
1610 assert(N->getState()->isNull(V).isConstrainedTrue() &&
1635 if (Succ->getState()->isNull(V).isConstrainedTrue())
1642 if (!Pred->getState()->isNull(V).isConstrainedTrue()) {
1645 assert(Succ->getState()->isNull(V).isConstrainedTrue());
1840 ProgramStateManager &StateMgr = N->getState()->getStateManager();
1955 if (LVState->getAnalysisManager().getAnalyzerOptions().ShouldTrackConditions)
1977 bool LVIsNull = LVState->isNull(LVal).isConstrainedTrue();
1997 SVal V = LVState->getRawSVal(loc::MemRegionVal(R));
2009 if (LVState->isNull(V).isConstrainedTrue())
2015 if (!DV->isZeroConstant() && LVState->isNull(*DV).isConstrainedTrue() &&
2030 SVal V = LVState->getSValAsScalarOrLoc(Inner, LVNode->getLocationContext());
2053 RVal = LVState->getRawSVal(L.getValue(), Inner->getType());
2055 RVal = LVState->getSVal(L->getRegion());
2088 if (state->isNull(V).isConstrainedTrue())
2262 CurrentState->getSVal(Cond, LCtx).isUnknownOrUndef();
2777 ArrayRef<ParmVarDecl *> parms = Call->parameters();
2780 const MemRegion *ArgReg = Call->getArgSVal(Idx).getAsRegion();
2803 SVal BoundVal = State->getSVal(R);
2859 const ConstraintRangeTy &NewCs = N->getState()->get<ConstraintRange>();
2861 N->getState()->get_context<ConstraintRange>();
tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp 70 ASTContext &Ctx = getState()->getStateManager().getContext();
250 State->getStateManager().getRegionManager().getVarRegion(PVD, SFC);
334 return Result->invalidateRegions(ValuesToInvalidate, getOriginExpr(),
377 CD.II = &getState()->getStateManager().getContext().Idents.get(
439 ASTContext &Ctx = getState()->getStateManager().getContext();
567 SubEngine &Engine = getState()->getStateManager().getOwningEngine();
595 SValBuilder &SVB = getState()->getStateManager().getSValBuilder();
795 ProgramStateManager &StateMgr = getState()->getStateManager();
870 SValBuilder &SVB = getState()->getStateManager().getSValBuilder();
915 SValBuilder &SVB = getState()->getStateManager().getSValBuilder();
952 SVal IvarLVal = getState()->getLValue(PropIvar, getReceiverSVal());
974 return getState()->getSVal(getState()->getRegion(SelfDecl, LCtx));
974 return getState()->getSVal(getState()->getRegion(SelfDecl, LCtx));
1107 getState()->getStateManager().getOwningEngine().getAnalysisManager();
1345 SValBuilder &SVB = getState()->getStateManager().getSValBuilder();
1396 SValBuilder &SVB = State->getStateManager().getSValBuilder();
1399 SVal ThisVal = State->getSVal(ThisPtr);
1412 SValBuilder &SVB = State->getStateManager().getSValBuilder();
1415 SVal ThisVal = State->getSVal(ThisPtr);
tools/clang/lib/StaticAnalyzer/Core/CheckerContext.cpp 105 ProgramStateManager &Mgr = State->getStateManager();
107 LHSVal = Mgr.getStoreManager().getBinding(State->getStore(),
119 std::tie(StTrue, StFalse) = State->assume(Eval.castAs<DefinedSVal>());
tools/clang/lib/StaticAnalyzer/Core/ConstraintManager.cpp 28 State->getStateManager().getRegionManager().getSymbolicRegion(Sym);
tools/clang/lib/StaticAnalyzer/Core/DynamicType.cpp 44 if (const DynamicTypeInfo *DTI = State->get<DynamicTypeMap>(MR))
61 return State->get<DynamicTypeMap>(MR);
68 const auto *Lookup = State->get<DynamicCastMap>().lookup(MR);
81 State = State->set<DynamicTypeMap>(MR->StripCasts(), NewTy);
102 State = State->set<DynamicTypeMap>(MR, CastToTy);
109 CastSet::Factory &F = State->get_context<CastSet>();
111 const CastSet *TempSet = State->get<DynamicCastMap>(MR);
115 State = State->set<DynamicCastMap>(MR, Set);
126 State = State->remove<DynamicCastMap>(Elem.first);
132 return removeDead(State, State->get<DynamicTypeMap>(), SR);
136 return removeDead(State, State->get<DynamicCastMap>(), SR);
144 const DynamicTypeMapTy &Map = State->get<DynamicTypeMap>();
180 const DynamicCastMapTy &Map = State->get<DynamicCastMap>();
tools/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp 118 if (state->store != pred_state->store || state->GDM != pred_state->GDM ||
118 if (state->store != pred_state->store || state->GDM != pred_state->GDM ||
118 if (state->store != pred_state->store || state->GDM != pred_state->GDM ||
118 if (state->store != pred_state->store || state->GDM != pred_state->GDM ||
288 getFirstPred()->getState()->getID() == getState()->getID() &&
288 getFirstPred()->getState()->getID() == getState()->getID() &&
tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp 253 const MemRegion *R = state->getRegion(PD, InitLoc);
257 SVal V = state->getSVal(loc::MemRegionVal(R));
268 if (ProgramStateRef newState = state->assume(*Constraint, true))
279 const MemRegion *R = state->getRegion(SelfD, InitLoc);
280 SVal V = state->getSVal(loc::MemRegionVal(R));
284 state = state->assume(*LV, true);
297 SVal V = state->getSVal(L);
299 state = state->assume(*LV, true);
318 SVal InitValWithAdjustments = State->getSVal(InitWithAdjustments, LC);
336 ProgramStateManager &StateMgr = State->getStateManager();
376 State = State->BindExpr(Result, LC, *V);
407 State = State->invalidateRegions(Reg, InitWithAdjustments,
422 SVal InitVal = State->getSVal(Init, LC);
426 State = State->bindLoc(BaseReg.castAs<Loc>(), InitVal, LC, false);
438 State->bindLoc(Reg.castAs<Loc>(), InitValWithAdjustments, LC, false);
440 State = State->bindLoc(BaseReg.castAs<Loc>(), InitVal, LC, false);
447 State = State->BindExpr(Result, LC, Reg);
449 State = State->BindExpr(Result, LC, InitValWithAdjustments);
467 assert(!State->get<ObjectsUnderConstruction>(Key) ||
470 return State->set<ObjectsUnderConstruction>(Key, V);
478 return Optional<SVal>::create(State->get<ObjectsUnderConstruction>(Key));
486 assert(State->contains<ObjectsUnderConstruction>(Key));
487 return State->remove<ObjectsUnderConstruction>(Key);
496 return State->set<ObjectsUnderConstruction>(Key, UnknownVal());
504 assert(State->contains<ObjectsUnderConstruction>(Key));
505 return State->remove<ObjectsUnderConstruction>(Key);
512 return State->contains<ObjectsUnderConstruction>(Key);
521 for (auto I : State->get<ObjectsUnderConstruction>())
566 for (const auto &I : State->get<ObjectsUnderConstruction>()) {
579 for (const auto &I : State->get<ObjectsUnderConstruction>()) {
606 if (LCtx && !State->get<ObjectsUnderConstruction>().isEmpty()) {
719 for (auto I : CleanedState->get<ObjectsUnderConstruction>()) {
831 SVal thisVal = State->getSVal(svalBuilder.getCXXThis(decl, stackFrame));
851 FieldLoc = State->getLValue(BMI->getIndirectMember(), thisVal);
854 FieldLoc = State->getLValue(BMI->getMember(), thisVal);
865 SVal LValue = State->getSVal(Init, stackFrame);
868 InitVal = State->getSVal(*LValueLoc);
878 InitVal = State->getSVal(BMI->getInit(), stackFrame);
957 SVal dest = state->getLValue(varDecl, Pred->getLocationContext());
961 const MemRegion *ValueRegion = state->getSVal(Region).getAsRegion();
992 SVal ArgVal = State->getSVal(Arg, LCtx);
996 if (State->isNull(ArgVal).isConstrainedTrue()) {
1031 SVal ThisVal = Pred->getState()->getSVal(ThisPtr);
1054 Loc ThisLoc = State->getSVal(ThisStorageLoc).castAs<Loc>();
1055 SVal FieldVal = State->getLValue(Member, ThisLoc);
1191 State->scanReachableSymbols<CollectReachableSymbolsCallback>(V);
1324 state = state->BindExpr(S, Pred->getLocationContext(),
1440 State = State->BindExpr(S, LCtx, *ConstantVal);
1474 ProgramStateRef State = N->getState()->BindExpr(Ex, LCtx, result);
1483 SVal Val = State->getSVal(Child, LCtx);
1541 state->BindExpr(B, Pred->getLocationContext(),
1542 state->getSVal(B->getRHS(),
1804 state->BindExpr(SE, Pred->getLocationContext(),
1805 state->getSVal(LastExpr,
1830 SVal V = state->getSVal(Result, Pred->getLocationContext());
1832 state->BindExpr(S, Pred->getLocationContext(), V));
1836 state->BindExpr(S, Pred->getLocationContext(),
1889 NewNodeState->set<ReplayWithoutInlining>(const_cast<Stmt *>(CE));
2024 return state->getSVal(Ex, LCtx);
2128 SVal X = PrevState->getSVal(Condition, PredI->getLocationContext());
2159 std::tie(StTrue, StFalse) = PrevState->assume(V);
2196 bool initHasRun = state->contains<InitializedGlobalsSet>(VD);
2200 state = state->add<InitializedGlobalsSet>(VD);
2213 SVal V = state->getSVal(builder.getTarget(), builder.getLocationContext());
2285 for (auto I : State->get<ObjectsUnderConstruction>())
2294 State = State->remove<ObjectsUnderConstruction>(I.first);
2341 SVal CondV_untested = state->getSVal(CondE, builder.getLocationContext());
2378 DefaultSt->assumeInclusiveRange(*NL, V1, V2);
2451 SVal CXXThisVal = state->getSVal(CXXThis);
2452 VInfo = std::make_pair(state->getLValue(FD, CXXThisVal), FD->getType());
2457 VInfo = std::make_pair(state->getLValue(VD, LocCtxt), VD->getType());
2466 V = state->getSVal(R);
2471 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V), nullptr,
2478 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V));
2483 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V), nullptr,
2495 state = state->assume(V.castAs<DefinedOrUnknownSVal>(), true);
2496 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V), nullptr,
2543 SVal V = state->getLValue(T,
2544 state->getSVal(Idx, LCtx),
2545 state->getSVal(Base, LCtx));
2546 Bldr.generateNode(A, Node, state->BindExpr(A, LCtx, V), nullptr,
2590 state = state->BindExpr(M, LCtx, MDVal);
2602 MR ? loc::MemRegionVal(MR) : state->getSVal(BaseExpr, LCtx);
2605 SVal L = state->getLValue(field, baseExprVal);
2623 L = state->getSVal(R);
2628 Bldr.generateNode(M, I, state->BindExpr(M, LCtx, L), nullptr,
2659 SVal SubExprVal = State->getSVal(SubExpr, LCtx);
2663 State = State->invalidateRegions(ValuesToInvalidate, AE,
2670 State = State->BindExpr(AE, LCtx, ResultVal);
2706 SVal StoredVal = State->getSVal(MR);
2708 if (State == (State->bindLoc(loc::MemRegionVal(MR), Val, LCtx)))
2794 state = state->bindLoc(location.castAs<Loc>(),
2869 V = state->getSVal(location.castAs<Loc>(), LoadTy);
2872 Bldr.generateNode(NodeEx, I, state->BindExpr(BoundEx, LCtx, V), tag,
2938 SVal V = state->getSVal(Ex, Pred->getLocationContext());
2945 std::tie(StateTrue, StateFalse) = state->assume(*SEV);
2950 StateTrue = StateTrue->BindExpr(Ex, Pred->getLocationContext(), Val);
2957 StateFalse = StateFalse->BindExpr(Ex, Pred->getLocationContext(), Val);
2977 SVal X = state->getSVal(O, Pred->getLocationContext());
2981 state = state->bindLoc(*LV, UnknownVal(), Pred->getLocationContext());
3006 N->getState()->getStateManager().getOwningEngine()).getBugReporter();
3060 Out << "{ \"state_id\": " << State->getID()
3087 State->printDOT(Out, N->getLocationContext(), Space);
tools/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp 58 SVal LeftV = state->getSVal(LHS, LCtx);
59 SVal RightV = state->getSVal(RHS, LCtx);
74 evalStore(Tmp2, B, LHS, *it, state->BindExpr(B, LCtx, ExprVal),
102 state = state->BindExpr(B, LCtx, Result);
141 SVal V = state->getSVal(LHS, LCtx);
184 state = state->BindExpr(B, LCtx, location);
186 state = state->BindExpr(B, LCtx, Result);
240 originalV = State->getSVal(copyExpr, LCtx);
242 originalV = State->getSVal(loc::MemRegionVal(originalR));
244 State = State->bindLoc(loc::MemRegionVal(capturedR), originalV, LCtx);
252 State->BindExpr(BE, Pred->getLocationContext(), V),
271 SVal OrigV = state->getSVal(Ex, LCtx);
276 state = state->BindExpr(CastE, LCtx, V);
295 state = state->BindExpr(CastE, LCtx, result);
313 evalLoad(Dst, CastE, CastE, subExprNode, state, state->getSVal(Ex, LCtx));
359 SVal V = state->getSVal(Ex, LCtx);
360 state = state->BindExpr(CastE, LCtx, V);
366 SVal V = state->getSVal(Ex, LCtx);
371 state = state->BindExpr(CastE, LCtx, V);
388 SVal V = state->getSVal(Ex, LCtx);
390 state = state->BindExpr(CastE, LCtx, UnknownVal());
431 SVal V = state->getSVal(Ex, LCtx);
433 state = state->BindExpr(CastE, LCtx, V);
440 SVal val = state->getSVal(Ex, LCtx);
442 state = state->BindExpr(CastE, LCtx, val);
448 SVal val = state->getSVal(Ex, LCtx);
472 state = state->BindExpr(CastE, LCtx, svalBuilder.makeNull());
480 state = state->BindExpr(CastE, LCtx, NewSym);
483 state = state->BindExpr(CastE, LCtx, val);
489 SVal val = state->getSVal(Ex, LCtx);
506 state = state->BindExpr(CastE, LCtx, val);
512 state = state->BindExpr(CastE, LCtx, V);
518 state = state->BindExpr(CastE, LCtx, V);
525 SVal V = state->getSVal(Ex, LCtx);
531 state = state->BindExpr(CastE, LCtx, CastedPTMSV);
558 SVal V = State->getSVal(CL->getInitializer(), LCtx);
564 Loc CLLoc = State->getLValue(CL, LCtx);
565 State = State->bindLoc(CLLoc, V, LCtx);
571 B.generateNode(CL, Pred, State->BindExpr(CL, LCtx, V));
602 SVal InitVal = state->getSVal(InitEx, LC);
626 evalBind(Dst2, DS, UpdatedN, state->getLValue(VD, LC), InitVal, true);
715 SVal RHSVal = N->getState()->getSVal(RHS, Pred->getLocationContext());
729 Bldr.generateNode(B, Pred, state->BindExpr(B, Pred->getLocationContext(), X));
751 B.generateNode(IE, Pred, state->BindExpr(IE, LCtx, V));
757 SVal V = state->getSVal(cast<Expr>(*it), LCtx);
762 state->BindExpr(IE, LCtx,
776 V = state->getSVal(IE->getInit(0), LCtx);
778 B.generateNode(IE, Pred, state->BindExpr(IE, LCtx, V));
831 V = SrcState->getSVal(ValEx, LCtx);
842 B.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V, true));
857 Pred->getState()->BindExpr(OOE, Pred->getLocationContext(),
898 state = state->BindExpr(Ex, (*I)->getLocationContext(),
920 Bldr.generateNode(U, *I, state->BindExpr(U, LCtx,
921 state->getSVal(Ex, LCtx)));
956 Bldr.generateNode(U, *I, state->BindExpr(U, LCtx,
957 state->getSVal(Ex, LCtx)));
972 Bldr.generateNode(U, *I, state->BindExpr(U, LCtx, X));
986 Bldr.generateNode(U, *I, State->BindExpr(U, LCtx, SV));
1012 SVal V = state->getSVal(Ex, LCtx);
1015 Bldr.generateNode(U, *I, state->BindExpr(U, LCtx, V));
1024 state = state->BindExpr(U, LCtx, evalComplement(V.castAs<NonLoc>()));
1028 state = state->BindExpr(U, LCtx, evalMinus(V.castAs<NonLoc>()));
1048 state = state->BindExpr(U, LCtx, Result);
1069 SVal loc = state->getSVal(Ex, LCtx);
1081 SVal V2_untested = state->getSVal(Ex, LCtx);
1085 state = state->BindExpr(U, LCtx, V2_untested);
1136 if (!state->assume(Constraint, true)) {
1142 state = state->assume(Constraint, false);
1151 state = state->BindExpr(U, LCtx, loc);
1153 state = state->BindExpr(U, LCtx, U->isPostfix() ? V2 : Result);
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp 78 V = Pred->getState()->getSVal(*L);
90 State = State->BindExpr(CallExpr, LCtx, ThisVal);
100 SValBuilder &SVB = State->getStateManager().getSValBuilder();
105 LValue = State->getLValue(Ty, SVB.makeZeroArrayIndex(), LValue);
128 SVal LValue = State->getLValue(Var, LCtx);
144 SVal ThisVal = State->getSVal(ThisPtr);
150 FieldVal = State->getLValue(Init->getIndirectMember(), ThisVal);
153 FieldVal = State->getLValue(Init->getMember(), ThisVal);
327 Caller->getCalleeStackFrame(currBldrCtx->blockCount());
345 const VarRegion *VR = Caller->getParameterLocation(
346 *Caller->getAdjustedParameterIndex(Idx), currBldrCtx->blockCount());
412 State = State->BindExpr(CE, LCtx, State->getSVal(*L, CE->getType()));
412 State = State->BindExpr(CE, LCtx, State->getSVal(*L, CE->getType()));
469 SVal ThisVal = State->getSVal(ThisPtr);
525 State = State->bindDefaultZero(Target, LCtx);
563 const MemRegion *Target = Call->getCXXThisVal().getAsRegion();
565 Call->getDecl()->getParent()->isAnyDestructorNoReturn()) {
651 Call->getSourceRange().getBegin(),
707 SVal RetVal = State->getSVal(CNE, LCtx);
720 State = State->assume(RetVal.castAs<DefinedOrUnknownSVal>(), true);
780 State = Call->invalidateRegions(blockCount);
796 State = State->assume(*dSymVal, true);
813 State = State->BindExpr(CNE, Pred->getLocationContext(), Result);
824 SVal PlacementLoc = State->getSVal(CNE->getPlacementArg(0), LCtx);
830 State = State->BindExpr(CNE, LCtx, Result);
841 evalBind(Dst, CNE, NewN, Result, State->getSVal(Init, LCtx),
867 state = state->bindLoc(state->getLValue(VD, LCtx), V, LCtx);
867 state = state->bindLoc(state->getLValue(VD, LCtx), V, LCtx);
885 SVal V = state->getSVal(loc::MemRegionVal(R));
886 Bldr.generateNode(TE, Pred, state->BindExpr(TE, LCtx, V));
907 SVal FieldLoc = State->getLValue(FieldForCapture, V);
913 InitVal = State->getSVal(InitExpr, LocCtxt);
919 InitVal = State->getSVal(SizeExpr, LocCtxt);
922 State = State->bindLoc(FieldLoc, InitVal, LocCtxt);
928 SVal LambdaRVal = State->getSVal(R);
934 State->BindExpr(LE, LocCtxt, LambdaRVal),
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp 187 const Decl *StaticDecl = Call->getDecl();
230 SVal V = state->getSVal(RS, LCtx);
244 state = state->BindExpr(CE, callerCtx, V);
251 SVal ThisV = state->getSVal(This);
252 ThisV = state->getSVal(ThisV.castAs<Loc>());
253 state = state->BindExpr(CCE, callerCtx, ThisV);
262 SVal AllocV = state->getSVal(CNE, callerCtx);
461 State = State->enterStackFrame(Call, CalleeSFC);
486 const void *ReplayState = State->get<ReplayWithoutInlining>();
493 return State->remove<ReplayWithoutInlining>();
616 return State->BindExpr(E, LCtx, Msg->getReceiverSVal());
621 ThisV = State->getSVal(ThisV.castAs<Loc>());
622 return State->BindExpr(E, LCtx, ThisV);
646 State = State->invalidateRegions(TargetR, E, Count, LCtx,
650 R = State->getSVal(Target.castAs<Loc>(), E->getType());
667 return State->BindExpr(E, LCtx, R);
1018 const Expr *E = Call->getOriginExpr();
1025 RuntimeDefinition RD = Call->getRuntimeDefinition();
1064 State->get<DynamicDispatchBifurcationMap>(BifurReg);
1080 State->set<DynamicDispatchBifurcationMap>(BifurReg,
1085 State->set<DynamicDispatchBifurcationMap>(BifurReg,
tools/clang/lib/StaticAnalyzer/Core/ExprEngineObjC.cpp 26 SVal baseVal = state->getSVal(Ex->getBase(), LCtx);
27 SVal location = state->getLValue(Ex->getDecl(), baseVal);
31 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, location));
59 ProgramStateRef nextState = state->BindExpr(S, LCtx, hasElementsV);
78 nextState = nextState->bindLoc(elementV, V, LCtx);
117 SVal collectionV = state->getSVal(collection, Pred->getLocationContext());
123 elementV = state->getLValue(elemD, Pred->getLocationContext());
125 elementV = state->getSVal(elem, Pred->getLocationContext());
128 bool isContainerNull = state->isNull(collectionV).isConstrainedTrue();
186 if (Msg->isInstanceMessage()) {
187 SVal recVal = Msg->getReceiverSVal();
195 std::tie(notNilState, nilState) = State->assume(receiverVal);
250 if (UpdatedMsg->isInstanceMessage()) {
251 SVal recVal = UpdatedMsg->getReceiverSVal();
tools/clang/lib/StaticAnalyzer/Core/LoopUnrolling.cpp 76 auto LS = State->get<LoopStack>();
78 State = State->set<LoopStack>(LS.getTail());
259 auto LS = State->get<LoopStack>();
263 State = State->set<LoopStack>(LS.getTail());
264 State = State->add<LoopStack>(
271 State = State->add<LoopStack>(
280 State = State->add<LoopStack>(
283 State = State->add<LoopStack>(
289 auto LS = State->get<LoopStack>();
tools/clang/lib/StaticAnalyzer/Core/LoopWidening.cpp 59 MemRegionManager &MRMgr = PrevState->getStateManager().getRegionManager();
93 return PrevState->invalidateRegions(Regions, getLoopCondition(LoopStmt),
tools/clang/lib/StaticAnalyzer/Core/ProgramState.cpp 399 NewState.GDM = GDMState->GDM;
507 ProgramState::GenericDataMap M1 = St->getGDM();
519 ProgramState::GenericDataMap OldM = state->getGDM();
535 StoreManager &StoreMgr = state->getStateManager().getStoreManager();
613 StoreManager &StoreMgr = state->getStateManager().getStoreManager();
614 if (!StoreMgr.scanReachableSymbols(state->getStore(), SR, *this))
tools/clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp 252 return S1->get<ConstraintRange>() == S2->get<ConstraintRange>();
252 return S1->get<ConstraintRange>() == S2->get<ConstraintRange>();
384 const RangeSet *Ranges = State->get<ConstraintRange>(Sym);
408 const ConstraintRangeTy::data_type *T = St->get<ConstraintRange>(Sym);
418 ConstraintRangeTy CR = State->get<ConstraintRange>();
419 ConstraintRangeTy::Factory &CRFactory = State->get_context<ConstraintRange>();
429 return Changed ? State->set<ConstraintRange>(CR) : State;
481 ConstraintRangeTy::data_type *V = State->get<ConstraintRange>(Sym);
526 SymbolManager &SymMgr = State->getSymbolManager();
529 if (const RangeSet *negV = State->get<ConstraintRange>(negSym)) {
570 return New.isEmpty() ? nullptr : St->set<ConstraintRange>(Sym, New);
585 return New.isEmpty() ? nullptr : St->set<ConstraintRange>(Sym, New);
621 return New.isEmpty() ? nullptr : St->set<ConstraintRange>(Sym, New);
657 return New.isEmpty() ? nullptr : St->set<ConstraintRange>(Sym, New);
693 return New.isEmpty() ? nullptr : St->set<ConstraintRange>(Sym, New);
736 return New.isEmpty() ? nullptr : St->set<ConstraintRange>(Sym, New);
746 return Out.isEmpty() ? nullptr : State->set<ConstraintRange>(Sym, Out);
755 return New.isEmpty() ? nullptr : State->set<ConstraintRange>(Sym, New);
765 ConstraintRangeTy Constraints = State->get<ConstraintRange>();
tools/clang/lib/StaticAnalyzer/Core/SValBuilder.cpp 439 return state->isNonNull(evalEQ(state, lhs, rhs));
515 std::tie(IsNotTruncated, IsTruncated) = state->assume(CompVal);
tools/clang/lib/StaticAnalyzer/Core/SimpleConstraintManager.cpp 30 SValBuilder &SVB = State->getStateManager().getSValBuilder();
tools/clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp 315 SValBuilder &SVB = State->getStateManager().getSValBuilder();
320 return !State->assume(*DV, false);
332 SValBuilder &SVB = State->getStateManager().getSValBuilder();
375 SValBuilder &SVB = State->getStateManager().getSValBuilder();
449 ProgramStateManager &StateMgr = State->getStateManager();
492 BasicValueFactory &BV = State->getBasicVals();
1116 return state->getLValue(FD, Result);
1223 return state->getConstraintManager().getSymVal(state, Sym);
1259 : State(State), SVB(State->getStateManager().getSValBuilder()) {}
tools/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp 235 if (Opts->PrintStats || Opts->ShouldSerializeStats) {
235 if (Opts->PrintStats || Opts->ShouldSerializeStats) {
250 if (Opts->PrintStats) {
256 if (Opts->AnalysisDiagOpt != PD_NONE) {
262 if (Opts->AnalyzerWerror)
265 if (Opts->ShouldEmitFixItHintsAsRemarks)
268 if (Opts->AnalysisDiagOpt == PD_TEXT) {
272 switch (Opts->AnalysisDiagOpt) {
284 switch (Opts->AnalysisStoreOpt) {
292 switch (Opts->AnalysisConstraintsOpt) {
303 if (!Opts->AnalyzerDisplayProgress)
391 if (!Opts->IsNaiveCTUEnabled)
406 CTU.getCrossTUDefinition(VD, Opts->CTUDir, Opts->CTUIndexName,
406 CTU.getCrossTUDefinition(VD, Opts->CTUDir, Opts->CTUIndexName,
407 Opts->DisplayCTUProgress);
641 if (Opts->AnalyzerDisplayProgress)
654 } else if (Opts->DisableAllCheckers) {
742 if (!Opts->AnalyzeSpecificFunction.empty() &&
743 getFunctionName(D) != Opts->AnalyzeSpecificFunction)
756 if (!Opts->AnalyzeAll && !Mgr->isInCodeFile(SL)) {
855 bool hasModelPath = analyzerOpts->Config.count("model-path") > 0;
tools/clang/lib/StaticAnalyzer/Frontend/ModelInjector.cpp 51 llvm::StringRef modelPath = analyzerOpts->ModelPath;
tools/clang/lib/Tooling/Core/Replacement.cpp 592 InMemoryFileSystem->addFile(
tools/clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp 100 DepFS->IgnoredFiles.clear();
102 DepFS->IgnoredFiles.insert(Entry.Path);
104 DepFS->IgnoredFiles.insert(Entry);
187 RealFS->setCurrentWorkingDirectory(WorkingDirectory);
tools/clang/lib/Tooling/Tooling.cpp 208 OverlayFileSystem->pushOverlay(InMemoryFileSystem);
211 InMemoryFileSystem->addFile(FileName, 0,
216 InMemoryFileSystem->addFile(
414 OverlayFileSystem->pushOverlay(InMemoryFileSystem);
419 Files->setVirtualFileSystem(OverlayFileSystem);
458 InMemoryFileSystem->addFile(
482 if (auto CWD = OverlayFileSystem->getCurrentWorkingDirectory()) {
513 if (OverlayFileSystem->setCurrentWorkingDirectory(
524 InMemoryFileSystem->addFile(
561 OverlayFileSystem->setCurrentWorkingDirectory(InitialWorkingDir))
629 OverlayFileSystem->pushOverlay(InMemoryFileSystem);
637 InMemoryFileSystem->addFile(FileName, 0,
tools/clang/tools/arcmt-test/arcmt-test.cpp 120 Diags->setClient(verifyDiag);
137 Diags->getClient());
138 return Diags->getClient()->getNumErrors() > 0;
tools/clang/tools/c-index-test/core_main.cpp 236 Reader->getModuleManager().visit([&](serialization::ModuleFile &Mod) -> bool {
tools/clang/tools/clang-format/ClangFormat.cpp 300 DiagOpts->ShowColors = (ShowColors && !NoShowColors);
tools/clang/tools/diagtool/ShowEnabledWarnings.cpp 126 Diags->getDiagnosticLevel(DiagID, SourceLocation());
tools/clang/tools/driver/driver.cpp 440 if (!DiagOpts->DiagnosticSerializationFile.empty()) {
442 clang::serialized_diags::create(DiagOpts->DiagnosticSerializationFile,
tools/clang/tools/extra/clang-include-fixer/plugin/IncludeFixerPlugin.cpp 42 SemaSource->setFilePath(InFile);
43 SemaSource->setCompilerInstance(&CI);
tools/clang/tools/extra/clang-query/tool/ClangQuery.cpp 77 if (!Q->run(llvm::outs(), QS))
121 if (!Q->run(llvm::outs(), QS))
140 Q->run(llvm::outs(), QS);
tools/clang/tools/extra/clang-reorder-fields/ReorderFieldsAction.cpp 192 unsigned ID = DiagEngine.getDiagnosticIDs()->getCustomDiagID(
tools/clang/tools/extra/clang-tidy/ClangTidy.cpp 109 DiagOpts->ShowColors = llvm::sys::Process::StandardOutHasColors();
333 AnalyzerOptions->Config[OptName.substr(AnalyzerPrefix.size())] = Opt.second;
424 AnalyzerOptions->CheckersAndPackages = getAnalyzerCheckersAndPackages(
426 if (!AnalyzerOptions->CheckersAndPackages.empty()) {
428 AnalyzerOptions->AnalysisStoreOpt = RegionStoreModel;
429 AnalyzerOptions->AnalysisDiagOpt = PD_NONE;
430 AnalyzerOptions->AnalyzeNestedBlocks = true;
431 AnalyzerOptions->eagerlyAssumeBinOpBifurcation = true;
tools/clang/tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp 163 unsigned ID = DiagEngine->getDiagnosticIDs()->getCustomDiagID(
227 DiagEngine->getDiagnosticIDs()->getWarningOptionForDiag(DiagnosticID);
469 unsigned ExternalID = ExternalDiagEngine->getDiagnosticIDs()->getCustomDiagID(
tools/clang/tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.h 177 DiagEngine->getDiagnosticIDs()->getDescription(DiagnosticID));
tools/clang/tools/extra/clang-tidy/ClangTidyOptions.cpp 233 if (FS->makeAbsolute(AbsoluteFilePath))
tools/clang/tools/extra/clang-tidy/ExpandModularHeadersPPCallbacks.cpp 66 OverlayFS->pushOverlay(InMemoryFs);
109 Compiler.getModuleManager()->visitInputFiles(
156 Compiler.getModuleManager()->getModuleManager().lookup(
tools/clang/tools/extra/clang-tidy/tool/ClangTidyMain.cpp 311 BaseFS->getBufferForFile(OverlayFile);
341 BaseFS->pushOverlay(VfsFromFile);
tools/clang/tools/extra/clangd/Compiler.cpp 50 if (Inputs.FS->setCurrentWorkingDirectory(Inputs.CompileCommand.Directory)) {
tools/clang/tools/extra/clangd/HeaderSourceSwitch.cpp 58 if (VFS->exists(NewPath))
65 if (VFS->exists(NewPath))
tools/clang/tools/extra/clangd/ParsedAST.cpp 313 auto BuildDir = VFS->getCurrentWorkingDirectory();
515 if (VFS->setCurrentWorkingDirectory(Inputs.CompileCommand.Directory)) {
tools/clang/tools/extra/clangd/Preamble.cpp 127 if (Inputs.FS->setCurrentWorkingDirectory(Inputs.CompileCommand.Directory)) {
134 Inputs.FS->makeAbsolute(AbsFileName);
tools/clang/tools/extra/clangd/index/Background.cpp 349 auto Buf = FS->getBufferForFile(AbsolutePath);
364 Inputs.FS->setCurrentWorkingDirectory(Cmd.Directory);
tools/clang/tools/extra/clangd/unittests/FSTests.cpp 24 FS->setCurrentWorkingDirectory(testRoot());
28 EXPECT_TRUE(ProduceFS->openFileForRead("x"));
29 EXPECT_TRUE(ProduceFS->status("y"));
30 EXPECT_TRUE(ProduceFS->status("main"));
43 auto Cached = ConsumeFS->status(testPath("fake"));
50 auto CachedDotDot = ConsumeFS->status(testPath("temp/../fake"));
tools/clang/tools/extra/clangd/unittests/HeadersTests.cpp 44 VFS->setCurrentWorkingDirectory(Cmd->Directory);
tools/clang/tools/extra/clangd/unittests/IndexActionTests.cpp 101 InMemoryFileSystem->addFile(Path, 0,
tools/clang/tools/extra/clangd/unittests/SymbolCollectorTests.cpp 276 InMemoryFileSystem->addFile(TestHeaderName, 0,
278 InMemoryFileSystem->addFile(TestFileName, 0,
1038 InMemoryFileSystem->addFile(IncFile, 0,
1057 InMemoryFileSystem->addFile(IncFile, 0,
1077 InMemoryFileSystem->addFile(IncFile, 0,
tools/clang/tools/extra/clangd/unittests/TestFS.cpp 26 MemFS->setCurrentWorkingDirectory(testRoot());
29 MemFS->addFile(
tools/clang/tools/extra/clangd/unittests/TweakTests.cpp 60 MemFS->setCurrentWorkingDirectory(testRoot());
62 MemFS->addFile(Path, 0, llvm::MemoryBuffer::getMemBuffer("", Path));
tools/clang/tools/extra/modularize/ModularizeUtilities.cpp 262 SourceMgr->getFileManager().getFile(InputPath);
281 if (auto DirEntry = FileMgr->getDirectory(DirName))
tools/clang/tools/extra/unittests/clang-include-fixer/IncludeFixerTest.cpp 38 InMemoryFileSystem->addFile(FileName, 0,
41 InMemoryFileSystem->addFile("foo.h", 0,
43 InMemoryFileSystem->addFile("dir/bar.h", 0,
45 InMemoryFileSystem->addFile("dir/otherdir/qux.h", 0,
47 InMemoryFileSystem->addFile("header.h", 0,
tools/clang/tools/extra/unittests/clang-include-fixer/find-all-symbols/FindAllSymbolsTests.cpp 89 InMemoryFileSystem->addFile(
91 InMemoryFileSystem->addFile(InternalHeader, 0,
103 InMemoryFileSystem->addFile(HeaderName, 0,
117 InMemoryFileSystem->addFile(
125 InMemoryFileSystem->addFile(FileName, 0,
tools/clang/tools/extra/unittests/clang-move/ClangMoveTests.cpp 211 Context.InMemoryFileSystem->setCurrentWorkingDirectory(WorkingDir);
tools/clang/tools/extra/unittests/clang-query/QueryEngineTest.cpp 139 EXPECT_TRUE(QueryParser::parse("let x \"foo1\"", S)->run(OS, S));
143 EXPECT_TRUE(QueryParser::parse("let y hasName(x)", S)->run(OS, S));
147 EXPECT_TRUE(QueryParser::parse("match functionDecl(y)", S)->run(OS, S));
153 EXPECT_TRUE(QueryParser::parse("unlet x", S)->run(OS, S));
157 EXPECT_FALSE(QueryParser::parse("let y hasName(x)", S)->run(OS, S));
tools/clang/tools/extra/unittests/clang-tidy/ClangTidyTest.h 124 InMemoryFileSystem->addFile(Filename, 0,
127 InMemoryFileSystem->addFile(
tools/clang/tools/libclang/CIndex.cpp 3448 Diags->setFatalsAsError(true);
3515 unsigned NumErrors = Diags->getClient()->getNumErrors();
3543 if (NumErrors != Diags->getClient()->getNumErrors()) {
tools/clang/tools/libclang/CXIndexDataConsumer.cpp 1155 EntityInfo.attributes = EntityInfo.AttrList->getAttrs();
1156 EntityInfo.numAttributes = EntityInfo.AttrList->getNumAttrs();
tools/clang/unittests/Basic/FileManagerTest.cpp 319 ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
345 ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
378 ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
411 ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
tools/clang/unittests/CrossTU/CrossTranslationUnitTest.cpp 124 CI.getAnalyzerOpts()->CTUImportThreshold = OverrideLimit;
tools/clang/unittests/Driver/ToolChainTest.cpp 59 InMemoryFileSystem->addFile(Path, 0,
99 InMemoryFileSystem->addFile(Path, 0,
tools/clang/unittests/Frontend/CompilerInstanceTest.cpp 90 Diags->Report(diag::err_expected) << "no crash";
tools/clang/unittests/Frontend/PCHPreambleTest.cpp 66 VFS->setCurrentWorkingDirectory("//./");
72 VFS->addFile(Filename, now, MemoryBuffer::getMemBufferCopy(Contents, Filename));
110 return VFS->GetReadCount(Filename);
tools/clang/unittests/Lex/HeaderSearchTest.cpp 40 VFS->addFile(Dir, 0, llvm::MemoryBuffer::getMemBuffer(""), /*User=*/None,
tools/clang/unittests/Lex/PPCallbacksTest.cpp 143 InMemoryFileSystem->addFile(HeaderPath, 0,
tools/clang/unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp 49 Compiler.getAnalyzerOpts()->CheckersAndPackages = {
tools/clang/unittests/Tooling/RefactoringTest.cpp 1045 EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer("")));
1046 EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer("")));
1066 EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer("")));
1067 EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer("")));
tools/clang/unittests/Tooling/RewriterTestContext.h 49 OverlayFileSystem->pushOverlay(InMemoryFileSystem);
57 InMemoryFileSystem->addFile(Name, 0, std::move(Source));
tools/clang/unittests/Tooling/Syntax/TokensTest.cpp 118 FS->addFile(FileName, time_t(), llvm::MemoryBuffer::getMemBufferCopy(""));
120 if (!Diags->getClient())
121 Diags->setClient(new IgnoringDiagConsumer);
149 if (!FS->addFile(Path, time_t(),
159 SourceMgr->createFileID(llvm::MemoryBuffer::getMemBufferCopy(Text)),
169 Ls.first = SourceMgr->getLocForStartOfFile(SourceMgr->getMainFileID())
169 Ls.first = SourceMgr->getLocForStartOfFile(SourceMgr->getMainFileID())
171 Ls.second = SourceMgr->getLocForStartOfFile(SourceMgr->getMainFileID())
171 Ls.second = SourceMgr->getLocForStartOfFile(SourceMgr->getMainFileID())
232 File = SourceMgr->getMainFileID();
339 Buffer.spelledTokens(SourceMgr->getMainFileID()),
tools/clang/unittests/Tooling/Syntax/TreeTest.cpp 77 FS->addFile(FileName, time_t(), llvm::MemoryBuffer::getMemBufferCopy(""));
78 if (!Diags->getClient())
79 Diags->setClient(new IgnoringDiagConsumer);
105 if (!FS->addFile(Path, time_t(),
tools/clang/unittests/Tooling/ToolingTest.cpp 155 OverlayFileSystem->pushOverlay(InMemoryFileSystem);
165 InMemoryFileSystem->addFile(
167 InMemoryFileSystem->addFile("def/abc", 0,
181 OverlayFileSystem->pushOverlay(InMemoryFileSystem);
191 InMemoryFileSystem->addFile(
193 InMemoryFileSystem->addFile("def/abc", 0,
197 InMemoryFileSystem->addFile("def/module.map", 0,
438 OverlayFileSystem->pushOverlay(InMemoryFileSystem);
440 InMemoryFileSystem->addFile(
tools/lldb/include/lldb/Utility/Reproducer.h 308 llvm::vfs::getRealFileSystem()->getBufferForFile(file.GetPath());
tools/lldb/source/Commands/CommandObjectReproducer.cpp 254 vfs::getRealFileSystem()->getBufferForFile(vfs_mapping.GetPath());
tools/lldb/source/Host/common/FileSystem.cpp 61 llvm::vfs::getRealFileSystem()->getBufferForFile(mapping.GetPath());
95 return m_fs->dir_begin(dir, ec);
104 return m_fs->status(path);
113 ErrorOr<vfs::Status> status = m_fs->status(path);
124 ErrorOr<vfs::Status> status = m_fs->status(path);
146 ErrorOr<vfs::Status> status = m_fs->status(path);
154 bool FileSystem::Exists(const Twine &path) const { return m_fs->exists(path); }
169 ErrorOr<vfs::Status> status = m_fs->status(path);
181 m_fs->isLocal(path, b);
198 ErrorOr<vfs::Status> Status = m_fs->status(Item.path());
220 return m_fs->makeAbsolute(path);
238 return m_fs->getRealPath(path, output);
tools/lldb/source/Initialization/SystemInitializerCommon.cpp 86 ->setCurrentWorkingDirectory(working_dir)) {
tools/lldb/unittests/Host/FileSystemTest.cpp 178 D->addRegularFile("/foo");
179 D->addDirectory("/bar");
180 D->addSymlink("/baz");
181 D->addRegularFile("/qux", ~sys::fs::perms::all_read);
182 D->setCurrentWorkingDirectory("/");
unittests/Support/FileCollectorTest.cpp 201 VFS->status(a.Path);
204 VFS->openFileForRead(b.Path);
207 VFS->status(subdir.Path);
212 auto It = VFS->dir_begin(subdir3.Path, EC);
295 VFS->getRealPath(symlink.Path, Output);
unittests/Support/VirtualFileSystemTest.cpp 190 D->addRegularFile("/foo");
191 Status = D->status("/foo");
200 D->addDirectory("/bar");
201 Status = D->status("/bar");
210 D->addSymlink("/baz");
211 Status = D->status("/baz");
221 ErrorOr<vfs::Status> Status2 = D->status("/foo");
229 EXPECT_FALSE(Status = D->status("/foo"));
232 EXPECT_FALSE(Status = O->status("/foo"));
234 D->addRegularFile("/foo");
235 Status = D->status("/foo");
239 Status2 = O->status("/foo");
246 Lower->addRegularFile("/foo");
247 Lower->addSymlink("/lower_link");
252 O->pushOverlay(Upper);
256 EXPECT_FALSE(O->getRealPath("/foo", RealPath));
260 EXPECT_FALSE(O->getRealPath("/lower_link", RealPath));
264 EXPECT_EQ(O->getRealPath("/upper_link", RealPath),
268 Upper->addSymlink("/upper_link");
269 EXPECT_FALSE(O->getRealPath("/upper_link", RealPath));
279 O->pushOverlay(Middle);
280 O->pushOverlay(Top);
287 Base->addRegularFile("/foo");
288 StatusB = Base->status("/foo");
290 Status1 = O->status("/foo");
292 Middle->addRegularFile("/foo");
293 StatusM = Middle->status("/foo");
295 Status2 = O->status("/foo");
297 Top->addRegularFile("/foo");
298 StatusT = Top->status("/foo");
300 Status3 = O->status("/foo");
317 O->pushOverlay(Upper);
319 Lower->addDirectory("/lower-only");
320 Upper->addDirectory("/upper-only");
323 ErrorOr<vfs::Status> Status1 = Lower->status("/lower-only");
325 ErrorOr<vfs::Status> Status2 = O->status("/lower-only");
329 Status1 = Upper->status("/upper-only");
331 Status2 = O->status("/upper-only");
342 O->pushOverlay(Upper);
345 Lower->addDirectory("/both", sys::fs::owner_read);
346 Upper->addDirectory("/both", sys::fs::owner_all | sys::fs::group_read);
347 Status = O->status("/both");
352 Lower->addRegularFile("/both/foo", sys::fs::owner_read);
353 Upper->addRegularFile("/both/bar", sys::fs::owner_write);
354 Status = O->status("/both/foo");
357 Status = O->status("/both/bar");
364 Lower->addRegularFile("/foo");
369 O->pushOverlay(Upper);
373 auto it = O->overlays_begin();
374 auto end = O->overlays_end();
378 Status = (*it)->status("/foo");
384 Status = (*it)->status("/foo");
393 auto it = O->overlays_rbegin();
394 auto end = O->overlays_rend();
398 Status = (*it)->status("/foo");
405 Status = (*it)->status("/foo");
484 vfs::directory_iterator I = FS->dir_begin(Twine(TestDirectory), EC);
493 I = FS->dir_begin(Twine(TestDirectory), EC);
579 for (vfs::directory_iterator I = FS->dir_begin(Twine(TestDirectory), EC), E;
583 FS->status(I->path()).getError();
735 (FS->status(I->path()) ? VisitedNonBrokenSymlinks : VisitedBrokenSymlinks)
775 O->pushOverlay(Upper);
778 checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>());
780 Lower->addRegularFile("/file1");
781 checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>("/file1"));
783 Upper->addRegularFile("/file2");
784 checkContents(O->dir_begin("/", EC), {"/file2", "/file1"});
786 Lower->addDirectory("/dir1");
787 Lower->addRegularFile("/dir1/foo");
788 Upper->addDirectory("/dir2");
789 Upper->addRegularFile("/dir2/foo");
790 checkContents(O->dir_begin("/dir2", EC), ArrayRef<StringRef>("/dir2/foo"));
791 checkContents(O->dir_begin("/", EC), {"/dir2", "/file2", "/dir1", "/file1"});
800 O->pushOverlay(Middle);
801 O->pushOverlay(Upper);
807 Lower->addRegularFile("/file1");
811 Upper->addDirectory("/dir");
812 Upper->addRegularFile("/dir/file2");
816 Lower->addDirectory("/dir1");
817 Lower->addRegularFile("/dir1/foo");
818 Lower->addDirectory("/dir1/a");
819 Lower->addRegularFile("/dir1/a/b");
820 Middle->addDirectory("/a");
821 Middle->addDirectory("/a/b");
822 Middle->addDirectory("/a/b/c");
823 Middle->addRegularFile("/a/b/c/d");
824 Middle->addRegularFile("/hiddenByUp");
825 Upper->addDirectory("/dir2");
826 Upper->addRegularFile("/dir2/foo");
827 Upper->addRegularFile("/hiddenByUp");
842 O->pushOverlay(Middle);
843 O->pushOverlay(Upper);
846 checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>());
848 Middle->addRegularFile("/file2");
849 checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>("/file2"));
851 Lower->addRegularFile("/file1");
852 Upper->addRegularFile("/file3");
853 checkContents(O->dir_begin("/", EC), {"/file3", "/file2", "/file1"});
862 O->pushOverlay(Middle);
863 O->pushOverlay(Upper);
866 Lower->addRegularFile("/onlyInLow");
867 Lower->addDirectory("/hiddenByMid");
868 Lower->addDirectory("/hiddenByUp");
869 Middle->addRegularFile("/onlyInMid");
870 Middle->addRegularFile("/hiddenByMid");
871 Middle->addDirectory("/hiddenByUp");
872 Upper->addRegularFile("/onlyInUp");
873 Upper->addRegularFile("/hiddenByUp");
875 O->dir_begin("/", EC),
881 vfs::directory_iterator I = O->dir_begin("/", EC), E;
890 vfs::directory_iterator I = O->dir_begin("/", EC), E;
904 Base->addFile("/a", 0, MemoryBuffer::getMemBuffer("test"));
1381 Lower->addRegularFile("//root/foo/bar/a");
1406 O->pushOverlay(FS);
1409 ErrorOr<vfs::Status> S = O->status("//root/file1");
1414 ErrorOr<vfs::Status> SLower = O->status("//root/foo/bar/a");
1420 auto OpenedF = O->openFileForRead("//root/file1");
1428 S = O->status("//root/");
1431 EXPECT_TRUE(S->equivalent(*O->status("//root/"))); // non-volatile UniqueID
1434 EXPECT_EQ(O->status("//root/file2").getError(),
1441 Lower->addRegularFile("//root/foo/bar/a");
1460 O->pushOverlay(FS);
1462 ErrorOr<vfs::Status> S = O->status("//root/XX");
1465 ErrorOr<vfs::Status> SS = O->status("//root/xx");
1468 SS = O->status("//root/xX");
1470 SS = O->status("//root/Xx");
1477 Lower->addRegularFile("//root/foo/bar/a");
1496 O->pushOverlay(FS);
1498 ErrorOr<vfs::Status> SS = O->status("//root/xx");
1500 SS = O->status("//root/xX");
1502 SS = O->status("//root/Xx");
1600 Lower->addRegularFile("//root/external/file");
1620 EXPECT_EQ("//root/external/file", FS->status("//root/A")->getName());
1622 EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName());
1623 EXPECT_EQ("//root/C", FS->status("//root/C")->getName());
1644 EXPECT_EQ("//root/A", FS->status("//root/A")->getName());
1646 EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName());
1647 EXPECT_EQ("//root/C", FS->status("//root/C")->getName());
1652 Lower->addRegularFile("//root/other");
1662 EXPECT_FALSE(FS->status("//root/path/to/file").getError());
1663 EXPECT_FALSE(FS->status("//root/path/to").getError());
1664 EXPECT_FALSE(FS->status("//root/path").getError());
1665 EXPECT_FALSE(FS->status("//root/").getError());
1676 EXPECT_FALSE(FS->status("//root/path/to/file").getError());
1677 EXPECT_FALSE(FS->status("//root/path/to").getError());
1678 EXPECT_FALSE(FS->status("//root/path").getError());
1679 EXPECT_FALSE(FS->status("//root/").getError());
1690 EXPECT_FALSE(FS->status("//root/path/to/file").getError());
1691 EXPECT_FALSE(FS->status("//root/path/to").getError());
1692 EXPECT_FALSE(FS->status("//root/path").getError());
1693 EXPECT_FALSE(FS->status("//root/").getError());
1698 Lower->addRegularFile("//root/other");
1709 EXPECT_FALSE(FS->status("//root/path/to/file").getError());
1710 EXPECT_FALSE(FS->status("//root/path/to").getError());
1711 EXPECT_FALSE(FS->status("//root/path").getError());
1712 EXPECT_FALSE(FS->status("//root/").getError());
1717 Lower->addDirectory("//root/");
1718 Lower->addDirectory("//root/foo");
1719 Lower->addDirectory("//root/foo/bar");
1720 Lower->addRegularFile("//root/foo/bar/a");
1721 Lower->addRegularFile("//root/foo/bar/b");
1722 Lower->addRegularFile("//root/file3");
1748 O->pushOverlay(FS);
1751 checkContents(O->dir_begin("//root/", EC),
1754 checkContents(O->dir_begin("//root/foo/bar", EC),
1764 Lower->addDirectory("//root/zab");
1765 Lower->addDirectory("//root/baz");
1766 Lower->addRegularFile("//root/zab/a");
1767 Lower->addRegularFile("//root/zab/b");
1798 O->pushOverlay(FS);
1802 checkContents(O->dir_begin("//root/baz/", EC),
1809 Lower->addDirectory("//root/a");
1810 Lower->addDirectory("//root/a/b");
1811 Lower->addDirectory("//root/a/b/c");
1812 Lower->addRegularFile("//root/a/b/c/file");
1833 O->pushOverlay(FS);
1885 Lower->addDirectory("//root/");
1886 Lower->addRegularFile("//root/a");
1887 Lower->addRegularFile("//root/b");
1908 checkContents(FS->dir_begin("//root/", EC),
1914 Lower->addDirectory("//root/");
1915 Lower->addRegularFile("//root/a");
1916 Lower->addRegularFile("//root/b");
1936 checkContents(FS->dir_begin("//root/", EC),
1942 Lower->addDirectory("//root/");
1943 Lower->addDirectory("//root/foo");
1944 Lower->addRegularFile("//root/foo/a");
1945 Lower->addRegularFile("//root/foo/b");
1965 checkContents(FS->dir_begin("//root/foo", EC),
1971 Lower->addDirectory("//dir/");
1972 Lower->addRegularFile("/foo");
1973 Lower->addSymlink("/link");
1999 EXPECT_FALSE(FS->getRealPath("/foo", RealPath));
2003 EXPECT_FALSE(FS->getRealPath("//root/bar", RealPath));
2007 EXPECT_FALSE(FS->getRealPath("//dir/", RealPath));
2011 EXPECT_EQ(FS->getRealPath("/non_existing", RealPath),
2017 Lower->addDirectory("//root/");
2018 Lower->addDirectory("//root/foo");
2019 Lower->addRegularFile("//root/foo/a");
2020 Lower->addRegularFile("//root/foo/b");
2038 std::error_code EC = FS->setCurrentWorkingDirectory("//root/bar");
2041 llvm::ErrorOr<std::string> WorkingDir = FS->getCurrentWorkingDirectory();
2045 llvm::ErrorOr<vfs::Status> Status = FS->status("./a");
2054 EC = FS->setCurrentWorkingDirectory("bogus");
2056 WorkingDir = FS->getCurrentWorkingDirectory();
2060 EC = FS->setCurrentWorkingDirectory("//root/");
2062 WorkingDir = FS->getCurrentWorkingDirectory();
2066 EC = FS->setCurrentWorkingDirectory("bar");
2068 WorkingDir = FS->getCurrentWorkingDirectory();
2075 Lower->addDirectory("//root/");
2076 Lower->addDirectory("//root/foo");
2077 Lower->addRegularFile("//root/foo/a");
2078 Lower->addRegularFile("//root/foo/b");
2079 Lower->addRegularFile("//root/c");
2097 std::error_code EC = FS->setCurrentWorkingDirectory("//root/");
2101 llvm::ErrorOr<vfs::Status> Status = FS->status("bar/a");
2105 Status = FS->status("foo/a");
2109 EC = FS->setCurrentWorkingDirectory("//root/bar");
2112 Status = FS->status("./a");
2116 Status = FS->status("./b");
2119 Status = FS->status("./c");
2122 EC = FS->setCurrentWorkingDirectory("//root/");
2125 Status = FS->status("c");
2132 Lower->addDirectory("//root/");
2133 Lower->addDirectory("//root/foo");
2134 Lower->addRegularFile("//root/foo/a");
2135 Lower->addRegularFile("//root/foo/b");
2136 Lower->addRegularFile("//root/c");
2154 std::error_code EC = FS->setCurrentWorkingDirectory("//root/");
2158 llvm::ErrorOr<vfs::Status> Status = FS->status("bar/a");
2162 Status = FS->status("foo/a");