1 //===--- DiagnosticIDs.cpp - Diagnostic IDs Handling ----------------------===// 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 // This file implements the Diagnostic IDs-related interfaces. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/Basic/DiagnosticIDs.h" 14 #include "clang/Basic/AllDiagnostics.h" 15 #include "clang/Basic/DiagnosticCategories.h" 16 #include "clang/Basic/SourceManager.h" 17 #include "llvm/ADT/STLExtras.h" 18 #include "llvm/ADT/SmallVector.h" 19 #include "llvm/Support/ErrorHandling.h" 20 #include <map> 21 using namespace clang; 22 23 //===----------------------------------------------------------------------===// 24 // Builtin Diagnostic information 25 //===----------------------------------------------------------------------===// 26 27 namespace { 28 29 struct StaticDiagInfoRec; 30 31 // Store the descriptions in a separate table to avoid pointers that need to 32 // be relocated, and also decrease the amount of data needed on 64-bit 33 // platforms. See "How To Write Shared Libraries" by Ulrich Drepper. 34 struct StaticDiagInfoDescriptionStringTable { 35 #define DIAG(ENUM, CLASS, DEFAULT_SEVERITY, DESC, GROUP, SFINAE, NOWERROR, \ 36 SHOWINSYSHEADER, SHOWINSYSMACRO, DEFERRABLE, CATEGORY) \ 37 char ENUM##_desc[sizeof(DESC)]; 38 // clang-format off 39 #include "clang/Basic/DiagnosticCommonKinds.inc" 40 #include "clang/Basic/DiagnosticDriverKinds.inc" 41 #include "clang/Basic/DiagnosticFrontendKinds.inc" 42 #include "clang/Basic/DiagnosticSerializationKinds.inc" 43 #include "clang/Basic/DiagnosticLexKinds.inc" 44 #include "clang/Basic/DiagnosticParseKinds.inc" 45 #include "clang/Basic/DiagnosticASTKinds.inc" 46 #include "clang/Basic/DiagnosticCommentKinds.inc" 47 #include "clang/Basic/DiagnosticCrossTUKinds.inc" 48 #include "clang/Basic/DiagnosticSemaKinds.inc" 49 #include "clang/Basic/DiagnosticAnalysisKinds.inc" 50 #include "clang/Basic/DiagnosticRefactoringKinds.inc" 51 // clang-format on 52 #undef DIAG 53 }; 54 55 const StaticDiagInfoDescriptionStringTable StaticDiagInfoDescriptions = { 56 #define DIAG(ENUM, CLASS, DEFAULT_SEVERITY, DESC, GROUP, SFINAE, NOWERROR, \ 57 SHOWINSYSHEADER, SHOWINSYSMACRO, DEFERRABLE, CATEGORY) \ 58 DESC, 59 // clang-format off 60 #include "clang/Basic/DiagnosticCommonKinds.inc" 61 #include "clang/Basic/DiagnosticDriverKinds.inc" 62 #include "clang/Basic/DiagnosticFrontendKinds.inc" 63 #include "clang/Basic/DiagnosticSerializationKinds.inc" 64 #include "clang/Basic/DiagnosticLexKinds.inc" 65 #include "clang/Basic/DiagnosticParseKinds.inc" 66 #include "clang/Basic/DiagnosticASTKinds.inc" 67 #include "clang/Basic/DiagnosticCommentKinds.inc" 68 #include "clang/Basic/DiagnosticCrossTUKinds.inc" 69 #include "clang/Basic/DiagnosticSemaKinds.inc" 70 #include "clang/Basic/DiagnosticAnalysisKinds.inc" 71 #include "clang/Basic/DiagnosticRefactoringKinds.inc" 72 // clang-format on 73 #undef DIAG 74 }; 75 76 extern const StaticDiagInfoRec StaticDiagInfo[]; 77 78 // Stored separately from StaticDiagInfoRec to pack better. Otherwise, 79 // StaticDiagInfoRec would have extra padding on 64-bit platforms. 80 const uint32_t StaticDiagInfoDescriptionOffsets[] = { 81 #define DIAG(ENUM, CLASS, DEFAULT_SEVERITY, DESC, GROUP, SFINAE, NOWERROR, \ 82 SHOWINSYSHEADER, SHOWINSYSMACRO, DEFERRABLE, CATEGORY) \ 83 offsetof(StaticDiagInfoDescriptionStringTable, ENUM##_desc), 84 // clang-format off 85 #include "clang/Basic/DiagnosticCommonKinds.inc" 86 #include "clang/Basic/DiagnosticDriverKinds.inc" 87 #include "clang/Basic/DiagnosticFrontendKinds.inc" 88 #include "clang/Basic/DiagnosticSerializationKinds.inc" 89 #include "clang/Basic/DiagnosticLexKinds.inc" 90 #include "clang/Basic/DiagnosticParseKinds.inc" 91 #include "clang/Basic/DiagnosticASTKinds.inc" 92 #include "clang/Basic/DiagnosticCommentKinds.inc" 93 #include "clang/Basic/DiagnosticCrossTUKinds.inc" 94 #include "clang/Basic/DiagnosticSemaKinds.inc" 95 #include "clang/Basic/DiagnosticAnalysisKinds.inc" 96 #include "clang/Basic/DiagnosticRefactoringKinds.inc" 97 // clang-format on 98 #undef DIAG 99 }; 100 101 // Diagnostic classes. 102 enum { 103 CLASS_NOTE = 0x01, 104 CLASS_REMARK = 0x02, 105 CLASS_WARNING = 0x03, 106 CLASS_EXTENSION = 0x04, 107 CLASS_ERROR = 0x05 108 }; 109 110 struct StaticDiagInfoRec { 111 uint16_t DiagID; 112 uint8_t DefaultSeverity : 3; 113 uint8_t Class : 3; 114 uint8_t SFINAE : 2; 115 uint8_t Category : 6; 116 uint8_t WarnNoWerror : 1; 117 uint8_t WarnShowInSystemHeader : 1; 118 uint8_t WarnShowInSystemMacro : 1; 119 120 uint16_t OptionGroupIndex : 15; 121 uint16_t Deferrable : 1; 122 123 uint16_t DescriptionLen; 124 125 unsigned getOptionGroupIndex() const { 126 return OptionGroupIndex; 127 } 128 129 StringRef getDescription() const { 130 size_t MyIndex = this - &StaticDiagInfo[0]; 131 uint32_t StringOffset = StaticDiagInfoDescriptionOffsets[MyIndex]; 132 const char* Table = reinterpret_cast<const char*>(&StaticDiagInfoDescriptions); 133 return StringRef(&Table[StringOffset], DescriptionLen); 134 } 135 136 diag::Flavor getFlavor() const { 137 return Class == CLASS_REMARK ? diag::Flavor::Remark 138 : diag::Flavor::WarningOrError; 139 } 140 141 bool operator<(const StaticDiagInfoRec &RHS) const { 142 return DiagID < RHS.DiagID; 143 } 144 }; 145 146 #define STRINGIFY_NAME(NAME) #NAME 147 #define VALIDATE_DIAG_SIZE(NAME) \ 148 static_assert( \ 149 static_cast<unsigned>(diag::NUM_BUILTIN_##NAME##_DIAGNOSTICS) < \ 150 static_cast<unsigned>(diag::DIAG_START_##NAME) + \ 151 static_cast<unsigned>(diag::DIAG_SIZE_##NAME), \ 152 STRINGIFY_NAME( \ 153 DIAG_SIZE_##NAME) " is insufficient to contain all " \ 154 "diagnostics, it may need to be made larger in " \ 155 "DiagnosticIDs.h."); 156 VALIDATE_DIAG_SIZE(COMMON) 157 VALIDATE_DIAG_SIZE(DRIVER) 158 VALIDATE_DIAG_SIZE(FRONTEND) 159 VALIDATE_DIAG_SIZE(SERIALIZATION) 160 VALIDATE_DIAG_SIZE(LEX) 161 VALIDATE_DIAG_SIZE(PARSE) 162 VALIDATE_DIAG_SIZE(AST) 163 VALIDATE_DIAG_SIZE(COMMENT) 164 VALIDATE_DIAG_SIZE(CROSSTU) 165 VALIDATE_DIAG_SIZE(SEMA) 166 VALIDATE_DIAG_SIZE(ANALYSIS) 167 VALIDATE_DIAG_SIZE(REFACTORING) 168 #undef VALIDATE_DIAG_SIZE 169 #undef STRINGIFY_NAME 170 171 const StaticDiagInfoRec StaticDiagInfo[] = { 172 // clang-format off 173 #define DIAG(ENUM, CLASS, DEFAULT_SEVERITY, DESC, GROUP, SFINAE, NOWERROR, \ 174 SHOWINSYSHEADER, SHOWINSYSMACRO, DEFERRABLE, CATEGORY) \ 175 { \ 176 diag::ENUM, \ 177 DEFAULT_SEVERITY, \ 178 CLASS, \ 179 DiagnosticIDs::SFINAE, \ 180 CATEGORY, \ 181 NOWERROR, \ 182 SHOWINSYSHEADER, \ 183 SHOWINSYSMACRO, \ 184 GROUP, \ 185 DEFERRABLE, \ 186 STR_SIZE(DESC, uint16_t)}, 187 #include "clang/Basic/DiagnosticCommonKinds.inc" 188 #include "clang/Basic/DiagnosticDriverKinds.inc" 189 #include "clang/Basic/DiagnosticFrontendKinds.inc" 190 #include "clang/Basic/DiagnosticSerializationKinds.inc" 191 #include "clang/Basic/DiagnosticLexKinds.inc" 192 #include "clang/Basic/DiagnosticParseKinds.inc" 193 #include "clang/Basic/DiagnosticASTKinds.inc" 194 #include "clang/Basic/DiagnosticCommentKinds.inc" 195 #include "clang/Basic/DiagnosticCrossTUKinds.inc" 196 #include "clang/Basic/DiagnosticSemaKinds.inc" 197 #include "clang/Basic/DiagnosticAnalysisKinds.inc" 198 #include "clang/Basic/DiagnosticRefactoringKinds.inc" 199 // clang-format on 200 #undef DIAG 201 }; 202 203 } // namespace 204 205 static const unsigned StaticDiagInfoSize = llvm::array_lengthof(StaticDiagInfo); 206 207 /// GetDiagInfo - Return the StaticDiagInfoRec entry for the specified DiagID, 208 /// or null if the ID is invalid. 209 static const StaticDiagInfoRec *GetDiagInfo(unsigned DiagID) { 210 // Out of bounds diag. Can't be in the table. 211 using namespace diag; 212 if (DiagID >= DIAG_UPPER_LIMIT || DiagID <= DIAG_START_COMMON) 213 return nullptr; 214 215 // Compute the index of the requested diagnostic in the static table. 216 // 1. Add the number of diagnostics in each category preceding the 217 // diagnostic and of the category the diagnostic is in. This gives us 218 // the offset of the category in the table. 219 // 2. Subtract the number of IDs in each category from our ID. This gives us 220 // the offset of the diagnostic in the category. 221 // This is cheaper than a binary search on the table as it doesn't touch 222 // memory at all. 223 unsigned Offset = 0; 224 unsigned ID = DiagID - DIAG_START_COMMON - 1; 225 #define CATEGORY(NAME, PREV) \ 226 if (DiagID > DIAG_START_##NAME) { \ 227 Offset += NUM_BUILTIN_##PREV##_DIAGNOSTICS - DIAG_START_##PREV - 1; \ 228 ID -= DIAG_START_##NAME - DIAG_START_##PREV; \ 229 } 230 CATEGORY(DRIVER, COMMON) 231 CATEGORY(FRONTEND, DRIVER) 232 CATEGORY(SERIALIZATION, FRONTEND) 233 CATEGORY(LEX, SERIALIZATION) 234 CATEGORY(PARSE, LEX) 235 CATEGORY(AST, PARSE) 236 CATEGORY(COMMENT, AST) 237 CATEGORY(CROSSTU, COMMENT) 238 CATEGORY(SEMA, CROSSTU) 239 CATEGORY(ANALYSIS, SEMA) 240 CATEGORY(REFACTORING, ANALYSIS) 241 #undef CATEGORY 242 243 // Avoid out of bounds reads. 244 if (ID + Offset >= StaticDiagInfoSize) 245 return nullptr; 246 247 assert(ID < StaticDiagInfoSize && Offset < StaticDiagInfoSize); 248 249 const StaticDiagInfoRec *Found = &StaticDiagInfo[ID + Offset]; 250 // If the diag id doesn't match we found a different diag, abort. This can 251 // happen when this function is called with an ID that points into a hole in 252 // the diagID space. 253 if (Found->DiagID != DiagID) 254 return nullptr; 255 return Found; 256 } 257 258 static DiagnosticMapping GetDefaultDiagMapping(unsigned DiagID) { 259 DiagnosticMapping Info = DiagnosticMapping::Make( 260 diag::Severity::Fatal, /*IsUser=*/false, /*IsPragma=*/false); 261 262 if (const StaticDiagInfoRec *StaticInfo = GetDiagInfo(DiagID)) { 263 Info.setSeverity((diag::Severity)StaticInfo->DefaultSeverity); 264 265 if (StaticInfo->WarnNoWerror) { 266 assert(Info.getSeverity() == diag::Severity::Warning && 267 "Unexpected mapping with no-Werror bit!"); 268 Info.setNoWarningAsError(true); 269 } 270 } 271 272 return Info; 273 } 274 275 /// getCategoryNumberForDiag - Return the category number that a specified 276 /// DiagID belongs to, or 0 if no category. 277 unsigned DiagnosticIDs::getCategoryNumberForDiag(unsigned DiagID) { 278 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) 279 return Info->Category; 280 return 0; 281 } 282 283 namespace { 284 // The diagnostic category names. 285 struct StaticDiagCategoryRec { 286 const char *NameStr; 287 uint8_t NameLen; 288 289 StringRef getName() const { 290 return StringRef(NameStr, NameLen); 291 } 292 }; 293 } 294 295 // Unfortunately, the split between DiagnosticIDs and Diagnostic is not 296 // particularly clean, but for now we just implement this method here so we can 297 // access GetDefaultDiagMapping. 298 DiagnosticMapping & 299 DiagnosticsEngine::DiagState::getOrAddMapping(diag::kind Diag) { 300 std::pair<iterator, bool> Result = 301 DiagMap.insert(std::make_pair(Diag, DiagnosticMapping())); 302 303 // Initialize the entry if we added it. 304 if (Result.second) 305 Result.first->second = GetDefaultDiagMapping(Diag); 306 307 return Result.first->second; 308 } 309 310 static const StaticDiagCategoryRec CategoryNameTable[] = { 311 #define GET_CATEGORY_TABLE 312 #define CATEGORY(X, ENUM) { X, STR_SIZE(X, uint8_t) }, 313 #include "clang/Basic/DiagnosticGroups.inc" 314 #undef GET_CATEGORY_TABLE 315 { nullptr, 0 } 316 }; 317 318 /// getNumberOfCategories - Return the number of categories 319 unsigned DiagnosticIDs::getNumberOfCategories() { 320 return llvm::array_lengthof(CategoryNameTable) - 1; 321 } 322 323 /// getCategoryNameFromID - Given a category ID, return the name of the 324 /// category, an empty string if CategoryID is zero, or null if CategoryID is 325 /// invalid. 326 StringRef DiagnosticIDs::getCategoryNameFromID(unsigned CategoryID) { 327 if (CategoryID >= getNumberOfCategories()) 328 return StringRef(); 329 return CategoryNameTable[CategoryID].getName(); 330 } 331 332 333 334 DiagnosticIDs::SFINAEResponse 335 DiagnosticIDs::getDiagnosticSFINAEResponse(unsigned DiagID) { 336 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) 337 return static_cast<DiagnosticIDs::SFINAEResponse>(Info->SFINAE); 338 return SFINAE_Report; 339 } 340 341 bool DiagnosticIDs::isDeferrable(unsigned DiagID) { 342 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) 343 return Info->Deferrable; 344 return false; 345 } 346 347 /// getBuiltinDiagClass - Return the class field of the diagnostic. 348 /// 349 static unsigned getBuiltinDiagClass(unsigned DiagID) { 350 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) 351 return Info->Class; 352 return ~0U; 353 } 354 355 //===----------------------------------------------------------------------===// 356 // Custom Diagnostic information 357 //===----------------------------------------------------------------------===// 358 359 namespace clang { 360 namespace diag { 361 class CustomDiagInfo { 362 typedef std::pair<DiagnosticIDs::Level, std::string> DiagDesc; 363 std::vector<DiagDesc> DiagInfo; 364 std::map<DiagDesc, unsigned> DiagIDs; 365 public: 366 367 /// getDescription - Return the description of the specified custom 368 /// diagnostic. 369 StringRef getDescription(unsigned DiagID) const { 370 assert(DiagID - DIAG_UPPER_LIMIT < DiagInfo.size() && 371 "Invalid diagnostic ID"); 372 return DiagInfo[DiagID-DIAG_UPPER_LIMIT].second; 373 } 374 375 /// getLevel - Return the level of the specified custom diagnostic. 376 DiagnosticIDs::Level getLevel(unsigned DiagID) const { 377 assert(DiagID - DIAG_UPPER_LIMIT < DiagInfo.size() && 378 "Invalid diagnostic ID"); 379 return DiagInfo[DiagID-DIAG_UPPER_LIMIT].first; 380 } 381 382 unsigned getOrCreateDiagID(DiagnosticIDs::Level L, StringRef Message, 383 DiagnosticIDs &Diags) { 384 DiagDesc D(L, std::string(Message)); 385 // Check to see if it already exists. 386 std::map<DiagDesc, unsigned>::iterator I = DiagIDs.lower_bound(D); 387 if (I != DiagIDs.end() && I->first == D) 388 return I->second; 389 390 // If not, assign a new ID. 391 unsigned ID = DiagInfo.size()+DIAG_UPPER_LIMIT; 392 DiagIDs.insert(std::make_pair(D, ID)); 393 DiagInfo.push_back(D); 394 return ID; 395 } 396 }; 397 398 } // end diag namespace 399 } // end clang namespace 400 401 402 //===----------------------------------------------------------------------===// 403 // Common Diagnostic implementation 404 //===----------------------------------------------------------------------===// 405 406 DiagnosticIDs::DiagnosticIDs() {} 407 408 DiagnosticIDs::~DiagnosticIDs() {} 409 410 /// getCustomDiagID - Return an ID for a diagnostic with the specified message 411 /// and level. If this is the first request for this diagnostic, it is 412 /// registered and created, otherwise the existing ID is returned. 413 /// 414 /// \param FormatString A fixed diagnostic format string that will be hashed and 415 /// mapped to a unique DiagID. 416 unsigned DiagnosticIDs::getCustomDiagID(Level L, StringRef FormatString) { 417 if (!CustomDiagInfo) 418 CustomDiagInfo.reset(new diag::CustomDiagInfo()); 419 return CustomDiagInfo->getOrCreateDiagID(L, FormatString, *this); 420 } 421 422 423 /// isBuiltinWarningOrExtension - Return true if the unmapped diagnostic 424 /// level of the specified diagnostic ID is a Warning or Extension. 425 /// This only works on builtin diagnostics, not custom ones, and is not legal to 426 /// call on NOTEs. 427 bool DiagnosticIDs::isBuiltinWarningOrExtension(unsigned DiagID) { 428 return DiagID < diag::DIAG_UPPER_LIMIT && 429 getBuiltinDiagClass(DiagID) != CLASS_ERROR; 430 } 431 432 /// Determine whether the given built-in diagnostic ID is a 433 /// Note. 434 bool DiagnosticIDs::isBuiltinNote(unsigned DiagID) { 435 return DiagID < diag::DIAG_UPPER_LIMIT && 436 getBuiltinDiagClass(DiagID) == CLASS_NOTE; 437 } 438 439 /// isBuiltinExtensionDiag - Determine whether the given built-in diagnostic 440 /// ID is for an extension of some sort. This also returns EnabledByDefault, 441 /// which is set to indicate whether the diagnostic is ignored by default (in 442 /// which case -pedantic enables it) or treated as a warning/error by default. 443 /// 444 bool DiagnosticIDs::isBuiltinExtensionDiag(unsigned DiagID, 445 bool &EnabledByDefault) { 446 if (DiagID >= diag::DIAG_UPPER_LIMIT || 447 getBuiltinDiagClass(DiagID) != CLASS_EXTENSION) 448 return false; 449 450 EnabledByDefault = 451 GetDefaultDiagMapping(DiagID).getSeverity() != diag::Severity::Ignored; 452 return true; 453 } 454 455 bool DiagnosticIDs::isDefaultMappingAsError(unsigned DiagID) { 456 if (DiagID >= diag::DIAG_UPPER_LIMIT) 457 return false; 458 459 return GetDefaultDiagMapping(DiagID).getSeverity() >= diag::Severity::Error; 460 } 461 462 /// getDescription - Given a diagnostic ID, return a description of the 463 /// issue. 464 StringRef DiagnosticIDs::getDescription(unsigned DiagID) const { 465 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) 466 return Info->getDescription(); 467 assert(CustomDiagInfo && "Invalid CustomDiagInfo"); 468 return CustomDiagInfo->getDescription(DiagID); 469 } 470 471 static DiagnosticIDs::Level toLevel(diag::Severity SV) { 472 switch (SV) { 473 case diag::Severity::Ignored: 474 return DiagnosticIDs::Ignored; 475 case diag::Severity::Remark: 476 return DiagnosticIDs::Remark; 477 case diag::Severity::Warning: 478 return DiagnosticIDs::Warning; 479 case diag::Severity::Error: 480 return DiagnosticIDs::Error; 481 case diag::Severity::Fatal: 482 return DiagnosticIDs::Fatal; 483 } 484 llvm_unreachable("unexpected severity"); 485 } 486 487 /// getDiagnosticLevel - Based on the way the client configured the 488 /// DiagnosticsEngine object, classify the specified diagnostic ID into a Level, 489 /// by consumable the DiagnosticClient. 490 DiagnosticIDs::Level 491 DiagnosticIDs::getDiagnosticLevel(unsigned DiagID, SourceLocation Loc, 492 const DiagnosticsEngine &Diag) const { 493 // Handle custom diagnostics, which cannot be mapped. 494 if (DiagID >= diag::DIAG_UPPER_LIMIT) { 495 assert(CustomDiagInfo && "Invalid CustomDiagInfo"); 496 return CustomDiagInfo->getLevel(DiagID); 497 } 498 499 unsigned DiagClass = getBuiltinDiagClass(DiagID); 500 if (DiagClass == CLASS_NOTE) return DiagnosticIDs::Note; 501 return toLevel(getDiagnosticSeverity(DiagID, Loc, Diag)); 502 } 503 504 /// Based on the way the client configured the Diagnostic 505 /// object, classify the specified diagnostic ID into a Level, consumable by 506 /// the DiagnosticClient. 507 /// 508 /// \param Loc The source location we are interested in finding out the 509 /// diagnostic state. Can be null in order to query the latest state. 510 diag::Severity 511 DiagnosticIDs::getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc, 512 const DiagnosticsEngine &Diag) const { 513 assert(getBuiltinDiagClass(DiagID) != CLASS_NOTE); 514 515 // Specific non-error diagnostics may be mapped to various levels from ignored 516 // to error. Errors can only be mapped to fatal. 517 diag::Severity Result = diag::Severity::Fatal; 518 519 // Get the mapping information, or compute it lazily. 520 DiagnosticsEngine::DiagState *State = Diag.GetDiagStateForLoc(Loc); 521 DiagnosticMapping &Mapping = State->getOrAddMapping((diag::kind)DiagID); 522 523 // TODO: Can a null severity really get here? 524 if (Mapping.getSeverity() != diag::Severity()) 525 Result = Mapping.getSeverity(); 526 527 // Upgrade ignored diagnostics if -Weverything is enabled. 528 if (State->EnableAllWarnings && Result == diag::Severity::Ignored && 529 !Mapping.isUser() && getBuiltinDiagClass(DiagID) != CLASS_REMARK) 530 Result = diag::Severity::Warning; 531 532 // Ignore -pedantic diagnostics inside __extension__ blocks. 533 // (The diagnostics controlled by -pedantic are the extension diagnostics 534 // that are not enabled by default.) 535 bool EnabledByDefault = false; 536 bool IsExtensionDiag = isBuiltinExtensionDiag(DiagID, EnabledByDefault); 537 if (Diag.AllExtensionsSilenced && IsExtensionDiag && !EnabledByDefault) 538 return diag::Severity::Ignored; 539 540 // For extension diagnostics that haven't been explicitly mapped, check if we 541 // should upgrade the diagnostic. 542 if (IsExtensionDiag && !Mapping.isUser()) 543 Result = std::max(Result, State->ExtBehavior); 544 545 // At this point, ignored errors can no longer be upgraded. 546 if (Result == diag::Severity::Ignored) 547 return Result; 548 549 // Honor -w: this disables all messages which which are not Error/Fatal by 550 // default (disregarding attempts to upgrade severity from Warning to Error), 551 // as well as disabling all messages which are currently mapped to Warning 552 // (whether by default or downgraded from Error via e.g. -Wno-error or #pragma 553 // diagnostic.) 554 if (State->IgnoreAllWarnings) { 555 if (Result == diag::Severity::Warning || 556 (Result >= diag::Severity::Error && 557 !isDefaultMappingAsError((diag::kind)DiagID))) 558 return diag::Severity::Ignored; 559 } 560 561 // If -Werror is enabled, map warnings to errors unless explicitly disabled. 562 if (Result == diag::Severity::Warning) { 563 if (State->WarningsAsErrors && !Mapping.hasNoWarningAsError()) 564 Result = diag::Severity::Error; 565 } 566 567 // If -Wfatal-errors is enabled, map errors to fatal unless explicitly 568 // disabled. 569 if (Result == diag::Severity::Error) { 570 if (State->ErrorsAsFatal && !Mapping.hasNoErrorAsFatal()) 571 Result = diag::Severity::Fatal; 572 } 573 574 // If explicitly requested, map fatal errors to errors. 575 if (Result == diag::Severity::Fatal && 576 Diag.CurDiagID != diag::fatal_too_many_errors && Diag.FatalsAsError) 577 Result = diag::Severity::Error; 578 579 // Custom diagnostics always are emitted in system headers. 580 bool ShowInSystemHeader = 581 !GetDiagInfo(DiagID) || GetDiagInfo(DiagID)->WarnShowInSystemHeader; 582 583 // If we are in a system header, we ignore it. We look at the diagnostic class 584 // because we also want to ignore extensions and warnings in -Werror and 585 // -pedantic-errors modes, which *map* warnings/extensions to errors. 586 if (State->SuppressSystemWarnings && !ShowInSystemHeader && Loc.isValid() && 587 Diag.getSourceManager().isInSystemHeader( 588 Diag.getSourceManager().getExpansionLoc(Loc))) 589 return diag::Severity::Ignored; 590 591 // We also ignore warnings due to system macros 592 bool ShowInSystemMacro = 593 !GetDiagInfo(DiagID) || GetDiagInfo(DiagID)->WarnShowInSystemMacro; 594 if (State->SuppressSystemWarnings && !ShowInSystemMacro && Loc.isValid() && 595 Diag.getSourceManager().isInSystemMacro(Loc)) 596 return diag::Severity::Ignored; 597 598 return Result; 599 } 600 601 #define GET_DIAG_ARRAYS 602 #include "clang/Basic/DiagnosticGroups.inc" 603 #undef GET_DIAG_ARRAYS 604 605 namespace { 606 struct WarningOption { 607 uint16_t NameOffset; 608 uint16_t Members; 609 uint16_t SubGroups; 610 StringRef Documentation; 611 612 // String is stored with a pascal-style length byte. 613 StringRef getName() const { 614 return StringRef(DiagGroupNames + NameOffset + 1, 615 DiagGroupNames[NameOffset]); 616 } 617 }; 618 } 619 620 // Second the table of options, sorted by name for fast binary lookup. 621 static const WarningOption OptionTable[] = { 622 #define DIAG_ENTRY(GroupName, FlagNameOffset, Members, SubGroups, Docs) \ 623 {FlagNameOffset, Members, SubGroups, Docs}, 624 #include "clang/Basic/DiagnosticGroups.inc" 625 #undef DIAG_ENTRY 626 }; 627 628 /// Given a diagnostic group ID, return its documentation. 629 StringRef DiagnosticIDs::getWarningOptionDocumentation(diag::Group Group) { 630 return OptionTable[static_cast<int>(Group)].Documentation; 631 } 632 633 StringRef DiagnosticIDs::getWarningOptionForGroup(diag::Group Group) { 634 return OptionTable[static_cast<int>(Group)].getName(); 635 } 636 637 llvm::Optional<diag::Group> 638 DiagnosticIDs::getGroupForWarningOption(StringRef Name) { 639 const auto *Found = llvm::partition_point( 640 OptionTable, [=](const WarningOption &O) { return O.getName() < Name; }); 641 if (Found == std::end(OptionTable) || Found->getName() != Name) 642 return llvm::None; 643 return static_cast<diag::Group>(Found - OptionTable); 644 } 645 646 llvm::Optional<diag::Group> DiagnosticIDs::getGroupForDiag(unsigned DiagID) { 647 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) 648 return static_cast<diag::Group>(Info->getOptionGroupIndex()); 649 return llvm::None; 650 } 651 652 /// getWarningOptionForDiag - Return the lowest-level warning option that 653 /// enables the specified diagnostic. If there is no -Wfoo flag that controls 654 /// the diagnostic, this returns null. 655 StringRef DiagnosticIDs::getWarningOptionForDiag(unsigned DiagID) { 656 if (auto G = getGroupForDiag(DiagID)) 657 return getWarningOptionForGroup(*G); 658 return StringRef(); 659 } 660 661 std::vector<std::string> DiagnosticIDs::getDiagnosticFlags() { 662 std::vector<std::string> Res{"-W", "-Wno-"}; 663 for (size_t I = 1; DiagGroupNames[I] != '\0';) { 664 std::string Diag(DiagGroupNames + I + 1, DiagGroupNames[I]); 665 I += DiagGroupNames[I] + 1; 666 Res.push_back("-W" + Diag); 667 Res.push_back("-Wno-" + Diag); 668 } 669 670 return Res; 671 } 672 673 /// Return \c true if any diagnostics were found in this group, even if they 674 /// were filtered out due to having the wrong flavor. 675 static bool getDiagnosticsInGroup(diag::Flavor Flavor, 676 const WarningOption *Group, 677 SmallVectorImpl<diag::kind> &Diags) { 678 // An empty group is considered to be a warning group: we have empty groups 679 // for GCC compatibility, and GCC does not have remarks. 680 if (!Group->Members && !Group->SubGroups) 681 return Flavor == diag::Flavor::Remark; 682 683 bool NotFound = true; 684 685 // Add the members of the option diagnostic set. 686 const int16_t *Member = DiagArrays + Group->Members; 687 for (; *Member != -1; ++Member) { 688 if (GetDiagInfo(*Member)->getFlavor() == Flavor) { 689 NotFound = false; 690 Diags.push_back(*Member); 691 } 692 } 693 694 // Add the members of the subgroups. 695 const int16_t *SubGroups = DiagSubGroups + Group->SubGroups; 696 for (; *SubGroups != (int16_t)-1; ++SubGroups) 697 NotFound &= getDiagnosticsInGroup(Flavor, &OptionTable[(short)*SubGroups], 698 Diags); 699 700 return NotFound; 701 } 702 703 bool 704 DiagnosticIDs::getDiagnosticsInGroup(diag::Flavor Flavor, StringRef Group, 705 SmallVectorImpl<diag::kind> &Diags) const { 706 if (llvm::Optional<diag::Group> G = getGroupForWarningOption(Group)) 707 return ::getDiagnosticsInGroup( 708 Flavor, &OptionTable[static_cast<unsigned>(*G)], Diags); 709 return true; 710 } 711 712 void DiagnosticIDs::getAllDiagnostics(diag::Flavor Flavor, 713 std::vector<diag::kind> &Diags) { 714 for (unsigned i = 0; i != StaticDiagInfoSize; ++i) 715 if (StaticDiagInfo[i].getFlavor() == Flavor) 716 Diags.push_back(StaticDiagInfo[i].DiagID); 717 } 718 719 StringRef DiagnosticIDs::getNearestOption(diag::Flavor Flavor, 720 StringRef Group) { 721 StringRef Best; 722 unsigned BestDistance = Group.size() + 1; // Maximum threshold. 723 for (const WarningOption &O : OptionTable) { 724 // Don't suggest ignored warning flags. 725 if (!O.Members && !O.SubGroups) 726 continue; 727 728 unsigned Distance = O.getName().edit_distance(Group, true, BestDistance); 729 if (Distance > BestDistance) 730 continue; 731 732 // Don't suggest groups that are not of this kind. 733 llvm::SmallVector<diag::kind, 8> Diags; 734 if (::getDiagnosticsInGroup(Flavor, &O, Diags) || Diags.empty()) 735 continue; 736 737 if (Distance == BestDistance) { 738 // Two matches with the same distance, don't prefer one over the other. 739 Best = ""; 740 } else if (Distance < BestDistance) { 741 // This is a better match. 742 Best = O.getName(); 743 BestDistance = Distance; 744 } 745 } 746 747 return Best; 748 } 749 750 /// ProcessDiag - This is the method used to report a diagnostic that is 751 /// finally fully formed. 752 bool DiagnosticIDs::ProcessDiag(DiagnosticsEngine &Diag) const { 753 Diagnostic Info(&Diag); 754 755 assert(Diag.getClient() && "DiagnosticClient not set!"); 756 757 // Figure out the diagnostic level of this message. 758 unsigned DiagID = Info.getID(); 759 DiagnosticIDs::Level DiagLevel 760 = getDiagnosticLevel(DiagID, Info.getLocation(), Diag); 761 762 // Update counts for DiagnosticErrorTrap even if a fatal error occurred 763 // or diagnostics are suppressed. 764 if (DiagLevel >= DiagnosticIDs::Error) { 765 ++Diag.TrapNumErrorsOccurred; 766 if (isUnrecoverable(DiagID)) 767 ++Diag.TrapNumUnrecoverableErrorsOccurred; 768 } 769 770 if (Diag.SuppressAllDiagnostics) 771 return false; 772 773 if (DiagLevel != DiagnosticIDs::Note) { 774 // Record that a fatal error occurred only when we see a second 775 // non-note diagnostic. This allows notes to be attached to the 776 // fatal error, but suppresses any diagnostics that follow those 777 // notes. 778 if (Diag.LastDiagLevel == DiagnosticIDs::Fatal) 779 Diag.FatalErrorOccurred = true; 780 781 Diag.LastDiagLevel = DiagLevel; 782 } 783 784 // If a fatal error has already been emitted, silence all subsequent 785 // diagnostics. 786 if (Diag.FatalErrorOccurred) { 787 if (DiagLevel >= DiagnosticIDs::Error && 788 Diag.Client->IncludeInDiagnosticCounts()) { 789 ++Diag.NumErrors; 790 } 791 792 return false; 793 } 794 795 // If the client doesn't care about this message, don't issue it. If this is 796 // a note and the last real diagnostic was ignored, ignore it too. 797 if (DiagLevel == DiagnosticIDs::Ignored || 798 (DiagLevel == DiagnosticIDs::Note && 799 Diag.LastDiagLevel == DiagnosticIDs::Ignored)) 800 return false; 801 802 if (DiagLevel >= DiagnosticIDs::Error) { 803 if (isUnrecoverable(DiagID)) 804 Diag.UnrecoverableErrorOccurred = true; 805 806 // Warnings which have been upgraded to errors do not prevent compilation. 807 if (isDefaultMappingAsError(DiagID)) 808 Diag.UncompilableErrorOccurred = true; 809 810 Diag.ErrorOccurred = true; 811 if (Diag.Client->IncludeInDiagnosticCounts()) { 812 ++Diag.NumErrors; 813 } 814 815 // If we've emitted a lot of errors, emit a fatal error instead of it to 816 // stop a flood of bogus errors. 817 if (Diag.ErrorLimit && Diag.NumErrors > Diag.ErrorLimit && 818 DiagLevel == DiagnosticIDs::Error) { 819 Diag.SetDelayedDiagnostic(diag::fatal_too_many_errors); 820 return false; 821 } 822 } 823 824 // Make sure we set FatalErrorOccurred to ensure that the notes from the 825 // diagnostic that caused `fatal_too_many_errors` won't be emitted. 826 if (Diag.CurDiagID == diag::fatal_too_many_errors) 827 Diag.FatalErrorOccurred = true; 828 // Finally, report it. 829 EmitDiag(Diag, DiagLevel); 830 return true; 831 } 832 833 void DiagnosticIDs::EmitDiag(DiagnosticsEngine &Diag, Level DiagLevel) const { 834 Diagnostic Info(&Diag); 835 assert(DiagLevel != DiagnosticIDs::Ignored && "Cannot emit ignored diagnostics!"); 836 837 Diag.Client->HandleDiagnostic((DiagnosticsEngine::Level)DiagLevel, Info); 838 if (Diag.Client->IncludeInDiagnosticCounts()) { 839 if (DiagLevel == DiagnosticIDs::Warning) 840 ++Diag.NumWarnings; 841 } 842 843 Diag.CurDiagID = ~0U; 844 } 845 846 bool DiagnosticIDs::isUnrecoverable(unsigned DiagID) const { 847 if (DiagID >= diag::DIAG_UPPER_LIMIT) { 848 assert(CustomDiagInfo && "Invalid CustomDiagInfo"); 849 // Custom diagnostics. 850 return CustomDiagInfo->getLevel(DiagID) >= DiagnosticIDs::Error; 851 } 852 853 // Only errors may be unrecoverable. 854 if (getBuiltinDiagClass(DiagID) < CLASS_ERROR) 855 return false; 856 857 if (DiagID == diag::err_unavailable || 858 DiagID == diag::err_unavailable_message) 859 return false; 860 861 // Currently we consider all ARC errors as recoverable. 862 if (isARCDiagnostic(DiagID)) 863 return false; 864 865 return true; 866 } 867 868 bool DiagnosticIDs::isARCDiagnostic(unsigned DiagID) { 869 unsigned cat = getCategoryNumberForDiag(DiagID); 870 return DiagnosticIDs::getCategoryNameFromID(cat).startswith("ARC "); 871 } 872