[Lex] Diagnose macro in command lines

[jackhong12]

Summary

• Fixes https://github.com/llvm/llvm-project/issues/56159

Description

We need to diagnose the macro in commands too. For example, the expected result of clang++ -Wreserved-identifier -D__WHY_NOT_ME__ -U__STDC__ tmp.cpp should be

<command line>:1:9: warning: macro name is a reserved identifier [-Wreserved-macro-identifier]
#define __WHY_NOT_ME__ 1
        ^
<command line>:2:8: warning: macro name is a reserved identifier [-Wreserved-macro-identifier]
#undef __STDC__
       ^

Currently, clang will not show any warning message when we define or undefine reserved macro in commands.

Fix

We use digital directives in the preprocessor, like

# 1 "<built-in>" 3
#define __llvm__ 1
#define __clang__ 1

...

# 1 "<command line>" 1
#define __WHY_NOT_ME__ 1
#undef __STDC__
#define __GCC_HAVE_DWARF2_CFI_ASM 1
# 1 "<built-in>" 2

I think we should use PresumedLoc to determine its <built-in> or <command line> section. In this case, the file name will be changed from <built-in> to <command line>. However, SourceMgr.getBufferName only returns the first name it matches.

Another issue is that clang will define __GCC_HAVE_DWARF2_CFI_ASM in the command line. But I don't know how to handle this macro. I only add this macro to the reserved macro list.

[jackhong12]

Sorry, I didn't consider some cases. I'll fix it soon!

[aaron.ballman]

Thank you for looking into this! I think we may need to figure out something better for handling macros defined by the driver, because otherwise we're going to get a bunch of false positives from this. For example, the clang-cl driver adds command line flags like -D_DEBUG and -D_MT, etc, the same as what happens for __GCC_HAVE_DWARF2_CFI_ASM. I'm not certain if there's an easy way to differentiate between driver-added -D flags and user-added -D flags, though. If we don't have anything that suffices already, we could invent something (either a new form of -D at the cc1 level that the driver emits for its defines, or some sort of cc1 flag to say "here's where user command line options begin", etc).

[serge-sans-paille]

great addition. Missing a test case though, which would probably trigger @aaron.ballman scenario

[jackhong12]

I added two flags, -driver-define and -driver-undefine, to indicate macros that the driver defines. And I moved driver-defined macros from <command line> file to <built-in> file, like

# 1 "<built-in>" 3
#define __llvm__ 1
#define __clang__ 1
...
# 1 "<command line>" 1
#define __WHY_NOT_ME__ 1
#undef __STDC__
# 1 "<built-in>" 2
#define __GCC_HAVE_DWARF2_CFI_ASM 1
...

[MaskRay]

clang/include/clang/Driver/Options.td

664

Make this CC1 only option NoDriverOption by moving it somewhere under let Flags = [CC1Option, NoDriverOption] in {

Don't add new Separate or JoinedOrSeparate options. They are legacy.

[jackhong12]

• modify option names
• only allow driver-defined macros used in cc1

[jackhong12]

clang/include/clang/Driver/Options.td

664

I tried to add = behind driver-define. But I got the following error messages when I ran ninja check-all.

[416/433] cd /home/zhenhong/ssd/zhenhong/llvm-project/clang/bindings/python && /usr/bin/cmake -E env CLANG_LIBRARY_PATH=/home/zhenhong/ssd/zhenhong/llvm-project/release/lib /usr/bin/python3.8 -m unittest discover                          
FAILED: tools/clang/bindings/python/tests/CMakeFiles/check-clang-python                                                                                                                                                                       
cd /home/zhenhong/ssd/zhenhong/llvm-project/clang/bindings/python && /usr/bin/cmake -E env CLANG_LIBRARY_PATH=/home/zhenhong/ssd/zhenhong/llvm-project/release/lib /usr/bin/python3.8 -m unittest discover                                    
E..........EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE...EEEEEEEEEE.EEEEE......EEEE..EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE                                                                                                                
======================================================================                                                                                                                                                                        
ERROR: test_access_specifiers (tests.cindex.test_access_specifiers.TestAccessSpecifiers)                                                                                                                                                      
Ensure that C++ access specifiers are available on cursors                                                                                                                                                                                    
----------------------------------------------------------------------                                                                                                                                                                        
Traceback (most recent call last):                                                                                                                                                                                                            
  File "/home/zhenhong/ssd/zhenhong/llvm-project/clang/bindings/python/tests/cindex/test_access_specifiers.py", line 20, in test_access_specifiers                                                                                            
    tu = get_tu("""                                                                                                                                                                                                                           
  File "/home/zhenhong/ssd/zhenhong/llvm-project/clang/bindings/python/tests/cindex/util.py", line 40, in get_tu                                                                                                                              
    return TranslationUnit.from_source(name, args, unsaved_files=[(name,                                                                                                                                                                      
  File "/home/zhenhong/ssd/zhenhong/llvm-project/clang/bindings/python/clang/cindex.py", line 2837, in from_source                                                                                                                            
    raise TranslationUnitLoadError("Error parsing translation unit.")                                                                                                                                                                         
clang.cindex.TranslationUnitLoadError: Error parsing translation unit.

...

I don't know what triggers the crash.

[aaron.ballman]

This review went cold for about a year now (sorry for not noticing we hadn't answered your question!), so I'm uncertain if @jackhong12 is still interested in pursuing this. If not, that's totally fine, just let us know so we can remove you as the assignee on the issue (https://github.com/llvm/llvm-project/issues/56159).

clang/include/clang/Driver/Options.td

664

I've never seen output like that before -- were you able to resolve this crash? @MaskRay do you have ideas?

[MaskRay]

clang/include/clang/Driver/Options.td

664

I suspect that this is a config issue.

This patch now requires some rebase to work. For example, the Flags/CC1Option mechanism has been replaced with Visibility<[CC1Option]>,

clang-tools-extra/test/pp-trace/pp-trace-include.cpp

 // CHECK-NEXT: - Callback: MacroDefined
 // CHECK:        MacroNameTok: __STDC_UTF_32__
 // CHECK-NEXT:   MacroDirective: MD_Define
 // CHECK:      - Callback: FileChanged
 // CHECK-NEXT:   Loc: "<command line>:1:1"
 // CHECK-NEXT:   Reason: EnterFile
 // CHECK-NEXT:   FileType: C_User
 // CHECK-NEXT:   PrevFID: (invalid)
-// CHECK:      - Callback: MacroDefined
 // CHECK:      - Callback: FileChanged
 // CHECK-NEXT:   Loc: "<built-in>:1:1"
 // CHECK-NEXT:   Reason: ExitFile
 // CHECK-NEXT:   FileType: C_User
 // CHECK-NEXT:   PrevFID: (invalid)
-// CHECK-NEXT: - Callback: FileChanged
+// CHECK:      - Callback: MacroDefined
+// CHECK:      - Callback: FileChanged
 // CHECK-NEXT:   Loc: "{{.*}}{{[/\\]}}pp-trace-include.cpp:1:1"
 // CHECK-NEXT:   Reason: ExitFile
 // CHECK-NEXT:   FileType: C_User
 // CHECK-NEXT:   PrevFID: (getFileEntryForID failed)
 // CHECK-NEXT: - Callback: InclusionDirective
 // CHECK-NEXT:   HashLoc: "{{.*}}{{[/\\]}}pp-trace-include.cpp:3:1"
 // CHECK-NEXT:   IncludeTok: include
 // CHECK-NEXT:   FileName: "Inputs/Level1A.h"

clang/include/clang/Driver/Options.td

def CC : Flag<["-"], "CC">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
     HelpText<"Include comments from within macros in preprocessed output">,
     MarshallingInfoFlag<PreprocessorOutputOpts<"ShowMacroComments">>;
 def C : Flag<["-"], "C">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
     HelpText<"Include comments in preprocessed output">,
     MarshallingInfoFlag<PreprocessorOutputOpts<"ShowComments">>;
 def D : JoinedOrSeparate<["-"], "D">, Group<Preprocessor_Group>,
     Flags<[CC1Option, FlangOption, FC1Option]>, MetaVarName<"<macro>=<value>">,
     HelpText<"Define <macro> to <value> (or 1 if <value> omitted)">;
+def driver_define : Joined<["-"], "driver-define">, Group<Preprocessor_Group>,
+    Flags<[CC1Option, NoDriverOption]>, MetaVarName<"<macro>=<value>">,
+    HelpText<"Define <macro> to <value> (or 1 if <value> omitted)">;
 def E : Flag<["-"], "E">, Flags<[NoXarchOption,CC1Option, FlangOption, FC1Option]>, Group<Action_Group>,
     HelpText<"Only run the preprocessor">;
 def F : JoinedOrSeparate<["-"], "F">, Flags<[RenderJoined,CC1Option]>,
     HelpText<"Add directory to framework include search path">;
 def G : JoinedOrSeparate<["-"], "G">, Flags<[NoXarchOption]>, Group<m_Group>,
     MetaVarName<"<size>">, HelpText<"Put objects of at most <size> bytes "
     "into small data section (MIPS / Hexagon)">;
 def G_EQ : Joined<["-"], "G=">, Flags<[NoXarchOption]>, Group<m_Group>, Alias<G>;

 def Tdata : JoinedOrSeparate<["-"], "Tdata">, Group<T_Group>,
   MetaVarName<"<addr>">, HelpText<"Set starting address of DATA to <addr>">;
 def Ttext : JoinedOrSeparate<["-"], "Ttext">, Group<T_Group>,
   MetaVarName<"<addr>">, HelpText<"Set starting address of TEXT to <addr>">;
 def T : JoinedOrSeparate<["-"], "T">, Group<T_Group>,
   MetaVarName<"<script>">, HelpText<"Specify <script> as linker script">;
 def U : JoinedOrSeparate<["-"], "U">, Group<Preprocessor_Group>,
   Flags<[CC1Option, FlangOption, FC1Option]>, MetaVarName<"<macro>">, HelpText<"Undefine macro <macro>">;
+def driver_undefine : Joined<["-"], "driver-undefine">, Group<Preprocessor_Group>,
+  Flags<[CC1Option, NoDriverOption]>, MetaVarName<"<macro>">, HelpText<"Undefine macro <macro>">;
 def V : JoinedOrSeparate<["-"], "V">, Flags<[NoXarchOption, Unsupported]>;
 def Wa_COMMA : CommaJoined<["-"], "Wa,">,
   HelpText<"Pass the comma separated arguments in <arg> to the assembler">,
   MetaVarName<"<arg>">;
 def Wall : Flag<["-"], "Wall">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
 def WCL4 : Flag<["-"], "WCL4">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
 def Wsystem_headers : Flag<["-"], "Wsystem-headers">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
 def Wno_system_headers : Flag<["-"], "Wno-system-headers">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;

clang/include/clang/Lex/PreprocessorOptions.h

enum class DisableValidationForModuleKind {
 
   LLVM_MARK_AS_BITMASK_ENUM(Module)
 };
 
 /// PreprocessorOptions - This class is used for passing the various options
 /// used in preprocessor initialization to InitializePreprocessor().
 class PreprocessorOptions {
 public:
-  std::vector<std::pair<std::string, bool/*isUndef*/>> Macros;
+  std::vector<std::pair<std::string, bool /*isUndef*/>> Macros, DriverMacros;
   std::vector<std::string> Includes;
   std::vector<std::string> MacroIncludes;
 
   /// Initialize the preprocessor with the compiler and target specific
   /// predefines.
   bool UsePredefines = true;
 
   /// Whether we should maintain a detailed record of all macro
public:
 
   void addMacroDef(StringRef Name) {
     Macros.emplace_back(std::string(Name), false);
   }
   void addMacroUndef(StringRef Name) {
     Macros.emplace_back(std::string(Name), true);
   }
 
+  void addDriverMacroDef(StringRef Name) {
+    DriverMacros.emplace_back(std::string(Name), false);
+  }
+  void addDriverMacroUndef(StringRef Name) {
+    DriverMacros.emplace_back(std::string(Name), true);
+  }
+
   void addRemappedFile(StringRef From, StringRef To) {
     RemappedFiles.emplace_back(std::string(From), std::string(To));
   }
 
   void addRemappedFile(StringRef From, llvm::MemoryBuffer *To) {
     RemappedFileBuffers.emplace_back(std::string(From), To);
   }
 

clang/lib/Driver/ToolChains/Clang.cpp

#endif
   CmdArgs.push_back(getBaseInputName(Args, Input));
 
   // Some flags which affect the language (via preprocessor
   // defines).
   if (Args.hasArg(options::OPT_static))
     CmdArgs.push_back("-static-define");
 
   if (Args.hasArg(options::OPT_municode))
-    CmdArgs.push_back("-DUNICODE");
+    CmdArgs.push_back("-driver-define=UNICODE");
 
   if (isa<AnalyzeJobAction>(JA))
     RenderAnalyzerOptions(Args, CmdArgs, Triple, Input);
 
   if (isa<AnalyzeJobAction>(JA) ||
       (isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze)))
     CmdArgs.push_back("-setup-static-analyzer");
 
if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
                        !TC.getTriple().isOSNetBSD() &&
                        !Distro(D.getVFS(), TC.getTriple()).IsGentoo() &&
                        !TC.getTriple().isAndroid() && TC.useIntegratedAs()))
     CmdArgs.push_back("-faddrsig");
 
   if ((Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) &&
       (EH || AsyncUnwindTables || UnwindTables ||
        DebugInfoKind != codegenoptions::NoDebugInfo))
-    CmdArgs.push_back("-D__GCC_HAVE_DWARF2_CFI_ASM=1");
+    CmdArgs.push_back("-driver-define__GCC_HAVE_DWARF2_CFI_ASM=1");
 
   if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
     std::string Str = A->getAsString(Args);
     if (!TC.getTriple().isOSBinFormatELF())
       D.Diag(diag::err_drv_unsupported_opt_for_target)
           << Str << TC.getTripleString();
     CmdArgs.push_back(Args.MakeArgString(Str));
   }
void Clang::AddClangCLArgs(const ArgList &Args, types::ID InputType,
 
   if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
     RTOptionID = A->getOption().getID();
 
   StringRef FlagForCRT;
   switch (RTOptionID) {
   case options::OPT__SLASH_MD:
     if (Args.hasArg(options::OPT__SLASH_LDd))
-      CmdArgs.push_back("-D_DEBUG");
-    CmdArgs.push_back("-D_MT");
-    CmdArgs.push_back("-D_DLL");
+      CmdArgs.push_back("-driver-define=_DEBUG");
+    CmdArgs.push_back("-driver-define=_MT");
+    CmdArgs.push_back("-driver-define=_DLL");
     FlagForCRT = "--dependent-lib=msvcrt";
     break;
   case options::OPT__SLASH_MDd:
-    CmdArgs.push_back("-D_DEBUG");
-    CmdArgs.push_back("-D_MT");
-    CmdArgs.push_back("-D_DLL");
+    CmdArgs.push_back("-driver-define=_DEBUG");
+    CmdArgs.push_back("-driver-define=_MT");
+    CmdArgs.push_back("-driver-define=_DLL");
     FlagForCRT = "--dependent-lib=msvcrtd";
     break;
   case options::OPT__SLASH_MT:
     if (Args.hasArg(options::OPT__SLASH_LDd))
-      CmdArgs.push_back("-D_DEBUG");
-    CmdArgs.push_back("-D_MT");
+      CmdArgs.push_back("-driver-define=_DEBUG");
+    CmdArgs.push_back("-driver-define=_MT");
     CmdArgs.push_back("-flto-visibility-public-std");
     FlagForCRT = "--dependent-lib=libcmt";
     break;
   case options::OPT__SLASH_MTd:
-    CmdArgs.push_back("-D_DEBUG");
-    CmdArgs.push_back("-D_MT");
+    CmdArgs.push_back("-driver-define=_DEBUG");
+    CmdArgs.push_back("-driver-define=_MT");
     CmdArgs.push_back("-flto-visibility-public-std");
     FlagForCRT = "--dependent-lib=libcmtd";
     break;
   default:
     llvm_unreachable("Unexpected option ID.");
   }
 
   if (Args.hasArg(options::OPT__SLASH_Zl)) {
-    CmdArgs.push_back("-D_VC_NODEFAULTLIB");
+    CmdArgs.push_back("-driver-define=_VC_NODEFAULTLIB");
   } else {
     CmdArgs.push_back(FlagForCRT.data());
 
     // This provides POSIX compatibility (maps 'open' to '_open'), which most
     // users want.  The /Za flag to cl.exe turns this off, but it's not
     // implemented in clang.
     CmdArgs.push_back("--dependent-lib=oldnames");
   }

clang/lib/Frontend/CompilerInvocation.cpp

if (M.first == "__CET__=2" && !M.second && CodeGenOpts.CFProtectionReturn &&
       continue;
     if (M.first == "__CET__=3" && !M.second && CodeGenOpts.CFProtectionReturn &&
         CodeGenOpts.CFProtectionBranch)
       continue;
 
     GenerateArg(Args, M.second ? OPT_U : OPT_D, M.first, SA);
   }
 
+  for (const auto &DM : Opts.DriverMacros)
+    GenerateArg(Args, DM.second ? OPT_driver_undefine : OPT_driver_define,
+                DM.first, SA);
+
   for (const auto &I : Opts.Includes) {
     // Don't generate OpenCL includes. They are implied by other flags that are
     // generated elsewhere.
     if (LangOpts.OpenCL && LangOpts.IncludeDefaultHeader &&
         ((LangOpts.DeclareOpenCLBuiltins && I == "opencl-c-base.h") ||
          I == "opencl-c.h"))
       continue;
     // Don't generate HLSL includes. They are implied by other flags that are
#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
   // Add macros from the command line.
   for (const auto *A : Args.filtered(OPT_D, OPT_U)) {
     if (A->getOption().matches(OPT_D))
       Opts.addMacroDef(A->getValue());
     else
       Opts.addMacroUndef(A->getValue());
   }
 
+  // Add driver defined macros
+  for (const auto *A : Args.filtered(OPT_driver_define, OPT_driver_undefine)) {
+    if (A->getOption().matches(OPT_driver_define))
+      Opts.addDriverMacroDef(A->getValue());
+    else
+      Opts.addDriverMacroUndef(A->getValue());
+  }
+
   // Add the ordered list of -includes.
   for (const auto *A : Args.filtered(OPT_include))
     Opts.Includes.emplace_back(A->getValue());
 
   for (const auto *A : Args.filtered(OPT_chain_include))
     Opts.ChainedIncludes.emplace_back(A->getValue());
 
   for (const auto *A : Args.filtered(OPT_remap_file)) {

clang/lib/Frontend/InitPreprocessor.cpp

else
       DefineBuiltinMacro(Builder, InitOpts.Macros[i].first,
                          PP.getDiagnostics());
   }
 
   // Exit the command line and go back to <built-in> (2 is LC_LEAVE).
   if (!PP.getLangOpts().AsmPreprocessor)
     Builder.append("# 1 \"<built-in>\" 2");
 
+  // Process driver defined macros
+  for (unsigned i = 0, e = InitOpts.DriverMacros.size(); i != e; ++i) {
+    if (InitOpts.DriverMacros[i].second) // isUndef
+      Builder.undefineMacro(InitOpts.DriverMacros[i].first);
+    else
+      DefineBuiltinMacro(Builder, InitOpts.DriverMacros[i].first,
+                         PP.getDiagnostics());
+  }
+
   // If -imacros are specified, include them now.  These are processed before
   // any -include directives.
   for (unsigned i = 0, e = InitOpts.MacroIncludes.size(); i != e; ++i)
     AddImplicitIncludeMacros(Builder, InitOpts.MacroIncludes[i]);
 
   // Process -include-pch/-include-pth directives.
   if (!InitOpts.ImplicitPCHInclude.empty())
     AddImplicitIncludePCH(Builder, PP, PCHContainerRdr,

clang/lib/Lex/PPDirectives.cpp

if (isDefineUndef == MU_Undef) {
     }
   }
 
   // If defining/undefining reserved identifier or a keyword, we need to issue
   // a warning.
   SourceLocation MacroNameLoc = MacroNameTok.getLocation();
   if (ShadowFlag)
     *ShadowFlag = false;
-  if (!SourceMgr.isInSystemHeader(MacroNameLoc) &&
-      (SourceMgr.getBufferName(MacroNameLoc) != "<built-in>")) {
+  PresumedLoc PL = SourceMgr.getPresumedLoc(MacroNameLoc);
+  const char *const FileName = PL.isValid() ? PL.getFilename() : nullptr;
+  if (!SourceMgr.isInSystemHeader(MacroNameLoc) && FileName != nullptr &&
+      strcmp(FileName, "<built-in>") && strcmp(FileName, "<driver define>")) {
     MacroDiag D = MD_NoWarn;
     if (isDefineUndef == MU_Define) {
       D = shouldWarnOnMacroDef(*this, II);
     }
     else if (isDefineUndef == MU_Undef)
       D = shouldWarnOnMacroUndef(*this, II);
     if (D == MD_KeywordDef) {
       // We do not want to warn on some patterns widely used in configuration

clang/test/Driver/cl-runtime-flags.c

 // Note: %s must be preceded by --, otherwise it may be interpreted as a
 // command-line option, e.g. on Mac where %s is commonly under /Users.
 
 // First check that regular clang doesn't do any of this stuff.
 // RUN: %clang -### %s 2>&1 | FileCheck -check-prefix=CHECK-CLANG %s
-// CHECK-CLANG-NOT: "-D_DEBUG"
-// CHECK-CLANG-NOT: "-D_MT"
-// CHECK-CLANG-NOT: "-D_DLL"
+// CHECK-CLANG-NOT: "-driver-define=_DEBUG"
+// CHECK-CLANG-NOT: "-driver-define=_MT"
+// CHECK-CLANG-NOT: "-driver-define=_DLL"
 // CHECK-CLANG-NOT: --dependent-lib
 
 // RUN: %clang_cl -### -- %s 2>&1 | FileCheck -check-prefix=CHECK-MT %s
 // RUN: %clang_cl -### /MT -- %s 2>&1 | FileCheck -check-prefix=CHECK-MT %s
-// CHECK-MT-NOT: "-D_DEBUG"
-// CHECK-MT: "-D_MT"
-// CHECK-MT-NOT: "-D_DLL"
+// CHECK-MT-NOT: "-driver-define=_DEBUG"
+// CHECK-MT: "-driver-define=_MT"
+// CHECK-MT-NOT: "-driver-define=_DLL"
 // CHECK-MT: "-flto-visibility-public-std"
 // CHECK-MT: "--dependent-lib=libcmt"
 // CHECK-MT: "--dependent-lib=oldnames"
 
 // RUN: %clang_cl -### /MTd -- %s 2>&1 | FileCheck -check-prefix=CHECK-MTd %s
 // RUN: %clang_cl -### /LD /MTd -- %s 2>&1 | FileCheck -check-prefix=CHECK-MTd %s
-// CHECK-MTd: "-D_DEBUG"
-// CHECK-MTd: "-D_MT"
-// CHECK-MTd-NOT: "-D_DLL"
+// CHECK-MTd: "-driver-define=_DEBUG"
+// CHECK-MTd: "-driver-define=_MT"
+// CHECK-MTd-NOT: "-driver-define=_DLL"
 // CHECK-MTd: "-flto-visibility-public-std"
 // CHECK-MTd: "--dependent-lib=libcmtd"
 // CHECK-MTd: "--dependent-lib=oldnames"
 
 // RUN: %clang_cl -### /MD -- %s 2>&1 | FileCheck -check-prefix=CHECK-MD %s
-// CHECK-MD-NOT: "-D_DEBUG"
-// CHECK-MD: "-D_MT"
-// CHECK-MD: "-D_DLL"
+// CHECK-MD-NOT: "-driver-define=_DEBUG"
+// CHECK-MD: "-driver-define=_MT"
+// CHECK-MD: "-driver-define=_DLL"
 // CHECK-MD: "--dependent-lib=msvcrt"
 // CHECK-MD: "--dependent-lib=oldnames"
 
 // RUN: %clang_cl -### /MDd -- %s 2>&1 | FileCheck -check-prefix=CHECK-MDd %s
-// CHECK-MDd: "-D_DEBUG"
-// CHECK-MDd: "-D_MT"
-// CHECK-MDd: "-D_DLL"
+// CHECK-MDd: "-driver-define=_DEBUG"
+// CHECK-MDd: "-driver-define=_MT"
+// CHECK-MDd: "-driver-define=_DLL"
 // CHECK-MDd: "--dependent-lib=msvcrtd"
 // CHECK-MDd: "--dependent-lib=oldnames"
 
 // RUN: %clang_cl -### /LD -- %s 2>&1 | FileCheck -check-prefix=CHECK-LD %s
 // RUN: %clang_cl -### /LD /MT -- %s 2>&1 | FileCheck -check-prefix=CHECK-LD %s
-// CHECK-LD-NOT: "-D_DEBUG"
-// CHECK-LD: "-D_MT"
-// CHECK-LD-NOT: "-D_DLL"
+// CHECK-LD-NOT: "-driver-define=_DEBUG"
+// CHECK-LD: "-driver-define=_MT"
+// CHECK-LD-NOT: "-driver-define=_DLL"
 // CHECK-LD: "--dependent-lib=libcmt"
 
 // RUN: %clang_cl -### /LDd -- %s 2>&1 | FileCheck -check-prefix=CHECK-LDd %s
 // RUN: %clang_cl -### /LDd /MTd -- %s 2>&1 | FileCheck -check-prefix=CHECK-LDd %s
-// CHECK-LDd: "-D_DEBUG"
-// CHECK-LDd: "-D_MT"
-// CHECK-LDd-NOT: "-D_DLL"
+// CHECK-LDd: "-driver-define=_DEBUG"
+// CHECK-LDd: "-driver-define=_MT"
+// CHECK-LDd-NOT: "-driver-define=_DLL"
 // CHECK-LDd: "--dependent-lib=libcmtd"
 
 // RUN: %clang_cl -### /LDd /MT -- %s 2>&1 | FileCheck -check-prefix=CHECK-LDdMT %s
 // RUN: %clang_cl -### /MT /LDd -- %s 2>&1 | FileCheck -check-prefix=CHECK-LDdMT %s
-// CHECK-LDdMT: "-D_DEBUG"
-// CHECK-LDdMT: "-D_MT"
-// CHECK-LDdMT-NOT: "-D_DLL"
+// CHECK-LDdMT: "-driver-define=_DEBUG"
+// CHECK-LDdMT: "-driver-define=_MT"
+// CHECK-LDdMT-NOT: "-driver-define=_DLL"
 // CHECK-LDdMT: "--dependent-lib=libcmt"
 
 // RUN: %clang_cl -### /LD /MD -- %s 2>&1 | FileCheck -check-prefix=CHECK-LDMD %s
 // RUN: %clang_cl -### /MD /LD -- %s 2>&1 | FileCheck -check-prefix=CHECK-LDMD %s
-// CHECK-LDMD-NOT: "-D_DEBUG"
-// CHECK-LDMD: "-D_MT"
-// CHECK-LDMD: "-D_DLL"
+// CHECK-LDMD-NOT: "-driver-define=_DEBUG"
+// CHECK-LDMD: "-driver-define=_MT"
+// CHECK-LDMD: "-driver-define=_DLL"
 // CHECK-LDMD: "--dependent-lib=msvcrt"
 
 // RUN: %clang_cl -### /LDd /MD -- %s 2>&1 | FileCheck -check-prefix=CHECK-LDdMD %s
 // RUN: %clang_cl -### /MD /LDd -- %s 2>&1 | FileCheck -check-prefix=CHECK-LDdMD %s
-// CHECK-LDdMD: "-D_DEBUG"
-// CHECK-LDdMD: "-D_MT"
-// CHECK-LDdMD: "-D_DLL"
+// CHECK-LDdMD: "-driver-define=_DEBUG"
+// CHECK-LDdMD: "-driver-define=_MT"
+// CHECK-LDdMD: "-driver-define=_DLL"
 // CHECK-LDdMD: "--dependent-lib=msvcrt"
 
 // RUN: %clang_cl -### /LD /MDd -- %s 2>&1 | FileCheck -check-prefix=CHECK-LDMDd %s
 // RUN: %clang_cl -### /MDd /LD -- %s 2>&1 | FileCheck -check-prefix=CHECK-LDMDd %s
 // RUN: %clang_cl -### /LDd /MDd -- %s 2>&1 | FileCheck -check-prefix=CHECK-LDMDd %s
 // RUN: %clang_cl -### /MDd /LDd -- %s 2>&1 | FileCheck -check-prefix=CHECK-LDMDd %s
-// CHECK-LDMDd: "-D_DEBUG"
-// CHECK-LDMDd: "-D_MT"
-// CHECK-LDMDd: "-D_DLL"
+// CHECK-LDMDd: "-driver-define=_DEBUG"
+// CHECK-LDMDd: "-driver-define=_MT"
+// CHECK-LDMDd: "-driver-define=_DLL"
 // CHECK-LDMDd: "--dependent-lib=msvcrtd"
 
 // RUN: %clang_cl /MD /MT -### -- %s 2>&1 | FileCheck -check-prefix=MTOVERRIDE %s
 // MTOVERRIDE: "--dependent-lib=libcmt"
 
 // RUN: %clang_cl -### /Zl -- %s 2>&1 | FileCheck -check-prefix=CHECK-MTZl %s
 // RUN: %clang_cl -### /MT /Zl -- %s 2>&1 | FileCheck -check-prefix=CHECK-MTZl %s
-// CHECK-MTZl-NOT: "-D_DEBUG"
-// CHECK-MTZl: "-D_MT"
-// CHECK-MTZl-NOT: "-D_DLL"
-// CHECK-MTZl-SAME: "-D_VC_NODEFAULTLIB"
+// CHECK-MTZl-NOT: "-driver-define=_DEBUG"
+// CHECK-MTZl: "-driver-define=_MT"
+// CHECK-MTZl-NOT: "-driver-define=_DLL"
+// CHECK-MTZl-SAME: "-driver-define=_VC_NODEFAULTLIB"
 // CHECK-MTZl-NOT: "--dependent-lib=libcmt"
 // CHECK-MTZl-NOT: "--dependent-lib=oldnames"

clang/test/Driver/mingw.cpp

 // CHECK_MINGW_UBUNTU_POSIX_TREE: "[[BASE:[^"]+]]/Inputs/mingw_ubuntu_posix_tree/usr{{/|\\\\}}lib{{/|\\\\}}gcc{{/|\\\\}}x86_64-w64-mingw32{{/|\\\\}}10.2-posix{{/|\\\\}}include{{/|\\\\}}c++"
 // CHECK_MINGW_UBUNTU_POSIX_TREE: "[[BASE]]/Inputs/mingw_ubuntu_posix_tree/usr{{/|\\\\}}lib{{/|\\\\}}gcc{{/|\\\\}}x86_64-w64-mingw32{{/|\\\\}}10.2-posix{{/|\\\\}}include{{/|\\\\}}c++{{/|\\\\}}x86_64-w64-mingw32"
 // CHECK_MINGW_UBUNTU_POSIX_TREE: "[[BASE]]/Inputs/mingw_ubuntu_posix_tree/usr{{/|\\\\}}lib{{/|\\\\}}gcc{{/|\\\\}}x86_64-w64-mingw32{{/|\\\\}}10.2-posix{{/|\\\\}}include{{/|\\\\}}c++{{/|\\\\}}backward"
 // CHECK_MINGW_UBUNTU_POSIX_TREE: "[[BASE]]/Inputs/mingw_ubuntu_posix_tree/usr{{/|\\\\}}x86_64-w64-mingw32{{/|\\\\}}include"
 
 // RUN: %clang -target i686-windows-gnu -E -### %s 2>&1 | FileCheck -check-prefix=CHECK_MINGW_NO_UNICODE %s
 // RUN: %clang -target i686-windows-gnu -E -### %s -municode 2>&1 | FileCheck -check-prefix=CHECK_MINGW_UNICODE %s
 // CHECK_MINGW_NO_UNICODE-NOT: "-DUNICODE"
-// CHECK_MINGW_UNICODE: "-DUNICODE"
+// CHECK_MINGW_UNICODE: "-driver-define=UNICODE"
 
 // RUN: %clang -target i686-windows-gnu -### %s 2>&1 | FileCheck -check-prefix=CHECK_NO_SUBSYS %s
 // RUN: %clang -target i686-windows-gnu -### %s -mwindows -mconsole 2>&1 | FileCheck -check-prefix=CHECK_SUBSYS_CONSOLE %s
 // RUN: %clang -target i686-windows-gnu -### %s -mconsole -mwindows 2>&1 | FileCheck -check-prefix=CHECK_SUBSYS_WINDOWS %s
 // CHECK_NO_SUBSYS-NOT: "--subsystem"
 // CHECK_SUBSYS_CONSOLE: "--subsystem" "console"
 // CHECK_SUBSYS_WINDOWS: "--subsystem" "windows"

clang/test/Preprocessor/macro-command-line-diagnosis.c

+// RUN: %clang_cc1 -Wreserved-identifier -D__WHY_NOT_ME__ -U__STDC__ %s -o - 2>&1 | FileCheck %s
+
+// CHECK:      warning: macro name is a reserved identifier [-Wreserved-macro-identifier]
+// CHECK-NEXT: #define __WHY_NOT_ME__ 1
+// CHECK:      warning: macro name is a reserved identifier [-Wreserved-macro-identifier]
+// CHECK-NEXT: #undef __STDC__