Use llvm::make_unique NFC

[hokein]

Summary

Apply clang-tidy modernize-make-unique check.

lib/Analysis/AliasAnalysis.cpp

 /// this list.
 bool AAResultsWrapperPass::runOnFunction(Function &F) {
   // NB! This *must* be reset before adding new AA results to the new
   // AAResults object because in the legacy pass manager, each instance
   // of these will refer to the *same* immutable analyses, registering and
   // unregistering themselves with them. We need to carefully tear down the
   // previous object first, in this case replacing it with an empty one, before
   // registering new results.
-  AAR.reset(
-      new AAResults(getAnalysis<TargetLibraryInfoWrapperPass>().getTLI()));
+  AAR = llvm::make_unique<AAResults>(
+      getAnalysis<TargetLibraryInfoWrapperPass>().getTLI());
 
   // BasicAA is always available for function analyses. Also, we add it first
   // so that it can trump TBAA results when it proves MustAlias.
   // FIXME: TBAA should have an explicit mode to support this and then we
   // should reconsider the ordering here.
   if (!DisableBasicAA)
     AAR->addAAResult(getAnalysis<BasicAAWrapperPass>().getResult());
 

lib/Analysis/AliasAnalysisEvaluator.cpp

public:
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<AAResultsWrapperPass>();
     AU.setPreservesAll();
   }
 
   bool doInitialization(Module &M) override {
-    P.reset(new AAEvaluator());
+    P = llvm::make_unique<AAEvaluator>();
     return false;
   }
 
   bool runOnFunction(Function &F) override {
     P->runInternal(F, getAnalysis<AAResultsWrapperPass>().getAAResults());
     return false;
   }
   bool doFinalization(Module &M) override {

lib/Analysis/BasicAliasAnalysis.cpp

 }
 
 bool BasicAAWrapperPass::runOnFunction(Function &F) {
   auto &ACT = getAnalysis<AssumptionCacheTracker>();
   auto &TLIWP = getAnalysis<TargetLibraryInfoWrapperPass>();
   auto &DTWP = getAnalysis<DominatorTreeWrapperPass>();
   auto *LIWP = getAnalysisIfAvailable<LoopInfoWrapperPass>();
 
-  Result.reset(new BasicAAResult(F.getParent()->getDataLayout(), TLIWP.getTLI(),
-                                 ACT.getAssumptionCache(F), &DTWP.getDomTree(),
-                                 LIWP ? &LIWP->getLoopInfo() : nullptr));
+  Result = llvm::make_unique<BasicAAResult>(
+      F.getParent()->getDataLayout(), TLIWP.getTLI(), ACT.getAssumptionCache(F),
+      &DTWP.getDomTree(), LIWP ? &LIWP->getLoopInfo() : nullptr);
 
   return false;
 }
 
 void BasicAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequired<AssumptionCacheTracker>();
   AU.addRequired<DominatorTreeWrapperPass>();

lib/Analysis/BlockFrequencyInfo.cpp

bool BlockFrequencyInfo::invalidate(Function &F, const PreservedAnalyses &PA,
   return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>() ||
            PAC.preservedSet<CFGAnalyses>());
 }
 
 void BlockFrequencyInfo::calculate(const Function &F,
                                    const BranchProbabilityInfo &BPI,
                                    const LoopInfo &LI) {
   if (!BFI)
-    BFI.reset(new ImplType);
+    BFI = llvm::make_unique<ImplType>();
   BFI->calculate(F, BPI, LI);
   if (ViewBlockFreqPropagationDAG != GVDT_None &&
       (ViewBlockFreqFuncName.empty() ||
        F.getName().equals(ViewBlockFreqFuncName))) {
     view();
   }
 }
 

lib/Analysis/CFLAndersAliasAnalysis.cpp

 }
 
 CFLAndersAAWrapperPass::CFLAndersAAWrapperPass() : ImmutablePass(ID) {
   initializeCFLAndersAAWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
 void CFLAndersAAWrapperPass::initializePass() {
   auto &TLIWP = getAnalysis<TargetLibraryInfoWrapperPass>();
-  Result.reset(new CFLAndersAAResult(TLIWP.getTLI()));
+  Result = llvm::make_unique<CFLAndersAAResult>(TLIWP.getTLI());
 }
 
 void CFLAndersAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequired<TargetLibraryInfoWrapperPass>();
 }

lib/Analysis/CFLSteensAliasAnalysis.cpp

 }
 
 CFLSteensAAWrapperPass::CFLSteensAAWrapperPass() : ImmutablePass(ID) {
   initializeCFLSteensAAWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
 void CFLSteensAAWrapperPass::initializePass() {
   auto &TLIWP = getAnalysis<TargetLibraryInfoWrapperPass>();
-  Result.reset(new CFLSteensAAResult(TLIWP.getTLI()));
+  Result = llvm::make_unique<CFLSteensAAResult>(TLIWP.getTLI());
 }
 
 void CFLSteensAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequired<TargetLibraryInfoWrapperPass>();
 }

lib/Analysis/CallGraph.cpp

 CallGraphWrapperPass::~CallGraphWrapperPass() {}
 
 void CallGraphWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
 }
 
 bool CallGraphWrapperPass::runOnModule(Module &M) {
   // All the real work is done in the constructor for the CallGraph.
-  G.reset(new CallGraph(M));
+  G = llvm::make_unique<CallGraph>(M);
   return false;
 }
 
 INITIALIZE_PASS(CallGraphWrapperPass, "basiccg", "CallGraph Construction",
                 false, true)
 
 char CallGraphWrapperPass::ID = 0;
 

lib/Analysis/DependenceAnalysis.cpp

 FunctionPass *llvm::createDependenceAnalysisWrapperPass() {
   return new DependenceAnalysisWrapperPass();
 }
 
 bool DependenceAnalysisWrapperPass::runOnFunction(Function &F) {
   auto &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
   auto &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
   auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
-  info.reset(new DependenceInfo(&F, &AA, &SE, &LI));
+  info = llvm::make_unique<DependenceInfo>(&F, &AA, &SE, &LI);
   return false;
 }
 
 DependenceInfo &DependenceAnalysisWrapperPass::getDI() const { return *info; }
 
 void DependenceAnalysisWrapperPass::releaseMemory() { info.reset(); }
 
 void DependenceAnalysisWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {

lib/Analysis/GlobalsModRef.cpp

ModulePass *llvm::createGlobalsAAWrapperPass() {
   return new GlobalsAAWrapperPass();
 }
 
 GlobalsAAWrapperPass::GlobalsAAWrapperPass() : ModulePass(ID) {
   initializeGlobalsAAWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
 bool GlobalsAAWrapperPass::runOnModule(Module &M) {
-  Result.reset(new GlobalsAAResult(GlobalsAAResult::analyzeModule(
+  Result = llvm::make_unique<GlobalsAAResult>(GlobalsAAResult::analyzeModule(
       M, getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(),
-      getAnalysis<CallGraphWrapperPass>().getCallGraph())));
+      getAnalysis<CallGraphWrapperPass>().getCallGraph()));
   return false;
 }
 
 bool GlobalsAAWrapperPass::doFinalization(Module &M) {
   Result.reset();
   return false;
 }
 
 void GlobalsAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequired<CallGraphWrapperPass>();
   AU.addRequired<TargetLibraryInfoWrapperPass>();
 }

lib/Analysis/IVUsers.cpp

 
 bool IVUsersWrapperPass::runOnLoop(Loop *L, LPPassManager &LPM) {
   auto *AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
       *L->getHeader()->getParent());
   auto *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   auto *SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
 
-  IU.reset(new IVUsers(L, AC, LI, DT, SE));
+  IU = llvm::make_unique<IVUsers>(L, AC, LI, DT, SE);
   return false;
 }
 
 void IVUsersWrapperPass::print(raw_ostream &OS, const Module *M) const {
   IU->print(OS, M);
 }
 
 void IVUsersWrapperPass::releaseMemory() { IU->releaseMemory(); }

lib/Analysis/MemorySSA.cpp

void MemorySSAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequiredTransitive<DominatorTreeWrapperPass>();
   AU.addRequiredTransitive<AAResultsWrapperPass>();
 }
 
 bool MemorySSAWrapperPass::runOnFunction(Function &F) {
   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   auto &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
-  MSSA.reset(new MemorySSA(F, &AA, &DT));
+  MSSA = llvm::make_unique<MemorySSA>(F, &AA, &DT);
   return false;
 }
 
 void MemorySSAWrapperPass::verifyAnalysis() const { MSSA->verifyMemorySSA(); }
 
 void MemorySSAWrapperPass::print(raw_ostream &OS, const Module *M) const {
   MSSA->print(OS);
 }

lib/Analysis/ObjCARCAliasAnalysis.cpp

ImmutablePass *llvm::createObjCARCAAWrapperPass() {
   return new ObjCARCAAWrapperPass();
 }
 
 ObjCARCAAWrapperPass::ObjCARCAAWrapperPass() : ImmutablePass(ID) {
   initializeObjCARCAAWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
 bool ObjCARCAAWrapperPass::doInitialization(Module &M) {
-  Result.reset(new ObjCARCAAResult(M.getDataLayout()));
+  Result = llvm::make_unique<ObjCARCAAResult>(M.getDataLayout());
   return false;
 }
 
 bool ObjCARCAAWrapperPass::doFinalization(Module &M) {
   Result.reset();
   return false;
 }
 
 void ObjCARCAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
 }

lib/Analysis/ProfileSummaryInfo.cpp

INITIALIZE_PASS(ProfileSummaryInfoWrapperPass, "profile-summary-info",
                 "Profile summary info", false, true)
 
 ProfileSummaryInfoWrapperPass::ProfileSummaryInfoWrapperPass()
     : ImmutablePass(ID) {
   initializeProfileSummaryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
 bool ProfileSummaryInfoWrapperPass::doInitialization(Module &M) {
-  PSI.reset(new ProfileSummaryInfo(M));
+  PSI = llvm::make_unique<ProfileSummaryInfo>(M);
   return false;
 }
 
 bool ProfileSummaryInfoWrapperPass::doFinalization(Module &M) {
   PSI.reset();
   return false;
 }
 

lib/Analysis/ScalarEvolution.cpp

INITIALIZE_PASS_END(ScalarEvolutionWrapperPass, "scalar-evolution",
                     "Scalar Evolution Analysis", false, true)
 char ScalarEvolutionWrapperPass::ID = 0;
 
 ScalarEvolutionWrapperPass::ScalarEvolutionWrapperPass() : FunctionPass(ID) {
   initializeScalarEvolutionWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
 bool ScalarEvolutionWrapperPass::runOnFunction(Function &F) {
-  SE.reset(new ScalarEvolution(
+  SE = llvm::make_unique<ScalarEvolution>(
       F, getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(),
       getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F),
       getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
-      getAnalysis<LoopInfoWrapperPass>().getLoopInfo()));
+      getAnalysis<LoopInfoWrapperPass>().getLoopInfo());
   return false;
 }
 
 void ScalarEvolutionWrapperPass::releaseMemory() { SE.reset(); }
 
 void ScalarEvolutionWrapperPass::print(raw_ostream &OS, const Module *) const {
   SE->print(OS);
 }

lib/Analysis/ScalarEvolutionAliasAnalysis.cpp

FunctionPass *llvm::createSCEVAAWrapperPass() {
   return new SCEVAAWrapperPass();
 }
 
 SCEVAAWrapperPass::SCEVAAWrapperPass() : FunctionPass(ID) {
   initializeSCEVAAWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
 bool SCEVAAWrapperPass::runOnFunction(Function &F) {
-  Result.reset(
-      new SCEVAAResult(getAnalysis<ScalarEvolutionWrapperPass>().getSE()));
+  Result = llvm::make_unique<SCEVAAResult>(
+      getAnalysis<ScalarEvolutionWrapperPass>().getSE());
   return false;
 }
 
 void SCEVAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequired<ScalarEvolutionWrapperPass>();
 }

lib/Analysis/ScopedNoAliasAA.cpp

ImmutablePass *llvm::createScopedNoAliasAAWrapperPass() {
   return new ScopedNoAliasAAWrapperPass();
 }
 
 ScopedNoAliasAAWrapperPass::ScopedNoAliasAAWrapperPass() : ImmutablePass(ID) {
   initializeScopedNoAliasAAWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
 bool ScopedNoAliasAAWrapperPass::doInitialization(Module &M) {
-  Result.reset(new ScopedNoAliasAAResult());
+  Result = llvm::make_unique<ScopedNoAliasAAResult>();
   return false;
 }
 
 bool ScopedNoAliasAAWrapperPass::doFinalization(Module &M) {
   Result.reset();
   return false;
 }
 
 void ScopedNoAliasAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
 }

lib/Analysis/TargetLibraryInfo.cpp

TargetLibraryInfo TargetLibraryAnalysis::run(Function &F,
   return TargetLibraryInfo(
       lookupInfoImpl(Triple(F.getParent()->getTargetTriple())));
 }
 
 TargetLibraryInfoImpl &TargetLibraryAnalysis::lookupInfoImpl(const Triple &T) {
   std::unique_ptr<TargetLibraryInfoImpl> &Impl =
       Impls[T.normalize()];
   if (!Impl)
-    Impl.reset(new TargetLibraryInfoImpl(T));
+    Impl = llvm::make_unique<TargetLibraryInfoImpl>(T);
 
   return *Impl;
 }
 
 unsigned TargetLibraryInfoImpl::getTargetWCharSize(const Triple &T) {
   // See also clang/lib/Basic/Targets.cpp.
   if (T.isPS4() || T.isOSWindows() || T.isArch16Bit())
     return 2;

lib/Analysis/TypeBasedAliasAnalysis.cpp

ImmutablePass *llvm::createTypeBasedAAWrapperPass() {
   return new TypeBasedAAWrapperPass();
 }
 
 TypeBasedAAWrapperPass::TypeBasedAAWrapperPass() : ImmutablePass(ID) {
   initializeTypeBasedAAWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
 bool TypeBasedAAWrapperPass::doInitialization(Module &M) {
-  Result.reset(new TypeBasedAAResult());
+  Result = llvm::make_unique<TypeBasedAAResult>();
   return false;
 }
 
 bool TypeBasedAAWrapperPass::doFinalization(Module &M) {
   Result.reset();
   return false;
 }
 
 void TypeBasedAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
 }

lib/CodeGen/BranchRelaxation.cpp

bool BranchRelaxation::runOnMachineFunction(MachineFunction &mf) {
 
   DEBUG(dbgs() << "***** BranchRelaxation *****\n");
 
   const TargetSubtargetInfo &ST = MF->getSubtarget();
   TII = ST.getInstrInfo();
 
   TRI = ST.getRegisterInfo();
   if (TRI->trackLivenessAfterRegAlloc(*MF))
-    RS.reset(new RegScavenger());
+    RS = llvm::make_unique<RegScavenger>();
 
   // Renumber all of the machine basic blocks in the function, guaranteeing that
   // the numbers agree with the position of the block in the function.
   MF->RenumberBlocks();
 
   // Do the initial scan of the function, building up information about the
   // sizes of each block.
   scanFunction();

lib/CodeGen/CodeGenPrepare.cpp

bool CodeGenPrepare::isMergingEmptyBlockProfitable(BasicBlock *BB,
   // case, no reason to skip merging because COPYs are expected to be place in
   // Pred already.
   if (SameIncomingValueBBs.count(Pred))
     return true;
 
   if (!BFI) {
     Function &F = *BB->getParent();
     LoopInfo LI{DominatorTree(F)};
-    BPI.reset(new BranchProbabilityInfo(F, LI));
-    BFI.reset(new BlockFrequencyInfo(F, *BPI, LI));
+    BPI = llvm::make_unique<BranchProbabilityInfo>(F, LI);
+    BFI = llvm::make_unique<BlockFrequencyInfo>(F, *BPI, LI);
   }
 
   BlockFrequency PredFreq = BFI->getBlockFreq(Pred);
   BlockFrequency BBFreq = BFI->getBlockFreq(BB);
 
   for (auto SameValueBB : SameIncomingValueBBs)
     if (SameValueBB->getUniquePredecessor() == Pred &&
         DestBB == findDestBlockOfMergeableEmptyBlock(SameValueBB))

lib/CodeGen/LiveRegMatrix.cpp

 
 bool LiveRegMatrix::runOnMachineFunction(MachineFunction &MF) {
   TRI = MF.getSubtarget().getRegisterInfo();
   LIS = &getAnalysis<LiveIntervals>();
   VRM = &getAnalysis<VirtRegMap>();
 
   unsigned NumRegUnits = TRI->getNumRegUnits();
   if (NumRegUnits != Matrix.size())
-    Queries.reset(new LiveIntervalUnion::Query[NumRegUnits]);
+    Queries = llvm::make_unique<LiveIntervalUnion::Query[]>(NumRegUnits);
   Matrix.init(LIUAlloc, NumRegUnits);
 
   // Make sure no stale queries get reused.
   invalidateVirtRegs();
   return false;
 }
 
 void LiveRegMatrix::releaseMemory() {

lib/CodeGen/MachineBlockFrequencyInfo.cpp

void MachineBlockFrequencyInfo::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   MachineFunctionPass::getAnalysisUsage(AU);
 }
 
 void MachineBlockFrequencyInfo::calculate(
     const MachineFunction &F, const MachineBranchProbabilityInfo &MBPI,
     const MachineLoopInfo &MLI) {
   if (!MBFI)
-    MBFI.reset(new ImplType);
+    MBFI = llvm::make_unique<ImplType>();
   MBFI->calculate(F, MBPI, MLI);
   if (ViewMachineBlockFreqPropagationDAG != GVDT_None &&
       (ViewBlockFreqFuncName.empty() ||
        F.getName().equals(ViewBlockFreqFuncName))) {
     view("MachineBlockFrequencyDAGS." + F.getName());
   }
 }
 

lib/CodeGen/MachineDominators.cpp

 void MachineDominatorTree::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   MachineFunctionPass::getAnalysisUsage(AU);
 }
 
 bool MachineDominatorTree::runOnMachineFunction(MachineFunction &F) {
   CriticalEdgesToSplit.clear();
   NewBBs.clear();
-  DT.reset(new DominatorTreeBase<MachineBasicBlock>(false));
+  DT = llvm::make_unique<DominatorTreeBase<MachineBasicBlock>>(false);
   DT->recalculate(F);
   return false;
 }
 
 MachineDominatorTree::MachineDominatorTree()
     : MachineFunctionPass(ID) {
   initializeMachineDominatorTreePass(*PassRegistry::getPassRegistry());
 }

lib/CodeGen/RegAllocGreedy.cpp

bool RAGreedy::runOnMachineFunction(MachineFunction &mf) {
   AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
 
   initializeCSRCost();
 
   calculateSpillWeightsAndHints(*LIS, mf, VRM, *Loops, *MBFI);
 
   DEBUG(LIS->dump());
 
-  SA.reset(new SplitAnalysis(*VRM, *LIS, *Loops));
-  SE.reset(new SplitEditor(*SA, *AA, *LIS, *VRM, *DomTree, *MBFI));
+  SA = llvm::make_unique<SplitAnalysis>(*VRM, *LIS, *Loops);
+  SE = llvm::make_unique<SplitEditor>(*SA, *AA, *LIS, *VRM, *DomTree, *MBFI);
   ExtraRegInfo.clear();
   ExtraRegInfo.resize(MRI->getNumVirtRegs());
   NextCascade = 1;
   IntfCache.init(MF, Matrix->getLiveUnions(), Indexes, LIS, TRI);
   GlobalCand.resize(32);  // This will grow as needed.
   SetOfBrokenHints.clear();
 
   allocatePhysRegs();
   tryHintsRecoloring();
   postOptimization();
   reportNumberOfSplillsReloads();
 
   releaseMemory();
   return true;
 }

lib/CodeGen/RegisterClassInfo.cpp

 
 void RegisterClassInfo::runOnMachineFunction(const MachineFunction &mf) {
   bool Update = false;
   MF = &mf;
 
   // Allocate new array the first time we see a new target.
   if (MF->getSubtarget().getRegisterInfo() != TRI) {
     TRI = MF->getSubtarget().getRegisterInfo();
-    RegClass.reset(new RCInfo[TRI->getNumRegClasses()]);
+    RegClass = llvm::make_unique<RCInfo[]>(TRI->getNumRegClasses());
     unsigned NumPSets = TRI->getNumRegPressureSets();
-    PSetLimits.reset(new unsigned[NumPSets]);
+    PSetLimits = llvm::make_unique<unsigned[]>(NumPSets);
     std::fill(&PSetLimits[0], &PSetLimits[NumPSets], 0);
     Update = true;
   }
 
   // Does this MF have different CSRs?
   assert(TRI && "no register info set");
 
   // Get the callee saved registers.

 void RegisterClassInfo::compute(const TargetRegisterClass *RC) const {
   assert(RC && "no register class given");
   RCInfo &RCI = RegClass[RC->getID()];
 
   // Raw register count, including all reserved regs.
   unsigned NumRegs = RC->getNumRegs();
 
   if (!RCI.Order)
-    RCI.Order.reset(new MCPhysReg[NumRegs]);
+    RCI.Order = llvm::make_unique<MCPhysReg[]>(NumRegs);
 
   unsigned N = 0;
   SmallVector<MCPhysReg, 16> CSRAlias;
   unsigned MinCost = 0xff;
   unsigned LastCost = ~0u;
   unsigned LastCostChange = 0;
 
   // FIXME: Once targets reserve registers instead of removing them from the

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

case OPC_CheckComplexPat: {
       unsigned CPNum = MatcherTable[MatcherIndex++];
       unsigned RecNo = MatcherTable[MatcherIndex++];
       assert(RecNo < RecordedNodes.size() && "Invalid CheckComplexPat");
 
       // If target can modify DAG during matching, keep the matching state
       // consistent.
       std::unique_ptr<MatchStateUpdater> MSU;
       if (ComplexPatternFuncMutatesDAG())
-        MSU.reset(new MatchStateUpdater(*CurDAG, &NodeToMatch, RecordedNodes,
-                                        MatchScopes));
+        MSU = llvm::make_unique<MatchStateUpdater>(*CurDAG, &NodeToMatch,
+                                                   RecordedNodes, MatchScopes);
 
       if (!CheckComplexPattern(NodeToMatch, RecordedNodes[RecNo].second,
                                RecordedNodes[RecNo].first, CPNum,
                                RecordedNodes))
         break;
       continue;
     }
     case OPC_CheckOpcode:

lib/DebugInfo/DWARF/DWARFContext.cpp

 }
 
 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrev() {
   if (Abbrev)
     return Abbrev.get();
 
   DataExtractor abbrData(getAbbrevSection(), isLittleEndian(), 0);
 
-  Abbrev.reset(new DWARFDebugAbbrev());
+  Abbrev = llvm::make_unique<DWARFDebugAbbrev>();
   Abbrev->extract(abbrData);
   return Abbrev.get();
 }
 
 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrevDWO() {
   if (AbbrevDWO)
     return AbbrevDWO.get();
 
   DataExtractor abbrData(getAbbrevDWOSection(), isLittleEndian(), 0);
-  AbbrevDWO.reset(new DWARFDebugAbbrev());
+  AbbrevDWO = llvm::make_unique<DWARFDebugAbbrev>();
   AbbrevDWO->extract(abbrData);
   return AbbrevDWO.get();
 }
 
 const DWARFDebugLoc *DWARFContext::getDebugLoc() {
   if (Loc)
     return Loc.get();
 
   DataExtractor LocData(getLocSection().Data, isLittleEndian(), 0);
-  Loc.reset(new DWARFDebugLoc(getLocSection().Relocs));
+  Loc = llvm::make_unique<DWARFDebugLoc>(getLocSection().Relocs);
   // assume all compile units have the same address byte size
   if (getNumCompileUnits())
     Loc->parse(LocData, getCompileUnitAtIndex(0)->getAddressByteSize());
   return Loc.get();
 }
 
 const DWARFDebugLocDWO *DWARFContext::getDebugLocDWO() {
   if (LocDWO)
     return LocDWO.get();
 
   DataExtractor LocData(getLocDWOSection().Data, isLittleEndian(), 0);
-  LocDWO.reset(new DWARFDebugLocDWO());
+  LocDWO = llvm::make_unique<DWARFDebugLocDWO>();
   LocDWO->parse(LocData);
   return LocDWO.get();
 }
 
 const DWARFDebugAranges *DWARFContext::getDebugAranges() {
   if (Aranges)
     return Aranges.get();
 
-  Aranges.reset(new DWARFDebugAranges());
+  Aranges = llvm::make_unique<DWARFDebugAranges>();
   Aranges->generate(this);
   return Aranges.get();
 }
 
 const DWARFDebugFrame *DWARFContext::getDebugFrame() {
   if (DebugFrame)
     return DebugFrame.get();
 
   // There's a "bug" in the DWARFv3 standard with respect to the target address
   // size within debug frame sections. While DWARF is supposed to be independent
   // of its container, FDEs have fields with size being "target address size",
   // which isn't specified in DWARF in general. It's only specified for CUs, but
   // .eh_frame can appear without a .debug_info section. Follow the example of
   // other tools (libdwarf) and extract this from the container (ObjectFile
   // provides this information). This problem is fixed in DWARFv4
   // See this dwarf-discuss discussion for more details:
   // http://lists.dwarfstd.org/htdig.cgi/dwarf-discuss-dwarfstd.org/2011-December/001173.html
   DataExtractor debugFrameData(getDebugFrameSection(), isLittleEndian(),
                                getAddressSize());
-  DebugFrame.reset(new DWARFDebugFrame(false /* IsEH */));
+  DebugFrame = llvm::make_unique<DWARFDebugFrame>(false /* IsEH */);
   DebugFrame->parse(debugFrameData);
   return DebugFrame.get();
 }
 
 const DWARFDebugFrame *DWARFContext::getEHFrame() {
   if (EHFrame)
     return EHFrame.get();
 
   DataExtractor debugFrameData(getEHFrameSection(), isLittleEndian(),
                                getAddressSize());
-  DebugFrame.reset(new DWARFDebugFrame(true /* IsEH */));
+  DebugFrame = llvm::make_unique<DWARFDebugFrame>(true /* IsEH */);
   DebugFrame->parse(debugFrameData);
   return DebugFrame.get();
 }
 
 const DWARFDebugMacro *DWARFContext::getDebugMacro() {
   if (Macro)
     return Macro.get();
 
   DataExtractor MacinfoData(getMacinfoSection(), isLittleEndian(), 0);
-  Macro.reset(new DWARFDebugMacro());
+  Macro = llvm::make_unique<DWARFDebugMacro>();
   Macro->parse(MacinfoData);
   return Macro.get();
 }
 
 const DWARFLineTable *
 DWARFContext::getLineTableForUnit(DWARFUnit *U) {
   if (!Line)
-    Line.reset(new DWARFDebugLine(&getLineSection().Relocs));
+    Line = llvm::make_unique<DWARFDebugLine>(&getLineSection().Relocs);
 
   auto UnitDIE = U->getUnitDIE();
   if (!UnitDIE)
     return nullptr;
 
   auto Offset = toSectionOffset(UnitDIE.find(DW_AT_stmt_list));
   if (!Offset)
     return nullptr; // No line table for this compile unit.

lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

if (Obj->getArch() == Triple::ppc64) {
     for (section_iterator Section : Obj->sections()) {
       StringRef Name;
       StringRef Data;
       if (auto EC = Section->getName(Name))
         return EC;
       if (Name == ".opd") {
         if (auto EC = Section->getContents(Data))
           return EC;
-        OpdExtractor.reset(new DataExtractor(Data, Obj->isLittleEndian(),
-                                             Obj->getBytesInAddress()));
+        OpdExtractor = llvm::make_unique<DataExtractor>(
+            Data, Obj->isLittleEndian(), Obj->getBytesInAddress());
         OpdAddress = Section->getAddress();
         break;
       }
     }
   }
   std::vector<std::pair<SymbolRef, uint64_t>> Symbols =
       computeSymbolSizes(*Obj);
   for (auto &P : Symbols)

lib/DebugInfo/Symbolize/Symbolize.cpp

if (!EC && DebugInfo != nullptr && !PDBFileName.empty()) {
       using namespace pdb;
       std::unique_ptr<IPDBSession> Session;
       if (auto Err = loadDataForEXE(PDB_ReaderType::DIA,
                                     Objects.first->getFileName(), Session)) {
         Modules.insert(
             std::make_pair(ModuleName, std::unique_ptr<SymbolizableModule>()));
         return std::move(Err);
       }
-      Context.reset(new PDBContext(*CoffObject, std::move(Session)));
+      Context = llvm::make_unique<PDBContext>(*CoffObject, std::move(Session));
     }
   }
   if (!Context)
-    Context.reset(new DWARFContextInMemory(*Objects.second));
+    Context = llvm::make_unique<DWARFContextInMemory>(*Objects.second);
   assert(Context);
   auto InfoOrErr =
       SymbolizableObjectFile::create(Objects.first, std::move(Context));
   std::unique_ptr<SymbolizableModule> SymMod;
   if (InfoOrErr)
     SymMod = std::move(InfoOrErr.get());
   auto InsertResult =
       Modules.insert(std::make_pair(ModuleName, std::move(SymMod)));

lib/MC/MCContext.cpp

 /// useless debug info for them.
 void MCContext::finalizeDwarfSections(MCStreamer &MCOS) {
   SectionsForRanges.remove_if(
       [&](MCSection *Sec) { return !MCOS.mayHaveInstructions(*Sec); });
 }
 
 CodeViewContext &MCContext::getCVContext() {
   if (!CVContext.get())
-    CVContext.reset(new CodeViewContext);
+    CVContext = llvm::make_unique<CodeViewContext>();
   return *CVContext.get();
 }
 
 //===----------------------------------------------------------------------===//
 // Error Reporting
 //===----------------------------------------------------------------------===//
 
 void MCContext::reportError(SMLoc Loc, const Twine &Msg) {

lib/Object/ELFObjectFile.cpp

ObjectFile::createELFObjectFile(MemoryBufferRef Obj) {
 
   if (MaxAlignment < 2)
     return object_error::parse_failed;
 
   std::error_code EC;
   std::unique_ptr<ObjectFile> R;
   if (Ident.first == ELF::ELFCLASS32) {
     if (Ident.second == ELF::ELFDATA2LSB)
-      R.reset(new ELFObjectFile<ELFType<support::little, false>>(Obj, EC));
+      R = llvm::make_unique<ELFObjectFile<ELFType<support::little, false>>>(Obj,
+                                                                            EC);
     else if (Ident.second == ELF::ELFDATA2MSB)
-      R.reset(new ELFObjectFile<ELFType<support::big, false>>(Obj, EC));
+      R = llvm::make_unique<ELFObjectFile<ELFType<support::big, false>>>(Obj,
+                                                                         EC);
     else
       return object_error::parse_failed;
   } else if (Ident.first == ELF::ELFCLASS64) {
     if (Ident.second == ELF::ELFDATA2LSB)
-      R.reset(new ELFObjectFile<ELFType<support::little, true>>(Obj, EC));
+      R = llvm::make_unique<ELFObjectFile<ELFType<support::little, true>>>(Obj,
+                                                                           EC);
     else if (Ident.second == ELF::ELFDATA2MSB)
-      R.reset(new ELFObjectFile<ELFType<support::big, true>>(Obj, EC));
+      R = llvm::make_unique<ELFObjectFile<ELFType<support::big, true>>>(Obj,
+                                                                        EC);
     else
       return object_error::parse_failed;
   } else {
     return object_error::parse_failed;
   }
 
   if (EC)
     return EC;

lib/ObjectYAML/ELFYAML.cpp

if (IO.outputting())
     sectionType = Section->Type;
   else
     IO.mapRequired("Type", sectionType);
 
   switch (sectionType) {
   case ELF::SHT_REL:
   case ELF::SHT_RELA:
     if (!IO.outputting())
-      Section.reset(new ELFYAML::RelocationSection());
+      Section = llvm::make_unique<ELFYAML::RelocationSection>();
     sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));
     break;
   case ELF::SHT_GROUP:
     if (!IO.outputting())
-      Section.reset(new ELFYAML::Group());
+      Section = llvm::make_unique<ELFYAML::Group>();
     groupSectionMapping(IO, *cast<ELFYAML::Group>(Section.get()));
     break;
   case ELF::SHT_NOBITS:
     if (!IO.outputting())
-      Section.reset(new ELFYAML::NoBitsSection());
+      Section = llvm::make_unique<ELFYAML::NoBitsSection>();
     sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
     break;
   case ELF::SHT_MIPS_ABIFLAGS:
     if (!IO.outputting())
-      Section.reset(new ELFYAML::MipsABIFlags());
+      Section = llvm::make_unique<ELFYAML::MipsABIFlags>();
     sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
     break;
   default:
     if (!IO.outputting())
-      Section.reset(new ELFYAML::RawContentSection());
+      Section = llvm::make_unique<ELFYAML::RawContentSection>();
     sectionMapping(IO, *cast<ELFYAML::RawContentSection>(Section.get()));
   }
 }
 
 StringRef MappingTraits<std::unique_ptr<ELFYAML::Section>>::validate(
     IO &io, std::unique_ptr<ELFYAML::Section> &Section) {
   const auto *RawSection = dyn_cast<ELFYAML::RawContentSection>(Section.get());
   if (!RawSection || RawSection->Size >= RawSection->Content.binary_size())

lib/ObjectYAML/ObjectYAML.cpp

if (ObjectFile.Coff)
       MappingTraits<COFFYAML::Object>::mapping(IO, *ObjectFile.Coff);
     if (ObjectFile.MachO)
       MappingTraits<MachOYAML::Object>::mapping(IO, *ObjectFile.MachO);
     if (ObjectFile.FatMachO)
       MappingTraits<MachOYAML::UniversalBinary>::mapping(IO,
                                                          *ObjectFile.FatMachO);
   } else {
     if (IO.mapTag("!ELF")) {
-      ObjectFile.Elf.reset(new ELFYAML::Object());
+      ObjectFile.Elf = llvm::make_unique<ELFYAML::Object>();
       MappingTraits<ELFYAML::Object>::mapping(IO, *ObjectFile.Elf);
     } else if (IO.mapTag("!COFF")) {
-      ObjectFile.Coff.reset(new COFFYAML::Object());
+      ObjectFile.Coff = llvm::make_unique<COFFYAML::Object>();
       MappingTraits<COFFYAML::Object>::mapping(IO, *ObjectFile.Coff);
     } else if (IO.mapTag("!mach-o")) {
-      ObjectFile.MachO.reset(new MachOYAML::Object());
+      ObjectFile.MachO = llvm::make_unique<MachOYAML::Object>();
       MappingTraits<MachOYAML::Object>::mapping(IO, *ObjectFile.MachO);
     } else if (IO.mapTag("!fat-mach-o")) {
-      ObjectFile.FatMachO.reset(new MachOYAML::UniversalBinary());
+      ObjectFile.FatMachO = llvm::make_unique<MachOYAML::UniversalBinary>();
       MappingTraits<MachOYAML::UniversalBinary>::mapping(IO,
                                                          *ObjectFile.FatMachO);
     } else if (IO.mapTag("!WASM")) {
-      ObjectFile.Wasm.reset(new WasmYAML::Object());
+      ObjectFile.Wasm = llvm::make_unique<WasmYAML::Object>();
       MappingTraits<WasmYAML::Object>::mapping(IO, *ObjectFile.Wasm);
     } else {
       Input &In = (Input &)IO;
       std::string Tag = In.getCurrentNode()->getRawTag();
       if (Tag.empty())
         IO.setError("YAML Object File missing document type tag!");
       else
         IO.setError(
             llvm::Twine("YAML Object File unsupported document type tag '") +
             llvm::Twine(Tag) + llvm::Twine("'!"));
     }
   }
 }

lib/ObjectYAML/WasmYAML.cpp

void MappingTraits<std::unique_ptr<WasmYAML::Section>>::mapping(
   if (IO.outputting())
     SectionType = Section->Type;
   else
     IO.mapRequired("Type", SectionType);
 
   switch (SectionType) {
   case wasm::WASM_SEC_CUSTOM:
     if (!IO.outputting())
-      Section.reset(new WasmYAML::CustomSection());
+      Section = llvm::make_unique<WasmYAML::CustomSection>();
     sectionMapping(IO, *cast<WasmYAML::CustomSection>(Section.get()));
     break;
   case wasm::WASM_SEC_TYPE:
     if (!IO.outputting())
-      Section.reset(new WasmYAML::TypeSection());
+      Section = llvm::make_unique<WasmYAML::TypeSection>();
     sectionMapping(IO, *cast<WasmYAML::TypeSection>(Section.get()));
     break;
   case wasm::WASM_SEC_IMPORT:
     if (!IO.outputting())
-      Section.reset(new WasmYAML::ImportSection());
+      Section = llvm::make_unique<WasmYAML::ImportSection>();
     sectionMapping(IO, *cast<WasmYAML::ImportSection>(Section.get()));
     break;
   case wasm::WASM_SEC_FUNCTION:
     if (!IO.outputting())
-      Section.reset(new WasmYAML::FunctionSection());
+      Section = llvm::make_unique<WasmYAML::FunctionSection>();
     sectionMapping(IO, *cast<WasmYAML::FunctionSection>(Section.get()));
     break;
   case wasm::WASM_SEC_TABLE:
     if (!IO.outputting())
-      Section.reset(new WasmYAML::TableSection());
+      Section = llvm::make_unique<WasmYAML::TableSection>();
     sectionMapping(IO, *cast<WasmYAML::TableSection>(Section.get()));
     break;
   case wasm::WASM_SEC_MEMORY:
     if (!IO.outputting())
-      Section.reset(new WasmYAML::MemorySection());
+      Section = llvm::make_unique<WasmYAML::MemorySection>();
     sectionMapping(IO, *cast<WasmYAML::MemorySection>(Section.get()));
     break;
   case wasm::WASM_SEC_GLOBAL:
     if (!IO.outputting())
-      Section.reset(new WasmYAML::GlobalSection());
+      Section = llvm::make_unique<WasmYAML::GlobalSection>();
     sectionMapping(IO, *cast<WasmYAML::GlobalSection>(Section.get()));
     break;
   case wasm::WASM_SEC_EXPORT:
     if (!IO.outputting())
-      Section.reset(new WasmYAML::ExportSection());
+      Section = llvm::make_unique<WasmYAML::ExportSection>();
     sectionMapping(IO, *cast<WasmYAML::ExportSection>(Section.get()));
     break;
   case wasm::WASM_SEC_START:
     if (!IO.outputting())
-      Section.reset(new WasmYAML::StartSection());
+      Section = llvm::make_unique<WasmYAML::StartSection>();
     sectionMapping(IO, *cast<WasmYAML::StartSection>(Section.get()));
     break;
   case wasm::WASM_SEC_ELEM:
     if (!IO.outputting())
-      Section.reset(new WasmYAML::ElemSection());
+      Section = llvm::make_unique<WasmYAML::ElemSection>();
     sectionMapping(IO, *cast<WasmYAML::ElemSection>(Section.get()));
     break;
   case wasm::WASM_SEC_CODE:
     if (!IO.outputting())
-      Section.reset(new WasmYAML::CodeSection());
+      Section = llvm::make_unique<WasmYAML::CodeSection>();
     sectionMapping(IO, *cast<WasmYAML::CodeSection>(Section.get()));
     break;
   case wasm::WASM_SEC_DATA:
     if (!IO.outputting())
-      Section.reset(new WasmYAML::DataSection());
+      Section = llvm::make_unique<WasmYAML::DataSection>();
     sectionMapping(IO, *cast<WasmYAML::DataSection>(Section.get()));
     break;
   default:
     llvm_unreachable("Unknown section type");
   }
 }
 
 void ScalarEnumerationTraits<WasmYAML::SectionType>::enumeration(

lib/ProfileData/InstrProfReader.cpp

if (Buffer->getBufferSize() > std::numeric_limits<unsigned>::max())
     return make_error<InstrProfError>(instrprof_error::too_large);
 
   if (Buffer->getBufferSize() == 0)
     return make_error<InstrProfError>(instrprof_error::empty_raw_profile);
 
   std::unique_ptr<InstrProfReader> Result;
   // Create the reader.
   if (IndexedInstrProfReader::hasFormat(*Buffer))
-    Result.reset(new IndexedInstrProfReader(std::move(Buffer)));
+    Result = llvm::make_unique<IndexedInstrProfReader>(std::move(Buffer));
   else if (RawInstrProfReader64::hasFormat(*Buffer))
-    Result.reset(new RawInstrProfReader64(std::move(Buffer)));
+    Result = llvm::make_unique<RawInstrProfReader64>(std::move(Buffer));
   else if (RawInstrProfReader32::hasFormat(*Buffer))
-    Result.reset(new RawInstrProfReader32(std::move(Buffer)));
+    Result = llvm::make_unique<RawInstrProfReader32>(std::move(Buffer));
   else if (TextInstrProfReader::hasFormat(*Buffer))
-    Result.reset(new TextInstrProfReader(std::move(Buffer)));
+    Result = llvm::make_unique<TextInstrProfReader>(std::move(Buffer));
   else
     return make_error<InstrProfError>(instrprof_error::unrecognized_format);
 
   // Initialize the reader and return the result.
   if (Error E = initializeReader(*Result))
     return std::move(E);
 
   return std::move(Result);
return count == 0 ||
          std::all_of(buffer.begin(), buffer.begin() + count,
                      [](char c) { return ::isprint(c) || ::isspace(c); });
 }
 
 // Read the profile variant flag from the header: ":FE" means this is a FE
 // generated profile. ":IR" means this is an IR level profile. Other strings
 // with a leading ':' will be reported an error format.
 Error TextInstrProfReader::readHeader() {
-  Symtab.reset(new InstrProfSymtab());
+  Symtab = llvm::make_unique<InstrProfSymtab>();
   bool IsIRInstr = false;
   if (!Line->startswith(":")) {
     IsIRLevelProfile = false;
     return success();
   }
   StringRef Str = (Line)->substr(1);
   if (Str.equals_lower("ir"))
     IsIRInstr = true;

lib/ProfileData/SampleProfReader.cpp

 ///
 /// \param C The LLVM context to use to emit diagnostics.
 ///
 /// \returns an error code indicating the status of the created reader.
 ErrorOr<std::unique_ptr<SampleProfileReader>>
 SampleProfileReader::create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C) {
   std::unique_ptr<SampleProfileReader> Reader;
   if (SampleProfileReaderBinary::hasFormat(*B))
-    Reader.reset(new SampleProfileReaderBinary(std::move(B), C));
+    Reader = llvm::make_unique<SampleProfileReaderBinary>(std::move(B), C);
   else if (SampleProfileReaderGCC::hasFormat(*B))
-    Reader.reset(new SampleProfileReaderGCC(std::move(B), C));
+    Reader = llvm::make_unique<SampleProfileReaderGCC>(std::move(B), C);
   else if (SampleProfileReaderText::hasFormat(*B))
-    Reader.reset(new SampleProfileReaderText(std::move(B), C));
+    Reader = llvm::make_unique<SampleProfileReaderText>(std::move(B), C);
   else
     return sampleprof_error::unrecognized_format;
 
   if (std::error_code EC = Reader->readHeader())
     return EC;
 
   return std::move(Reader);
 }

lib/ProfileData/SampleProfWriter.cpp

 /// \param Format Encoding format for the profile file.
 ///
 /// \returns an error code indicating the status of the created writer.
 ErrorOr<std::unique_ptr<SampleProfileWriter>>
 SampleProfileWriter::create(StringRef Filename, SampleProfileFormat Format) {
   std::error_code EC;
   std::unique_ptr<raw_ostream> OS;
   if (Format == SPF_Binary)
-    OS.reset(new raw_fd_ostream(Filename, EC, sys::fs::F_None));
+    OS = llvm::make_unique<raw_fd_ostream>(Filename, EC, sys::fs::F_None);
   else
-    OS.reset(new raw_fd_ostream(Filename, EC, sys::fs::F_Text));
+    OS = llvm::make_unique<raw_fd_ostream>(Filename, EC, sys::fs::F_Text);
   if (EC)
     return EC;
 
   return create(OS, Format);
 }
 
 /// \brief Create a sample profile stream writer based on the specified format.
 ///

lib/Support/SpecialCaseList.cpp

void SpecialCaseList::compile() {
   assert(!IsCompiled && "compile() should only be called once");
   // Iterate through each of the prefixes, and create Regexs for them.
   for (StringMap<StringMap<std::string>>::const_iterator I = Regexps.begin(),
                                                          E = Regexps.end();
        I != E; ++I) {
     for (StringMap<std::string>::const_iterator II = I->second.begin(),
                                                 IE = I->second.end();
          II != IE; ++II) {
-      Entries[I->getKey()][II->getKey()].RegEx.reset(new Regex(II->getValue()));
+      Entries[I->getKey()][II->getKey()].RegEx =
+          llvm::make_unique<Regex>(II->getValue());
     }
   }
   Regexps.clear();
   IsCompiled = true;
 }
 
 SpecialCaseList::~SpecialCaseList() {}
 

lib/Support/YAMLParser.cpp

 
 document_iterator Stream::begin() {
   if (CurrentDoc)
     report_fatal_error("Can only iterate over the stream once");
 
   // Skip Stream-Start.
   scanner->getNext();
 
-  CurrentDoc.reset(new Document(*this));
+  CurrentDoc = llvm::make_unique<Document>(*this);
   return document_iterator(CurrentDoc);
 }
 
 document_iterator Stream::end() {
   return document_iterator();
 }
 
 void Stream::skip() {

lib/Target/AMDGPU/GCNIterativeScheduler.cpp

if (D != DbgE)
       Res.push_back(D->first);
   }
   return Res;
 }
 
 void GCNIterativeScheduler::setBestSchedule(Region &R,
                                             ScheduleRef Schedule,
                                             const GCNRegPressure &MaxRP) {
-  R.BestSchedule.reset(
-    new TentativeSchedule{ detachSchedule(Schedule), MaxRP });
+  R.BestSchedule = llvm::make_unique<TentativeSchedule>(
+      TentativeSchedule{detachSchedule(Schedule), MaxRP});
 }
 
 void GCNIterativeScheduler::scheduleBest(Region &R) {
   assert(R.BestSchedule.get() && "No schedule specified");
   scheduleRegion(R, R.BestSchedule->Schedule, R.BestSchedule->MaxPressure);
   R.BestSchedule.reset();
 }
 

lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

public:
   void ChangeSection(MCSection *Section, const MCExpr *Subsection) override {
     LastMappingSymbols[getCurrentSection().first] = std::move(LastEMSInfo);
     MCELFStreamer::ChangeSection(Section, Subsection);
     auto LastMappingSymbol = LastMappingSymbols.find(Section);
     if (LastMappingSymbol != LastMappingSymbols.end()) {
       LastEMSInfo = std::move(LastMappingSymbol->second);
       return;
     }
-    LastEMSInfo.reset(new ElfMappingSymbolInfo(SMLoc(), nullptr, 0));
+    LastEMSInfo = llvm::make_unique<ElfMappingSymbolInfo>(SMLoc(), nullptr, 0);
   }
 
   /// This function is the one used to emit instruction data into the ELF
   /// streamer. We override it to add the appropriate mapping symbol if
   /// necessary.
   void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
                        bool) override {
     if (IsThumb)

lib/Target/Mips/MipsDelaySlotFiller.cpp

bool Filler::searchSuccBBs(MachineBasicBlock &MBB, Iter Slot) const {
 
   // Do not allow moving instructions which have unallocatable register operands
   // across basic block boundaries.
   RegDU.setUnallocatableRegs(*Fn);
 
   // Only allow moving loads from stack or constants if any of the SuccBB's
   // predecessors have multiple successors.
   if (HasMultipleSuccs) {
-    IM.reset(new LoadFromStackOrConst());
+    IM = llvm::make_unique<LoadFromStackOrConst>();
   } else {
     const MachineFrameInfo &MFI = Fn->getFrameInfo();
-    IM.reset(new MemDefsUses(Fn->getDataLayout(), &MFI));
+    IM = llvm::make_unique<MemDefsUses>(Fn->getDataLayout(), &MFI);
   }
 
   if (!searchRange(MBB, SuccBB->begin(), SuccBB->end(), RegDU, *IM, Slot,
                    Filler))
     return false;
 
   insertDelayFiller(Filler, BrMap);
   addLiveInRegs(Filler, *SuccBB);

lib/Target/PowerPC/PPCISelDAGToDAG.cpp

class BitPermutationSelector {
   // The bool is true if something interesting was deduced, otherwise if we're
   // providing only a generic representation of V (or something else likewise
   // uninteresting for instruction selection) through the SmallVector.
   std::pair<bool, SmallVector<ValueBit, 64> *> getValueBits(SDValue V,
                                                             unsigned NumBits) {
     auto &ValueEntry = Memoizer[V];
     if (ValueEntry)
       return std::make_pair(ValueEntry->first, &ValueEntry->second);
-    ValueEntry.reset(new ValueBitsMemoizedValue());
+    ValueEntry = llvm::make_unique<ValueBitsMemoizedValue>();
     bool &Interesting = ValueEntry->first;
     SmallVector<ValueBit, 64> &Bits = ValueEntry->second;
     Bits.resize(NumBits);
 
     switch (V.getOpcode()) {
     default: break;
     case ISD::ROTL:
       if (isa<ConstantSDNode>(V.getOperand(1))) {

lib/Transforms/IPO/PartialInlining.cpp

void PartialInlinerImpl::computeCallsiteToProfCountMap(
   BlockFrequencyInfo *CurrentCallerBFI = nullptr;
 
   auto ComputeCurrBFI = [&,this](Function *Caller) {
       // For the old pass manager:
       if (!GetBFI) {
         DominatorTree DT(*Caller);
         LoopInfo LI(DT);
         BranchProbabilityInfo BPI(*Caller, LI);
-        TempBFI.reset(new BlockFrequencyInfo(*Caller, BPI, LI));
+        TempBFI = llvm::make_unique<BlockFrequencyInfo>(*Caller, BPI, LI);
         CurrentCallerBFI = TempBFI.get();
       } else {
         // New pass manager:
         CurrentCallerBFI = &(*GetBFI)(*Caller);
       }
   };
 
   for (User *User : Users) {

lib/Transforms/IPO/SampleProfile.cpp

unsigned SampleProfileLoader::getFunctionLoc(Function &F) {
   F.getContext().diagnose(DiagnosticInfoSampleProfile(
       "No debug information found in function " + F.getName() +
           ": Function profile not used",
       DS_Warning));
   return 0;
 }
 
 void SampleProfileLoader::computeDominanceAndLoopInfo(Function &F) {
-  DT.reset(new DominatorTree);
+  DT = llvm::make_unique<DominatorTree>();
   DT->recalculate(F);
 
-  PDT.reset(new DominatorTreeBase<BasicBlock>(true));
+  PDT = llvm::make_unique<DominatorTreeBase<BasicBlock>>(true);
   PDT->recalculate(F);
 
-  LI.reset(new LoopInfo);
+  LI = llvm::make_unique<LoopInfo>();
   LI->analyze(*DT);
 }
 
 /// \brief Generate branch weight metadata for all branches in \p F.
 ///
 /// Branch weights are computed out of instruction samples using a
 /// propagation heuristic. Propagation proceeds in 3 phases:
 ///

lib/Transforms/Scalar/JumpThreading.cpp

bool JumpThreading::runOnFunction(Function &F) {
   auto TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
   auto LVI = &getAnalysis<LazyValueInfoWrapperPass>().getLVI();
   auto AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
   std::unique_ptr<BlockFrequencyInfo> BFI;
   std::unique_ptr<BranchProbabilityInfo> BPI;
   bool HasProfileData = F.getEntryCount().hasValue();
   if (HasProfileData) {
     LoopInfo LI{DominatorTree(F)};
-    BPI.reset(new BranchProbabilityInfo(F, LI, TLI));
-    BFI.reset(new BlockFrequencyInfo(F, *BPI, LI));
+    BPI = llvm::make_unique<BranchProbabilityInfo>(F, LI, TLI);
+    BFI = llvm::make_unique<BlockFrequencyInfo>(F, *BPI, LI);
   }
 
   return Impl.runImpl(F, TLI, LVI, AA, HasProfileData, std::move(BFI),
                       std::move(BPI));
 }
 
 PreservedAnalyses JumpThreadingPass::run(Function &F,
                                          FunctionAnalysisManager &AM) {
 
   auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
   auto &LVI = AM.getResult<LazyValueAnalysis>(F);
   auto &AA = AM.getResult<AAManager>(F);
 
   std::unique_ptr<BlockFrequencyInfo> BFI;
   std::unique_ptr<BranchProbabilityInfo> BPI;
   bool HasProfileData = F.getEntryCount().hasValue();
   if (HasProfileData) {
     LoopInfo LI{DominatorTree(F)};
-    BPI.reset(new BranchProbabilityInfo(F, LI, &TLI));
-    BFI.reset(new BlockFrequencyInfo(F, *BPI, LI));
+    BPI = llvm::make_unique<BranchProbabilityInfo>(F, LI, &TLI);
+    BFI = llvm::make_unique<BlockFrequencyInfo>(F, *BPI, LI);
   }
 
   bool Changed = runImpl(F, &TLI, &LVI, &AA, HasProfileData, std::move(BFI),
                          std::move(BPI));
 
   if (!Changed)
     return PreservedAnalyses::all();
   PreservedAnalyses PA;

lib/Transforms/Scalar/LoopVersioningLICM.cpp

if (skipLoop(L))
     return false;
   // Get Analysis information.
   AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
   SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
   LAA = &getAnalysis<LoopAccessLegacyAnalysis>();
   LAI = nullptr;
   // Set Current Loop
   CurLoop = L;
-  CurAST.reset(new AliasSetTracker(*AA));
+  CurAST = llvm::make_unique<AliasSetTracker>(*AA);
 
   // Loop over the body of this loop, construct AST.
   LoopInfo *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   for (auto *Block : L->getBlocks()) {
     if (LI->getLoopFor(Block) == L) // Ignore blocks in subloop.
       CurAST->add(*Block);          // Incorporate the specified basic block
   }
 

tools/dsymutil/DwarfLinker.cpp

bool DwarfStreamer::init(Triple TheTriple, StringRef OutputFilename) {
   MRI.reset(TheTarget->createMCRegInfo(TripleName));
   if (!MRI)
     return error(Twine("no register info for target ") + TripleName, Context);
 
   MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName));
   if (!MAI)
     return error("no asm info for target " + TripleName, Context);
 
-  MOFI.reset(new MCObjectFileInfo);
-  MC.reset(new MCContext(MAI.get(), MRI.get(), MOFI.get()));
+  MOFI = llvm::make_unique<MCObjectFileInfo>();
+  MC = llvm::make_unique<MCContext>(MAI.get(), MRI.get(), MOFI.get());
   MOFI->InitMCObjectFileInfo(TheTriple, /*PIC*/ false, CodeModel::Default, *MC);
 
   MCTargetOptions Options;
   MAB = TheTarget->createMCAsmBackend(*MRI, TripleName, "", Options);
   if (!MAB)
     return error("no asm backend for target " + TripleName, Context);
 
   MII.reset(TheTarget->createMCInstrInfo());

tools/lli/lli.cpp

if (!ErrorMsg.empty())
       errs() << argv[0] << ": error creating EE: " << ErrorMsg << "\n";
     else
       errs() << argv[0] << ": unknown error creating EE!\n";
     exit(1);
   }
 
   std::unique_ptr<LLIObjectCache> CacheManager;
   if (EnableCacheManager) {
-    CacheManager.reset(new LLIObjectCache(ObjectCacheDir));
+    CacheManager = llvm::make_unique<LLIObjectCache>(ObjectCacheDir);
     EE->setObjectCache(CacheManager.get());
   }
 
   // Load any additional modules specified on the command line.
   for (unsigned i = 0, e = ExtraModules.size(); i != e; ++i) {
     std::unique_ptr<Module> XMod = parseIRFile(ExtraModules[i], Err, Context);
     if (!XMod)
       reportError(Err, argv[0]);
if (ChildPID == 0) {
     // Close the parent ends of the pipes
     close(PipeFD[0][1]);
     close(PipeFD[1][0]);
 
 
     // Execute the child process.
     std::unique_ptr<char[]> ChildPath, ChildIn, ChildOut;
     {
-      ChildPath.reset(new char[ChildExecPath.size() + 1]);
+      ChildPath = llvm::make_unique<char[]>(ChildExecPath.size() + 1);
       std::copy(ChildExecPath.begin(), ChildExecPath.end(), &ChildPath[0]);
       ChildPath[ChildExecPath.size()] = '\0';
       std::string ChildInStr = utostr(PipeFD[0][0]);
-      ChildIn.reset(new char[ChildInStr.size() + 1]);
+      ChildIn = llvm::make_unique<char[]>(ChildInStr.size() + 1);
       std::copy(ChildInStr.begin(), ChildInStr.end(), &ChildIn[0]);
       ChildIn[ChildInStr.size()] = '\0';
       std::string ChildOutStr = utostr(PipeFD[1][1]);
-      ChildOut.reset(new char[ChildOutStr.size() + 1]);
+      ChildOut = llvm::make_unique<char[]>(ChildOutStr.size() + 1);
       std::copy(ChildOutStr.begin(), ChildOutStr.end(), &ChildOut[0]);
       ChildOut[ChildOutStr.size()] = '\0';
     }
 
     char * const args[] = { &ChildPath[0], &ChildIn[0], &ChildOut[0], nullptr };
     int rc = execv(ChildExecPath.c_str(), args);
     if (rc != 0)
       perror("Error executing child process: ");

tools/llvm-dis/llvm-dis.cpp

std::unique_ptr<tool_output_file> Out(
       new tool_output_file(OutputFilename, EC, sys::fs::F_None));
   if (EC) {
     errs() << EC.message() << '\n';
     return 1;
   }
 
   std::unique_ptr<AssemblyAnnotationWriter> Annotator;
   if (ShowAnnotations)
-    Annotator.reset(new CommentWriter());
+    Annotator = llvm::make_unique<CommentWriter>();
 
   // All that llvm-dis does is write the assembly to a file.
   if (!DontPrint)
     M->print(Out->os(), Annotator.get(), PreserveAssemblyUseListOrder);
 
   // Declare success.
   Out->keep();
 
   return 0;
 }

tools/llvm-objdump/MachODump.cpp

static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
   struct DisassembleInfo ThumbSymbolizerInfo;
   std::unique_ptr<MCRelocationInfo> ThumbRelInfo;
   if (ThumbTarget) {
     ThumbMRI.reset(ThumbTarget->createMCRegInfo(ThumbTripleName));
     ThumbAsmInfo.reset(
         ThumbTarget->createMCAsmInfo(*ThumbMRI, ThumbTripleName));
     ThumbSTI.reset(
         ThumbTarget->createMCSubtargetInfo(ThumbTripleName, MCPU, FeaturesStr));
-    ThumbCtx.reset(new MCContext(ThumbAsmInfo.get(), ThumbMRI.get(), nullptr));
+    ThumbCtx = llvm::make_unique<MCContext>(ThumbAsmInfo.get(), ThumbMRI.get(),
+                                            nullptr);
     ThumbDisAsm.reset(ThumbTarget->createMCDisassembler(*ThumbSTI, *ThumbCtx));
     MCContext *PtrThumbCtx = ThumbCtx.get();
     ThumbRelInfo.reset(
         ThumbTarget->createMCRelocationInfo(ThumbTripleName, *PtrThumbCtx));
     if (ThumbRelInfo) {
       ThumbSymbolizer.reset(ThumbTarget->createMCSymbolizer(
           ThumbTripleName, SymbolizerGetOpInfo, SymbolizerSymbolLookUp,
           &ThumbSymbolizerInfo, PtrThumbCtx, std::move(ThumbRelInfo)));
if (!DSYMFile.empty()) {
       }
       DbgObj =
           ObjectFile::createMachOObjectFile(BufOrErr.get()->getMemBufferRef())
               .get()
               .release();
     }
 
     // Setup the DIContext
-    diContext.reset(new DWARFContextInMemory(*DbgObj));
+    diContext = llvm::make_unique<DWARFContextInMemory>(*DbgObj);
   }
 
   if (FilterSections.size() == 0)
     outs() << "(" << DisSegName << "," << DisSectName << ") section\n";
 
   for (unsigned SectIdx = 0; SectIdx != Sections.size(); SectIdx++) {
     StringRef SectName;
     if (Sections[SectIdx].getName(SectName) || SectName != DisSectName)

tools/llvm-objdump/llvm-objdump.cpp

 
 public:
   virtual ~SourcePrinter() {}
   SourcePrinter() : Obj(nullptr), Symbolizer(nullptr) {}
   SourcePrinter(const ObjectFile *Obj, StringRef DefaultArch) : Obj(Obj) {
     symbolize::LLVMSymbolizer::Options SymbolizerOpts(
         DILineInfoSpecifier::FunctionNameKind::None, true, false, false,
         DefaultArch);
-    Symbolizer.reset(new symbolize::LLVMSymbolizer(SymbolizerOpts));
+    Symbolizer = llvm::make_unique<symbolize::LLVMSymbolizer>(SymbolizerOpts);
   }
   virtual void printSourceLine(raw_ostream &OS, uint64_t Address,
                                StringRef Delimiter = "; ");
 };
 
 bool SourcePrinter::cacheSource(std::string File) {
   auto BufferOrError = MemoryBuffer::getFile(File);
   if (!BufferOrError)

tools/llvm-readobj/COFFDumper.cpp

 
 std::error_code createCOFFDumper(const object::ObjectFile *Obj,
                                  ScopedPrinter &Writer,
                                  std::unique_ptr<ObjDumper> &Result) {
   const COFFObjectFile *COFFObj = dyn_cast<COFFObjectFile>(Obj);
   if (!COFFObj)
     return readobj_error::unsupported_obj_file_format;
 
-  Result.reset(new COFFDumper(COFFObj, Writer));
+  Result = llvm::make_unique<COFFDumper>(COFFObj, Writer);
   return readobj_error::success;
 }
 
 } // namespace llvm
 
 // Given a a section and an offset into this section the function returns the
 // symbol used for the relocation at the offset.
 std::error_code COFFDumper::resolveSymbol(const coff_section *Section,

tools/llvm-readobj/ELFDumper.cpp

 } // end anonymous namespace
 
 namespace llvm {
 
 template <class ELFT>
 static std::error_code createELFDumper(const ELFFile<ELFT> *Obj,
                                        ScopedPrinter &Writer,
                                        std::unique_ptr<ObjDumper> &Result) {
-  Result.reset(new ELFDumper<ELFT>(Obj, Writer));
+  Result = llvm::make_unique<ELFDumper<ELFT>>(Obj, Writer);
   return readobj_error::success;
 }
 
 std::error_code createELFDumper(const object::ObjectFile *Obj,
                                 ScopedPrinter &Writer,
                                 std::unique_ptr<ObjDumper> &Result) {
   // Little-endian 32-bit
   if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
case ELF::SHT_GNU_verneed:
       dot_gnu_version_r_sec = &Sec;
       break;
     }
   }
 
   parseDynamicTable(LoadSegments);
 
   if (opts::Output == opts::GNU)
-    ELFDumperStyle.reset(new GNUStyle<ELFT>(Writer, this));
+    ELFDumperStyle = llvm::make_unique<GNUStyle<ELFT>>(Writer, this);
   else
-    ELFDumperStyle.reset(new LLVMStyle<ELFT>(Writer, this));
+    ELFDumperStyle = llvm::make_unique<LLVMStyle<ELFT>>(Writer, this);
 }
 
 template <typename ELFT>
 void ELFDumper<ELFT>::parseDynamicTable(
     ArrayRef<const Elf_Phdr *> LoadSegments) {
   auto toMappedAddr = [&](uint64_t VAddr) -> const uint8_t * {
     const Elf_Phdr *const *I = std::upper_bound(
         LoadSegments.begin(), LoadSegments.end(), VAddr, compareAddr<ELFT>);

tools/llvm-readobj/MachODumper.cpp

 
 std::error_code createMachODumper(const object::ObjectFile *Obj,
                                   ScopedPrinter &Writer,
                                   std::unique_ptr<ObjDumper> &Result) {
   const MachOObjectFile *MachOObj = dyn_cast<MachOObjectFile>(Obj);
   if (!MachOObj)
     return readobj_error::unsupported_obj_file_format;
 
-  Result.reset(new MachODumper(MachOObj, Writer));
+  Result = llvm::make_unique<MachODumper>(MachOObj, Writer);
   return readobj_error::success;
 }
 
 } // namespace llvm
 
 static const EnumEntry<uint32_t> MachOMagics[] = {
   { "Magic",      MachO::MH_MAGIC    },
   { "Cigam",      MachO::MH_CIGAM    },

tools/llvm-readobj/WasmDumper.cpp

 namespace llvm {
 
 std::error_code createWasmDumper(const object::ObjectFile *Obj,
                                  ScopedPrinter &Writer,
                                  std::unique_ptr<ObjDumper> &Result) {
   const WasmObjectFile *WasmObj = dyn_cast<WasmObjectFile>(Obj);
   assert(WasmObj && "createWasmDumper called with non-wasm object");
 
-  Result.reset(new WasmDumper(WasmObj, Writer));
+  Result = llvm::make_unique<WasmDumper>(WasmObj, Writer);
   return readobj_error::success;
 }
 
 } // namespace llvm

tools/llvm-stress/llvm-stress.cpp

int main(int argc, char **argv) {
 
   // Figure out what stream we are supposed to write to...
   std::unique_ptr<tool_output_file> Out;
   // Default to standard output.
   if (OutputFilename.empty())
     OutputFilename = "-";
 
   std::error_code EC;
-  Out.reset(new tool_output_file(OutputFilename, EC, sys::fs::F_None));
+  Out =
+      llvm::make_unique<tool_output_file>(OutputFilename, EC, sys::fs::F_None);
   if (EC) {
     errs() << EC.message() << '\n';
     return 1;
   }
 
   legacy::PassManager Passes;
   Passes.add(createVerifierPass());
   Passes.add(createPrintModulePass(Out->os()));
   Passes.run(*M.get());
   Out->keep();
 
   return 0;
 }

tools/obj2yaml/macho2yaml.cpp

Error macho2yaml(raw_ostream &Out, const object::MachOObjectFile &Obj) {
 
   yaml::Output Yout(Out);
   Yout << YAMLFile;
   return Error::success();
 }
 
 Error macho2yaml(raw_ostream &Out, const object::MachOUniversalBinary &Obj) {
   yaml::YamlObjectFile YAMLFile;
-  YAMLFile.FatMachO.reset(new MachOYAML::UniversalBinary());
+  YAMLFile.FatMachO = llvm::make_unique<MachOYAML::UniversalBinary>();
   MachOYAML::UniversalBinary &YAML = *YAMLFile.FatMachO;
   YAML.Header.magic = Obj.getMagic();
   YAML.Header.nfat_arch = Obj.getNumberOfObjects();
 
   for (auto Slice : Obj.objects()) {
     MachOYAML::FatArch arch;
     arch.cputype = Slice.getCPUType();
     arch.cpusubtype = Slice.getCPUSubType();

tools/opt/opt.cpp

if (!OutputFilename.empty())
       errs() << "WARNING: The -o (output filename) option is ignored when\n"
                 "the --disable-output option is used.\n";
   } else {
     // Default to standard output.
     if (OutputFilename.empty())
       OutputFilename = "-";
 
     std::error_code EC;
-    Out.reset(new tool_output_file(OutputFilename, EC, sys::fs::F_None));
+    Out = llvm::make_unique<tool_output_file>(OutputFilename, EC,
+                                              sys::fs::F_None);
     if (EC) {
       errs() << EC.message() << '\n';
       return 1;
     }
 
     if (!ThinLinkBitcodeFile.empty()) {
-      ThinLinkOut.reset(
-          new tool_output_file(ThinLinkBitcodeFile, EC, sys::fs::F_None));
+      ThinLinkOut = llvm::make_unique<tool_output_file>(ThinLinkBitcodeFile, EC,
+                                                        sys::fs::F_None);
       if (EC) {
         errs() << EC.message() << '\n';
         return 1;
       }
     }
   }
 
   Triple ModuleTriple(M->getTargetTriple());
#endif
 
   // Add internal analysis passes from the target machine.
   Passes.add(createTargetTransformInfoWrapperPass(TM ? TM->getTargetIRAnalysis()
                                                      : TargetIRAnalysis()));
 
   std::unique_ptr<legacy::FunctionPassManager> FPasses;
   if (OptLevelO0 || OptLevelO1 || OptLevelO2 || OptLevelOs || OptLevelOz ||
       OptLevelO3) {
-    FPasses.reset(new legacy::FunctionPassManager(M.get()));
+    FPasses = llvm::make_unique<legacy::FunctionPassManager>(M.get());
     FPasses->add(createTargetTransformInfoWrapperPass(
         TM ? TM->getTargetIRAnalysis() : TargetIRAnalysis()));
   }
 
   if (PrintBreakpoints) {
     // Default to standard output.
     if (!Out) {
       if (OutputFilename.empty())

tools/sancov/sancov.cc

case Bitness32:
     readInts<uint32_t>(Buf->getBufferStart() + 8, Buf->getBufferEnd(),
                        Addrs.get());
     break;
   default:
     errs() << "Unsupported bitness: " << Header->Bitness << '\n';
     return make_error_code(errc::illegal_byte_sequence);
   }
 
-  return std::unique_ptr<RawCoverage>(new RawCoverage(std::move(Addrs)));
+  return llvm::make_unique<RawCoverage>(std::move(Addrs));
 }
 
 // Print coverage addresses.
 raw_ostream &operator<<(raw_ostream &OS, const RawCoverage &CoverageData) {
   for (auto Addr : *CoverageData.Addrs) {
     OS << "0x";
     OS.write_hex(Addr);
     OS << "\n";
if (Pos == std::string::npos)
     return Path;
   return Path.substr(Pos + ClStripPathPrefix.size());
 }
 
 static std::unique_ptr<symbolize::LLVMSymbolizer> createSymbolizer() {
   symbolize::LLVMSymbolizer::Options SymbolizerOptions;
   SymbolizerOptions.Demangle = ClDemangle;
   SymbolizerOptions.UseSymbolTable = true;
-  return std::unique_ptr<symbolize::LLVMSymbolizer>(
-      new symbolize::LLVMSymbolizer(SymbolizerOptions));
+  return llvm::make_unique<symbolize::LLVMSymbolizer>(SymbolizerOptions);
 }
 
 static std::string normalizeFilename(const std::string &FileName) {
   SmallString<256> S(FileName);
   sys::path::remove_dots(S, /* remove_dot_dot */ true);
   return stripPathPrefix(S.str().str());
 }
 

unittests/Analysis/AliasAnalysisTest.cpp

public:
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
     AU.addRequired<TargetLibraryInfoWrapperPass>();
   }
 
   bool doInitialization(Module &M) override {
-    Result.reset(new TestCustomAAResult(std::move(CB)));
+    Result = llvm::make_unique<TestCustomAAResult>(std::move(CB));
     return true;
   }
 
   bool doFinalization(Module &M) override {
     Result.reset();
     return true;
   }
 
protected:
   std::unique_ptr<AssumptionCache> AC;
   std::unique_ptr<BasicAAResult> BAR;
   std::unique_ptr<AAResults> AAR;
 
   AliasAnalysisTest() : M("AliasAnalysisTest", C), TLI(TLII) {}
 
   AAResults &getAAResults(Function &F) {
     // Reset the Function AA results first to clear out any references.
-    AAR.reset(new AAResults(TLI));
+    AAR = llvm::make_unique<AAResults>(TLI);
 
     // Build the various AA results and register them.
-    AC.reset(new AssumptionCache(F));
-    BAR.reset(new BasicAAResult(M.getDataLayout(), TLI, *AC));
+    AC = llvm::make_unique<AssumptionCache>(F);
+    BAR = llvm::make_unique<BasicAAResult>(M.getDataLayout(), TLI, *AC);
     AAR->addAAResult(*BAR);
 
     return *AAR;
   }
 };
 
 TEST_F(AliasAnalysisTest, getModRefInfo) {
   // Setup function.

unittests/Analysis/BlockFrequencyInfoTest.cpp

 class BlockFrequencyInfoTest : public testing::Test {
 protected:
   std::unique_ptr<BranchProbabilityInfo> BPI;
   std::unique_ptr<DominatorTree> DT;
   std::unique_ptr<LoopInfo> LI;
   LLVMContext C;
 
   BlockFrequencyInfo buildBFI(Function &F) {
-    DT.reset(new DominatorTree(F));
-    LI.reset(new LoopInfo(*DT));
-    BPI.reset(new BranchProbabilityInfo(F, *LI));
+    DT = llvm::make_unique<DominatorTree>(F);
+    LI = llvm::make_unique<LoopInfo>(*DT);
+    BPI = llvm::make_unique<BranchProbabilityInfo>(F, *LI);
     return BlockFrequencyInfo(F, *BPI, *LI);
   }
   std::unique_ptr<Module> makeLLVMModule() {
     const char *ModuleStrig = "define i32 @f(i32 %x) {\n"
                               "bb0:\n"
                               "  %y1 = icmp eq i32 %x, 0 \n"
                               "  br i1 %y1, label %bb1, label %bb2 \n"
                               "bb1:\n"

unittests/Analysis/BranchProbabilityInfoTest.cpp

 
 struct BranchProbabilityInfoTest : public testing::Test {
   std::unique_ptr<BranchProbabilityInfo> BPI;
   std::unique_ptr<DominatorTree> DT;
   std::unique_ptr<LoopInfo> LI;
   LLVMContext C;
 
   BranchProbabilityInfo &buildBPI(Function &F) {
-    DT.reset(new DominatorTree(F));
-    LI.reset(new LoopInfo(*DT));
-    BPI.reset(new BranchProbabilityInfo(F, *LI));
+    DT = llvm::make_unique<DominatorTree>(F);
+    LI = llvm::make_unique<LoopInfo>(*DT);
+    BPI = llvm::make_unique<BranchProbabilityInfo>(F, *LI);
     return *BPI;
   }
 
   std::unique_ptr<Module> makeLLVMModule() {
     const char *ModuleString = "define void @f() { exit: ret void }\n";
     SMDiagnostic Err;
     return parseAssemblyString(ModuleString, Err, C);
   }

unittests/Analysis/MemorySSA.cpp

TestAnalyses(MemorySSATest &Test)
       Walker = MSSA->getWalker();
     }
   };
 
   std::unique_ptr<TestAnalyses> Analyses;
 
   void setupAnalyses() {
     assert(F);
-    Analyses.reset(new TestAnalyses(*this));
+    Analyses = llvm::make_unique<TestAnalyses>(*this);
   }
 
 public:
   MemorySSATest()
       : M("MemorySSATest", C), B(C), DL(DLString), TLI(TLII), F(nullptr) {}
 };
 
 TEST_F(MemorySSATest, CreateALoad) {

unittests/Analysis/ProfileSummaryInfoTest.cpp

protected:
   std::unique_ptr<BranchProbabilityInfo> BPI;
   std::unique_ptr<DominatorTree> DT;
   std::unique_ptr<LoopInfo> LI;
 
   ProfileSummaryInfo buildPSI(Module *M) {
     return ProfileSummaryInfo(*M);
   }
   BlockFrequencyInfo buildBFI(Function &F) {
-    DT.reset(new DominatorTree(F));
-    LI.reset(new LoopInfo(*DT));
-    BPI.reset(new BranchProbabilityInfo(F, *LI));
+    DT = llvm::make_unique<DominatorTree>(F);
+    LI = llvm::make_unique<LoopInfo>(*DT);
+    BPI = llvm::make_unique<BranchProbabilityInfo>(F, *LI);
     return BlockFrequencyInfo(F, *BPI, *LI);
   }
   std::unique_ptr<Module> makeLLVMModule(const char *ProfKind = nullptr) {
     const char *ModuleString =
         "define i32 @g(i32 %x) !prof !21 {{\n"
         "  ret i32 0\n"
         "}\n"
         "define i32 @h(i32 %x) !prof !22 {{\n"

unittests/Analysis/ScalarEvolutionTest.cpp

protected:
 
   std::unique_ptr<AssumptionCache> AC;
   std::unique_ptr<DominatorTree> DT;
   std::unique_ptr<LoopInfo> LI;
 
   ScalarEvolutionsTest() : M("", Context), TLII(), TLI(TLII) {}
 
   ScalarEvolution buildSE(Function &F) {
-    AC.reset(new AssumptionCache(F));
-    DT.reset(new DominatorTree(F));
-    LI.reset(new LoopInfo(*DT));
+    AC = llvm::make_unique<AssumptionCache>(F);
+    DT = llvm::make_unique<DominatorTree>(F);
+    LI = llvm::make_unique<LoopInfo>(*DT);
     return ScalarEvolution(F, TLI, *AC, *DT, *LI);
   }
 
   void runWithSE(
       Module &M, StringRef FuncName,
       function_ref<void(Function &F, LoopInfo &LI, ScalarEvolution &SE)> Test) {
     auto *F = M.getFunction(FuncName);
     ASSERT_NE(F, nullptr) << "Could not find " << FuncName;

unittests/DebugInfo/DWARF/DwarfGenerator.cpp

return make_error<StringError>(Twine("no register info for target ") +
                                        TripleName,
                                    inconvertibleErrorCode());
 
   MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName));
   if (!MAI)
     return make_error<StringError>("no asm info for target " + TripleName,
                                    inconvertibleErrorCode());
 
-  MOFI.reset(new MCObjectFileInfo);
-  MC.reset(new MCContext(MAI.get(), MRI.get(), MOFI.get()));
+  MOFI = llvm::make_unique<MCObjectFileInfo>();
+  MC = llvm::make_unique<MCContext>(MAI.get(), MRI.get(), MOFI.get());
   MOFI->InitMCObjectFileInfo(TheTriple, /*PIC*/ false, CodeModel::Default, *MC);
 
   MCTargetOptions Options;
   MAB = TheTarget->createMCAsmBackend(*MRI, TripleName, "", Options);
   if (!MAB)
     return make_error<StringError>("no asm backend for target " + TripleName,
                                    inconvertibleErrorCode());
 
bool dwarfgen::Generator::saveFile(StringRef Path) {
   if (EC)
     return false;
   Strm.write(FileBytes.data(), FileBytes.size());
   Strm.close();
   return true;
 }
 
 dwarfgen::CompileUnit &dwarfgen::Generator::addCompileUnit() {
-  CompileUnits.push_back(std::unique_ptr<CompileUnit>(
-      new CompileUnit(*this, Version, Asm->getPointerSize())));
+  CompileUnits.push_back(
+      llvm::make_unique<CompileUnit>(*this, Version, Asm->getPointerSize()));
   return *CompileUnits.back();
 }

unittests/DebugInfo/PDB/PDBApiTest.cpp

private:
   PDB_SymType Type;
 };
 
 class PDBApiTest : public testing::Test {
 public:
   std::unordered_map<PDB_SymType, std::unique_ptr<PDBSymbol>> SymbolMap;
 
   void SetUp() override {
-    Session.reset(new MockSession());
+    Session = llvm::make_unique<MockSession>();
 
     InsertItemWithTag(PDB_SymType::None);
     InsertItemWithTag(PDB_SymType::Exe);
     InsertItemWithTag(PDB_SymType::Compiland);
     InsertItemWithTag(PDB_SymType::CompilandDetails);
     InsertItemWithTag(PDB_SymType::CompilandEnv);
     InsertItemWithTag(PDB_SymType::Function);
     InsertItemWithTag(PDB_SymType::Block);

unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp

TEST_F(MCJITObjectCacheTest, VerifyLoadFromCache) {
   createJIT(std::move(M));
   TheJIT->setObjectCache(Cache.get());
   TheJIT->finalizeObject();
 
   // Destroy the MCJIT engine we just used
   TheJIT.reset();
 
   // Create a new memory manager.
-  MM.reset(new SectionMemoryManager());
+  MM = llvm::make_unique<SectionMemoryManager>();
 
   // Create a new module and save it. Use a different return code so we can
   // tell if MCJIT compiled this module or used the cache.
   M.reset(createEmptyModule("<main>"));
   Main = insertMainFunction(M.get(), ReplacementRC);
   const Module * SecondModulePointer = M.get();
 
   // Create a new MCJIT instance to load this module then execute it.
TEST_F(MCJITObjectCacheTest, VerifyNonLoadFromCache) {
   createJIT(std::move(M));
   TheJIT->setObjectCache(Cache.get());
   TheJIT->finalizeObject();
 
   // Destroy the MCJIT engine we just used
   TheJIT.reset();
 
   // Create a new memory manager.
-  MM.reset(new SectionMemoryManager());
+  MM = llvm::make_unique<SectionMemoryManager>();
 
   // Create a new module and save it. Use a different return code so we can
   // tell if MCJIT compiled this module or used the cache. Note that we use
   // a new module name here so the module shouldn't be found in the cache.
   M.reset(createEmptyModule("<not-main>"));
   Main = insertMainFunction(M.get(), ReplacementRC);
   const Module * SecondModulePointer = M.get();
 

unittests/IR/IRBuilderTest.cpp

 
 using namespace llvm;
 
 namespace {
 
 class IRBuilderTest : public testing::Test {
 protected:
   void SetUp() override {
-    M.reset(new Module("MyModule", Ctx));
+    M = llvm::make_unique<Module>("MyModule", Ctx);
     FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
                                           /*isVarArg=*/false);
     F = Function::Create(FTy, Function::ExternalLinkage, "", M.get());
     BB = BasicBlock::Create(Ctx, "", F);
     GV = new GlobalVariable(*M, Type::getFloatTy(Ctx), true,
                             GlobalValue::ExternalLinkage, nullptr);
   }
 

unittests/IR/ValueHandleTest.cpp

TEST_F(ValueHandle, DestroyingOtherVHOnSameValueDoesntBreakIteration) {
   // We create the active CallbackVH in the middle of a palindromic
   // arrangement of other VHs so that the bad behavior would be
   // triggered in whichever order callbacks run.
 
   class DestroyingVH final : public CallbackVH {
   public:
     std::unique_ptr<WeakTrackingVH> ToClear[2];
     DestroyingVH(Value *V) {
-      ToClear[0].reset(new WeakTrackingVH(V));
+      ToClear[0] = llvm::make_unique<WeakTrackingVH>(V);
       setValPtr(V);
-      ToClear[1].reset(new WeakTrackingVH(V));
+      ToClear[1] = llvm::make_unique<WeakTrackingVH>(V);
     }
     void deleted() override {
       ToClear[0].reset();
       ToClear[1].reset();
       CallbackVH::deleted();
     }
     void allUsesReplacedWith(Value *) override {
       ToClear[0].reset();

 }
 
 #ifdef GTEST_HAS_DEATH_TEST
 
 TEST_F(ValueHandle, PoisoningVH_Asserts) {
   PoisoningVH<Value> VH(BitcastV.get());
 
   // The poisoned handle shouldn't assert when the value is deleted.
-  BitcastV.reset(new BitCastInst(ConstantV, Type::getInt32Ty(Context)));
+  BitcastV =
+      llvm::make_unique<BitCastInst>(ConstantV, Type::getInt32Ty(Context));
   // But should when we access the handle.
   EXPECT_DEATH((void)*VH, "Accessed a poisoned value handle!");
 
   // Now check that poison catches RAUW.
   VH = BitcastV.get();
   // The replace doesn't trigger anything immediately.
   BitcastV->replaceAllUsesWith(ConstantV);
   // But a use does.
   EXPECT_DEATH((void)*VH, "Accessed a poisoned value handle!");
 
   // Don't clear anything out here as destroying the handles should be fine.
 }
 
 TEST_F(ValueHandle, TrackingVH_Asserts) {
   {
     TrackingVH<Value> VH(BitcastV.get());
 
     // The tracking handle shouldn't assert when the value is deleted.
-    BitcastV.reset(new BitCastInst(ConstantV, Type::getInt32Ty(Context)));
+    BitcastV =
+        llvm::make_unique<BitCastInst>(ConstantV, Type::getInt32Ty(Context));
     // But should when we access the handle.
     EXPECT_DEATH((void)*VH,
                  "TrackingVH must be non-null and valid on dereference!");
   }
 
   {
     TrackingVH<Instruction> VH(BitcastV.get());
 

unittests/Linker/LinkModulesTest.cpp

 
 using namespace llvm;
 
 namespace {
 
 class LinkModuleTest : public testing::Test {
 protected:
   void SetUp() override {
-    M.reset(new Module("MyModule", Ctx));
+    M = llvm::make_unique<Module>("MyModule", Ctx);
     FunctionType *FTy = FunctionType::get(
         Type::getInt8PtrTy(Ctx), Type::getInt32Ty(Ctx), false /*=isVarArg*/);
     F = Function::Create(FTy, Function::ExternalLinkage, "ba_func", M.get());
     F->setCallingConv(CallingConv::C);
 
     EntryBB = BasicBlock::Create(Ctx, "entry", F);
     SwitchCase1BB = BasicBlock::Create(Ctx, "switch.case.1", F);
     SwitchCase2BB = BasicBlock::Create(Ctx, "switch.case.2", F);

unittests/Support/ErrorOrTest.cpp

TEST(ErrorOr, SimpleValue) {
   a = t2();
   EXPECT_FALSE(a);
   EXPECT_EQ(a.getError(), errc::invalid_argument);
 #ifdef EXPECT_DEBUG_DEATH
   EXPECT_DEBUG_DEATH(*a, "Cannot get value when an error exists");
 #endif
 }
 
-ErrorOr<std::unique_ptr<int> > t3() {
-  return std::unique_ptr<int>(new int(3));
-}
+ErrorOr<std::unique_ptr<int>> t3() { return llvm::make_unique<int>(3); }
 
 TEST(ErrorOr, Types) {
   int x;
   ErrorOr<int&> a(x);
   *a = 42;
   EXPECT_EQ(42, x);
 
   // Move only types.

utils/TableGen/DAGISelMatcherOpt.cpp

#if 0
       if ((EN->hasGlue() || EN->hasChain()) &&
           EN->getNumNonChainGlueVTs() > ... need to get no results reliably ...)
         ResultMatch = false;
 #endif
           
       if (ResultsMatch) {
         const SmallVectorImpl<MVT::SimpleValueType> &VTs = EN->getVTList();
         const SmallVectorImpl<unsigned> &Operands = EN->getOperandList();
-        MatcherPtr.reset(new MorphNodeToMatcher(EN->getOpcodeName(),
-                                                VTs, Operands,
-                                                EN->hasChain(), EN->hasInFlag(),
-                                                EN->hasOutFlag(),
-                                                EN->hasMemRefs(),
-                                                EN->getNumFixedArityOperands(),
-                                                Pattern));
+        MatcherPtr = llvm::make_unique<MorphNodeToMatcher>(
+            EN->getOpcodeName(), VTs, Operands, EN->hasChain(), EN->hasInFlag(),
+            EN->hasOutFlag(), EN->hasMemRefs(), EN->getNumFixedArityOperands(),
+            Pattern);
         return;
       }
 
       // FIXME2: Kill off all the SelectionDAG::SelectNodeTo and getMachineNode
       // variants.
     }
   
   ContractNodes(N->getNextPtr(), CGP);
if (AllOpcodeChecks) {
     SmallVector<std::pair<const SDNodeInfo*, Matcher*>, 8> Cases;
     for (unsigned i = 0, e = NewOptionsToMatch.size(); i != e; ++i) {
       CheckOpcodeMatcher *COM = cast<CheckOpcodeMatcher>(NewOptionsToMatch[i]);
       assert(Opcodes.insert(COM->getOpcode().getEnumName()).second &&
              "Duplicate opcodes not factored?");
       Cases.push_back(std::make_pair(&COM->getOpcode(), COM->takeNext()));
       delete COM;
     }
-    
-    MatcherPtr.reset(new SwitchOpcodeMatcher(Cases));
+    MatcherPtr = llvm::make_unique<SwitchOpcodeMatcher>(Cases);
     return;
   }
   
   // If all the options are CheckType's, we can form the SwitchType, woot.
   if (AllTypeChecks) {
     DenseMap<unsigned, unsigned> TypeEntry;
     SmallVector<std::pair<MVT::SimpleValueType, Matcher*>, 8> Cases;
     for (unsigned i = 0, e = NewOptionsToMatch.size(); i != e; ++i) {
for (auto &M : Cases) {
         std::unique_ptr<Matcher> Scope(SM);
         FactorNodes(Scope);
         M.second = Scope.release();
         assert(M.second && "null matcher");
       }
     }
 
     if (Cases.size() != 1) {
-      MatcherPtr.reset(new SwitchTypeMatcher(Cases));
+      MatcherPtr = llvm::make_unique<SwitchTypeMatcher>(Cases);
     } else {
       // If we factored and ended up with one case, create it now.
-      MatcherPtr.reset(new CheckTypeMatcher(Cases[0].first, 0));
+      MatcherPtr = llvm::make_unique<CheckTypeMatcher>(Cases[0].first, 0);
       MatcherPtr->setNext(Cases[0].second);
     }
     return;
   }
   
 
   // Reassemble the Scope node with the adjusted children.
   Scope->setNumChildren(NewOptionsToMatch.size());