[clang-cl] Accept `#pragma warning(disable : N)` for some N

[thakis]

Summary

clang-cl maps /wdNNNN to -Wno-flags for a few warnings that map
cleanly from cl.exe concepts to clang concepts.

This patch adds support for the same numbers to
#pragma warning(disable : NNNN). It also lets
#pragma warning(push) and #pragma warning(pop) have an effect,
since these are used together with warning(disable).

The optional numeric argument to warning(push) is ignored,
as are the other non-disable pragma warning() arguments.
(Supporting error would be easy, but we also don't support
/we, and those should probably be added together.)

The motivating example is that a bunch of code (including in LLVM)
uses this idiom to locally disable warnings about calls to deprecated
functions in Windows-only code, and 4996 maps nicely to
-Wno-deprecated-declarations:

#pragma warning(push)
#pragma warning(disable: 4996)
  f();
#pragma warning(pop)

Implementation-wise:

• Move /wd flag handling from Options.td to actual Driver-level code
• Extract the function mapping cl.exe IDs to warning groups to the new file clang/lib/Basic/CLWarnings.cpp
• Create a diag::Group enum so that CLWarnings.cpp can refer to existing groups by ID (and give DllexportExplicitInstantiationDecl a named group), and add a function to map a diag::Group to the spelling of it's associated commandline flag
• Call that new function from the PragmaWarning handler

[thakis]

some clang-format

[thakis]

tweak

[hans]

Nice!

clang/lib/Basic/CLWarnings.cpp

18

Would it be possible to reference the DiagGroup symbolically here somehow instead of using a string? That way, if the DiagGroup gets renamed, we don't risk forgetting to update this string.

[thakis]

clang/lib/Basic/CLWarnings.cpp

18

As far as I can tell, diagnostic groups don't exist as enums. Options:

• Make this function return a diag:: that the number maps to, and then use DiagnosticIDs::getWarningOptionForDiag() to get that diag's group name and disable that. That should work, but it's a bit confusing since we'd return a single diag here (either of warn_deprecated, warn_property_method_deprecated, warn_atl_uuid_deprecated and several others would have the same effect of representing the group DeprecatedDeclarations) but then disable the whole group.

• Update clang-tblgen to emit something that can be used to create a DiagGroup enum and use that.

The latter sounds better to me, so I'll look into that.

[thakis]

tblgen group IDs

Done, please take a look. We now have a diag::Group enum.

[hans]

Nice! lgtm

clang/include/clang/Basic/CLWarnings.h

19

clang-tidy's comment about the extra semicolon seems valid

[haowei]

We are seeing a series of weird errors in our windows clang builder after this patch landed:

[1/828] Building CXX object compiler-rt\lib\sanitizer_common\CMakeFiles\RTSanitizerCommonNoTermination.x86_64.dir\sanitizer_solaris.cpp.obj
FAILED: compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommonNoTermination.x86_64.dir/sanitizer_solaris.cpp.obj 
C:\b\s\w\ir\x\w\staging\llvm_build\.\bin\clang-cl.exe  /nologo -TP -DHAVE_RPC_XDR_H=0 -DUNICODE -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS -D_UNICODE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D__func__=__FUNCTION__ -IC:\b\s\w\ir\x\w\llvm-project\compiler-rt\lib\sanitizer_common\.. /DWIN32 /D_WINDOWS   /Zc:inline /Zc:__cplusplus /Zc:strictStrings /Oi /Zc:rvalueCast /Brepro /bigobj /W4 -wd4141 -wd4146 -wd4244 -wd4267 -wd4291 -wd4351 -wd4456 -wd4457 -wd4458 -wd4459 -wd4503 -wd4624 -wd4722 -wd4100 -wd4127 -wd4512 -wd4505 -wd4610 -wd4510 -wd4702 -wd4245 -wd4706 -wd4310 -wd4701 -wd4703 -wd4389 -wd4611 -wd4805 -wd4204 -wd4577 -wd4091 -wd4592 -wd4319 -wd4709 -wd4324 -w14062 -we4238 /Gw /MD /Z7 /O2 /Ob1    /Zc:threadSafeInit- -Wthread-safety -Wthread-safety-reference -Wthread-safety-beta /Z7 -UNDEBUG /showIncludes /Focompiler-rt\lib\sanitizer_common\CMakeFiles\RTSanitizerCommonNoTermination.x86_64.dir\sanitizer_solaris.cpp.obj /Fdcompiler-rt\lib\sanitizer_common\CMakeFiles\RTSanitizerCommonNoTermination.x86_64.dir\ -c C:\b\s\w\ir\x\w\llvm-project\compiler-rt\lib\sanitizer_common\sanitizer_solaris.cpp
error: unknown argument: '-wd4141'
error: unknown argument: '-wd4146'
error: unknown argument: '-wd4244'
error: unknown argument: '-wd4267'
error: unknown argument: '-wd4291'
error: unknown argument: '-wd4351'
error: unknown argument: '-wd4456'
error: unknown argument: '-wd4457'
error: unknown argument: '-wd4458'
error: unknown argument: '-wd4459'
error: unknown argument: '-wd4503'
error: unknown argument: '-wd4624'
error: unknown argument: '-wd4722'
error: unknown argument: '-wd4127'
error: unknown argument: '-wd4512'
error: unknown argument: '-wd4505'
error: unknown argument: '-wd4610'
error: unknown argument: '-wd4510'
error: unknown argument: '-wd4702'
fatal error: too many errors emitted, stopping now [-ferror-limit=]

Failed build task is https://ci.chromium.org/ui/p/fuchsia/builders/toolchain.ci/clang-windows-x64/b8834735134024529217/overview . The error disappeared when I revert this change on our builder. Do you have an idea why this change caused the build issue?

[akhuang]

Seems like there are also errors in chrome builds and the llvm compiler-rt build, will just revert it for now --

[thakis]

Thanks for the revert. The problem was that this continue was in the wrong spot:

diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index 9450e8b154c5..369c12aea523 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -5453,8 +5453,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
       if (auto Group = diagGroupFromCLWarningID(WarningNumber)) {
         CmdArgs.push_back(Args.MakeArgString(
             "-Wno-" + DiagnosticIDs::getWarningOptionForGroup(*Group)));
-        continue;
       }
+      continue;
     }
     A->render(Args, CmdArgs);
   }

The tests didn't catch this because they pass -###. In the reland I'm including the following additional test that will catch this at test time (it checks we don't pass wd flags with an unknown number through unchanged to cc1):

diff --git a/clang/test/Driver/cl-options.c b/clang/test/Driver/cl-options.c
index 74dd68753a1f..618be2d230f9 100644
--- a/clang/test/Driver/cl-options.c
+++ b/clang/test/Driver/cl-options.c
@@ -359,6 +359,7 @@
 // Wno: "-Wno-unused-parameter"
 // Wno: "-Wno-dllexport-explicit-instantiation-decl"
 // Wno: "-Wno-deprecated-declarations"
+// Wno-NOT: "-wd
 
 // Ignored options. Check that we don't get "unused during compilation" errors.
 // RUN: %clang_cl /c \

[xbolva00]

Please next time give a bit more time to potential reviewers / other folks outside your org. The whole lifecycle of this patch (posted - landed) took < 24h.

[thakis]

In D110668#3034576, @xbolva00 wrote:

Please next time give a bit more time to potential reviewers / other folks outside your org. The whole lifecycle of this patch (posted - landed) took < 24h.

Is there anything wrong with the patch?

I agree that it's good to let larger changes sit for a bit, but this seems like a fairly small and inconsequential change to me. Many patches land with a review time < 24h.

In any case, happy to address post-commit review comments too of course.

[xbolva00]

In D110668#3036361, @thakis wrote:

In D110668#3034576, @xbolva00 wrote:

Please next time give a bit more time to potential reviewers / other folks outside your org. The whole lifecycle of this patch (posted - landed) took < 24h.

Is there anything wrong with the patch?

I agree that it's good to let larger changes sit for a bit, but this seems like a fairly small and inconsequential change to me. Many patches land with a review time < 24h.

In any case, happy to address post-commit review comments too of course.

I think I would prefer to implement such "mapping" in DiagnosticGroups.td instead of current solution. cc @aaron.ballman as well, as he is an exprienced reviewer here.

What I mean, for example:

def UnusedParameter : DiagGroup<"unused-parameter", 4100>;

[thakis]

What I mean, for example:

def UnusedParameter : DiagGroup<"unused-parameter", 4100>;

That's an interesting idea.

Given how seldom this is used, I weakly prefer having actual code for this though: It makes it easy to see all of those mapped flags, and it keeps rarely used things out of tablegen, which is imho a good thing.

[aaron.ballman]

In D110668#3038858, @xbolva00 wrote:

In D110668#3036361, @thakis wrote:

In D110668#3034576, @xbolva00 wrote:

Please next time give a bit more time to potential reviewers / other folks outside your org. The whole lifecycle of this patch (posted - landed) took < 24h.

Is there anything wrong with the patch?

I agree that it's good to let larger changes sit for a bit, but this seems like a fairly small and inconsequential change to me. Many patches land with a review time < 24h.

In any case, happy to address post-commit review comments too of course.

I think I would prefer to implement such "mapping" in DiagnosticGroups.td instead of current solution. cc @aaron.ballman as well, as he is an exprienced reviewer here.

What I mean, for example:

def UnusedParameter : DiagGroup<"unused-parameter", 4100>;

FWIW, I agree that this is a better approach -- I'm uncomfortable having a separate list of diagnostic IDs that matter. To me, this information is part of the diagnostic itself. Having it listed alongside the diagnostic text also means that when we repurpose a diagnostic to have a slightly different meaning (which does happen from time to time), there's something more visible in the reviewer's face about whether the change also means the diagnostic shouldn't map to a CL diagnostic (or should map to a different one). Personally, I would prefer to see it surfaced like this:

def UnusedParameter : DiagGroup<"unused-parameter", [CL<4100>]>;

so that it accepts a list of alternative IDs for the diagnostic. We currently only care about the stable numbering from cl.exe, but there's no reason we wouldn't want to use this for other kinds of diagnostic grouping aliases. For example, someday we may want to use these same facilities to map between Clang diagnostic groups and GCC diagnostic groups where we surfaced different names for the group by accident.

In D110668#3040408, @thakis wrote:

That's an interesting idea.

Given how seldom this is used, I weakly prefer having actual code for this though: It makes it easy to see all of those mapped flags, and it keeps rarely used things out of tablegen, which is imho a good thing.

If we want to make it easy to see all the mapped flags, we can add a -cc1 option to dump them out in a more consumable manner, so I think we have solutions we can use there. I don't see this as being a rarely used thing though -- it's the stable identifier for the diagnostic, so it strongly relates to the definition of the diagnostic itself. This comes up in user-facing ways like through #pragma warning, so it seems worth it to have it in tablegen, at least to me.

[thakis]

Thanks for the feedback. I'll work on a follow-up that implements that.

clang/include/clang/Basic/CLWarnings.h

+//===--- CLWarnings.h - Maps some cl.exe warning ids  -----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_BASIC_CLWARNINGS_H
+#define LLVM_CLANG_BASIC_CLWARNINGS_H
+
+#include "llvm/ADT/Optional.h"
+
+namespace clang {
+
+namespace diag {
+enum class Group;
+}
+
+/// For cl.exe warning IDs that cleany map to clang diagnostic groups,
+/// returns the corresponding group. Else, returns an empty Optional.
+llvm::Optional<diag::Group> diagGroupFromCLWarningID(unsigned);
+
+} // end namespace clang
+
+#endif // LLVM_CLANG_BASIC_CLWARNINGS_H

clang/include/clang/Basic/Diagnostic.h

public:
   /// \param Flavor The flavor of group to affect. -Rfoo does not affect the
   /// state of the -Wfoo group and vice versa.
   ///
   /// \param Loc The source location that this change of diagnostic state should
   /// take affect. It can be null if we are setting the state from command-line.
   bool setSeverityForGroup(diag::Flavor Flavor, StringRef Group,
                            diag::Severity Map,
                            SourceLocation Loc = SourceLocation());
+  bool setSeverityForGroup(diag::Flavor Flavor, diag::Group Group,
+                           diag::Severity Map,
+                           SourceLocation Loc = SourceLocation());
 
   /// Set the warning-as-error flag for the given diagnostic group.
   ///
   /// This function always only operates on the current diagnostic state.
   ///
   /// \returns True if the given group is unknown, false otherwise.
   bool setDiagnosticGroupWarningAsError(StringRef Group, bool Enabled);
 

clang/include/clang/Basic/DiagnosticCategories.h

namespace diag {
     enum {
 #define GET_CATEGORY_TABLE
 #define CATEGORY(X, ENUM) ENUM,
 #include "clang/Basic/DiagnosticGroups.inc"
 #undef CATEGORY
 #undef GET_CATEGORY_TABLE
       DiagCat_NUM_CATEGORIES
     };
+
+    enum class Group {
+#define DIAG_ENTRY(GroupName, FlagNameOffset, Members, SubGroups) GroupName,
+#include "clang/Basic/DiagnosticGroups.inc"
+#undef CATEGORY
+#undef DIAG_ENTRY
+    };
   }  // end namespace diag
 }  // end namespace clang
 
 #endif

clang/include/clang/Basic/DiagnosticGroups.td

 def DanglingInitializerList : DiagGroup<"dangling-initializer-list">;
 def DanglingGsl : DiagGroup<"dangling-gsl">;
 def ReturnStackAddress : DiagGroup<"return-stack-address">;
 def Dangling : DiagGroup<"dangling", [DanglingField,
                                       DanglingInitializerList,
                                       DanglingGsl,
                                       ReturnStackAddress]>;
 def DistributedObjectModifiers : DiagGroup<"distributed-object-modifiers">;
+def DllexportExplicitInstantiationDecl : DiagGroup<"dllexport-explicit-instantiation-decl">;
 def ExcessInitializers : DiagGroup<"excess-initializers">;
 def ExpansionToDefined : DiagGroup<"expansion-to-defined">;
 def FlagEnum : DiagGroup<"flag-enum">;
 def IncrementBool : DiagGroup<"increment-bool", [DeprecatedIncrementBool]>;
 def InfiniteRecursion : DiagGroup<"infinite-recursion">;
 def PureVirtualCallFromCtorDtor: DiagGroup<"call-to-pure-virtual-from-ctor-dtor">;
 def GNUImaginaryConstant : DiagGroup<"gnu-imaginary-constant">;
 def IgnoredReferenceQualifiers : DiagGroup<"ignored-reference-qualifiers">;

clang/include/clang/Basic/DiagnosticIDs.h

 #include <vector>
 
 namespace clang {
   class DiagnosticsEngine;
   class SourceLocation;
 
   // Import the diagnostic enums themselves.
   namespace diag {
+    enum class Group;
+
     // Size of each of the diagnostic categories.
     enum {
       DIAG_SIZE_COMMON        =  300,
       DIAG_SIZE_DRIVER        =  250,
       DIAG_SIZE_FRONTEND      =  150,
       DIAG_SIZE_SERIALIZATION =  120,
       DIAG_SIZE_LEX           =  400,
       DIAG_SIZE_PARSE         =  600,
public:
   /// extension of some sort, and whether it is enabled by default.
   ///
   /// This also returns EnabledByDefault, which is set to indicate whether the
   /// diagnostic is ignored by default (in which case -pedantic enables it) or
   /// treated as a warning/error by default.
   ///
   static bool isBuiltinExtensionDiag(unsigned DiagID, bool &EnabledByDefault);
 
+  /// Given a group ID, returns the flag that toggles the group.
+  /// For example, for Group::DeprecatedDeclarations, returns
+  /// "deprecated-declarations".
+  static StringRef getWarningOptionForGroup(diag::Group);
 
   /// Return the lowest-level warning option that enables the specified
   /// diagnostic.
   ///
   /// If there is no -Wfoo flag that controls the diagnostic, this returns null.
   static StringRef getWarningOptionForDiag(unsigned DiagID);
 
   /// Return the category number that a specified \p DiagID belongs to,

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_attribute_dllimport_data_definition : Error<
   "definition of dllimport data">;
 def err_attribute_dllimport_static_field_definition : Error<
   "definition of dllimport static field not allowed">;
 def warn_attribute_dllimport_static_field_definition : Warning<
   "definition of dllimport static field">,
   InGroup<DiagGroup<"dllimport-static-field-def">>;
 def warn_attribute_dllexport_explicit_instantiation_decl : Warning<
   "explicit instantiation declaration should not be 'dllexport'">,
-  InGroup<DiagGroup<"dllexport-explicit-instantiation-decl">>;
+  InGroup<DllexportExplicitInstantiationDecl>;
 def warn_attribute_dllexport_explicit_instantiation_def : Warning<
   "'dllexport' attribute ignored on explicit instantiation definition">,
   InGroup<IgnoredAttributes>;
 def warn_invalid_initializer_from_system_header : Warning<
   "invalid constructor from class in system header, should not be explicit">,
   InGroup<DiagGroup<"invalid-initializer-from-system-header">>;
 def note_used_in_initialization_here : Note<"used in initialization here">;
 def err_attribute_dll_member_of_dll_class : Error<

clang/include/clang/Driver/Options.td

 def _SLASH_Wall : CLFlag<"Wall">, HelpText<"Enable -Weverything">,
   Alias<W_Joined>, AliasArgs<["everything"]>;
 def _SLASH_WX : CLFlag<"WX">, HelpText<"Treat warnings as errors">,
   Alias<W_Joined>, AliasArgs<["error"]>;
 def _SLASH_WX_ : CLFlag<"WX-">,
   HelpText<"Do not treat warnings as errors (default)">,
   Alias<W_Joined>, AliasArgs<["no-error"]>;
 def _SLASH_w_flag : CLFlag<"w">, HelpText<"Disable all warnings">, Alias<w>;
-def _SLASH_wd4005 : CLFlag<"wd4005">, Alias<W_Joined>,
-  AliasArgs<["no-macro-redefined"]>;
-def _SLASH_wd4018 : CLFlag<"wd4018">, Alias<W_Joined>,
-  AliasArgs<["no-sign-compare"]>;
-def _SLASH_wd4100 : CLFlag<"wd4100">, Alias<W_Joined>,
-  AliasArgs<["no-unused-parameter"]>;
-def _SLASH_wd4910 : CLFlag<"wd4910">, Alias<W_Joined>,
-  AliasArgs<["no-dllexport-explicit-instantiation-decl"]>;
-def _SLASH_wd4996 : CLFlag<"wd4996">, Alias<W_Joined>,
-  AliasArgs<["no-deprecated-declarations"]>;
+def _SLASH_wd : CLCompileJoined<"wd">;
 def _SLASH_vd : CLJoined<"vd">, HelpText<"Control vtordisp placement">,
   Alias<vtordisp_mode_EQ>;
 def _SLASH_X : CLFlag<"X">,
   HelpText<"Do not add %INCLUDE% to include search path">, Alias<nostdlibinc>;
 def _SLASH_Zc_sizedDealloc : CLFlag<"Zc:sizedDealloc">,
   HelpText<"Enable C++14 sized global deallocation functions">,
   Alias<fsized_deallocation>;
 def _SLASH_Zc_sizedDealloc_ : CLFlag<"Zc:sizedDealloc-">,

clang/lib/Basic/CLWarnings.cpp

+//===--- CLWarnings.h - Maps some cl.exe warning ids  -----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements the Diagnostic-related interfaces.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Basic/CLWarnings.h"
+#include "clang/Basic/DiagnosticCategories.h"
+
+using namespace clang;
+
+llvm::Optional<diag::Group>
+clang::diagGroupFromCLWarningID(unsigned CLWarningID) {
+  switch (CLWarningID) {
+  case 4005: return diag::Group::MacroRedefined;
+  case 4018: return diag::Group::SignCompare;
+  case 4100: return diag::Group::UnusedParameter;
+  case 4910: return diag::Group::DllexportExplicitInstantiationDecl;
+  case 4996: return diag::Group::DeprecatedDeclarations;
+  }
+  return {};
+}

clang/lib/Basic/CMakeLists.txt

 if(CLANG_VENDOR)
   set_source_files_properties(Version.cpp
     PROPERTIES COMPILE_DEFINITIONS "CLANG_VENDOR=\"${CLANG_VENDOR} \"")
 endif()
 
 add_clang_library(clangBasic
   Attributes.cpp
   Builtins.cpp
+  CLWarnings.cpp
   CharInfo.cpp
   CodeGenOptions.cpp
   Cuda.cpp
   DarwinSDKInfo.cpp
   Diagnostic.cpp
   DiagnosticIDs.cpp
   DiagnosticOptions.cpp
   ExpressionTraits.cpp

clang/lib/Basic/Diagnostic.cpp

bool DiagnosticsEngine::setSeverityForGroup(diag::Flavor Flavor,
 
   // Set the mapping.
   for (diag::kind Diag : GroupDiags)
     setSeverity(Diag, Map, Loc);
 
   return false;
 }
 
+bool DiagnosticsEngine::setSeverityForGroup(diag::Flavor Flavor,
+                                            diag::Group Group,
+                                            diag::Severity Map,
+                                            SourceLocation Loc) {
+  return setSeverityForGroup(Flavor, Diags->getWarningOptionForGroup(Group),
+                             Map, Loc);
+}
+
 bool DiagnosticsEngine::setDiagnosticGroupWarningAsError(StringRef Group,
                                                          bool Enabled) {
   // If we are enabling this feature, just set the diagnostic mappings to map to
   // errors.
   if (Enabled)
     return setSeverityForGroup(diag::Flavor::WarningOrError, Group,
                                diag::Severity::Error);
 

clang/lib/Basic/DiagnosticIDs.cpp

StringRef getName() const {
       return StringRef(DiagGroupNames + NameOffset + 1,
                        DiagGroupNames[NameOffset]);
     }
   };
 }
 
 // Second the table of options, sorted by name for fast binary lookup.
 static const WarningOption OptionTable[] = {
-#define GET_DIAG_TABLE
+#define DIAG_ENTRY(GroupName, FlagNameOffset, Members, SubGroups)              \
+  {FlagNameOffset, Members, SubGroups},
 #include "clang/Basic/DiagnosticGroups.inc"
-#undef GET_DIAG_TABLE
+#undef DIAG_ENTRY
 };
 
+StringRef DiagnosticIDs::getWarningOptionForGroup(diag::Group Group) {
+  return OptionTable[static_cast<int>(Group)].getName();
+}
+
 /// getWarningOptionForDiag - Return the lowest-level warning option that
 /// enables the specified diagnostic.  If there is no -Wfoo flag that controls
 /// the diagnostic, this returns null.
 StringRef DiagnosticIDs::getWarningOptionForDiag(unsigned DiagID) {
   if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
-    return OptionTable[Info->getOptionGroupIndex()].getName();
+    return getWarningOptionForGroup(
+        static_cast<diag::Group>(Info->getOptionGroupIndex()));
   return StringRef();
 }
 
 std::vector<std::string> DiagnosticIDs::getDiagnosticFlags() {
   std::vector<std::string> Res;
   for (size_t I = 1; DiagGroupNames[I] != '\0';) {
     std::string Diag(DiagGroupNames + I + 1, DiagGroupNames[I]);
     I += DiagGroupNames[I] + 1;

clang/lib/Driver/ToolChains/Clang.cpp

 #include "Arch/Sparc.h"
 #include "Arch/SystemZ.h"
 #include "Arch/VE.h"
 #include "Arch/X86.h"
 #include "CommonArgs.h"
 #include "Hexagon.h"
 #include "MSP430.h"
 #include "PS4CPU.h"
+#include "clang/Basic/CLWarnings.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/CodeGenOptions.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Basic/Version.h"
 #include "clang/Driver/Distro.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/InputInfo.h"
for (const Arg *A :
     D.Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
     A->claim();
   }
 
   claimNoWarnArgs(Args);
 
   Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
 
-  Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
+  for (const Arg *A :
+       Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) {
+    A->claim();
+    if (A->getOption().getID() == options::OPT__SLASH_wd) {
+      unsigned WarningNumber;
+      if (StringRef(A->getValue()).getAsInteger(10, WarningNumber)) {
+        D.Diag(diag::err_drv_invalid_int_value)
+            << A->getAsString(Args) << A->getValue();
+        continue;
+      }
+
+      if (auto Group = diagGroupFromCLWarningID(WarningNumber)) {
+        CmdArgs.push_back(Args.MakeArgString(
+            Twine("-Wno-") + DiagnosticIDs::getWarningOptionForGroup(*Group)));
+        continue;
+      }
+    }
+    A->render(Args, CmdArgs);
+  }
+
   if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
     CmdArgs.push_back("-pedantic");
   Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
   Args.AddLastArg(CmdArgs, options::OPT_w);
 
   // Fixed point flags
   if (Args.hasFlag(options::OPT_ffixed_point, options::OPT_fno_fixed_point,
                    /*Default=*/false))

clang/lib/Lex/Pragma.cpp

 //===- Pragma.cpp - Pragma registration and handling ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the PragmaHandler/PragmaTable interfaces and implements
 // pragma related methods of the Preprocessor class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Lex/Pragma.h"
+#include "clang/Basic/CLWarnings.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticLex.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/Module.h"
 #include "clang/Basic/SourceLocation.h"
if (II && II->isStr("push")) {
         if (Tok.is(tok::numeric_constant) &&
             PP.parseSimpleIntegerLiteral(Tok, Value))
           Level = int(Value);
         if (Level < 0 || Level > 4) {
           PP.Diag(Tok, diag::warn_pragma_warning_push_level);
           return;
         }
       }
+      PP.getDiagnostics().pushMappings(DiagLoc);
       if (Callbacks)
         Callbacks->PragmaWarningPush(DiagLoc, Level);
     } else if (II && II->isStr("pop")) {
       // #pragma warning( pop )
       PP.Lex(Tok);
-      if (Callbacks)
+      if (!PP.getDiagnostics().popMappings(DiagLoc))
+        PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop);
+      else if (Callbacks)
         Callbacks->PragmaWarningPop(DiagLoc);
     } else {
       // #pragma warning( warning-specifier : warning-number-list
       //                  [; warning-specifier : warning-number-list...] )
       while (true) {
         II = Tok.getIdentifierInfo();
         if (!II && !Tok.is(tok::numeric_constant)) {
           PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
if (II && II->isStr("push")) {
           uint64_t Value;
           if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 ||
               Value > INT_MAX) {
             PP.Diag(Tok, diag::warn_pragma_warning_expected_number);
             return;
           }
           Ids.push_back(int(Value));
         }
+
+        // Only act on disable for now.
+        diag::Severity SV = diag::Severity();
+        if (Specifier == PPCallbacks::PWS_Disable)
+          SV = diag::Severity::Ignored;
+        if (SV != diag::Severity())
+          for (int Id : Ids) {
+            if (auto Group = diagGroupFromCLWarningID(Id)) {
+              bool unknownDiag = PP.getDiagnostics().setSeverityForGroup(
+                  diag::Flavor::WarningOrError, *Group, SV, DiagLoc);
+              assert(!unknownDiag &&
+                     "wd table should only contain known diags");
+              (void)unknownDiag;
+            }
+          }
+
         if (Callbacks)
           Callbacks->PragmaWarning(DiagLoc, Specifier, Ids);
 
         // Parse the next specifier if there is a semicolon.
         if (Tok.isNot(tok::semi))
           break;
         PP.Lex(Tok);
       }

clang/test/Driver/cl-options.c

 // CHECK-CHAR8_T: "-fchar8_t"
 // RUN: %clang_cl -c -### /Zc:char8_t- -- %s 2>&1 | FileCheck -check-prefix CHECK-CHAR8_T_ %s
 // CHECK-CHAR8_T_: "-fno-char8_t"
 
 // RUN: %clang_cl -c -### /std:c11 -- %s 2>&1 | FileCheck -check-prefix CHECK-C11 %s
 // CHECK-C11: -std=c11
 
 // For some warning ids, we can map from MSVC warning to Clang warning.
-// RUN: %clang_cl -wd4005 -wd4100 -wd4910 -wd4996 -### -- %s 2>&1 | FileCheck -check-prefix=Wno %s
+// RUN: %clang_cl -wd4005 -wd4100 -wd4910 -wd4996 -wd12345678 -### -- %s 2>&1 | FileCheck -check-prefix=Wno %s
 // Wno: "-cc1"
 // Wno: "-Wno-macro-redefined"
 // Wno: "-Wno-unused-parameter"
 // Wno: "-Wno-dllexport-explicit-instantiation-decl"
 // Wno: "-Wno-deprecated-declarations"
 
 // Ignored options. Check that we don't get "unused during compilation" errors.
 // RUN: %clang_cl /c \

clang/test/Sema/pragma-warning.cpp

+// RUN: %clang_cc1 -triple x86_64-pc-windows-msvc -fms-extensions -fsyntax-only -verify %s
+
+[[deprecated]] void f() {} // expected-note 2 {{marked deprecated here}}
+
+#define From__pragma() \
+  __pragma(warning(push)) \
+  __pragma(warning(disable:4996)) \
+  f(); \
+  __pragma(warning(pop))
+
+void g() {
+  f(); // expected-warning {{deprecated}}
+
+#pragma warning(push)
+#pragma warning(disable: 4996)
+  f(); // no diag
+
+#pragma warning(disable: 49960000)
+#pragma warning(pop)
+
+  f(); // expected-warning {{deprecated}}
+
+  From__pragma(); // no diag
+}

clang/tools/diagtool/DiagnosticNames.cpp

 
 
 #define GET_DIAG_ARRAYS
 #include "clang/Basic/DiagnosticGroups.inc"
 #undef GET_DIAG_ARRAYS
 
 // Second the table of options, sorted by name for fast binary lookup.
 static const GroupRecord OptionTable[] = {
-#define GET_DIAG_TABLE
+#define DIAG_ENTRY(GroupName, FlagNameOffset, Members, SubGroups)              \
+  {FlagNameOffset, Members, SubGroups},
 #include "clang/Basic/DiagnosticGroups.inc"
-#undef GET_DIAG_TABLE
+#undef DIAG_ENTRY
 };
 
 llvm::StringRef GroupRecord::getName() const {
   return StringRef(DiagGroupNames + NameOffset + 1, DiagGroupNames[NameOffset]);
 }
 
 GroupRecord::subgroup_iterator GroupRecord::subgroup_begin() const {
   return DiagSubGroups + SubGroups;

clang/utils/TableGen/ClangDiagnosticsEmitter.cpp

public:
     }
 
     typedef std::vector<std::string>::const_iterator const_iterator;
     const_iterator begin() const { return CategoryStrings.begin(); }
     const_iterator end() const { return CategoryStrings.end(); }
   };
 
   struct GroupInfo {
+    llvm::StringRef GroupName;
     std::vector<const Record*> DiagsInGroup;
     std::vector<std::string> SubGroups;
     unsigned IDNo;
 
     llvm::SmallVector<const Record *, 1> Defs;
 
     GroupInfo() : IDNo(0) {}
   };
static void groupDiagnostics(const std::vector<Record*> &Diags,
   }
 
   // Add all DiagGroup's to the DiagsInGroup list to make sure we pick up empty
   // groups (these are warnings that GCC supports that clang never produces).
   for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
     Record *Group = DiagGroups[i];
     GroupInfo &GI =
         DiagsInGroup[std::string(Group->getValueAsString("GroupName"))];
+    GI.GroupName = Group->getName();
     GI.Defs.push_back(Group);
 
     std::vector<Record*> SubGroups = Group->getValueAsListOfDefs("SubGroups");
     for (unsigned j = 0, e = SubGroups.size(); j != e; ++j)
       GI.SubGroups.push_back(
           std::string(SubGroups[j]->getValueAsString("GroupName")));
   }
 
for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
     OS << R.getValueAsDef("Class")->getName();
     OS << ", (unsigned)diag::Severity::"
        << R.getValueAsDef("DefaultSeverity")->getValueAsString("Name");
 
     // Description string.
     OS << ", \"";
     OS.write_escaped(DiagTextBuilder.buildForDefinition(&R)) << '"';
 
-    // Warning associated with the diagnostic. This is stored as an index into
-    // the alphabetically sorted warning table.
+    // Warning group associated with the diagnostic. This is stored as an index
+    // into the alphabetically sorted warning group table.
     if (DefInit *DI = dyn_cast<DefInit>(R.getValueInit("Group"))) {
       std::map<std::string, GroupInfo>::iterator I = DiagsInGroup.find(
           std::string(DI->getDef()->getValueAsString("GroupName")));
       assert(I != DiagsInGroup.end());
       OS << ", " << I->second.IDNo;
     } else if (DiagsInPedantic.count(&R)) {
       std::map<std::string, GroupInfo>::iterator I =
         DiagsInGroup.find("pedantic");
static void emitDiagTable(std::map<std::string, GroupInfo> &DiagsInGroup,
                           RecordVec &DiagsInPedantic,
                           RecordVec &GroupsInPedantic,
                           StringToOffsetTable &GroupNames, raw_ostream &OS) {
   unsigned MaxLen = 0;
 
   for (auto const &I: DiagsInGroup)
     MaxLen = std::max(MaxLen, (unsigned)I.first.size());
 
-  OS << "\n#ifdef GET_DIAG_TABLE\n";
+  OS << "\n#ifdef DIAG_ENTRY\n";
   unsigned SubGroupIndex = 1, DiagArrayIndex = 1;
   for (auto const &I: DiagsInGroup) {
     // Group option string.
-    OS << "  { /* ";
+    OS << "DIAG_ENTRY(";
+    OS << I.second.GroupName << " /* ";
+
     if (I.first.find_first_not_of("abcdefghijklmnopqrstuvwxyz"
                                    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                    "0123456789!@#$%^*-+=:?") !=
         std::string::npos)
       PrintFatalError("Invalid character in diagnostic group '" + I.first +
                       "'");
-    OS << I.first << " */ " << std::string(MaxLen - I.first.size(), ' ');
+    OS << I.first << " */, ";
     // Store a pascal-style length byte at the beginning of the string.
     std::string Name = char(I.first.size()) + I.first;
     OS << GroupNames.GetOrAddStringOffset(Name, false) << ", ";
 
     // Special handling for 'pedantic'.
     const bool IsPedantic = I.first == "pedantic";
 
     // Diagnostics in the group.
     const std::vector<const Record *> &V = I.second.DiagsInGroup;
     const bool hasDiags =
         !V.empty() || (IsPedantic && !DiagsInPedantic.empty());
     if (hasDiags) {
       OS << "/* DiagArray" << I.second.IDNo << " */ " << DiagArrayIndex
          << ", ";
       if (IsPedantic)
         DiagArrayIndex += DiagsInPedantic.size();
       DiagArrayIndex += V.size() + 1;
     } else {
-      OS << "/* Empty */     0, ";
+      OS << "0, ";
     }
 
     // Subgroups.
     const std::vector<std::string> &SubGroups = I.second.SubGroups;
     const bool hasSubGroups =
         !SubGroups.empty() || (IsPedantic && !GroupsInPedantic.empty());
     if (hasSubGroups) {
       OS << "/* DiagSubGroup" << I.second.IDNo << " */ " << SubGroupIndex;
       if (IsPedantic)
         SubGroupIndex += GroupsInPedantic.size();
       SubGroupIndex += SubGroups.size() + 1;
     } else {
-      OS << "/* Empty */         0";
+      OS << "0";
     }
 
-    OS << " },\n";
+    OS << " )\n";
   }
-  OS << "#endif // GET_DIAG_TABLE\n\n";
+  OS << "#endif // DIAG_ENTRY\n\n";
 }
 
 /// Emit the table of diagnostic categories.
 ///
 /// The table has the form of macro calls that have two parameters. The
 /// category's name as well as an enum that represents the category. The
 /// table can be used by defining the macro 'CATEGORY' and including this
 /// table right after.

llvm/utils/gn/secondary/clang/lib/Basic/BUILD.gn

deps = [
     "//clang/include/clang/Sema:AttrSpellingListIndex",
     "//llvm/include/llvm/Config:llvm-config",
     "//llvm/lib/Support",
   ]
   include_dirs = [ "." ]
   sources = [
     "Attributes.cpp",
     "Builtins.cpp",
+    "CLWarnings.cpp",
     "CharInfo.cpp",
     "CodeGenOptions.cpp",
     "Cuda.cpp",
     "DarwinSDKInfo.cpp",
     "Diagnostic.cpp",
     "DiagnosticIDs.cpp",
     "DiagnosticOptions.cpp",
     "ExpressionTraits.cpp",