[lldb] Make frame recognizers vend synthesized eValueTypeVariableArgument values

[kubamracek]

Ping.

[jingham]

LGTM

[kubamracek]

Landed in r353363.

include/lldb/Target/StackFrameRecognizer.h

 //===-- StackFrameRecognizer.h ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_StackFrameRecognizer_h_
 #define liblldb_StackFrameRecognizer_h_
 
+#include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-public.h"
 
 namespace lldb_private {
 
public:
   static void RemoveAllRecognizers();
 
   static lldb::StackFrameRecognizerSP GetRecognizerForFrame(
       lldb::StackFrameSP frame);
 
   static lldb::RecognizedStackFrameSP RecognizeFrame(lldb::StackFrameSP frame);
 };
 
+/// @class ValueObjectRecognizerSynthesizedValue
+///
+/// ValueObject subclass that presents the passed ValueObject as a recognized
+/// value with the specified ValueType. Frame recognizers should return
+/// instances of this class as the returned objects in GetRecognizedArguments().
+
+class ValueObjectRecognizerSynthesizedValue : public ValueObject {
+ public:
+  static lldb::ValueObjectSP Create(ValueObject &parent, lldb::ValueType type) {
+    return (new ValueObjectRecognizerSynthesizedValue(parent, type))->GetSP();
+  }
+  ValueObjectRecognizerSynthesizedValue(ValueObject &parent,
+                                        lldb::ValueType type)
+      : ValueObject(parent), m_type(type) {
+    SetName(parent.GetName());
+  }
+
+  uint64_t GetByteSize() override { return m_parent->GetByteSize(); }
+  lldb::ValueType GetValueType() const override { return m_type; }
+  bool UpdateValue() override {
+    if (!m_parent->UpdateValueIfNeeded()) return false;
+    m_value = m_parent->GetValue();
+    return true;
+  }
+  size_t CalculateNumChildren(uint32_t max = UINT32_MAX) override {
+    return m_parent->GetNumChildren(max);
+  }
+  CompilerType GetCompilerTypeImpl() override {
+    return m_parent->GetCompilerType();
+  }
+  bool IsSynthetic() override { return true; }
+
+ private:
+  lldb::ValueType m_type;
+};
+
 } // namespace lldb_private
 
 #endif // liblldb_StackFrameRecognizer_h_

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

def test_frame_recognizer_1(self):
         # ... 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(0).GetValueType(), lldb.eValueTypeVariableArgument)
         self.assertEqual(variables.GetValueAtIndex(1).name, "b")
         self.assertEqual(variables.GetValueAtIndex(1).signed, 56)
+        self.assertEqual(variables.GetValueAtIndex(1).GetValueType(), lldb.eValueTypeVariableArgument)
 
         self.expect("frame recognizer info 0",
                     substrs=['frame 0 is recognized by recognizer.MyFrameRecognizer'])
 
         self.expect("frame recognizer info 999", error=True,
                     substrs=['no frame with index 999'])
 
         self.expect("frame recognizer info 1",

packages/Python/lldbsuite/test/lang/objc/exceptions/TestObjCExceptions.py

def test_objc_exceptions_at_throw(self):
         frame = thread.GetSelectedFrame()
         
         opts = lldb.SBVariablesOptions()
         opts.SetIncludeRecognizedArguments(True)
         variables = frame.GetVariables(opts)
 
         self.assertEqual(variables.GetSize(), 1)
         self.assertEqual(variables.GetValueAtIndex(0).name, "exception")
+        self.assertEqual(variables.GetValueAtIndex(0).GetValueType(), lldb.eValueTypeVariableArgument)
 
         lldbutil.run_to_source_breakpoint(self, "// Set break point at this line.", lldb.SBFileSpec("main.mm"), launch_info=launch_info)
 
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped', 'stop reason = breakpoint'])
 
         target = self.dbg.GetSelectedTarget()
         thread = target.GetProcess().GetSelectedThread()

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

ObjCExceptionRecognizedStackFrame(StackFrameSP frame_sp) {
     if (!abi->GetArgumentValues(*thread_sp, args)) return;
 
     addr_t exception_addr = args.GetValueAtIndex(0)->GetScalar().ULongLong();
 
     Value value(exception_addr);
     value.SetCompilerType(voidstar);
     exception = ValueObjectConstResult::Create(frame_sp.get(), value,
                                                ConstString("exception"));
+    exception = ValueObjectRecognizerSynthesizedValue::Create(
+        *exception, eValueTypeVariableArgument);
     exception = exception->GetDynamicValue(eDynamicDontRunTarget);
 
     m_arguments = ValueObjectListSP(new ValueObjectList());
     m_arguments->Append(exception);
   }
 
   ValueObjectSP exception;
 

source/Target/StackFrameRecognizer.cpp

 
 RecognizedStackFrameSP
 ScriptedStackFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame) {
   if (!m_python_object_sp || !m_interpreter)
     return RecognizedStackFrameSP();
 
   ValueObjectListSP args =
       m_interpreter->GetRecognizedArguments(m_python_object_sp, frame);
+  auto args_synthesized = ValueObjectListSP(new ValueObjectList());
+  for (const auto o : args->GetObjects()) {
+    args_synthesized->Append(ValueObjectRecognizerSynthesizedValue::Create(
+        *o, eValueTypeVariableArgument));
+  }
 
-  return RecognizedStackFrameSP(new ScriptedRecognizedStackFrame(args));
+  return RecognizedStackFrameSP(
+      new ScriptedRecognizedStackFrame(args_synthesized));
 }
 
 #endif
 
 class StackFrameRecognizerManagerImpl {
 public:
   void AddRecognizer(StackFrameRecognizerSP recognizer,
                      const ConstString &module, const ConstString &symbol,