maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

NFC cleanup: Prefer make_unique over reset(new T()) 

llvm-svn: 346929
This commit is contained in:
David Blaikie 2018-11-15 03:04:23 +00:00
parent 1013fe7451
commit e0cfc04419
1 changed files with 43 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
clang/lib/Parse/ParsePragma.cpp
View File

@ -261,119 +261,122 @@ struct PragmaAttributeHandler : public PragmaHandler {
} // end namespace } // end namespace
void Parser::initializePragmaHandlers() { void Parser::initializePragmaHandlers() {
AlignHandler.reset(new PragmaAlignHandler()); AlignHandler = llvm::make_unique<PragmaAlignHandler>();
PP.AddPragmaHandler(AlignHandler.get()); PP.AddPragmaHandler(AlignHandler.get());
GCCVisibilityHandler.reset(new PragmaGCCVisibilityHandler()); GCCVisibilityHandler = llvm::make_unique<PragmaGCCVisibilityHandler>();
PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get()); PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get());
OptionsHandler.reset(new PragmaOptionsHandler()); OptionsHandler = llvm::make_unique<PragmaOptionsHandler>();
PP.AddPragmaHandler(OptionsHandler.get()); PP.AddPragmaHandler(OptionsHandler.get());
PackHandler.reset(new PragmaPackHandler()); PackHandler = llvm::make_unique<PragmaPackHandler>();
PP.AddPragmaHandler(PackHandler.get()); PP.AddPragmaHandler(PackHandler.get());
MSStructHandler.reset(new PragmaMSStructHandler()); MSStructHandler = llvm::make_unique<PragmaMSStructHandler>();
PP.AddPragmaHandler(MSStructHandler.get()); PP.AddPragmaHandler(MSStructHandler.get());
UnusedHandler.reset(new PragmaUnusedHandler()); UnusedHandler = llvm::make_unique<PragmaUnusedHandler>();
PP.AddPragmaHandler(UnusedHandler.get()); PP.AddPragmaHandler(UnusedHandler.get());
WeakHandler.reset(new PragmaWeakHandler()); WeakHandler = llvm::make_unique<PragmaWeakHandler>();
PP.AddPragmaHandler(WeakHandler.get()); PP.AddPragmaHandler(WeakHandler.get());
RedefineExtnameHandler.reset(new PragmaRedefineExtnameHandler()); RedefineExtnameHandler = llvm::make_unique<PragmaRedefineExtnameHandler>();
PP.AddPragmaHandler(RedefineExtnameHandler.get()); PP.AddPragmaHandler(RedefineExtnameHandler.get());
FPContractHandler.reset(new PragmaFPContractHandler()); FPContractHandler = llvm::make_unique<PragmaFPContractHandler>();
PP.AddPragmaHandler("STDC", FPContractHandler.get()); PP.AddPragmaHandler("STDC", FPContractHandler.get());
STDCFENVHandler.reset(new PragmaSTDC_FENV_ACCESSHandler()); STDCFENVHandler = llvm::make_unique<PragmaSTDC_FENV_ACCESSHandler>();
PP.AddPragmaHandler("STDC", STDCFENVHandler.get()); PP.AddPragmaHandler("STDC", STDCFENVHandler.get());
STDCCXLIMITHandler.reset(new PragmaSTDC_CX_LIMITED_RANGEHandler()); STDCCXLIMITHandler = llvm::make_unique<PragmaSTDC_CX_LIMITED_RANGEHandler>();
PP.AddPragmaHandler("STDC", STDCCXLIMITHandler.get()); PP.AddPragmaHandler("STDC", STDCCXLIMITHandler.get());
STDCUnknownHandler.reset(new PragmaSTDC_UnknownHandler()); STDCUnknownHandler = llvm::make_unique<PragmaSTDC_UnknownHandler>();
PP.AddPragmaHandler("STDC", STDCUnknownHandler.get()); PP.AddPragmaHandler("STDC", STDCUnknownHandler.get());
PCSectionHandler.reset(new PragmaClangSectionHandler(Actions)); PCSectionHandler = llvm::make_unique<PragmaClangSectionHandler>(Actions);
PP.AddPragmaHandler("clang", PCSectionHandler.get()); PP.AddPragmaHandler("clang", PCSectionHandler.get());
if (getLangOpts().OpenCL) { if (getLangOpts().OpenCL) {
OpenCLExtensionHandler.reset(new PragmaOpenCLExtensionHandler()); OpenCLExtensionHandler = llvm::make_unique<PragmaOpenCLExtensionHandler>();
PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get()); PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get());
PP.AddPragmaHandler("OPENCL", FPContractHandler.get()); PP.AddPragmaHandler("OPENCL", FPContractHandler.get());
} }
if (getLangOpts().OpenMP) if (getLangOpts().OpenMP)
OpenMPHandler.reset(new PragmaOpenMPHandler()); OpenMPHandler = llvm::make_unique<PragmaOpenMPHandler>();
else else
OpenMPHandler.reset(new PragmaNoOpenMPHandler()); OpenMPHandler = llvm::make_unique<PragmaNoOpenMPHandler>();
PP.AddPragmaHandler(OpenMPHandler.get()); PP.AddPragmaHandler(OpenMPHandler.get());
if (getLangOpts().MicrosoftExt || if (getLangOpts().MicrosoftExt ||
getTargetInfo().getTriple().isOSBinFormatELF()) { getTargetInfo().getTriple().isOSBinFormatELF()) {
MSCommentHandler.reset(new PragmaCommentHandler(Actions)); MSCommentHandler = llvm::make_unique<PragmaCommentHandler>(Actions);
PP.AddPragmaHandler(MSCommentHandler.get()); PP.AddPragmaHandler(MSCommentHandler.get());
} }
if (getLangOpts().MicrosoftExt) { if (getLangOpts().MicrosoftExt) {
MSDetectMismatchHandler.reset(new PragmaDetectMismatchHandler(Actions)); MSDetectMismatchHandler =
llvm::make_unique<PragmaDetectMismatchHandler>(Actions);
PP.AddPragmaHandler(MSDetectMismatchHandler.get()); PP.AddPragmaHandler(MSDetectMismatchHandler.get());
MSPointersToMembers.reset(new PragmaMSPointersToMembers()); MSPointersToMembers = llvm::make_unique<PragmaMSPointersToMembers>();
PP.AddPragmaHandler(MSPointersToMembers.get()); PP.AddPragmaHandler(MSPointersToMembers.get());
MSVtorDisp.reset(new PragmaMSVtorDisp()); MSVtorDisp = llvm::make_unique<PragmaMSVtorDisp>();
PP.AddPragmaHandler(MSVtorDisp.get()); PP.AddPragmaHandler(MSVtorDisp.get());
MSInitSeg.reset(new PragmaMSPragma("init_seg")); MSInitSeg = llvm::make_unique<PragmaMSPragma>("init_seg");
PP.AddPragmaHandler(MSInitSeg.get()); PP.AddPragmaHandler(MSInitSeg.get());
MSDataSeg.reset(new PragmaMSPragma("data_seg")); MSDataSeg = llvm::make_unique<PragmaMSPragma>("data_seg");
PP.AddPragmaHandler(MSDataSeg.get()); PP.AddPragmaHandler(MSDataSeg.get());
MSBSSSeg.reset(new PragmaMSPragma("bss_seg")); MSBSSSeg = llvm::make_unique<PragmaMSPragma>("bss_seg");
PP.AddPragmaHandler(MSBSSSeg.get()); PP.AddPragmaHandler(MSBSSSeg.get());
MSConstSeg.reset(new PragmaMSPragma("const_seg")); MSConstSeg = llvm::make_unique<PragmaMSPragma>("const_seg");
PP.AddPragmaHandler(MSConstSeg.get()); PP.AddPragmaHandler(MSConstSeg.get());
MSCodeSeg.reset(new PragmaMSPragma("code_seg")); MSCodeSeg = llvm::make_unique<PragmaMSPragma>("code_seg");
PP.AddPragmaHandler(MSCodeSeg.get()); PP.AddPragmaHandler(MSCodeSeg.get());
MSSection.reset(new PragmaMSPragma("section")); MSSection = llvm::make_unique<PragmaMSPragma>("section");
PP.AddPragmaHandler(MSSection.get()); PP.AddPragmaHandler(MSSection.get());
MSRuntimeChecks.reset(new PragmaMSRuntimeChecksHandler()); MSRuntimeChecks = llvm::make_unique<PragmaMSRuntimeChecksHandler>();
PP.AddPragmaHandler(MSRuntimeChecks.get()); PP.AddPragmaHandler(MSRuntimeChecks.get());
MSIntrinsic.reset(new PragmaMSIntrinsicHandler()); MSIntrinsic = llvm::make_unique<PragmaMSIntrinsicHandler>();
PP.AddPragmaHandler(MSIntrinsic.get()); PP.AddPragmaHandler(MSIntrinsic.get());
MSOptimize.reset(new PragmaMSOptimizeHandler()); MSOptimize = llvm::make_unique<PragmaMSOptimizeHandler>();
PP.AddPragmaHandler(MSOptimize.get()); PP.AddPragmaHandler(MSOptimize.get());
} }
if (getLangOpts().CUDA) { if (getLangOpts().CUDA) {
CUDAForceHostDeviceHandler.reset( CUDAForceHostDeviceHandler =
new PragmaForceCUDAHostDeviceHandler(Actions)); llvm::make_unique<PragmaForceCUDAHostDeviceHandler>(Actions);
PP.AddPragmaHandler("clang", CUDAForceHostDeviceHandler.get()); PP.AddPragmaHandler("clang", CUDAForceHostDeviceHandler.get());
} }
OptimizeHandler.reset(new PragmaOptimizeHandler(Actions)); OptimizeHandler = llvm::make_unique<PragmaOptimizeHandler>(Actions);
PP.AddPragmaHandler("clang", OptimizeHandler.get()); PP.AddPragmaHandler("clang", OptimizeHandler.get());
LoopHintHandler.reset(new PragmaLoopHintHandler()); LoopHintHandler = llvm::make_unique<PragmaLoopHintHandler>();
PP.AddPragmaHandler("clang", LoopHintHandler.get()); PP.AddPragmaHandler("clang", LoopHintHandler.get());
UnrollHintHandler.reset(new PragmaUnrollHintHandler("unroll")); UnrollHintHandler = llvm::make_unique<PragmaUnrollHintHandler>("unroll");
PP.AddPragmaHandler(UnrollHintHandler.get()); PP.AddPragmaHandler(UnrollHintHandler.get());
NoUnrollHintHandler.reset(new PragmaUnrollHintHandler("nounroll")); NoUnrollHintHandler = llvm::make_unique<PragmaUnrollHintHandler>("nounroll");
PP.AddPragmaHandler(NoUnrollHintHandler.get()); PP.AddPragmaHandler(NoUnrollHintHandler.get());
UnrollAndJamHintHandler.reset(new PragmaUnrollHintHandler("unroll_and_jam")); UnrollAndJamHintHandler =
llvm::make_unique<PragmaUnrollHintHandler>("unroll_and_jam");
PP.AddPragmaHandler(UnrollAndJamHintHandler.get()); PP.AddPragmaHandler(UnrollAndJamHintHandler.get());
NoUnrollAndJamHintHandler.reset( NoUnrollAndJamHintHandler =
new PragmaUnrollHintHandler("nounroll_and_jam")); llvm::make_unique<PragmaUnrollHintHandler>("nounroll_and_jam");
PP.AddPragmaHandler(NoUnrollAndJamHintHandler.get()); PP.AddPragmaHandler(NoUnrollAndJamHintHandler.get());
FPHandler.reset(new PragmaFPHandler()); FPHandler = llvm::make_unique<PragmaFPHandler>();
PP.AddPragmaHandler("clang", FPHandler.get()); PP.AddPragmaHandler("clang", FPHandler.get());
AttributePragmaHandler.reset(new PragmaAttributeHandler(AttrFactory)); AttributePragmaHandler =
llvm::make_unique<PragmaAttributeHandler>(AttrFactory);
PP.AddPragmaHandler("clang", AttributePragmaHandler.get()); PP.AddPragmaHandler("clang", AttributePragmaHandler.get());
} }