Index: lib/Analysis/AliasAnalysis.cpp
===================================================================
--- lib/Analysis/AliasAnalysis.cpp
+++ lib/Analysis/AliasAnalysis.cpp
@@ -613,8 +613,8 @@
   // 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.
Index: lib/Analysis/AliasAnalysisEvaluator.cpp
===================================================================
--- lib/Analysis/AliasAnalysisEvaluator.cpp
+++ lib/Analysis/AliasAnalysisEvaluator.cpp
@@ -362,7 +362,7 @@
   }
 
   bool doInitialization(Module &M) override {
-    P.reset(new AAEvaluator());
+    P = llvm::make_unique<AAEvaluator>();
     return false;
   }
 
Index: lib/Analysis/BasicAliasAnalysis.cpp
===================================================================
--- lib/Analysis/BasicAliasAnalysis.cpp
+++ lib/Analysis/BasicAliasAnalysis.cpp
@@ -1817,9 +1817,9 @@
   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;
 }
Index: lib/Analysis/BlockFrequencyInfo.cpp
===================================================================
--- lib/Analysis/BlockFrequencyInfo.cpp
+++ lib/Analysis/BlockFrequencyInfo.cpp
@@ -163,7 +163,7 @@
                                    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() ||
Index: lib/Analysis/CFLAndersAliasAnalysis.cpp
===================================================================
--- lib/Analysis/CFLAndersAliasAnalysis.cpp
+++ lib/Analysis/CFLAndersAliasAnalysis.cpp
@@ -885,7 +885,7 @@
 
 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 {
Index: lib/Analysis/CFLSteensAliasAnalysis.cpp
===================================================================
--- lib/Analysis/CFLSteensAliasAnalysis.cpp
+++ lib/Analysis/CFLSteensAliasAnalysis.cpp
@@ -361,7 +361,7 @@
 
 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 {
Index: lib/Analysis/CallGraph.cpp
===================================================================
--- lib/Analysis/CallGraph.cpp
+++ lib/Analysis/CallGraph.cpp
@@ -264,7 +264,7 @@
 
 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;
 }
 
Index: lib/Analysis/DependenceAnalysis.cpp
===================================================================
--- lib/Analysis/DependenceAnalysis.cpp
+++ lib/Analysis/DependenceAnalysis.cpp
@@ -142,7 +142,7 @@
   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;
 }
 
Index: lib/Analysis/GlobalsModRef.cpp
===================================================================
--- lib/Analysis/GlobalsModRef.cpp
+++ lib/Analysis/GlobalsModRef.cpp
@@ -974,9 +974,9 @@
 }
 
 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;
 }
 
Index: lib/Analysis/IVUsers.cpp
===================================================================
--- lib/Analysis/IVUsers.cpp
+++ lib/Analysis/IVUsers.cpp
@@ -368,7 +368,7 @@
   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;
 }
 
Index: lib/Analysis/MemorySSA.cpp
===================================================================
--- lib/Analysis/MemorySSA.cpp
+++ lib/Analysis/MemorySSA.cpp
@@ -1923,7 +1923,7 @@
 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;
 }
 
Index: lib/Analysis/ObjCARCAliasAnalysis.cpp
===================================================================
--- lib/Analysis/ObjCARCAliasAnalysis.cpp
+++ lib/Analysis/ObjCARCAliasAnalysis.cpp
@@ -148,7 +148,7 @@
 }
 
 bool ObjCARCAAWrapperPass::doInitialization(Module &M) {
-  Result.reset(new ObjCARCAAResult(M.getDataLayout()));
+  Result = llvm::make_unique<ObjCARCAAResult>(M.getDataLayout());
   return false;
 }
 
Index: lib/Analysis/ProfileSummaryInfo.cpp
===================================================================
--- lib/Analysis/ProfileSummaryInfo.cpp
+++ lib/Analysis/ProfileSummaryInfo.cpp
@@ -211,7 +211,7 @@
 }
 
 bool ProfileSummaryInfoWrapperPass::doInitialization(Module &M) {
-  PSI.reset(new ProfileSummaryInfo(M));
+  PSI = llvm::make_unique<ProfileSummaryInfo>(M);
   return false;
 }
 
Index: lib/Analysis/ScalarEvolution.cpp
===================================================================
--- lib/Analysis/ScalarEvolution.cpp
+++ lib/Analysis/ScalarEvolution.cpp
@@ -10579,11 +10579,11 @@
 }
 
 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;
 }
 
Index: lib/Analysis/ScalarEvolutionAliasAnalysis.cpp
===================================================================
--- lib/Analysis/ScalarEvolutionAliasAnalysis.cpp
+++ lib/Analysis/ScalarEvolutionAliasAnalysis.cpp
@@ -132,8 +132,8 @@
 }
 
 bool SCEVAAWrapperPass::runOnFunction(Function &F) {
-  Result.reset(
-      new SCEVAAResult(getAnalysis<ScalarEvolutionWrapperPass>().getSE()));
+  Result = llvm::make_unique<SCEVAAResult>(
+      getAnalysis<ScalarEvolutionWrapperPass>().getSE());
   return false;
 }
 
Index: lib/Analysis/ScopedNoAliasAA.cpp
===================================================================
--- lib/Analysis/ScopedNoAliasAA.cpp
+++ lib/Analysis/ScopedNoAliasAA.cpp
@@ -193,7 +193,7 @@
 }
 
 bool ScopedNoAliasAAWrapperPass::doInitialization(Module &M) {
-  Result.reset(new ScopedNoAliasAAResult());
+  Result = llvm::make_unique<ScopedNoAliasAAResult>();
   return false;
 }
 
Index: lib/Analysis/TargetLibraryInfo.cpp
===================================================================
--- lib/Analysis/TargetLibraryInfo.cpp
+++ lib/Analysis/TargetLibraryInfo.cpp
@@ -1514,7 +1514,7 @@
   std::unique_ptr<TargetLibraryInfoImpl> &Impl =
       Impls[T.normalize()];
   if (!Impl)
-    Impl.reset(new TargetLibraryInfoImpl(T));
+    Impl = llvm::make_unique<TargetLibraryInfoImpl>(T);
 
   return *Impl;
 }
Index: lib/Analysis/TypeBasedAliasAnalysis.cpp
===================================================================
--- lib/Analysis/TypeBasedAliasAnalysis.cpp
+++ lib/Analysis/TypeBasedAliasAnalysis.cpp
@@ -573,7 +573,7 @@
 }
 
 bool TypeBasedAAWrapperPass::doInitialization(Module &M) {
-  Result.reset(new TypeBasedAAResult());
+  Result = llvm::make_unique<TypeBasedAAResult>();
   return false;
 }
 
Index: lib/CodeGen/BranchRelaxation.cpp
===================================================================
--- lib/CodeGen/BranchRelaxation.cpp
+++ lib/CodeGen/BranchRelaxation.cpp
@@ -489,7 +489,7 @@
 
   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.
Index: lib/CodeGen/CodeGenPrepare.cpp
===================================================================
--- lib/CodeGen/CodeGenPrepare.cpp
+++ lib/CodeGen/CodeGenPrepare.cpp
@@ -743,8 +743,8 @@
   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);
Index: lib/CodeGen/LiveRegMatrix.cpp
===================================================================
--- lib/CodeGen/LiveRegMatrix.cpp
+++ lib/CodeGen/LiveRegMatrix.cpp
@@ -59,7 +59,7 @@
 
   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.
Index: lib/CodeGen/MachineBlockFrequencyInfo.cpp
===================================================================
--- lib/CodeGen/MachineBlockFrequencyInfo.cpp
+++ lib/CodeGen/MachineBlockFrequencyInfo.cpp
@@ -176,7 +176,7 @@
     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() ||
Index: lib/CodeGen/MachineDominators.cpp
===================================================================
--- lib/CodeGen/MachineDominators.cpp
+++ lib/CodeGen/MachineDominators.cpp
@@ -49,7 +49,7 @@
 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;
 }
Index: lib/CodeGen/RegAllocGreedy.cpp
===================================================================
--- lib/CodeGen/RegAllocGreedy.cpp
+++ lib/CodeGen/RegAllocGreedy.cpp
@@ -2752,8 +2752,8 @@
 
   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;
Index: lib/CodeGen/RegisterClassInfo.cpp
===================================================================
--- lib/CodeGen/RegisterClassInfo.cpp
+++ lib/CodeGen/RegisterClassInfo.cpp
@@ -48,9 +48,9 @@
   // 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;
   }
@@ -95,7 +95,7 @@
   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;
Index: lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
===================================================================
--- lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
+++ lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
@@ -3069,8 +3069,8 @@
       // 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,
Index: lib/DebugInfo/DWARF/DWARFContext.cpp
===================================================================
--- lib/DebugInfo/DWARF/DWARFContext.cpp
+++ lib/DebugInfo/DWARF/DWARFContext.cpp
@@ -723,7 +723,7 @@
 
   DataExtractor abbrData(getAbbrevSection(), isLittleEndian(), 0);
 
-  Abbrev.reset(new DWARFDebugAbbrev());
+  Abbrev = llvm::make_unique<DWARFDebugAbbrev>();
   Abbrev->extract(abbrData);
   return Abbrev.get();
 }
@@ -733,7 +733,7 @@
     return AbbrevDWO.get();
 
   DataExtractor abbrData(getAbbrevDWOSection(), isLittleEndian(), 0);
-  AbbrevDWO.reset(new DWARFDebugAbbrev());
+  AbbrevDWO = llvm::make_unique<DWARFDebugAbbrev>();
   AbbrevDWO->extract(abbrData);
   return AbbrevDWO.get();
 }
@@ -743,7 +743,7 @@
     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());
@@ -755,7 +755,7 @@
     return LocDWO.get();
 
   DataExtractor LocData(getLocDWOSection().Data, isLittleEndian(), 0);
-  LocDWO.reset(new DWARFDebugLocDWO());
+  LocDWO = llvm::make_unique<DWARFDebugLocDWO>();
   LocDWO->parse(LocData);
   return LocDWO.get();
 }
@@ -764,7 +764,7 @@
   if (Aranges)
     return Aranges.get();
 
-  Aranges.reset(new DWARFDebugAranges());
+  Aranges = llvm::make_unique<DWARFDebugAranges>();
   Aranges->generate(this);
   return Aranges.get();
 }
@@ -784,7 +784,7 @@
   // 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();
 }
@@ -795,7 +795,7 @@
 
   DataExtractor debugFrameData(getEHFrameSection(), isLittleEndian(),
                                getAddressSize());
-  DebugFrame.reset(new DWARFDebugFrame(true /* IsEH */));
+  DebugFrame = llvm::make_unique<DWARFDebugFrame>(true /* IsEH */);
   DebugFrame->parse(debugFrameData);
   return DebugFrame.get();
 }
@@ -805,7 +805,7 @@
     return Macro.get();
 
   DataExtractor MacinfoData(getMacinfoSection(), isLittleEndian(), 0);
-  Macro.reset(new DWARFDebugMacro());
+  Macro = llvm::make_unique<DWARFDebugMacro>();
   Macro->parse(MacinfoData);
   return Macro.get();
 }
@@ -813,7 +813,7 @@
 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)
Index: lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp
===================================================================
--- lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp
+++ lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp
@@ -60,8 +60,8 @@
       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;
       }
Index: lib/DebugInfo/Symbolize/Symbolize.cpp
===================================================================
--- lib/DebugInfo/Symbolize/Symbolize.cpp
+++ lib/DebugInfo/Symbolize/Symbolize.cpp
@@ -405,11 +405,11 @@
             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));
Index: lib/MC/MCContext.cpp
===================================================================
--- lib/MC/MCContext.cpp
+++ lib/MC/MCContext.cpp
@@ -597,7 +597,7 @@
 
 CodeViewContext &MCContext::getCVContext() {
   if (!CVContext.get())
-    CVContext.reset(new CodeViewContext);
+    CVContext = llvm::make_unique<CodeViewContext>();
   return *CVContext.get();
 }
 
Index: lib/Object/ELFObjectFile.cpp
===================================================================
--- lib/Object/ELFObjectFile.cpp
+++ lib/Object/ELFObjectFile.cpp
@@ -51,16 +51,20 @@
   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 {
Index: lib/ObjectYAML/ELFYAML.cpp
===================================================================
--- lib/ObjectYAML/ELFYAML.cpp
+++ lib/ObjectYAML/ELFYAML.cpp
@@ -742,27 +742,27 @@
   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()));
   }
 }
Index: lib/ObjectYAML/ObjectYAML.cpp
===================================================================
--- lib/ObjectYAML/ObjectYAML.cpp
+++ lib/ObjectYAML/ObjectYAML.cpp
@@ -31,20 +31,20 @@
                                                          *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;
Index: lib/ObjectYAML/WasmYAML.cpp
===================================================================
--- lib/ObjectYAML/WasmYAML.cpp
+++ lib/ObjectYAML/WasmYAML.cpp
@@ -123,62 +123,62 @@
   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:
Index: lib/ProfileData/InstrProfReader.cpp
===================================================================
--- lib/ProfileData/InstrProfReader.cpp
+++ lib/ProfileData/InstrProfReader.cpp
@@ -70,13 +70,13 @@
   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);
 
@@ -136,7 +136,7 @@
 // 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;
Index: lib/ProfileData/SampleProfReader.cpp
===================================================================
--- lib/ProfileData/SampleProfReader.cpp
+++ lib/ProfileData/SampleProfReader.cpp
@@ -785,11 +785,11 @@
 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;
 
Index: lib/ProfileData/SampleProfWriter.cpp
===================================================================
--- lib/ProfileData/SampleProfWriter.cpp
+++ lib/ProfileData/SampleProfWriter.cpp
@@ -258,9 +258,9 @@
   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;
 
Index: lib/Support/SpecialCaseList.cpp
===================================================================
--- lib/Support/SpecialCaseList.cpp
+++ lib/Support/SpecialCaseList.cpp
@@ -149,7 +149,8 @@
     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();
Index: lib/Support/YAMLParser.cpp
===================================================================
--- lib/Support/YAMLParser.cpp
+++ lib/Support/YAMLParser.cpp
@@ -1762,7 +1762,7 @@
   // Skip Stream-Start.
   scanner->getNext();
 
-  CurrentDoc.reset(new Document(*this));
+  CurrentDoc = llvm::make_unique<Document>(*this);
   return document_iterator(CurrentDoc);
 }
 
Index: lib/Target/AMDGPU/GCNIterativeScheduler.cpp
===================================================================
--- lib/Target/AMDGPU/GCNIterativeScheduler.cpp
+++ lib/Target/AMDGPU/GCNIterativeScheduler.cpp
@@ -326,8 +326,8 @@
 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) {
Index: lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
===================================================================
--- lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
+++ lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
@@ -471,7 +471,7 @@
       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
Index: lib/Target/Mips/MipsDelaySlotFiller.cpp
===================================================================
--- lib/Target/Mips/MipsDelaySlotFiller.cpp
+++ lib/Target/Mips/MipsDelaySlotFiller.cpp
@@ -800,10 +800,10 @@
   // 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,
Index: lib/Target/PowerPC/PPCISelDAGToDAG.cpp
===================================================================
--- lib/Target/PowerPC/PPCISelDAGToDAG.cpp
+++ lib/Target/PowerPC/PPCISelDAGToDAG.cpp
@@ -1009,7 +1009,7 @@
     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);
Index: lib/Transforms/IPO/PartialInlining.cpp
===================================================================
--- lib/Transforms/IPO/PartialInlining.cpp
+++ lib/Transforms/IPO/PartialInlining.cpp
@@ -615,7 +615,7 @@
         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:
Index: lib/Transforms/IPO/SampleProfile.cpp
===================================================================
--- lib/Transforms/IPO/SampleProfile.cpp
+++ lib/Transforms/IPO/SampleProfile.cpp
@@ -1277,13 +1277,13 @@
 }
 
 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);
 }
 
Index: lib/Transforms/Scalar/JumpThreading.cpp
===================================================================
--- lib/Transforms/Scalar/JumpThreading.cpp
+++ lib/Transforms/Scalar/JumpThreading.cpp
@@ -132,8 +132,8 @@
   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),
@@ -152,8 +152,8 @@
   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),
Index: lib/Transforms/Scalar/LoopVersioningLICM.cpp
===================================================================
--- lib/Transforms/Scalar/LoopVersioningLICM.cpp
+++ lib/Transforms/Scalar/LoopVersioningLICM.cpp
@@ -526,7 +526,7 @@
   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();
Index: tools/dsymutil/DwarfLinker.cpp
===================================================================
--- tools/dsymutil/DwarfLinker.cpp
+++ tools/dsymutil/DwarfLinker.cpp
@@ -593,8 +593,8 @@
   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;
Index: tools/lli/lli.cpp
===================================================================
--- tools/lli/lli.cpp
+++ tools/lli/lli.cpp
@@ -481,7 +481,7 @@
 
   std::unique_ptr<LLIObjectCache> CacheManager;
   if (EnableCacheManager) {
-    CacheManager.reset(new LLIObjectCache(ObjectCacheDir));
+    CacheManager = llvm::make_unique<LLIObjectCache>(ObjectCacheDir);
     EE->setObjectCache(CacheManager.get());
   }
 
@@ -728,15 +728,15 @@
     // 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';
     }
Index: tools/llvm-dis/llvm-dis.cpp
===================================================================
--- tools/llvm-dis/llvm-dis.cpp
+++ tools/llvm-dis/llvm-dis.cpp
@@ -192,7 +192,7 @@
 
   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)
Index: tools/llvm-objdump/MachODump.cpp
===================================================================
--- tools/llvm-objdump/MachODump.cpp
+++ tools/llvm-objdump/MachODump.cpp
@@ -6465,7 +6465,8 @@
         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(
@@ -6548,7 +6549,7 @@
     }
 
     // Setup the DIContext
-    diContext.reset(new DWARFContextInMemory(*DbgObj));
+    diContext = llvm::make_unique<DWARFContextInMemory>(*DbgObj);
   }
 
   if (FilterSections.size() == 0)
Index: tools/llvm-objdump/llvm-objdump.cpp
===================================================================
--- tools/llvm-objdump/llvm-objdump.cpp
+++ tools/llvm-objdump/llvm-objdump.cpp
@@ -434,7 +434,7 @@
     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 = "; ");
Index: tools/llvm-readobj/COFFDumper.cpp
===================================================================
--- tools/llvm-readobj/COFFDumper.cpp
+++ tools/llvm-readobj/COFFDumper.cpp
@@ -226,7 +226,7 @@
   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;
 }
 
Index: tools/llvm-readobj/ELFDumper.cpp
===================================================================
--- tools/llvm-readobj/ELFDumper.cpp
+++ tools/llvm-readobj/ELFDumper.cpp
@@ -413,7 +413,7 @@
 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;
 }
 
@@ -1321,9 +1321,9 @@
   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>
Index: tools/llvm-readobj/MachODumper.cpp
===================================================================
--- tools/llvm-readobj/MachODumper.cpp
+++ tools/llvm-readobj/MachODumper.cpp
@@ -74,7 +74,7 @@
   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;
 }
 
Index: tools/llvm-readobj/WasmDumper.cpp
===================================================================
--- tools/llvm-readobj/WasmDumper.cpp
+++ tools/llvm-readobj/WasmDumper.cpp
@@ -195,7 +195,7 @@
   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;
 }
 
Index: tools/llvm-stress/llvm-stress.cpp
===================================================================
--- tools/llvm-stress/llvm-stress.cpp
+++ tools/llvm-stress/llvm-stress.cpp
@@ -713,7 +713,8 @@
     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;
Index: tools/obj2yaml/macho2yaml.cpp
===================================================================
--- tools/obj2yaml/macho2yaml.cpp
+++ tools/obj2yaml/macho2yaml.cpp
@@ -503,7 +503,7 @@
 
 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();
Index: tools/opt/opt.cpp
===================================================================
--- tools/opt/opt.cpp
+++ tools/opt/opt.cpp
@@ -475,15 +475,16 @@
       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;
@@ -559,7 +560,7 @@
   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()));
   }
Index: tools/sancov/sancov.cc
===================================================================
--- tools/sancov/sancov.cc
+++ tools/sancov/sancov.cc
@@ -269,7 +269,7 @@
     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.
@@ -567,8 +567,7 @@
   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) {
Index: unittests/Analysis/AliasAnalysisTest.cpp
===================================================================
--- unittests/Analysis/AliasAnalysisTest.cpp
+++ unittests/Analysis/AliasAnalysisTest.cpp
@@ -115,7 +115,7 @@
   }
 
   bool doInitialization(Module &M) override {
-    Result.reset(new TestCustomAAResult(std::move(CB)));
+    Result = llvm::make_unique<TestCustomAAResult>(std::move(CB));
     return true;
   }
 
@@ -152,11 +152,11 @@
 
   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;
Index: unittests/Analysis/BlockFrequencyInfoTest.cpp
===================================================================
--- unittests/Analysis/BlockFrequencyInfoTest.cpp
+++ unittests/Analysis/BlockFrequencyInfoTest.cpp
@@ -33,9 +33,9 @@
   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() {
Index: unittests/Analysis/BranchProbabilityInfoTest.cpp
===================================================================
--- unittests/Analysis/BranchProbabilityInfoTest.cpp
+++ unittests/Analysis/BranchProbabilityInfoTest.cpp
@@ -32,9 +32,9 @@
   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;
   }
 
Index: unittests/Analysis/MemorySSA.cpp
===================================================================
--- unittests/Analysis/MemorySSA.cpp
+++ unittests/Analysis/MemorySSA.cpp
@@ -61,7 +61,7 @@
 
   void setupAnalyses() {
     assert(F);
-    Analyses.reset(new TestAnalyses(*this));
+    Analyses = llvm::make_unique<TestAnalyses>(*this);
   }
 
 public:
Index: unittests/Analysis/ProfileSummaryInfoTest.cpp
===================================================================
--- unittests/Analysis/ProfileSummaryInfoTest.cpp
+++ unittests/Analysis/ProfileSummaryInfoTest.cpp
@@ -40,9 +40,9 @@
     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) {
Index: unittests/Analysis/ScalarEvolutionTest.cpp
===================================================================
--- unittests/Analysis/ScalarEvolutionTest.cpp
+++ unittests/Analysis/ScalarEvolutionTest.cpp
@@ -45,9 +45,9 @@
   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);
   }
 
Index: unittests/DebugInfo/DWARF/DwarfGenerator.cpp
===================================================================
--- unittests/DebugInfo/DWARF/DwarfGenerator.cpp
+++ unittests/DebugInfo/DWARF/DwarfGenerator.cpp
@@ -151,8 +151,8 @@
     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;
@@ -266,7 +266,7 @@
 }
 
 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();
 }
Index: unittests/DebugInfo/PDB/PDBApiTest.cpp
===================================================================
--- unittests/DebugInfo/PDB/PDBApiTest.cpp
+++ unittests/DebugInfo/PDB/PDBApiTest.cpp
@@ -323,7 +323,7 @@
   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);
Index: unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp
===================================================================
--- unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp
+++ unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp
@@ -161,7 +161,7 @@
   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.
@@ -195,7 +195,7 @@
   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
Index: unittests/IR/IRBuilderTest.cpp
===================================================================
--- unittests/IR/IRBuilderTest.cpp
+++ unittests/IR/IRBuilderTest.cpp
@@ -27,7 +27,7 @@
 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());
Index: unittests/IR/ValueHandleTest.cpp
===================================================================
--- unittests/IR/ValueHandleTest.cpp
+++ unittests/IR/ValueHandleTest.cpp
@@ -363,9 +363,9 @@
   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();
@@ -512,7 +512,8 @@
   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!");
 
@@ -531,7 +532,8 @@
     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!");
Index: unittests/Linker/LinkModulesTest.cpp
===================================================================
--- unittests/Linker/LinkModulesTest.cpp
+++ unittests/Linker/LinkModulesTest.cpp
@@ -27,7 +27,7 @@
 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());
Index: unittests/Support/ErrorOrTest.cpp
===================================================================
--- unittests/Support/ErrorOrTest.cpp
+++ unittests/Support/ErrorOrTest.cpp
@@ -37,9 +37,7 @@
 #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;
Index: utils/TableGen/DAGISelMatcherOpt.cpp
===================================================================
--- utils/TableGen/DAGISelMatcherOpt.cpp
+++ utils/TableGen/DAGISelMatcherOpt.cpp
@@ -121,13 +121,10 @@
       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;
       }
 
@@ -399,8 +396,8 @@
       Cases.push_back(std::make_pair(&COM->getOpcode(), COM->takeNext()));
       delete COM;
     }
-    
-    MatcherPtr.reset(new SwitchOpcodeMatcher(Cases));
+
+    MatcherPtr = llvm::make_unique<SwitchOpcodeMatcher>(Cases);
     return;
   }
   
@@ -446,10 +443,10 @@
     }
 
     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;