[lldb] Disable macro redefinition warnings in expression wrapper

[teemperor]

Summary

GCC emits macro definitions into debug info when compiling with -g3.
LLDB is translating this information into #define directives which are injected into the
source code of user expressions. While this mechanism itself works fine, it can lead to
spurious "... macro redefined" warnings when the defined macro is also a builtin Clang macro:

warning: <lldb wrapper prefix>:46:9: '__VERSION__' macro redefined
#define __VERSION__ "12.1.0"
        ^
<built-in>:19:9: previous definition is here
#define __VERSION__ "Clang 14.0.6"
[repeated about a 100 more times for every builtin macro]

This patch just disables the diagnostic when parsing LLDB's generated list of
macros definitions.

[Michael137]

LGTM thanks!

[Michael137]

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.cpp

150

You might want to also add -Wbuiltin-macro-redefined

Just tried this change on my Ubuntu VM with gcc-11 and it gets rid of most diagnostics apart from one:

(lldb) p alksjdh                                                                                          
error: expression failed to parse:                                                                        
warning: <lldb wrapper prefix>:252:9: redefining builtin macro                         
#define __FLT_EVAL_METHOD__ 0                                                                             
        ^                                                                                                 
error: <user expression 0>:1:1: use of undeclared identifier 'alksjdh'                                    
alksjdh                                                                                                   
^

[teemperor]

• Address builtin redefining (Thanks Michael!)

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.cpp

 //===-- ClangExpressionSourceCode.cpp -------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangExpressionSourceCode.h"
 
 #include "ClangExpressionUtil.h"
 
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Lexer.h"
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/StringRef.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/TypeSystem.h"

 
 } // anonymous namespace
 
 static void AddMacros(const DebugMacros *dm, CompileUnit *comp_unit,
                       AddMacroState &state, StreamString &stream) {
   if (dm == nullptr)
     return;
 
+  // The macros directives below can potentially redefine builtin macros of the
+  // Clang instance which parses the user expression. The Clang diagnostics
+  // caused by this are not useful for the user as the source code here is
+  // generated by LLDB.
+  stream << "#pragma clang diagnostic push\n";
+  stream << "#pragma clang diagnostic ignored \"-Wmacro-redefined\"\n";
+  stream << "#pragma clang diagnostic ignored \"-Wbuiltin-macro-redefined\"\n";
+  auto pop_warning = llvm::make_scope_exit([&stream](){
+    stream << "#pragma clang diagnostic pop\n";
+  });
+
   for (size_t i = 0; i < dm->GetNumMacroEntries(); i++) {
     const DebugMacroEntry &entry = dm->GetMacroEntryAtIndex(i);
     uint32_t line;
 
     switch (entry.GetType()) {
     case DebugMacroEntry::DEFINE:
       if (state.IsValidEntry(entry.GetLineNumber()))
         stream.Printf("#define %s\n", entry.GetMacroString().AsCString());

lldb/test/API/commands/expression/macros/TestMacros.py

def test_expr_with_macros(self):
         # This time, MACRO_1 and MACRO_2 are not visible.
         result = frame.EvaluateExpression("MACRO_1")
         self.assertTrue(result.GetError().Fail(),
                         "Printing MACRO_1 fails in the header file")
 
         result = frame.EvaluateExpression("MACRO_2")
         self.assertTrue(result.GetError().Fail(),
                         "Printing MACRO_2 fails in the header file")
+
+        # Check that the macro definitions do not trigger bogus Clang
+        # diagnostics about macro redefinitions.
+        result = frame.EvaluateExpression("does_not_parse")
+        self.assertNotIn("macro redefined", str(result.GetError()))
+        self.assertNotIn("redefining builtin macro", str(result.GetError()))