1 //===--- DiagnosticIDs.cpp - Diagnostic IDs Handling ----------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the Diagnostic IDs-related interfaces. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/AST/ASTDiagnostic.h" 15 #include "clang/Analysis/AnalysisDiagnostic.h" 16 #include "clang/Basic/DiagnosticIDs.h" 17 #include "clang/Basic/DiagnosticCategories.h" 18 #include "clang/Basic/SourceManager.h" 19 #include "clang/Driver/DriverDiagnostic.h" 20 #include "clang/Frontend/FrontendDiagnostic.h" 21 #include "clang/Lex/LexDiagnostic.h" 22 #include "clang/Parse/ParseDiagnostic.h" 23 #include "clang/Sema/SemaDiagnostic.h" 24 #include "llvm/ADT/SmallVector.h" 25 #include "llvm/Support/ErrorHandling.h" 26 27 #include <map> 28 using namespace clang; 29 30 //===----------------------------------------------------------------------===// 31 // Builtin Diagnostic information 32 //===----------------------------------------------------------------------===// 33 34 namespace { 35 36 // Diagnostic classes. 37 enum { 38 CLASS_NOTE = 0x01, 39 CLASS_WARNING = 0x02, 40 CLASS_EXTENSION = 0x03, 41 CLASS_ERROR = 0x04 42 }; 43 44 struct StaticDiagInfoRec { 45 unsigned short DiagID; 46 unsigned Mapping : 3; 47 unsigned Class : 3; 48 unsigned SFINAE : 1; 49 unsigned AccessControl : 1; 50 unsigned WarnNoWerror : 1; 51 unsigned WarnShowInSystemHeader : 1; 52 unsigned Category : 5; 53 54 uint8_t NameLen; 55 uint8_t OptionGroupLen; 56 57 uint16_t DescriptionLen; 58 uint16_t BriefExplanationLen; 59 uint16_t FullExplanationLen; 60 61 const char *NameStr; 62 const char *OptionGroupStr; 63 64 const char *DescriptionStr; 65 const char *BriefExplanationStr; 66 const char *FullExplanationStr; 67 68 StringRef getName() const { 69 return StringRef(NameStr, NameLen); 70 } 71 StringRef getOptionGroup() const { 72 return StringRef(OptionGroupStr, OptionGroupLen); 73 } 74 75 StringRef getDescription() const { 76 return StringRef(DescriptionStr, DescriptionLen); 77 } 78 StringRef getBriefExplanation() const { 79 return StringRef(BriefExplanationStr, BriefExplanationLen); 80 } 81 StringRef getFullExplanation() const { 82 return StringRef(FullExplanationStr, FullExplanationLen); 83 } 84 85 bool operator<(const StaticDiagInfoRec &RHS) const { 86 return DiagID < RHS.DiagID; 87 } 88 }; 89 90 struct StaticDiagNameIndexRec { 91 const char *NameStr; 92 unsigned short DiagID; 93 uint8_t NameLen; 94 95 StringRef getName() const { 96 return StringRef(NameStr, NameLen); 97 } 98 99 bool operator<(const StaticDiagNameIndexRec &RHS) const { 100 return getName() < RHS.getName(); 101 } 102 103 bool operator==(const StaticDiagNameIndexRec &RHS) const { 104 return getName() == RHS.getName(); 105 } 106 }; 107 108 template <size_t SizeOfStr, typename FieldType> 109 class StringSizerHelper { 110 char FIELD_TOO_SMALL[SizeOfStr <= FieldType(~0U) ? 1 : -1]; 111 public: 112 enum { Size = SizeOfStr }; 113 }; 114 115 } // namespace anonymous 116 117 #define STR_SIZE(str, fieldTy) StringSizerHelper<sizeof(str)-1, fieldTy>::Size 118 119 static const StaticDiagInfoRec StaticDiagInfo[] = { 120 #define DIAG(ENUM,CLASS,DEFAULT_MAPPING,DESC,GROUP, \ 121 SFINAE,ACCESS,NOWERROR,SHOWINSYSHEADER, \ 122 CATEGORY,BRIEF,FULL) \ 123 { diag::ENUM, DEFAULT_MAPPING, CLASS, SFINAE, ACCESS, \ 124 NOWERROR, SHOWINSYSHEADER, CATEGORY, \ 125 STR_SIZE(#ENUM, uint8_t), STR_SIZE(GROUP, uint8_t), \ 126 STR_SIZE(DESC, uint16_t), STR_SIZE(BRIEF, uint16_t), \ 127 STR_SIZE(FULL, uint16_t), \ 128 #ENUM, GROUP, DESC, BRIEF, FULL }, 129 #include "clang/Basic/DiagnosticCommonKinds.inc" 130 #include "clang/Basic/DiagnosticDriverKinds.inc" 131 #include "clang/Basic/DiagnosticFrontendKinds.inc" 132 #include "clang/Basic/DiagnosticLexKinds.inc" 133 #include "clang/Basic/DiagnosticParseKinds.inc" 134 #include "clang/Basic/DiagnosticASTKinds.inc" 135 #include "clang/Basic/DiagnosticSemaKinds.inc" 136 #include "clang/Basic/DiagnosticAnalysisKinds.inc" 137 #undef DIAG 138 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} 139 }; 140 141 static const unsigned StaticDiagInfoSize = 142 sizeof(StaticDiagInfo)/sizeof(StaticDiagInfo[0])-1; 143 144 /// To be sorted before first use (since it's splitted among multiple files) 145 static const StaticDiagNameIndexRec StaticDiagNameIndex[] = { 146 #define DIAG_NAME_INDEX(ENUM) { #ENUM, diag::ENUM, STR_SIZE(#ENUM, uint8_t) }, 147 #include "clang/Basic/DiagnosticIndexName.inc" 148 #undef DIAG_NAME_INDEX 149 { 0, 0, 0 } 150 }; 151 152 static const unsigned StaticDiagNameIndexSize = 153 sizeof(StaticDiagNameIndex)/sizeof(StaticDiagNameIndex[0])-1; 154 155 /// GetDiagInfo - Return the StaticDiagInfoRec entry for the specified DiagID, 156 /// or null if the ID is invalid. 157 static const StaticDiagInfoRec *GetDiagInfo(unsigned DiagID) { 158 // If assertions are enabled, verify that the StaticDiagInfo array is sorted. 159 #ifndef NDEBUG 160 static bool IsFirst = true; 161 if (IsFirst) { 162 for (unsigned i = 1; i != StaticDiagInfoSize; ++i) { 163 assert(StaticDiagInfo[i-1].DiagID != StaticDiagInfo[i].DiagID && 164 "Diag ID conflict, the enums at the start of clang::diag (in " 165 "DiagnosticIDs.h) probably need to be increased"); 166 167 assert(StaticDiagInfo[i-1] < StaticDiagInfo[i] && 168 "Improperly sorted diag info"); 169 } 170 IsFirst = false; 171 } 172 #endif 173 174 // Search the diagnostic table with a binary search. 175 StaticDiagInfoRec Find = { static_cast<unsigned short>(DiagID), 176 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; 177 178 const StaticDiagInfoRec *Found = 179 std::lower_bound(StaticDiagInfo, StaticDiagInfo + StaticDiagInfoSize, Find); 180 if (Found == StaticDiagInfo + StaticDiagInfoSize || 181 Found->DiagID != DiagID) 182 return 0; 183 184 return Found; 185 } 186 187 static DiagnosticMappingInfo GetDefaultDiagMappingInfo(unsigned DiagID) { 188 DiagnosticMappingInfo Info = DiagnosticMappingInfo::Make( 189 diag::MAP_FATAL, /*IsUser=*/false, /*IsPragma=*/false); 190 191 if (const StaticDiagInfoRec *StaticInfo = GetDiagInfo(DiagID)) { 192 Info.setMapping((diag::Mapping) StaticInfo->Mapping); 193 194 if (StaticInfo->WarnNoWerror) { 195 assert(Info.getMapping() == diag::MAP_WARNING && 196 "Unexpected mapping with no-Werror bit!"); 197 Info.setNoWarningAsError(true); 198 } 199 200 if (StaticInfo->WarnShowInSystemHeader) { 201 assert(Info.getMapping() == diag::MAP_WARNING && 202 "Unexpected mapping with show-in-system-header bit!"); 203 Info.setShowInSystemHeader(true); 204 } 205 } 206 207 return Info; 208 } 209 210 /// getWarningOptionForDiag - Return the lowest-level warning option that 211 /// enables the specified diagnostic. If there is no -Wfoo flag that controls 212 /// the diagnostic, this returns null. 213 StringRef DiagnosticIDs::getWarningOptionForDiag(unsigned DiagID) { 214 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) 215 return Info->getOptionGroup(); 216 return StringRef(); 217 } 218 219 /// getCategoryNumberForDiag - Return the category number that a specified 220 /// DiagID belongs to, or 0 if no category. 221 unsigned DiagnosticIDs::getCategoryNumberForDiag(unsigned DiagID) { 222 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) 223 return Info->Category; 224 return 0; 225 } 226 227 namespace { 228 // The diagnostic category names. 229 struct StaticDiagCategoryRec { 230 const char *NameStr; 231 uint8_t NameLen; 232 233 StringRef getName() const { 234 return StringRef(NameStr, NameLen); 235 } 236 }; 237 } 238 239 // Unfortunately, the split between DiagnosticIDs and Diagnostic is not 240 // particularly clean, but for now we just implement this method here so we can 241 // access GetDefaultDiagMapping. 242 DiagnosticMappingInfo &DiagnosticsEngine::DiagState::getOrAddMappingInfo( 243 diag::kind Diag) 244 { 245 std::pair<iterator, bool> Result = DiagMap.insert( 246 std::make_pair(Diag, DiagnosticMappingInfo())); 247 248 // Initialize the entry if we added it. 249 if (Result.second) 250 Result.first->second = GetDefaultDiagMappingInfo(Diag); 251 252 return Result.first->second; 253 } 254 255 static const StaticDiagCategoryRec CategoryNameTable[] = { 256 #define GET_CATEGORY_TABLE 257 #define CATEGORY(X, ENUM) { X, STR_SIZE(X, uint8_t) }, 258 #include "clang/Basic/DiagnosticGroups.inc" 259 #undef GET_CATEGORY_TABLE 260 { 0, 0 } 261 }; 262 263 /// getNumberOfCategories - Return the number of categories 264 unsigned DiagnosticIDs::getNumberOfCategories() { 265 return sizeof(CategoryNameTable) / sizeof(CategoryNameTable[0])-1; 266 } 267 268 /// getCategoryNameFromID - Given a category ID, return the name of the 269 /// category, an empty string if CategoryID is zero, or null if CategoryID is 270 /// invalid. 271 StringRef DiagnosticIDs::getCategoryNameFromID(unsigned CategoryID) { 272 if (CategoryID >= getNumberOfCategories()) 273 return StringRef(); 274 return CategoryNameTable[CategoryID].getName(); 275 } 276 277 278 279 DiagnosticIDs::SFINAEResponse 280 DiagnosticIDs::getDiagnosticSFINAEResponse(unsigned DiagID) { 281 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) { 282 if (Info->AccessControl) 283 return SFINAE_AccessControl; 284 285 if (!Info->SFINAE) 286 return SFINAE_Report; 287 288 if (Info->Class == CLASS_ERROR) 289 return SFINAE_SubstitutionFailure; 290 291 // Suppress notes, warnings, and extensions; 292 return SFINAE_Suppress; 293 } 294 295 return SFINAE_Report; 296 } 297 298 /// getName - Given a diagnostic ID, return its name 299 StringRef DiagnosticIDs::getName(unsigned DiagID) { 300 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) 301 return Info->getName(); 302 return StringRef(); 303 } 304 305 /// getIdFromName - Given a diagnostic name, return its ID, or 0 306 unsigned DiagnosticIDs::getIdFromName(StringRef Name) { 307 const StaticDiagNameIndexRec *StaticDiagNameIndexEnd = 308 StaticDiagNameIndex + StaticDiagNameIndexSize; 309 310 if (Name.empty()) { return diag::DIAG_UPPER_LIMIT; } 311 312 assert(Name.size() == static_cast<uint8_t>(Name.size()) && 313 "Name is too long"); 314 StaticDiagNameIndexRec Find = { Name.data(), 0, 315 static_cast<uint8_t>(Name.size()) }; 316 317 const StaticDiagNameIndexRec *Found = 318 std::lower_bound( StaticDiagNameIndex, StaticDiagNameIndexEnd, Find); 319 if (Found == StaticDiagNameIndexEnd || 320 Found->getName() != Name) 321 return diag::DIAG_UPPER_LIMIT; 322 323 return Found->DiagID; 324 } 325 326 /// getBriefExplanation - Given a diagnostic ID, return a brief explanation 327 /// of the issue 328 StringRef DiagnosticIDs::getBriefExplanation(unsigned DiagID) { 329 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) 330 return Info->getBriefExplanation(); 331 return StringRef(); 332 } 333 334 /// getFullExplanation - Given a diagnostic ID, return a full explanation 335 /// of the issue 336 StringRef DiagnosticIDs::getFullExplanation(unsigned DiagID) { 337 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) 338 return Info->getFullExplanation(); 339 return StringRef(); 340 } 341 342 /// getBuiltinDiagClass - Return the class field of the diagnostic. 343 /// 344 static unsigned getBuiltinDiagClass(unsigned DiagID) { 345 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) 346 return Info->Class; 347 return ~0U; 348 } 349 350 //===----------------------------------------------------------------------===// 351 // diag_iterator 352 //===----------------------------------------------------------------------===// 353 354 llvm::StringRef DiagnosticIDs::diag_iterator::getDiagName() const { 355 return static_cast<const StaticDiagNameIndexRec*>(impl)->getName(); 356 } 357 358 unsigned DiagnosticIDs::diag_iterator::getDiagID() const { 359 return static_cast<const StaticDiagNameIndexRec*>(impl)->DiagID; 360 } 361 362 DiagnosticIDs::diag_iterator &DiagnosticIDs::diag_iterator::operator++() { 363 const StaticDiagNameIndexRec* ptr = 364 static_cast<const StaticDiagNameIndexRec*>(impl);; 365 ++ptr; 366 impl = ptr; 367 return *this; 368 } 369 370 DiagnosticIDs::diag_iterator DiagnosticIDs::diags_begin() { 371 return DiagnosticIDs::diag_iterator(StaticDiagNameIndex); 372 } 373 374 DiagnosticIDs::diag_iterator DiagnosticIDs::diags_end() { 375 return DiagnosticIDs::diag_iterator(StaticDiagNameIndex + 376 StaticDiagNameIndexSize); 377 } 378 379 //===----------------------------------------------------------------------===// 380 // Custom Diagnostic information 381 //===----------------------------------------------------------------------===// 382 383 namespace clang { 384 namespace diag { 385 class CustomDiagInfo { 386 typedef std::pair<DiagnosticIDs::Level, std::string> DiagDesc; 387 std::vector<DiagDesc> DiagInfo; 388 std::map<DiagDesc, unsigned> DiagIDs; 389 public: 390 391 /// getDescription - Return the description of the specified custom 392 /// diagnostic. 393 StringRef getDescription(unsigned DiagID) const { 394 assert(this && DiagID-DIAG_UPPER_LIMIT < DiagInfo.size() && 395 "Invalid diagnosic ID"); 396 return DiagInfo[DiagID-DIAG_UPPER_LIMIT].second; 397 } 398 399 /// getLevel - Return the level of the specified custom diagnostic. 400 DiagnosticIDs::Level getLevel(unsigned DiagID) const { 401 assert(this && DiagID-DIAG_UPPER_LIMIT < DiagInfo.size() && 402 "Invalid diagnosic ID"); 403 return DiagInfo[DiagID-DIAG_UPPER_LIMIT].first; 404 } 405 406 unsigned getOrCreateDiagID(DiagnosticIDs::Level L, StringRef Message, 407 DiagnosticIDs &Diags) { 408 DiagDesc D(L, Message); 409 // Check to see if it already exists. 410 std::map<DiagDesc, unsigned>::iterator I = DiagIDs.lower_bound(D); 411 if (I != DiagIDs.end() && I->first == D) 412 return I->second; 413 414 // If not, assign a new ID. 415 unsigned ID = DiagInfo.size()+DIAG_UPPER_LIMIT; 416 DiagIDs.insert(std::make_pair(D, ID)); 417 DiagInfo.push_back(D); 418 return ID; 419 } 420 }; 421 422 } // end diag namespace 423 } // end clang namespace 424 425 426 //===----------------------------------------------------------------------===// 427 // Common Diagnostic implementation 428 //===----------------------------------------------------------------------===// 429 430 DiagnosticIDs::DiagnosticIDs() { 431 CustomDiagInfo = 0; 432 } 433 434 DiagnosticIDs::~DiagnosticIDs() { 435 delete CustomDiagInfo; 436 } 437 438 /// getCustomDiagID - Return an ID for a diagnostic with the specified message 439 /// and level. If this is the first request for this diagnosic, it is 440 /// registered and created, otherwise the existing ID is returned. 441 unsigned DiagnosticIDs::getCustomDiagID(Level L, StringRef Message) { 442 if (CustomDiagInfo == 0) 443 CustomDiagInfo = new diag::CustomDiagInfo(); 444 return CustomDiagInfo->getOrCreateDiagID(L, Message, *this); 445 } 446 447 448 /// isBuiltinWarningOrExtension - Return true if the unmapped diagnostic 449 /// level of the specified diagnostic ID is a Warning or Extension. 450 /// This only works on builtin diagnostics, not custom ones, and is not legal to 451 /// call on NOTEs. 452 bool DiagnosticIDs::isBuiltinWarningOrExtension(unsigned DiagID) { 453 return DiagID < diag::DIAG_UPPER_LIMIT && 454 getBuiltinDiagClass(DiagID) != CLASS_ERROR; 455 } 456 457 /// \brief Determine whether the given built-in diagnostic ID is a 458 /// Note. 459 bool DiagnosticIDs::isBuiltinNote(unsigned DiagID) { 460 return DiagID < diag::DIAG_UPPER_LIMIT && 461 getBuiltinDiagClass(DiagID) == CLASS_NOTE; 462 } 463 464 /// isBuiltinExtensionDiag - Determine whether the given built-in diagnostic 465 /// ID is for an extension of some sort. This also returns EnabledByDefault, 466 /// which is set to indicate whether the diagnostic is ignored by default (in 467 /// which case -pedantic enables it) or treated as a warning/error by default. 468 /// 469 bool DiagnosticIDs::isBuiltinExtensionDiag(unsigned DiagID, 470 bool &EnabledByDefault) { 471 if (DiagID >= diag::DIAG_UPPER_LIMIT || 472 getBuiltinDiagClass(DiagID) != CLASS_EXTENSION) 473 return false; 474 475 EnabledByDefault = 476 GetDefaultDiagMappingInfo(DiagID).getMapping() != diag::MAP_IGNORE; 477 return true; 478 } 479 480 bool DiagnosticIDs::isDefaultMappingAsError(unsigned DiagID) { 481 if (DiagID >= diag::DIAG_UPPER_LIMIT) 482 return false; 483 484 return GetDefaultDiagMappingInfo(DiagID).getMapping() == diag::MAP_ERROR; 485 } 486 487 /// getDescription - Given a diagnostic ID, return a description of the 488 /// issue. 489 StringRef DiagnosticIDs::getDescription(unsigned DiagID) const { 490 if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) 491 return Info->getDescription(); 492 return CustomDiagInfo->getDescription(DiagID); 493 } 494 495 /// getDiagnosticLevel - Based on the way the client configured the 496 /// DiagnosticsEngine object, classify the specified diagnostic ID into a Level, 497 /// by consumable the DiagnosticClient. 498 DiagnosticIDs::Level 499 DiagnosticIDs::getDiagnosticLevel(unsigned DiagID, SourceLocation Loc, 500 const DiagnosticsEngine &Diag) const { 501 // Handle custom diagnostics, which cannot be mapped. 502 if (DiagID >= diag::DIAG_UPPER_LIMIT) 503 return CustomDiagInfo->getLevel(DiagID); 504 505 unsigned DiagClass = getBuiltinDiagClass(DiagID); 506 assert(DiagClass != CLASS_NOTE && "Cannot get diagnostic level of a note!"); 507 return getDiagnosticLevel(DiagID, DiagClass, Loc, Diag); 508 } 509 510 /// \brief Based on the way the client configured the Diagnostic 511 /// object, classify the specified diagnostic ID into a Level, consumable by 512 /// the DiagnosticClient. 513 /// 514 /// \param Loc The source location we are interested in finding out the 515 /// diagnostic state. Can be null in order to query the latest state. 516 DiagnosticIDs::Level 517 DiagnosticIDs::getDiagnosticLevel(unsigned DiagID, unsigned DiagClass, 518 SourceLocation Loc, 519 const DiagnosticsEngine &Diag) const { 520 // Specific non-error diagnostics may be mapped to various levels from ignored 521 // to error. Errors can only be mapped to fatal. 522 DiagnosticIDs::Level Result = DiagnosticIDs::Fatal; 523 524 DiagnosticsEngine::DiagStatePointsTy::iterator 525 Pos = Diag.GetDiagStatePointForLoc(Loc); 526 DiagnosticsEngine::DiagState *State = Pos->State; 527 528 // Get the mapping information, or compute it lazily. 529 DiagnosticMappingInfo &MappingInfo = State->getOrAddMappingInfo( 530 (diag::kind)DiagID); 531 532 switch (MappingInfo.getMapping()) { 533 default: llvm_unreachable("Unknown mapping!"); 534 case diag::MAP_IGNORE: 535 Result = DiagnosticIDs::Ignored; 536 break; 537 case diag::MAP_WARNING: 538 Result = DiagnosticIDs::Warning; 539 break; 540 case diag::MAP_ERROR: 541 Result = DiagnosticIDs::Error; 542 break; 543 case diag::MAP_FATAL: 544 Result = DiagnosticIDs::Fatal; 545 break; 546 } 547 548 // Upgrade ignored diagnostics if -Weverything is enabled. 549 if (Diag.EnableAllWarnings && Result == DiagnosticIDs::Ignored && 550 !MappingInfo.isUser()) 551 Result = DiagnosticIDs::Warning; 552 553 // Ignore -pedantic diagnostics inside __extension__ blocks. 554 // (The diagnostics controlled by -pedantic are the extension diagnostics 555 // that are not enabled by default.) 556 bool EnabledByDefault; 557 bool IsExtensionDiag = isBuiltinExtensionDiag(DiagID, EnabledByDefault); 558 if (Diag.AllExtensionsSilenced && IsExtensionDiag && !EnabledByDefault) 559 return DiagnosticIDs::Ignored; 560 561 // For extension diagnostics that haven't been explicitly mapped, check if we 562 // should upgrade the diagnostic. 563 if (IsExtensionDiag && !MappingInfo.isUser()) { 564 switch (Diag.ExtBehavior) { 565 case DiagnosticsEngine::Ext_Ignore: 566 break; 567 case DiagnosticsEngine::Ext_Warn: 568 // Upgrade ignored diagnostics to warnings. 569 if (Result == DiagnosticIDs::Ignored) 570 Result = DiagnosticIDs::Warning; 571 break; 572 case DiagnosticsEngine::Ext_Error: 573 // Upgrade ignored or warning diagnostics to errors. 574 if (Result == DiagnosticIDs::Ignored || Result == DiagnosticIDs::Warning) 575 Result = DiagnosticIDs::Error; 576 break; 577 } 578 } 579 580 // At this point, ignored errors can no longer be upgraded. 581 if (Result == DiagnosticIDs::Ignored) 582 return Result; 583 584 // Honor -w, which is lower in priority than pedantic-errors, but higher than 585 // -Werror. 586 if (Result == DiagnosticIDs::Warning && Diag.IgnoreAllWarnings) 587 return DiagnosticIDs::Ignored; 588 589 // If -Werror is enabled, map warnings to errors unless explicitly disabled. 590 if (Result == DiagnosticIDs::Warning) { 591 if (Diag.WarningsAsErrors && !MappingInfo.hasNoWarningAsError()) 592 Result = DiagnosticIDs::Error; 593 } 594 595 // If -Wfatal-errors is enabled, map errors to fatal unless explicity 596 // disabled. 597 if (Result == DiagnosticIDs::Error) { 598 if (Diag.ErrorsAsFatal && !MappingInfo.hasNoErrorAsFatal()) 599 Result = DiagnosticIDs::Fatal; 600 } 601 602 // If we are in a system header, we ignore it. We look at the diagnostic class 603 // because we also want to ignore extensions and warnings in -Werror and 604 // -pedantic-errors modes, which *map* warnings/extensions to errors. 605 if (Result >= DiagnosticIDs::Warning && 606 DiagClass != CLASS_ERROR && 607 // Custom diagnostics always are emitted in system headers. 608 DiagID < diag::DIAG_UPPER_LIMIT && 609 !MappingInfo.hasShowInSystemHeader() && 610 Diag.SuppressSystemWarnings && 611 Loc.isValid() && 612 Diag.getSourceManager().isInSystemHeader( 613 Diag.getSourceManager().getExpansionLoc(Loc))) 614 return DiagnosticIDs::Ignored; 615 616 return Result; 617 } 618 619 struct clang::WarningOption { 620 // Be safe with the size of 'NameLen' because we don't statically check if 621 // the size will fit in the field; the struct size won't decrease with a 622 // shorter type anyway. 623 size_t NameLen; 624 const char *NameStr; 625 const short *Members; 626 const short *SubGroups; 627 628 StringRef getName() const { 629 return StringRef(NameStr, NameLen); 630 } 631 }; 632 633 #define GET_DIAG_ARRAYS 634 #include "clang/Basic/DiagnosticGroups.inc" 635 #undef GET_DIAG_ARRAYS 636 637 // Second the table of options, sorted by name for fast binary lookup. 638 static const WarningOption OptionTable[] = { 639 #define GET_DIAG_TABLE 640 #include "clang/Basic/DiagnosticGroups.inc" 641 #undef GET_DIAG_TABLE 642 }; 643 static const size_t OptionTableSize = 644 sizeof(OptionTable) / sizeof(OptionTable[0]); 645 646 static bool WarningOptionCompare(const WarningOption &LHS, 647 const WarningOption &RHS) { 648 return LHS.getName() < RHS.getName(); 649 } 650 651 void DiagnosticIDs::getDiagnosticsInGroup( 652 const WarningOption *Group, 653 llvm::SmallVectorImpl<diag::kind> &Diags) const 654 { 655 // Add the members of the option diagnostic set. 656 if (const short *Member = Group->Members) { 657 for (; *Member != -1; ++Member) 658 Diags.push_back(*Member); 659 } 660 661 // Add the members of the subgroups. 662 if (const short *SubGroups = Group->SubGroups) { 663 for (; *SubGroups != (short)-1; ++SubGroups) 664 getDiagnosticsInGroup(&OptionTable[(short)*SubGroups], Diags); 665 } 666 } 667 668 bool DiagnosticIDs::getDiagnosticsInGroup( 669 StringRef Group, 670 llvm::SmallVectorImpl<diag::kind> &Diags) const 671 { 672 WarningOption Key = { Group.size(), Group.data(), 0, 0 }; 673 const WarningOption *Found = 674 std::lower_bound(OptionTable, OptionTable + OptionTableSize, Key, 675 WarningOptionCompare); 676 if (Found == OptionTable + OptionTableSize || 677 Found->getName() != Group) 678 return true; // Option not found. 679 680 getDiagnosticsInGroup(Found, Diags); 681 return false; 682 } 683 684 /// ProcessDiag - This is the method used to report a diagnostic that is 685 /// finally fully formed. 686 bool DiagnosticIDs::ProcessDiag(DiagnosticsEngine &Diag) const { 687 Diagnostic Info(&Diag); 688 689 if (Diag.SuppressAllDiagnostics) 690 return false; 691 692 assert(Diag.getClient() && "DiagnosticClient not set!"); 693 694 // Figure out the diagnostic level of this message. 695 DiagnosticIDs::Level DiagLevel; 696 unsigned DiagID = Info.getID(); 697 698 if (DiagID >= diag::DIAG_UPPER_LIMIT) { 699 // Handle custom diagnostics, which cannot be mapped. 700 DiagLevel = CustomDiagInfo->getLevel(DiagID); 701 } else { 702 // Get the class of the diagnostic. If this is a NOTE, map it onto whatever 703 // the diagnostic level was for the previous diagnostic so that it is 704 // filtered the same as the previous diagnostic. 705 unsigned DiagClass = getBuiltinDiagClass(DiagID); 706 if (DiagClass == CLASS_NOTE) { 707 DiagLevel = DiagnosticIDs::Note; 708 } else { 709 DiagLevel = getDiagnosticLevel(DiagID, DiagClass, Info.getLocation(), 710 Diag); 711 } 712 } 713 714 if (DiagLevel != DiagnosticIDs::Note) { 715 // Record that a fatal error occurred only when we see a second 716 // non-note diagnostic. This allows notes to be attached to the 717 // fatal error, but suppresses any diagnostics that follow those 718 // notes. 719 if (Diag.LastDiagLevel == DiagnosticIDs::Fatal) 720 Diag.FatalErrorOccurred = true; 721 722 Diag.LastDiagLevel = DiagLevel; 723 } 724 725 // Update counts for DiagnosticErrorTrap even if a fatal error occurred. 726 if (DiagLevel >= DiagnosticIDs::Error) { 727 ++Diag.TrapNumErrorsOccurred; 728 if (isUnrecoverable(DiagID)) 729 ++Diag.TrapNumUnrecoverableErrorsOccurred; 730 } 731 732 // If a fatal error has already been emitted, silence all subsequent 733 // diagnostics. 734 if (Diag.FatalErrorOccurred) { 735 if (DiagLevel >= DiagnosticIDs::Error && 736 Diag.Client->IncludeInDiagnosticCounts()) { 737 ++Diag.NumErrors; 738 ++Diag.NumErrorsSuppressed; 739 } 740 741 return false; 742 } 743 744 // If the client doesn't care about this message, don't issue it. If this is 745 // a note and the last real diagnostic was ignored, ignore it too. 746 if (DiagLevel == DiagnosticIDs::Ignored || 747 (DiagLevel == DiagnosticIDs::Note && 748 Diag.LastDiagLevel == DiagnosticIDs::Ignored)) 749 return false; 750 751 if (DiagLevel >= DiagnosticIDs::Error) { 752 if (isUnrecoverable(DiagID)) 753 Diag.UnrecoverableErrorOccurred = true; 754 755 if (Diag.Client->IncludeInDiagnosticCounts()) { 756 Diag.ErrorOccurred = true; 757 ++Diag.NumErrors; 758 } 759 760 // If we've emitted a lot of errors, emit a fatal error instead of it to 761 // stop a flood of bogus errors. 762 if (Diag.ErrorLimit && Diag.NumErrors > Diag.ErrorLimit && 763 DiagLevel == DiagnosticIDs::Error) { 764 Diag.SetDelayedDiagnostic(diag::fatal_too_many_errors); 765 return false; 766 } 767 } 768 769 // If we have any Fix-Its, make sure that all of the Fix-Its point into 770 // source locations that aren't macro expansions. If any point into macro 771 // expansions, remove all of the Fix-Its. 772 for (unsigned I = 0, N = Diag.NumFixItHints; I != N; ++I) { 773 const FixItHint &FixIt = Diag.FixItHints[I]; 774 if (FixIt.RemoveRange.isInvalid() || 775 FixIt.RemoveRange.getBegin().isMacroID() || 776 FixIt.RemoveRange.getEnd().isMacroID()) { 777 Diag.NumFixItHints = 0; 778 break; 779 } 780 } 781 782 // Finally, report it. 783 Diag.Client->HandleDiagnostic((DiagnosticsEngine::Level)DiagLevel, Info); 784 if (Diag.Client->IncludeInDiagnosticCounts()) { 785 if (DiagLevel == DiagnosticIDs::Warning) 786 ++Diag.NumWarnings; 787 } 788 789 Diag.CurDiagID = ~0U; 790 791 return true; 792 } 793 794 bool DiagnosticIDs::isUnrecoverable(unsigned DiagID) const { 795 if (DiagID >= diag::DIAG_UPPER_LIMIT) { 796 // Custom diagnostics. 797 return CustomDiagInfo->getLevel(DiagID) >= DiagnosticIDs::Error; 798 } 799 800 // Only errors may be unrecoverable. 801 if (getBuiltinDiagClass(DiagID) < CLASS_ERROR) 802 return false; 803 804 if (DiagID == diag::err_unavailable || 805 DiagID == diag::err_unavailable_message) 806 return false; 807 808 // Currently we consider all ARC errors as recoverable. 809 if (getCategoryNumberForDiag(DiagID) == 810 diag::DiagCat_Automatic_Reference_Counting_Issue) 811 return false; 812 813 return true; 814 } 815