[lldb] Ignore libcxx std::ranges global variables in frame var

[Michael137]

Summary

The motivation is to avoid cluttering LLDB's global variable view for
std::ranges users.

Before:

(lldb) frame var -g
...
(const std::ranges::__end::__fn) std::__1::ranges::__cpo::end = {}
(const std::ranges::views::__all::__fn) std::__1::ranges::views::__cpo::all = {}
(const std::ranges::__begin::__fn) std::__1::ranges::__cpo::begin = {}
(const std::ranges::views::__take::__fn) std::__1::ranges::views::__cpo::take = {}
(const std::ranges::__max_element::__fn) std::__1::ranges::__cpo::max_element = {}
(const std::ranges::__size::__fn) std::__1::ranges::__cpo::size = {}
(const std::ranges::__data::__fn) std::__1::ranges::__cpo::data = {}

After this patch none of these __cpo variables would show up.

[Michael137]

Alternative to https://reviews.llvm.org/D142993

The other option would be introducing a new clang attribute that indicates "we don't want the debugger to display this but still keep the debug-info". This is what artificial does for inline-functions. So we could extend the attribute to handle variable declarations.

[Michael137]

Alternative to https://reviews.llvm.org/D142993

The other option would be introducing a new clang attribute that indicates "we don't want the debugger to display this but still keep the debug-info". This is what artificial does for inline-functions. So we could extend the attribute to handle variable declarations.

[Michael137]

• Remove leftover debug code

[aprantl]

I think this is fine. It's concise, adds useful plugin functionality and we're already hardcoding all sorts of special knowledge about libc++.

lldb/include/lldb/Target/LanguageRuntime.h

154

Can you add a doxygen comment about the effects here?

[Michael137]

• Fix typo
• Add doxygen comment

[Michael137]

Whoops, last second variable name change broke the build bot. Fixed in 4d909c556e2caa8e150b892384fe8d42e774f8b0

lldb/include/lldb/Target/LanguageRuntime.h

public:
 
   virtual lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
                                                           bool stop_others) = 0;
 
   /// Identify whether a name is a runtime value that should not be hidden by
   /// from the user interface.
   virtual bool IsAllowedRuntimeValue(ConstString name) { return false; }
 
+  /// Returns 'true' if we the variable with the specified 'name'
+  /// should be hidden from variable views (e.g., when listing variables in
+  /// 'frame variable' or 'target variable')
+  virtual bool ShouldHideVariable(llvm::StringRef name) const { return false; }
+
   virtual std::optional<CompilerType> GetRuntimeType(CompilerType base_type) {
     return std::nullopt;
   }
 
   void ModulesDidLoad(const ModuleList &module_list) override {}
 
   // Called by ClangExpressionParser::PrepareForExecution to query for any
   // custom LLVM IR passes that need to be run before an expression is

lldb/source/Core/ValueObject.cpp

else
     return GetCompilerType().IsPossibleDynamicType(nullptr, true, true);
 }
 
 bool ValueObject::IsRuntimeSupportValue() {
   Process *process(GetProcessSP().get());
   if (!process)
     return false;
 
+  if (!GetVariable())
+    return false;
+
+  auto *runtime = process->GetLanguageRuntime(GetVariable()->GetLanguage());
+  if (runtime)
+    if (runtime->ShouldHideVariable(GetName().GetStringRef()))
+      return true;
+
   // We trust that the compiler did the right thing and marked runtime support
   // values as artificial.
-  if (!GetVariable() || !GetVariable()->IsArtificial())
+  if (!GetVariable()->IsArtificial())
     return false;
 
-  if (auto *runtime = process->GetLanguageRuntime(GetVariable()->GetLanguage()))
+  if (runtime)
     if (runtime->IsAllowedRuntimeValue(GetName()))
       return false;
 
   return true;
 }
 
 bool ValueObject::IsNilReference() {
   if (Language *language = Language::FindPlugin(GetObjectRuntimeLanguage())) {

lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h

public:
   /// \param[in] stop_others
   ///     True if other threads should pause during execution.
   ///
   /// \return
   ///      A ThreadPlan Shared pointer
   lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
                                                   bool stop_others) override;
 
+  bool ShouldHideVariable(llvm::StringRef name) const override;
+
   bool IsAllowedRuntimeValue(ConstString name) override;
 protected:
   // Classes that inherit from CPPLanguageRuntime can see and modify these
   CPPLanguageRuntime(Process *process);
 
 private:
   using OperatorStringToCallableInfoMap =
     llvm::StringMap<CPPLanguageRuntime::LibCppStdFunctionCallableInfo>;
 
   OperatorStringToCallableInfoMap CallableLookupCache;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_CPLUSPLUS_CPPLANGUAGERUNTIME_H

lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp

 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Target/ThreadPlanStepInRange.h"
+#include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Timer.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static ConstString g_this = ConstString("this");
 
 char CPPLanguageRuntime::ID = 0;
 
 CPPLanguageRuntime::CPPLanguageRuntime(Process *process)
     : LanguageRuntime(process) {}
 
+bool CPPLanguageRuntime::ShouldHideVariable(llvm::StringRef name) const {
+  // Matches the global function objects in std::ranges/std::ranges::views
+  // E.g.,
+  //   std::__1::ranges::views::__cpo::take
+  //   std::__1::ranges::__cpo::max_element
+  static RegularExpression ignore_global_ranges_pattern(
+      "std::__[[:alnum:]]+::ranges(::views)*::__cpo");
+
+  return ignore_globale_ranges_pattern.Execute(name);
+}
+
 bool CPPLanguageRuntime::IsAllowedRuntimeValue(ConstString name) {
   return name == g_this;
 }
 
 bool CPPLanguageRuntime::GetObjectDescription(Stream &str,
                                               ValueObject &object) {
   // C++ has no generic way to do this.
   return false;

lldb/test/API/lang/cpp/hide_global_ranges_vars/Makefile

+CXX_SOURCES := main.cpp
+CXXFLAGS_EXTRAS := -std=c++20
+
+include Makefile.rules

lldb/test/API/lang/cpp/hide_global_ranges_vars/TestHideGlobalRangesVars.py

+"""Test that frame var and target var hide
+the global function objects in the libc++
+ranges implementation"""
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class HideGlobalRangesVarsTestCase(TestBase):
+
+    @add_test_categories(["libc++"])
+    @skipIf(compiler=no_match("clang"))
+    @skipIf(compiler="clang", compiler_version=['<', '16.0'])
+    def test(self):
+        self.build()
+
+        lldbutil.run_to_source_breakpoint(self, "return", lldb.SBFileSpec('main.cpp', False))
+
+        self.expect("frame variable --show-globals",
+                    substrs=["::ranges::views::__cpo",
+                             "::ranges::__cpo"],
+                    matching=False)
+
+        self.expect("target variable",
+                    substrs=["::ranges::views::__cpo",
+                             "::ranges::__cpo"],
+                    matching=False)

lldb/test/API/lang/cpp/hide_global_ranges_vars/main.cpp

+#include <ranges>
+
+int main(int argc, char const *argv[]) {
+  int arr[3] = {1, 2, 3};
+  auto arr_view = std::ranges::views::all(arr);
+  auto arr_max = std::ranges::max_element(arr);
+
+  return 0;
+}