[lldb] Add GetCurrentException APIs to SBThread, add frame recognizer for objc_exception_throw for Obj-C runtimes

[kubamracek]

Summary

This adds new APIs and a command to deal with exceptions (mostly Obj-C exceptions):

SBThread and Thread get GetCurrentException API, which returns an SBValue/ValueObjectSP with the current exception for a thread. "Current" means an exception that is currently being thrown, caught or otherwise processed. In this patch, we only know about the exception when in objc_exception_throw, but subsequent patches will expand this (and add GetCurrentExceptionBacktrace, which will return an SBThread/ThreadSP containing a historical thread backtrace retrieved from the exception object. Currently unimplemented, subsequent patches will implement this).

Extracting the exception from objc_exception_throw is implemented by adding a frame recognizer.

This also add a new sub-command "thread exception", which prints the current exception.

[jingham]

I have a couple of structural questions.

First, it would be good to stop a bit and think about how to make the StackFrameRecognizer's return data more flexible. At some point, for instance, it would be great to be able to add a StackFrameRecognizerPython and then let people add their own plugins to handle special data from functions they know about in their code. Basically DataFormatters for functions on the stack. But if the way you get data out of a Recognizer is to call specific functions on the recognizer, then you're going to have to enumerate up front all the kinds of data a recognizer can provide, which will make this harder.

It seems however like providing some interesting ValueObjects is a pretty common thing to do, so maybe it would be better to have an API like:

ValueObjectSP GetValueObjectOfKind(const char *kind);

in which case you probably also want:

GetSupportedKinds()

that returns some kind of string list so you could anonymously print all the interesting information.

I actually like having a command to get the current exception (and it's backtrace) for a thread. We do an analogous thing when listing the queue that launched the current thread (and the backtrace when dispatched) with:

thread backtrace -e true

So now we have two very different ways to do analogous things. Maybe it would be better to change --extended to take an enum, and then do:

thread backtrace --extended queues

or

thread backtrace --extended exception

[kubamracek]

Thanks for the high-level feedback! I'll split the patch and we can discuss further.

[kubamracek]

Hi, I've moved the part that introduces the frame recognizers to https://reviews.llvm.org/D44603.

[jingham]

Are you planning to rewrite this the command part of this patch using the changes from https://reviews.llvm.org/D44603 once that's approved?

I like the fact that the part of this that prints exception objects gets access to them through the thread, not the frame. Even though the implementation in D44603 only knows how to get the exception object at the point of throw, at some point it would be nice to support the scenario where you stop sayin a breakpoint on a destructor that's getting run as the stack is unwound due to an exception, and we can tell you what exception is currently propagating. For that purpose, asking the thread seems right.

[kubamracek]

Are you planning to rewrite this the command part of this patch using the changes from https://reviews.llvm.org/D44603 once that's approved?

Yes.

[kubamracek]

Updating patch for the recently-landed StackFrameRecognizers.

[kubamracek]

Hi, I've updated this patch after a while. Since then, StackFrameRecognizers have already landed, so this patch now just adds one subclass of a StackFrameRecognizer.

It seems however like providing some interesting ValueObjects is a pretty common thing to do, so maybe it would be better to have an API like:
ValueObjectSP GetValueObjectOfKind(const char *kind);

For now, I've kept the new method, GetExceptionObject(). If you'd still like me to change it into a string-based API, let me know, I'll be happy to change it. I agree that it doesn't make sense to keep adding methods to the base RecognizedStackFrame class.

Maybe it would be better to change --extended to take an enum, and then do:
thread backtrace --extended exception

I can add that. On top of the backtrace, the exception has a class name and message (at least in Obj-C), which is also important to present via some command. Do you want to keep thread exception as well? Or make thread backtrace -e exception be the only way to access the class+message of an exception?

[kubamracek]

Simplifying this a bit further, adding a test, and commenting out the backtrace API, which I'll add in a subsequent commit.

[jingham]

The exception breakpoints know that libobjc.B.dylib`objc_exception_throw is where you stop for exception breakpoints, and now the ObjCExceptionRecognizer knows the same thing. It always makes me nervous when two different places have the same hard-coded string. Can we add an API to ObjCLanguageRuntime to get the FileSpec for the module and a function name for the exception function, and then have both CreateExceptionResolver and RegisterObjCExceptionRecognizer use that? Actually it would be better to just add this to the LanguageRuntime, because then we could use it for the C++ CreateExceptionResolver and later (when one of us gets to it) for RegisterCPlusPlusExceptionRecognizer as well. But since C++ can throw in a couple of places, it will need to return a vector of name+library pairs.

Other than this niggle, this looks great.

[kubamracek]

Updated patch. I've added a static AppleObjCRuntime::GetExceptionThrowLocation(), which returns the location of the exception throw breakpoint for the Obj-C runtime. I tried adding it as virtual method on LanguageRuntime instead, but then it wasn't clear to me how to make it easily return either an optional (there's runtimes that don't have exceptions) or an array (as you said, C++ will need multiple locations) and how to make existing code CreateExceptionResolver work with that. Let me know if that's okay.

[jingham]

This isn't an external API, so we can generalize it when we get around to extending the Recognizers to C++ exceptions. This is fine for now.

Thanks for doing this!

[kubamracek]

Landed, thanks for the review!

include/lldb/API/SBThread.h

public:
   bool GetDescription(lldb::SBStream &description, bool stop_format) const;
 
   bool GetStatus(lldb::SBStream &status) const;
 
   SBThread GetExtendedBacktraceThread(const char *type);
 
   uint32_t GetExtendedBacktraceOriginatingIndexID();
 
+  SBThread GetCurrentExceptionBacktrace();
+
+  SBValue GetCurrentException();
+
   bool SafeToCallFunctions();
 
 #ifndef SWIG
   lldb_private::Thread *operator->();
 
   lldb_private::Thread *get();
 
 #endif

include/lldb/Target/StackFrameRecognizer.h

 /// holds recognized arguments (via GetRecognizedArguments).
 
 class RecognizedStackFrame
     : public std::enable_shared_from_this<RecognizedStackFrame> {
 public:
   virtual lldb::ValueObjectListSP GetRecognizedArguments() {
     return m_arguments;
   }
+  virtual lldb::ValueObjectSP GetExceptionObject() {
+    return lldb::ValueObjectSP();
+  }
   virtual ~RecognizedStackFrame(){};
 
 protected:
   lldb::ValueObjectListSP m_arguments;
 };
 
 /// @class StackFrameRecognizer
 ///

 /// @class StackFrameRecognizerManager
 ///
 /// Static class that provides a registry of known stack frame recognizers.
 /// Has static methods to add, enumerate, remove, query and invoke recognizers.
 
 class StackFrameRecognizerManager {
 public:
   static void AddRecognizer(lldb::StackFrameRecognizerSP recognizer,
-                            ConstString &module, ConstString &symbol,
+                            const ConstString &module, const ConstString &symbol,
                             bool first_instruction_only = true);
 
   static void AddRecognizer(lldb::StackFrameRecognizerSP recognizer,
                             lldb::RegularExpressionSP module,
                             lldb::RegularExpressionSP symbol,
                             bool first_instruction_only = true);
 
   static void ForEach(

include/lldb/Target/Thread.h

   /// an extended backtrace.  The SystemRuntime plugin will set/request this.
   ///
   /// @return
   ///     The token needed by the SystemRuntime to create an extended backtrace.
   ///     LLDB_INVALID_ADDRESS is returned if no token is available.
   //----------------------------------------------------------------------
   virtual uint64_t GetExtendedBacktraceToken() { return LLDB_INVALID_ADDRESS; }
 
+  lldb::ThreadSP GetCurrentExceptionBacktrace();
+
+  lldb::ValueObjectSP GetCurrentException();
+
 protected:
   friend class ThreadPlan;
   friend class ThreadList;
   friend class ThreadEventData;
   friend class StackFrameList;
   friend class StackFrame;
   friend class OperatingSystem;
 

source/API/SBThread.cpp

 
 uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() {
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
     return thread_sp->GetExtendedBacktraceOriginatingIndexID();
   return LLDB_INVALID_INDEX32;
 }
 
+SBThread SBThread::GetCurrentExceptionBacktrace() {
+  ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
+  if (!thread_sp) return SBThread();
+
+  return SBThread(thread_sp->GetCurrentExceptionBacktrace());
+}
+
+SBValue SBThread::GetCurrentException() {
+  ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
+  if (!thread_sp) return SBValue();
+
+  return SBValue(thread_sp->GetCurrentException());
+}
+
 bool SBThread::SafeToCallFunctions() {
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
     return thread_sp->SafeToCallFunctions();
   return true;
 }
 
 lldb_private::Thread *SBThread::operator->() {

source/Commands/CommandObjectThread.cpp

bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
     }
     return true;
   }
 
   CommandOptions m_options;
 };
 
 //-------------------------------------------------------------------------
+// CommandObjectThreadException
+//-------------------------------------------------------------------------
+
+static OptionDefinition g_thread_exception_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "count",    'c', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCount,      "How many frames to display (-1 for all)" },
+  { LLDB_OPT_SET_1, false, "start",    's', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeFrameIndex, "Frame in which to start the backtrace" },
+    // clang-format on
+};
+
+class CommandObjectThreadException : public CommandObjectIterateOverThreads {
+ public:
+  class CommandOptions : public Options {
+   public:
+    CommandOptions() : Options() { OptionParsingStarting(nullptr); }
+
+    ~CommandOptions() override = default;
+
+    Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
+                          ExecutionContext *execution_context) override {
+      Status error;
+      const int short_option = m_getopt_table[option_idx].val;
+
+      switch (short_option) {
+        case 'c': {
+          int32_t input_count = 0;
+          if (option_arg.getAsInteger(0, m_count)) {
+            m_count = UINT32_MAX;
+            error.SetErrorStringWithFormat(
+                "invalid integer value for option '%c'", short_option);
+          } else if (input_count < 0)
+            m_count = UINT32_MAX;
+        } break;
+        case 's':
+          if (option_arg.getAsInteger(0, m_start))
+            error.SetErrorStringWithFormat(
+                "invalid integer value for option '%c'", short_option);
+          break;
+        default:
+          error.SetErrorStringWithFormat("invalid short option character '%c'",
+                                         short_option);
+          break;
+      }
+      return error;
+    }
+
+    void OptionParsingStarting(ExecutionContext *execution_context) override {
+      m_count = UINT32_MAX;
+      m_start = 0;
+    }
+
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return llvm::makeArrayRef(g_thread_exception_options);
+    }
+
+    // Instance variables to hold the values for command options.
+    uint32_t m_count;
+    uint32_t m_start;
+  };
+
+  CommandObjectThreadException(CommandInterpreter &interpreter)
+      : CommandObjectIterateOverThreads(
+            interpreter, "thread exception",
+            "Display the current exception object for a thread. Defaults to "
+            "the current thread.",
+            "thread exception",
+            eCommandRequiresProcess | eCommandTryTargetAPILock |
+                eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
+        m_options() {
+    m_add_return = false;
+  }
+
+  ~CommandObjectThreadException() override = default;
+
+  Options *GetOptions() override { return &m_options; }
+
+  bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
+    ThreadSP thread_sp =
+        m_exe_ctx.GetProcessPtr()->GetThreadList().FindThreadByID(tid);
+    if (!thread_sp) {
+      result.AppendErrorWithFormat("thread no longer exists: 0x%" PRIx64 "\n",
+                                   tid);
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
+
+    Stream &strm = result.GetOutputStream();
+    ValueObjectSP exception_object_sp = thread_sp->GetCurrentException();
+    if (exception_object_sp) {
+      exception_object_sp->Dump(strm);
+    }
+
+    ThreadSP exception_thread_sp = thread_sp->GetCurrentExceptionBacktrace();
+    if (exception_thread_sp && exception_thread_sp->IsValid()) {
+      const uint32_t num_frames_with_source = 0;
+      const bool stop_format = false;
+      exception_thread_sp->GetStatus(strm, m_options.m_start, m_options.m_count,
+                                     num_frames_with_source, stop_format);
+    }
+
+    return true;
+  }
+
+  CommandOptions m_options;
+};
+
+//-------------------------------------------------------------------------
 // CommandObjectThreadReturn
 //-------------------------------------------------------------------------
 
 static constexpr OptionDefinition g_thread_return_options[] = {
     // clang-format off
   { LLDB_OPT_SET_ALL, false, "from-expression", 'x', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Return from the innermost expression evaluation." }
     // clang-format on
 };
CommandObjectMultiwordThread::CommandObjectMultiwordThread(
   LoadSubCommand("jump",
                  CommandObjectSP(new CommandObjectThreadJump(interpreter)));
   LoadSubCommand("select",
                  CommandObjectSP(new CommandObjectThreadSelect(interpreter)));
   LoadSubCommand("until",
                  CommandObjectSP(new CommandObjectThreadUntil(interpreter)));
   LoadSubCommand("info",
                  CommandObjectSP(new CommandObjectThreadInfo(interpreter)));
+  LoadSubCommand(
+      "exception",
+      CommandObjectSP(new CommandObjectThreadException(interpreter)));
   LoadSubCommand("step-in",
                  CommandObjectSP(new CommandObjectThreadStepWithTypeAndScope(
                      interpreter, "thread step-in",
                      "Source level single step, stepping into calls.  Defaults "
                      "to current thread unless specified.",
                      nullptr, eStepTypeInto, eStepScopeSource)));
 
   LoadSubCommand("step-out",

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

 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/lldb-enumerations.h"
 
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
+#include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/VariableList.h"
+#include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/StackFrameRecognizer.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
if (symbol_load_addr != LLDB_INVALID_ADDRESS) {
       return default_value;
     }
   } else {
     error.SetErrorString("no symbol");
     return default_value;
   }
 }
 
+static void RegisterObjCExceptionRecognizer();
+
 AppleObjCRuntimeV2::AppleObjCRuntimeV2(Process *process,
                                        const ModuleSP &objc_module_sp)
     : AppleObjCRuntime(process), m_get_class_info_code(),
       m_get_class_info_args(LLDB_INVALID_ADDRESS),
       m_get_class_info_args_mutex(), m_get_shared_cache_class_info_code(),
       m_get_shared_cache_class_info_args(LLDB_INVALID_ADDRESS),
       m_get_shared_cache_class_info_args_mutex(), m_decl_vendor_ap(),
       m_tagged_pointer_obfuscator(LLDB_INVALID_ADDRESS),
       m_isa_hash_table_ptr(LLDB_INVALID_ADDRESS),
       m_hash_signature(),
       m_has_object_getClass(false), m_loaded_objc_opt(false),
       m_non_pointer_isa_cache_ap(
           NonPointerISACache::CreateInstance(*this, objc_module_sp)),
       m_tagged_pointer_vendor_ap(
           TaggedPointerVendorV2::CreateInstance(*this, objc_module_sp)),
       m_encoding_to_type_sp(), m_noclasses_warning_emitted(false),
       m_CFBoolean_values() {
   static const ConstString g_gdb_object_getClass("gdb_object_getClass");
   m_has_object_getClass = (objc_module_sp->FindFirstSymbolWithNameAndType(
                                g_gdb_object_getClass, eSymbolTypeCode) != NULL);
+  RegisterObjCExceptionRecognizer();
 }
 
 bool AppleObjCRuntimeV2::GetDynamicTypeAndAddress(
     ValueObject &in_value, lldb::DynamicValueType use_dynamic,
     TypeAndOrName &class_type_or_name, Address &address,
     Value::ValueType &value_type) {
   // We should never get here with a null process...
   assert(m_process != NULL);

 void AppleObjCRuntimeV2::GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true,
                                                       lldb::addr_t &cf_false) {
   if (GetCFBooleanValuesIfNeeded()) {
     cf_true = m_CFBoolean_values->second;
     cf_false = m_CFBoolean_values->first;
   } else
     this->AppleObjCRuntime::GetValuesForGlobalCFBooleans(cf_true, cf_false);
 }
+
+#pragma mark Frame recognizers
+
+class ObjCExceptionRecognizedStackFrame : public RecognizedStackFrame {
+ public:
+  ObjCExceptionRecognizedStackFrame(StackFrameSP frame_sp) {
+    ThreadSP thread_sp = frame_sp->GetThread();
+    ProcessSP process_sp = thread_sp->GetProcess();
+
+    const lldb::ABISP &abi = process_sp->GetABI();
+    if (!abi) return;
+
+    CompilerType voidstar = process_sp->GetTarget()
+                                .GetScratchClangASTContext()
+                                ->GetBasicType(lldb::eBasicTypeVoid)
+                                .GetPointerType();
+
+    ValueList args;
+    Value input_value;
+    input_value.SetCompilerType(voidstar);
+    args.PushValue(input_value);
+
+    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 = exception->GetDynamicValue(eDynamicDontRunTarget);
+  }
+
+  ValueObjectSP exception;
+
+  lldb::ValueObjectSP GetExceptionObject() override { return exception; }
+};
+
+class ObjCExceptionThrowFrameRecognizer : public StackFrameRecognizer {
+  lldb::RecognizedStackFrameSP RecognizeFrame(lldb::StackFrameSP frame) {
+    return lldb::RecognizedStackFrameSP(
+        new ObjCExceptionRecognizedStackFrame(frame));
+  };
+};
+
+static void RegisterObjCExceptionRecognizer() {
+  static llvm::once_flag g_once_flag;
+  llvm::call_once(g_once_flag, []() {
+    StackFrameRecognizerManager::AddRecognizer(
+        StackFrameRecognizerSP(new ObjCExceptionThrowFrameRecognizer()),
+        ConstString("libobjc.A.dylib"), ConstString("objc_exception_throw"),
+        /*first_instruction_only*/ true);
+  });
+}

source/Target/StackFrameRecognizer.cpp

ScriptedStackFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame) {
 
   return RecognizedStackFrameSP(new ScriptedRecognizedStackFrame(args));
 }
 
 #endif
 
 class StackFrameRecognizerManagerImpl {
 public:
-  void AddRecognizer(StackFrameRecognizerSP recognizer, ConstString &module,
-                     ConstString &symbol, bool first_instruction_only) {
+  void AddRecognizer(StackFrameRecognizerSP recognizer, const ConstString &module,
+                     const ConstString &symbol, bool first_instruction_only) {
     m_recognizers.push_front({(uint32_t)m_recognizers.size(), false, recognizer, false, module, RegularExpressionSP(),
                               symbol, RegularExpressionSP(),
                               first_instruction_only});
   }
 
   void AddRecognizer(StackFrameRecognizerSP recognizer,
                      RegularExpressionSP module, RegularExpressionSP symbol,
                      bool first_instruction_only) {

 
 StackFrameRecognizerManagerImpl &GetStackFrameRecognizerManagerImpl() {
   static StackFrameRecognizerManagerImpl instance =
       StackFrameRecognizerManagerImpl();
   return instance;
 }
 
 void StackFrameRecognizerManager::AddRecognizer(
-    StackFrameRecognizerSP recognizer, ConstString &module, ConstString &symbol,
+    StackFrameRecognizerSP recognizer, const ConstString &module, const ConstString &symbol,
     bool first_instruction_only) {
   GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol,
                                                      first_instruction_only);
 }
 
 void StackFrameRecognizerManager::AddRecognizer(
     StackFrameRecognizerSP recognizer, RegularExpressionSP module,
     RegularExpressionSP symbol, bool first_instruction_only) {

source/Target/Thread.cpp

 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/StackFrameRecognizer.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanBase.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Target/ThreadPlanPython.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
if (StateIsStoppedState(process->GetState(), true)) {
     // Why do we need to set the current thread by ID here???
     process->GetThreadList().SetSelectedThreadByID(GetID());
     error = process->Resume();
   } else {
     error.SetErrorString("process not stopped");
   }
   return error;
 }
+
+ValueObjectSP Thread::GetCurrentException() {
+  StackFrameSP frame_sp(GetStackFrameAtIndex(0));
+  if (!frame_sp) return ValueObjectSP();
+
+  RecognizedStackFrameSP recognized_frame(frame_sp->GetRecognizedFrame());
+  if (!recognized_frame) return ValueObjectSP();
+
+  return recognized_frame->GetExceptionObject();
+}
+
+ThreadSP Thread::GetCurrentExceptionBacktrace() {
+  // TODO
+  return ThreadSP();
+}