1 //===--- Warnings.cpp - C-Language Front-end ------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Command line warning options handler. 10 // 11 //===----------------------------------------------------------------------===// 12 // 13 // This file is responsible for handling all warning options. This includes 14 // a number of -Wfoo options and their variants, which are driven by TableGen- 15 // generated data, and the special cases -pedantic, -pedantic-errors, -w, 16 // -Werror and -Wfatal-errors. 17 // 18 // Each warning option controls any number of actual warnings. 19 // Given a warning option 'foo', the following are valid: 20 // -Wfoo, -Wno-foo, -Werror=foo, -Wfatal-errors=foo 21 // 22 // Remark options are also handled here, analogously, except that they are much 23 // simpler because a remark can't be promoted to an error. 24 #include "clang/Basic/AllDiagnostics.h" 25 #include "clang/Basic/Diagnostic.h" 26 #include "clang/Basic/DiagnosticOptions.h" 27 #include <algorithm> 28 #include <cstring> 29 #include <utility> 30 using namespace clang; 31 32 // EmitUnknownDiagWarning - Emit a warning and typo hint for unknown warning 33 // opts 34 static void EmitUnknownDiagWarning(DiagnosticsEngine &Diags, 35 diag::Flavor Flavor, StringRef Prefix, 36 StringRef Opt) { 37 StringRef Suggestion = DiagnosticIDs::getNearestOption(Flavor, Opt); 38 Diags.Report(diag::warn_unknown_diag_option) 39 << (Flavor == diag::Flavor::WarningOrError ? 0 : 1) 40 << (Prefix.str() += std::string(Opt)) << !Suggestion.empty() 41 << (Prefix.str() += std::string(Suggestion)); 42 } 43 44 void clang::ProcessWarningOptions(DiagnosticsEngine &Diags, 45 const DiagnosticOptions &Opts, 46 bool ReportDiags) { 47 Diags.setSuppressSystemWarnings(true); // Default to -Wno-system-headers 48 Diags.setIgnoreAllWarnings(Opts.IgnoreWarnings); 49 Diags.setShowOverloads(Opts.getShowOverloads()); 50 51 Diags.setElideType(Opts.ElideType); 52 Diags.setPrintTemplateTree(Opts.ShowTemplateTree); 53 Diags.setShowColors(Opts.ShowColors); 54 55 // Handle -ferror-limit 56 if (Opts.ErrorLimit) 57 Diags.setErrorLimit(Opts.ErrorLimit); 58 if (Opts.TemplateBacktraceLimit) 59 Diags.setTemplateBacktraceLimit(Opts.TemplateBacktraceLimit); 60 if (Opts.ConstexprBacktraceLimit) 61 Diags.setConstexprBacktraceLimit(Opts.ConstexprBacktraceLimit); 62 63 // If -pedantic or -pedantic-errors was specified, then we want to map all 64 // extension diagnostics onto WARNING or ERROR unless the user has futz'd 65 // around with them explicitly. 66 if (Opts.PedanticErrors) 67 Diags.setExtensionHandlingBehavior(diag::Severity::Error); 68 else if (Opts.Pedantic) 69 Diags.setExtensionHandlingBehavior(diag::Severity::Warning); 70 else 71 Diags.setExtensionHandlingBehavior(diag::Severity::Ignored); 72 73 SmallVector<diag::kind, 10> _Diags; 74 const IntrusiveRefCntPtr< DiagnosticIDs > DiagIDs = 75 Diags.getDiagnosticIDs(); 76 // We parse the warning options twice. The first pass sets diagnostic state, 77 // while the second pass reports warnings/errors. This has the effect that 78 // we follow the more canonical "last option wins" paradigm when there are 79 // conflicting options. 80 for (unsigned Report = 0, ReportEnd = 2; Report != ReportEnd; ++Report) { 81 bool SetDiagnostic = (Report == 0); 82 83 // If we've set the diagnostic state and are not reporting diagnostics then 84 // we're done. 85 if (!SetDiagnostic && !ReportDiags) 86 break; 87 88 for (unsigned i = 0, e = Opts.Warnings.size(); i != e; ++i) { 89 const auto Flavor = diag::Flavor::WarningOrError; 90 StringRef Opt = Opts.Warnings[i]; 91 StringRef OrigOpt = Opts.Warnings[i]; 92 93 // Treat -Wformat=0 as an alias for -Wno-format. 94 if (Opt == "format=0") 95 Opt = "no-format"; 96 97 // Check to see if this warning starts with "no-", if so, this is a 98 // negative form of the option. 99 bool isPositive = !Opt.consume_front("no-"); 100 101 // Figure out how this option affects the warning. If -Wfoo, map the 102 // diagnostic to a warning, if -Wno-foo, map it to ignore. 103 diag::Severity Mapping = 104 isPositive ? diag::Severity::Warning : diag::Severity::Ignored; 105 106 // -Wsystem-headers is a special case, not driven by the option table. It 107 // cannot be controlled with -Werror. 108 if (Opt == "system-headers") { 109 if (SetDiagnostic) 110 Diags.setSuppressSystemWarnings(!isPositive); 111 continue; 112 } 113 114 // -Weverything is a special case as well. It implicitly enables all 115 // warnings, including ones not explicitly in a warning group. 116 if (Opt == "everything") { 117 if (SetDiagnostic) { 118 if (isPositive) { 119 Diags.setEnableAllWarnings(true); 120 } else { 121 Diags.setEnableAllWarnings(false); 122 Diags.setSeverityForAll(Flavor, diag::Severity::Ignored); 123 } 124 } 125 continue; 126 } 127 128 // -Werror/-Wno-error is a special case, not controlled by the option 129 // table. It also has the "specifier" form of -Werror=foo. GCC supports 130 // the deprecated -Werror-implicit-function-declaration which is used by 131 // a few projects. 132 if (Opt.starts_with("error")) { 133 StringRef Specifier; 134 if (Opt.size() > 5) { // Specifier must be present. 135 if (Opt[5] != '=' && 136 Opt.substr(5) != "-implicit-function-declaration") { 137 if (Report) 138 Diags.Report(diag::warn_unknown_warning_specifier) 139 << "-Werror" << ("-W" + OrigOpt.str()); 140 continue; 141 } 142 Specifier = Opt.substr(6); 143 } 144 145 if (Specifier.empty()) { 146 if (SetDiagnostic) 147 Diags.setWarningsAsErrors(isPositive); 148 continue; 149 } 150 151 if (SetDiagnostic) { 152 // Set the warning as error flag for this specifier. 153 Diags.setDiagnosticGroupWarningAsError(Specifier, isPositive); 154 } else if (DiagIDs->getDiagnosticsInGroup(Flavor, Specifier, _Diags)) { 155 EmitUnknownDiagWarning(Diags, Flavor, "-Werror=", Specifier); 156 } 157 continue; 158 } 159 160 // -Wfatal-errors is yet another special case. 161 if (Opt.starts_with("fatal-errors")) { 162 StringRef Specifier; 163 if (Opt.size() != 12) { 164 if ((Opt[12] != '=' && Opt[12] != '-') || Opt.size() == 13) { 165 if (Report) 166 Diags.Report(diag::warn_unknown_warning_specifier) 167 << "-Wfatal-errors" << ("-W" + OrigOpt.str()); 168 continue; 169 } 170 Specifier = Opt.substr(13); 171 } 172 173 if (Specifier.empty()) { 174 if (SetDiagnostic) 175 Diags.setErrorsAsFatal(isPositive); 176 continue; 177 } 178 179 if (SetDiagnostic) { 180 // Set the error as fatal flag for this specifier. 181 Diags.setDiagnosticGroupErrorAsFatal(Specifier, isPositive); 182 } else if (DiagIDs->getDiagnosticsInGroup(Flavor, Specifier, _Diags)) { 183 EmitUnknownDiagWarning(Diags, Flavor, "-Wfatal-errors=", Specifier); 184 } 185 continue; 186 } 187 188 if (Report) { 189 if (DiagIDs->getDiagnosticsInGroup(Flavor, Opt, _Diags)) 190 EmitUnknownDiagWarning(Diags, Flavor, isPositive ? "-W" : "-Wno-", 191 Opt); 192 } else { 193 Diags.setSeverityForGroup(Flavor, Opt, Mapping); 194 } 195 } 196 197 for (StringRef Opt : Opts.Remarks) { 198 const auto Flavor = diag::Flavor::Remark; 199 200 // Check to see if this warning starts with "no-", if so, this is a 201 // negative form of the option. 202 bool IsPositive = !Opt.consume_front("no-"); 203 204 auto Severity = IsPositive ? diag::Severity::Remark 205 : diag::Severity::Ignored; 206 207 // -Reverything sets the state of all remarks. Note that all remarks are 208 // in remark groups, so we don't need a separate 'all remarks enabled' 209 // flag. 210 if (Opt == "everything") { 211 if (SetDiagnostic) 212 Diags.setSeverityForAll(Flavor, Severity); 213 continue; 214 } 215 216 if (Report) { 217 if (DiagIDs->getDiagnosticsInGroup(Flavor, Opt, _Diags)) 218 EmitUnknownDiagWarning(Diags, Flavor, IsPositive ? "-R" : "-Rno-", 219 Opt); 220 } else { 221 Diags.setSeverityForGroup(Flavor, Opt, 222 IsPositive ? diag::Severity::Remark 223 : diag::Severity::Ignored); 224 } 225 } 226 } 227 } 228