From: Tyler Nowicki Date: Fri, 18 Jul 2014 19:40:19 +0000 (+0000) Subject: Recommit: Handle diagnostic warnings in Frontend diagnostic handler. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=f123d90865ba7ce63af433cfe932d4a5dda0cb26;p=clang Recommit: Handle diagnostic warnings in Frontend diagnostic handler. Clang uses a diagnostic handler to grab diagnostic messages so it can print them with the line of source code they refer to. This patch extends this to handle optimization failures that were added to llvm to produce a warning when loop vectorization is explicitly specified (using a pragma clang loop directive) but fails. Update renames warning flag name to avoid indicating the flag's severity and adds a test. Reviewed by Alp Toker git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@213400 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/clang/Basic/DiagnosticFrontendKinds.td b/include/clang/Basic/DiagnosticFrontendKinds.td index c08ac992ee..ab0c6cfb1b 100644 --- a/include/clang/Basic/DiagnosticFrontendKinds.td +++ b/include/clang/Basic/DiagnosticFrontendKinds.td @@ -41,6 +41,8 @@ def remark_fe_backend_optimization_remark_missed : Remark<"%0">, BackendInfo, InGroup, DefaultRemark; def remark_fe_backend_optimization_remark_analysis : Remark<"%0">, BackendInfo, InGroup, DefaultRemark; +def warn_fe_backend_optimization_failure : Warning<"%0">, BackendInfo, + InGroup, DefaultWarn; def note_fe_backend_optimization_remark_invalid_loc : Note<"could " "not determine the original source location for %0:%1:%2">; diff --git a/include/clang/Basic/DiagnosticGroups.td b/include/clang/Basic/DiagnosticGroups.td index 3d10fcfef0..840b14b07c 100644 --- a/include/clang/Basic/DiagnosticGroups.td +++ b/include/clang/Basic/DiagnosticGroups.td @@ -704,6 +704,7 @@ def RemarkBackendPlugin : DiagGroup<"remark-backend-plugin">; def BackendOptimizationRemark : DiagGroup<"pass">; def BackendOptimizationRemarkMissed : DiagGroup<"pass-missed">; def BackendOptimizationRemarkAnalysis : DiagGroup<"pass-analysis">; +def BackendOptimizationFailure : DiagGroup<"pass-failed">; // Instrumentation based profiling warnings. def ProfileInstrOutOfDate : DiagGroup<"profile-instr-out-of-date">; diff --git a/lib/CodeGen/CodeGenAction.cpp b/lib/CodeGen/CodeGenAction.cpp index 559c2ef4ba..04d2cd9d53 100644 --- a/lib/CodeGen/CodeGenAction.cpp +++ b/lib/CodeGen/CodeGenAction.cpp @@ -238,15 +238,16 @@ namespace clang { /// \brief Specialized handlers for optimization remarks. /// Note that these handlers only accept remarks and they always handle /// them. - void - EmitOptimizationRemark(const llvm::DiagnosticInfoOptimizationBase &D, - unsigned DiagID); + void EmitOptimizationMessage(const llvm::DiagnosticInfoOptimizationBase &D, + unsigned DiagID); void OptimizationRemarkHandler(const llvm::DiagnosticInfoOptimizationRemark &D); void OptimizationRemarkHandler( const llvm::DiagnosticInfoOptimizationRemarkMissed &D); void OptimizationRemarkHandler( const llvm::DiagnosticInfoOptimizationRemarkAnalysis &D); + void OptimizationFailureHandler( + const llvm::DiagnosticInfoOptimizationFailure &D); }; void BackendConsumer::anchor() {} @@ -416,10 +417,11 @@ BackendConsumer::StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D) { return false; } -void BackendConsumer::EmitOptimizationRemark( +void BackendConsumer::EmitOptimizationMessage( const llvm::DiagnosticInfoOptimizationBase &D, unsigned DiagID) { - // We only support remarks. - assert(D.getSeverity() == llvm::DS_Remark); + // We only support warnings and remarks. + assert(D.getSeverity() == llvm::DS_Remark || + D.getSeverity() == llvm::DS_Warning); SourceManager &SourceMgr = Context->getSourceManager(); FileManager &FileMgr = SourceMgr.getFileManager(); @@ -442,8 +444,9 @@ void BackendConsumer::EmitOptimizationRemark( if (const Decl *FD = Gen->GetDeclForMangledName(D.getFunction().getName())) Loc = FD->getASTContext().getFullLoc(FD->getBodyRBrace()); - Diags.Report(Loc, DiagID) << AddFlagValue(D.getPassName()) - << D.getMsg().str(); + Diags.Report(Loc, DiagID) + << AddFlagValue(D.getPassName() ? D.getPassName() : "") + << D.getMsg().str(); if (DILoc.isInvalid()) // If we were not able to translate the file:line:col information @@ -460,7 +463,7 @@ void BackendConsumer::OptimizationRemarkHandler( // expression that matches the name of the pass name in \p D. if (CodeGenOpts.OptimizationRemarkPattern && CodeGenOpts.OptimizationRemarkPattern->match(D.getPassName())) - EmitOptimizationRemark(D, diag::remark_fe_backend_optimization_remark); + EmitOptimizationMessage(D, diag::remark_fe_backend_optimization_remark); } void BackendConsumer::OptimizationRemarkHandler( @@ -470,8 +473,8 @@ void BackendConsumer::OptimizationRemarkHandler( // name in \p D. if (CodeGenOpts.OptimizationRemarkMissedPattern && CodeGenOpts.OptimizationRemarkMissedPattern->match(D.getPassName())) - EmitOptimizationRemark(D, - diag::remark_fe_backend_optimization_remark_missed); + EmitOptimizationMessage(D, + diag::remark_fe_backend_optimization_remark_missed); } void BackendConsumer::OptimizationRemarkHandler( @@ -481,10 +484,15 @@ void BackendConsumer::OptimizationRemarkHandler( // name in \p D. if (CodeGenOpts.OptimizationRemarkAnalysisPattern && CodeGenOpts.OptimizationRemarkAnalysisPattern->match(D.getPassName())) - EmitOptimizationRemark( + EmitOptimizationMessage( D, diag::remark_fe_backend_optimization_remark_analysis); } +void BackendConsumer::OptimizationFailureHandler( + const llvm::DiagnosticInfoOptimizationFailure &D) { + EmitOptimizationMessage(D, diag::warn_fe_backend_optimization_failure); +} + /// \brief This function is invoked when the backend needs /// to report something to the user. void BackendConsumer::DiagnosticHandlerImpl(const DiagnosticInfo &DI) { @@ -518,6 +526,11 @@ void BackendConsumer::DiagnosticHandlerImpl(const DiagnosticInfo &DI) { OptimizationRemarkHandler( cast(DI)); return; + case llvm::DK_OptimizationFailure: + // Optimization failures are always handled completely by this + // handler. + OptimizationFailureHandler(cast(DI)); + return; default: // Plugin IDs are not bound to any value as they are set dynamically. ComputeDiagRemarkID(Severity, backend_plugin, DiagID); diff --git a/test/Misc/backend-optimization-failure.cpp b/test/Misc/backend-optimization-failure.cpp new file mode 100644 index 0000000000..79b7a3a8cf --- /dev/null +++ b/test/Misc/backend-optimization-failure.cpp @@ -0,0 +1,20 @@ +// RUN: %clang_cc1 %s -O3 -emit-llvm -gline-tables-only -S -verify -o /dev/null + +// Test verifies optimization failures generated by the backend are handled +// correctly by clang. LLVM tests verify all of the failure conditions. + +void test_switch(int *A, int *B, int Length) { +#pragma clang loop vectorize(enable) unroll(disable) + for (int i = 0; i < Length; i++) { + /* expected-warning {{loop not vectorized: failed explicitly specified loop vectorization}} */ switch (A[i]) { + case 0: + B[i] = 1; + break; + case 1: + B[i] = 2; + break; + default: + B[i] = 3; + } + } +}