reference, declarationdefinition
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.cpp
10515     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.cpp
10451     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);