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