Add --suppress-system-warnings (on by default, use =0 to disable)

- For investigating warnings in system headers / builtins.
 - Currently also enables the behavior that allows silent redefinition
   of types in system headers. Conceptually these are separate but I
   didn't feel it was worth two options (or changing LangOptions).

llvm-svn: 56163

clang/Driver/clang.cpp

@@ -519,6 +519,11 @@ static llvm::cl::opt<bool>
 ErrorOnExtensions("pedantic-errors",
                   llvm::cl::desc("Issue an error on uses of GCC extensions"));
 
+static llvm::cl::opt<bool>
+SuppressSystemWarnings("suppress-system-warnings",
+                     llvm::cl::desc("Issue an error on uses of GCC extensions"),
+                       llvm::cl::init(true));
+
 static llvm::cl::opt<bool>
 WarnUnusedMacros("Wunused_macros",
          llvm::cl::desc("Warn for unused macros in the main translation unit"));
@@ -547,6 +552,9 @@ static void InitializeDiagnostics(Diagnostic &Diags) {
   Diags.setWarnOnExtensions(WarnOnExtensions);
   Diags.setErrorOnExtensions(ErrorOnExtensions);
 
+  // Suppress warnings in system headers unless requested not to.
+  Diags.setSuppressSystemWarnings(SuppressSystemWarnings);
+
   // Silence the "macro is not used" warning unless requested.
   if (!WarnUnusedMacros)
     Diags.setDiagnosticMapping(diag::pp_macro_not_used, diag::MAP_IGNORE);

clang/include/clang/Basic/Diagnostic.h

@@ -61,6 +61,7 @@ private:
   bool WarningsAsErrors;      // Treat warnings like errors: 
   bool WarnOnExtensions;      // Enables warnings for gcc extensions: -pedantic.
   bool ErrorOnExtensions;     // Error on extensions: -pedantic-errors.
+  bool SuppressSystemWarnings;// Suppress warnings in system headers.
   DiagnosticClient *Client;
 
   /// DiagMappings - Mapping information for diagnostics.  Mapping info is
@@ -110,6 +111,11 @@ public:
   void setErrorOnExtensions(bool Val) { ErrorOnExtensions = Val; }
   bool getErrorOnExtensions() const { return ErrorOnExtensions; }
 
+  /// setSuppressSystemWarnings - When set to true mask warnings that
+  /// come from system headers.
+  void setSuppressSystemWarnings(bool Val) { SuppressSystemWarnings = Val; }
+  bool getSuppressSystemWarnings() const { return SuppressSystemWarnings; }
+
   /// setDiagnosticMapping - This allows the client to specify that certain
   /// warnings are ignored.  Only NOTEs, WARNINGs, and EXTENSIONs can be mapped.
   void setDiagnosticMapping(diag::kind Diag, diag::Mapping Map) {

clang/lib/Basic/Diagnostic.cpp

@@ -113,6 +113,7 @@ Diagnostic::Diagnostic(DiagnosticClient *client) : Client(client) {
   WarningsAsErrors = false;
   WarnOnExtensions = false;
   ErrorOnExtensions = false;
+  SuppressSystemWarnings = false;
   // Clear all mappings, setting them to MAP_DEFAULT.
   memset(DiagMappings, 0, sizeof(DiagMappings));
   
@@ -224,7 +225,8 @@ void Diagnostic::Report(DiagnosticClient* C,
   // have to check on the original DiagID here, because we also want to
   // ignore extensions and warnings in -Werror and -pedantic-errors modes,
   // which *map* warnings/extensions to errors.
-  if (DiagID < diag::NUM_BUILTIN_DIAGNOSTICS &&
+  if (SuppressSystemWarnings &&
+      DiagID < diag::NUM_BUILTIN_DIAGNOSTICS &&
       getBuiltinDiagClass(DiagID) != ERROR &&
       Loc.isValid() && Loc.isFileID() && Loc.isInSystemHeader())
     return;

clang/lib/Sema/SemaDecl.cpp

@@ -276,11 +276,13 @@ TypedefDecl *Sema::MergeTypeDefDecl(TypedefDecl *New, Decl *OldD) {
   // *either* declaration is in a system header. The code below implements
   // this adhoc compatibility rule. FIXME: The following code will not
   // work properly when compiling ".i" files (containing preprocessed output).
-  SourceManager &SrcMgr = Context.getSourceManager();
+  if (PP.getDiagnostics().getSuppressSystemWarnings()) {
-  if (SrcMgr.isInSystemHeader(Old->getLocation()))
+    SourceManager &SrcMgr = Context.getSourceManager();
-    return New;
+    if (SrcMgr.isInSystemHeader(Old->getLocation()))
-  if (SrcMgr.isInSystemHeader(New->getLocation()))
+      return New;
-    return New;
+    if (SrcMgr.isInSystemHeader(New->getLocation()))
+      return New;
+  }
 
   Diag(New->getLocation(), diag::err_redefinition, New->getName());
   Diag(Old->getLocation(), diag::err_previous_definition);