*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 273 insertions, 250 deletions

diff --git a/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp b/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp
index d311f5fb5f6..452d319860d 100644
--- a/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp
+++ b/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp
@@ -1,4 +1,5 @@
-//===-- AppleGetPendingItemsHandler.cpp -------------------------------*- C++ -*-===//
+//===-- AppleGetPendingItemsHandler.cpp -------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -32,8 +33,10 @@
 using namespace lldb;
 using namespace lldb_private;
 
-const char *AppleGetPendingItemsHandler::g_get_pending_items_function_name = "__lldb_backtrace_recording_get_pending_items";
-const char *AppleGetPendingItemsHandler::g_get_pending_items_function_code = "                                  \n\
+const char *AppleGetPendingItemsHandler::g_get_pending_items_function_name =
+    "__lldb_backtrace_recording_get_pending_items";
+const char *AppleGetPendingItemsHandler::g_get_pending_items_function_code =
+    "                                  \n\
 extern \"C\"                                                                                                    \n\
 {                                                                                                               \n\
     /*                                                                                                          \n\
@@ -101,290 +104,310 @@ extern \"C\"
 ";
 
 AppleGetPendingItemsHandler::AppleGetPendingItemsHandler(Process *process)
-    : m_process(process),
-      m_get_pending_items_impl_code(),
+    : m_process(process), m_get_pending_items_impl_code(),
       m_get_pending_items_function_mutex(),
       m_get_pending_items_return_buffer_addr(LLDB_INVALID_ADDRESS),
-      m_get_pending_items_retbuffer_mutex()
-{
-}
-
-AppleGetPendingItemsHandler::~AppleGetPendingItemsHandler ()
-{
-}
-
-void
-AppleGetPendingItemsHandler::Detach()
-{
-    if (m_process && m_process->IsAlive() && m_get_pending_items_return_buffer_addr != LLDB_INVALID_ADDRESS)
-    {
-        std::unique_lock<std::mutex> lock(m_get_pending_items_retbuffer_mutex, std::defer_lock);
-        lock.try_lock(); // Even if we don't get the lock, deallocate the buffer
-        m_process->DeallocateMemory(m_get_pending_items_return_buffer_addr);
-    }
+      m_get_pending_items_retbuffer_mutex() {}
+
+AppleGetPendingItemsHandler::~AppleGetPendingItemsHandler() {}
+
+void AppleGetPendingItemsHandler::Detach() {
+  if (m_process && m_process->IsAlive() &&
+      m_get_pending_items_return_buffer_addr != LLDB_INVALID_ADDRESS) {
+    std::unique_lock<std::mutex> lock(m_get_pending_items_retbuffer_mutex,
+                                      std::defer_lock);
+    lock.try_lock(); // Even if we don't get the lock, deallocate the buffer
+    m_process->DeallocateMemory(m_get_pending_items_return_buffer_addr);
+  }
 }
 
 // Compile our __lldb_backtrace_recording_get_pending_items() function (from the
-// source above in g_get_pending_items_function_code) if we don't find that function in the inferior
-// already with USE_BUILTIN_FUNCTION defined.  (e.g. this would be the case for testing.)
+// source above in g_get_pending_items_function_code) if we don't find that
+// function in the inferior
+// already with USE_BUILTIN_FUNCTION defined.  (e.g. this would be the case for
+// testing.)
+//
+// Insert the __lldb_backtrace_recording_get_pending_items into the inferior
+// process if needed.
 //
-// Insert the __lldb_backtrace_recording_get_pending_items into the inferior process if needed.
+// Write the get_pending_items_arglist into the inferior's memory space to
+// prepare for the call.
 //
-// Write the get_pending_items_arglist into the inferior's memory space to prepare for the call.
-// 
-// Returns the address of the arguments written down in the inferior process, which can be used to
+// Returns the address of the arguments written down in the inferior process,
+// which can be used to
 // make the function call.
 
-lldb::addr_t
-AppleGetPendingItemsHandler::SetupGetPendingItemsFunction(Thread &thread, ValueList &get_pending_items_arglist)
-{
-    ThreadSP thread_sp (thread.shared_from_this());
-    ExecutionContext exe_ctx (thread_sp);
-    DiagnosticManager diagnostics;
-    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYSTEM_RUNTIME));
-
-    lldb::addr_t args_addr = LLDB_INVALID_ADDRESS;
-    FunctionCaller *get_pending_items_caller = nullptr;
-
-    // Scope for mutex locker:
-    {
-        std::lock_guard<std::mutex> guard(m_get_pending_items_function_mutex);
-
-        // First stage is to make the ClangUtility to hold our injected function:
-
-        if (!m_get_pending_items_impl_code.get())
-        {
-            if (g_get_pending_items_function_code != NULL)
-            {
-                Error error;
-                m_get_pending_items_impl_code.reset (exe_ctx.GetTargetRef().GetUtilityFunctionForLanguage(g_get_pending_items_function_code,
-                                                                                                          eLanguageTypeObjC,
-                                                                                                          g_get_pending_items_function_name,
-                                                                                                          error));
-                if (error.Fail())
-                {
-                    if (log)
-                        log->Printf ("Failed to get UtilityFunction for pending-items introspection: %s.", error.AsCString());
-                    return args_addr;
-                }
-
-                if (!m_get_pending_items_impl_code->Install(diagnostics, exe_ctx))
-                {
-                    if (log)
-                    {
-                        log->Printf("Failed to install pending-items introspection.");
-                        diagnostics.Dump(log);
-                    }
-                    m_get_pending_items_impl_code.reset();
-                    return args_addr;
-                }
-            }
-            else
-            {
-                if (log)
-                    log->Printf("No pending-items introspection code found.");
-                return LLDB_INVALID_ADDRESS;
-            }
-            
-            // Next make the runner function for our implementation utility function.
-            Error error;
-            ClangASTContext *clang_ast_context = thread.GetProcess()->GetTarget().GetScratchClangASTContext();
-            CompilerType get_pending_items_return_type = clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
-            get_pending_items_caller = m_get_pending_items_impl_code->MakeFunctionCaller (get_pending_items_return_type,
-                                                                                          get_pending_items_arglist,
-                                                                                          thread_sp,
-                                                                                          error);
-            if (error.Fail())
-            {
-                if (log)
-                    log->Printf ("Failed to install pending-items introspection function caller: %s.", error.AsCString());
-                m_get_pending_items_impl_code.reset();
-                return args_addr;
-            }
+lldb::addr_t AppleGetPendingItemsHandler::SetupGetPendingItemsFunction(
+    Thread &thread, ValueList &get_pending_items_arglist) {
+  ThreadSP thread_sp(thread.shared_from_this());
+  ExecutionContext exe_ctx(thread_sp);
+  DiagnosticManager diagnostics;
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYSTEM_RUNTIME));
+
+  lldb::addr_t args_addr = LLDB_INVALID_ADDRESS;
+  FunctionCaller *get_pending_items_caller = nullptr;
+
+  // Scope for mutex locker:
+  {
+    std::lock_guard<std::mutex> guard(m_get_pending_items_function_mutex);
+
+    // First stage is to make the ClangUtility to hold our injected function:
+
+    if (!m_get_pending_items_impl_code.get()) {
+      if (g_get_pending_items_function_code != NULL) {
+        Error error;
+        m_get_pending_items_impl_code.reset(
+            exe_ctx.GetTargetRef().GetUtilityFunctionForLanguage(
+                g_get_pending_items_function_code, eLanguageTypeObjC,
+                g_get_pending_items_function_name, error));
+        if (error.Fail()) {
+          if (log)
+            log->Printf("Failed to get UtilityFunction for pending-items "
+                        "introspection: %s.",
+                        error.AsCString());
+          return args_addr;
         }
-    }
-
-    diagnostics.Clear();
 
-    if (get_pending_items_caller == nullptr)
-    {
+        if (!m_get_pending_items_impl_code->Install(diagnostics, exe_ctx)) {
+          if (log) {
+            log->Printf("Failed to install pending-items introspection.");
+            diagnostics.Dump(log);
+          }
+          m_get_pending_items_impl_code.reset();
+          return args_addr;
+        }
+      } else {
         if (log)
-            log->Printf ("Failed to get get_pending_items_caller.");
+          log->Printf("No pending-items introspection code found.");
         return LLDB_INVALID_ADDRESS;
+      }
+
+      // Next make the runner function for our implementation utility function.
+      Error error;
+      ClangASTContext *clang_ast_context =
+          thread.GetProcess()->GetTarget().GetScratchClangASTContext();
+      CompilerType get_pending_items_return_type =
+          clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
+      get_pending_items_caller =
+          m_get_pending_items_impl_code->MakeFunctionCaller(
+              get_pending_items_return_type, get_pending_items_arglist,
+              thread_sp, error);
+      if (error.Fail()) {
+        if (log)
+          log->Printf("Failed to install pending-items introspection function "
+                      "caller: %s.",
+                      error.AsCString());
+        m_get_pending_items_impl_code.reset();
+        return args_addr;
+      }
     }
-    
-    // Now write down the argument values for this particular call.  This looks like it might be a race condition
-    // if other threads were calling into here, but actually it isn't because we allocate a new args structure for
-    // this call by passing args_addr = LLDB_INVALID_ADDRESS...
+  }
 
-    if (!get_pending_items_caller->WriteFunctionArguments(exe_ctx, args_addr, get_pending_items_arglist, diagnostics))
-    {
-        if (log)
-        {
-            log->Printf("Error writing pending-items function arguments.");
-            diagnostics.Dump(log);
-        }
+  diagnostics.Clear();
 
-        return args_addr;
+  if (get_pending_items_caller == nullptr) {
+    if (log)
+      log->Printf("Failed to get get_pending_items_caller.");
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  // Now write down the argument values for this particular call.  This looks
+  // like it might be a race condition
+  // if other threads were calling into here, but actually it isn't because we
+  // allocate a new args structure for
+  // this call by passing args_addr = LLDB_INVALID_ADDRESS...
+
+  if (!get_pending_items_caller->WriteFunctionArguments(
+          exe_ctx, args_addr, get_pending_items_arglist, diagnostics)) {
+    if (log) {
+      log->Printf("Error writing pending-items function arguments.");
+      diagnostics.Dump(log);
     }
 
     return args_addr;
+  }
+
+  return args_addr;
 }
 
 AppleGetPendingItemsHandler::GetPendingItemsReturnInfo
-AppleGetPendingItemsHandler::GetPendingItems (Thread &thread, addr_t queue, addr_t page_to_free, uint64_t page_to_free_size, Error &error)
-{
-    lldb::StackFrameSP thread_cur_frame = thread.GetStackFrameAtIndex(0);
-    ProcessSP process_sp (thread.CalculateProcess());
-    TargetSP target_sp (thread.CalculateTarget());
-    ClangASTContext *clang_ast_context = target_sp->GetScratchClangASTContext();
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYSTEM_RUNTIME));
-
-    GetPendingItemsReturnInfo return_value;
-    return_value.items_buffer_ptr = LLDB_INVALID_ADDRESS;
-    return_value.items_buffer_size = 0;
-    return_value.count = 0;
-
-    error.Clear();
-
-    if (thread.SafeToCallFunctions() == false)
-    {
-        if (log)
-            log->Printf ("Not safe to call functions on thread 0x%" PRIx64, thread.GetID());
-        error.SetErrorString ("Not safe to call functions on this thread.");
-        return return_value;
-    }
-
-    // Set up the arguments for a call to
-
-    // struct get_pending_items_return_values
-    // {
-    //     uint64_t pending_items_buffer_ptr;    /* the address of the items buffer from libBacktraceRecording */
-    //     uint64_t pending_items_buffer_size;   /* the size of the items buffer from libBacktraceRecording */
-    //     uint64_t count;                /* the number of items included in the queues buffer */
-    // };
-    //
-    // void  __lldb_backtrace_recording_get_pending_items
-    //                                            (struct get_pending_items_return_values *return_buffer,
-    //                                             int debug,
-    //                                             uint64_t /* dispatch_queue_t */ queue
-    //                                             void *page_to_free,
-    //                                             uint64_t page_to_free_size)
-
-    // Where the return_buffer argument points to a 24 byte region of memory already allocated by lldb in
-    // the inferior process.
-
-    CompilerType clang_void_ptr_type = clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
-    Value return_buffer_ptr_value;
-    return_buffer_ptr_value.SetValueType (Value::eValueTypeScalar);
-    return_buffer_ptr_value.SetCompilerType (clang_void_ptr_type);
-
-    CompilerType clang_int_type = clang_ast_context->GetBasicType(eBasicTypeInt);
-    Value debug_value;
-    debug_value.SetValueType (Value::eValueTypeScalar);
-    debug_value.SetCompilerType (clang_int_type);
-
-    CompilerType clang_uint64_type = clang_ast_context->GetBasicType(eBasicTypeUnsignedLongLong);
-    Value queue_value;
-    queue_value.SetValueType (Value::eValueTypeScalar);
-    queue_value.SetCompilerType (clang_uint64_type);
-
-    Value page_to_free_value;
-    page_to_free_value.SetValueType (Value::eValueTypeScalar);
-    page_to_free_value.SetCompilerType (clang_void_ptr_type);
-
-    Value page_to_free_size_value;
-    page_to_free_size_value.SetValueType (Value::eValueTypeScalar);
-    page_to_free_size_value.SetCompilerType (clang_uint64_type);
-
-    std::lock_guard<std::mutex> guard(m_get_pending_items_retbuffer_mutex);
-    if (m_get_pending_items_return_buffer_addr == LLDB_INVALID_ADDRESS)
-    {
-        addr_t bufaddr = process_sp->AllocateMemory (32, ePermissionsReadable | ePermissionsWritable, error);
-        if (!error.Success() || bufaddr == LLDB_INVALID_ADDRESS)
-        {
-            if (log)
-                log->Printf ("Failed to allocate memory for return buffer for get current queues func call");
-            return return_value;
-        }
-        m_get_pending_items_return_buffer_addr = bufaddr;
+AppleGetPendingItemsHandler::GetPendingItems(Thread &thread, addr_t queue,
+                                             addr_t page_to_free,
+                                             uint64_t page_to_free_size,
+                                             Error &error) {
+  lldb::StackFrameSP thread_cur_frame = thread.GetStackFrameAtIndex(0);
+  ProcessSP process_sp(thread.CalculateProcess());
+  TargetSP target_sp(thread.CalculateTarget());
+  ClangASTContext *clang_ast_context = target_sp->GetScratchClangASTContext();
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYSTEM_RUNTIME));
+
+  GetPendingItemsReturnInfo return_value;
+  return_value.items_buffer_ptr = LLDB_INVALID_ADDRESS;
+  return_value.items_buffer_size = 0;
+  return_value.count = 0;
+
+  error.Clear();
+
+  if (thread.SafeToCallFunctions() == false) {
+    if (log)
+      log->Printf("Not safe to call functions on thread 0x%" PRIx64,
+                  thread.GetID());
+    error.SetErrorString("Not safe to call functions on this thread.");
+    return return_value;
+  }
+
+  // Set up the arguments for a call to
+
+  // struct get_pending_items_return_values
+  // {
+  //     uint64_t pending_items_buffer_ptr;    /* the address of the items
+  //     buffer from libBacktraceRecording */
+  //     uint64_t pending_items_buffer_size;   /* the size of the items buffer
+  //     from libBacktraceRecording */
+  //     uint64_t count;                /* the number of items included in the
+  //     queues buffer */
+  // };
+  //
+  // void  __lldb_backtrace_recording_get_pending_items
+  //                                            (struct
+  //                                            get_pending_items_return_values
+  //                                            *return_buffer,
+  //                                             int debug,
+  //                                             uint64_t /* dispatch_queue_t */
+  //                                             queue
+  //                                             void *page_to_free,
+  //                                             uint64_t page_to_free_size)
+
+  // Where the return_buffer argument points to a 24 byte region of memory
+  // already allocated by lldb in
+  // the inferior process.
+
+  CompilerType clang_void_ptr_type =
+      clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
+  Value return_buffer_ptr_value;
+  return_buffer_ptr_value.SetValueType(Value::eValueTypeScalar);
+  return_buffer_ptr_value.SetCompilerType(clang_void_ptr_type);
+
+  CompilerType clang_int_type = clang_ast_context->GetBasicType(eBasicTypeInt);
+  Value debug_value;
+  debug_value.SetValueType(Value::eValueTypeScalar);
+  debug_value.SetCompilerType(clang_int_type);
+
+  CompilerType clang_uint64_type =
+      clang_ast_context->GetBasicType(eBasicTypeUnsignedLongLong);
+  Value queue_value;
+  queue_value.SetValueType(Value::eValueTypeScalar);
+  queue_value.SetCompilerType(clang_uint64_type);
+
+  Value page_to_free_value;
+  page_to_free_value.SetValueType(Value::eValueTypeScalar);
+  page_to_free_value.SetCompilerType(clang_void_ptr_type);
+
+  Value page_to_free_size_value;
+  page_to_free_size_value.SetValueType(Value::eValueTypeScalar);
+  page_to_free_size_value.SetCompilerType(clang_uint64_type);
+
+  std::lock_guard<std::mutex> guard(m_get_pending_items_retbuffer_mutex);
+  if (m_get_pending_items_return_buffer_addr == LLDB_INVALID_ADDRESS) {
+    addr_t bufaddr = process_sp->AllocateMemory(
+        32, ePermissionsReadable | ePermissionsWritable, error);
+    if (!error.Success() || bufaddr == LLDB_INVALID_ADDRESS) {
+      if (log)
+        log->Printf("Failed to allocate memory for return buffer for get "
+                    "current queues func call");
+      return return_value;
     }
+    m_get_pending_items_return_buffer_addr = bufaddr;
+  }
 
-    ValueList argument_values;
+  ValueList argument_values;
 
-    return_buffer_ptr_value.GetScalar() = m_get_pending_items_return_buffer_addr;
-    argument_values.PushValue (return_buffer_ptr_value);
+  return_buffer_ptr_value.GetScalar() = m_get_pending_items_return_buffer_addr;
+  argument_values.PushValue(return_buffer_ptr_value);
 
-    debug_value.GetScalar() = 0;
-    argument_values.PushValue (debug_value);
+  debug_value.GetScalar() = 0;
+  argument_values.PushValue(debug_value);
 
-    queue_value.GetScalar() = queue;
-    argument_values.PushValue (queue_value);
+  queue_value.GetScalar() = queue;
+  argument_values.PushValue(queue_value);
 
-    if (page_to_free != LLDB_INVALID_ADDRESS)
-        page_to_free_value.GetScalar() = page_to_free;
-    else
-        page_to_free_value.GetScalar() = 0;
-    argument_values.PushValue (page_to_free_value);
+  if (page_to_free != LLDB_INVALID_ADDRESS)
+    page_to_free_value.GetScalar() = page_to_free;
+  else
+    page_to_free_value.GetScalar() = 0;
+  argument_values.PushValue(page_to_free_value);
 
-    page_to_free_size_value.GetScalar() = page_to_free_size;
-    argument_values.PushValue (page_to_free_size_value);
+  page_to_free_size_value.GetScalar() = page_to_free_size;
+  argument_values.PushValue(page_to_free_size_value);
 
-    addr_t args_addr = SetupGetPendingItemsFunction(thread, argument_values);
+  addr_t args_addr = SetupGetPendingItemsFunction(thread, argument_values);
 
-    DiagnosticManager diagnostics;
-    ExecutionContext exe_ctx;
-    FunctionCaller *get_pending_items_caller = m_get_pending_items_impl_code->GetFunctionCaller();
+  DiagnosticManager diagnostics;
+  ExecutionContext exe_ctx;
+  FunctionCaller *get_pending_items_caller =
+      m_get_pending_items_impl_code->GetFunctionCaller();
 
-    EvaluateExpressionOptions options;
-    options.SetUnwindOnError (true);
-    options.SetIgnoreBreakpoints (true);
-    options.SetStopOthers (true);
-    options.SetTimeoutUsec(500000);
-    options.SetTryAllThreads (false);
-    thread.CalculateExecutionContext (exe_ctx);
+  EvaluateExpressionOptions options;
+  options.SetUnwindOnError(true);
+  options.SetIgnoreBreakpoints(true);
+  options.SetStopOthers(true);
+  options.SetTimeoutUsec(500000);
+  options.SetTryAllThreads(false);
+  thread.CalculateExecutionContext(exe_ctx);
 
-    if (get_pending_items_caller == NULL)
-    {
-        error.SetErrorString ("Unable to compile function to call __introspection_dispatch_queue_get_pending_items");
-        return return_value;
-    }
-
-    ExpressionResults func_call_ret;
-    Value results;
-    func_call_ret = get_pending_items_caller->ExecuteFunction(exe_ctx, &args_addr, options, diagnostics, results);
-    if (func_call_ret != eExpressionCompleted || !error.Success())
-    {
-        if (log)
-            log->Printf ("Unable to call __introspection_dispatch_queue_get_pending_items(), got ExpressionResults %d, error contains %s", func_call_ret, error.AsCString(""));
-        error.SetErrorString ("Unable to call __introspection_dispatch_queue_get_pending_items() for list of queues");
-        return return_value;
-    }
-
-    return_value.items_buffer_ptr = m_process->ReadUnsignedIntegerFromMemory (m_get_pending_items_return_buffer_addr, 8, LLDB_INVALID_ADDRESS, error);
-    if (!error.Success() || return_value.items_buffer_ptr == LLDB_INVALID_ADDRESS)
-    {
-        return_value.items_buffer_ptr = LLDB_INVALID_ADDRESS;
-        return return_value;
-    }
+  if (get_pending_items_caller == NULL) {
+    error.SetErrorString("Unable to compile function to call "
+                         "__introspection_dispatch_queue_get_pending_items");
+    return return_value;
+  }
 
-    return_value.items_buffer_size = m_process->ReadUnsignedIntegerFromMemory (m_get_pending_items_return_buffer_addr + 8, 8, 0, error);
+  ExpressionResults func_call_ret;
+  Value results;
+  func_call_ret = get_pending_items_caller->ExecuteFunction(
+      exe_ctx, &args_addr, options, diagnostics, results);
+  if (func_call_ret != eExpressionCompleted || !error.Success()) {
+    if (log)
+      log->Printf("Unable to call "
+                  "__introspection_dispatch_queue_get_pending_items(), got "
+                  "ExpressionResults %d, error contains %s",
+                  func_call_ret, error.AsCString(""));
+    error.SetErrorString("Unable to call "
+                         "__introspection_dispatch_queue_get_pending_items() "
+                         "for list of queues");
+    return return_value;
+  }
 
-    if (!error.Success())
-    {
-        return_value.items_buffer_ptr = LLDB_INVALID_ADDRESS;
-        return return_value;
-    }
+  return_value.items_buffer_ptr = m_process->ReadUnsignedIntegerFromMemory(
+      m_get_pending_items_return_buffer_addr, 8, LLDB_INVALID_ADDRESS, error);
+  if (!error.Success() ||
+      return_value.items_buffer_ptr == LLDB_INVALID_ADDRESS) {
+    return_value.items_buffer_ptr = LLDB_INVALID_ADDRESS;
+    return return_value;
+  }
 
-    return_value.count = m_process->ReadUnsignedIntegerFromMemory (m_get_pending_items_return_buffer_addr + 16, 8, 0, error);
-    if (!error.Success())
-    {
-        return_value.items_buffer_ptr = LLDB_INVALID_ADDRESS;
-        return return_value;
-    }
+  return_value.items_buffer_size = m_process->ReadUnsignedIntegerFromMemory(
+      m_get_pending_items_return_buffer_addr + 8, 8, 0, error);
 
-    if (log)
-        log->Printf ("AppleGetPendingItemsHandler called __introspection_dispatch_queue_get_pending_items (page_to_free == 0x%" PRIx64 ", size = %" PRId64 "), returned page is at 0x%" PRIx64 ", size %" PRId64 ", count = %" PRId64, page_to_free, page_to_free_size, return_value.items_buffer_ptr, return_value.items_buffer_size, return_value.count);
+  if (!error.Success()) {
+    return_value.items_buffer_ptr = LLDB_INVALID_ADDRESS;
+    return return_value;
+  }
 
+  return_value.count = m_process->ReadUnsignedIntegerFromMemory(
+      m_get_pending_items_return_buffer_addr + 16, 8, 0, error);
+  if (!error.Success()) {
+    return_value.items_buffer_ptr = LLDB_INVALID_ADDRESS;
     return return_value;
+  }
+
+  if (log)
+    log->Printf("AppleGetPendingItemsHandler called "
+                "__introspection_dispatch_queue_get_pending_items "
+                "(page_to_free == 0x%" PRIx64 ", size = %" PRId64
+                "), returned page is at 0x%" PRIx64 ", size %" PRId64
+                ", count = %" PRId64,
+                page_to_free, page_to_free_size, return_value.items_buffer_ptr,
+                return_value.items_buffer_size, return_value.count);
+
+  return return_value;
 }