[lldb] Add a "display-recognized-arguments" target setting to show recognized arguments by default

[jingham]

That's great. Can you add a test that if you make a default SBVariableOption and then flip the target setting you get the target's default value?

[kubamracek]

Adding test.

[jingham]

Excellent!

include/lldb/API/SBTarget.h

protected:
   friend class SBFunction;
   friend class SBInstruction;
   friend class SBModule;
   friend class SBProcess;
   friend class SBSection;
   friend class SBSourceManager;
   friend class SBSymbol;
   friend class SBValue;
+  friend class SBVariablesOptions;
 
   //------------------------------------------------------------------
   // Constructors are private, use static Target::Create function to create an
   // instance of this class.
   //------------------------------------------------------------------
 
   lldb::TargetSP GetSP() const;
 

include/lldb/API/SBVariablesOptions.h

public:
   ~SBVariablesOptions();
 
   bool IsValid() const;
 
   bool GetIncludeArguments() const;
 
   void SetIncludeArguments(bool);
 
-  bool GetIncludeRecognizedArguments() const;
+  bool GetIncludeRecognizedArguments(const lldb::SBTarget &) const;
 
   void SetIncludeRecognizedArguments(bool);
 
   bool GetIncludeLocals() const;
 
   void SetIncludeLocals(bool);
 
   bool GetIncludeStatics() const;

include/lldb/Target/Target.h

public:
   bool GetNonStopModeEnabled() const;
 
   void SetNonStopModeEnabled(bool b);
 
   bool GetDisplayRuntimeSupportValues() const;
 
   void SetDisplayRuntimeSupportValues(bool b);
 
+  bool GetDisplayRecognizedArguments() const;
+
+  void SetDisplayRecognizedArguments(bool b);
+
   const ProcessLaunchInfo &GetProcessLaunchInfo();
 
   void SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info);
 
   bool GetInjectLocalVariables(ExecutionContext *exe_ctx) const;
 
   void SetInjectLocalVariables(ExecutionContext *exe_ctx, bool b);
 

packages/Python/lldbsuite/test/functionalities/frame-recognizer/TestFrameRecognizer.py

def test_frame_recognizer_1(self):
         frame = thread.GetSelectedFrame()
 
         self.assertEqual(frame.GetSymbol().GetName(), "foo")
         self.assertFalse(frame.GetLineEntry().IsValid())
 
         self.expect("frame variable",
                     substrs=['(int) a = 42', '(int) b = 56'])
 
-        opts = lldb.SBVariablesOptions();
-        opts.SetIncludeRecognizedArguments(True);
-        variables = frame.GetVariables(opts);
+        # Recognized arguments don't show up by default...
+        variables = frame.GetVariables(lldb.SBVariablesOptions())
+        self.assertEqual(variables.GetSize(), 0)
+
+        # ...unless you set target.display-recognized-arguments to 1...
+        self.runCmd("settings set target.display-recognized-arguments 1")
+        variables = frame.GetVariables(lldb.SBVariablesOptions())
+        self.assertEqual(variables.GetSize(), 2)
+
+        # ...and you can reset it back to 0 to hide them again...
+        self.runCmd("settings set target.display-recognized-arguments 0")
+        variables = frame.GetVariables(lldb.SBVariablesOptions())
+        self.assertEqual(variables.GetSize(), 0)
+
+        # ... or explicitly ask for them with SetIncludeRecognizedArguments(True).
+        opts = lldb.SBVariablesOptions()
+        opts.SetIncludeRecognizedArguments(True)
+        variables = frame.GetVariables(opts)
 
         self.assertEqual(variables.GetSize(), 2)
         self.assertEqual(variables.GetValueAtIndex(0).name, "a")
         self.assertEqual(variables.GetValueAtIndex(0).signed, 42)
         self.assertEqual(variables.GetValueAtIndex(1).name, "b")
         self.assertEqual(variables.GetValueAtIndex(1).signed, 56)
 
         self.expect("frame recognizer info 0",

scripts/interface/SBVariablesOptions.i

public:
     
     bool
     GetIncludeArguments ()  const;
     
     void
     SetIncludeArguments (bool);
 
     bool
-    GetIncludeRecognizedArguments ()  const;
+    GetIncludeRecognizedArguments (const lldb::SBTarget &)  const;
 
     void
     SetIncludeRecognizedArguments (bool);
 
     bool
     GetIncludeLocals ()  const;
     
     void

source/API/SBFrame.cpp

SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
 
   const bool statics = options.GetIncludeStatics();
   const bool arguments = options.GetIncludeArguments();
-  const bool recognized_arguments = options.GetIncludeRecognizedArguments();
+  const bool recognized_arguments =
+        options.GetIncludeRecognizedArguments(SBTarget(exe_ctx.GetTargetSP()));
   const bool locals = options.GetIncludeLocals();
   const bool in_scope_only = options.GetInScopeOnly();
   const bool include_runtime_support_values =
       options.GetIncludeRuntimeSupportValues();
   const lldb::DynamicValueType use_dynamic = options.GetUseDynamic();
 
   if (log)
     log->Printf(

source/API/SBVariablesOptions.cpp

 //===-- SBVariablesOptions.cpp --------------------------------------*- C++
 //-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBVariablesOptions.h"
+#include "lldb/API/SBTarget.h"
+#include "lldb/Target/Target.h"
+
+#include "lldb/lldb-private.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 class VariablesOptionsImpl {
 public:
   VariablesOptionsImpl()
-      : m_include_arguments(false), m_include_recognized_arguments(false),
-        m_include_locals(false), m_include_statics(false),
-        m_in_scope_only(false), m_include_runtime_support_values(false),
+      : m_include_arguments(false), m_include_locals(false),
+        m_include_statics(false), m_in_scope_only(false),
+        m_include_runtime_support_values(false),
+        m_include_recognized_arguments(eLazyBoolCalculate),
         m_use_dynamic(lldb::eNoDynamicValues) {}
 
   VariablesOptionsImpl(const VariablesOptionsImpl &) = default;
 
   ~VariablesOptionsImpl() = default;
 
   VariablesOptionsImpl &operator=(const VariablesOptionsImpl &) = default;
 
   bool GetIncludeArguments() const { return m_include_arguments; }
 
   void SetIncludeArguments(bool b) { m_include_arguments = b; }
 
-  bool GetIncludeRecognizedArguments() const {
+  bool GetIncludeRecognizedArguments(const lldb::TargetSP &target_sp) const {
+    if (m_include_recognized_arguments != eLazyBoolCalculate)
         return m_include_recognized_arguments;
+    return target_sp ? target_sp->GetDisplayRecognizedArguments() : false;
   }
 
   void SetIncludeRecognizedArguments(bool b) {
-    m_include_recognized_arguments = b;
+    m_include_recognized_arguments = b ? eLazyBoolYes : eLazyBoolNo;
   }
 
   bool GetIncludeLocals() const { return m_include_locals; }
 
   void SetIncludeLocals(bool b) { m_include_locals = b; }
 
   bool GetIncludeStatics() const { return m_include_statics; }
 
public:
   }
 
   lldb::DynamicValueType GetUseDynamic() const { return m_use_dynamic; }
 
   void SetUseDynamic(lldb::DynamicValueType d) { m_use_dynamic = d; }
 
 private:
   bool m_include_arguments : 1;
-  bool m_include_recognized_arguments : 1;
   bool m_include_locals : 1;
   bool m_include_statics : 1;
   bool m_in_scope_only : 1;
   bool m_include_runtime_support_values : 1;
+  LazyBool m_include_recognized_arguments; // can be overridden with a setting
   lldb::DynamicValueType m_use_dynamic;
 };
 
 SBVariablesOptions::SBVariablesOptions()
     : m_opaque_ap(new VariablesOptionsImpl()) {}
 
 SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options)
     : m_opaque_ap(new VariablesOptionsImpl(options.ref())) {}

 bool SBVariablesOptions::GetIncludeArguments() const {
   return m_opaque_ap->GetIncludeArguments();
 }
 
 void SBVariablesOptions::SetIncludeArguments(bool arguments) {
   m_opaque_ap->SetIncludeArguments(arguments);
 }
 
-bool SBVariablesOptions::GetIncludeRecognizedArguments() const {
-  return m_opaque_ap->GetIncludeRecognizedArguments();
+bool SBVariablesOptions::GetIncludeRecognizedArguments(
+    const lldb::SBTarget &target) const {
+  return m_opaque_ap->GetIncludeRecognizedArguments(target.GetSP());
 }
 
 void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) {
   m_opaque_ap->SetIncludeRecognizedArguments(arguments);
 }
 
 bool SBVariablesOptions::GetIncludeLocals() const {
   return m_opaque_ap->GetIncludeLocals();

source/Target/Target.cpp

nullptr, {}, "Expressions that crash will show up in crash logs if "
                   "strings and this setting is set to true."},
     {"trap-handler-names", OptionValue::eTypeArray, true,
      OptionValue::eTypeString, nullptr, {},
      "A list of trap handler function names, e.g. a common Unix user process "
      "one is _sigtramp."},
     {"display-runtime-support-values", OptionValue::eTypeBoolean, false, false,
      nullptr, {}, "If true, LLDB will show variables that are meant to "
                   "support the operation of a language's runtime support."},
+    {"display-recognized-arguments", OptionValue::eTypeBoolean, false, false,
+     nullptr, {}, "Show recognized arguments in variable listings by default."},
     {"non-stop-mode", OptionValue::eTypeBoolean, false, 0, nullptr, {},
      "Disable lock-step debugging, instead control threads independently."},
     {"require-hardware-breakpoint", OptionValue::eTypeBoolean, false, 0,
      nullptr, {}, "Require all breakpoints to be hardware breakpoints."}};
 // clang-format on
 
 enum {
   ePropertyDefaultArch,
enum {
   ePropertyHexImmediateStyle,
   ePropertyUseFastStepping,
   ePropertyLoadScriptFromSymbolFile,
   ePropertyLoadCWDlldbinitFile,
   ePropertyMemoryModuleLoadLevel,
   ePropertyDisplayExpressionsInCrashlogs,
   ePropertyTrapHandlerNames,
   ePropertyDisplayRuntimeSupportValues,
+  ePropertyDisplayRecognizedArguments,
   ePropertyNonStopModeEnabled,
   ePropertyRequireHardwareBreakpoints,
   ePropertyExperimental,
 };
 
 class TargetOptionValueProperties : public OptionValueProperties {
 public:
   TargetOptionValueProperties(const ConstString &name)
bool TargetProperties::GetDisplayRuntimeSupportValues() const {
   return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
 }
 
 void TargetProperties::SetDisplayRuntimeSupportValues(bool b) {
   const uint32_t idx = ePropertyDisplayRuntimeSupportValues;
   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 }
 
+bool TargetProperties::GetDisplayRecognizedArguments() const {
+  const uint32_t idx = ePropertyDisplayRecognizedArguments;
+  return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
+}
+
+void TargetProperties::SetDisplayRecognizedArguments(bool b) {
+  const uint32_t idx = ePropertyDisplayRecognizedArguments;
+  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
+}
+
 bool TargetProperties::GetNonStopModeEnabled() const {
   const uint32_t idx = ePropertyNonStopModeEnabled;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
 }
 
 void TargetProperties::SetNonStopModeEnabled(bool b) {
   const uint32_t idx = ePropertyNonStopModeEnabled;
   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);