|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
examples/HowToUseJIT/HowToUseJIT.cpp 66 std::unique_ptr<Module> Owner = std::make_unique<Module>("test", Context);
examples/HowToUseLLJIT/HowToUseLLJIT.cpp 23 auto Context = std::make_unique<LLVMContext>();
24 auto M = std::make_unique<Module>("test", *Context);
examples/Kaleidoscope/BuildingAJIT/Chapter1/KaleidoscopeJIT.h 45 []() { return std::make_unique<SectionMemoryManager>(); }),
48 Ctx(std::make_unique<LLVMContext>()) {
64 return std::make_unique<KaleidoscopeJIT>(std::move(*JTMB), std::move(*DL));
examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp 332 auto Result = std::make_unique<NumberExprAST>(NumVal);
359 return std::make_unique<VariableExprAST>(IdName);
383 return std::make_unique<CallExprAST>(IdName, std::move(Args));
412 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
458 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
507 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
548 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
585 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
662 return std::make_unique<PrototypeAST>(FnName, ArgNames, Kind != 0,
674 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
682 auto Proto = std::make_unique<PrototypeAST>
684 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
1106 TheModule = std::make_unique<Module>("my cool jit", *TheContext);
1110 Builder = std::make_unique<IRBuilder<>>(*TheContext);
examples/Kaleidoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h 51 []() { return std::make_unique<SectionMemoryManager>(); }),
55 Ctx(std::make_unique<LLVMContext>()) {
75 return std::make_unique<KaleidoscopeJIT>(std::move(*JTMB), std::move(*DL));
92 auto FPM = std::make_unique<legacy::FunctionPassManager>(&M);
examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp 332 auto Result = std::make_unique<NumberExprAST>(NumVal);
359 return std::make_unique<VariableExprAST>(IdName);
383 return std::make_unique<CallExprAST>(IdName, std::move(Args));
412 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
458 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
507 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
548 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
585 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
662 return std::make_unique<PrototypeAST>(FnName, ArgNames, Kind != 0,
674 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
682 auto Proto = std::make_unique<PrototypeAST>(
684 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
1106 TheModule = std::make_unique<Module>("my cool jit", *TheContext);
1110 Builder = std::make_unique<IRBuilder<>>(*TheContext);
examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h 134 auto FPM = std::make_unique<legacy::FunctionPassManager>(M.get());
examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp 332 auto Result = std::make_unique<NumberExprAST>(NumVal);
359 return std::make_unique<VariableExprAST>(IdName);
383 return std::make_unique<CallExprAST>(IdName, std::move(Args));
412 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
458 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
507 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
548 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
585 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
662 return std::make_unique<PrototypeAST>(FnName, ArgNames, Kind != 0,
674 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
682 auto Proto = std::make_unique<PrototypeAST>("__anon_expr",
684 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
1105 TheModule = std::make_unique<Module>("my cool jit", TheContext);
1225 TheJIT = std::make_unique<KaleidoscopeJIT>();
examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h 210 auto FPM = std::make_unique<legacy::FunctionPassManager>(M.get());
examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp 317 auto Result = std::make_unique<NumberExprAST>(NumVal);
344 return std::make_unique<VariableExprAST>(IdName);
368 return std::make_unique<CallExprAST>(IdName, std::move(Args));
397 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
443 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
492 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
533 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
570 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
647 return std::make_unique<PrototypeAST>(FnName, ArgNames, Kind != 0,
659 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
667 auto Proto = std::make_unique<PrototypeAST>("__anon_expr",
669 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
1098 TheModule = std::make_unique<Module>("my cool jit", TheContext);
1117 std::make_unique<PrototypeAST>(FnAST->getProto());
1143 std::make_unique<PrototypeAST>(FnAST->getProto());
1230 TheJIT = std::make_unique<KaleidoscopeJIT>();
examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h 227 auto FPM = std::make_unique<legacy::FunctionPassManager>(M.get());
examples/Kaleidoscope/BuildingAJIT/Chapter5/toy.cpp 334 auto Result = std::make_unique<NumberExprAST>(NumVal);
361 return std::make_unique<VariableExprAST>(IdName);
385 return std::make_unique<CallExprAST>(IdName, std::move(Args));
414 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
460 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
509 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
550 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
587 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
664 return std::make_unique<PrototypeAST>(FnName, ArgNames, Kind != 0,
676 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
687 std::make_unique<CallExprAST>("printExprResult", std::move(PEArgs));
690 auto Proto = std::make_unique<PrototypeAST>("__anon_expr",
692 return std::make_unique<FunctionAST>(std::move(Proto),
1122 TheModule = std::make_unique<Module>("my cool jit", TheContext);
1141 std::make_unique<PrototypeAST>(FnAST->getProto());
1167 std::make_unique<PrototypeAST>(FnAST->getProto());
1256 return std::make_unique<FDRPCChannel>(sockfd, sockfd);
1284 TheJIT = std::make_unique<KaleidoscopeJIT>(ES, *Remote);
1288 std::make_unique<PrototypeAST>("printExprResult",
examples/Kaleidoscope/Chapter2/toy.cpp 200 auto Result = std::make_unique<NumberExprAST>(NumVal);
227 return std::make_unique<VariableExprAST>(IdName);
251 return std::make_unique<CallExprAST>(IdName, std::move(Args));
303 LHS = std::make_unique<BinaryExprAST>(BinOp, std::move(LHS),
340 return std::make_unique<PrototypeAST>(FnName, std::move(ArgNames));
351 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
359 auto Proto = std::make_unique<PrototypeAST>("__anon_expr",
361 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
examples/Kaleidoscope/Chapter3/toy.cpp 226 auto Result = std::make_unique<NumberExprAST>(NumVal);
253 return std::make_unique<VariableExprAST>(IdName);
277 return std::make_unique<CallExprAST>(IdName, std::move(Args));
330 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
366 return std::make_unique<PrototypeAST>(FnName, std::move(ArgNames));
377 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
385 auto Proto = std::make_unique<PrototypeAST>("__anon_expr",
387 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
601 TheModule = std::make_unique<Module>("my cool jit", TheContext);
examples/Kaleidoscope/Chapter4/toy.cpp 236 auto Result = std::make_unique<NumberExprAST>(NumVal);
263 return std::make_unique<VariableExprAST>(IdName);
287 return std::make_unique<CallExprAST>(IdName, std::move(Args));
340 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
376 return std::make_unique<PrototypeAST>(FnName, std::move(ArgNames));
387 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
395 auto Proto = std::make_unique<PrototypeAST>("__anon_expr",
397 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
553 TheModule = std::make_unique<Module>("my cool jit", TheContext);
557 TheFPM = std::make_unique<legacy::FunctionPassManager>(TheModule.get());
692 TheJIT = std::make_unique<KaleidoscopeJIT>();
examples/Kaleidoscope/Chapter5/toy.cpp 281 auto Result = std::make_unique<NumberExprAST>(NumVal);
308 return std::make_unique<VariableExprAST>(IdName);
332 return std::make_unique<CallExprAST>(IdName, std::move(Args));
361 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
407 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
467 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
503 return std::make_unique<PrototypeAST>(FnName, std::move(ArgNames));
514 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
522 auto Proto = std::make_unique<PrototypeAST>("__anon_expr",
524 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
827 TheModule = std::make_unique<Module>("my cool jit", TheContext);
831 TheFPM = std::make_unique<legacy::FunctionPassManager>(TheModule.get());
966 TheJIT = std::make_unique<KaleidoscopeJIT>();
examples/Kaleidoscope/Chapter6/toy.cpp 315 auto Result = std::make_unique<NumberExprAST>(NumVal);
342 return std::make_unique<VariableExprAST>(IdName);
366 return std::make_unique<CallExprAST>(IdName, std::move(Args));
395 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
441 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
480 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
517 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
594 return std::make_unique<PrototypeAST>(FnName, ArgNames, Kind != 0,
606 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
614 auto Proto = std::make_unique<PrototypeAST>("__anon_expr",
616 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
946 TheModule = std::make_unique<Module>("my cool jit", TheContext);
950 TheFPM = std::make_unique<legacy::FunctionPassManager>(TheModule.get());
1085 TheJIT = std::make_unique<KaleidoscopeJIT>();
examples/Kaleidoscope/Chapter7/toy.cpp 337 auto Result = std::make_unique<NumberExprAST>(NumVal);
364 return std::make_unique<VariableExprAST>(IdName);
388 return std::make_unique<CallExprAST>(IdName, std::move(Args));
417 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
463 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
512 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
553 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
590 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
667 return std::make_unique<PrototypeAST>(FnName, ArgNames, Kind != 0,
679 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
687 auto Proto = std::make_unique<PrototypeAST>("__anon_expr",
689 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
1114 TheModule = std::make_unique<Module>("my cool jit", TheContext);
1118 TheFPM = std::make_unique<legacy::FunctionPassManager>(TheModule.get());
1256 TheJIT = std::make_unique<KaleidoscopeJIT>();
examples/Kaleidoscope/Chapter8/toy.cpp 338 auto Result = std::make_unique<NumberExprAST>(NumVal);
365 return std::make_unique<VariableExprAST>(IdName);
389 return std::make_unique<CallExprAST>(IdName, std::move(Args));
418 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
464 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
513 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
554 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
591 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
668 return std::make_unique<PrototypeAST>(FnName, ArgNames, Kind != 0,
680 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
688 auto Proto = std::make_unique<PrototypeAST>("__anon_expr",
690 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
1110 TheModule = std::make_unique<Module>("my cool jit", TheContext);
examples/Kaleidoscope/Chapter9/toy.cpp 445 auto Result = std::make_unique<NumberExprAST>(NumVal);
474 return std::make_unique<VariableExprAST>(LitLoc, IdName);
498 return std::make_unique<CallExprAST>(LitLoc, IdName, std::move(Args));
529 return std::make_unique<IfExprAST>(IfLoc, std::move(Cond), std::move(Then),
575 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
624 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
665 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
702 LHS = std::make_unique<BinaryExprAST>(BinLoc, BinOp, std::move(LHS),
782 return std::make_unique<PrototypeAST>(FnLoc, FnName, ArgNames, Kind != 0,
794 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
803 auto Proto = std::make_unique<PrototypeAST>(FnLoc, "__anon_expr",
805 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
1317 TheModule = std::make_unique<Module>("my cool jit", TheContext);
1419 TheJIT = std::make_unique<KaleidoscopeJIT>();
1432 DBuilder = std::make_unique<DIBuilder>(*TheModule);
examples/LLJITExamples/ExampleModules.h 38 auto Ctx = std::make_unique<LLVMContext>();
examples/LLJITExamples/LLJITWithJITLink/LLJITWithJITLink.cpp 54 return std::make_unique<ObjectLinkingLayer>(ES, MemMgr);
examples/ParallelJIT/ParallelJIT.cpp 262 std::unique_ptr<Module> Owner = std::make_unique<Module>("test", Context);
examples/SpeculativeJIT/SpeculativeJIT.cpp 51 auto ES = std::make_unique<ExecutionSession>();
128 return std::make_unique<SectionMemoryManager>();
168 auto Ctx = std::make_unique<LLVMContext>();
include/llvm/ADT/Any.h 41 return std::make_unique<StorageImpl<T>>(Value);
81 Storage = std::make_unique<StorageImpl<U>>(std::forward<T>(Value));
include/llvm/Analysis/RegionInfoImpl.h 368 std::make_unique<RegionNodeT>(static_cast<RegionT *>(Deconst), BB)};
include/llvm/CodeGen/GlobalISel/GISelKnownBits.h 102 Info = std::make_unique<GISelKnownBits>(MF);
include/llvm/CodeGen/LiveInterval.h 231 : segmentSet(UseSegmentSet ? std::make_unique<SegmentSet>()
include/llvm/CodeGen/MachinePipeliner.h 205 Mutations.push_back(std::make_unique<CopyToPhiMutation>());
include/llvm/DebugInfo/CodeView/SymbolDeserializer.h 65 Mapping = std::make_unique<MappingInfo>(Record.content(), Container);
include/llvm/DebugInfo/CodeView/TypeDeserializer.h 69 Mapping = std::make_unique<MappingInfo>(Record.content());
include/llvm/DebugInfo/DIContext.h 296 return std::make_unique<Derived>(static_cast<const Derived &>(*this));
include/llvm/DebugInfo/PDB/Native/SymbolCache.h 90 auto Result = std::make_unique<ConcreteSymbolT>(
include/llvm/DebugInfo/PDB/PDBSymbol.h 134 return std::make_unique<ConcreteSymbolEnumerator<T>>(std::move(BaseIter));
include/llvm/ExecutionEngine/JITLink/JITLink.h 974 return std::make_unique<Impl>(std::move(Cont));
include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h 447 auto GVsM = std::make_unique<Module>((SrcM.getName() + ".globals").str(),
640 auto M = std::make_unique<Module>(NewName, SrcM.getContext());
include/llvm/ExecutionEngine/Orc/Core.h 363 return std::make_unique<AbsoluteSymbolsMaterializationUnit>(
407 return std::make_unique<ReExportsMaterializationUnit>(
419 return std::make_unique<ReExportsMaterializationUnit>(
include/llvm/ExecutionEngine/Orc/LambdaResolver.h 76 return std::make_unique<LR>(AcknowledgeORCv1Deprecation,
include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h 170 auto Symbols = std::make_unique<StringMap<const GlobalValue*>>();
208 std::make_unique<EmissionDeferredModule>(std::move(K), std::move(M));
include/llvm/ExecutionEngine/Orc/LazyReexports.h 74 return std::make_unique<NotifyResolvedFunctionImpl<NotifyResolvedImpl>>(
189 return std::make_unique<LazyReexportsMaterializationUnit>(
include/llvm/ExecutionEngine/Orc/Legacy.h 87 return std::make_unique<LambdaSymbolResolverImpl>(
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h 496 std::make_unique<RemoteTrampolinePool>(Client), ES,
556 return std::make_unique<RemoteIndirectStubsManager>(*this, Id);
include/llvm/ExecutionEngine/Orc/RPCUtils.h 780 return std::make_unique<ResponseHandlerImpl<ChannelT, FuncRetT, HandlerT>>(
include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h 219 PFC(std::make_unique<PreFinalizeContents>(
237 PFC->RTDyld = std::make_unique<RuntimeDyld>(*MemMgr, ResolverAdapter);
341 return std::make_unique<LOS>(Parent, std::move(K), std::move(Obj),
include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h 470 auto Buffer = std::make_unique<StringMemoryBuffer>(std::move(ObjBuffer));
include/llvm/IR/Metadata.h 809 makeReplaceable(std::make_unique<ReplaceableMetadataImpl>(getContext()));
include/llvm/IR/ModuleSummaryIndex.h 606 TIdInfo = std::make_unique<TypeIdInfo>(TypeIdInfo{
685 TIdInfo = std::make_unique<TypeIdInfo>();
785 VTableFuncs = std::make_unique<VTableFuncList>(std::move(Funcs));
1422 std::make_unique<FunctionSummary>(I->calculateCallGraphRoot());
include/llvm/IR/ModuleSummaryIndexYAML.h 223 Elem.SummaryList.push_back(std::make_unique<FunctionSummary>(
include/llvm/IR/PassManagerInternal.h 292 return std::make_unique<ResultModelT>(
include/llvm/LTO/Config.h 229 std::make_unique<LTOLLVMDiagnosticHandler>(&DiagHandler), true);
include/llvm/MCA/HardwareUnits/LSUnit.h 290 std::make_pair(NextGroupID, std::make_unique<MemoryGroup>()));
include/llvm/MCA/HardwareUnits/Scheduler.h 162 : Scheduler(std::make_unique<ResourceManager>(Model), Lsu,
include/llvm/ProfileData/InstrProf.h 694 ? std::make_unique<ValueProfData>(*RHS.ValueData)
704 ValueData = std::make_unique<ValueProfData>(*RHS.ValueData);
816 ValueData = std::make_unique<ValueProfData>();
include/llvm/Support/Error.h 331 return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
include/llvm/Support/GenericDomTree.h 574 std::make_unique<DomTreeNodeBase<NodeT>>(BB, IDomNode))).get();
588 std::make_unique<DomTreeNodeBase<NodeT>>(BB, nullptr)).get();
include/llvm/Support/GenericDomTreeConstruction.h 189 std::make_unique<DomTreeNodeBase<NodeT>>(BB, IDomNode)))
589 std::make_unique<DomTreeNodeBase<NodeT>>(Root, nullptr))
614 std::make_unique<DomTreeNodeBase<NodeT>>(W, IDomNode));
666 std::make_unique<DomTreeNodeBase<NodeT>>(From, VirtualRoot)))
include/llvm/Support/Registry.h 118 static std::unique_ptr<T> CtorFn() { return std::make_unique<V>(); }
lib/Analysis/AssumptionCache.cpp 259 FunctionCallbackVH(&F, this), std::make_unique<AssumptionCache>(F)));
lib/Analysis/CallGraph.cpp 32 CallsExternalNode(std::make_unique<CallGraphNode>(nullptr)) {
153 CGN = std::make_unique<CallGraphNode>(const_cast<Function *>(F));
lib/Analysis/DDG.cpp 193 return std::make_unique<DataDependenceGraph>(L, DI);
lib/Analysis/DependenceAnalysis.cpp 3418 return std::make_unique<Dependence>(Src, Dst);
3433 return std::make_unique<Dependence>(Src, Dst);
3780 return std::make_unique<FullDependence>(std::move(Result));
lib/Analysis/LazyBranchProbabilityInfo.cpp 60 LBPI = std::make_unique<LazyBranchProbabilityInfo>(&F, &LI, &TLI);
lib/Analysis/LazyValueInfo.cpp 191 ValueCache[Val] = std::make_unique<ValueCacheEntryTy>(Val, this);
lib/Analysis/LegacyDivergenceAnalysis.cpp 338 gpuDA = std::make_unique<GPUDivergenceAnalysis>(F, DT, PDT, LI, TTI);
lib/Analysis/LoopAccessAnalysis.cpp 2102 Report = std::make_unique<OptimizationRemarkAnalysis>(DEBUG_TYPE, RemarkName, DL,
2347 : PSE(std::make_unique<PredicatedScalarEvolution>(*SE, *L)),
2348 PtrRtChecking(std::make_unique<RuntimePointerChecking>(SE)),
2349 DepChecker(std::make_unique<MemoryDepChecker>(*PSE, L)), TheLoop(L),
2404 LAI = std::make_unique<LoopAccessInfo>(L, SE, TLI, AA, DT, LI);
lib/Analysis/LoopCacheAnalysis.cpp 487 return std::make_unique<CacheCost>(Loops, AR.LI, AR.SE, AR.TTI, AR.AA, DI, TRT);
lib/Analysis/MemorySSA.cpp 1252 Res.first->second = std::make_unique<AccessList>();
1260 Res.first->second = std::make_unique<DefsList>();
1569 std::make_unique<ClobberWalkerBase<AliasAnalysis>>(this, AA, DT);
1572 std::make_unique<CachingWalker<AliasAnalysis>>(this, WalkerBase.get());
1582 std::make_unique<ClobberWalkerBase<AliasAnalysis>>(this, AA, DT);
1585 std::make_unique<SkipSelfWalker<AliasAnalysis>>(this, WalkerBase.get());
2272 return MemorySSAAnalysis::Result(std::make_unique<MemorySSA>(F, &AA, &DT));
lib/Analysis/ModuleSummaryAnalysis.cpp 470 auto FuncSummary = std::make_unique<FunctionSummary>(
601 auto GVarSummary = std::make_unique<GlobalVarSummary>(Flags, VarFlags,
619 auto AS = std::make_unique<AliasSummary>(Flags);
699 std::make_unique<FunctionSummary>(
717 std::make_unique<GlobalVarSummary>(
744 BFIPtr = std::make_unique<BlockFrequencyInfo>(F, BPI, LI);
lib/Analysis/OptimizationRemarkEmitter.cpp 42 OwnedBFI = std::make_unique<BlockFrequencyInfo>(*F, BPI, LI);
100 ORE = std::make_unique<OptimizationRemarkEmitter>(&Fn, BFI);
lib/Analysis/OrderedInstructions.cpp 24 OBB = OBBMap.insert({IBB, std::make_unique<OrderedBasicBlock>(IBB)}).first;
lib/AsmParser/LLParser.cpp 8111 auto FS = std::make_unique<FunctionSummary>(
8171 std::make_unique<GlobalVarSummary>(GVFlags, GVarFlags, std::move(Refs));
8212 auto AS = std::make_unique<AliasSummary>(GVFlags);
lib/AsmParser/Parser.cpp 45 std::make_unique<Module>(F.getBufferIdentifier(), Context);
74 std::make_unique<Module>(F.getBufferIdentifier(), Context);
76 std::make_unique<ModuleSummaryIndex>(/*HaveGVs=*/true);
126 std::make_unique<ModuleSummaryIndex>(/*HaveGVs=*/false);
lib/Bitcode/Reader/BitcodeReader.cpp 5901 auto FS = std::make_unique<FunctionSummary>(
5927 auto AS = std::make_unique<AliasSummary>(Flags);
5961 std::make_unique<GlobalVarSummary>(Flags, GVF, std::move(Refs));
5988 std::make_unique<GlobalVarSummary>(Flags, GVF, std::move(Refs));
6046 auto FS = std::make_unique<FunctionSummary>(
6073 auto AS = std::make_unique<AliasSummary>(Flags);
6102 std::make_unique<GlobalVarSummary>(Flags, GVF, std::move(Refs));
6465 std::make_unique<Module>(ModuleIdentifier, Context);
6512 auto Index = std::make_unique<ModuleSummaryIndex>(/*HaveGVs=*/false);
lib/Bitcode/Reader/MetadataLoader.cpp 2136 : Pimpl(std::make_unique<MetadataLoaderImpl>(
lib/CodeGen/AsmPrinter/AsmPrinter.cpp 312 Handlers.emplace_back(std::make_unique<CodeViewDebug>(this),
382 Handlers.emplace_back(std::make_unique<WinCFGuard>(this), CFGuardName,
1035 OwnedMDT = std::make_unique<MachineDominatorTree>();
1043 OwnedMLI = std::make_unique<MachineLoopInfo>();
lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp 75 DiagInfo = std::make_unique<SrcMgrDiagInfo>();
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp 1333 auto Insertion = FnDebugInfo.insert({&GV, std::make_unique<FunctionInfo>()});
3015 Insertion.first->second = std::make_unique<GlobalVariableList>();
lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp 211 DwarfExpr = std::make_unique<DIEDwarfExpression>(*Asm, *this, *Loc);
1080 Entity = std::make_unique<DbgVariable>(
1084 Entity = std::make_unique<DbgLabel>(
lib/CodeGen/AsmPrinter/DwarfDebug.cpp 204 TmpBuf = std::make_unique<TempBuffer>(OutBS.GenerateComments);
262 ValueLoc = std::make_unique<DbgValueLoc>(getDebugLocValue(DbgValue));
855 auto OwnedUnit = std::make_unique<DwarfCompileUnit>(
1282 auto RegVar = std::make_unique<DbgVariable>(
1493 std::make_unique<DbgVariable>(cast<const DILocalVariable>(Node),
1499 std::make_unique<DbgLabel>(cast<const DILabel>(Node),
2794 auto OwnedUnit = std::make_unique<DwarfCompileUnit>(
2894 auto OwnedUnit = std::make_unique<DwarfTypeUnit>(CU, Asm, this, &InfoHolder,
lib/CodeGen/AsmPrinter/DwarfDebug.h 156 ValueLoc = std::make_unique<DbgValueLoc>(Value);
lib/CodeGen/CodeGenPrepare.cpp 347 DT = std::make_unique<DominatorTree>(F);
2670 Actions.push_back(std::make_unique<TypePromotionTransaction::OperandSetter>(
2677 std::make_unique<TypePromotionTransaction::InstructionRemover>(
2684 std::make_unique<TypePromotionTransaction::UsesReplacer>(Inst, New));
2689 std::make_unique<TypePromotionTransaction::TypeMutator>(Inst, NewTy));
2719 std::make_unique<TypePromotionTransaction::InstructionMoveBefore>(
lib/CodeGen/GCMetadata.cpp 75 Functions.push_back(std::make_unique<GCFunctionInfo>(F, *S));
lib/CodeGen/GlobalISel/CSEInfo.cpp 69 Config = std::make_unique<CSEConfigConstantOnly>();
71 Config = std::make_unique<CSEConfigFull>();
lib/CodeGen/GlobalISel/Combiner.cpp 107 CSEInfo ? std::make_unique<CSEMIRBuilder>() : std::make_unique<MachineIRBuilder>();
107 CSEInfo ? std::make_unique<CSEMIRBuilder>() : std::make_unique<MachineIRBuilder>();
lib/CodeGen/GlobalISel/IRTranslator.cpp 2228 EntryBuilder = std::make_unique<CSEMIRBuilder>(CurMF);
2231 CurBuilder = std::make_unique<CSEMIRBuilder>(CurMF);
2234 EntryBuilder = std::make_unique<MachineIRBuilder>();
2235 CurBuilder = std::make_unique<MachineIRBuilder>();
2242 ORE = std::make_unique<OptimizationRemarkEmitter>(&F);
2247 SL = std::make_unique<GISelSwitchLowering>(this, FuncInfo);
lib/CodeGen/GlobalISel/Legalizer.cpp 187 MIRBuilder = std::make_unique<CSEMIRBuilder>();
191 MIRBuilder = std::make_unique<MachineIRBuilder>();
lib/CodeGen/GlobalISel/RegBankSelect.cpp 95 MORE = std::make_unique<MachineOptimizationRemarkEmitter>(MF, MBFI);
lib/CodeGen/GlobalISel/RegisterBankInfo.cpp 286 PartMapping = std::make_unique<PartialMapping>(StartIdx, Length, RegBank);
320 ValMapping = std::make_unique<ValueMapping>(BreakDown, NumBreakDowns);
394 InstrMapping = std::make_unique<InstructionMapping>(
lib/CodeGen/IfConversion.cpp 1315 Tokens.push_back(std::make_unique<IfcvtToken>(
1333 Tokens.push_back(std::make_unique<IfcvtToken>(
1353 std::make_unique<IfcvtToken>(BBI, ICTriangle, TNeedSub, Dups));
1362 std::make_unique<IfcvtToken>(BBI, ICTriangleRev, TNeedSub, Dups));
1378 std::make_unique<IfcvtToken>(BBI, ICSimple, TNeedSub, Dups));
1390 Tokens.push_back(std::make_unique<IfcvtToken>(BBI, ICTriangleFalse,
1402 std::make_unique<IfcvtToken>(BBI, ICTriangleFRev, FNeedSub, Dups));
1412 std::make_unique<IfcvtToken>(BBI, ICSimpleFalse, FNeedSub, Dups));
lib/CodeGen/InlineSpiller.cpp 1148 auto LI = std::make_unique<LiveInterval>(OrigLI.reg, OrigLI.weight);
lib/CodeGen/LLVMTargetMachine.cpp 143 auto FOut = std::make_unique<formatted_raw_ostream>(Out);
lib/CodeGen/LazyMachineBlockFrequencyInfo.cpp 76 OwnedMDT = std::make_unique<MachineDominatorTree>();
82 OwnedMLI = std::make_unique<MachineLoopInfo>();
87 OwnedMBFI = std::make_unique<MachineBlockFrequencyInfo>();
lib/CodeGen/LiveDebugVariables.cpp 581 userValues.push_back(std::make_unique<UserValue>(Var, Expr, DL, allocator));
676 userLabels.push_back(std::make_unique<UserLabel>(Label, DL, Idx));
lib/CodeGen/MIRParser/MIRParser.cpp 219 return std::make_unique<Module>(Filename, Context);
239 M = std::make_unique<Module>(Filename, Context);
952 return std::make_unique<MIRParser>(
953 std::make_unique<MIRParserImpl>(std::move(Contents), Filename, Context));
lib/CodeGen/MachineBlockPlacement.cpp 2985 MBFI = std::make_unique<BranchFolder::MBFIWrapper>(
lib/CodeGen/MachineFunction.cpp 204 std::make_unique<PseudoSourceValueManager>(*(getSubtarget().
lib/CodeGen/MachineInstr.cpp 1730 CtxPtr = std::make_unique<LLVMContext>();
lib/CodeGen/MachineOptimizationRemarkEmitter.cpp 79 ORE = std::make_unique<MachineOptimizationRemarkEmitter>(MF, MBFI);
lib/CodeGen/MachinePostDominators.cpp 40 PDT = std::make_unique<PostDomTreeT>();
lib/CodeGen/MachineScheduler.cpp 1543 return EnableMemOpCluster ? std::make_unique<LoadClusterMutation>(TII, TRI)
1550 return EnableMemOpCluster ? std::make_unique<StoreClusterMutation>(TII, TRI)
1662 return std::make_unique<CopyConstrain>(TII, TRI);
3302 new ScheduleDAGMILive(C, std::make_unique<GenericScheduler>(C));
3454 return new ScheduleDAGMI(C, std::make_unique<PostGenericScheduler>(C),
3565 return new ScheduleDAGMILive(C, std::make_unique<ILPScheduler>(true));
3568 return new ScheduleDAGMILive(C, std::make_unique<ILPScheduler>(false));
3662 C, std::make_unique<InstructionShuffler>(Alternate, TopDown));
lib/CodeGen/MacroFusion.cpp 179 return std::make_unique<MacroFusion>(shouldScheduleAdjacent, true);
187 return std::make_unique<MacroFusion>(shouldScheduleAdjacent, false);
lib/CodeGen/PseudoSourceValue.cpp 132 V = std::make_unique<FixedStackPseudoSourceValue>(FI, TII);
141 E = std::make_unique<GlobalValuePseudoSourceValue>(GV, TII);
150 E = std::make_unique<ExternalSymbolPseudoSourceValue>(ES, TII);
lib/CodeGen/RegAllocPBQP.cpp 827 std::make_unique<PBQPRAConstraintList>();
828 ConstraintsRoot->addConstraint(std::make_unique<SpillCosts>());
829 ConstraintsRoot->addConstraint(std::make_unique<Interference>());
831 ConstraintsRoot->addConstraint(std::make_unique<Coalescing>());
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h 429 SL(std::make_unique<SDAGSwitchLowering>(this, funcinfo)), FuncInfo(funcinfo),
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp 440 ORE = std::make_unique<OptimizationRemarkEmitter>(&Fn);
lib/CodeGen/TargetPassConfig.cpp 1238 return std::make_unique<CSEConfigBase>();
lib/DebugInfo/DWARF/DWARFContext.cpp 667 CUIndex = std::make_unique<DWARFUnitIndex>(DW_SECT_INFO);
678 TUIndex = std::make_unique<DWARFUnitIndex>(DW_SECT_TYPES);
688 GdbIndex = std::make_unique<DWARFGdbIndex>();
1819 auto DObj = std::make_unique<DWARFObjInMemory>(Obj, L, HandleError);
1820 return std::make_unique<DWARFContext>(std::move(DObj), std::move(DWPName));
1827 std::make_unique<DWARFObjInMemory>(Sections, AddrSize, isLittleEndian);
1828 return std::make_unique<DWARFContext>(std::move(DObj), "");
lib/DebugInfo/DWARF/DWARFDebugFrame.cpp 464 auto Cie = std::make_unique<CIE>(
lib/DebugInfo/DWARF/DWARFUnit.cpp 86 U = std::make_unique<DWARFTypeUnit>(Context, InfoSection, Header, DA,
90 U = std::make_unique<DWARFCompileUnit>(Context, InfoSection, Header,
lib/DebugInfo/DWARF/DWARFVerifier.cpp 299 Unit = TypeUnitVector.addUnit(std::make_unique<DWARFTypeUnit>(
313 Unit = CompileUnitVector.addUnit(std::make_unique<DWARFCompileUnit>(
lib/DebugInfo/MSF/MappedBlockStream.cpp 55 return std::make_unique<MappedBlockStreamImpl<MappedBlockStream>>(
66 return std::make_unique<MappedBlockStreamImpl<MappedBlockStream>>(
321 return std::make_unique<MappedBlockStreamImpl<WritableMappedBlockStream>>(
lib/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.cpp 183 C13Builders.push_back(std::make_unique<DebugSubsectionRecordBuilder>(
189 C13Builders.push_back(std::make_unique<DebugSubsectionRecordBuilder>(
lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp 117 std::make_unique<DbiModuleDescriptorBuilder>(ModuleName, Index, Msf));
lib/DebugInfo/PDB/Native/GSIStreamBuilder.cpp 186 : Msf(Msf), PSH(std::make_unique<GSIHashStreamBuilder>()),
187 GSH(std::make_unique<GSIHashStreamBuilder>()) {}
lib/DebugInfo/PDB/Native/NativeEnumInjectedSources.cpp 108 return std::make_unique<NativeInjectedSource>(std::next(Stream.begin(), N)->second,
115 return std::make_unique<NativeInjectedSource>((Cur++)->second, File, Strings);
lib/DebugInfo/PDB/Native/NativeRawSymbol.cpp 33 return std::make_unique<NullEnumerator<PDBSymbol>>();
39 return std::make_unique<NullEnumerator<PDBSymbol>>();
45 return std::make_unique<NullEnumerator<PDBSymbol>>();
51 return std::make_unique<NullEnumerator<PDBSymbol>>();
57 return std::make_unique<NullEnumerator<PDBSymbol>>();
63 return std::make_unique<NullEnumerator<PDBSymbol>>();
68 return std::make_unique<NullEnumerator<PDBSymbol>>();
73 return std::make_unique<NullEnumerator<PDBSymbol>>();
78 return std::make_unique<NullEnumerator<IPDBLineNumber>>();
84 return std::make_unique<NullEnumerator<IPDBLineNumber>>();
89 return std::make_unique<NullEnumerator<IPDBLineNumber>>();
94 return std::make_unique<NullEnumerator<IPDBLineNumber>>();
lib/DebugInfo/PDB/Native/NativeSession.cpp 62 auto Stream = std::make_unique<MemoryBufferByteStream>(
65 auto Allocator = std::make_unique<BumpPtrAllocator>();
66 auto File = std::make_unique<PDBFile>(Path, std::move(Stream), *Allocator);
73 std::make_unique<NativeSession>(std::move(File), std::move(Allocator));
205 return std::make_unique<NativeEnumInjectedSources>(*Pdb, *ISS, *Strings);
lib/DebugInfo/PDB/Native/NativeTypeEnum.cpp 166 return std::make_unique<NullEnumerator<PDBSymbol>>();
173 return std::make_unique<NativeEnumEnumEnumerators>(Session, *ClassParent);
lib/DebugInfo/PDB/Native/NativeTypeFunctionSig.cpp 68 auto NTFA = std::make_unique<NativeTypeFunctionArg>(Session, std::move(S));
136 return std::make_unique<NullEnumerator<PDBSymbol>>();
138 auto NET = std::make_unique<NativeEnumTypes>(Session,
lib/DebugInfo/PDB/Native/PDBFile.cpp 267 auto TempGlobals = std::make_unique<GlobalsStream>(std::move(*GlobalS));
280 auto TempInfo = std::make_unique<InfoStream>(std::move(*InfoS));
293 auto TempDbi = std::make_unique<DbiStream>(std::move(*DbiS));
306 auto TempTpi = std::make_unique<TpiStream>(*this, std::move(*TpiS));
322 auto TempIpi = std::make_unique<TpiStream>(*this, std::move(*IpiS));
340 auto TempPublics = std::make_unique<PublicsStream>(std::move(*PublicS));
359 auto TempSymbols = std::make_unique<SymbolStream>(std::move(*SymbolS));
373 auto N = std::make_unique<PDBStringTable>();
394 auto IJ = std::make_unique<InjectedSourceStream>(std::move(*IJS));
lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp 45 Msf = std::make_unique<MSFBuilder>(std::move(*ExpectedMsf));
53 Info = std::make_unique<InfoStreamBuilder>(*Msf, NamedStreams);
59 Dbi = std::make_unique<DbiStreamBuilder>(*Msf);
65 Tpi = std::make_unique<TpiStreamBuilder>(*Msf, StreamTPI);
71 Ipi = std::make_unique<TpiStreamBuilder>(*Msf, StreamIPI);
81 Gsi = std::make_unique<GSIStreamBuilder>(*Msf);
lib/DebugInfo/PDB/Native/TpiStream.cpp 115 Types = std::make_unique<LazyRandomTypeCollection>(
lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp 138 std::make_unique<BinaryByteStream>(Bytes, llvm::support::little);
lib/DebugInfo/PDB/PDBSymbolFunc.cpp 82 return std::make_unique<FunctionArgEnumerator>(Session, *this);
lib/DebugInfo/PDB/PDBSymbolTypeFunctionSig.cpp 66 return std::make_unique<FunctionArgEnumerator>(Session, *this);
lib/DebugInfo/PDB/UDTLayout.cpp 74 UdtLayout = std::make_unique<ClassLayout>(std::move(UDT));
208 auto BL = std::make_unique<BaseClassLayout>(*this, Offset, false,
219 std::make_unique<VTableLayoutItem>(*this, std::move(VTables[0]));
227 auto DM = std::make_unique<DataMemberLayoutItem>(*this, std::move(Data));
239 auto VBPL = std::make_unique<VBPtrLayoutItem>(*this, std::move(VBP),
253 std::make_unique<BaseClassLayout>(*this, Offset, Elide, std::move(VB));
lib/ExecutionEngine/JITLink/JITLinkGeneric.h 129 auto L = std::make_unique<LinkerImpl>(std::forward<ArgTs>(Args)...);
lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp 50 G(std::make_unique<LinkGraph>(Obj.getFileName(), getPointerSize(Obj),
lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp 158 std::make_unique<PartitioningIRMaterializationUnit>(
270 R.replace(std::make_unique<PartitioningIRMaterializationUnit>(
313 R.replace(std::make_unique<PartitioningIRMaterializationUnit>(
lib/ExecutionEngine/Orc/CompileUtils.cpp 45 auto ObjBuffer = std::make_unique<SmallVectorMemoryBuffer>(
lib/ExecutionEngine/Orc/ExecutionUtils.cpp 189 return std::make_unique<DynamicLibrarySearchGenerator>(
lib/ExecutionEngine/Orc/IndirectionUtils.cpp 70 std::make_unique<CompileCallbackMaterializationUnit>(
167 return std::make_unique<
174 return std::make_unique<
180 return std::make_unique<
186 return std::make_unique<
192 return std::make_unique<
199 return std::make_unique<
206 return std::make_unique<
211 return std::make_unique<
lib/ExecutionEngine/Orc/LLJIT.cpp 71 auto GetMemMgr = []() { return std::make_unique<SectionMemoryManager>(); };
73 std::make_unique<RTDyldObjectLinkingLayer>(ES, std::move(GetMemMgr));
105 : ES(S.ES ? std::move(S.ES) : std::make_unique<ExecutionSession>()),
126 CompileLayer = std::make_unique<IRCompileLayer>(
132 CompileThreads = std::make_unique<ThreadPool>(S.NumCompileThreads);
229 TransformLayer = std::make_unique<IRTransformLayer>(*ES, *CompileLayer);
232 CODLayer = std::make_unique<CompileOnDemandLayer>(
lib/ExecutionEngine/Orc/Layer.cpp 22 return JD.define(std::make_unique<BasicIRLayerMaterializationUnit>(
lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp 332 jitLink(std::make_unique<ObjectLinkingLayerJITLinkContext>(
lib/ExecutionEngine/Orc/OrcCBindingsStack.h 100 return std::make_unique<GenericLayerImpl<LayerT>>(Layer);
330 std::make_unique<SectionMemoryManager>(),
344 std::make_unique<SectionMemoryManager>(),
472 return std::make_unique<CODLayerT>(
lib/ExecutionEngine/Orc/ThreadSafeModule.cpp 54 ThreadSafeContext NewTSCtx(std::make_unique<LLVMContext>());
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.cpp 53 return std::make_unique<RuntimeDyldCOFFI386>(MemMgr, Resolver);
55 return std::make_unique<RuntimeDyldCOFFThumb>(MemMgr, Resolver);
57 return std::make_unique<RuntimeDyldCOFFX86_64>(MemMgr, Resolver);
64 return std::make_unique<LoadedCOFFObjectInfo>(*this, *ObjSectionToIDOrErr);
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp 854 : Impl(::std::make_unique<RuntimeDyldCheckerImpl>(
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp 245 return std::make_unique<RuntimeDyldELF>(MemMgr, Resolver);
250 return std::make_unique<RuntimeDyldELFMips>(MemMgr, Resolver);
257 return std::make_unique<LoadedELFObjectInfo>(*this, *ObjSectionToIDOrErr);
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp 357 return std::make_unique<RuntimeDyldMachOARM>(MemMgr, Resolver);
359 return std::make_unique<RuntimeDyldMachOAArch64>(MemMgr, Resolver);
361 return std::make_unique<RuntimeDyldMachOAArch64>(MemMgr, Resolver);
363 return std::make_unique<RuntimeDyldMachOI386>(MemMgr, Resolver);
365 return std::make_unique<RuntimeDyldMachOX86_64>(MemMgr, Resolver);
372 return std::make_unique<LoadedMachOObjectInfo>(*this,
lib/FuzzMutate/FuzzerCLI.cpp 174 return std::make_unique<Module>("M", Context);
lib/IR/AsmWriter.cpp 840 std::make_unique<SlotTracker>(M, ShouldInitializeAllMetadata);
2317 MachineStorage = std::make_unique<SlotTracker>(Context);
lib/IR/Function.cpp 254 SymTab = std::make_unique<ValueSymbolTable>();
lib/IR/LLVMContextImpl.cpp 24 : DiagHandler(std::make_unique<DiagnosticHandler>()),
lib/IR/RemarkStreamer.cpp 165 std::make_unique<ToolOutputFile>(RemarksFilename, EC, Flags);
177 Context.setRemarkStreamer(std::make_unique<RemarkStreamer>(
209 std::make_unique<RemarkStreamer>(std::move(*RemarkSerializer)));
lib/IR/Verifier.cpp 5155 V = std::make_unique<Verifier>(
lib/LTO/Caching.cpp 145 return std::make_unique<CacheStream>(
146 std::make_unique<raw_fd_ostream>(Temp->FD, /* ShouldClose */ false),
lib/LTO/LTO.cpp 470 Ctx(Conf), CombinedModule(std::make_unique<Module>("ld-temp.o", Ctx)),
471 Mover(std::make_unique<IRMover>(*CombinedModule)) {}
1164 return std::make_unique<InProcessThinBackend>(
1254 return std::make_unique<WriteIndexesThinBackend>(
1406 std::make_unique<ToolOutputFile>(StatsFilename, EC, sys::fs::OF_None);
lib/LTO/LTOBackend.cpp 61 ResolutionFile = std::make_unique<raw_fd_ostream>(
336 DwoOut = std::make_unique<ToolOutputFile>(DwoFile, EC, sys::fs::OF_None);
lib/LTO/LTOCodeGenerator.cpp 177 TheLinker = std::make_unique<Linker>(*MergedModule);
696 Context.setDiagnosticHandler(std::make_unique<LTODiagnosticHandler>(this),
lib/LTO/ThinLTOCodeGenerator.cpp 302 return std::make_unique<SmallVectorMemoryBuffer>(std::move(OutputBuffer));
452 return std::make_unique<SmallVectorMemoryBuffer>(std::move(OutputBuffer));
567 std::make_unique<ModuleSummaryIndex>(/*HaveGVs=*/false);
lib/MC/ELFObjectWriter.cpp 1550 return std::make_unique<ELFSingleObjectWriter>(std::move(MOTW), OS,
1558 return std::make_unique<ELFDwoObjectWriter>(std::move(MOTW), OS, DwoOS,
lib/MC/MCAsmStreamer.cpp 71 Assembler(std::make_unique<MCAssembler>(
lib/MC/MCObjectStreamer.cpp 30 Assembler(std::make_unique<MCAssembler>(
lib/MC/MCParser/DarwinAsmParser.cpp 781 auto NewOS = std::make_unique<raw_fd_ostream>(
lib/MC/MCStreamer.cpp 683 std::make_unique<WinEH::FrameInfo>(Symbol, StartProc));
717 WinFrameInfos.emplace_back(std::make_unique<WinEH::FrameInfo>(
lib/MC/MachObjectWriter.cpp 1050 return std::make_unique<MachObjectWriter>(std::move(MOTW), OS,
lib/MC/WasmObjectWriter.cpp 1270 ProducersSection = std::make_unique<WasmCustomSection>(Name, &Section);
1275 std::make_unique<WasmCustomSection>(Name, &Section);
1598 return std::make_unique<WasmObjectWriter>(std::move(MOTW), OS);
lib/MC/WinCOFFObjectWriter.cpp 242 Symbols.push_back(std::make_unique<COFFSymbol>(Name));
254 Sections.emplace_back(std::make_unique<COFFSection>(Name));
1101 return std::make_unique<WinCOFFObjectWriter>(std::move(MOTW), OS);
lib/MC/XCOFFObjectWriter.cpp 648 return std::make_unique<XCOFFObjectWriter>(std::move(MOTW), OS);
lib/MCA/Context.cpp 35 auto RCU = std::make_unique<RetireControlUnit>(SM);
36 auto PRF = std::make_unique<RegisterFile>(SM, MRI, Opts.RegisterFileSize);
37 auto LSU = std::make_unique<LSUnit>(SM, Opts.LoadQueueSize,
39 auto HWS = std::make_unique<Scheduler>(SM, *LSU);
42 auto Fetch = std::make_unique<EntryStage>(SrcMgr);
43 auto Dispatch = std::make_unique<DispatchStage>(STI, MRI, Opts.DispatchWidth,
46 std::make_unique<ExecuteStage>(*HWS, Opts.EnableBottleneckAnalysis);
47 auto Retire = std::make_unique<RetireStage>(*RCU, *PRF, *LSU);
56 auto StagePipeline = std::make_unique<Pipeline>();
59 StagePipeline->appendStage(std::make_unique<MicroOpQueueStage>(
lib/MCA/HardwareUnits/ResourceManager.cpp 107 return std::make_unique<DefaultResourceStrategy>(RS.getReadyMask());
131 std::make_unique<ResourceState>(*SM.getProcResource(I), I, Mask);
lib/MCA/HardwareUnits/Scheduler.cpp 24 Strategy = S ? std::move(S) : std::make_unique<DefaultSchedulerStrategy>();
lib/MCA/InstrBuilder.cpp 546 std::unique_ptr<InstrDesc> ID = std::make_unique<InstrDesc>();
615 std::unique_ptr<Instruction> NewIS = std::make_unique<Instruction>(D);
lib/MCA/Stages/EntryStage.cpp 36 std::unique_ptr<Instruction> Inst = std::make_unique<Instruction>(SR.second);
lib/Object/ELFObjectFile.cpp 66 return std::make_unique<ELFObjectFile<ELFT>>(std::move(*Ret));
lib/Object/MachOObjectFile.cpp 3436 O->BindRebaseSectionTable = std::make_unique<BindRebaseSegInfo>(O);
4107 O->BindRebaseSectionTable = std::make_unique<BindRebaseSegInfo>(O);
lib/Object/WasmObjectFile.cpp 59 auto ObjectFile = std::make_unique<WasmObjectFile>(Buffer, Err);
lib/ObjectYAML/ELFEmitter.cpp 223 std::make_unique<ELFYAML::Section>(
240 std::unique_ptr<ELFYAML::Section> Sec = std::make_unique<ELFYAML::Section>(
lib/ObjectYAML/ELFYAML.cpp 1195 Section = std::make_unique<ELFYAML::StackSizesSection>();
1197 Section = std::make_unique<ELFYAML::RawContentSection>();
lib/ObjectYAML/MinidumpYAML.cpp 101 return std::make_unique<ExceptionStream>();
103 return std::make_unique<MemoryInfoListStream>();
105 return std::make_unique<MemoryListStream>();
107 return std::make_unique<ModuleListStream>();
109 return std::make_unique<RawContentStream>(Type);
111 return std::make_unique<SystemInfoStream>();
113 return std::make_unique<TextContentStream>(Type);
115 return std::make_unique<ThreadListStream>();
474 return std::make_unique<ExceptionStream>(*ExpectedExceptionStream,
479 return std::make_unique<MemoryInfoListStream>(*ExpectedList);
494 return std::make_unique<MemoryListStream>(std::move(Ranges));
514 return std::make_unique<ModuleListStream>(std::move(Modules));
517 return std::make_unique<RawContentStream>(StreamDesc.Type,
526 return std::make_unique<SystemInfoStream>(*ExpectedInfo,
530 return std::make_unique<TextContentStream>(
546 return std::make_unique<ThreadListStream>(std::move(Threads));
lib/Option/ArgList.cpp 244 std::make_unique<Arg>(Opt, MakeArgString(Opt.getPrefix() + Opt.getName()),
253 std::make_unique<Arg>(Opt, MakeArgString(Opt.getPrefix() + Opt.getName()),
262 std::make_unique<Arg>(Opt, MakeArgString(Opt.getPrefix() + Opt.getName()),
270 SynthesizedArgs.push_back(std::make_unique<Arg>(
lib/ProfileData/Coverage/CoverageMappingReader.cpp 542 return std::make_unique<VersionedCovMapFuncRecordReader<
550 return std::make_unique<VersionedCovMapFuncRecordReader<
553 return std::make_unique<VersionedCovMapFuncRecordReader<
lib/ProfileData/GCOV.cpp 43 auto GFun = std::make_unique<GCOVFunction>(*this);
167 Blocks.push_back(std::make_unique<GCOVBlock>(*this, i));
188 Edges.push_back(std::make_unique<GCOVEdge>(*Blocks[BlockNo], *Blocks[Dst]));
705 return std::make_unique<raw_null_ostream>();
709 std::make_unique<raw_fd_ostream>(CoveragePath, EC, sys::fs::OF_Text);
712 return std::make_unique<raw_null_ostream>();
lib/ProfileData/InstrProfReader.cpp 122 auto Result = std::make_unique<IndexedInstrProfReader>(
388 std::unique_ptr<InstrProfSymtab> NewSymtab = std::make_unique<InstrProfSymtab>();
776 Summary = std::make_unique<ProfileSummary>(
836 std::make_unique<InstrProfReaderIndex<OnDiskHashTableImplV3>>(
841 Remapper = std::make_unique<
847 Remapper = std::make_unique<InstrProfReaderNullRemapper>(*IndexPtr);
858 std::unique_ptr<InstrProfSymtab> NewSymtab = std::make_unique<InstrProfSymtab>();
lib/ProfileData/ProfileSummaryBuilder.cpp 96 return std::make_unique<ProfileSummary>(
103 return std::make_unique<ProfileSummary>(
lib/ProfileData/SampleProfReader.cpp 566 ProfSymList = std::make_unique<ProfileSymbolList>();
941 Summary = std::make_unique<ProfileSummary>(
1308 auto Remappings = std::make_unique<SymbolRemappingReader>();
1319 return std::make_unique<SampleProfileReaderItaniumRemapper>(
lib/ProfileData/SampleProfWriter.cpp 136 LocalBufStream = std::make_unique<raw_string_ostream>(LocalBuf);
lib/Remarks/BitstreamRemarkParser.cpp 320 StrTab ? std::make_unique<BitstreamRemarkParser>(Buf, std::move(*StrTab))
321 : std::make_unique<BitstreamRemarkParser>(Buf);
494 std::unique_ptr<Remark> Result = std::make_unique<Remark>();
lib/Remarks/BitstreamRemarkSerializer.cpp 374 return std::make_unique<BitstreamMetaSerializer>(
lib/Remarks/RemarkParser.cpp 55 return std::make_unique<YAMLRemarkParser>(Buf);
61 return std::make_unique<BitstreamRemarkParser>(Buf);
78 return std::make_unique<YAMLStrTabRemarkParser>(Buf, std::move(StrTab));
80 return std::make_unique<BitstreamRemarkParser>(Buf, std::move(StrTab));
lib/Remarks/RemarkSerializer.cpp 28 return std::make_unique<YAMLRemarkSerializer>(OS, Mode);
30 return std::make_unique<YAMLStrTabRemarkSerializer>(OS, Mode);
32 return std::make_unique<BitstreamRemarkSerializer>(OS, Mode);
45 return std::make_unique<YAMLRemarkSerializer>(OS, Mode, std::move(StrTab));
47 return std::make_unique<YAMLStrTabRemarkSerializer>(OS, Mode,
50 return std::make_unique<BitstreamRemarkSerializer>(OS, Mode,
lib/Remarks/YAMLRemarkParser.cpp 163 ? std::make_unique<YAMLStrTabRemarkParser>(Buf, std::move(*StrTab))
164 : std::make_unique<YAMLRemarkParser>(Buf);
205 std::unique_ptr<Remark> Result = std::make_unique<Remark>();
lib/Remarks/YAMLRemarkSerializer.cpp 183 return std::make_unique<YAMLMetaSerializer>(OS, ExternalFilename);
203 return std::make_unique<YAMLStrTabMetaSerializer>(OS, ExternalFilename,
lib/Support/CodeGenCoverage.cpp 106 std::make_unique<ToolOutputFile>(CoverageFilename, EC, OpenFlags);
lib/Support/Error.cpp 90 return Error(std::make_unique<ECError>(ECError(EC)));
lib/Support/FileCheck.cpp 184 return std::make_unique<FileCheckNumericVariableUse>(Name, NumericVariable);
209 return std::make_unique<FileCheckExpressionLiteral>(LiteralValue);
262 return std::make_unique<FileCheckASTBinop>(EvalBinop, std::move(LeftOp),
841 std::make_unique<FileCheckNumericVariable>(args...));
849 std::make_unique<FileCheckStringSubstitution>(this, VarName, InsertIdx));
856 Substitutions.push_back(std::make_unique<FileCheckNumericSubstitution>(
1126 : Req(Req), PatternContext(std::make_unique<FileCheckPatternContext>()),
1127 CheckStrings(std::make_unique<std::vector<FileCheckString>>()) {}
lib/Support/FileOutputBuffer.cpp 124 return std::make_unique<InMemoryBuffer>(Path, MB, Size, Mode);
149 auto MappedFile = std::make_unique<fs::mapped_file_region>(
160 return std::make_unique<OnDiskBuffer>(Path, std::move(File),
lib/Support/JSON.cpp 505 std::make_unique<ParseError>(Msg, Line, P - StartOfLine, P - Start));
lib/Support/SpecialCaseList.cpp 56 std::make_pair(std::make_unique<Regex>(std::move(CheckRE)), LineNumber));
178 std::unique_ptr<Matcher> M = std::make_unique<Matcher>();
lib/Support/Timer.cpp 61 return std::make_unique<raw_fd_ostream>(2, false); // stderr.
63 return std::make_unique<raw_fd_ostream>(1, false); // stdout.
70 auto Result = std::make_unique<raw_fd_ostream>(
77 return std::make_unique<raw_fd_ostream>(2, false); // stderr.
lib/Support/VirtualFileSystem.cpp 352 return std::make_unique<RealFileSystem>(false);
757 Name, std::make_unique<detail::InMemoryDirectory>(std::move(Stat))));
1239 std::make_unique<RedirectingFileSystem::RedirectingDirectoryEntry>(
1279 std::make_unique<RedirectingFileSystem::RedirectingFileEntry>(
1450 Result = std::make_unique<RedirectingFileSystem::RedirectingFileEntry>(
1455 std::make_unique<RedirectingFileSystem::RedirectingDirectoryEntry>(
1474 std::make_unique<RedirectingFileSystem::RedirectingDirectoryEntry>(
1790 std::make_unique<FileWithFixedStatus>(std::move(*Result), S));
lib/Support/YAMLTraits.cpp 380 return std::make_unique<ScalarHNode>(N, KeyStr);
383 return std::make_unique<ScalarHNode>(N, ValueCopy);
385 auto SQHNode = std::make_unique<SequenceHNode>(N);
394 auto mapHNode = std::make_unique<MapHNode>(N);
419 return std::make_unique<EmptyHNode>(N);
lib/TableGen/Record.cpp 1619 auto NewRecOwner = std::make_unique<Record>(Records.getNewAnonymousName(),
lib/TableGen/SetTheory.cpp 258 addOperator("add", std::make_unique<AddOp>());
259 addOperator("sub", std::make_unique<SubOp>());
260 addOperator("and", std::make_unique<AndOp>());
261 addOperator("shl", std::make_unique<ShlOp>());
262 addOperator("trunc", std::make_unique<TruncOp>());
263 addOperator("rotl", std::make_unique<RotOp>(false));
264 addOperator("rotr", std::make_unique<RotOp>(true));
265 addOperator("decimate", std::make_unique<DecimateOp>());
266 addOperator("interleave", std::make_unique<InterleaveOp>());
267 addOperator("sequence", std::make_unique<SequenceOp>());
279 addExpander(ClassName, std::make_unique<FieldExpander>(FieldName));
lib/TableGen/TGLexer.cpp 54 std::make_unique<std::vector<PreprocessorControlDesc>>());
396 std::make_unique<std::vector<PreprocessorControlDesc>>());
lib/TableGen/TGParser.cpp 381 Dest->emplace_back(std::make_unique<ForeachLoop>(Loop.Loc, Loop.IterVar,
416 auto Rec = std::make_unique<Record>(*E.Rec);
1333 ParseRecTmp = std::make_unique<Record>(".parse", ArrayRef<SMLoc>{}, Records);
1600 ParseRecTmp = std::make_unique<Record>(".parse", ArrayRef<SMLoc>{}, Records);
2705 CurRec = std::make_unique<Record>(Records.getNewAnonymousName(), DefLoc, Records,
2708 CurRec = std::make_unique<Record>(Name, DefLoc, Records);
2786 Loops.push_back(std::make_unique<ForeachLoop>(Loc, IterName, ListValue));
2837 std::make_unique<Record>(Lex.getCurStrVal(), Lex.getLoc(), Records,
2966 std::make_unique<MultiClass>(Name, Lex.getLoc(),Records)));
lib/Target/AArch64/AArch64A57FPLoadBalancing.cpp 619 auto G = std::make_unique<Chain>(MI, Idx, getColor(DestReg));
664 auto G = std::make_unique<Chain>(MI, Idx, getColor(DestReg));
lib/Target/AArch64/AArch64StackTagging.cpp 594 DeleteDT = std::make_unique<DominatorTree>(*F);
604 DeletePDT = std::make_unique<PostDominatorTree>(*F);
lib/Target/AArch64/AArch64Subtarget.cpp 294 return balanceFPOps() ? std::make_unique<A57ChainingConstraint>() : nullptr;
lib/Target/AArch64/AArch64TargetMachine.cpp 194 return std::make_unique<AArch64_MachoTargetObjectFile>();
196 return std::make_unique<AArch64_COFFTargetObjectFile>();
198 return std::make_unique<AArch64_ELFTargetObjectFile>();
323 I = std::make_unique<AArch64Subtarget>(TargetTriple, CPU, FS, *this,
lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp 1803 auto Op = std::make_unique<AArch64Operand>(k_Token, Ctx);
1818 auto Op = std::make_unique<AArch64Operand>(k_Register, Ctx);
1850 auto Op = std::make_unique<AArch64Operand>(k_VectorList, Ctx);
1863 auto Op = std::make_unique<AArch64Operand>(k_VectorIndex, Ctx);
1872 auto Op = std::make_unique<AArch64Operand>(k_Immediate, Ctx);
1883 auto Op = std::make_unique<AArch64Operand>(k_ShiftedImm, Ctx);
1893 auto Op = std::make_unique<AArch64Operand>(k_CondCode, Ctx);
1902 auto Op = std::make_unique<AArch64Operand>(k_FPImm, Ctx);
1914 auto Op = std::make_unique<AArch64Operand>(k_Barrier, Ctx);
1928 auto Op = std::make_unique<AArch64Operand>(k_SysReg, Ctx);
1941 auto Op = std::make_unique<AArch64Operand>(k_SysCR, Ctx);
1952 auto Op = std::make_unique<AArch64Operand>(k_Prefetch, Ctx);
1965 auto Op = std::make_unique<AArch64Operand>(k_PSBHint, Ctx);
1978 auto Op = std::make_unique<AArch64Operand>(k_BTIHint, Ctx);
1990 auto Op = std::make_unique<AArch64Operand>(k_ShiftExtend, Ctx);
lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp 451 return std::make_unique<AArch64ELFObjectWriter>(OSABI, IsILP32);
lib/Target/AArch64/MCTargetDesc/AArch64MachObjectWriter.cpp 409 return std::make_unique<AArch64MachObjectWriter>(CPUType, CPUSubtype,
lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp 123 return std::make_unique<AArch64WinCOFFObjectWriter>();
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.h 55 std::make_unique<msgpack::Document>();
lib/Target/AMDGPU/AMDGPULibFunc.cpp 685 F.Impl = std::make_unique<AMDGPUMangledLibFunc>();
687 F.Impl = std::make_unique<AMDGPUUnmangledLibFunc>();
lib/Target/AMDGPU/AMDGPUSubtarget.cpp 890 Mutations.push_back(std::make_unique<MemOpClusterMutation>(&InstrInfo));
891 Mutations.push_back(std::make_unique<FillMFMAShadowMutation>(&InstrInfo));
lib/Target/AMDGPU/AMDGPUTargetMachine.cpp 247 return std::make_unique<AMDGPUTargetObjectFile>();
251 return new ScheduleDAGMILive(C, std::make_unique<R600SchedStrategy>());
261 new GCNScheduleDAGMILive(C, std::make_unique<GCNMaxOccupancySchedStrategy>(C));
487 I = std::make_unique<R600Subtarget>(TargetTriple, GPU, FS, *this);
523 I = std::make_unique<GCNSubtarget>(TargetTriple, GPU, FS, *this);
lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp 899 auto Op = std::make_unique<AMDGPUOperand>(Immediate, AsmParser);
912 auto Res = std::make_unique<AMDGPUOperand>(Token, AsmParser);
923 auto Op = std::make_unique<AMDGPUOperand>(Register, AsmParser);
933 auto Op = std::make_unique<AMDGPUOperand>(Expression, AsmParser);
lib/Target/AMDGPU/GCNIterativeScheduler.cpp 240 : BaseClass(C, std::make_unique<SchedStrategyStub>())
lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFObjectWriter.cpp 90 return std::make_unique<AMDGPUELFObjectWriter>(Is64Bit, OSABI,
lib/Target/AMDGPU/SIInsertWaitcnts.cpp 1500 Brackets = std::make_unique<WaitcntBrackets>(*BI.Incoming);
1505 Brackets = std::make_unique<WaitcntBrackets>(ST);
1525 SuccBI.Incoming = std::make_unique<WaitcntBrackets>(*Brackets);
lib/Target/AMDGPU/SIMachineFunctionInfo.h 879 std::make_unique<AMDGPUBufferPseudoSourceValue>(TII));
888 std::make_unique<AMDGPUImagePseudoSourceValue>(TII));
895 std::make_unique<AMDGPUGWSResourcePseudoSourceValue>(TII);
lib/Target/AMDGPU/SIMachineScheduler.cpp 1231 BlockPtrs.push_back(std::make_unique<SIScheduleBlock>(DAG, this, ID));
1804 ScheduleDAGMILive(C, std::make_unique<GenericScheduler>(C)) {
lib/Target/AMDGPU/SIMemoryLegalizer.cpp 659 return std::make_unique<SIGfx6CacheControl>(ST);
661 return std::make_unique<SIGfx7CacheControl>(ST);
662 return std::make_unique<SIGfx10CacheControl>(ST, ST.isCuModeEnabled());
lib/Target/AMDGPU/SIModeRegister.cpp 229 auto NewInfo = std::make_unique<BlockData>();
lib/Target/AMDGPU/SIPeepholeSDWA.cpp 583 return std::make_unique<SDWADstOperand>(
586 return std::make_unique<SDWASrcOperand>(
622 return std::make_unique<SDWADstOperand>(Dst, Src1, BYTE_1, UNUSED_PAD);
624 return std::make_unique<SDWASrcOperand>(
684 return std::make_unique<SDWASrcOperand>(
713 return std::make_unique<SDWASrcOperand>(
843 return std::make_unique<SDWADstPreserveOperand>(
lib/Target/ARC/ARCTargetMachine.cpp 41 TLOF(std::make_unique<TargetLoweringObjectFileELF>()),
lib/Target/ARM/ARMParallelDSP.cpp 116 Muls.push_back(std::make_unique<MulCandidate>(I, LHS, RHS));
805 std::make_unique<WidenedLoad>(Loads, WideLoad)));
lib/Target/ARM/ARMTargetMachine.cpp 106 return std::make_unique<TargetLoweringObjectFileMachO>();
108 return std::make_unique<TargetLoweringObjectFileCOFF>();
109 return std::make_unique<ARMElfTargetObjectFile>();
287 I = std::make_unique<ARMSubtarget>(TargetTriple, CPU, FS, *this, isLittle,
lib/Target/ARM/AsmParser/ARMAsmParser.cpp 3383 auto Op = std::make_unique<ARMOperand>(k_ITCondMask);
3392 auto Op = std::make_unique<ARMOperand>(k_CondCode);
3401 auto Op = std::make_unique<ARMOperand>(k_VPTPred);
3409 auto Op = std::make_unique<ARMOperand>(k_CoprocNum);
3417 auto Op = std::make_unique<ARMOperand>(k_CoprocReg);
3426 auto Op = std::make_unique<ARMOperand>(k_CoprocOption);
3434 auto Op = std::make_unique<ARMOperand>(k_CCOut);
3442 auto Op = std::make_unique<ARMOperand>(k_Token);
3452 auto Op = std::make_unique<ARMOperand>(k_Register);
3463 auto Op = std::make_unique<ARMOperand>(k_ShiftedRegister);
3476 auto Op = std::make_unique<ARMOperand>(k_ShiftedImmediate);
3487 auto Op = std::make_unique<ARMOperand>(k_ShifterImmediate);
3497 auto Op = std::make_unique<ARMOperand>(k_RotateImmediate);
3506 auto Op = std::make_unique<ARMOperand>(k_ModifiedImmediate);
3516 auto Op = std::make_unique<ARMOperand>(k_ConstantPoolImmediate);
3525 auto Op = std::make_unique<ARMOperand>(k_BitfieldDescriptor);
3559 auto Op = std::make_unique<ARMOperand>(Kind);
3572 auto Op = std::make_unique<ARMOperand>(k_VectorList);
3584 auto Op = std::make_unique<ARMOperand>(k_VectorListAllLanes);
3596 auto Op = std::make_unique<ARMOperand>(k_VectorListIndexed);
3608 auto Op = std::make_unique<ARMOperand>(k_VectorIndex);
3617 auto Op = std::make_unique<ARMOperand>(k_Immediate);
3629 auto Op = std::make_unique<ARMOperand>(k_Memory);
3646 auto Op = std::make_unique<ARMOperand>(k_PostIndexRegister);
3658 auto Op = std::make_unique<ARMOperand>(k_MemBarrierOpt);
3667 auto Op = std::make_unique<ARMOperand>(k_InstSyncBarrierOpt);
3676 auto Op = std::make_unique<ARMOperand>(k_TraceSyncBarrierOpt);
3685 auto Op = std::make_unique<ARMOperand>(k_ProcIFlags);
3693 auto Op = std::make_unique<ARMOperand>(k_MSRMask);
3701 auto Op = std::make_unique<ARMOperand>(k_BankedReg);
lib/Target/ARM/MCTargetDesc/ARMELFObjectWriter.cpp 266 return std::make_unique<ARMELFObjectWriter>(OSABI);
lib/Target/ARM/MCTargetDesc/ARMMachObjectWriter.cpp 509 return std::make_unique<ARMMachObjectWriter>(Is64Bit, CPUType, CPUSubtype);
lib/Target/ARM/MCTargetDesc/ARMWinCOFFObjectWriter.cpp 95 return std::make_unique<ARMWinCOFFObjectWriter>(Is64Bit);
lib/Target/AVR/AVRTargetMachine.cpp 53 this->TLOF = std::make_unique<AVRTargetObjectFile>();
lib/Target/AVR/AsmParser/AVRAsmParser.cpp 202 return std::make_unique<AVROperand>(Str, S);
207 return std::make_unique<AVROperand>(RegNum, S, E);
212 return std::make_unique<AVROperand>(Val, S, E);
217 return std::make_unique<AVROperand>(RegNum, Val, S, E);
lib/Target/AVR/MCTargetDesc/AVRELFObjectWriter.cpp 155 return std::make_unique<AVRELFObjectWriter>(OSABI);
lib/Target/BPF/AsmParser/BPFAsmParser.cpp 197 auto Op = std::make_unique<BPFOperand>(Token);
206 auto Op = std::make_unique<BPFOperand>(Register);
215 auto Op = std::make_unique<BPFOperand>(Immediate);
lib/Target/BPF/BPFTargetMachine.cpp 65 TLOF(std::make_unique<TargetLoweringObjectFileELF>()),
lib/Target/BPF/BTFDebug.cpp 415 auto TypeEntry = std::make_unique<BTFTypeInt>(
434 auto TypeEntry = std::make_unique<BTFTypeFuncProto>(STy, VLen, FuncArgNames);
465 std::make_unique<BTFTypeStruct>(CTy, IsStruct, HasBitField, VLen);
492 std::make_unique<BTFTypeArray>(ElemTypeId,
507 auto TypeEntry = std::make_unique<BTFTypeInt>(dwarf::DW_ATE_unsigned, 32,
519 auto TypeEntry = std::make_unique<BTFTypeEnum>(CTy, VLen);
527 auto TypeEntry = std::make_unique<BTFTypeFwd>(CTy->getName(), IsUnion);
569 auto TypeEntry = std::make_unique<BTFTypeDerived>(DTy, Tag, true);
583 auto TypeEntry = std::make_unique<BTFTypeDerived>(DTy, Tag, false);
650 std::make_unique<BTFTypeStruct>(CTy, true, HasBitField, Elements.size());
901 std::make_unique<BTFTypeFunc>(SP->getName(), ProtoTypeId);
1106 std::make_unique<BTFKindVar>(Global.getName(), GVTypeId, GVarInfo);
1111 DataSecEntries[SecName] = std::make_unique<BTFKindDataSec>(Asm, SecName);
1169 auto FwdTypeEntry = std::make_unique<BTFTypeFwd>(TypeName, IsUnion);
lib/Target/BPF/MCTargetDesc/BPFELFObjectWriter.cpp 88 return std::make_unique<BPFELFObjectWriter>(OSABI);
lib/Target/Hexagon/HexagonInstrInfo.cpp 764 return std::make_unique<HexagonPipelinerLoopInfo>(LoopInst, &*I);
lib/Target/Hexagon/HexagonSubtarget.cpp 377 Mutations.push_back(std::make_unique<UsrOverflowMutation>());
378 Mutations.push_back(std::make_unique<HVXMemLatencyMutation>());
379 Mutations.push_back(std::make_unique<BankConflictMutation>());
384 Mutations.push_back(std::make_unique<UsrOverflowMutation>());
385 Mutations.push_back(std::make_unique<HVXMemLatencyMutation>());
lib/Target/Hexagon/HexagonTargetMachine.cpp 114 new VLIWMachineScheduler(C, std::make_unique<ConvergingVLIWScheduler>());
115 DAG->addMutation(std::make_unique<HexagonSubtarget::UsrOverflowMutation>());
116 DAG->addMutation(std::make_unique<HexagonSubtarget::HVXMemLatencyMutation>());
117 DAG->addMutation(std::make_unique<HexagonSubtarget::CallMutation>());
221 TLOF(std::make_unique<HexagonTargetObjectFile>()) {
247 I = std::make_unique<HexagonSubtarget>(TargetTriple, CPU, FS, *this);
lib/Target/Hexagon/HexagonVLIWPacketizer.cpp 140 addMutation(std::make_unique<HexagonSubtarget::UsrOverflowMutation>());
141 addMutation(std::make_unique<HexagonSubtarget::HVXMemLatencyMutation>());
142 addMutation(std::make_unique<HexagonSubtarget::BankConflictMutation>());
lib/Target/Hexagon/MCTargetDesc/HexagonELFObjectWriter.cpp 302 return std::make_unique<HexagonELFObjectWriter>(OSABI, CPU);
lib/Target/Lanai/AsmParser/LanaiAsmParser.cpp 584 auto Op = std::make_unique<LanaiOperand>(TOKEN);
594 auto Op = std::make_unique<LanaiOperand>(REGISTER);
603 auto Op = std::make_unique<LanaiOperand>(IMMEDIATE);
lib/Target/Lanai/MCTargetDesc/LanaiELFObjectWriter.cpp 91 return std::make_unique<LanaiELFObjectWriter>(OSABI);
lib/Target/MSP430/AsmParser/MSP430AsmParser.cpp 194 return std::make_unique<MSP430Operand>(Str, S);
199 return std::make_unique<MSP430Operand>(k_Reg, RegNum, S, E);
204 return std::make_unique<MSP430Operand>(Val, S, E);
210 return std::make_unique<MSP430Operand>(RegNum, Val, S, E);
215 return std::make_unique<MSP430Operand>(k_IndReg, RegNum, S, E);
220 return std::make_unique<MSP430Operand>(k_PostIndReg, RegNum, S, E);
lib/Target/MSP430/MCTargetDesc/MSP430ELFObjectWriter.cpp 57 return std::make_unique<MSP430ELFObjectWriter>(OSABI);
lib/Target/MSP430/MSP430TargetMachine.cpp 49 TLOF(std::make_unique<TargetLoweringObjectFileELF>()),
lib/Target/Mips/AsmParser/MipsAsmParser.cpp 521 std::make_unique<MipsAssemblerOptions>(getSTI().getFeatureBits()));
525 std::make_unique<MipsAssemblerOptions>(getSTI().getFeatureBits()));
853 auto Op = std::make_unique<MipsOperand>(k_RegisterIndex, Parser);
1455 auto Op = std::make_unique<MipsOperand>(k_Token, Parser);
1530 auto Op = std::make_unique<MipsOperand>(k_Immediate, Parser);
1540 auto Op = std::make_unique<MipsOperand>(k_Memory, Parser);
1553 auto Op = std::make_unique<MipsOperand>(k_RegList, Parser);
7049 std::make_unique<MipsAssemblerOptions>(AssemblerOptions.back().get()));
lib/Target/Mips/MCTargetDesc/MipsELFObjectWriter.cpp 693 return std::make_unique<MipsELFObjectWriter>(OSABI, HasRelocationAddend,
lib/Target/Mips/MipsTargetMachine.cpp 120 isLittle(isLittle), TLOF(std::make_unique<MipsTargetObjectFile>()),
202 I = std::make_unique<MipsSubtarget>(
lib/Target/NVPTX/NVPTXTargetMachine.cpp 119 TLOF(std::make_unique<NVPTXTargetObjectFile>()),
lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp 582 auto Op = std::make_unique<PPCOperand>(Token);
611 auto Op = std::make_unique<PPCOperand>(Immediate);
621 auto Op = std::make_unique<PPCOperand>(Expression);
632 auto Op = std::make_unique<PPCOperand>(TLSRegister);
642 auto Op = std::make_unique<PPCOperand>(ContextImmediate);
lib/Target/PowerPC/MCTargetDesc/PPCELFObjectWriter.cpp 446 return std::make_unique<PPCELFObjectWriter>(Is64Bit, OSABI);
lib/Target/PowerPC/MCTargetDesc/PPCMachObjectWriter.cpp 379 return std::make_unique<PPCMachObjectWriter>(Is64Bit, CPUType, CPUSubtype);
lib/Target/PowerPC/MCTargetDesc/PPCXCOFFObjectWriter.cpp 28 return std::make_unique<PPCXCOFFObjectWriter>(Is64Bit);
lib/Target/PowerPC/PPCInstrInfo.cpp 4242 return std::make_unique<PPCPipelinerLoopInfo>(LoopInst, &*I, LoopCount);
lib/Target/PowerPC/PPCTargetMachine.cpp 189 return std::make_unique<TargetLoweringObjectFileMachO>();
192 return std::make_unique<TargetLoweringObjectFileXCOFF>();
194 return std::make_unique<PPC64LinuxTargetObjectFile>();
272 std::make_unique<PPCPreRASchedStrategy>(C) :
273 std::make_unique<GenericScheduler>(C));
284 std::make_unique<PPCPostRASchedStrategy>(C) :
285 std::make_unique<PostGenericScheduler>(C), true);
341 I = std::make_unique<PPCSubtarget>(
lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp 636 auto Op = std::make_unique<RISCVOperand>(KindTy::Token);
646 auto Op = std::make_unique<RISCVOperand>(KindTy::Register);
656 auto Op = std::make_unique<RISCVOperand>(KindTy::Immediate);
666 auto Op = std::make_unique<RISCVOperand>(KindTy::SystemRegister);
lib/Target/RISCV/MCTargetDesc/RISCVELFObjectWriter.cpp 141 return std::make_unique<RISCVELFObjectWriter>(OSABI, Is64Bit);
lib/Target/RISCV/RISCVTargetMachine.cpp 66 TLOF(std::make_unique<RISCVELFTargetObjectFile>()),
lib/Target/Sparc/AsmParser/SparcAsmParser.cpp 379 auto Op = std::make_unique<SparcOperand>(k_Token);
389 auto Op = std::make_unique<SparcOperand>(k_Register);
399 auto Op = std::make_unique<SparcOperand>(k_Immediate);
484 auto Op = std::make_unique<SparcOperand>(k_MemoryReg);
lib/Target/Sparc/MCTargetDesc/SparcELFObjectWriter.cpp 138 return std::make_unique<SparcELFObjectWriter>(Is64Bit, OSABI);
lib/Target/Sparc/SparcTargetMachine.cpp 101 TLOF(std::make_unique<SparcELFTargetObjectFile>()),
136 I = std::make_unique<SparcSubtarget>(TargetTriple, CPU, FS, *this,
lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp 158 return std::make_unique<SystemZOperand>(KindInvalid, StartLoc, EndLoc);
162 auto Op = std::make_unique<SystemZOperand>(KindToken, Loc, Loc);
170 auto Op = std::make_unique<SystemZOperand>(KindReg, StartLoc, EndLoc);
178 auto Op = std::make_unique<SystemZOperand>(KindImm, StartLoc, EndLoc);
187 auto Op = std::make_unique<SystemZOperand>(KindMem, StartLoc, EndLoc);
203 auto Op = std::make_unique<SystemZOperand>(KindImmTLS, StartLoc, EndLoc);
lib/Target/SystemZ/MCTargetDesc/SystemZMCObjectWriter.cpp 165 return std::make_unique<SystemZObjectWriter>(OSABI);
lib/Target/SystemZ/SystemZTargetMachine.cpp 157 TLOF(std::make_unique<TargetLoweringObjectFileELF>()),
179 std::make_unique<SystemZPostRASchedStrategy>(C),
lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp 347 Operands.push_back(std::make_unique<WebAssemblyOperand>(
360 Operands.push_back(std::make_unique<WebAssemblyOperand>(
382 Operands.push_back(std::make_unique<WebAssemblyOperand>(
411 Operands.push_back(std::make_unique<WebAssemblyOperand>(
421 Operands.push_back(std::make_unique<WebAssemblyOperand>(
453 Operands.push_back(std::make_unique<WebAssemblyOperand>(
508 auto Signature = std::make_unique<wasm::WasmSignature>();
522 Operands.push_back(std::make_unique<WebAssemblyOperand>(
547 Operands.push_back(std::make_unique<WebAssemblyOperand>(
582 auto Op = std::make_unique<WebAssemblyOperand>(
704 auto Signature = std::make_unique<wasm::WasmSignature>();
720 auto Signature = std::make_unique<wasm::WasmSignature>();
lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp 121 return std::make_unique<WebAssemblyWasmObjectWriter>(Is64Bit, IsEmscripten);
lib/Target/WebAssembly/WebAssemblyCFGSort.cpp 100 LoopMap[ML] = std::make_unique<ConcreteRegion<MachineLoop>>(ML);
107 std::make_unique<ConcreteRegion<WebAssemblyException>>(WE);
lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp 118 std::make_unique<wasm::WasmSignature>(std::move(Returns), std::move(Params));
169 auto Signature = std::make_unique<wasm::WasmSignature>(std::move(Returns),
lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.cpp 77 auto Sig = std::make_unique<wasm::WasmSignature>();
lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp 143 I = std::make_unique<WebAssemblySubtarget>(TargetTriple, CPU, FS, *this);
lib/Target/X86/AsmParser/X86Operand.h 584 auto Res = std::make_unique<X86Operand>(Token, Loc, EndLoc);
594 auto Res = std::make_unique<X86Operand>(Register, StartLoc, EndLoc);
605 return std::make_unique<X86Operand>(DXRegister, StartLoc, EndLoc);
610 auto Res = std::make_unique<X86Operand>(Prefix, StartLoc, EndLoc);
617 auto Res = std::make_unique<X86Operand>(Immediate, StartLoc, EndLoc);
627 auto Res = std::make_unique<X86Operand>(Memory, StartLoc, EndLoc);
655 auto Res = std::make_unique<X86Operand>(Memory, StartLoc, EndLoc);
lib/Target/X86/MCTargetDesc/X86ELFObjectWriter.cpp 333 return std::make_unique<X86ELFObjectWriter>(IsELF64, OSABI, EMachine);
lib/Target/X86/MCTargetDesc/X86MachObjectWriter.cpp 602 return std::make_unique<X86MachObjectWriter>(Is64Bit, CPUType, CPUSubtype);
lib/Target/X86/MCTargetDesc/X86WinCOFFObjectWriter.cpp 112 return std::make_unique<X86WinCOFFObjectWriter>(Is64Bit);
lib/Target/X86/MCTargetDesc/X86WinCOFFTargetStreamer.cpp 173 CurFPOData = std::make_unique<FPOData>();
lib/Target/X86/X86CondBrFolding.cpp 567 return std::make_unique<TargetMBBInfo>(TargetMBBInfo{
lib/Target/X86/X86TargetMachine.cpp 91 return std::make_unique<X86_64MachoTargetObjectFile>();
92 return std::make_unique<TargetLoweringObjectFileMachO>();
96 return std::make_unique<X86FreeBSDTargetObjectFile>();
98 return std::make_unique<X86LinuxNaClTargetObjectFile>();
100 return std::make_unique<X86SolarisTargetObjectFile>();
102 return std::make_unique<X86FuchsiaTargetObjectFile>();
104 return std::make_unique<X86ELFTargetObjectFile>();
106 return std::make_unique<TargetLoweringObjectFileCOFF>();
311 I = std::make_unique<X86Subtarget>(
lib/Target/XCore/XCoreTargetMachine.cpp 56 TLOF(std::make_unique<XCoreTargetObjectFile>()),
lib/Transforms/Coroutines/CoroCleanup.cpp 118 L = std::make_unique<Lowerer>(M);
lib/Transforms/Coroutines/CoroEarly.cpp 250 L = std::make_unique<Lowerer>(M);
lib/Transforms/Coroutines/CoroElide.cpp 289 L = std::make_unique<Lowerer>(M);
lib/Transforms/IPO/FunctionImport.cpp 453 FailureInfo = std::make_unique<FunctionImporter::ImportFailureInfo>(
lib/Transforms/IPO/HotColdSplitting.cpp 576 DT = std::make_unique<DominatorTree>(F);
578 PDT = std::make_unique<PostDominatorTree>(F);
lib/Transforms/IPO/Inliner.cpp 887 std::make_unique<ImportedFunctionsInliningStatistics>();
lib/Transforms/IPO/PartialInlining.cpp 412 std::make_unique<FunctionOutliningMultiRegionInfo>();
592 std::make_unique<FunctionOutliningInfo>();
969 ClonedOI = std::make_unique<FunctionOutliningInfo>();
994 ClonedOMRI = std::make_unique<FunctionOutliningMultiRegionInfo>();
lib/Transforms/IPO/SCCP.cpp 19 std::make_unique<PredicateInfo>(F, DT, FAM.getResult<AssumptionAnalysis>(F)),
59 std::make_unique<PredicateInfo>(
lib/Transforms/IPO/SampleProfile.cpp 1821 OwnedORE = std::make_unique<OptimizationRemarkEmitter>(&F);
lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp 469 NewIndex = std::make_unique<ModuleSummaryIndex>(
lib/Transforms/IPO/WholeProgramDevirt.cpp 643 ORE = std::make_unique<OptimizationRemarkEmitter>(F);
lib/Transforms/Instrumentation/CFGMST.h 260 Iter->second = std::move(std::make_unique<BBInfo>(Index));
266 Iter->second = std::move(std::make_unique<BBInfo>(Index));
lib/Transforms/Instrumentation/ControlHeightReduction.cpp 2082 std::make_unique<OptimizationRemarkEmitter>(&F);
lib/Transforms/Instrumentation/GCOVProfiling.cpp 707 Funcs.push_back(std::make_unique<GCOVFunction>(SP, &F, &out, FunctionIdent++,
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp 308 HWASan = std::make_unique<HWAddressSanitizer>(M, CompileKernel, Recover);
lib/Transforms/Instrumentation/IndirectCallPromotion.cpp 406 OwnedORE = std::make_unique<OptimizationRemarkEmitter>(&F);
lib/Transforms/Instrumentation/PGOInstrumentation.cpp 1596 std::make_unique<BranchProbabilityInfo>(F, LI);
1598 std::make_unique<BlockFrequencyInfo>(F, *NewBPI, LI);
lib/Transforms/Scalar/EarlyCSE.cpp 530 MSSAUpdater(std::make_unique<MemorySSAUpdater>(MSSA)) {}
lib/Transforms/Scalar/GVNHoist.cpp 260 MSSAUpdater(std::make_unique<MemorySSAUpdater>(MSSA)) {}
lib/Transforms/Scalar/LICM.cpp 350 MSSAU = std::make_unique<MemorySSAUpdater>(MSSA);
2183 CurAST = std::make_unique<AliasSetTracker>(*AA);
2202 auto CurAST = std::make_unique<AliasSetTracker>(*AA, MSSA, L);
lib/Transforms/Scalar/LoopUnswitch.cpp 529 MSSAU = std::make_unique<MemorySSAUpdater>(MSSA);
lib/Transforms/Scalar/NewGVN.cpp 661 PredInfo(std::make_unique<PredicateInfo>(F, *DT, *AC)),
lib/Transforms/Utils/CloneModule.cpp 51 std::make_unique<Module>(M.getModuleIdentifier(), M.getContext());
lib/Transforms/Utils/Evaluator.cpp 472 AllocaTmps.push_back(std::make_unique<GlobalVariable>(
lib/Transforms/Utils/ImportedFunctionsInliningStatistics.cpp 28 ValueLookup = std::make_unique<InlineGraphNode>();
lib/Transforms/Utils/LoopSimplify.cpp 811 MSSAU = std::make_unique<MemorySSAUpdater>(MSSA);
842 MSSAU = std::make_unique<MemorySSAUpdater>(MSSA);
lib/Transforms/Utils/PredicateInfo.cpp 801 auto PredInfo = std::make_unique<PredicateInfo>(F, DT, AC);
815 auto PredInfo = std::make_unique<PredicateInfo>(F, DT, AC);
874 std::make_unique<PredicateInfo>(F, DT, AC)->verifyPredicateInfo();
lib/Transforms/Utils/SymbolRewriter.cpp 383 DL->push_back(std::make_unique<ExplicitRewriteFunctionDescriptor>(
387 std::make_unique<PatternRewriteFunctionDescriptor>(Source, Transform));
445 DL->push_back(std::make_unique<ExplicitRewriteGlobalVariableDescriptor>(
449 DL->push_back(std::make_unique<PatternRewriteGlobalVariableDescriptor>(
508 DL->push_back(std::make_unique<ExplicitRewriteNamedAliasDescriptor>(
512 DL->push_back(std::make_unique<PatternRewriteNamedAliasDescriptor>(
lib/Transforms/Vectorize/LoopVectorize.cpp 2790 LVer = std::make_unique<LoopVersioning>(*Legal->getLAI(), OrigLoop, LI, DT,
7103 auto Plan = std::make_unique<VPlan>(VPBB);
7235 auto Plan = std::make_unique<VPlan>();
lib/Transforms/Vectorize/SLPVectorizer.cpp 1391 VectorizableTree.push_back(std::make_unique<TreeEntry>(VectorizableTree));
2296 BSRef = std::make_unique<BlockScheduling>(BB);
lib/WindowsManifest/WindowsManifestMerger.cpp 707 : Impl(std::make_unique<WindowsManifestMergerImpl>()) {}
lib/XRay/FDRRecordProducer.cpp 43 return std::make_unique<NewBufferRecord>();
50 return std::make_unique<EndBufferRecord>();
52 return std::make_unique<NewCPUIDRecord>();
54 return std::make_unique<TSCWrapRecord>();
56 return std::make_unique<WallclockRecord>();
59 return std::make_unique<CustomEventRecordV5>();
60 return std::make_unique<CustomEventRecord>();
62 return std::make_unique<CallArgRecord>();
64 return std::make_unique<BufferExtents>();
66 return std::make_unique<TypedEventRecord>();
68 return std::make_unique<PIDRecord>();
170 R = std::make_unique<FunctionRecord>();
tools/clang/examples/AnnotateFunctions/AnnotateFunctions.cpp 44 return std::make_unique<AnnotateFunctionsConsumer>();
tools/clang/examples/PrintFunctionNames/PrintFunctionNames.cpp 84 return std::make_unique<PrintFunctionsConsumer>(CI, ParsedTemplates);
tools/clang/examples/clang-interpreter/main.cpp 61 return std::make_unique<SectionMemoryManager>();
tools/clang/include/clang/AST/ASTImporterSharedState.h 50 LookupTable = std::make_unique<ASTImporterLookupTable>(ToTU);
tools/clang/include/clang/Basic/SyncScope.h 147 return std::make_unique<AtomicScopeOpenCLModel>();
tools/clang/include/clang/Frontend/ASTUnit.h 318 CCTUInfo = std::make_unique<CodeCompletionTUInfo>(
tools/clang/include/clang/Lex/Preprocessor.h 998 C = std::make_unique<PPChainedCallbacks>(std::move(C),
tools/clang/include/clang/Sema/SemaInternal.h 100 SS(SS ? std::make_unique<CXXScopeSpec>(*SS) : nullptr),
tools/clang/include/clang/Sema/TypoCorrection.h 359 return std::make_unique<DefaultFilterCCC>(*this);
372 return std::make_unique<DeclFilterCCC>(*this);
387 return std::make_unique<FunctionCallFilterCCC>(*this);
412 return std::make_unique<NoTypoCorrectionCCC>(*this);
tools/clang/include/clang/Serialization/ASTReader.h 1589 L = std::make_unique<ChainedASTReaderListener>(std::move(L),
1605 L = std::make_unique<ChainedASTReaderListener>(std::move(L),
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h 367 return std::make_unique<ExplodedGraph>();
tools/clang/include/clang/Tooling/Refactoring/RefactoringActionRulesInternal.h 151 return std::make_unique<Rule>(std::make_tuple(Requirements...));
tools/clang/include/clang/Tooling/Tooling.h 402 return std::make_unique<T>();
420 return std::make_unique<ConsumerFactoryAdaptor>(ConsumerFactory,
tools/clang/lib/ARCMigrate/ARCMT.cpp 456 std::make_unique<ARCMTMacroTrackerPPCallbacks>(ARCMTMacroLocs));
457 return std::make_unique<ASTConsumer>();
tools/clang/lib/ARCMigrate/ObjCMT.cpp 211 Consumers.push_back(std::make_unique<ObjCMigrateASTConsumer>(
214 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
2037 return std::make_unique<ObjCMigrateASTConsumer>(
tools/clang/lib/AST/ASTContext.cpp10515 Parents = std::make_unique<ParentMap>(*this);
tools/clang/lib/AST/ExternalASTMerger.cpp 417 Importers.push_back(std::make_unique<LazyASTImporter>(
tools/clang/lib/AST/ItaniumCXXABI.cpp 252 return std::make_unique<ItaniumNumberingContext>(
tools/clang/lib/AST/Mangle.cpp 479 : Impl(std::make_unique<Implementation>(Ctx)) {}
tools/clang/lib/AST/MicrosoftCXXABI.cpp 135 return std::make_unique<MicrosoftNumberingContext>();
tools/clang/lib/AST/VTableBuilder.cpp 2271 return std::make_unique<VTableLayout>(
3256 Paths.push_back(std::make_unique<VPtrInfo>(RD));
3279 auto P = std::make_unique<VPtrInfo>(*BaseInfo);
3565 auto VFPtrs = std::make_unique<VPtrInfoVector>();
3579 VFTableLayouts[id] = std::make_unique<VTableLayout>(
3671 Entry = std::make_unique<VirtualBaseInfo>();
tools/clang/lib/ASTMatchers/ASTMatchFinder.cpp 1081 return std::make_unique<internal::MatchASTConsumer>(this, ParsingDone);
tools/clang/lib/ASTMatchers/Dynamic/Marshallers.h 732 return std::make_unique<FixedArgCountMatcherDescriptor>(
744 return std::make_unique<FixedArgCountMatcherDescriptor>(
758 return std::make_unique<FixedArgCountMatcherDescriptor>(
769 return std::make_unique<VariadicFuncMatcherDescriptor>(VarFunc, MatcherName);
781 return std::make_unique<DynCastAllOfMatcherDescriptor>(VarFunc, MatcherName);
794 return std::make_unique<OverloadedMatcherDescriptor>(Overloads);
813 return std::make_unique<VariadicOperatorMatcherDescriptor>(
tools/clang/lib/ASTMatchers/Dynamic/Registry.cpp 123 REGISTER_MATCHER_OVERLOAD(equals);
tools/clang/lib/Analysis/AnalysisDeclContext.cpp 305 AC = std::make_unique<AnalysisDeclContext>(this, D, cfgBuildOptions);
tools/clang/lib/Analysis/CallGraph.cpp 207 Node = std::make_unique<CallGraphNode>(F);
tools/clang/lib/Analysis/Consumed.cpp 1029 Entry = std::make_unique<ConsumedStateMap>(*StateMap);
1061 return isBackEdgeTarget(Block) ? std::make_unique<ConsumedStateMap>(*Entry)
1320 CurrStates = std::make_unique<ConsumedStateMap>();
tools/clang/lib/Analysis/ThreadSafety.cpp 885 FSet.addLock(FactMan, std::make_unique<LockableFactEntry>(
990 std::make_unique<LockableFactEntry>(Cp, kind, loc));
999 FSet.addLock(FactMan, std::make_unique<LockableFactEntry>(
1554 addLock(Result, std::make_unique<LockableFactEntry>(ExclusiveLockToAdd,
1558 addLock(Result, std::make_unique<LockableFactEntry>(SharedLockToAdd,
1843 std::make_unique<LockableFactEntry>(
1855 std::make_unique<LockableFactEntry>(
1867 std::make_unique<LockableFactEntry>(
1931 Analyzer->addLock(FSet, std::make_unique<LockableFactEntry>(
1935 Analyzer->addLock(FSet, std::make_unique<LockableFactEntry>(
1947 auto ScopedEntry = std::make_unique<ScopedLockableFactEntry>(Scp, MLoc);
2352 auto Entry = std::make_unique<LockableFactEntry>(Mu, LK_Exclusive, Loc);
2357 auto Entry = std::make_unique<LockableFactEntry>(Mu, LK_Shared, Loc);
2526 ExpectedExitSet.addLock(FactMan, std::make_unique<LockableFactEntry>(
2529 ExpectedExitSet.addLock(FactMan, std::make_unique<LockableFactEntry>(
tools/clang/lib/Analysis/plugins/SampleAnalyzer/MainCallChecker.cpp 40 std::make_unique<PathSensitiveBugReport>(*BT, BT->getDescription(), N);
tools/clang/lib/Basic/FileManager.cpp 107 auto UDE = std::make_unique<DirectoryEntry>();
387 VirtualFileEntries.push_back(std::make_unique<FileEntry>());
409 BypassFileEntries.push_back(std::make_unique<FileEntry>());
tools/clang/lib/Basic/SourceManager.cpp 515 FakeContentCacheForRecovery = std::make_unique<SrcMgr::ContentCache>();
1853 MacroArgsCache = std::make_unique<MacroArgsMap>();
2182 std::make_unique<FileManager>(FileSystemOptions(), InMemoryFileSystem);
2185 Diagnostics = std::make_unique<DiagnosticsEngine>(
2188 SourceMgr = std::make_unique<SourceManager>(*Diagnostics, *FileMgr);
tools/clang/lib/CodeGen/BackendUtil.cpp 122 auto F = std::make_unique<llvm::ToolOutputFile>(Path, EC,
1422 return std::make_unique<lto::NativeObjectStream>(std::move(OS));
1534 EmptyModule = std::make_unique<llvm::Module>("empty", M->getContext());
tools/clang/lib/CodeGen/CGCall.cpp 906 return std::make_unique<ConstantArrayExpansion>(
950 return std::make_unique<RecordExpansion>(std::move(Bases),
954 return std::make_unique<ComplexExpansion>(CT->getElementType());
956 return std::make_unique<NoExpansion>();
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 2079 std::make_unique<CodeGenFunction::OMPMapVars>();
4693 std::make_unique<CodeGenFunction::OMPMapVars>();
tools/clang/lib/CodeGen/CodeGenAction.cpp 267 Ctx.setDiagnosticHandler(std::make_unique<ClangDiagnosticHandler>(
946 std::make_unique<MacroPPCallbacks>(BEConsumer->getCodeGenerator(),
1007 auto M = std::make_unique<llvm::Module>("empty", *VMContext);
tools/clang/lib/CodeGen/CodeGenModule.cpp 5917 SanStats = std::make_unique<llvm::SanitizerStatReport>(&getModule());
tools/clang/lib/CodeGen/CodeGenPGO.cpp 983 std::make_unique<llvm::InstrProfRecord>(std::move(RecordExpected.get()));
tools/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp 300 std::make_unique<llvm::raw_svector_ostream>(Buffer));
324 return std::make_unique<PCHContainerGenerator>(
tools/clang/lib/DirectoryWatcher/linux/DirectoryWatcher-linux.cpp 189 auto ManagedBuffer = std::make_unique<Buffer>();
357 return std::make_unique<DirectoryWatcherLinux>(
tools/clang/lib/Driver/Driver.cpp 632 CudaTC = std::make_unique<toolchains::CudaToolChain>(
647 HIPTC = std::make_unique<toolchains::HIPToolChain>(
705 CudaTC = std::make_unique<toolchains::CudaToolChain>(
766 CfgOptions = std::make_unique<InputArgList>(
960 CLOptions = std::make_unique<InputArgList>(
1006 auto CLModePassThroughOptions = std::make_unique<InputArgList>(
1099 std::make_unique<InputArgList>(std::move(Args));
4704 TC = std::make_unique<toolchains::AIX>(*this, Target, Args);
4707 TC = std::make_unique<toolchains::Haiku>(*this, Target, Args);
4710 TC = std::make_unique<toolchains::Ananas>(*this, Target, Args);
4713 TC = std::make_unique<toolchains::CloudABI>(*this, Target, Args);
4720 TC = std::make_unique<toolchains::DarwinClang>(*this, Target, Args);
4723 TC = std::make_unique<toolchains::DragonFly>(*this, Target, Args);
4726 TC = std::make_unique<toolchains::OpenBSD>(*this, Target, Args);
4729 TC = std::make_unique<toolchains::NetBSD>(*this, Target, Args);
4732 TC = std::make_unique<toolchains::FreeBSD>(*this, Target, Args);
4735 TC = std::make_unique<toolchains::Minix>(*this, Target, Args);
4740 TC = std::make_unique<toolchains::HexagonToolChain>(*this, Target,
4744 TC = std::make_unique<toolchains::MipsLLVMToolChain>(*this, Target,
4749 TC = std::make_unique<toolchains::PPCLinuxToolChain>(*this, Target,
4752 TC = std::make_unique<toolchains::Linux>(*this, Target, Args);
4755 TC = std::make_unique<toolchains::NaClToolChain>(*this, Target, Args);
4758 TC = std::make_unique<toolchains::Fuchsia>(*this, Target, Args);
4761 TC = std::make_unique<toolchains::Solaris>(*this, Target, Args);
4766 TC = std::make_unique<toolchains::AMDGPUToolChain>(*this, Target, Args);
4772 TC = std::make_unique<toolchains::Generic_ELF>(*this, Target, Args);
4774 TC = std::make_unique<toolchains::MachO>(*this, Target, Args);
4776 TC = std::make_unique<toolchains::Generic_GCC>(*this, Target, Args);
4779 TC = std::make_unique<toolchains::MinGW>(*this, Target, Args);
4782 TC = std::make_unique<toolchains::CrossWindowsToolChain>(*this, Target,
4789 TC = std::make_unique<toolchains::CrossWindowsToolChain>(
4793 std::make_unique<toolchains::MSVCToolChain>(*this, Target, Args);
4798 TC = std::make_unique<toolchains::PS4CPU>(*this, Target, Args);
4801 TC = std::make_unique<toolchains::Contiki>(*this, Target, Args);
4804 TC = std::make_unique<toolchains::Hurd>(*this, Target, Args);
4811 TC = std::make_unique<toolchains::TCEToolChain>(*this, Target, Args);
4814 TC = std::make_unique<toolchains::TCELEToolChain>(*this, Target, Args);
4817 TC = std::make_unique<toolchains::HexagonToolChain>(*this, Target,
4821 TC = std::make_unique<toolchains::LanaiToolChain>(*this, Target, Args);
4824 TC = std::make_unique<toolchains::XCoreToolChain>(*this, Target, Args);
4828 TC = std::make_unique<toolchains::WebAssembly>(*this, Target, Args);
4831 TC = std::make_unique<toolchains::AVRToolChain>(*this, Target, Args);
4835 std::make_unique<toolchains::MSP430ToolChain>(*this, Target, Args);
4839 TC = std::make_unique<toolchains::RISCVToolChain>(*this, Target, Args);
4843 TC = std::make_unique<toolchains::MyriadToolChain>(*this, Target,
4846 TC = std::make_unique<toolchains::BareMetal>(*this, Target, Args);
4848 TC = std::make_unique<toolchains::Generic_ELF>(*this, Target, Args);
4850 TC = std::make_unique<toolchains::MachO>(*this, Target, Args);
4852 TC = std::make_unique<toolchains::Generic_GCC>(*this, Target, Args);
tools/clang/lib/Driver/DriverOptions.cpp 44 auto Result = std::make_unique<DriverOptTable>();
tools/clang/lib/Driver/ToolChains/AIX.cpp 92 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/AMDGPU.cpp 34 C.addCommand(std::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
tools/clang/lib/Driver/ToolChains/AVR.cpp 147 C.addCommand(std::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
tools/clang/lib/Driver/ToolChains/Ananas.cpp 42 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
126 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/BareMetal.cpp 194 C.addCommand(std::make_unique<Command>(JA, *this,
tools/clang/lib/Driver/ToolChains/Clang.cpp 1924 auto File = std::make_unique<llvm::raw_fd_ostream>(Filename, EC,
2005 std::make_unique<llvm::raw_fd_ostream>(FD, /*shouldClose=*/true);
3757 C.addCommand(std::make_unique<Command>(JA, *this, D.getClangProgramPath(),
5541 C.addCommand(std::make_unique<FallbackCommand>(
5547 C.addCommand(std::make_unique<ForceSuccessCommand>(JA, *this, Exec,
5550 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
6269 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
6352 C.addCommand(std::make_unique<Command>(
6418 C.addCommand(std::make_unique<Command>(
6448 C.addCommand(std::make_unique<Command>(
tools/clang/lib/Driver/ToolChains/CloudABI.cpp 95 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/CommonArgs.cpp 848 C.addCommand(std::make_unique<Command>(JA, T, Exec, ExtractArgs, II));
851 C.addCommand(std::make_unique<Command>(JA, T, Exec, StripArgs, II));
tools/clang/lib/Driver/ToolChains/CrossWindows.cpp 60 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
205 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/Cuda.cpp 425 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
491 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
568 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/Darwin.cpp 149 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
454 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, None));
656 std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs);
680 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
700 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
723 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/DragonFly.cpp 48 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
172 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/FreeBSD.cpp 115 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
346 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/Fuchsia.cpp 159 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/Gnu.cpp 192 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
631 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
883 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/HIP.cpp 83 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
129 C.addCommand(std::make_unique<Command>(JA, *this, OptExec, OptArgs, Inputs));
171 C.addCommand(std::make_unique<Command>(JA, *this, Llc, LlcArgs, Inputs));
187 C.addCommand(std::make_unique<Command>(JA, *this, Lld, LldArgs, Inputs));
221 C.addCommand(std::make_unique<Command>(JA, T, Bundler, BundlerArgs, Inputs));
tools/clang/lib/Driver/ToolChains/Hexagon.cpp 186 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
373 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/InterfaceStubs.cpp 31 C.addCommand(std::make_unique<Command>(JA, *this, Args.MakeArgString(Merger),
tools/clang/lib/Driver/ToolChains/MSP430.cpp 230 C.addCommand(std::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
tools/clang/lib/Driver/ToolChains/MSVC.cpp 584 auto LinkCmd = std::make_unique<Command>(
725 return std::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
tools/clang/lib/Driver/ToolChains/MinGW.cpp 52 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
297 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/Minix.cpp 39 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
91 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/Myriad.cpp 80 C.addCommand(std::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
115 C.addCommand(std::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
201 C.addCommand(std::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
tools/clang/lib/Driver/ToolChains/NaCl.cpp 196 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/NetBSD.cpp 106 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
340 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/OpenBSD.cpp 92 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
230 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/PS4CPU.cpp 65 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
144 C.addCommand(std::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
322 C.addCommand(std::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/RISCVToolchain.cpp 144 C.addCommand(std::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
tools/clang/lib/Driver/ToolChains/Solaris.cpp 44 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
153 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/WebAssembly.cpp 92 C.addCommand(std::make_unique<Command>(JA, *this, Linker, CmdArgs, Inputs));
tools/clang/lib/Driver/ToolChains/XCore.cpp 55 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
83 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
tools/clang/lib/Format/ContinuationIndenter.cpp 1808 return std::make_unique<BreakableStringLiteral>(
1820 return std::make_unique<BreakableBlockComment>(
1830 return std::make_unique<BreakableLineCommentSection>(
tools/clang/lib/Format/Format.cpp 2417 std::make_unique<Environment>(Code, FileName, Ranges, FirstStartColumn,
2431 Env = std::make_unique<Environment>(
tools/clang/lib/Format/UnwrappedLineParser.cpp 148 Parser.Line = std::make_unique<UnwrappedLine>();
tools/clang/lib/Frontend/ASTConsumers.cpp 142 return std::make_unique<ASTPrinter>(std::move(Out), ASTPrinter::Print,
151 return std::make_unique<ASTPrinter>(std::move(Out),
159 return std::make_unique<ASTDeclNodeLister>(nullptr);
196 return std::make_unique<ASTViewer>();
tools/clang/lib/Frontend/ASTUnit.cpp 823 AST->Reader->setListener(std::make_unique<ASTInfoCollector>(
1003 std::make_unique<MacroDefinitionTrackerPPCallbacks>(
1005 return std::make_unique<TopLevelDeclTrackerConsumer>(
1053 return std::make_unique<MacroDefinitionTrackerPPCallbacks>(Hash);
1628 std::make_unique<MacroDefinitionTrackerPPCallbacks>(
1633 Consumers.push_back(std::make_unique<TopLevelDeclTrackerConsumer>(
1636 std::make_unique<MultiplexConsumer>(std::move(Consumers)));
tools/clang/lib/Frontend/ChainedIncludesSource.cpp 161 auto consumer = std::make_unique<PCHGenerator>(
tools/clang/lib/Frontend/CompilerInstance.cpp 226 auto FileOS = std::make_unique<llvm::raw_fd_ostream>(
240 auto Logger = std::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
679 return std::make_unique<llvm::raw_null_ostream>();
805 auto B = std::make_unique<llvm::buffer_ostream>(*OS);
1009 auto StatS = std::make_unique<llvm::raw_fd_ostream>(
1493 ReadTimer = std::make_unique<llvm::Timer>("reading_modules",
1589 auto Listener = std::make_unique<ReadModuleNames>(*this);
tools/clang/lib/Frontend/CreateInvocationFromCommandLine.cpp 92 auto CI = std::make_unique<CompilerInvocation>();
tools/clang/lib/Frontend/DependencyFile.cpp 171 PP.addPPCallbacks(std::make_unique<DepCollectorPPCallbacks>(
174 std::make_unique<DepCollectorMMCallbacks>(*this));
177 R.addListener(std::make_unique<DepCollectorASTListener>(*this));
tools/clang/lib/Frontend/DependencyGraph.cpp 64 PP.addPPCallbacks(std::make_unique<DependencyGraphCallback>(&PP, OutputFile,
tools/clang/lib/Frontend/FrontendAction.cpp 219 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
tools/clang/lib/Frontend/FrontendActions.cpp 58 return std::make_unique<ASTConsumer>();
112 Consumers.push_back(std::make_unique<PCHGenerator>(
120 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
175 Consumers.push_back(std::make_unique<PCHGenerator>(
185 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
316 return std::make_unique<ASTConsumer>();
322 return std::make_unique<ASTConsumer>();
327 return std::make_unique<ASTConsumer>();
475 return std::make_unique<ASTConsumer>();
488 std::make_unique<DefaultTemplateInstCallback>());
tools/clang/lib/Frontend/HeaderIncludeGen.cpp 123 PP.addPPCallbacks(std::make_unique<HeaderIncludesCallback>(
tools/clang/lib/Frontend/InterfaceStubFunctionsConsumer.cpp 306 return std::make_unique<InterfaceStubFunctionsConsumer>(
tools/clang/lib/Frontend/ModuleDependencyCollector.cpp 102 R.addListener(std::make_unique<ModuleDependencyListener>(*this));
106 PP.addPPCallbacks(std::make_unique<ModuleDependencyPPCallbacks>(
109 std::make_unique<ModuleDependencyMMCallbacks>(*this));
tools/clang/lib/Frontend/MultiplexConsumer.cpp 252 std::make_unique<MultiplexASTMutationListener>(mutationListeners);
256 std::make_unique<MultiplexASTDeserializationListener>(
tools/clang/lib/Frontend/PrecompiledPreamble.cpp 205 OS = std::make_unique<llvm::raw_string_ostream>(*InMemStorage);
216 return std::make_unique<PrecompilePreambleConsumer>(
tools/clang/lib/Frontend/Rewrite/FrontendActions.cpp 53 return std::make_unique<ASTConsumer>();
298 std::make_unique<RewriteImportsListener>(CI, OutputStream));
tools/clang/lib/Frontend/Rewrite/HTMLPrint.cpp 51 return std::make_unique<HTMLPrinter>(std::move(OS), PP, SyntaxHighlight,
tools/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp 666 return std::make_unique<RewriteModernObjC>(InFile, std::move(OS), Diags,
tools/clang/lib/Frontend/Rewrite/RewriteObjC.cpp 596 return std::make_unique<RewriteObjCFragileABI>(
tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp 299 return std::make_unique<SDiagsWriter>(OutputFile, Diags, MergeChildRecords);
746 State->MetaDiagnostics = std::make_unique<DiagnosticsEngine>(
783 auto OS = std::make_unique<llvm::raw_fd_ostream>(State->OutputFile.c_str(),
tools/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp 675 std::make_unique<VerifyFileTracker>(*this, *SrcManager));
1120 return std::make_unique<StandardDirective>(DirectiveLoc, DiagnosticLoc,
1146 return std::make_unique<RegexDirective>(
tools/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp 44 case ASTDeclList: return std::make_unique<ASTDeclListAction>();
45 case ASTDump: return std::make_unique<ASTDumpAction>();
46 case ASTPrint: return std::make_unique<ASTPrintAction>();
47 case ASTView: return std::make_unique<ASTViewAction>();
49 return std::make_unique<DumpCompilerOptionsAction>();
50 case DumpRawTokens: return std::make_unique<DumpRawTokensAction>();
51 case DumpTokens: return std::make_unique<DumpTokensAction>();
52 case EmitAssembly: return std::make_unique<EmitAssemblyAction>();
53 case EmitBC: return std::make_unique<EmitBCAction>();
54 case EmitHTML: return std::make_unique<HTMLPrintAction>();
55 case EmitLLVM: return std::make_unique<EmitLLVMAction>();
56 case EmitLLVMOnly: return std::make_unique<EmitLLVMOnlyAction>();
57 case EmitCodeGenOnly: return std::make_unique<EmitCodeGenOnlyAction>();
58 case EmitObj: return std::make_unique<EmitObjAction>();
59 case FixIt: return std::make_unique<FixItAction>();
61 return std::make_unique<GenerateModuleFromModuleMapAction>();
63 return std::make_unique<GenerateModuleInterfaceAction>();
65 return std::make_unique<GenerateHeaderModuleAction>();
66 case GeneratePCH: return std::make_unique<GeneratePCHAction>();
68 return std::make_unique<GenerateInterfaceIfsExpV1Action>();
69 case InitOnly: return std::make_unique<InitOnlyAction>();
70 case ParseSyntaxOnly: return std::make_unique<SyntaxOnlyAction>();
71 case ModuleFileInfo: return std::make_unique<DumpModuleInfoAction>();
72 case VerifyPCH: return std::make_unique<VerifyPCHAction>();
73 case TemplightDump: return std::make_unique<TemplightDumpAction>();
94 case PrintPreamble: return std::make_unique<PrintPreambleAction>();
98 return std::make_unique<RewriteIncludesAction>();
99 return std::make_unique<PrintPreprocessedAction>();
102 case RewriteMacros: return std::make_unique<RewriteMacrosAction>();
103 case RewriteTest: return std::make_unique<RewriteTestAction>();
105 case RewriteObjC: return std::make_unique<RewriteObjCAction>();
111 return std::make_unique<arcmt::MigrateSourceAction>();
116 case RunAnalysis: return std::make_unique<ento::AnalysisAction>();
120 case RunPreprocessorOnly: return std::make_unique<PreprocessOnlyAction>();
122 return std::make_unique<PrintDependencyDirectivesSourceMinimizerAction>();
144 Act = std::make_unique<FixItRecompile>(std::move(Act));
155 Act = std::make_unique<arcmt::CheckAction>(std::move(Act));
158 Act = std::make_unique<arcmt::ModifyAction>(std::move(Act));
161 Act = std::make_unique<arcmt::MigrateAction>(std::move(Act),
169 Act = std::make_unique<arcmt::ObjCMigrateAction>(std::move(Act),
179 Act = std::make_unique<ASTMergeAction>(std::move(Act),
tools/clang/lib/Index/IndexingAction.cpp 80 PP->addPPCallbacks(std::make_unique<IndexPPCallbacks>(IndexCtx));
118 return std::make_unique<IndexASTConsumer>(
130 return std::make_unique<IndexASTConsumer>(DataConsumer, Opts, PP,
138 return std::make_unique<IndexAction>(std::move(DataConsumer), Opts);
192 return std::make_unique<IndexPPCallbacks>(
tools/clang/lib/Lex/PPLexerChange.cpp 131 TokLexer = std::make_unique<TokenLexer>(Tok, ILEnd, Macro, Args, *this);
183 TokLexer = std::make_unique<TokenLexer>(
tools/clang/lib/Lex/Preprocessor.cpp 217 PragmaHandlers = std::make_unique<PragmaNamespace>(StringRef());
tools/clang/lib/Parse/ParseExpr.cpp 574 return std::make_unique<CastExpressionIdValidator>(*this);
tools/clang/lib/Parse/ParsePragma.cpp 268 AlignHandler = std::make_unique<PragmaAlignHandler>();
271 GCCVisibilityHandler = std::make_unique<PragmaGCCVisibilityHandler>();
274 OptionsHandler = std::make_unique<PragmaOptionsHandler>();
277 PackHandler = std::make_unique<PragmaPackHandler>();
280 MSStructHandler = std::make_unique<PragmaMSStructHandler>();
283 UnusedHandler = std::make_unique<PragmaUnusedHandler>();
286 WeakHandler = std::make_unique<PragmaWeakHandler>();
289 RedefineExtnameHandler = std::make_unique<PragmaRedefineExtnameHandler>();
292 FPContractHandler = std::make_unique<PragmaFPContractHandler>();
295 STDCFENVHandler = std::make_unique<PragmaSTDC_FENV_ACCESSHandler>();
298 STDCCXLIMITHandler = std::make_unique<PragmaSTDC_CX_LIMITED_RANGEHandler>();
301 STDCUnknownHandler = std::make_unique<PragmaSTDC_UnknownHandler>();
304 PCSectionHandler = std::make_unique<PragmaClangSectionHandler>(Actions);
308 OpenCLExtensionHandler = std::make_unique<PragmaOpenCLExtensionHandler>();
314 OpenMPHandler = std::make_unique<PragmaOpenMPHandler>();
316 OpenMPHandler = std::make_unique<PragmaNoOpenMPHandler>();
321 MSCommentHandler = std::make_unique<PragmaCommentHandler>(Actions);
327 std::make_unique<PragmaDetectMismatchHandler>(Actions);
329 MSPointersToMembers = std::make_unique<PragmaMSPointersToMembers>();
331 MSVtorDisp = std::make_unique<PragmaMSVtorDisp>();
333 MSInitSeg = std::make_unique<PragmaMSPragma>("init_seg");
335 MSDataSeg = std::make_unique<PragmaMSPragma>("data_seg");
337 MSBSSSeg = std::make_unique<PragmaMSPragma>("bss_seg");
339 MSConstSeg = std::make_unique<PragmaMSPragma>("const_seg");
341 MSCodeSeg = std::make_unique<PragmaMSPragma>("code_seg");
343 MSSection = std::make_unique<PragmaMSPragma>("section");
345 MSRuntimeChecks = std::make_unique<PragmaMSRuntimeChecksHandler>();
347 MSIntrinsic = std::make_unique<PragmaMSIntrinsicHandler>();
349 MSOptimize = std::make_unique<PragmaMSOptimizeHandler>();
355 std::make_unique<PragmaForceCUDAHostDeviceHandler>(Actions);
359 OptimizeHandler = std::make_unique<PragmaOptimizeHandler>(Actions);
362 LoopHintHandler = std::make_unique<PragmaLoopHintHandler>();
365 UnrollHintHandler = std::make_unique<PragmaUnrollHintHandler>("unroll");
368 NoUnrollHintHandler = std::make_unique<PragmaUnrollHintHandler>("nounroll");
372 std::make_unique<PragmaUnrollHintHandler>("unroll_and_jam");
376 std::make_unique<PragmaUnrollHintHandler>("nounroll_and_jam");
379 FPHandler = std::make_unique<PragmaFPHandler>();
383 std::make_unique<PragmaAttributeHandler>(AttrFactory);
tools/clang/lib/Parse/ParseStmt.cpp 143 return std::make_unique<StatementFilterCCC>(*this);
tools/clang/lib/Parse/ParseTentative.cpp 1196 return std::make_unique<TentativeParseCCC>(*this);
tools/clang/lib/Sema/Sema.cpp 186 std::make_unique<sema::SemaPPCallbacks>();
tools/clang/lib/Sema/SemaCXXScopeSpec.cpp 443 return std::make_unique<NestedNameSpecifierValidatorCCC>(*this);
tools/clang/lib/Sema/SemaDecl.cpp 110 return std::make_unique<TypeNameValidatorCCC>(*this);
7940 return std::make_unique<DifferentNameValidatorCCC>(*this);
17278 auto Vec = std::make_unique<ECDVector>();
tools/clang/lib/Sema/SemaDeclCXX.cpp 4019 return std::make_unique<MemInitializerValidatorCCC>(*this);
9796 return std::make_unique<NamespaceValidatorCCC>(*this);
10376 return std::make_unique<UsingValidatorCCC>(*this);
tools/clang/lib/Sema/SemaDeclObjC.cpp 515 return std::make_unique<ObjCInterfaceValidatorCCC>(*this);
1390 return std::make_unique<ObjCTypeArgOrProtocolValidatorCCC>(*this);
tools/clang/lib/Sema/SemaExpr.cpp 4973 return std::make_unique<FunctionCallCCC>(*this);
tools/clang/lib/Sema/SemaExprMember.cpp 632 return std::make_unique<RecordMemberExprValidatorCCC>(*this);
tools/clang/lib/Sema/SemaExprObjC.cpp 2118 return std::make_unique<ObjCInterfaceOrSuperCCC>(*this);
tools/clang/lib/Sema/SemaInit.cpp 2310 return std::make_unique<FieldInitializerValidatorCCC>(*this);
tools/clang/lib/Sema/SemaLookup.cpp 4866 auto Consumer = std::make_unique<TypoCorrectionConsumer>(
tools/clang/lib/Sema/SemaOpenMP.cpp 2227 return std::make_unique<VarDeclFilterCCC>(*this);
2249 return std::make_unique<VarOrFuncDeclFilterCCC>(*this);
tools/clang/lib/Sema/SemaTemplate.cpp 629 return std::make_unique<TemplateCandidateFilter>(*this);
3424 return std::make_unique<CandidateCallback>(*this);
10321 auto LPT = std::make_unique<LateParsedTemplate>();
tools/clang/lib/Sema/SemaTemplateVariadic.cpp 954 return std::make_unique<ParameterPackValidatorCCC>(*this);
tools/clang/lib/Serialization/ASTReader.cpp 8794 auto LT = std::make_unique<LateParsedTemplate>();
tools/clang/lib/Serialization/ModuleManager.cpp 147 auto NewModule = std::make_unique<ModuleFile>(Type, Generation);
tools/clang/lib/Serialization/PCHContainerOperations.cpp 57 return std::make_unique<RawPCHContainerGenerator>(std::move(OS), Buffer);
66 registerWriter(std::make_unique<RawPCHContainerWriter>());
67 registerReader(std::make_unique<RawPCHContainerReader>());
tools/clang/lib/StaticAnalyzer/Checkers/ArrayBoundChecker.cpp 79 std::make_unique<PathSensitiveBugReport>(*BT, BT->getDescription(), N);
tools/clang/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp 211 std::make_unique<TaintBugVisitor>(ByteOffset));
259 auto BR = std::make_unique<PathSensitiveBugReport>(*BT, os.str(), errorNode);
tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp 214 auto R = std::make_unique<PathSensitiveBugReport>(*BT, Msg, N);
523 auto report = std::make_unique<PathSensitiveBugReport>(*BT, os.str(), N);
578 auto report = std::make_unique<PathSensitiveBugReport>(BT, OS.str(), N);
638 auto report = std::make_unique<PathSensitiveBugReport>(*BT, os.str(), N);
791 auto R = std::make_unique<PathSensitiveBugReport>(*BT, os.str(),
tools/clang/lib/StaticAnalyzer/Checkers/BlockInCriticalSectionChecker.cpp 176 auto R = std::make_unique<PathSensitiveBugReport>(*BlockInCritSectionBugType,
tools/clang/lib/StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp 39 std::make_unique<PathSensitiveBugReport>(*BT, BT->getDescription(), N));
tools/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp 573 auto report = std::make_unique<PathSensitiveBugReport>(
590 auto Report = std::make_unique<PathSensitiveBugReport>(*BT, WarningMsg, N);
614 auto Report = std::make_unique<PathSensitiveBugReport>(*BT, WarningMsg, N);
630 std::make_unique<PathSensitiveBugReport>(*BT_NotCString, WarningMsg, N);
653 std::make_unique<PathSensitiveBugReport>(*BT_NotCString, WarningMsg, N);
tools/clang/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp 98 auto R = std::make_unique<PathSensitiveBugReport>(*BT, BT->getDescription(), N);
178 auto R = std::make_unique<PathSensitiveBugReport>(*BT, Os.str(), N);
255 auto R = std::make_unique<PathSensitiveBugReport>(*BT, Os.str(), N);
298 auto R = std::make_unique<PathSensitiveBugReport>(*BT, os.str(), N);
361 auto R = std::make_unique<PathSensitiveBugReport>(*BT, Desc, N);
423 C.emitReport(std::make_unique<PathSensitiveBugReport>(*BT_call_few_args,
485 auto R = std::make_unique<PathSensitiveBugReport>(*BT, BT->getDescription(), N);
529 std::make_unique<PathSensitiveBugReport>(*BT_msg_ret, os.str(), N);
tools/clang/lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp 135 auto R = std::make_unique<PathSensitiveBugReport>(*BT, BT->getDescription(),
tools/clang/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp 579 auto BR = std::make_unique<PathSensitiveBugReport>(*MissingReleaseBugType,
701 auto BR = std::make_unique<PathSensitiveBugReport>(*ExtraReleaseBugType,
743 auto BR = std::make_unique<PathSensitiveBugReport>(*MistakenDeallocBugType,
tools/clang/lib/StaticAnalyzer/Checkers/ChrootChecker.cpp 130 C.emitReport(std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/CloneChecker.cpp 117 auto R = std::make_unique<BasicBugReport>(
172 auto R = std::make_unique<BasicBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/ConversionChecker.cpp 124 auto R = std::make_unique<PathSensitiveBugReport>(*BT, Msg, N);
tools/clang/lib/StaticAnalyzer/Checkers/DebugCheckers.cpp 337 std::make_unique<PathSensitiveBugReport>(BT_stmtLoc, "Statement", Node);
tools/clang/lib/StaticAnalyzer/Checkers/DeleteWithNonVirtualDtorChecker.cpp 95 auto R = std::make_unique<PathSensitiveBugReport>(*BT, BT->getDescription(), N);
99 R->addVisitor(std::make_unique<DeleteBugVisitor>());
tools/clang/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp 182 auto report = std::make_unique<PathSensitiveBugReport>(
203 auto report = std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp 50 auto R = std::make_unique<PathSensitiveBugReport>(*BT, Msg, N);
91 std::make_unique<taint::TaintBugVisitor>(*DV));
tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypeChecker.cpp 83 auto R = std::make_unique<PathSensitiveBugReport>(
86 R->addVisitor(std::make_unique<DynamicTypeBugVisitor>(Reg));
tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp 914 auto R = std::make_unique<PathSensitiveBugReport>(*ObjCGenericsBugType,
917 R->addVisitor(std::make_unique<GenericsBugVisitor>(Sym));
tools/clang/lib/StaticAnalyzer/Checkers/EnumCastOutOfRangeChecker.cpp 86 C.emitReport(std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp 151 BR.emitReport(std::make_unique<PathSensitiveBugReport>(*BT, Msg, N));
tools/clang/lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp 59 std::make_unique<PathSensitiveBugReport>(*BT, BT->getDescription(), N);
tools/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp 739 auto report = std::make_unique<PathSensitiveBugReport>(*BT, Msg, N);
741 report->addVisitor(std::make_unique<TaintBugVisitor>(TaintedSVal));
tools/clang/lib/StaticAnalyzer/Checkers/InnerPointerChecker.cpp 264 return std::make_unique<InnerPointerChecker::InnerPointerBRVisitor>(Sym);
tools/clang/lib/StaticAnalyzer/Checkers/IteratorChecker.cpp 1593 auto R = std::make_unique<PathSensitiveBugReport>(*OutOfRangeBugType, Message,
1603 auto R = std::make_unique<PathSensitiveBugReport>(*MismatchedBugType, Message,
1614 auto R = std::make_unique<PathSensitiveBugReport>(*MismatchedBugType, Message,
1624 auto R = std::make_unique<PathSensitiveBugReport>(*InvalidatedBugType,
tools/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp 764 auto R = std::make_unique<PathSensitiveBugReport>(
775 R->addVisitor(std::make_unique<NonLocalizedStringBRVisitor>(StringRegion));
tools/clang/lib/StaticAnalyzer/Checkers/MIGChecker.cpp 277 auto R = std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp 33 auto Report = std::make_unique<PathSensitiveBugReport>(
42 Report->addVisitor(std::make_unique<RequestNodeVisitor>(
56 auto Report = std::make_unique<PathSensitiveBugReport>(*MissingWaitBugType,
62 Report->addVisitor(std::make_unique<RequestNodeVisitor>(
76 auto Report = std::make_unique<PathSensitiveBugReport>(*UnmatchedWaitBugType,
tools/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp 242 auto Report = std::make_unique<PathSensitiveBugReport>(*BT, os.str(), N);
243 Report->addVisitor(std::make_unique<SecKeychainBugVisitor>(AP.first));
287 std::make_unique<PathSensitiveBugReport>(*BT, os.str(), N);
288 Report->addVisitor(std::make_unique<SecKeychainBugVisitor>(V));
341 auto Report = std::make_unique<PathSensitiveBugReport>(
494 auto Report = std::make_unique<PathSensitiveBugReport>(
498 Report->addVisitor(std::make_unique<SecKeychainBugVisitor>(AP.first));
tools/clang/lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp 143 std::make_unique<PathSensitiveBugReport>(*BT_dispatchOnce, os.str(), N);
tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp 2084 auto R = std::make_unique<PathSensitiveBugReport>(*BT_BadFree[*CheckKind],
2109 auto R = std::make_unique<PathSensitiveBugReport>(
2165 auto R = std::make_unique<PathSensitiveBugReport>(*BT_MismatchedDealloc,
2169 R->addVisitor(std::make_unique<MallocBugVisitor>(Sym));
2225 auto R = std::make_unique<PathSensitiveBugReport>(*BT_OffsetFree[*CheckKind],
2252 auto R = std::make_unique<PathSensitiveBugReport>(
2261 R->addVisitor(std::make_unique<MallocBugVisitor>(Sym));
2287 auto R = std::make_unique<PathSensitiveBugReport>(
2296 R->addVisitor(std::make_unique<MallocBugVisitor>(Sym));
2316 auto R = std::make_unique<PathSensitiveBugReport>(
2320 R->addVisitor(std::make_unique<MallocBugVisitor>(Sym));
2344 auto R = std::make_unique<PathSensitiveBugReport>(
2350 R->addVisitor(std::make_unique<MallocBugVisitor>(Sym));
2384 auto R = std::make_unique<PathSensitiveBugReport>(*BT_BadFree[*CheckKind],
2609 auto R = std::make_unique<PathSensitiveBugReport>(
2613 R->addVisitor(std::make_unique<MallocBugVisitor>(Sym, true));
3219 StackHint = std::make_unique<StackHintGeneratorForSymbol>(
3230 StackHint = std::make_unique<StackHintGeneratorForSymbol>(
3242 StackHint = std::make_unique<StackHintGeneratorForSymbol>(
3258 StackHint = std::make_unique<StackHintGeneratorForSymbol>(
3299 StackHint = std::make_unique<StackHintGeneratorForSymbol>(Sym, "");
3303 StackHint = std::make_unique<StackHintGeneratorForReallocationFailed>(
3323 StackHint = std::make_unique<StackHintGeneratorForSymbol>(
tools/clang/lib/StaticAnalyzer/Checkers/MmapWriteExecChecker.cpp 70 auto Report = std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp 432 auto R = std::make_unique<PathSensitiveBugReport>(
435 R->addVisitor(std::make_unique<MovedBugVisitor>(*this, Region, RD, MK));
tools/clang/lib/StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp 70 auto Report = std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp 277 std::make_unique<PathSensitiveBugReport>(*bug, os.str(), event.SinkNode));
tools/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp 200 std::make_unique<PathSensitiveBugReport>(*BTAttrNonNull, SBuf, ErrorNode);
213 auto R = std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp 166 auto R = std::make_unique<PathSensitiveBugReport>(*BT, Msg, N);
169 R->addVisitor(std::make_unique<NullabilityBugVisitor>(Region));
tools/clang/lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp 49 auto report = std::make_unique<PathSensitiveBugReport>(
73 auto report = std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp 147 auto R = std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp 162 C.emitReport(std::make_unique<PathSensitiveBugReport>(*BT, errorStr, N));
tools/clang/lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp 190 auto BR = std::make_unique<PathSensitiveBugReport>(*DoubleSuperDeallocBugType,
193 BR->addVisitor(std::make_unique<SuperDeallocBRVisitor>(Sym));
tools/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp 309 std::make_unique<BugType>(this, "Excessive Padding", "Performance");
339 std::make_unique<BasicBugReport>(*PaddingBug, Os.str(), CELoc);
tools/clang/lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp 176 auto R = std::make_unique<PathSensitiveBugReport>(
199 auto R = std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp 67 std::make_unique<PathSensitiveBugReport>(*BT, BT->getDescription(), N);
tools/clang/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp 243 auto report = std::make_unique<PathSensitiveBugReport>(
308 auto Report = std::make_unique<PathSensitiveBugReport>(
331 auto report = std::make_unique<PathSensitiveBugReport>(
403 std::make_unique<PathSensitiveBugReport>(*BT_destroylock, Message, N);
443 std::make_unique<PathSensitiveBugReport>(*BT_initlock, Message, N);
456 auto Report = std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp 878 auto report = std::make_unique<RefCountReport>(
1098 std::make_unique<RefLeakReport>(leakAtReturn, LOpts, N, Sym, C);
1122 auto R = std::make_unique<RefCountReport>(
1276 auto R = std::make_unique<RefCountReport>(overAutorelease, LOpts, N, Sym,
1324 Ctx.emitReport(std::make_unique<RefLeakReport>(BT, LOpts, N, L, Ctx));
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp 816 addVisitor(std::make_unique<RefCountReportVisitor>(sym));
824 addVisitor(std::make_unique<RefCountReportVisitor>(sym));
916 addVisitor(std::make_unique<RefLeakReportVisitor>(sym));
tools/clang/lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp 83 std::make_unique<PathSensitiveBugReport>(*BT, BT->getDescription(), N);
tools/clang/lib/StaticAnalyzer/Checkers/ReturnUndefChecker.cpp 87 std::make_unique<PathSensitiveBugReport>(BT, BT.getDescription(), N);
tools/clang/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp 209 auto R = std::make_unique<PathSensitiveBugReport>(
222 auto R = std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp 158 BT_returnstack = std::make_unique<BuiltinBug>(
166 std::make_unique<PathSensitiveBugReport>(*BT_returnstack, os.str(), N);
197 BT_capturedstackasync = std::make_unique<BuiltinBug>(
203 auto Report = std::make_unique<PathSensitiveBugReport>(
220 BT_capturedstackret = std::make_unique<BuiltinBug>(
226 auto Report = std::make_unique<PathSensitiveBugReport>(*BT_capturedstackret,
335 BT_stackleak = std::make_unique<BuiltinBug>(
356 std::make_unique<PathSensitiveBugReport>(*BT_stackleak, Out.str(), N);
tools/clang/lib/StaticAnalyzer/Checkers/StreamChecker.cpp 280 C.emitReport(std::make_unique<PathSensitiveBugReport>(
348 C.emitReport(std::make_unique<PathSensitiveBugReport>(
378 C.emitReport(std::make_unique<PathSensitiveBugReport>(
408 C.emitReport(std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/TaintTesterChecker.cpp 55 auto report = std::make_unique<PathSensitiveBugReport>(*BT, "tainted", N);
tools/clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp 170 auto R = std::make_unique<PathSensitiveBugReport>(
175 R->addVisitor(std::make_unique<DivisionBRVisitor>(Val.getAsSymbol(),
tools/clang/lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp 99 auto R = std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp 86 auto R = std::make_unique<PathSensitiveBugReport>(*BT, os.str(), N);
89 R->addVisitor(std::make_unique<FindLastStoreBRVisitor>(
tools/clang/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp 173 auto report = std::make_unique<PathSensitiveBugReport>(*BT, OS.str(), N);
tools/clang/lib/StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp 55 auto R = std::make_unique<PathSensitiveBugReport>(*BT, BT->getDescription(), N);
tools/clang/lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp 111 auto R = std::make_unique<PathSensitiveBugReport>(*BT, OS.str(), N);
tools/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObjectChecker.cpp 190 auto Report = std::make_unique<PathSensitiveBugReport>(
204 auto Report = std::make_unique<PathSensitiveBugReport>(
tools/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp 138 auto Report = std::make_unique<PathSensitiveBugReport>(*BT_open, Msg, N);
308 std::make_unique<PathSensitiveBugReport>(*BT_pthreadOnce, os.str(), N);
352 std::make_unique<PathSensitiveBugReport>(*BT_mallocZero, os.str(), N);
tools/clang/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp 75 auto report = std::make_unique<PathSensitiveBugReport>(*BT, os.str(), N);
113 std::make_unique<TaintBugVisitor>(sizeV));
tools/clang/lib/StaticAnalyzer/Checkers/ValistChecker.cpp 258 auto R = std::make_unique<PathSensitiveBugReport>(*BT_uninitaccess, Msg, N);
260 R->addVisitor(std::make_unique<ValistBugVisitor>(VAList));
299 auto R = std::make_unique<PathSensitiveBugReport>(
303 R->addVisitor(std::make_unique<ValistBugVisitor>(Reg, true));
tools/clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp 135 auto Report = std::make_unique<PathSensitiveBugReport>(*BT, os.str(), N);
tools/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp 149 auto Report = std::make_unique<PathSensitiveBugReport>(*BT, OS.str(), N);
209 Chk->BT_Pure = std::make_unique<BugType>(Mgr.getCurrentCheckerName(),
218 Chk->BT_Impure = std::make_unique<BugType>(
tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp 1314 return std::make_unique<PathDiagnostic>(
1318 std::make_unique<FilesToLineNumsMap>());
1325 return std::make_unique<PathDiagnostic>(
2560 auto GNew = std::make_unique<ExplodedGraph>();
2698 std::make_unique<VisitorsDiagnosticsTy>();
2764 R->addVisitor(std::make_unique<LikelyFalsePositiveSuppressionBRVisitor>());
2767 R->addVisitor(std::make_unique<NilReceiverBRVisitor>());
2768 R->addVisitor(std::make_unique<ConditionBRVisitor>());
2769 R->addVisitor(std::make_unique<TagVisitor>());
2782 R->addVisitor(std::make_unique<FalsePositiveRefutationBRVisitor>());
2806 auto Out = std::make_unique<DiagnosticForConsumerMapTy>();
3006 auto piece = std::make_unique<PathDiagnosticEventPiece>(
3084 auto ExecutedLines = std::make_unique<FilesToLineNumsMap>();
3123 auto Out = std::make_unique<DiagnosticForConsumerMapTy>();
3251 auto R = std::make_unique<BasicBugReport>(*BT, str, Loc);
tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp 836 BR.addVisitor(std::make_unique<MacroNullReturnSuppressionVisitor>(
998 BR.addVisitor(std::make_unique<ReturnVisitor>(CalleeContext,
1487 BR.addVisitor(std::make_unique<FindLastStoreBRVisitor>(
1956 report.addVisitor(std::make_unique<TrackControlDependencyCondBRVisitor>(
1984 report.addVisitor(std::make_unique<FindLastStoreBRVisitor>(
1999 std::make_unique<NoStoreFuncVisitor>(cast<SubRegion>(R), TKind));
2005 report.addVisitor(std::make_unique<UndefOrNullArgVisitor>(R));
2010 report.addVisitor(std::make_unique<TrackConstraintBRVisitor>(
2018 std::make_unique<SuppressInlineDefensiveChecksVisitor>(*DV,
2022 report.addVisitor(std::make_unique<FindLastStoreBRVisitor>(
2059 std::make_unique<UndefOrNullArgVisitor>(L->getRegion()));
2062 report.addVisitor(std::make_unique<FindLastStoreBRVisitor>(
2069 report.addVisitor(std::make_unique<TrackConstraintBRVisitor>(
tools/clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp 333 return std::make_unique<RangeConstraintManager>(Eng, StMgr.getSValBuilder());
tools/clang/lib/StaticAnalyzer/Core/RegionStore.cpp 678 return std::make_unique<RegionStoreManager>(StMgr, F);
685 return std::make_unique<RegionStoreManager>(StMgr, F);
tools/clang/lib/StaticAnalyzer/Core/SMTConstraintManager.cpp 17 return std::make_unique<SMTConstraintManager>(Eng, StMgr.getSValBuilder());
tools/clang/lib/StaticAnalyzer/Core/WorkList.cpp 82 return std::make_unique<DFS>();
86 return std::make_unique<BFS>();
127 return std::make_unique<BFSBlockDFSContents>();
189 return std::make_unique<UnexploredFirstStack>();
252 return std::make_unique<UnexploredFirstPriorityQueue>();
312 return std::make_unique<UnexploredFirstPriorityLocationQueue>();
tools/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp 236 AnalyzerTimers = std::make_unique<llvm::TimerGroup>(
238 SyntaxCheckTimer = std::make_unique<llvm::Timer>(
240 ExprEngineTimer = std::make_unique<llvm::Timer>(
242 BugReporterTimer = std::make_unique<llvm::Timer>(
338 Mgr = std::make_unique<AnalysisManager>(*Ctx, PathConsumers, CreateStoreMgr,
857 return std::make_unique<AnalysisConsumer>(
tools/clang/lib/StaticAnalyzer/Frontend/CheckerRegistration.cpp 33 auto checkerMgr = std::make_unique<CheckerManager>(context, opts);
tools/clang/lib/StaticAnalyzer/Frontend/FrontendActions.cpp 26 return std::make_unique<ModelConsumer>(Bodies);
tools/clang/lib/Tooling/ASTDiff/ASTDiff.cpp 963 : DiffImpl(std::make_unique<Impl>(*T1.TreeImpl, *T2.TreeImpl, Options)) {}
972 : TreeImpl(std::make_unique<SyntaxTree::Impl>(
tools/clang/lib/Tooling/AllTUsExecution.cpp 166 return std::make_unique<AllTUsToolExecutor>(std::move(OptionsParser),
tools/clang/lib/Tooling/CommonOptionsParser.cpp 145 std::make_unique<ArgumentsAdjustingCompilations>(
tools/clang/lib/Tooling/CompilationDatabase.cpp 359 return std::make_unique<FixedCompilationDatabase>(Directory, StrippedArgs);
373 return std::make_unique<FixedCompilationDatabase>(
tools/clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp 245 auto Result = std::make_unique<MinimizedVFSFile>(
tools/clang/lib/Tooling/DependencyScanning/DependencyScanningTool.cpp 30 this->Opts = std::make_unique<DependencyOutputOptions>(Opts);
tools/clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp 129 auto Opts = std::make_unique<DependencyOutputOptions>(
138 auto Action = std::make_unique<PreprocessOnlyAction>();
161 std::make_unique<ExcludedPreprocessorDirectiveSkipMapping>();
tools/clang/lib/Tooling/GuessTargetAndModeCompilationDatabase.cpp 53 return std::make_unique<TargetAndModeAdderDatabase>(std::move(Base));
tools/clang/lib/Tooling/InterpolatingCompilationDatabase.cpp 540 return std::make_unique<InterpolatingCompilationDatabase>(std::move(Inner));
tools/clang/lib/Tooling/Refactoring/ASTSelectionRequirements.cpp 38 std::make_unique<SelectedASTNode>(std::move(*ASTSelection));
tools/clang/lib/Tooling/Refactoring/RefactoringActions.cpp 101 Actions.push_back(std::make_unique<LocalRename>());
102 Actions.push_back(std::make_unique<ExtractRefactoring>());
tools/clang/lib/Tooling/Refactoring/Rename/RenamingAction.cpp 269 return std::make_unique<RenamingASTConsumer>(NewNames, PrevNames, USRList,
274 return std::make_unique<USRSymbolRenamer>(NewNames, USRList, FileToReplaces);
tools/clang/lib/Tooling/Refactoring/Rename/USRFindingAction.cpp 273 return std::make_unique<NamedDeclFindingConsumer>(
tools/clang/lib/Tooling/RefactoringCallbacks.cpp 69 return std::make_unique<RefactoringASTConsumer>(*this);
tools/clang/lib/Tooling/StandaloneExecution.cpp 79 return std::make_unique<StandaloneToolExecutor>(std::move(OptionsParser));
tools/clang/lib/Tooling/Syntax/Tokens.cpp 339 auto CB = std::make_unique<CollectPPExpansions>(*this);
tools/clang/tools/c-index-test/core_main.cpp 253 pchContOps->registerReader(std::make_unique<ObjectFilePCHContainerReader>());
tools/clang/tools/clang-check/ClangCheck.cpp 147 return std::make_unique<clang::ASTConsumer>();
tools/clang/tools/clang-diff/ClangDiff.cpp 77 std::make_unique<ArgumentsAdjustingCompilations>(
100 std::make_unique<clang::tooling::FixedCompilationDatabase>(
tools/clang/tools/clang-extdef-mapping/ClangExtDefMapGen.cpp 108 return std::make_unique<MapExtDefNamesConsumer>(CI.getASTContext());
tools/clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp 162 builder.setMCJITMemoryManager(std::make_unique<SectionMemoryManager>());
tools/clang/tools/clang-import-test/clang-import-test.cpp 81 : Passthrough(std::make_unique<TextDiagnosticBuffer>()) {}
161 auto Ins = std::make_unique<CompilerInstance>();
162 auto DC = std::make_unique<TestDiagnosticConsumer>();
166 auto Inv = std::make_unique<CompilerInvocation>();
216 auto AST = std::make_unique<ASTContext>(
268 auto ES = std::make_unique<ExternalASTMerger>(Target, Sources);
275 auto ST = std::make_unique<SelectorTable>();
276 auto BC = std::make_unique<Builtin::Context>();
301 auto ST = std::make_unique<SelectorTable>();
302 auto BC = std::make_unique<Builtin::Context>();
311 auto LLVMCtx = std::make_unique<llvm::LLVMContext>();
tools/clang/tools/clang-offload-bundler/ClangOffloadBundler.cpp 626 return std::make_unique<BinaryFileHandler>();
630 return std::make_unique<ObjectFileHandler>(
638 return std::make_unique<TextFileHandler>(/*Comment=*/"//");
640 return std::make_unique<TextFileHandler>(/*Comment=*/"//");
642 return std::make_unique<TextFileHandler>(/*Comment=*/"//");
646 return std::make_unique<TextFileHandler>(/*Comment=*/"#");
648 return std::make_unique<TextFileHandler>(/*Comment=*/";");
650 return std::make_unique<BinaryFileHandler>();
652 return std::make_unique<TextFileHandler>(/*Comment=*/"#");
656 return std::make_unique<BinaryFileHandler>();
658 return std::make_unique<BinaryFileHandler>();
tools/clang/tools/clang-refactor/ClangRefactor.cpp 154 return std::make_unique<TestSourceSelectionArgument>(
159 return std::make_unique<SourceRangeSelectionArgument>(std::move(*Range));
240 return std::make_unique<cl::opt<T>>(
263 Selection = std::make_unique<cl::opt<std::string>>(
364 SubCommands.push_back(std::make_unique<RefactoringActionSubcommand>(
465 return std::make_unique<ToolASTAction>(Callback);
472 return std::make_unique<ToolActionFactory>(
tools/clang/tools/clang-refactor/TestSupport.cpp 259 return std::make_unique<TestRefactoringResultConsumer>(*this);
tools/clang/tools/clang-scan-deps/ClangScanDeps.cpp 146 std::make_unique<tooling::ArgumentsAdjustingCompilations>(
213 WorkerTools.push_back(std::make_unique<DependencyScanningTool>(
tools/clang/tools/driver/cc1_main.cpp 197 PCHOps->registerWriter(std::make_unique<ObjectFilePCHContainerWriter>());
198 PCHOps->registerReader(std::make_unique<ObjectFilePCHContainerReader>());
tools/clang/tools/driver/cc1as_main.cpp 318 auto Out = std::make_unique<raw_fd_ostream>(
454 auto FOut = std::make_unique<formatted_raw_ostream>(*Out);
465 BOS = std::make_unique<buffer_ostream>(*FDOS);
tools/clang/tools/extra/clang-change-namespace/ChangeNamespace.cpp 112 return std::make_unique<Lexer>(SM.getLocForStartOfFile(LocInfo.first),
tools/clang/tools/extra/clang-doc/BitcodeReader.cpp 354 I->Children.emplace_back(std::make_unique<CommentInfo>());
726 std::unique_ptr<Info> I = std::make_unique<T>();
tools/clang/tools/extra/clang-doc/ClangDoc.cpp 46 return std::make_unique<MapASTVisitor>(&Compiler.getASTContext(), CDCtx);
52 return std::make_unique<ClangDocAction>(CDCtx);
57 return std::make_unique<MapperActionFactory>(CDCtx);
tools/clang/tools/extra/clang-doc/HTMLGenerator.cpp 87 Children.emplace_back(std::make_unique<TextNode>(Text.str()));
274 auto LinkNode = std::make_unique<TagNode>(HTMLTag::TAG_LINK);
291 auto ScriptNode = std::make_unique<TagNode>(HTMLTag::TAG_SCRIPT);
303 auto LinkNode = std::make_unique<TagNode>(HTMLTag::TAG_A, Text);
313 return std::make_unique<TextNode>(Type.Name);
333 Out.emplace_back(std::make_unique<TextNode>(", "));
352 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, "Enums"));
354 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_DIV));
368 auto List = std::make_unique<TagNode>(HTMLTag::TAG_UL);
370 List->Children.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_LI, M));
381 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, "Functions"));
383 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_DIV));
400 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, "Members"));
402 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_UL));
408 auto LIBody = std::make_unique<TagNode>(HTMLTag::TAG_LI);
409 LIBody->Children.emplace_back(std::make_unique<TextNode>(Access));
411 LIBody->Children.emplace_back(std::make_unique<TextNode>(" " + M.Name));
424 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, Title));
426 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_UL));
429 auto LiNode = std::make_unique<TagNode>(HTMLTag::TAG_LI);
440 return std::make_unique<TagNode>(
445 auto Node = std::make_unique<TagNode>(HTMLTag::TAG_P);
446 Node->Children.emplace_back(std::make_unique<TextNode>("Defined at line "));
448 std::make_unique<TagNode>(HTMLTag::TAG_A, std::to_string(L.LineNumber));
454 Node->Children.emplace_back(std::make_unique<TextNode>(" of file "));
455 auto LocFileNode = std::make_unique<TagNode>(
472 auto MetaNode = std::make_unique<TagNode>(HTMLTag::TAG_META);
475 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_TITLE, Title));
488 auto HeaderNode = std::make_unique<TagNode>(HTMLTag::TAG_HEADER, ProjectName);
501 auto MainNode = std::make_unique<TagNode>(HTMLTag::TAG_MAIN);
503 auto LeftSidebarNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
509 auto MainContentNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
515 auto RightSidebarNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
533 auto FooterNode = std::make_unique<TagNode>(HTMLTag::TAG_FOOTER);
534 auto SpanNode = std::make_unique<TagNode>(
577 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_SPAN));
589 Out.emplace_back(std::make_unique<TagNode>(ListHTMLTag));
592 auto LiBody = std::make_unique<TagNode>(HTMLTag::TAG_LI);
602 auto FullComment = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
610 auto ParagraphComment = std::make_unique<TagNode>(HTMLTag::TAG_P);
622 return std::make_unique<TextNode>(I.Text);
628 auto CommentBlock = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
646 std::make_unique<TagNode>(HTMLTag::TAG_H3, EnumType + I.Name));
673 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H3, I.Name));
679 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_P));
685 std::make_unique<TextNode>(Access + " "));
689 FunctionHeader->Children.emplace_back(std::make_unique<TextNode>(" "));
692 std::make_unique<TextNode>(I.Name + "("));
696 FunctionHeader->Children.emplace_back(std::make_unique<TextNode>(", "));
699 std::make_unique<TextNode>(" " + P.Name));
701 FunctionHeader->Children.emplace_back(std::make_unique<TextNode>(")"));
727 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H1, InfoTitle));
765 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H1, InfoTitle));
784 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_P));
786 PBody->Children.emplace_back(std::make_unique<TextNode>("Inherits from "));
793 PBody->Children.emplace_back(std::make_unique<TextNode>(", "));
922 auto MainNode = std::make_unique<TagNode>(HTMLTag::TAG_MAIN);
924 auto LeftSidebarNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
tools/clang/tools/extra/clang-doc/Representation.cpp 39 std::unique_ptr<Info> Merged = std::make_unique<T>(Values[0]->USR);
tools/clang/tools/extra/clang-doc/Serialize.cpp 93 CurrentCI.Children.emplace_back(std::make_unique<CommentInfo>());
493 auto I = std::make_unique<NamespaceInfo>();
506 auto ParentI = std::make_unique<NamespaceInfo>();
519 auto I = std::make_unique<RecordInfo>();
541 auto ParentI = std::make_unique<NamespaceInfo>();
549 auto ParentI = std::make_unique<RecordInfo>();
573 auto ParentI = std::make_unique<NamespaceInfo>();
610 auto ParentI = std::make_unique<RecordInfo>();
632 auto ParentI = std::make_unique<NamespaceInfo>();
644 auto ParentI = std::make_unique<NamespaceInfo>();
652 auto ParentI = std::make_unique<RecordInfo>();
tools/clang/tools/extra/clang-include-fixer/FuzzySymbolIndex.cpp 137 return std::make_unique<MemSymbolIndex>(
tools/clang/tools/extra/clang-include-fixer/IncludeFixer.cpp 37 return std::make_unique<clang::ASTConsumer>();
107 std::make_unique<Action>(SymbolIndexMgr, MinimizeIncludePaths);
tools/clang/tools/extra/clang-include-fixer/find-all-symbols/FindAllSymbolsAction.cpp 30 Compiler.getPreprocessor().addPPCallbacks(std::make_unique<FindAllMacros>(
tools/clang/tools/extra/clang-include-fixer/find-all-symbols/FindAllSymbolsAction.h 51 return std::make_unique<FindAllSymbolsAction>(Reporter, RegexHeaderMap);
tools/clang/tools/extra/clang-include-fixer/find-all-symbols/tool/FindAllSymbolsMain.cpp 148 std::make_unique<clang::find_all_symbols::FindAllSymbolsActionFactory>(
tools/clang/tools/extra/clang-include-fixer/plugin/IncludeFixerPlugin.cpp 44 return std::make_unique<ASTConsumerManagerWrapper>(SymbolIndexMgr);
tools/clang/tools/extra/clang-include-fixer/tool/ClangIncludeFixer.cpp 164 auto SymbolIndexMgr = std::make_unique<include_fixer::SymbolIndexManager>();
188 return std::make_unique<include_fixer::InMemorySymbolIndex>(Symbols);
tools/clang/tools/extra/clang-move/HelperDeclRefGraph.cpp 62 Node = std::make_unique<CallGraphNode>(F);
tools/clang/tools/extra/clang-move/Move.cpp 479 Compiler.getPreprocessor().addPPCallbacks(std::make_unique<FindAllIncludes>(
613 MatchCallbacks.push_back(std::make_unique<ClassDeclarationMatch>(this));
632 MatchCallbacks.push_back(std::make_unique<FunctionDeclarationMatch>(this));
637 MatchCallbacks.push_back(std::make_unique<VarDeclarationMatch>(this));
644 MatchCallbacks.push_back(std::make_unique<EnumDeclarationMatch>(this));
653 MatchCallbacks.push_back(std::make_unique<TypeAliasMatch>(this));
tools/clang/tools/extra/clang-move/Move.h 228 return std::make_unique<ClangMoveAction>(Context, Reporter);
tools/clang/tools/extra/clang-reorder-fields/ReorderFieldsAction.cpp 305 return std::make_unique<ReorderingConsumer>(RecordName, DesiredFieldsOrder,
tools/clang/tools/extra/clang-tidy/ClangTidy.cpp 395 Profiling = std::make_unique<ClangTidyProfiling>(
407 auto ModuleExpander = std::make_unique<ExpandModularHeadersPPCallbacks>(
439 return std::make_unique<ClangTidyASTConsumer>(
474 std::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),
485 std::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),
536 return std::make_unique<Action>(&ConsumerFactory);
tools/clang/tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp 176 CheckFilter = std::make_unique<CachedGlobList>(*getOptions().Checks);
178 std::make_unique<CachedGlobList>(*getOptions().WarningsAsErrors);
567 std::make_unique<llvm::Regex>(*Context.getOptions().HeaderFilterRegex);
tools/clang/tools/extra/clang-tidy/ClangTidyModule.h 61 return std::make_unique<CheckType>(Name, Context);
tools/clang/tools/extra/clang-tidy/ExpandModularHeadersPPCallbacks.cpp 57 : Recorder(std::make_unique<FileRecorder>()), Compiler(*CI),
75 HeaderInfo = std::make_unique<HeaderSearch>(HSO, Sources, Diags, LangOpts,
81 PP = std::make_unique<clang::Preprocessor>(PO, Diags, LangOpts, Sources,
tools/clang/tools/extra/clang-tidy/abseil/StringFindStartswithCheck.cpp 118 IncludeInserter = std::make_unique<utils::IncludeInserter>(SM, getLangOpts(),
tools/clang/tools/extra/clang-tidy/bugprone/LambdaFunctionNameCheck.cpp 69 PP->addPPCallbacks(std::make_unique<MacroExpansionsWithFileAndLine>(
tools/clang/tools/extra/clang-tidy/bugprone/MacroParenthesesCheck.cpp 253 PP->addPPCallbacks(std::make_unique<MacroParenthesesPPCallbacks>(PP, this));
tools/clang/tools/extra/clang-tidy/bugprone/MacroRepeatedSideEffectsCheck.cpp 176 PP->addPPCallbacks(::std::make_unique<MacroRepeatedPPCallbacks>(*this, *PP));
tools/clang/tools/extra/clang-tidy/bugprone/UseAfterMoveCheck.cpp 105 std::make_unique<ExprSequence>(TheCFG.get(), FunctionBody, Context);
106 BlockMap = std::make_unique<StmtToBlockMap>(TheCFG.get(), Context);
tools/clang/tools/extra/clang-tidy/cert/SetLongJmpCheck.cpp 54 PP->addPPCallbacks(std::make_unique<SetJmpMacroCallbacks>(*this));
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/InitVariablesCheck.cpp 43 std::make_unique<utils::IncludeInserter>(SM, getLangOpts(), IncludeStyle);
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/MacroUsageCheck.cpp 77 PP->addPPCallbacks(std::make_unique<MacroUsageCallbacks>(
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp 38 Inserter = std::make_unique<utils::IncludeInserter>(SM, getLangOpts(),
tools/clang/tools/extra/clang-tidy/fuchsia/RestrictSystemIncludesCheck.cpp 106 std::make_unique<RestrictedIncludesPPCallbacks>(*this, SM));
tools/clang/tools/extra/clang-tidy/google/AvoidUnderscoreInGoogletestNameCheck.cpp 82 std::make_unique<AvoidUnderscoreInGoogletestNameCallback>(PP, this));
tools/clang/tools/extra/clang-tidy/google/IntegerTypesCheck.cpp 71 IdentTable = std::make_unique<IdentifierTable>(getLangOpts());
tools/clang/tools/extra/clang-tidy/google/TodoCommentCheck.cpp 55 Handler(std::make_unique<TodoCommentHandler>(
tools/clang/tools/extra/clang-tidy/google/UpgradeGoogletestCaseCheck.cpp 128 std::make_unique<UpgradeGoogletestCasePPCallback>(this, PP));
tools/clang/tools/extra/clang-tidy/llvm/IncludeOrderCheck.cpp 56 PP->addPPCallbacks(::std::make_unique<IncludeOrderPPCallbacks>(*this, SM));
tools/clang/tools/extra/clang-tidy/misc/UnusedParametersCheck.cpp 138 Indexer = std::make_unique<IndexerVisitor>(*Result.Context);
tools/clang/tools/extra/clang-tidy/modernize/DeprecatedHeadersCheck.cpp 47 ::std::make_unique<IncludeModernizePPCallbacks>(*this, getLangOpts()));
tools/clang/tools/extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp 72 Inserter = std::make_unique<utils::IncludeInserter>(SM, getLangOpts(),
tools/clang/tools/extra/clang-tidy/modernize/PassByValueCheck.cpp 174 Inserter = std::make_unique<utils::IncludeInserter>(SM, getLangOpts(),
tools/clang/tools/extra/clang-tidy/modernize/ReplaceAutoPtrCheck.cpp 143 Inserter = std::make_unique<utils::IncludeInserter>(SM, getLangOpts(),
tools/clang/tools/extra/clang-tidy/modernize/ReplaceRandomShuffleCheck.cpp 47 IncludeInserter = std::make_unique<utils::IncludeInserter>(SM, getLangOpts(),
tools/clang/tools/extra/clang-tidy/performance/MoveConstructorInitCheck.cpp 96 Inserter = std::make_unique<utils::IncludeInserter>(SM, getLangOpts(),
tools/clang/tools/extra/clang-tidy/performance/TypePromotionInMathFnCheck.cpp 39 IncludeInserter = std::make_unique<utils::IncludeInserter>(SM, getLangOpts(),
tools/clang/tools/extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp 172 Inserter = std::make_unique<utils::IncludeInserter>(SM, getLangOpts(),
tools/clang/tools/extra/clang-tidy/plugin/ClangTidyPlugin.cpp 45 auto DiagEngine = std::make_unique<DiagnosticsEngine>(
54 return std::make_unique<WrapConsumer>(
70 auto Options = std::make_unique<FileOptionsProvider>(
72 Context = std::make_unique<ClangTidyContext>(std::move(Options));
tools/clang/tools/extra/clang-tidy/readability/IdentifierNamingCheck.cpp 249 std::make_unique<IdentifierNamingCheckPPCallbacks>(ModuleExpanderPP,
tools/clang/tools/extra/clang-tidy/readability/RedundantPreprocessorCheck.cpp 102 ::std::make_unique<RedundantPreprocessorCallbacks>(*this, *PP));
tools/clang/tools/extra/clang-tidy/tool/ClangTidyMain.cpp 293 return std::make_unique<ConfigOptionsProvider>(
303 return std::make_unique<FileOptionsProvider>(GlobalOptions, DefaultOptions,
tools/clang/tools/extra/clang-tidy/utils/HeaderGuard.cpp 272 PP->addPPCallbacks(std::make_unique<HeaderGuardPPCallbacks>(PP, this));
tools/clang/tools/extra/clang-tidy/utils/IncludeInserter.cpp 45 return std::make_unique<IncludeInserterCallback>(this);
61 std::make_unique<IncludeSorter>(
75 FileID, std::make_unique<IncludeSorter>(
tools/clang/tools/extra/clang-tidy/utils/TransformerClangTidyCheck.cpp 56 Inserter = std::make_unique<IncludeInserter>(
tools/clang/tools/extra/clangd/ClangdLSPServer.cpp 143 *Next = std::make_unique<SelectionRange>();
482 BaseCDB = std::make_unique<DirectoryBasedGlobalCompilationDatabase>(
tools/clang/tools/extra/clangd/ClangdServer.cpp 130 std::make_unique<UpdateIndexCallbacks>(DynamicIdx.get(), DiagConsumer,
136 MergedIdx.push_back(std::make_unique<MergedIndex>(Idx, this->Index));
145 BackgroundIdx = std::make_unique<BackgroundIndex>(
tools/clang/tools/extra/clangd/CodeComplete.cpp 1260 auto RecorderOwner = std::make_unique<CompletionRecorder>(Opts, [&]() {
1768 std::make_unique<SignatureHelpCollector>(Options, Index, Result),
tools/clang/tools/extra/clangd/Compiler.cpp 89 auto Clang = std::make_unique<CompilerInstance>(
tools/clang/tools/extra/clangd/Context.h 125 std::make_unique<TypedAnyStorage<typename std::decay<Type>::type>>(
135 std::make_unique<TypedAnyStorage<typename std::decay<Type>::type>>(
tools/clang/tools/extra/clangd/Headers.cpp 115 return std::make_unique<RecordHeaders>(SM, Out);
tools/clang/tools/extra/clangd/JSONTransport.cpp 297 return std::make_unique<JSONTransport>(In, Out, InMirror, Pretty, Style);
tools/clang/tools/extra/clangd/ParsedAST.cpp 99 return std::make_unique<DeclTrackingASTConsumer>(/*ref*/ TopLevelDecls);
240 auto Action = std::make_unique<ClangdFrontendAction>();
264 CTContext.emplace(std::make_unique<tidy::DefaultOptionsProvider>(
349 std::make_unique<CollectMainFileMacros>(Clang->getSourceManager(),
522 std::make_unique<CompilerInvocation>(*Invocation),
tools/clang/tools/extra/clangd/Preamble.cpp 55 return std::make_unique<PPChainedCallbacks>(
57 std::make_unique<CollectMainFileMacros>(*SourceMgr, *LangOpts, Macros));
135 auto StatCache = std::make_unique<PreambleFileStatusCache>(AbsFileName);
tools/clang/tools/extra/clangd/QueryDriverDatabase.cpp 280 return std::make_unique<QueryDriverDatabase>(QueryDriverGlobs,
tools/clang/tools/extra/clangd/TUScheduler.cpp 491 AST = NewAST ? std::make_unique<ParsedAST>(std::move(*NewAST)) : nullptr;
542 std::make_unique<CompilerInvocation>(*Invocation),
546 AST = NewAST ? std::make_unique<ParsedAST>(std::move(*NewAST)) : nullptr;
853 : std::make_unique<ParsingCallbacks>()),
855 IdleASTs(std::make_unique<ASTCache>(RetentionPolicy.MaxRetainedASTs)),
tools/clang/tools/extra/clangd/Trace.cpp 54 SpanKey, std::make_unique<JSONSpan>(this, Name, Args));
202 return std::make_unique<JSONTracer>(OS, Pretty);
tools/clang/tools/extra/clangd/URI.cpp 64 return std::make_unique<FileSystemScheme>();
tools/clang/tools/extra/clangd/index/Background.cpp 141 : SwapIndex(std::make_unique<MemIndex>()), FSProvider(FSProvider),
297 auto SS = std::make_unique<SymbolSlab>(std::move(Syms).build());
298 auto RS = std::make_unique<RefSlab>(std::move(Refs).build());
299 auto RelS = std::make_unique<RelationSlab>(std::move(Relations).build());
300 auto IG = std::make_unique<IncludeGraph>(
463 ? std::make_unique<SymbolSlab>(std::move(*LS.Shard->Symbols))
466 ? std::make_unique<RefSlab>(std::move(*LS.Shard->Refs))
470 ? std::make_unique<RelationSlab>(std::move(*LS.Shard->Relations))
tools/clang/tools/extra/clangd/index/BackgroundIndexStorage.cpp 67 return std::make_unique<IndexFileIn>(std::move(*I));
107 : IndexStorageMapMu(std::make_unique<std::mutex>()),
130 return std::make_unique<NullStorage>();
132 return std::make_unique<DiskBackedIndexStorage>(CDBDirectory);
tools/clang/tools/extra/clangd/index/CanonicalIncludes.cpp 85 return std::make_unique<PragmaCommentHandler>(Includes);
tools/clang/tools/extra/clangd/index/FileIndex.cpp 220 return std::make_unique<MemIndex>(
227 return std::make_unique<dex::Dex>(
239 PreambleIndex(std::make_unique<MemIndex>()),
240 MainFileIndex(std::make_unique<MemIndex>()) {}
247 Path, std::make_unique<SymbolSlab>(std::move(std::get<0>(Slabs))),
248 std::make_unique<RefSlab>(),
249 std::make_unique<RelationSlab>(std::move(std::get<2>(Slabs))),
259 Path, std::make_unique<SymbolSlab>(std::move(std::get<0>(Contents))),
260 std::make_unique<RefSlab>(std::move(std::get<1>(Contents))),
261 std::make_unique<RelationSlab>(std::move(std::get<2>(Contents))),
tools/clang/tools/extra/clangd/index/IndexAction.cpp 147 std::make_unique<IncludeGraphCollector>(CI.getSourceManager(), IG));
221 auto Includes = std::make_unique<CanonicalIncludes>();
223 return std::make_unique<IndexAction>(
tools/clang/tools/extra/clangd/index/MemIndex.cpp 24 return std::make_unique<MemIndex>(Data.first, Data.second, Relations,
tools/clang/tools/extra/clangd/index/SymbolCollector.cpp 198 std::make_unique<CodeCompletionTUInfo>(CompletionAllocator);
tools/clang/tools/extra/clangd/index/dex/Dex.cpp 32 return std::make_unique<Dex>(Data.first, Data.second, Rels, std::move(Data),
tools/clang/tools/extra/clangd/index/dex/Iterator.cpp 383 return std::make_unique<AndIterator>(std::move(RealChildren));
413 return std::make_unique<OrIterator>(std::move(RealChildren));
418 return std::make_unique<TrueIterator>(Size);
422 return std::make_unique<FalseIterator>();
431 return std::make_unique<BoostIterator>(std::move(Child), Factor);
438 return std::make_unique<LimitIterator>(std::move(Child), Limit);
tools/clang/tools/extra/clangd/index/dex/PostingList.cpp 223 return std::make_unique<ChunkIterator>(Tok, Chunks);
tools/clang/tools/extra/clangd/index/dex/dexp/Dexp.cpp 260 {"find", "Search for symbols with fuzzyFind", std::make_unique<FuzzyFind>},
262 std::make_unique<Lookup>},
264 std::make_unique<Refs>},
tools/clang/tools/extra/clangd/indexer/IndexerMain.cpp 122 std::make_unique<clang::clangd::IndexActionFactory>(Data),
tools/clang/tools/extra/clangd/refactor/tweaks/ExtractVariable.cpp 456 Target = std::make_unique<ExtractionContext>(N, SM, Ctx);
tools/clang/tools/extra/clangd/tool/ClangdMain.cpp 588 StaticIdx.reset(Placeholder = new SwapIndex(std::make_unique<MemIndex>()));
644 ClangTidyOptProvider = std::make_unique<tidy::FileOptionsProvider>(
tools/clang/tools/extra/clangd/unittests/BackgroundIndexTests.cpp 77 return std::make_unique<IndexFileIn>(std::move(*IndexFile));
577 : Target(std::make_unique<MemIndex>()),
590 Source.update("", std::make_unique<SymbolSlab>(std::move(SB).build()),
tools/clang/tools/extra/clangd/unittests/ContextTests.cpp 29 Context Ctx = Context::empty().derive(Param, std::make_unique<int>(10));
tools/clang/tools/extra/clangd/unittests/FileIndexTests.cpp 71 return std::make_unique<SymbolSlab>(std::move(Slab).build());
80 return std::make_unique<RefSlab>(std::move(Slab).build());
110 return std::make_unique<SymbolSlab>(std::move(S).build());
tools/clang/tools/extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp 85 OverlayCDBTest() : Base(std::make_unique<BaseCDB>()) {}
tools/clang/tools/extra/clangd/unittests/IndexTests.cpp 116 SwapIndex S(std::make_unique<MemIndex>(SymbolSlab(), RefSlab(),
120 S.reset(std::make_unique<MemIndex>()); // Now the MemIndex is destroyed.
tools/clang/tools/extra/clangd/unittests/SymbolCollectorTests.cpp 236 return std::make_unique<IndexAction>(Collector, std::move(IndexOpts),
262 auto Factory = std::make_unique<SymbolIndexActionFactory>(
tools/clang/tools/extra/clangd/unittests/TUSchedulerTests.cpp 93 return std::make_unique<CaptureDiags>();
tools/clang/tools/extra/clangd/unittests/TestTU.cpp 90 auto Idx = std::make_unique<FileIndex>(/*UseDex=*/true);
tools/clang/tools/extra/modularize/CoverageChecker.cpp 109 PP.addPPCallbacks(std::make_unique<CoverageCheckerCallbacks>(Checker));
120 return std::make_unique<CoverageCheckerConsumer>(Checker,
134 return std::make_unique<CoverageCheckerAction>(Checker);
158 return std::make_unique<CoverageChecker>(ModuleMapPath, IncludePaths,
tools/clang/tools/extra/modularize/Modularize.cpp 708 return std::make_unique<CollectEntitiesConsumer>(
727 return std::make_unique<CollectEntitiesAction>(Entities, PPTracker,
799 return std::make_unique<CompileCheckConsumer>();
808 return std::make_unique<CompileCheckAction>();
tools/clang/tools/extra/modularize/PreprocessorTracker.cpp 817 PP.addPPCallbacks(std::make_unique<PreprocessorCallbacks>(*this, PP,
tools/clang/tools/extra/pp-trace/PPTrace.cpp 89 std::make_unique<PPCallbacksTracker>(Filters, CallbackCalls, PP));
90 return std::make_unique<ASTConsumer>();
117 return std::make_unique<PPTraceAction>(Filters, OS);
tools/clang/tools/extra/unittests/clang-doc/BitcodeTest.cpp 172 Top.Children.emplace_back(std::make_unique<CommentInfo>());
175 BlankLine->Children.emplace_back(std::make_unique<CommentInfo>());
178 Top.Children.emplace_back(std::make_unique<CommentInfo>());
181 Brief->Children.emplace_back(std::make_unique<CommentInfo>());
186 Top.Children.emplace_back(std::make_unique<CommentInfo>());
189 Extended->Children.emplace_back(std::make_unique<CommentInfo>());
192 Extended->Children.emplace_back(std::make_unique<CommentInfo>());
196 Top.Children.emplace_back(std::make_unique<CommentInfo>());
199 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
201 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
206 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
209 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
212 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
217 Top.Children.emplace_back(std::make_unique<CommentInfo>());
222 Verbatim->Children.emplace_back(std::make_unique<CommentInfo>());
226 Top.Children.emplace_back(std::make_unique<CommentInfo>());
232 ParamOut->Children.emplace_back(std::make_unique<CommentInfo>());
235 std::make_unique<CommentInfo>());
238 std::make_unique<CommentInfo>());
242 Top.Children.emplace_back(std::make_unique<CommentInfo>());
247 ParamIn->Children.emplace_back(std::make_unique<CommentInfo>());
250 std::make_unique<CommentInfo>());
254 std::make_unique<CommentInfo>());
257 Top.Children.emplace_back(std::make_unique<CommentInfo>());
262 Return->Children.emplace_back(std::make_unique<CommentInfo>());
265 std::make_unique<CommentInfo>());
tools/clang/tools/extra/unittests/clang-doc/GeneratorTest.cpp 20 auto InfoA = std::make_unique<Info>();
24 auto InfoC = std::make_unique<Info>();
31 auto InfoD = std::make_unique<Info>();
34 auto InfoF = std::make_unique<Info>();
43 auto InfoG = std::make_unique<Info>(InfoType::IT_namespace);
tools/clang/tools/extra/unittests/clang-doc/HTMLGeneratorTest.cpp 381 Top.Children.emplace_back(std::make_unique<CommentInfo>());
384 BlankLine->Children.emplace_back(std::make_unique<CommentInfo>());
387 Top.Children.emplace_back(std::make_unique<CommentInfo>());
390 Brief->Children.emplace_back(std::make_unique<CommentInfo>());
395 Top.Children.emplace_back(std::make_unique<CommentInfo>());
398 Extended->Children.emplace_back(std::make_unique<CommentInfo>());
401 Extended->Children.emplace_back(std::make_unique<CommentInfo>());
405 Top.Children.emplace_back(std::make_unique<CommentInfo>());
408 Entities->Children.emplace_back(std::make_unique<CommentInfo>());
tools/clang/tools/extra/unittests/clang-doc/MDGeneratorTest.cpp 224 Top.Children.emplace_back(std::make_unique<CommentInfo>());
227 BlankLine->Children.emplace_back(std::make_unique<CommentInfo>());
230 Top.Children.emplace_back(std::make_unique<CommentInfo>());
233 Brief->Children.emplace_back(std::make_unique<CommentInfo>());
238 Top.Children.emplace_back(std::make_unique<CommentInfo>());
241 Extended->Children.emplace_back(std::make_unique<CommentInfo>());
244 Extended->Children.emplace_back(std::make_unique<CommentInfo>());
248 Top.Children.emplace_back(std::make_unique<CommentInfo>());
251 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
253 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
258 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
261 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
264 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
269 Top.Children.emplace_back(std::make_unique<CommentInfo>());
274 Verbatim->Children.emplace_back(std::make_unique<CommentInfo>());
278 Top.Children.emplace_back(std::make_unique<CommentInfo>());
284 ParamOut->Children.emplace_back(std::make_unique<CommentInfo>());
287 std::make_unique<CommentInfo>());
290 std::make_unique<CommentInfo>());
294 Top.Children.emplace_back(std::make_unique<CommentInfo>());
299 ParamIn->Children.emplace_back(std::make_unique<CommentInfo>());
302 std::make_unique<CommentInfo>());
306 std::make_unique<CommentInfo>());
309 Top.Children.emplace_back(std::make_unique<CommentInfo>());
314 Return->Children.emplace_back(std::make_unique<CommentInfo>());
317 std::make_unique<CommentInfo>());
tools/clang/tools/extra/unittests/clang-doc/MergeTest.cpp 46 Infos.emplace_back(std::make_unique<NamespaceInfo>(std::move(One)));
47 Infos.emplace_back(std::make_unique<NamespaceInfo>(std::move(Two)));
49 auto Expected = std::make_unique<NamespaceInfo>();
117 Infos.emplace_back(std::make_unique<RecordInfo>(std::move(One)));
118 Infos.emplace_back(std::make_unique<RecordInfo>(std::move(Two)));
120 auto Expected = std::make_unique<RecordInfo>();
167 auto OneParagraphComment = std::make_unique<CommentInfo>();
169 auto OneTextComment = std::make_unique<CommentInfo>();
187 auto TwoParagraphComment = std::make_unique<CommentInfo>();
189 auto TwoTextComment = std::make_unique<CommentInfo>();
196 Infos.emplace_back(std::make_unique<FunctionInfo>(std::move(One)));
197 Infos.emplace_back(std::make_unique<FunctionInfo>(std::move(Two)));
199 auto Expected = std::make_unique<FunctionInfo>();
214 auto ExpectedParagraphComment = std::make_unique<CommentInfo>();
216 auto ExpectedTextComment = std::make_unique<CommentInfo>();
248 Infos.emplace_back(std::make_unique<EnumInfo>(std::move(One)));
249 Infos.emplace_back(std::make_unique<EnumInfo>(std::move(Two)));
251 auto Expected = std::make_unique<EnumInfo>();
tools/clang/tools/extra/unittests/clang-doc/YAMLGeneratorTest.cpp 278 Top.Children.emplace_back(std::make_unique<CommentInfo>());
281 BlankLine->Children.emplace_back(std::make_unique<CommentInfo>());
284 Top.Children.emplace_back(std::make_unique<CommentInfo>());
287 Brief->Children.emplace_back(std::make_unique<CommentInfo>());
292 Top.Children.emplace_back(std::make_unique<CommentInfo>());
295 Extended->Children.emplace_back(std::make_unique<CommentInfo>());
298 Extended->Children.emplace_back(std::make_unique<CommentInfo>());
302 Top.Children.emplace_back(std::make_unique<CommentInfo>());
305 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
307 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
312 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
315 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
318 HTML->Children.emplace_back(std::make_unique<CommentInfo>());
323 Top.Children.emplace_back(std::make_unique<CommentInfo>());
328 Verbatim->Children.emplace_back(std::make_unique<CommentInfo>());
332 Top.Children.emplace_back(std::make_unique<CommentInfo>());
338 ParamOut->Children.emplace_back(std::make_unique<CommentInfo>());
341 std::make_unique<CommentInfo>());
344 std::make_unique<CommentInfo>());
348 Top.Children.emplace_back(std::make_unique<CommentInfo>());
353 ParamIn->Children.emplace_back(std::make_unique<CommentInfo>());
356 std::make_unique<CommentInfo>());
360 std::make_unique<CommentInfo>());
363 Top.Children.emplace_back(std::make_unique<CommentInfo>());
368 Return->Children.emplace_back(std::make_unique<CommentInfo>());
371 std::make_unique<CommentInfo>());
tools/clang/tools/extra/unittests/clang-include-fixer/IncludeFixerTest.cpp 95 auto SymbolIndexMgr = std::make_unique<SymbolIndexManager>();
97 [=]() { return std::make_unique<InMemorySymbolIndex>(Symbols); });
tools/clang/tools/extra/unittests/clang-move/ClangMoveTests.cpp 230 auto Factory = std::make_unique<clang::move::ClangMoveActionFactory>(
tools/clang/tools/extra/unittests/clang-tidy/ClangTidyTest.h 43 Result.emplace_back(std::make_unique<Check>(
91 ClangTidyContext Context(std::make_unique<DefaultOptionsProvider>(
121 std::make_unique<TestClangTidyAction<CheckTypes...>>(Checks, Finder,
tools/clang/tools/extra/unittests/clang-tidy/IncludeInserterTest.cpp 36 Inserter = std::make_unique<utils::IncludeInserter>(
tools/clang/tools/libclang/CIndex.cpp 3810 auto result = std::make_unique<ExprEvalResult>();
tools/clang/tools/libclang/CIndexDiagnostic.cpp 104 auto Owner = std::make_unique<CXStoredDiagnostic>(*SD, LangOpts);
125 std::make_unique<CXDiagnosticCustomNoteImpl>(Message, L));
143 std::make_unique<CXDiagnosticCustomNoteImpl>(Message, L));
tools/clang/tools/libclang/CXLoadedDiagnostic.cpp 250 TopDiags = std::make_unique<CXLoadedDiagnosticSetImpl>();
309 CurrentDiags.push_back(std::make_unique<CXLoadedDiagnostic>());
tools/clang/tools/libclang/Indexing.cpp 359 PP.addPPCallbacks(std::make_unique<IndexPPCallbacks>(PP, *DataConsumer));
366 std::make_unique<ParsedSrcLocationsTracker>(*SKData, *PPRec, PP);
370 Consumers.push_back(std::make_unique<IndexingConsumer>(
375 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
434 std::make_unique<ThreadSafeParsedRegions>();
576 auto IndexAction = std::make_unique<IndexingFrontendAction>(
tools/clang/unittests/AST/EvaluateAsRValueTest.cpp 62 return std::make_unique<Consumer>();
92 std::make_unique<EvaluateConstantInitializersAction>(),
tools/clang/unittests/AST/ExternalASTSourceTest.cpp 40 return std::make_unique<ASTConsumer>();
tools/clang/unittests/AST/RecursiveASTVisitorTest.cpp 45 return std::make_unique<Consumer>(Process);
87 std::make_unique<ProcessASTAction>(
tools/clang/unittests/ASTMatchers/ASTMatchersInternalTest.cpp 58 HasClassB, std::make_unique<VerifyIdIsBoundTo<Decl>>("b")));
61 HasClassB, std::make_unique<VerifyIdIsBoundTo<Decl>>("a")));
64 HasClassB, std::make_unique<VerifyIdIsBoundTo<Decl>>("b")));
81 HasClassB, std::make_unique<VerifyIdIsBoundTo<Decl>>("b")));
84 HasClassB, std::make_unique<VerifyIdIsBoundTo<Decl>>("a")));
87 HasClassB, std::make_unique<VerifyIdIsBoundTo<Decl>>("b")));
tools/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp 691 ClassX, std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x")));
694 ClassX, std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("other-id")));
701 std::make_unique<VerifyIdIsBoundTo<Decl>>("b")));
708 std::make_unique<VerifyIdIsBoundTo<CXXMemberCallExpr>>("x")));
725 std::make_unique<VerifyIdIsBoundTo<CallExpr>>("x")));
737 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 2)));
787 std::make_unique<VerifyIdIsBoundTo<CXXOperatorCallExpr>>("x", 2)));
1820 std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 2)));
1828 std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 1)));
1833 std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 1)));
2340 std::make_unique<VerifyIdIsBoundTo<VarDecl>>("decl", 2)));
2353 std::make_unique<VerifyIdIsBoundTo<VarDecl>>("d", 5)));
2370 std::make_unique<VerifyIdIsBoundTo<Expr>>("data", 1)));
tools/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp 1579 std::make_unique<VerifyAncestorHasChildIsEqual<CXXRecordDecl>>()));
1582 std::make_unique<VerifyAncestorHasChildIsEqual<IfStmt>>()));
1586 std::make_unique<VerifyAncestorHasChildIsEqual<Type>>()));
tools/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp 83 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 3)));
98 std::make_unique<VerifyIdIsBoundTo<Type>>("x", 2)));
110 std::make_unique<VerifyIdIsBoundTo<QualType>>("x", 2)));
645 CallExpr, std::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 1)));
657 CallExpr2, std::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 1)));
669 std::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>(
673 std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>(
678 std::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 2)));
681 std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("arg", 2)));
698 std::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param")));
715 std::make_unique<VerifyIdIsBoundTo<VarDecl>>("v", 4)));
1820 std::make_unique<VerifyIdIsBoundTo<CaseStmt>>("x", 3)));
1897 std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("x", 1)));
1903 std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 3)));
1911 std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 4)));
1918 std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("x", 1)));
1927 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", "C")));
1935 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", "C")));
1943 std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 4)));
1952 std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 8)));
1961 std::make_unique<VerifyIdIsBoundTo<IfStmt>>("if", 6)));
1967 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1995 std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x", 1)));
1999 std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x", 1)));
2005 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
2009 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
2015 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
2019 std::make_unique<VerifyIdIsBoundTo<Expr>>("x", 1)));
2023 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
2028 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
2034 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
2038 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
2043 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
2047 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
2054 std::make_unique<VerifyIdIsBoundTo<Stmt>>("x", 2)));
2058 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
2063 std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
2070 std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("decl", 1)));
2074 std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("decl", 1)));
2081 std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("v", 1)));
2088 std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 2)));
2097 std::make_unique<VerifyIdIsBoundTo<Decl>>("v", 3)));
2102 std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("v", 3)));
2140 std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("r", 1)));
2152 std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("d", "E")));
2166 std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("f", "g", 2)));
2303 stmt().bind("node"), std::make_unique<HasDuplicateParents>()));
2365 std::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>(
2373 std::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("loc", 1)));
2402 std::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>("x", 1)));
2418 std::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>("x", 3)));
2445 std::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("x", 1)));
2461 std::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("x", 3)));
2486 std::make_unique<VerifyMatchOnNode<Decl>>(
2491 std::make_unique<VerifyMatchOnNode<Decl>>(
2499 std::make_unique<VerifyMatchOnNode<Stmt>>(
2503 std::make_unique<VerifyMatchOnNode<Stmt>>(
2510 std::make_unique<VerifyMatchOnNode<Decl>>(
2514 std::make_unique<VerifyMatchOnNode<Decl>>(
2572 std::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("override", "f", 1)));
2575 std::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("overridden", "f",
2580 std::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("override", "f", 1)));
2583 std::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("overridden", "f",
2595 std::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("override", "f", 2)));
2598 std::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("overridden", "f",
tools/clang/unittests/ASTMatchers/Dynamic/ParserTest.cpp 391 std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("parmABinding")));
394 std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("parmABinding")));
407 std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("parmABinding")));
410 std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("parmABinding")));
tools/clang/unittests/Basic/FileManagerTest.cpp 113 manager.setStatCache(std::make_unique<FakeStatCache>());
123 manager.setStatCache(std::make_unique<FakeStatCache>());
140 auto statCache = std::make_unique<FakeStatCache>();
175 manager.setStatCache(std::make_unique<FakeStatCache>());
193 auto statCache = std::make_unique<FakeStatCache>();
212 auto statCache = std::make_unique<FakeStatCache>();
241 auto statCache = std::make_unique<FakeStatCache>();
258 auto statCache = std::make_unique<FakeStatCache>();
280 auto statCache = std::make_unique<FakeStatCache>();
351 auto statCache = std::make_unique<FakeStatCache>();
384 auto statCache = std::make_unique<FakeStatCache>();
417 auto Cache = std::make_unique<FakeStatCache>();
tools/clang/unittests/Basic/SourceManagerTest.cpp 398 PP.addPPCallbacks(std::make_unique<MacroTracker>(Macros));
tools/clang/unittests/CrossTU/CrossTranslationUnitTest.cpp 125 return std::make_unique<CTUASTConsumer>(CI, Success);
137 EXPECT_TRUE(tooling::runToolOnCode(std::make_unique<CTUAction>(&Success, 1u),
144 EXPECT_TRUE(tooling::runToolOnCode(std::make_unique<CTUAction>(&Success, 0u),
tools/clang/unittests/Frontend/ASTUnitTest.cpp 37 input_file = std::make_unique<ToolOutputFile>(InputFileName, FD);
tools/clang/unittests/Frontend/CompilerInstanceTest.cpp 84 auto DiagPrinter = std::make_unique<TextDiagnosticPrinter>(
tools/clang/unittests/Frontend/FrontendActionTest.cpp 51 return std::make_unique<Visitor>(CI, ActOnEndOfTranslationUnit,
tools/clang/unittests/Frontend/OutputStreamTest.cpp 61 Compiler.setOutputStream(std::make_unique<raw_null_ostream>());
88 std::make_unique<raw_string_ostream>(VerboseBuffer);
90 Compiler.setOutputStream(std::make_unique<raw_null_ostream>());
tools/clang/unittests/Index/IndexTests.cpp 137 return std::make_unique<Consumer>(Index, CI.getPreprocessorPtr(), Opts);
158 tooling::runToolOnCode(std::make_unique<IndexAction>(Index),
168 tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
173 tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
183 tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
188 tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
205 tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
226 tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
242 tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
250 tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
265 tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
279 tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
tools/clang/unittests/Lex/LexerTest.cpp 56 std::unique_ptr<Preprocessor> PP = std::make_unique<Preprocessor>(
tools/clang/unittests/Sema/CodeCompleteTest.cpp 105 std::make_unique<CodeCompleteAction>(offsetToPosition(Code, Offset),
tools/clang/unittests/Sema/ExternalSemaSourceTest.cpp 190 return std::make_unique<clang::ASTConsumer>();
223 auto Installer = std::make_unique<ExternalSemaSourceInstaller>();
235 auto Installer = std::make_unique<ExternalSemaSourceInstaller>();
250 auto Installer = std::make_unique<ExternalSemaSourceInstaller>();
269 auto Installer = std::make_unique<ExternalSemaSourceInstaller>();
285 auto Installer = std::make_unique<ExternalSemaSourceInstaller>();
301 auto Installer = std::make_unique<ExternalSemaSourceInstaller>();
tools/clang/unittests/StaticAnalyzer/CallDescriptionTest.cpp 96 return std::make_unique<CallDescriptionConsumer>(Compiler, RM);
tools/clang/unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp 61 return tooling::runToolOnCode(std::make_unique<TestAction<CheckerT>>(OS),
tools/clang/unittests/StaticAnalyzer/StoreTest.cpp 94 return std::make_unique<VariableBindConsumer>(Compiler);
99 EXPECT_TRUE(tooling::runToolOnCode(std::make_unique<VariableBindAction>(),
tools/clang/unittests/StaticAnalyzer/SymbolReaperTest.cpp 58 return std::make_unique<SuperRegionLivenessConsumer>(Compiler);
65 tooling::runToolOnCode(std::make_unique<SuperRegionLivenessAction>(),
tools/clang/unittests/Tooling/CommentHandlerTest.cpp 59 return std::make_unique<CommentHandlerAction>(this);
tools/clang/unittests/Tooling/CompilationDatabaseTest.cpp 697 inferMissingCompileCommands(std::make_unique<MemCDB>(Entries))
711 inferMissingCompileCommands(std::make_unique<MemCDB>(Entries))
844 auto Results = inferTargetAndDriverMode(std::make_unique<MemCDB>(Entries))
tools/clang/unittests/Tooling/DependencyScannerTest.cpp 68 auto Action = std::make_unique<PreprocessOnlyAction>();
tools/clang/unittests/Tooling/ExecutionTest.cpp 82 return std::make_unique<ReportResultAction>(Context);
130 return std::make_unique<TestToolExecutor>(std::move(OptionsParser));
tools/clang/unittests/Tooling/RefactoringTest.cpp 653 return runToolOnCode(std::make_unique<TestAction>(this), Code);
683 return std::make_unique<FindConsumer>(Visitor);
tools/clang/unittests/Tooling/Syntax/TokensTest.cpp 109 return std::make_unique<ASTConsumer>();
tools/clang/unittests/Tooling/Syntax/TreeTest.cpp 43 Arena = std::make_unique<syntax::Arena>(Ctx.getSourceManager(),
66 std::make_unique<syntax::TokenCollector>(CI.getPreprocessor());
67 return std::make_unique<BuildSyntaxTree>(Root, Arena,
tools/clang/unittests/Tooling/TestVisitor.h 89 return std::make_unique<TestAction>(this);
112 return std::make_unique<FindConsumer>(Visitor);
tools/clang/unittests/Tooling/ToolingTest.cpp 66 std::make_unique<TestAction>(
67 std::make_unique<FindTopLevelDeclConsumer>(&FoundTopLevelDecl)),
106 std::make_unique<TestAction>(
107 std::make_unique<FindClassDeclXConsumer>(&FoundClassDeclX)),
113 std::make_unique<TestAction>(
114 std::make_unique<FindClassDeclXConsumer>(&FoundClassDeclX)),
138 return std::make_unique<FindTopLevelDeclConsumer>(nullptr);
164 Args, std::make_unique<SyntaxOnlyAction>(), Files.get());
190 Args, std::make_unique<SyntaxOnlyAction>(), Files.get());
210 return std::make_unique<FindTopLevelDeclConsumer>(&Matched);
252 return std::make_unique<SkipBodyConsumer>();
260 EXPECT_TRUE(runToolOnCode(std::make_unique<SkipBodyAction>(),
262 EXPECT_FALSE(runToolOnCode(std::make_unique<SkipBodyAction>(),
267 std::make_unique<SkipBodyAction>(),
270 std::make_unique<SkipBodyAction>(), "struct skipMe { skipMe(); };"
274 std::make_unique<SkipBodyAction>(), "struct skipMe { skipMe(); };"
278 std::make_unique<SkipBodyAction>(),
283 std::make_unique<SkipBodyAction>(), "struct skipMe { skipMe() : bases()... { error } };",
287 std::make_unique<SkipBodyAction>(), "struct skipMeNot { skipMeNot() : an_error() { } };",
289 EXPECT_FALSE(runToolOnCodeWithArgs(std::make_unique<SkipBodyAction>(),
296 std::make_unique<SkipBodyAction>(),
299 std::make_unique<SkipBodyAction>(),
302 runToolOnCode(std::make_unique<SkipBodyAction>(),
306 std::make_unique<SkipBodyAction>(),
311 std::make_unique<SkipBodyAction>(), "template<typename T> int skipMe() { an_error_here }"
314 std::make_unique<SkipBodyAction>(),
328 EXPECT_TRUE(runToolOnCodeWithArgs(std::make_unique<SkipBodyAction>(), "", Args));
343 return std::make_unique<ASTConsumer>();
352 std::make_unique<CheckColoredDiagnosticsAction>(true), "",
355 std::make_unique<CheckColoredDiagnosticsAction>(false), "",
358 std::make_unique<CheckColoredDiagnosticsAction>(true), "",
361 std::make_unique<CheckColoredDiagnosticsAction>(false), "",
364 std::make_unique<CheckColoredDiagnosticsAction>(true), "",
369 std::make_unique<CheckColoredDiagnosticsAction>(false), "",
656 return std::make_unique<Consumer>();
662 runToolOnCode(std::make_unique<ResetDiagnosticAction>(),
tools/clang/utils/TableGen/ClangAttrEmitter.cpp 1261 Ptr = std::make_unique<AlignedArgument>(Arg, Attr);
1263 Ptr = std::make_unique<EnumArgument>(Arg, Attr);
1265 Ptr = std::make_unique<ExprArgument>(Arg, Attr);
1267 Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "FunctionDecl *");
1269 Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "NamedDecl *");
1271 Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "IdentifierInfo *");
1273 Ptr = std::make_unique<DefaultSimpleArgument>(
1276 Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "bool");
1278 Ptr = std::make_unique<DefaultSimpleArgument>(
1281 Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "int");
1283 Ptr = std::make_unique<StringArgument>(Arg, Attr);
1285 Ptr = std::make_unique<TypeArgument>(Arg, Attr);
1287 Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "unsigned");
1289 Ptr = std::make_unique<VariadicArgument>(Arg, Attr, "unsigned");
1291 Ptr = std::make_unique<VariadicStringArgument>(Arg, Attr);
1293 Ptr = std::make_unique<VariadicEnumArgument>(Arg, Attr);
1295 Ptr = std::make_unique<VariadicExprArgument>(Arg, Attr);
1297 Ptr = std::make_unique<VariadicParamIdxArgument>(Arg, Attr);
1299 Ptr = std::make_unique<VariadicParamOrParamIdxArgument>(Arg, Attr);
1301 Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "ParamIdx");
1303 Ptr = std::make_unique<VariadicIdentifierArgument>(Arg, Attr);
1305 Ptr = std::make_unique<VersionArgument>(Arg, Attr);
tools/clang/utils/TableGen/MveEmitter.cpp 857 VectorTypes[key] = std::make_unique<VectorType>(ST);
864 MultiVectorTypes[key] = std::make_unique<MultiVectorType>(Registers, VT);
870 PredicateTypes[key] = std::make_unique<PredicateType>(Lanes);
877 PointerTypes[key] = std::make_unique<PointerType>(PT);
1217 ScalarTypes[R->getName()] = std::make_unique<ScalarType>(R);
1224 auto Intrinsic = std::make_unique<ACLEIntrinsic>(*this, R, Param);
tools/clang/utils/TableGen/NeonEmitter.cpp 1754 ST.addOperator("lowhalf", std::make_unique<LowHalf>());
1755 ST.addOperator("highhalf", std::make_unique<HighHalf>());
1757 std::make_unique<Rev>(Arg1.first.getElementSizeInBits()));
1759 std::make_unique<MaskExpander>(Arg1.first.getNumElements()));
tools/dsymutil/DwarfLinker.cpp 242 Streamer = std::make_unique<DwarfStreamer>(OutFile, Options);
1004 std::make_unique<DIEAbbrev>(Abbrev.getTag(), Abbrev.hasChildren()));
2330 Unit = std::make_unique<CompileUnit>(*CU, UnitID++, !Options.NoODR,
2717 LinkContext.CompileUnits.push_back(std::make_unique<CompileUnit>(
tools/dsymutil/DwarfStreamer.cpp 94 *MC, std::make_unique<formatted_raw_ostream>(OutFile), true, true, MIP,
tools/dsymutil/MachODebugMapParser.cpp 192 Result = std::make_unique<DebugMap>(MainBinary.getArchTriple(), BinaryPath, UUID);
tools/dsymutil/MachOUtils.cpp 38 File = std::make_unique<sys::fs::TempFile>(std::move(*T));
tools/gold/gold-plugin.cpp 84 File = std::make_unique<ld_plugin_input_file>();
927 return std::make_unique<LTO>(std::move(Conf), Backend,
977 auto LinkedObjectsFile = std::make_unique<raw_fd_ostream>(
1014 F.leader_handle, std::make_unique<PluginInputFile>(F.handle)));
1049 return std::make_unique<lto::NativeObjectStream>(
1050 std::make_unique<llvm::raw_fd_ostream>(FD, true));
tools/llc/llc.cpp 245 auto FDOut = std::make_unique<ToolOutputFile>(OutputFilename, EC, OpenFlags);
332 std::make_unique<LLCDiagnosticHandler>(&HasError));
482 DwoOut = std::make_unique<ToolOutputFile>(SplitDwarfOutputFile, EC,
536 BOS = std::make_unique<raw_svector_ostream>(Buffer);
tools/lld/COFF/LTO.cpp 49 std::make_unique<raw_fd_ostream>(file, ec, sys::fs::OpenFlags::OF_None);
108 ltoObj = std::make_unique<lto::LTO>(createConfig(), backend,
163 return std::make_unique<lto::NativeObjectStream>(
164 std::make_unique<raw_svector_ostream>(buf[task]));
tools/lld/COFF/PDB.cpp 1144 auto newChecksums = std::make_unique<DebugChecksumsSubsection>(linker.pdbStrTab);
tools/lld/ELF/InputFiles.cpp 267 dwarf = make<DWARFCache>(std::make_unique<DWARFContext>(
268 std::make_unique<LLDDwarfObj<ELFT>>(this)));
tools/lld/ELF/LTO.cpp 53 std::make_unique<raw_fd_ostream>(file, ec, sys::fs::OpenFlags::OF_None);
144 ltoObj = std::make_unique<lto::LTO>(createConfig(), backend,
254 return std::make_unique<lto::NativeObjectStream>(
255 std::make_unique<raw_svector_ostream>(buf[task]));
tools/lld/ELF/LinkerScript.cpp 1095 auto deleter = std::make_unique<AddressState>();
tools/lld/ELF/SyntheticSections.cpp 2719 DWARFContext dwarf(std::make_unique<LLDDwarfObj<ELFT>>(file));
tools/lld/include/lld/ReaderWriter/MachOLinkingContext.h 104 ctx->getNodes().push_back(std::make_unique<FileNode>(std::move(file)));
tools/lld/lib/Driver/DarwinLdDriver.cpp 98 result.push_back(std::make_unique<ErrorFile>(path, ec));
163 ctx.getNodes().push_back(std::make_unique<FileNode>(std::move(file)));
1141 members.insert(members.begin(), std::make_unique<FileNode>(std::move(*i)));
1188 std::make_unique<FileNode>(std::move(mergedFile)));
tools/lld/lib/ReaderWriter/FileArchive.cpp 213 std::make_unique<FileArchive>(std::move(mb), reg, path, _logLoading);
tools/lld/lib/ReaderWriter/MachO/CompactUnwindPass.cpp 576 pm.add(std::make_unique<CompactUnwindPass>(ctx));
tools/lld/lib/ReaderWriter/MachO/GOTPass.cpp 179 pm.add(std::make_unique<GOTPass>(ctx));
tools/lld/lib/ReaderWriter/MachO/LayoutPass.cpp 481 pm.add(std::make_unique<LayoutPass>(
tools/lld/lib/ReaderWriter/MachO/MachOLinkingContext.cpp 805 auto sectCreateFile = std::make_unique<mach_o::SectCreateFile>();
807 getNodes().push_back(std::make_unique<FileNode>(std::move(sectCreateFile)));
1022 elements.push_back(std::make_unique<GroupEnd>(numLibs));
tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileBinaryReader.cpp 545 std::make_unique<MachOFile>(std::move(mb), &_ctx);
571 std::make_unique<MachODylibFile>(std::move(mb), &_ctx);
tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp 720 allocator = std::make_unique<BumpPtrAllocator>();
815 file.setDebugInfo(std::make_unique<StabsDebugInfo>(std::move(stabsList)));
977 allocator = std::make_unique<BumpPtrAllocator>();
981 file.setDebugInfo(std::make_unique<DwarfDebugInfo>(std::move(*tuOrErr)));
tools/lld/lib/ReaderWriter/MachO/ObjCPass.cpp 127 pm.add(std::make_unique<ObjCPass>(ctx));
tools/lld/lib/ReaderWriter/MachO/ShimPass.cpp 124 pm.add(std::make_unique<ShimPass>(ctx));
tools/lld/lib/ReaderWriter/MachO/TLVPass.cpp 136 pm.add(std::make_unique<TLVPass>(ctx));
tools/lld/wasm/LTO.cpp 70 return std::make_unique<lto::LTO>(std::move(c), backend,
140 return std::make_unique<lto::NativeObjectStream>(
141 std::make_unique<raw_svector_ostream>(buf[task]));
tools/lldb/include/lldb/Expression/DiagnosticManager.h 113 std::make_unique<Diagnostic>(message, severity, origin, compiler_id));
tools/lldb/include/lldb/Utility/Reproducer.h 253 std::unique_ptr<ProviderBase> provider = std::make_unique<T>(m_root);
tools/lldb/include/lldb/Utility/ReproducerInstrumentation.h 457 DoRegister(uintptr_t(f), std::make_unique<DefaultReplayer<Signature>>(f),
467 DoRegister(uintptr_t(f), std::make_unique<DefaultReplayer<Signature>>(g),
tools/lldb/source/API/SBAddress.cpp 31 m_opaque_up = std::make_unique<Address>(*lldb_object_ptr);
tools/lldb/source/API/SBBreakpointOptionCommon.cpp 44 : TypedBaton(std::make_unique<CallbackData>()) {
tools/lldb/source/API/SBDebugger.cpp 161 std::make_unique<SystemInitializerFull>(), LoadPlugin)) {
659 auto entry_up = std::make_unique<StructuredData::Dictionary>();
666 auto array_up = std::make_unique<StructuredData::Array>();
670 auto entry_up = std::make_unique<StructuredData::Dictionary>();
680 auto config_up = std::make_unique<StructuredData::Dictionary>();
1077 auto platform_dict = std::make_unique<StructuredData::Dictionary>();
tools/lldb/source/API/SBDeclaration.cpp 35 m_opaque_up = std::make_unique<Declaration>(*lldb_object_ptr);
tools/lldb/source/API/SBFrame.cpp 1110 stack_trace = std::make_unique<llvm::PrettyStackTraceFormat>(
tools/lldb/source/API/SBLineEntry.cpp 35 m_opaque_up = std::make_unique<LineEntry>(*lldb_object_ptr);
48 m_opaque_up = std::make_unique<LineEntry>(lldb_object_ref);
tools/lldb/source/API/SBStream.cpp 100 m_opaque_up = std::make_unique<StreamFile>(std::move(file.get()));
112 FileSP file = std::make_unique<NativeFile>(fh, transfer_fh_ownership);
135 m_opaque_up = std::make_unique<StreamFile>(file_sp);
156 m_opaque_up = std::make_unique<StreamFile>(fd, transfer_fh_ownership);
tools/lldb/source/API/SBStringList.cpp 24 m_opaque_up = std::make_unique<StringList>(*lldb_strings_ptr);
tools/lldb/source/API/SBSymbolContext.cpp 30 m_opaque_up = std::make_unique<SymbolContext>(*sc_ptr);
54 m_opaque_up = std::make_unique<SymbolContext>(*sc_ptr);
tools/lldb/source/API/SBTarget.cpp 221 auto stats_up = std::make_unique<StructuredData::Dictionary>();
tools/lldb/source/API/Utils.h 19 return std::make_unique<T>(*src);
tools/lldb/source/Breakpoint/BreakpointOptions.cpp 312 auto bp_options = std::make_unique<BreakpointOptions>(
tools/lldb/source/Commands/CommandObjectBreakpoint.cpp 161 auto cmd_data = std::make_unique<BreakpointOptions::CommandData>();
tools/lldb/source/Commands/CommandObjectBreakpointCommand.cpp 247 auto cmd_data = std::make_unique<BreakpointOptions::CommandData>();
269 auto cmd_data = std::make_unique<BreakpointOptions::CommandData>();
tools/lldb/source/Commands/CommandObjectCommands.cpp 992 m_regex_cmd_up = std::make_unique<CommandObjectRegexCommand>(
tools/lldb/source/Commands/CommandObjectMemory.cpp 785 std::make_unique<StreamFile>(std::move(outfile.get()));
tools/lldb/source/Core/Debugger.cpp 285 auto bytes = std::make_unique<EventDataBytes>(new_prompt);
710 std::make_unique<CommandInterpreter>(*this, false)),
1216 m_source_manager_up = std::make_unique<SourceManager>(shared_from_this());
tools/lldb/source/Core/Module.cpp 295 auto data_up = std::make_unique<DataBufferHeap>(size_to_read, 0);
1277 m_sections_up = std::make_unique<SectionList>();
tools/lldb/source/Core/ValueObjectSyntheticFilter.cpp 143 m_synth_filter_up = std::make_unique<DummySyntheticFrontEnd>(*m_parent);
tools/lldb/source/Expression/IRExecutionUnit.cpp 319 m_object_cache_up = std::make_unique<ObjectDumper>();
tools/lldb/source/Host/common/Socket.cpp 118 std::make_unique<TCPSocket>(true, child_processes_inherit);
122 std::make_unique<UDPSocket>(true, child_processes_inherit);
127 std::make_unique<DomainSocket>(true, child_processes_inherit);
136 std::make_unique<AbstractSocket>(child_processes_inherit);
tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp 90 m_auxv = std::make_unique<AuxVector>(m_process->GetAuxvData());
182 m_auxv = std::make_unique<AuxVector>(m_process->GetAuxvData());
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp 134 std::make_unique<clang::ExternalASTMerger>(target, sources);
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h 359 m_parser_vars = std::make_unique<ParserVars>();
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp 211 auto new_diagnostic = std::make_unique<ClangDiagnostic>(
tools/lldb/source/Plugins/Language/ObjC/NSDictionary.h 71 MatcherUP GetFullMatch(ConstString n) { return std::make_unique<Full>(n); }
74 return std::make_unique<Prefix>(p);
tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp 4592 std::make_unique<StreamFile>(std::move(file.get()));
tools/lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp 130 m_sections_up = std::make_unique<SectionList>();
tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp 1764 m_sections_up = std::make_unique<SectionList>();
tools/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp 797 auto objfile_up = std::make_unique<ObjectFileMachO>(
tools/lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp 137 auto objfile_up = std::make_unique<ObjectFilePECOFF>(
154 auto objfile_up = std::make_unique<ObjectFilePECOFF>(
551 auto data_up = std::make_unique<DataBufferHeap>(size, 0);
775 return std::make_unique<PECallFrameInfo>(*this, data_dir_exception.vmaddr,
tools/lldb/source/Plugins/ObjectFile/PECOFF/PECallFrameInfo.cpp 370 std::unique_ptr<UnwindPlan::Row> row = std::make_unique<UnwindPlan::Row>();
tools/lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp 1594 m_threads.push_back(std::make_unique<NativeThreadLinux>(*this, thread_id));
tools/lldb/source/Plugins/Process/POSIX/NativeProcessELF.cpp 24 m_aux_vector = std::make_unique<AuxVector>(auxv_data);
tools/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp 58 m_symtab_up = std::make_unique<Symtab>(this);
86 m_sections_up = std::make_unique<SectionList>();
516 m_jit_loaders_up = std::make_unique<JITLoaderList>();
tools/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp 551 auto data_up = std::make_unique<CommandDataPython>();
578 auto data_up = std::make_unique<WatchpointOptions::CommandData>();
1297 auto data_up = std::make_unique<CommandDataPython>(extra_args_sp);
1320 auto data_up = std::make_unique<WatchpointOptions::CommandData>();
tools/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp 694 data.line_table_up = std::make_unique<LineTable>(&cu);
tools/lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp 24 auto apple_names_table_up = std::make_unique<DWARFMappedHash::MemoryTable>(
30 std::make_unique<DWARFMappedHash::MemoryTable>(
35 auto apple_types_table_up = std::make_unique<DWARFMappedHash::MemoryTable>(
40 auto apple_objc_table_up = std::make_unique<DWARFMappedHash::MemoryTable>(
47 return std::make_unique<AppleDWARFIndex>(
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp 1326 auto unique_ast_entry_up = std::make_unique<UniqueDWARFASTType>();
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp 41 m_cu_aranges_up = std::make_unique<DWARFDebugAranges>();
tools/lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp 27 auto index_up = std::make_unique<DebugNames>(debug_names.GetAsLLVM(),
tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp 474 m_index = std::make_unique<ManualDWARFIndex>(*GetObjectFile()->GetModule(),
612 auto abbr = std::make_unique<DWARFDebugAbbrev>();
635 m_info = std::make_unique<DWARFDebugInfo>(*this, m_context);
1001 std::make_unique<LineTable>(&comp_unit);
1590 return std::make_unique<SymbolFileDWARFDwo>(dwo_obj_file, *dwarf_cu);
tools/lldb/source/Plugins/SymbolFile/NativePDB/CompileUnitIndex.cpp 133 cci = std::make_unique<CompilandIndexItem>(PdbCompilandId{ modi }, debug_stream, std::move(descriptor));
142 cci = std::make_unique<CompilandIndexItem>(
tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp 93 auto Stream = std::make_unique<llvm::MemoryBufferByteStream>(
96 auto File = std::make_unique<PDBFile>(Path, std::move(Stream), Allocator);
335 m_ast = std::make_unique<PdbAstBuilder>(*m_objfile_sp, *m_index, *clang);
1070 auto line_table = std::make_unique<LineTable>(&comp_unit);
tools/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp 1777 auto line_table = std::make_unique<LineTable>(&comp_unit);
tools/lldb/source/Symbol/ClangASTContext.cpp 8321 return std::make_unique<clang::CXXBaseSpecifier>(
tools/lldb/source/Target/Platform.cpp 387 m_module_cache(std::make_unique<ModuleCache>()) {
tools/lldb/source/Utility/Reproducer.cpp 188 auto strm = std::make_unique<raw_fd_ostream>(index.GetPath(), EC,
237 auto recorder = std::make_unique<DataRecorder>(std::move(filename), ec);
299 m_stream_up = std::make_unique<raw_fd_ostream>(history_file.GetPath(), EC,
329 return std::make_unique<CommandLoader>(std::move(files));
tools/lldb/source/Utility/StructuredData.cpp 78 auto dict_up = std::make_unique<StructuredData::Dictionary>();
89 auto array_up = std::make_unique<StructuredData::Array>();
tools/lldb/tools/lldb-instr/Instrument.cpp 338 return std::make_unique<SBConsumer>(MyRewriter, CI.getASTContext());
351 PCHOpts->registerWriter(std::make_unique<ObjectFilePCHContainerWriter>());
352 PCHOpts->registerReader(std::make_unique<ObjectFilePCHContainerReader>());
tools/lldb/tools/lldb-server/lldb-server.cpp 43 std::make_unique<SystemInitializerLLGS>(), nullptr))
tools/lldb/tools/lldb-test/lldb-test.cpp 1073 std::make_unique<SystemInitializerTest>(), nullptr)) {
tools/lldb/unittests/Expression/DWARFExpressionTest.cpp 148 m_symfile_dwarf = std::make_unique<SymbolFileDWARF>(m_objfile_sp, nullptr);
tools/lldb/unittests/Expression/DiagnosticManagerTest.cpp 46 std::make_unique<Diagnostic>(msg, severity, origin, custom_diag_id);
62 mgr.AddDiagnostic(std::make_unique<FixItDiag>("no fixit", false));
65 mgr.AddDiagnostic(std::make_unique<FixItDiag>("fixit", true));
68 mgr.AddDiagnostic(std::make_unique<FixItDiag>("no fixit", false));
71 mgr.AddDiagnostic(std::make_unique<FixItDiag>("fixit", true));
83 std::make_unique<TextDiag>("abc", eDiagnosticSeverityError));
92 std::make_unique<TextDiag>("b\nc", eDiagnosticSeverityError));
99 std::make_unique<TextDiag>("abc", eDiagnosticSeverityError));
102 std::make_unique<TextDiag>("def", eDiagnosticSeverityError));
111 std::make_unique<TextDiag>("foo", eDiagnosticSeverityError));
113 std::make_unique<TextDiag>("bar", eDiagnosticSeverityWarning));
116 std::make_unique<TextDiag>("baz", eDiagnosticSeverityRemark));
125 std::make_unique<TextDiag>("baz", eDiagnosticSeverityRemark));
127 std::make_unique<TextDiag>("bar", eDiagnosticSeverityWarning));
129 std::make_unique<TextDiag>("foo", eDiagnosticSeverityError));
145 std::make_unique<TextDiag>("foo", eDiagnosticSeverityError));
147 std::make_unique<TextDiag>("bar", eDiagnosticSeverityError));
158 std::make_unique<TextDiag>("bar", eDiagnosticSeverityError));
162 std::make_unique<TextDiag>("foo", eDiagnosticSeverityError));
tools/lldb/unittests/Host/MainLoopTest.cpp 113 auto conn = std::make_unique<ConnectionFileDescriptor>(
tools/lldb/unittests/Process/minidump/RegisterContextMinidumpTest.cpp 56 auto RegInterface = std::make_unique<RegisterContextLinux_i386>(arch);
117 auto RegInterface = std::make_unique<RegisterContextLinux_x86_64>(arch);
tools/lldb/unittests/tools/lldb-server/tests/MessageObjects.cpp 322 return std::make_unique<StopReplyStop>(Signal, Thread, Name,
332 return std::make_unique<StopReplyExit>(Status);
tools/lldb/unittests/tools/lldb-server/tests/TestClient.cpp 114 auto Conn = std::make_unique<ConnectionFileDescriptor>(accept_socket);
tools/lli/lli.cpp 311 std::unique_ptr<Module> M = std::make_unique<Module>("CygMingHelper", Context);
747 orc::ThreadSafeContext TSCtx(std::make_unique<LLVMContext>());
965 return std::make_unique<FDRawChannel>(PipeFD[1][0], PipeFD[0][1]);
tools/llvm-cov/CodeCoverage.cpp 715 auto NameFilterer = std::make_unique<CoverageFilters>();
717 NameFilterer->push_back(std::make_unique<NameCoverageFilter>(Name));
720 std::make_unique<NameWhitelistCoverageFilter>(*NameWhitelist));
723 std::make_unique<NameRegexCoverageFilter>(Regex));
731 auto StatFilterer = std::make_unique<CoverageFilters>();
733 StatFilterer->push_back(std::make_unique<RegionCoverageFilter>(
736 StatFilterer->push_back(std::make_unique<RegionCoverageFilter>(
739 StatFilterer->push_back(std::make_unique<LineCoverageFilter>(
742 StatFilterer->push_back(std::make_unique<LineCoverageFilter>(
750 std::make_unique<NameRegexCoverageFilter>(RE));
1043 Exporter = std::make_unique<CoverageExporterJson>(*Coverage.get(),
1051 Exporter = std::make_unique<CoverageExporterLcov>(*Coverage.get(),
tools/llvm-cov/SourceCoverageView.cpp 79 return std::make_unique<CoveragePrinterText>(Opts);
81 return std::make_unique<CoveragePrinterHTML>(Opts);
144 return std::make_unique<SourceCoverageViewText>(
147 return std::make_unique<SourceCoverageViewHTML>(
tools/llvm-dis/llvm-dis.cpp 156 std::make_unique<LLVMDisDiagnosticHandler>(argv[0]));
tools/llvm-elfabi/ELFObjHandler.cpp 295 std::unique_ptr<ELFStub> DestStub = std::make_unique<ELFStub>();
tools/llvm-exegesis/lib/Analysis.cpp 176 Context_ = std::make_unique<MCContext>(AsmInfo_.get(), RegInfo_.get(),
tools/llvm-exegesis/lib/Assembler.cpp 152 auto Mod = std::make_unique<Module>(ModuleID, *Context);
158 std::unique_ptr<LLVMContext> Context = std::make_unique<LLVMContext>();
163 std::make_unique<MachineModuleInfoWrapperPass>(&LLVMTM);
175 auto Context = std::make_unique<LLVMContext>();
178 auto MMIWP = std::make_unique<MachineModuleInfoWrapperPass>(TM.get());
291 : Context(std::make_unique<LLVMContext>()) {
304 std::make_unique<TrackingSectionMemoryManager>(&CodeSize))
tools/llvm-exegesis/lib/BenchmarkRunner.cpp 30 : State(State), Mode(Mode), Scratch(std::make_unique<ScratchSpace>()) {}
tools/llvm-exegesis/lib/SnippetRepetitor.cpp 110 return std::make_unique<DuplicateSnippetRepetitor>(State);
112 return std::make_unique<LoopSnippetRepetitor>(State);
tools/llvm-exegesis/lib/Target.cpp 71 return std::make_unique<LatencySnippetGenerator>(State, Opts);
76 return std::make_unique<UopsSnippetGenerator>(State, Opts);
81 return std::make_unique<LatencyBenchmarkRunner>(State, Mode);
86 return std::make_unique<UopsBenchmarkRunner>(State);
tools/llvm-exegesis/lib/X86/Target.cpp 565 return std::make_unique<X86LatencySnippetGenerator>(State, Opts);
571 return std::make_unique<X86UopsSnippetGenerator>(State, Opts);
tools/llvm-isel-fuzzer/llvm-isel-fuzzer.cpp 62 return std::make_unique<IRMutator>(std::move(Types), std::move(Strategies));
tools/llvm-jitlink/llvm-jitlink.cpp 392 return std::make_unique<jitlink::InProcessMemoryManager>();
413 ObjLayer.addPlugin(std::make_unique<EHFrameRegistrationPlugin>(
416 ObjLayer.addPlugin(std::make_unique<JITLinkSessionPlugin>(*this));
804 ShowTimes ? std::make_unique<JITLinkTimers>() : nullptr;
tools/llvm-link/llvm-link.cpp 354 std::make_unique<LLVMLinkDiagnosticHandler>(), true);
360 auto Composite = std::make_unique<Module>("llvm-link", Context);
tools/llvm-lto/llvm-lto.cpp 318 std::unique_ptr<LLVMContext> Context = std::make_unique<LLVMContext>();
319 Context->setDiagnosticHandler(std::make_unique<LLVMLTODiagnosticHandler>(),
924 Context.setDiagnosticHandler(std::make_unique<LLVMLTODiagnosticHandler>(),
tools/llvm-lto2/llvm-lto2.cpp 336 auto S = std::make_unique<raw_fd_ostream>(Path, EC, sys::fs::OF_None);
338 return std::make_unique<lto::NativeObjectStream>(std::move(S));
tools/llvm-mc/llvm-mc.cpp 215 auto Out = std::make_unique<ToolOutputFile>(Path, EC, Flags);
466 auto FOut = std::make_unique<formatted_raw_ostream>(*OS);
481 BOS = std::make_unique<buffer_ostream>(Out->os());
tools/llvm-mca/CodeRegion.cpp 21 Regions.emplace_back(std::make_unique<CodeRegion>("", SMLoc()));
39 Regions[0] = std::make_unique<CodeRegion>(Description, Loc);
65 Regions.emplace_back(std::make_unique<CodeRegion>(Description, Loc));
tools/llvm-mca/llvm-mca.cpp 241 std::make_unique<ToolOutputFile>(OutputFilename, EC, sys::fs::OF_Text);
495 auto P = std::make_unique<mca::Pipeline>();
496 P->appendStage(std::make_unique<mca::EntryStage>(S));
497 P->appendStage(std::make_unique<mca::InstructionTables>(SM));
502 Printer.addView(std::make_unique<mca::InstructionInfoView>(
506 std::make_unique<mca::ResourcePressureView>(*STI, *IP, Insts));
521 std::make_unique<mca::SummaryView>(SM, Insts, DispatchWidth));
524 Printer.addView(std::make_unique<mca::BottleneckAnalysis>(
529 Printer.addView(std::make_unique<mca::InstructionInfoView>(
533 Printer.addView(std::make_unique<mca::DispatchStatistics>());
536 Printer.addView(std::make_unique<mca::SchedulerStatistics>(*STI));
539 Printer.addView(std::make_unique<mca::RetireControlUnitStatistics>(SM));
542 Printer.addView(std::make_unique<mca::RegisterFileStatistics>(*STI));
546 std::make_unique<mca::ResourcePressureView>(*STI, *IP, Insts));
551 Printer.addView(std::make_unique<mca::TimelineView>(
tools/llvm-objcopy/COFF/Reader.cpp 194 auto Obj = std::make_unique<Object>();
tools/llvm-objcopy/ELF/ELFObjcopy.cpp 139 return std::make_unique<ELFWriter<ELF32LE>>(Obj, Buf,
142 return std::make_unique<ELFWriter<ELF64LE>>(Obj, Buf,
145 return std::make_unique<ELFWriter<ELF32BE>>(Obj, Buf,
148 return std::make_unique<ELFWriter<ELF64BE>>(Obj, Buf,
159 return std::make_unique<BinaryWriter>(Obj, Buf);
161 return std::make_unique<IHexWriter>(Obj, Buf);
tools/llvm-objcopy/ELF/Object.cpp 668 Symbols.emplace_back(std::make_unique<Symbol>(Sym));
1665 auto Obj = std::make_unique<Object>();
2082 auto SecSizer = std::make_unique<ELFSectionSizer<ELFT>>();
2120 SecWriter = std::make_unique<ELFSectionWriter<ELFT>>(Buf);
2194 SecWriter = std::make_unique<BinarySectionWriter>(Buf);
tools/llvm-objcopy/ELF/Object.h 885 BasicELFBuilder() : Obj(std::make_unique<Object>()) {}
1056 auto Sec = std::make_unique<T>(std::forward<Ts>(Args)...);
1064 Segments.emplace_back(std::make_unique<Segment>(Data));
tools/llvm-objcopy/MachO/MachOReader.cpp 201 O.SymTable.Symbols.push_back(std::make_unique<SymbolEntry>(SE));
265 auto Obj = std::make_unique<Object>();
tools/llvm-objdump/MachODump.cpp10451 info->bindtable = std::make_unique<SymbolAddressMap>();
tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp 44 std::make_unique<InjectorIRStrategy>(
47 std::make_unique<InstDeleterIRStrategy>());
49 return std::make_unique<IRMutator>(std::move(Types), std::move(Strategies));
tools/llvm-pdbutil/BytesOutputStyle.cpp 460 std::make_unique<LazyRandomTypeCollection>(Types, Count, Offsets);
tools/llvm-pdbutil/DumpOutputStyle.cpp 1555 SymbolError = std::make_unique<Error>(std::move(EC));
tools/llvm-pdbutil/ExplainOutputStyle.cpp 67 std::make_unique<BinaryByteStream>(File.unknown().getBuffer(),
tools/llvm-pdbutil/InputFile.cpp 388 std::make_unique<LazyRandomTypeCollection>(Array, Count, Offsets);
401 Types = std::make_unique<LazyRandomTypeCollection>(Records, 100);
405 Types = std::make_unique<LazyRandomTypeCollection>(100);
tools/llvm-pdbutil/PrettyTypeDumper.cpp 120 auto Layout = std::make_unique<ClassLayout>(std::move(Class));
262 auto Layout = std::make_unique<ClassLayout>(std::move(Class));
tools/llvm-pdbutil/llvm-pdbutil.cpp 866 auto O = std::make_unique<YAMLOutputStyle>(File);
867 O = std::make_unique<YAMLOutputStyle>(File);
875 auto O = std::make_unique<DumpOutputStyle>(IF);
883 auto O = std::make_unique<BytesOutputStyle>(File);
1350 auto O = std::make_unique<ExplainOutputStyle>(IF, Off);
tools/llvm-profdata/llvm-profdata.cpp 150 auto Remapper = std::make_unique<SymbolRemapper>();
316 Contexts.emplace_back(std::make_unique<WriterContext>(
tools/llvm-rc/ResourceScriptParser.cpp 431 auto Accels = std::make_unique<AcceleratorsResource>(
452 return std::make_unique<CursorResource>(*Arg, MemoryFlags);
478 auto Dialog = std::make_unique<DialogResource>(
500 return std::make_unique<UserDefinedResource>(Type, read().value(),
520 return std::make_unique<UserDefinedResource>(Type, std::move(Data),
529 return std::make_unique<VersionInfoResource>(
600 return std::make_unique<BitmapResource>(*Arg, MemoryFlags);
607 return std::make_unique<IconResource>(*Arg, MemoryFlags);
614 return std::make_unique<HTMLResource>(*Arg, MemoryFlags);
622 return std::make_unique<MenuResource>(std::move(*OptStatements),
647 List.addDefinition(std::make_unique<MenuSeparator>());
672 List.addDefinition(std::make_unique<PopupItem>(
679 std::make_unique<MenuItem>(*CaptionResult, MenuResult, *FlagsResult));
691 auto Table = std::make_unique<StringTableResource>(std::move(*OptStatements),
712 auto Contents = std::make_unique<VersionInfoBlock>(BlockName);
749 return std::make_unique<VersionInfoValue>(*KeyResult, std::move(Values),
784 return std::make_unique<LanguageResource>((*Args)[0], (*Args)[1]);
789 return std::make_unique<CharacteristicsStmt>(*Arg);
794 return std::make_unique<VersionStmt>(*Arg);
799 return std::make_unique<CaptionStmt>(*Arg);
804 return std::make_unique<ClassStmt>(*Arg);
829 return std::make_unique<FontStmt>(*SizeResult, *NameResult, FontWeight,
835 return std::make_unique<StyleStmt>(*Arg);
840 return std::make_unique<ExStyleStmt>(*Arg);
tools/llvm-rc/ResourceScriptStmt.h 290 OptStatements(std::make_unique<OptionalStmtList>(std::move(Stmts))) {}
tools/llvm-rc/llvm-rc.cpp 179 auto FOut = std::make_unique<raw_fd_ostream>(
184 Visitor = std::make_unique<ResourceFileWriter>(Params, std::move(FOut));
tools/llvm-readobj/COFFDumper.cpp 1165 auto CODD = std::make_unique<COFFObjectDumpDelegate>(*this, Section, Obj,
tools/llvm-rtdyld/llvm-rtdyld.cpp 921 Checker = std::make_unique<RuntimeDyldChecker>(
967 Timers = ShowTimes ? std::make_unique<RTDyldTimers>() : nullptr;
tools/llvm-stress/llvm-stress.cpp 738 auto M = std::make_unique<Module>("/tmp/autogen.bc", Context);
tools/lto/lto.cpp 115 std::make_unique<LTOToolDiagnosticHandler>(), true);
280 std::unique_ptr<LLVMContext> Context = std::make_unique<LLVMContext>();
281 Context->setDiagnosticHandler(std::make_unique<LTOToolDiagnosticHandler>(),
341 InLocalContext ? new LibLTOCodeGenerator(std::make_unique<LLVMContext>())
tools/obj2yaml/elf2yaml.cpp 151 auto Y = std::make_unique<ELFYAML::Object>();
513 auto S = std::make_unique<ELFYAML::StackSizesSection>();
546 auto S = std::make_unique<ELFYAML::AddrsigSection>();
586 auto S = std::make_unique<ELFYAML::DynamicSection>();
603 auto S = std::make_unique<ELFYAML::RelocationSection>();
641 auto S = std::make_unique<ELFYAML::RawContentSection>();
665 auto S = std::make_unique<ELFYAML::SymtabShndxSection>();
680 auto S = std::make_unique<ELFYAML::NoBitsSection>();
691 auto S = std::make_unique<ELFYAML::NoteSection>();
727 auto S = std::make_unique<ELFYAML::HashSection>();
771 auto S = std::make_unique<ELFYAML::VerdefSection>();
820 auto S = std::make_unique<ELFYAML::SymverSection>();
839 auto S = std::make_unique<ELFYAML::VerneedSection>();
910 auto S = std::make_unique<ELFYAML::Group>();
946 auto S = std::make_unique<ELFYAML::MipsABIFlags>();
tools/obj2yaml/macho2yaml.cpp 193 auto Y = std::make_unique<MachOYAML::Object>();
tools/obj2yaml/wasm2yaml.cpp 56 std::make_unique<WasmYAML::DylinkSection>();
66 std::make_unique<WasmYAML::NameSection>();
76 std::make_unique<WasmYAML::LinkingSection>();
137 std::make_unique<WasmYAML::ProducersSection>();
160 std::make_unique<WasmYAML::TargetFeaturesSection>();
169 CustomSec = std::make_unique<WasmYAML::CustomSection>(WasmSec.Name);
176 auto Y = std::make_unique<WasmYAML::Object>();
196 auto TypeSec = std::make_unique<WasmYAML::TypeSection>();
211 auto ImportSec = std::make_unique<WasmYAML::ImportSection>();
242 auto FuncSec = std::make_unique<WasmYAML::FunctionSection>();
250 auto TableSec = std::make_unique<WasmYAML::TableSection>();
258 auto MemorySec = std::make_unique<WasmYAML::MemorySection>();
266 auto GlobalSec = std::make_unique<WasmYAML::GlobalSection>();
279 auto EventSec = std::make_unique<WasmYAML::EventSection>();
291 auto StartSec = std::make_unique<WasmYAML::StartSection>();
297 auto ExportSec = std::make_unique<WasmYAML::ExportSection>();
309 auto ElemSec = std::make_unique<WasmYAML::ElemSection>();
323 auto CodeSec = std::make_unique<WasmYAML::CodeSection>();
340 auto DataSec = std::make_unique<WasmYAML::DataSection>();
354 auto DataCountSec = std::make_unique<WasmYAML::DataCountSection>();
tools/opt/opt.cpp 724 Out = std::make_unique<ToolOutputFile>(OutputFilename, EC,
871 BOS = std::make_unique<raw_svector_ostream>(Buffer);
tools/polly/lib/Transform/DeLICM.cpp 1361 Impl = std::make_unique<DeLICMImpl>(&S, &LI);
tools/polly/lib/Transform/ForwardOpTree.cpp 917 Impl = std::make_unique<ForwardOpTreeImpl>(&S, &LI, MaxOpGuard);
tools/sancov/sancov.cpp 248 auto Addrs = std::make_unique<std::set<uint64_t>>();
365 auto Coverage(std::make_unique<SymbolizedCoverage>());
866 auto Coverage = std::make_unique<SymbolizedCoverage>();
1020 auto Result = std::make_unique<SymbolizedCoverage>();
unittests/ADT/IteratorTest.cpp 110 V.push_back(std::make_unique<int>(1));
111 V.push_back(std::make_unique<int>(2));
112 V.push_back(std::make_unique<int>(3));
113 V.push_back(std::make_unique<int>(4));
212 std::unique_ptr<int> A[] = {std::make_unique<int>(0), std::make_unique<int>(1),
212 std::unique_ptr<int> A[] = {std::make_unique<int>(0), std::make_unique<int>(1),
213 std::make_unique<int>(2), std::make_unique<int>(3),
213 std::make_unique<int>(2), std::make_unique<int>(3),
214 std::make_unique<int>(4), std::make_unique<int>(5),
214 std::make_unique<int>(4), std::make_unique<int>(5),
215 std::make_unique<int>(6)};
unittests/ADT/MakeUniqueTest.cpp 17 auto p0 = std::make_unique<int>();
21 auto p1 = std::make_unique<int>(5);
25 auto p2 = std::make_unique<std::tuple<int, int>>(0, 1);
29 auto p3 = std::make_unique<std::tuple<int, int, int>>(0, 1, 2);
33 auto p4 = std::make_unique<std::tuple<int, int, int, int>>(0, 1, 2, 3);
37 auto p5 = std::make_unique<std::tuple<int, int, int, int, int>>(0, 1, 2, 3, 4);
42 std::make_unique<std::tuple<int, int, int, int, int, int>>(0, 1, 2, 3, 4, 5);
46 auto p7 = std::make_unique<std::tuple<int, int, int, int, int, int, int>>(
51 auto p8 = std::make_unique<std::tuple<int, int, int, int, int, int, int, int>>(
57 std::make_unique<std::tuple<int, int, int, int, int, int, int, int, int>>(
63 std::make_unique<std::tuple<int, int, int, int, int, int, int, int, int, int>>(
unittests/ADT/MapVectorTest.cpp 152 MV.insert(std::make_pair(1, std::make_unique<int>(1)));
153 MV.insert(std::make_pair(2, std::make_unique<int>(2)));
309 MV.insert(std::make_pair(1, std::make_unique<int>(1)));
310 MV.insert(std::make_pair(2, std::make_unique<int>(2)));
unittests/ADT/STLExtrasTest.cpp 454 std::unique_ptr<int> V2 = std::make_unique<int>(0);
unittests/Analysis/MemorySSATest.cpp 54 MSSA = std::make_unique<MemorySSA>(*Test.F, &AA, &DT);
1434 std::make_unique<MemorySSAUpdater>(&MSSA);
1496 std::make_unique<MemorySSAUpdater>(&MSSA);
1568 std::make_unique<MemorySSAUpdater>(&MSSA);
unittests/CodeGen/AArch64SelectionDAGTest.cpp 62 MF = std::make_unique<MachineFunction>(*F, *TM, *TM->getSubtargetImpl(*F), 0,
65 DAG = std::make_unique<SelectionDAG>(*TM, CodeGenOpt::None);
unittests/CodeGen/GlobalISel/CSETest.cpp 25 CSEInfo.setCSEConfig(std::make_unique<CSEConfigFull>());
87 CSEInfo.setCSEConfig(std::make_unique<CSEConfigConstantOnly>());
unittests/CodeGen/GlobalISel/GISelMITest.h 114 auto MMI = std::make_unique<MachineModuleInfo>(&TM);
unittests/CodeGen/MachineInstrTest.cpp 145 return std::make_unique<MCContext>(
150 return std::make_unique<BogusTargetMachine>();
164 return std::make_unique<MachineFunction>(*F, *TM, STI, FunctionNum, MMI);
unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp 91 GlobalState = std::make_unique<GlobalTestState>();
123 TestState = std::make_unique<PerTestState>();
unittests/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp 28 TTB = std::make_unique<AppendingTypeTableBuilder>(Storage);
29 CRB = std::make_unique<ContinuationRecordBuilder>();
unittests/DebugInfo/DWARF/DwarfGenerator.cpp 449 Stream = std::make_unique<raw_svector_ostream>(FileBytes);
472 StringPool = std::make_unique<DwarfStringPool>(Allocator, *Asm, StringRef());
544 std::make_unique<CompileUnit>(*this, Version, Asm->getPointerSize()));
550 std::make_unique<LineTable>(Version, Format, Asm->getPointerSize()));
unittests/DebugInfo/PDB/PDBApiTest.cpp 467 auto RawSymbol = std::make_unique<MockRawSymbol>(Tag);
unittests/ExecutionEngine/ExecutionEngineTest.cpp 30 auto Owner = std::make_unique<Module>("<main>", Context);
unittests/ExecutionEngine/JITLink/JITLinkTestCommon.cpp 76 DisCtx = std::make_unique<MCContext>(MAI.get(), MRI.get(), nullptr);
88 AsCtx = std::make_unique<MCContext>(MAI.get(), MRI.get(), &MOFI, &SrcMgr);
136 MemMgr = std::make_unique<InProcessMemoryManager>();
unittests/ExecutionEngine/JITLink/MachO_x86_64_Tests.cpp 42 auto JTCtx = std::make_unique<TestJITLinkContext>(
unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp 40 cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
108 cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
125 cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
220 auto MU = std::make_unique<SimpleMaterializationUnit>(
254 JD.addGenerator(std::make_unique<BadGenerator>());
317 auto BarMU = std::make_unique<SimpleMaterializationUnit>(
347 JD.addGenerator(std::make_unique<ReexportsGenerator>(JD2, false, Filter));
361 auto FooMU = std::make_unique<SimpleMaterializationUnit>(
400 auto FooMU = std::make_unique<SimpleMaterializationUnit>(
404 auto BarMU = std::make_unique<SimpleMaterializationUnit>(
408 auto BazMU = std::make_unique<SimpleMaterializationUnit>(
536 auto FooMU = std::make_unique<SimpleMaterializationUnit>(
540 auto BarMU = std::make_unique<SimpleMaterializationUnit>(
599 auto FooMU = std::make_unique<SimpleMaterializationUnit>(
603 auto BarMU = std::make_unique<SimpleMaterializationUnit>(
663 auto FooMU = std::make_unique<SimpleMaterializationUnit>(
667 auto BarMU = std::make_unique<SimpleMaterializationUnit>(
727 auto FooMU = std::make_unique<SimpleMaterializationUnit>(
731 auto BarMU = std::make_unique<SimpleMaterializationUnit>(
780 auto MU = std::make_unique<SimpleMaterializationUnit>(
810 auto MU = std::make_unique<SimpleMaterializationUnit>(
841 auto MU = std::make_unique<SimpleMaterializationUnit>(
883 auto MU1 = std::make_unique<SimpleMaterializationUnit>(
892 auto MU2 = std::make_unique<SimpleMaterializationUnit>(
931 auto MU = std::make_unique<SimpleMaterializationUnit>(
977 JD.addGenerator(std::make_unique<TestGenerator>(SymbolMap({{Bar, BarSym}})));
988 auto MU = std::make_unique<SimpleMaterializationUnit>(
1025 auto MU = std::make_unique<SimpleMaterializationUnit>(
1061 auto BarMU = std::make_unique<SimpleMaterializationUnit>(
1081 auto MU = std::make_unique<SimpleMaterializationUnit>(
1132 auto MU = std::make_unique<SimpleMaterializationUnit>(
1139 auto NewMU = std::make_unique<SimpleMaterializationUnit>(
1176 auto MU = std::make_unique<SimpleMaterializationUnit>(
1207 auto MU = std::make_unique<SimpleMaterializationUnit>(
1211 std::make_unique<MaterializationResponsibility>(std::move(R));
1222 auto MU2 = std::make_unique<SimpleMaterializationUnit>(
unittests/ExecutionEngine/Orc/LazyCallThroughAndReexportsTest.cpp 40 cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
unittests/ExecutionEngine/Orc/LegacyCompileOnDemandLayerTest.cpp 28 : JITCompileCallbackManager(std::make_unique<DummyTrampolinePool>(), ES,
81 [] { return std::make_unique<DummyStubsManager>(); }, true);
unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp 78 auto M = std::make_unique<Module>("", Context);
unittests/ExecutionEngine/Orc/QueueChannel.h 171 auto C1 = std::make_unique<QueueChannel>(Q1, Q2);
172 auto C2 = std::make_unique<QueueChannel>(Q2, Q1);
unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp 57 return std::make_unique<MemoryManagerWrapper>(DebugSectionSeen);
74 auto M = std::make_unique<Module>("", Context);
126 ThreadSafeContext TSCtx(std::make_unique<LLVMContext>());
156 ES, []() { return std::make_unique<SectionMemoryManager>(); });
199 ThreadSafeContext TSCtx(std::make_unique<LLVMContext>());
221 ES, []() { return std::make_unique<SectionMemoryManager>(); });
unittests/ExecutionEngine/Orc/ThreadSafeModuleTest.cpp 24 ThreadSafeContext TSCtx(std::make_unique<LLVMContext>());
25 auto M = std::make_unique<Module>("M", *TSCtx.getContext());
32 ThreadSafeContext TSCtx(std::make_unique<LLVMContext>());
34 auto M1 = std::make_unique<Module>("M1", *TSCtx.getContext());
37 auto M2 = std::make_unique<Module>("M2", *TSCtx.getContext());
44 ThreadSafeContext TSCtx(std::make_unique<LLVMContext>());
48 auto M1 = std::make_unique<Module>("M1", *TSCtx.getContext());
53 auto M2 = std::make_unique<Module>("M2", *TSCtx.getContext());
61 ThreadSafeContext TSCtx(std::make_unique<LLVMContext>());
62 auto M = std::make_unique<Module>("M", *TSCtx.getContext());
69 ThreadSafeContext TSCtx(std::make_unique<LLVMContext>());
70 auto M = std::make_unique<Module>("M", *TSCtx.getContext());
87 ThreadSafeContext TSCtx(std::make_unique<LLVMContext>());
90 auto M = std::make_unique<Module>("M", Ctx);
unittests/FuzzMutate/StrategiesTest.cpp 35 std::make_unique<InjectorIRStrategy>(
38 return std::make_unique<IRMutator>(std::move(Types), std::move(Strategies));
47 Strategies.push_back(std::make_unique<InstDeleterIRStrategy>());
49 return std::make_unique<IRMutator>(std::move(Types), std::move(Strategies));
82 auto M = std::make_unique<Module>("M", Ctx);
unittests/IR/CFGBuilder.cpp 23 : Context(std::make_unique<LLVMContext>()),
24 M(std::make_unique<Module>(ModuleName, *Context)) {
unittests/IR/MetadataTest.cpp 37 ContextAndReplaceableUses CRU(std::make_unique<ReplaceableMetadataImpl>(Context));
46 CRU.makeReplaceable(std::make_unique<ReplaceableMetadataImpl>(Context));
54 auto ReplaceableUses = std::make_unique<ReplaceableMetadataImpl>(Context);
unittests/IR/TimePassesTest.cpp 130 std::make_unique<TimePassesHandler>(true);
unittests/Linker/LinkModulesTest.cpp 280 auto Dst = std::make_unique<Module>("Linked", C);
349 auto Dst = std::make_unique<Module>("Linked", C);
unittests/MC/DwarfLineTables.cpp 43 Ctx = std::make_unique<MCContext>(MAI.get(), MRI.get(), nullptr);
unittests/ProfileData/CoverageMappingTest.cpp 237 std::make_unique<CoverageMappingReaderMock>(Funcs));
242 std::make_unique<CoverageMappingReaderMock>(Funcs));
unittests/ProfileData/InstrProfTest.cpp 892 std::unique_ptr<Module> M = std::make_unique<Module>("MyModule.cpp", Ctx);
unittests/Support/BinaryStreamTest.cpp 147 std::make_unique<BinaryByteStream>(InputData, Endians[I]);
148 auto InBrokenStream = std::make_unique<BrokenStream>(
162 std::make_unique<MutableBinaryByteStream>(OutputData, Endians[I]);
163 Streams[I * 2 + 1].Output = std::make_unique<BrokenStream>(
171 std::make_unique<MutableBinaryByteStream>(InputData, Endians[I]);
172 Streams[I * 2 + 1].Output = std::make_unique<BrokenStream>(
180 std::make_unique<BinaryByteStream>(OutputData, Endians[I]);
181 Streams[I * 2 + 1].Input = std::make_unique<BrokenStream>(
unittests/Support/Casting.cpp 196 std::unique_ptr<derived> newd() { return std::make_unique<derived>(); }
197 std::unique_ptr<base> newb() { return std::make_unique<derived>(); }
201 auto D = std::make_unique<derived>();
unittests/Support/DataExtractorTest.cpp 195 auto C = std::make_unique<DataExtractor::Cursor>(0);
203 auto C = std::make_unique<DataExtractor::Cursor>(0);
212 auto C = std::make_unique<DataExtractor::Cursor>(0);
220 auto C = std::make_unique<DataExtractor::Cursor>(0);
unittests/Support/FileCheckTest.cpp 96 std::make_unique<FileCheckNumericVariableUse>("FOO", &FooVar);
100 std::make_unique<FileCheckNumericVariableUse>("BAR", &BarVar);
421 std::make_unique<FileCheckNumericVariableUse>("@LINE", &LineVar);
422 auto NVarUse = std::make_unique<FileCheckNumericVariableUse>("N", &NVar);
unittests/Support/TrigramIndexTest.cpp 25 std::make_unique<TrigramIndex>();
unittests/Support/YAMLIOTest.cpp 2844 N = std::make_unique<Scalar>();
2850 N = std::make_unique<Seq>();
2856 N = std::make_unique<Map>();
2935 std::unique_ptr<Poly> node = std::make_unique<Scalar>(true);
2949 auto seq = std::make_unique<Seq>();
2950 seq->push_back(std::make_unique<Scalar>(true));
2951 seq->push_back(std::make_unique<Scalar>(1.0));
2981 auto map = std::make_unique<Map>();
2982 (*map)["foo"] = std::make_unique<Scalar>(false);
2983 (*map)["bar"] = std::make_unique<Scalar>(2.0);
unittests/Target/AArch64/InstSizes.cpp 33 return std::make_unique<AArch64InstrInfo>(ST);
unittests/Target/X86/MachineSizeOptsTest.cpp 78 MMI = std::make_unique<MachineModuleInfo>(TM.get());
unittests/Transforms/Utils/ValueMapperTest.cpp 69 std::unique_ptr<GlobalVariable> G0 = std::make_unique<GlobalVariable>(
71 std::unique_ptr<GlobalVariable> G1 = std::make_unique<GlobalVariable>(
unittests/Transforms/Vectorize/VPlanTestBase.h 51 auto Plan = std::make_unique<VPlan>();
61 auto Plan = std::make_unique<VPlan>();
unittests/XRay/FDRProducerConsumerTest.cpp 37 return std::make_unique<NewBufferRecord>(1);
41 return std::make_unique<NewCPUIDRecord>(1, 2);
45 return std::make_unique<TSCWrapRecord>(1);
49 return std::make_unique<WallclockRecord>(1, 2);
53 return std::make_unique<CustomEventRecord>(4, 1, 2, "data");
57 return std::make_unique<CallArgRecord>(1);
61 return std::make_unique<PIDRecord>(1);
65 return std::make_unique<FunctionRecord>(RecordTypes::ENTER, 1, 2);
69 return std::make_unique<CustomEventRecordV5>(4, 1, "data");
73 return std::make_unique<TypedEventRecord>(4, 1, 2, "data");
85 Writer = std::make_unique<FDRTraceWriter>(OS, H);
108 Writer = std::make_unique<FDRTraceWriter>(OS, H);
unittests/XRay/FDRRecordPrinterTest.cpp 25 return std::make_unique<BufferExtents>(1);
33 return std::make_unique<WallclockRecord>(1, 2);
41 return std::make_unique<NewCPUIDRecord>(1, 2);
49 return std::make_unique<TSCWrapRecord>(1);
57 return std::make_unique<CustomEventRecord>(4, 1, 2, "data");
67 return std::make_unique<CallArgRecord>(1);
77 return std::make_unique<PIDRecord>(1);
85 return std::make_unique<NewBufferRecord>(1);
93 return std::make_unique<EndBufferRecord>();
unittests/tools/llvm-exegesis/X86/SnippetRepetitorTest.cpp 36 Context = std::make_unique<LLVMContext>();
38 std::make_unique<Module>("X86SnippetRepetitorTest", *Context);
40 MMI = std::make_unique<MachineModuleInfo>(TM.get());
utils/TableGen/AsmMatcherEmitter.cpp 1519 auto II = std::make_unique<MatchableInfo>(*CGI);
1536 auto Alias = std::make_unique<CodeGenInstAlias>(AllInstAliases[i],
1550 auto II = std::make_unique<MatchableInfo>(std::move(Alias));
1619 auto AliasII = std::make_unique<MatchableInfo>(*II);
utils/TableGen/CodeGenDAGPatterns.cpp 3112 (PatternFragments[Frag] = std::make_unique<TreePattern>(
utils/TableGen/CodeGenRegisters.cpp 673 std::make_unique<Record>(Name, Def->getLoc(), Def->getRecords()));
1101 std::make_unique<TupleExpander>(SynthDefs));
utils/TableGen/CodeGenSchedule.cpp 175 Sets.addOperator("instrs", std::make_unique<InstrsOp>());
176 Sets.addOperator("instregex", std::make_unique<InstRegexOp>(Target));
utils/TableGen/CodeGenTarget.cpp 296 RegBank = std::make_unique<CodeGenRegBank>(Records, getHwModes());
393 SchedModels = std::make_unique<CodeGenSchedModels>(Records, *this);
406 Instructions[Insts[i]] = std::make_unique<CodeGenInstruction>(Insts[i]);
utils/TableGen/DAGISelEmitter.cpp 176 std::make_unique<ScopeMatcher>(PatternMatchers);
utils/TableGen/FixedLenDecoderEmitter.cpp 606 std::make_pair(-1U, std::make_unique<FilterChooser>(
632 Inst.first, std::make_unique<FilterChooser>(
utils/TableGen/GICombinerEmitter.cpp 249 std::make_unique<CombineRule>(Target, NumPatternTotal, TheDef);
utils/TableGen/GlobalISelEmitter.cpp 1509 Predicates.emplace_back(std::make_unique<Kind>(
2063 std::make_unique<Kind>(getInsnVarID(), std::forward<Args>(args)...));
2807 std::make_unique<Kind>(InsnID, std::forward<Args>(args)...));
2970 Actions.emplace_back(std::make_unique<Kind>(std::forward<Args>(args)...));
2985 std::make_unique<Kind>(std::forward<Args>(args)...));
4881 std::unique_ptr<GroupT> CurrentGroup = std::make_unique<GroupT>();
4902 CurrentGroup = std::make_unique<GroupT>();
utils/TableGen/SearchableTableEmitter.cpp 137 Intr = std::make_unique<CodeGenIntrinsic>(cast<DefInit>(I)->getDef());
544 auto Index = std::make_unique<SearchIndex>();
580 Enum.Entries.push_back(std::make_unique<GenericEnum::Entry>(Name, Value));
650 auto Enum = std::make_unique<GenericEnum>();
667 auto Table = std::make_unique<GenericTable>();
736 auto Enum = std::make_unique<GenericEnum>();
746 auto Table = std::make_unique<GenericTable>();
utils/TableGen/X86DisassemblerTables.cpp 654 Tables[i] = std::make_unique<ContextDecision>();
utils/TableGen/X86RecognizableInstr.cpp 752 filter = std::make_unique<DumbFilter>();
761 filter = std::make_unique<ModFilter>(true);
770 filter = std::make_unique<ModFilter>(false);
776 filter = std::make_unique<ExtendedFilter>(true, Form - X86Local::MRM0r);
782 filter = std::make_unique<ExtendedFilter>(false, Form - X86Local::MRM0m);
785 filter = std::make_unique<ExactFilter>(0xC0 + Form - X86Local::MRM_C0);