|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
include/llvm/Support/type_traits.h 122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
tools/clang/include/clang/Basic/FileManager.h 358 this->FS = std::move(FS);
tools/clang/include/clang/Frontend/ASTUnit.h 442 void setASTContext(ASTContext *ctx) { Ctx = ctx; }
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h 1256 Copy->State = NewState;
tools/clang/lib/AST/ASTContext.cpp 971 ExternalSource = std::move(Source);
tools/clang/lib/ASTMatchers/ASTMatchersInternal.cpp 242 Result.Implementation =
tools/clang/lib/Basic/FileManager.cpp 58 this->FS = llvm::vfs::getRealFileSystem();
tools/clang/lib/Driver/Driver.cpp 137 this->VFS = llvm::vfs::getRealFileSystem();
tools/clang/lib/Frontend/ASTUnit.cpp 569 Target =
777 AST->Diagnostics = Diags;
780 AST->FileMgr = new FileManager(FileSystemOpts, VFS);
782 AST->SourceMgr = new SourceManager(AST->getDiagnostics(),
785 AST->ModuleCache = new InMemoryModuleCache;
811 AST->Ctx = new ASTContext(*AST->LangOpts, AST->getSourceManager(),
818 AST->Reader = new ASTReader(
1127 FileMgr = Clang->createFileManager(std::move(VFS));
1167 SourceMgr = new SourceManager(getDiagnostics(), *FileMgr,
1453 Ctx = &CI.getASTContext();
1459 Target = &CI.getTarget();
1460 Reader = CI.getModuleManager();
1500 AST->Diagnostics = Diags;
1503 AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS);
1505 AST->SourceMgr = new SourceManager(AST->getDiagnostics(), *AST->FileMgr,
1507 AST->ModuleCache = new InMemoryModuleCache;
1596 AST->Ctx = nullptr;
1598 AST->Reader = nullptr;
1703 AST->Diagnostics = Diags;
1712 AST->FileMgr = FileMgr;
1784 AST->Diagnostics = Diags;
1787 VFS = llvm::vfs::getRealFileSystem();
1788 VFS = createVFSFromCompilerInvocation(*CI, *Diags, VFS);
1789 AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS);
1790 AST->ModuleCache = new InMemoryModuleCache;
1804 Diags = nullptr;
1833 VFS = &FileMgr->getVirtualFileSystem();
tools/clang/lib/Frontend/ChainedIncludesSource.cpp 186 Reader = createASTReader(
211 Reader = createASTReader(CI, pchName, SerialBufs, serialBufNames);
tools/clang/lib/Frontend/CompilerInstance.cpp 84 Diagnostics = Value;
97 void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; }
98 void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; }
101 FileMgr = Value;
105 SourceMgr = Value;
113 Context = Value;
144 ModuleManager = std::move(Reader);
270 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
313 VFS = FileMgr ? &FileMgr->getVirtualFileSystem()
317 FileMgr = new FileManager(getFileSystemOpts(), std::move(VFS));
324 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
497 ModuleManager = createPCHExternalASTSource(
1496 ModuleManager = new ASTReader(
2152 ExternalSemaSrc = std::move(ESS);
tools/clang/lib/Frontend/CompilerInvocation.cpp 3716 Result = FS;
tools/clang/lib/Frontend/CreateInvocationFromCommandLine.cpp 33 Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions);
tools/clang/lib/Frontend/FrontendAction.cpp 835 source = createChainedIncludesSource(CI, FinalReader);
tools/clang/lib/Frontend/PrecompiledPreamble.cpp 314 VFS =
747 VFS = createVFSOverlayForPreamblePCH(PCHPath, std::move(*Buf), VFS);
756 VFS = createVFSOverlayForPreamblePCH(PCHPath, std::move(Buf), VFS);
tools/clang/lib/Rewrite/RewriteRope.cpp 802 AllocBuffer = Res;
tools/clang/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp 174 state = state_withinLowerBound;
223 state = state_withinUpperBound;
tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp 984 State = assumeCollectionNonEmpty(C, State, FCS, /*Assumption*/false);
988 State = checkCollectionNonNil(C, State, FCS);
989 State = checkElementNonNil(C, State, FCS);
990 State = assumeCollectionNonEmpty(C, State, FCS, /*Assumption*/true);
1042 State = State->set<ContainerCountMap>(ContainerS, CountS);
1045 State = State->remove<ContainerNonEmptyMap>(ContainerS);
1046 State = assumeCollectionNonEmpty(C, State, ContainerS, *NonEmpty);
1113 State = State->remove<ContainerCountMap>(Sym);
1114 State = State->remove<ContainerNonEmptyMap>(Sym);
1129 State = State->remove<ContainerCountMap>(Sym);
1130 State = State->remove<ContainerNonEmptyMap>(Sym);
1211 State = assumeExprIsNonNull(M.getOriginExpr(), State, C);
1223 State = assumeExprIsNonNull(M.getOriginExpr(), State, C);
1231 State = assumeExprIsNonNull(M.getOriginExpr(), State, C);
tools/clang/lib/StaticAnalyzer/Checkers/BlockInCriticalSectionChecker.cpp 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);
96 state = state->assume(extentMatchesSizeArg, true);
tools/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp 391 state = checkNonNull(C, state, FirstBuf, BufVal, 1);
421 state = CheckLocation(C, state, warningExpr, BufEnd, firstMessage);
431 state = checkNonNull(C, state, SecondBuf, BufVal, 2);
441 state = CheckLocation(C, state, warningExpr, BufEnd, secondMessage);
493 state = stateFalse;
707 state = stateOkay;
784 state = state->assume(evalLength.castAs<DefinedOrUnknownSVal>(), true);
786 state = state->set<CStringLength>(MR, strLength);
1097 State = State->bindDefaultZero(svalBuilder.makeLoc(BR),
1102 State = InvalidateBuffer(C, State, DstBuffer, MemVal,
1109 State = setCStringLength(State, MR,
1121 State = setCStringLength(
1128 State = InvalidateBuffer(C, State, DstBuffer, MemVal,
1161 stateZeroSize = stateZeroSize->BindExpr(CE, LCtx, destVal);
1168 state = stateNonZeroSize;
1172 state = checkNonNull(C, state, Dest, destVal, 1);
1181 state = checkNonNull(C, state, Source, srcVal, 2);
1188 state = CheckBufferAccess(C, state, Size, Dest, Source,
1191 state = CheckOverlap(C, state, Size, Dest, Source);
1214 state = state->BindExpr(CE, LCtx, lastElement);
1218 state = state->BindExpr(CE, LCtx, destVal);
1227 state = InvalidateBuffer(C, state, Dest, C.getSVal(Dest),
1232 state = InvalidateBuffer(C, state, Source, C.getSVal(Source),
1296 state = stateZeroSize;
1297 state = state->BindExpr(CE, LCtx,
1304 state = stateNonZeroSize;
1321 state = StSameBuf;
1322 state = CheckBufferAccess(C, state, Size, Left);
1324 state = StSameBuf->BindExpr(CE, LCtx,
1333 state = StNotSameBuf;
1334 state = CheckBufferAccess(C, state, Size, Left, Right);
1339 state = state->BindExpr(CE, LCtx, CmpV);
1376 stateZeroSize = stateZeroSize->BindExpr(CE, LCtx, zero);
1385 state = stateNonZeroSize;
1392 state = checkNonNull(C, state, Arg, ArgVal, 1);
1447 state = state->assume(C.getSValBuilder().evalBinOpNN(
1453 state = state->assume(C.getSValBuilder().evalBinOpNN(
1473 state = state->BindExpr(CE, LCtx, result);
1550 state = checkNonNull(C, state, Dst, DstVal, 1);
1557 state = checkNonNull(C, state, srcExpr, srcVal, 2);
1579 state = CheckOverlap(C, state, isBounded ? CE->getArg(2) : CE->getArg(1), Dst, srcExpr);
1611 state = stateSourceTooLong;
1616 state = stateSourceNotTooLong;
1657 StateZeroSize = StateZeroSize->BindExpr(CE, LCtx, DstVal);
1659 StateZeroSize = StateZeroSize->BindExpr(CE, LCtx, *lenValNL);
1693 state = state->assume(
1705 state = state->assume(
1742 state = checkAdditionOverflow(C, state, *srcStrLengthNL, *dstStrLengthNL);
1765 state = state->assume(sourceInResult.castAs<DefinedOrUnknownSVal>(),
1777 state =
1815 state = CheckLocation(C, state, CE->getArg(2), maxLastElement,
1831 state = CheckLocation(C, state, Dst, lastElement, warningMsg);
1848 state = InvalidateBuffer(C, state, Dst, *dstRegVal,
1853 state = InvalidateBuffer(C, state, srcExpr, srcVal, /*IsSourceBuffer*/true,
1865 state = setCStringLength(state, dstRegVal->getRegion(), finalStrLength);
1878 state = state->BindExpr(CE, LCtx, Result);
1913 state = checkNonNull(C, state, s1, s1Val, 1);
1920 state = checkNonNull(C, state, s2, s2Val, 2);
1949 StSameBuf = StSameBuf->BindExpr(CE, LCtx,
1959 state = StNotSameBuf;
2020 state = state->assume(compareWithZeroVal, true);
2025 state = state->BindExpr(CE, LCtx, resultVal);
2047 State = checkNonNull(C, State, SearchStrPtr, SearchStrVal, 1);
2054 State = checkNonNull(C, State, DelimStr, DelimStrVal, 2);
2066 State = InvalidateBuffer(C, State, SearchStrPtr, Result,
2071 State = State->bindLoc(*SearchStrLoc,
2085 State = State->BindExpr(CE, LCtx, Result);
2116 State = InvalidateBuffer(C, State, Dst, DstVal, /*IsSource=*/false,
2122 State = State->BindExpr(CE, LCtx, ResultVal);
2150 StateZeroSize = StateZeroSize->BindExpr(CE, LCtx, MemVal);
2157 State = checkNonNull(C, StateNonZeroSize, Mem, MemVal, 1);
2161 State = CheckBufferAccess(C, State, Size, Mem);
2171 State = State->BindExpr(CE, LCtx, MemVal);
2204 State = checkNonNull(C, StateNonZeroSize, Mem, MemVal, 1);
2208 State = CheckBufferAccess(C, State, Size, Mem);
2304 state = state->set<CStringLength>(MR, strLength);
2396 state = state->set<CStringLength>(Entries);
tools/clang/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp 396 State = StNonNull;
tools/clang/lib/StaticAnalyzer/Checkers/CastValueChecker.cpp 206 State = setDynamicTypeAndCastInfo(State, MR, CastFromTy, CastToTy,
248 State = setDynamicTypeAndCastInfo(State, MR, CastFromTy, CastToTy,
tools/clang/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp 299 State = State->set<UnreleasedIvarMap>(SelfSymbol, RequiredReleases);
441 State = removeValueRequiringRelease(State, InstanceSymbol, NullSymbol);
471 State = State->remove<UnreleasedIvarMap>(Sym);
479 State = removeValueRequiringRelease(State, InstanceSymbol, Sym);
585 State = State->remove<UnreleasedIvarMap>(SelfSym);
587 State = State->set<UnreleasedIvarMap>(SelfSym, NewUnreleased);
tools/clang/lib/StaticAnalyzer/Checkers/ChrootChecker.cpp 84 state = Mgr.addGDM(state, ChrootChecker::getTag(), (void*) ROOT_CHANGED);
106 state = Mgr.addGDM(state, ChrootChecker::getTag(),
tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp 124 State = State->remove<MostSpecializedTypeArgsMap>(I->first);
140 State = setDynamicTypeInfo(State, Region, Ty, /*CanBeSubClassed=*/false);
286 State = setDynamicTypeInfo(State, ToR, QualType(NewTy, 0));
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);
568 State = State->remove<MostSpecializedTypeArgsMap>(Sym);
840 State = State->set<MostSpecializedTypeArgsMap>(RetSym, InferredType);
881 State = setDynamicTypeInfo(State, RetRegion, ResultType,
894 State = State->set<MostSpecializedTypeArgsMap>(RetSym, ResultPtrType);
tools/clang/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp 237 State = State->BindExpr(CE, C.getLocationContext(),
257 State = State->add<MarkedSymbols>(Sym);
274 State = State->remove<MarkedSymbols>(Sym);
280 State = State->remove<DenotedSymbols>(Sym);
tools/clang/lib/StaticAnalyzer/Checkers/GTestChecker.cpp 148 State = assumeValuesEqual(ThisSuccess, BooleanArgVal, State, C);
176 State = assumeValuesEqual(ThisSuccess, OtherSuccess, State, C);
284 State = C.getConstraintManager().assume(
tools/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp 482 State = Rule.process(CE, C);
508 State = addTaint(State, CE, C.getLocationContext());
519 State = addTaint(State, *V);
523 State = State->remove<TaintArgsOnPostVisit>();
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 142 State = allocation_state::markReleased(State, Symbol, Origin);
144 State = State->remove<RawPtrMap>(MR);
217 State = State->set<RawPtrMap>(ObjRegion, Set);
243 State = State->remove<RawPtrMap>(Entry.first);
251 State = CleanedUpSet.isEmpty()
tools/clang/lib/StaticAnalyzer/Checkers/IteratorChecker.cpp 723 State = setIteratorPosition(State, Call.getReturnValue(), *Pos);
725 State = removeIteratorPosition(State, Call.getArgSVal(0));
754 State = setIteratorPosition(State, Loc, *Pos);
759 State = removeIteratorPosition(State, Loc);
773 State = setIteratorPosition(State, C.getSVal(MTE), *Pos);
825 State = State->remove<IteratorRegionMap>(Reg.first);
833 State = State->remove<IteratorSymbolMap>(Sym.first);
843 State = State->remove<ContainerMap>(Cont.first);
878 State = assumeNoOverflow(State, Sym, 4);
882 State = setIteratorPosition(State, LVal,
886 State = setIteratorPosition(State, RVal,
899 if ((State = relateSymbols(State, Sym1, Sym2,
914 StateTrue = StateTrue->assume(*ConditionVal, true);
919 StateFalse = StateFalse->assume(*ConditionVal, false);
961 State = setIteratorPosition(State, Iter, NewPos);
962 State = setIteratorPosition(State, RetVal, Postfix ? *Pos : NewPos);
979 State = setIteratorPosition(State, Iter, NewPos);
980 State = setIteratorPosition(State, RetVal, Postfix ? *Pos : NewPos);
1004 State =
1151 State = createContainerBegin(State, ContReg, CE, C.getASTContext().LongTy,
1155 State = setIteratorPosition(State, RetVal,
1173 State = createContainerEnd(State, ContReg, CE, C.getASTContext().LongTy,
1177 State = setIteratorPosition(State, RetVal,
1191 State = assumeNoOverflow(State, Sym, 4);
1192 State = setIteratorPosition(State, RetVal,
1210 State = invalidateAllIteratorPositions(State, ContReg);
1226 State = reassignAllIteratorPositionsUnless(State, OldContReg, ContReg,
1234 State = assumeNoOverflow(State, NewEndSym, 4);
1236 State = setContainerData(State, ContReg, CData->newEnd(NewEndSym));
1238 State = setContainerData(State, ContReg,
1243 State = rebaseSymbolInIteratorPositionsIf(
1248 State = reassignAllIteratorPositions(State, OldContReg, ContReg);
1254 State =
1257 State = setContainerData(State, ContReg,
1260 State =
1266 State = reassignAllIteratorPositions(State, OldContReg, ContReg);
1288 State =
1295 State = invalidateAllIteratorPositions(State, ContReg);
1310 State = invalidateAllIteratorPositions(State, ContReg);
1322 State = invalidateIteratorPositions(State, EndSym, BO_GE);
1332 State = setContainerData(State, ContReg, CData->newEnd(newEndSym));
1363 State = invalidateIteratorPositions(State, BackSym, BO_GE);
1364 State = setContainerData(State, ContReg, CData->newEnd(nullptr));
1366 State = invalidateIteratorPositions(State, BackSym, BO_EQ);
1369 State = setContainerData(State, ContReg, CData->newEnd(newEndSym));
1385 State = invalidateAllIteratorPositions(State, ContReg);
1401 State = setContainerData(State, ContReg, CData->newBegin(newBeginSym));
1424 State = invalidateIteratorPositions(State, BeginSym, BO_LE);
1426 State = invalidateIteratorPositions(State, BeginSym, BO_EQ);
1436 State = setContainerData(State, ContReg, CData->newBegin(newBeginSym));
1452 State = invalidateAllIteratorPositions(State, Cont);
1454 State = invalidateIteratorPositions(State, Pos->getOffset(), BO_GE);
1458 State = invalidateIteratorPositions(State, EndSym, BO_GE);
1459 State = setContainerData(State, Cont, CData->newEnd(nullptr));
1478 State = invalidateAllIteratorPositions(State, Cont);
1480 State = invalidateIteratorPositions(State, Pos->getOffset(), BO_GE);
1484 State = invalidateIteratorPositions(State, EndSym, BO_GE);
1485 State = setContainerData(State, Cont, CData->newEnd(nullptr));
1489 State = invalidateIteratorPositions(State, Pos->getOffset(), BO_EQ);
1509 State = invalidateAllIteratorPositions(State, Cont);
1511 State = invalidateIteratorPositions(State, Pos1->getOffset(), BO_GE);
1515 State = invalidateIteratorPositions(State, EndSym, BO_GE);
1516 State = setContainerData(State, Cont, CData->newEnd(nullptr));
1520 State = invalidateIteratorPositions(State, Pos1->getOffset(), BO_GE,
1543 State = invalidateIteratorPositions(State, NextSym, BO_EQ);
1556 State = invalidateIteratorPositions(State, Pos1->getOffset(), BO_GT,
1585 State = assumeNoOverflow(State, NewPosSym, 4);
1954 State = assumeNoOverflow(State, Sym, 4);
1977 State = assumeNoOverflow(State, Sym, 4);
2119 NewState = NewState->assume(*DV, true);
2129 NewState = NewState->assume(*DV, true);
2151 State = State->set<IteratorRegionMap>(RegionMap);
2164 State = State->set<IteratorSymbolMap>(SymbolMap);
tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp 51 State = State->set<RequestMap>(MR, Request::State::Nonblocking);
81 State = State->set<RequestMap>(ReqRegion, Request::State::Wait);
85 State = ErrorNode->getState();
117 State = ErrorNode->getState();
122 State = State->remove<RequestMap>(Req.first);
tools/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp 229 State = State->remove<AllocatedData>(AP.first);
274 State = State->remove<AllocatedData>(V);
379 State = State->remove<AllocatedData>(ArgSM);
389 State = State->remove<AllocatedData>(ArgSM);
440 State = State->set<AllocatedData>(V, AllocationState(ArgExpr, idx,
535 State = State->remove<AllocatedData>(I->first);
555 State = State->remove<AllocatedData>(I->first);
593 State = State->remove<AllocatedData>(Sym);
614 State = State->remove<AllocatedData>(Sym);
tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp 808 state = state->remove<RegionState>(sym);
1077 State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State);
1078 State = ProcessZeroAllocCheck(C, CE, 0, State);
1081 State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State);
1087 State = MaybeState.getValue();
1089 State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State);
1098 State = MaybeState.getValue();
1100 State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State);
1104 State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State);
1105 State = ProcessZeroAllocCheck(C, CE, 0, State);
1109 State = ReallocMemAux(C, CE, /*ShouldFreeOnFail*/ false, State);
1110 State = ProcessZeroAllocCheck(C, CE, 1, State);
1112 State = ReallocMemAux(C, CE, /*ShouldFreeOnFail*/ true, State);
1113 State = ProcessZeroAllocCheck(C, CE, 1, State);
1115 State = CallocMem(C, CE, State);
1116 State = ProcessZeroAllocCheck(C, CE, 0, State);
1117 State = ProcessZeroAllocCheck(C, CE, 1, State);
1124 State = FreeMemAux(C, CE, State, 0, false, IsKnownToBeAllocatedMemory);
1129 State = MallocUpdateRefState(C, CE, State);
1131 State = MallocUpdateRefState(C, CE, State);
1136 State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State,
1138 State = ProcessZeroAllocCheck(C, CE, 0, State);
1146 State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State,
1148 State = ProcessZeroAllocCheck(C, CE, 0, State);
1151 State = MallocMemAux(C, CE, CE->getArg(0), UndefinedVal(), State,
1153 State = ProcessZeroAllocCheck(C, CE, 0, State);
1157 State = FreeMemAux(C, CE, State, 0, false, IsKnownToBeAllocatedMemory);
1165 State = MallocMemAux(C, CE, UnknownVal(), UnknownVal(), State,
1168 State = FreeMemAux(C, CE, State, 0, false, IsKnownToBeAllocatedMemory);
1175 State = MallocMemAux(C, CE, CE->getArg(0), zeroVal, State);
1176 State = ProcessZeroAllocCheck(C, CE, 0, State);
1180 State = MallocMemAux(C, CE, CE->getArg(1), UndefinedVal(), State);
1181 State = ProcessZeroAllocCheck(C, CE, 1, State);
1195 State = MallocMemAux(C, CE, TotalSize, Init, State);
1196 State = ProcessZeroAllocCheck(C, CE, 0, State);
1197 State = ProcessZeroAllocCheck(C, CE, 1, State);
1202 State = ReallocMemAux(C, CE, /*ShouldFreeOnFail*/ false, State,
1204 State = ProcessZeroAllocCheck(C, CE, 1, State);
1205 State = ProcessZeroAllocCheck(C, CE, 2, State);
1217 State = MallocMemReturnsAttr(C, CE, I, State);
1221 State = FreeMemAttr(C, CE, I, State);
1354 State = MallocUpdateRefState(C, NE, State, NE->isArray() ? AF_CXXNewArray
1356 State = addExtentSize(C, NE, State, Target);
1357 State = ProcessZeroAllocCheck(C, NE, 0, State, Target);
1413 State = State->assume(extentMatchesSize, true);
1431 State = FreeMemAux(C, DE->getArgument(), DE, State,
1530 State = State->BindExpr(CE, C.getLocationContext(), RetVal);
1533 State = State->bindDefaultInitial(RetVal, Init, LCtx);
1547 State = State->assume(extentMatchesSize, true);
1595 State = StateI;
1878 State = State->remove<FreeReturnValue>(SymBase);
1887 State = State->set<FreeReturnValue>(SymBase, RetStatusSymbol);
2488 stateRealloc = stateRealloc->set<ReallocPairs>(ToPtr,
2649 state = state->remove<ReallocPairs>(I->first);
2658 state = state->remove<FreeReturnValue>(I->first);
2796 state =
2830 State = State->set<RegionState>(Sym, RefState::getEscaped(RS));
2890 state = state->remove<RegionState>(I.getKey());
2908 state = state->set<RegionState>(ReallocSym,
2912 state = state->remove<RegionState>(ReallocSym);
2919 state = state->remove<ReallocPairs>(I.getKey());
3138 State = State->set<RegionState>(sym, RefState::getEscaped(RS));
tools/clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp 249 State = State->remove<TrackedRegionMap>(E.first);
386 State = State->set<TrackedRegionMap>(Region, RegionState::getReported());
490 State = State->set<TrackedRegionMap>(ArgRegion, RegionState::getMoved());
610 State = removeFromState(State, CC->getCXXThisVal().getAsRegion());
644 State = removeFromState(State, ThisRegion);
661 State = removeFromState(State, ThisRegion);
694 State = State->remove<TrackedRegionMap>(Region);
722 State = removeFromState(State, Region);
730 State = removeFromState(State, Region->getBaseRegion());
tools/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp 174 state = stateNotNull;
tools/clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp 441 OriginalState = OriginalState->set<InvariantViolated>(true);
459 State = State->remove<NullabilityMap>(I->first);
599 State = State->set<InvariantViolated>(true);
631 State = State->set<NullabilityMap>(Region,
734 State = State->set<NullabilityMap>(
769 State = State->set<NullabilityMap>(Region, Nullability::Contradicted);
779 State = State->set<NullabilityMap>(Region, Nullability::Nullable);
848 State =
858 State =
871 State = State->set<NullabilityMap>(ReturnRegion,
899 State = State->set<NullabilityMap>(
921 State = State->set<NullabilityMap>(
960 State = State->set<NullabilityMap>(Region, Nullability::Contradicted);
972 State = State->set<NullabilityMap>(Region,
980 State = State->set<NullabilityMap>(Region, Nullability::Contradicted);
1119 State = State->set<InvariantViolated>(true);
1156 State = State->set<NullabilityMap>(
1164 State = State->set<NullabilityMap>(
tools/clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp 169 State = State->remove<ArraySizeMap>(Sym);
tools/clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp 121 state = state->set<SelfFlag>(sym, getSelfFlags(val, state) | flag);
183 state = state->set<CalledInit>(true);
276 state = state->remove<PreCallSelfFlags>();
330 State = State->remove<CalledInit>();
332 State = State->remove<SelfFlag>(sym);
tools/clang/lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp 125 State = State->add<CalledSuperDealloc>(ReceiverSymbol);
tools/clang/lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp 236 State = State->set<RegionState>(Region, AllocKind::Array);
253 State = State->set<RegionState>(Region, Kind);
271 State = State->set<RegionState>(Region, AllocKind::Reinterpreted);
292 State = State->set<RegionState>(Region, AllocKind::Array);
tools/clang/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp 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);
227 state = resolvePossiblyDestroyedMutex(state, lockR, sym);
273 lockSucc = state->assume(retVal, false);
279 lockSucc = state;
283 lockSucc = lockSucc->add<LockSet>(lockR);
284 lockSucc = lockSucc->set<LockMap>(lockR, LockState::getLocked());
298 state = resolvePossiblyDestroyedMutex(state, lockR, sym);
339 state = state->set<LockSet>(LS.getTail());
342 state = state->set<LockMap>(lockR, LockState::getUnlocked());
358 State = resolvePossiblyDestroyedMutex(State, LockR, sym);
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());
419 State = resolvePossiblyDestroyedMutex(State, LockR, sym);
423 State = State->set<LockMap>(LockR, LockState::getUnlocked());
477 State = resolvePossiblyDestroyedMutex(State, lockR, &Sym);
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp 136 state = removeRefBinding(state, sym);
178 state = state->scanReachableSymbols<StopTrackingCallback>(Regions).getState();
219 state = updateSymbol(state, Sym, *T, AE, hasErr, C);
238 state = updateSymbol(state, sym, *T,
252 state = setRefBinding(state, sym,
278 State = setRefBinding(State, Sym,
334 State = setRefBinding(State, Sym, PlusZero.withIvarAccess());
464 state = removeRefBinding(state, Sym);
472 state = removeRefBinding(state, Sym);
482 state = removeRefBinding(state, Sym);
546 AssumeNonZeroReturn = AssumeNonZeroReturn->assume(*DL, true);
547 AssumeZeroReturn = AssumeZeroReturn->assume(*DL, false);
579 AssumeNonZeroReturn = makeNotOwnedParameter(AssumeNonZeroReturn);
580 AssumeZeroReturn = makeNotOwnedParameter(AssumeZeroReturn);
583 AssumeNonZeroReturn = makeOwnedParameter(AssumeNonZeroReturn);
584 AssumeZeroReturn = makeOwnedParameter(AssumeZeroReturn);
587 AssumeNonZeroReturn = makeOwnedParameter(AssumeNonZeroReturn);
590 AssumeZeroReturn = makeOwnedParameter(AssumeZeroReturn);
629 state = updateSymbol(state, Sym, *T, Effect, hasErr, C);
648 state = updateSymbol(state, Sym, *T,
661 state = updateSymbol(state, Sym, *T, Summ.getThisEffect(),
696 state = setRefBinding(state, Sym, *updatedRefVal);
940 state = state->BindExpr(CE, LCtx, RetVal, /*Invalidate=*/false);
947 NullOutputState = NullOutputState->BindExpr(
954 state = state->assume(*L, /*assumption=*/true);
1023 state = setRefBinding(state, Sym, X);
1036 state = handleAutoreleaseCounts(state, Pred, &AutoreleaseTag, C, Sym, X, S);
1091 state = setRefBinding(state, Sym, X);
1110 state = setRefBinding(state, Sym,
1115 state = setRefBinding(state, Sym, X ^ RefVal::ErrorReturnedNotOwned);
1145 state = state->scanReachableSymbols<StopTrackingCallback>(val).getState();
1178 state = state->set<RefBindings>(B);
1201 state = removeRefBinding(state, sym);
1262 state = setRefBinding(state, Sym, V);
1359 state = setRefBinding(state, Sym, NewVal);
1387 state = handleAutoreleaseCounts(state, Pred, /*Tag=*/nullptr, Ctx,
1404 state = handleSymbolDeath(state, I.first, I.second, Leaked);
1422 state = handleAutoreleaseCounts(state, Pred, &Tag, C, Sym, V);
1428 state = handleSymbolDeath(state, Sym, *getRefBinding(state, Sym), Leaked);
1451 state = state->set<RefBindings>(B);
tools/clang/lib/StaticAnalyzer/Checkers/ReturnValueChecker.cpp 113 State = State->assume(ReturnV.castAs<DefinedOrUnknownSVal>(), ExpectedValue);
tools/clang/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp 99 state = state->remove<StreamMap>(sym);
132 State = State->set<StreamMap>(FileDesc, StreamState::getOpened());
158 State = State->set<StreamMap>(FileDesc, StreamState::getClosed());
190 State = State->remove<StreamMap>(Sym);
264 State = State->remove<StreamMap>(Sym);
tools/clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp 256 State = CM.assumeInclusiveRange(State, *N, Min, Max, false);
290 State = CM.assumeInclusiveRange(State, *N, MinusInf, Left, false);
298 State = CM.assumeInclusiveRange(State, *N, Right, PlusInf, false);
307 State = CM.assumeInclusiveRange(State, *N, Min, Max, false);
335 State = State->assume(*CompV, true);
360 NewState = VR.apply(NewState, Call, Summary);
391 State = State->BindExpr(CE, LC, V);
tools/clang/lib/StaticAnalyzer/Checkers/StreamChecker.cpp 221 state = state->BindExpr(CE, C.getLocationContext(), RetVal);
231 stateNotNull =
233 stateNull =
261 if (!(state = CheckNullStream(C.getSVal(CE->getArg(0)), state, C)))
tools/clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp 150 State =
tools/clang/lib/StaticAnalyzer/Checkers/TrustNonnullChecker.cpp 74 State = addImplication(Antecedent, State, true);
75 State = addImplication(Antecedent, State, false);
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);
136 State = dropDeadFromGDM<NullImplicationMap>(SymReaper, State);
137 State = dropDeadFromGDM<NonNullImplicationMap>(SymReaper, State);
151 State = State->remove<MapName>(P.first);
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 93 St = PrevN->getState();
tools/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObjectChecker.cpp 221 State = State->remove<AnalyzedRegions>(R);
264 State = State->add<AnalyzedRegions>(PointeeR);
267 State = State->add<AnalyzedRegions>(FR);
tools/clang/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp 129 state = stateNotZero;
152 state = StatePos;
175 state = state->assume(sizeIsKnown, true);
tools/clang/lib/StaticAnalyzer/Checkers/ValistChecker.cpp 212 State = State->remove<InitializedVALists>(Reg);
330 State = State->remove<InitializedVALists>(VAList);
351 State = State->add<InitializedVALists>(VAList);
374 State = State->remove<InitializedVALists>(VAList);
tools/clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp 177 ChildState = ChildState->set<VforkResultRegion>(LhsDeclReg);
tools/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp 180 State = State->set<CtorDtorMap>(Reg, ObjectState::CtorCalled);
182 State = State->remove<CtorDtorMap>(Reg);
194 State = State->set<CtorDtorMap>(Reg, ObjectState::DtorCalled);
196 State = State->remove<CtorDtorMap>(Reg);
tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp 629 LastReturnState = State;
tools/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp 607 state = RegionChangesChecker(state, invalidated, ExplicitRegions, Regions,
629 State = PointerEscapeChecker(State, Escaped, Call, Kind, ETraits);
643 state = EvalAssumeChecker(state, Cond, Assumption);
tools/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp 107 InitState = SubEng.getInitialState(L);
tools/clang/lib/StaticAnalyzer/Core/DynamicType.cpp 81 State = State->set<DynamicTypeMap>(MR->StripCasts(), NewTy);
102 State = State->set<DynamicTypeMap>(MR, CastToTy);
115 State = State->set<DynamicCastMap>(MR, Set);
126 State = State->remove<DynamicCastMap>(Elem.first);
tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp 269 state = newState;
284 state = state->assume(*LV, true);
299 state = state->assume(*LV, true);
375 State = finishObjectConstruction(State, MT, LC);
376 State = State->BindExpr(Result, LC, *V);
407 State = State->invalidateRegions(Reg, InitWithAdjustments,
426 State = State->bindLoc(BaseReg.castAs<Loc>(), InitVal, LC, false);
437 State =
440 State = State->bindLoc(BaseReg.castAs<Loc>(), InitVal, LC, false);
447 State = State->BindExpr(Result, LC, Reg);
449 State = State->BindExpr(Result, LC, InitValWithAdjustments);
453 State = processRegionChange(State, TR, LC);
731 CleanedState = StateMgr.removeDeadBindings(CleanedState, SFC, SymReaper);
750 CheckerState =
808 NewState = processLoopEnd(S, NewState);
843 State = finishObjectConstruction(State, BMI, LC);
1082 State = finishObjectConstruction(State, D.getBindTemporaryExpr(),
1090 State = cleanupElidedDestructor(State, BTE, LC);
1168 State = addObjectUnderConstruction(State, BTE, LC, UnknownVal());
1324 state = state->BindExpr(S, Pred->getLocationContext(),
1440 State = State->BindExpr(S, LCtx, *ConstantVal);
1442 State = createTemporaryRegionIfNeeded(State, LCtx,
1484 State = escapeValue(State, Val, PSK_EscapeOther);
1888 NewNodeState =
2200 state = state->add<InitializedGlobalsSet>(VD);
2268 State = finishArgumentConstruction(
2294 State = State->remove<ObjectsUnderConstruction>(I.first);
2380 StateCase = DefaultSt;
2495 state = state->assume(V.castAs<DefinedOrUnknownSVal>(), true);
2587 state = createTemporaryRegionIfNeeded(state, LCtx, BaseExpr);
2590 state = state->BindExpr(M, LCtx, MDVal);
2598 state = createTemporaryRegionIfNeeded(state, LCtx, BaseExpr,
2663 State = State->invalidateRegions(ValuesToInvalidate, AE,
2670 State = State->BindExpr(AE, LCtx, ResultVal);
2746 State = getCheckerManager().runCheckersForPointerEscape(State,
2751 State = getCheckerManager().runCheckersForPointerEscape(State,
2781 state = processPointerEscapedOnBind(state, location, Val, LC);
2789 state = processPointerEscapedOnBind(state, location, Val, LC);
2794 state = state->bindLoc(location.castAs<Loc>(),
2862 state = I->getState();
2950 StateTrue = StateTrue->BindExpr(Ex, Pred->getLocationContext(), Val);
2957 StateFalse = StateFalse->BindExpr(Ex, Pred->getLocationContext(), Val);
2981 state = state->bindLoc(*LV, UnknownVal(), Pred->getLocationContext());
tools/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp 96 state = createTemporaryRegionIfNeeded(state, LCtx, LHS);
102 state = state->BindExpr(B, LCtx, Result);
105 state = escapeValue(state, LeftV, PSK_EscapeOther);
106 state = escapeValue(state, RightV, PSK_EscapeOther);
139 state = (*I)->getState();
184 state = state->BindExpr(B, LCtx, location);
186 state = state->BindExpr(B, LCtx, Result);
244 State = State->bindLoc(loc::MemRegionVal(capturedR), originalV, LCtx);
276 state = state->BindExpr(CastE, LCtx, V);
278 state = escapeValue(state, OrigV, PSK_EscapeOther);
295 state = state->BindExpr(CastE, LCtx, result);
360 state = state->BindExpr(CastE, LCtx, V);
371 state = state->BindExpr(CastE, LCtx, V);
376 state =
390 state = state->BindExpr(CastE, LCtx, UnknownVal());
395 state =
425 state =
433 state = state->BindExpr(CastE, LCtx, V);
442 state = state->BindExpr(CastE, LCtx, val);
472 state = state->BindExpr(CastE, LCtx, svalBuilder.makeNull());
480 state = state->BindExpr(CastE, LCtx, NewSym);
483 state = state->BindExpr(CastE, LCtx, val);
506 state = state->BindExpr(CastE, LCtx, val);
512 state = state->BindExpr(CastE, LCtx, V);
518 state = state->BindExpr(CastE, LCtx, V);
531 state = state->BindExpr(CastE, LCtx, CastedPTMSV);
536 state = handleLVectorSplat(state, LCtx, CastE, Bldr, Pred);
542 state = handleLVectorSplat(state, LCtx, CastE, Bldr, Pred);
565 State = State->bindLoc(CLLoc, V, LCtx);
606 state = finishObjectConstruction(state, DS, LC);
806 SrcState = N->getState();
898 state = state->BindExpr(Ex, (*I)->getLocationContext(),
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);
1079 state = (*I)->getState();
1085 state = state->BindExpr(U, LCtx, V2_untested);
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 34 state = createTemporaryRegionIfNeeded(state, LCtx, tempExpr, ME);
90 State = State->BindExpr(CallExpr, LCtx, ThisVal);
92 State = bindReturnValue(Call, LCtx, State);
132 State =
159 State = addObjectUnderConstruction(State, Init, LCtx, FieldVal);
258 State = addObjectUnderConstruction(State, CE, LCtx, V);
262 State = elideDestructor(State, BTE, LCtx);
267 State = addObjectUnderConstruction(State, MTE, LCtx, V);
273 State = PreElideState;
306 State = addObjectUnderConstruction(State, BTE, LCtx, V);
309 State = addObjectUnderConstruction(State, MTE, LCtx, V);
359 State = addObjectUnderConstruction(State, {CE, Idx}, LCtx, V);
369 State = addObjectUnderConstruction(State, {CCE, Idx}, LCtx, V);
376 State = addObjectUnderConstruction(State, {ME, Idx}, LCtx, V);
382 State = addObjectUnderConstruction(State, BTE, LCtx, V);
410 State = finishObjectConstruction(State, CE, LCtx);
412 State = State->BindExpr(CE, LCtx, State->getSVal(*L, CE->getType()));
525 State = State->bindDefaultZero(Target, LCtx);
720 State = State->assume(RetVal.castAs<DefinedOrUnknownSVal>(), true);
757 State = finishObjectConstruction(State, CNE, LCtx);
780 State = Call->invalidateRegions(blockCount);
796 State = State->assume(*dSymVal, true);
813 State = State->BindExpr(CNE, Pred->getLocationContext(), Result);
830 State = State->BindExpr(CNE, LCtx, Result);
867 state = state->bindLoc(state->getLValue(VD, LCtx), V, LCtx);
922 State = State->bindLoc(FieldLoc, InitVal, LocCtxt);
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp 244 state = state->BindExpr(CE, callerCtx, V);
253 state = state->BindExpr(CCE, callerCtx, ThisV);
267 state = addObjectUnderConstruction(state, CNE, calleeCtx->getParent(),
461 State = State->enterStackFrame(Call, CalleeSFC);
542 State = finishObjectConstruction(State, {E, I}, LC);
646 State = State->invalidateRegions(TargetR, E, Count, LCtx,
675 State = Call.invalidateRegions(currBldrCtx->blockCount(), State);
676 State = bindReturnValue(Call, Pred->getLocationContext(), State);
1023 State = InlinedFailedState;
tools/clang/lib/StaticAnalyzer/Core/ExprEngineObjC.cpp 78 nextState = nextState->bindLoc(elementV, V, LCtx);
tools/clang/lib/StaticAnalyzer/Core/LoopUnrolling.cpp 78 State = State->set<LoopStack>(LS.getTail());
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>(
tools/clang/lib/StaticAnalyzer/Core/ProgramState.cpp 214 newState = Eng.notifyCheckersOfPointerEscape(newState, IS,
tools/clang/lib/StaticAnalyzer/Core/SimpleConstraintManager.cpp 46 State = assumeAux(State, Cond, Assumption);
tools/clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp 156 DiagOpts = new DiagnosticOptions();
158 RealFS = new ProxyFileSystemWithoutChdir(llvm::vfs::getRealFileSystem());
163 DepFS = new DependencyScanningWorkerFilesystem(
166 Files = new FileManager(FileSystemOptions(), RealFS);
tools/clang/tools/extra/clang-query/QueryParser.cpp 253 Q = parseSetOutputKind<SetExclusiveOutputQuery>();
256 Q = parseSetBool(&QuerySession::BindRoot);
259 Q = parseSetBool(&QuerySession::PrintMatcher);
282 Q = parseSetOutputKind<EnableOutputQuery>();
284 Q = parseSetOutputKind<DisableOutputQuery>();
tools/clang/tools/extra/clang-tidy/ClangTidyOptions.cpp 210 FS = llvm::vfs::getRealFileSystem();
tools/clang/tools/extra/clangd/ClangdServer.cpp 169 Inputs.FS = FS;
tools/clang/tools/extra/clangd/CodeComplete.cpp 1053 VFS = Input.Preamble->StatCache->getConsumingFS(std::move(VFS));
1056 ParseInput.FS = VFS;
tools/clang/tools/extra/clangd/Compiler.cpp 96 VFS = VFSWithRemapping;
tools/clang/tools/extra/clangd/ParsedAST.cpp 514 VFS = Preamble->StatCache->getConsumingFS(std::move(VFS));
tools/clang/tools/extra/clangd/index/Background.cpp 363 Inputs.FS = std::move(FS);
tools/clang/tools/extra/clangd/unittests/FileIndexTests.cpp 274 PI.FS = buildTestFS(std::move(Files));
tools/clang/tools/extra/clangd/unittests/HeadersTests.cpp 48 PI.FS = VFS;
tools/clang/tools/extra/clangd/unittests/ParsedASTTests.cpp 221 Inputs.FS = buildTestFS({{testPath("foo.cpp"), "void test() {}"}});
tools/clang/tools/extra/clangd/unittests/TUSchedulerTests.cpp 50 Inputs.FS = buildTestFS(Files, Timestamps);
tools/clang/tools/extra/clangd/unittests/TestTU.cpp 57 Inputs.FS = buildTestFS(Files);
tools/clang/tools/extra/unittests/clang-query/QueryParserTest.cpp 30 Q = parse("\n");
44 Q = parse("help me");
53 Q = parse("q");
56 Q = parse("quit me");
66 Q = parse("set foo bar");
70 Q = parse("set output");
75 Q = parse("set bind-root true foo");
79 Q = parse("set output foo");
84 Q = parse("set output dump");
88 Q = parse("set output detailed-ast");
92 Q = parse("enable output detailed-ast");
96 Q = parse("enable");
100 Q = parse("disable output detailed-ast");
104 Q = parse("set bind-root foo");
109 Q = parse("set bind-root true");
120 Q = parse("m stmt()");
132 Q = parse("l foo decl()");
138 Q = parse("let bar \"str\"");
144 Q = parse("let");
148 Q = parse("unlet x");
153 Q = parse("unlet");
157 Q = parse("unlet x bad_data");
167 Q = parse("let foo decl() # creates a decl() matcher called foo");
170 Q = parse("set bind-root false # reduce noise");
tools/clang/tools/libclang/CXIndexDataConsumer.cpp 1154 EntityInfo.AttrList = AttrListInfo::create(D, *this);
tools/clang/unittests/Basic/SourceManagerTest.cpp 39 Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
tools/clang/unittests/Frontend/ASTUnitTest.cpp 42 Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions());
tools/clang/unittests/Frontend/PCHPreambleTest.cpp 59 VFS = new ReadCountingInMemoryFileSystem();
tools/clang/unittests/Lex/HeaderSearchTest.cpp 36 Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
tools/clang/unittests/Lex/LexerTest.cpp 45 Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
tools/clang/unittests/Lex/PPCallbacksTest.cpp 125 Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
tools/clang/unittests/Lex/PPConditionalDirectiveRecordTest.cpp 39 Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
unittests/Support/VirtualFileSystemTest.cpp 1370 FS = getFromYAMLString("");
1372 FS = getFromYAMLString("[]");
1374 FS = getFromYAMLString("'string'");
1514 FS = getFromYAMLString("{ 'roots':[}", Lower);
1516 FS = getFromYAMLString(
1522 FS = getFromYAMLString("{ 'knobular': 'true', 'roots':[] }", Lower);
1524 FS = getFromYAMLString("{ 'case-sensitive': 'maybe', 'roots':[] }", Lower);
1528 FS = getFromYAMLString("{ 'roots':'' }", Lower);
1530 FS = getFromYAMLString("{ 'roots':{} }", Lower);
1534 FS = getFromYAMLString(
1537 FS = getFromYAMLString("{ 'roots':[ { 'type': 'file', 'name': [], "
1541 FS = getFromYAMLString(
1545 FS = getFromYAMLString(
1549 FS = getFromYAMLString(
1553 FS = getFromYAMLString(
1557 FS = getFromYAMLString(
1563 FS = getFromYAMLString("{ 'roots':[ { 'type': 'file', 'name': 'me' }", Lower);
1565 FS = getFromYAMLString(
1568 FS = getFromYAMLString("{ 'roots':[ { 'name': 'me', 'contents': [] }", Lower);
1572 FS = getFromYAMLString("{ 'roots':[], 'roots':[] }", Lower);
1574 FS = getFromYAMLString(
1578 FS =
1585 FS = getFromYAMLRawString("{ 'roots':[] }", Lower);
1589 FS = getFromYAMLRawString("{ 'version':'foo', 'roots':[] }", Lower);
1591 FS = getFromYAMLRawString("{ 'version':-1, 'roots':[] }", Lower);
1593 FS = getFromYAMLRawString("{ 'version':100000, 'roots':[] }", Lower);
1626 FS = getFromYAMLString("{ 'use-external-names': false,\n"
1668 FS = getFromYAMLString(
1682 FS = getFromYAMLString(
1862 FS = getFromYAMLString("{ 'roots': [\n"
1871 FS = getFromYAMLString(
usr/include/c++/7.4.0/bits/stl_algobase.h 343 *__result = std::move(*__first);
usr/include/c++/7.4.0/tuple 1252 this->_M_head(*this) = std::forward<_U1>(__in.first);
1253 this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);