Read exception records from Windows mini dump

[amccarth]

Summary

Now when you do a thread list, you'll see the exception information in the stop info for the thread that stopped.

I'd like to move the ExceptionRecord.h file to a common place as a separate patch.

[zturner]

I would really like to start seeing tests go in at the same time as the patches. Can any of this functionality be tested yet? i.e. are there commands that will exercise this code? Also still haven't seen tests go in for the basic minidump functionality, like a test that just creates and loads a minidump without any errors. Do you think it's better to do that now or as a followup patch? Either way, I don't think we should wait too much longer before building up some tests.

source/Plugins/Process/win-minidump/ProcessWinMiniDump.cpp

160

Shouldn't this be std::numeric_limits<uint32_t>::max() and the loop index variable be unsigned as well?

173

Can you invert this conditional and early-out to keep the indentation level reduced?

320

Same here

339

And here.

[amccarth]

source/Plugins/Process/win-minidump/ProcessWinMiniDump.cpp

173

Done, but >grumble<. It seems likely this code will evolve into a cascaded if-else-if (as per the ProcessWindows::RefreshStateAfterStop), in which case the early out would have to be reverted.

Checking for prerequisites before doing something is natural, flexible, and avoids code duplication. Early outs are like Yoda comparisons--harder to read for dubious advantage.

320

That would violate the DRY principle, since I'd have to repeat the construction of an invalid or unknown ArchSpec.

[amccarth]

Addresses some of Zach's comments.

[zturner]

source/Plugins/Process/win-minidump/ProcessWinMiniDump.cpp

173

I know :-/ Not saying I agree or disagree, it's just the LLVM style.

http://llvm.org/docs/CodingStandards.html#use-early-exits-and-continue-to-simplify-code

[amccarth]

Forgot to flip logic for the early outs.

source/Plugins/Process/Windows/ExceptionRecord.h

 //===-- ExceptionRecord.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_Plugins_Process_Windows_ExceptionRecord_H_
 #define liblldb_Plugins_Process_Windows_ExceptionRecord_H_
 
 #include "ForwardDecl.h"
 
 #include "lldb/lldb-forward.h"
 #include "lldb/Host/windows/windows.h"
+#include <DbgHelp.h>
 
 #include <memory>
 #include <vector>
 
 namespace lldb_private
 {
 
 //----------------------------------------------------------------------
ExceptionRecord(const EXCEPTION_RECORD &record, lldb::tid_t thread_id)
         m_code = record.ExceptionCode;
         m_continuable = (record.ExceptionFlags == 0);
         if (record.ExceptionRecord)
             m_next_exception.reset(new ExceptionRecord(*record.ExceptionRecord, thread_id));
         m_exception_addr = reinterpret_cast<lldb::addr_t>(record.ExceptionAddress);
         m_thread_id = thread_id;
         m_arguments.assign(record.ExceptionInformation, record.ExceptionInformation + record.NumberParameters);
     }
+
+    // MINIDUMP_EXCEPTIONs are almost identical to EXCEPTION_RECORDs.
+    ExceptionRecord(const MINIDUMP_EXCEPTION &record, lldb::tid_t thread_id) :
+        m_code(record.ExceptionCode),
+        m_continuable(record.ExceptionFlags == 0),
+        m_next_exception(nullptr),
+        m_exception_addr(static_cast<lldb::addr_t>(record.ExceptionAddress)),
+        m_thread_id(thread_id),
+        m_arguments(record.ExceptionInformation, record.ExceptionInformation + record.NumberParameters)
+    {
+        // Set up link to nested exception.
+        if (record.ExceptionRecord)
+        {
+            m_next_exception.reset(new ExceptionRecord(*reinterpret_cast<const MINIDUMP_EXCEPTION *>(record.ExceptionRecord),
+                                                       thread_id));
+        }
+    }
+
     virtual ~ExceptionRecord() {}
 
     DWORD
     GetExceptionCode() const
     {
         return m_code;
     }
     bool

source/Plugins/Process/win-minidump/ProcessWinMiniDump.h

 
 private:
     lldb_private::Error
     MapMiniDumpIntoMemory(const char *file);
 
     lldb_private::ArchSpec
     DetermineArchitecture();
 
+    void
+    ReadExceptionRecord();
+
+    // A thin wrapper around WinAPI's MiniDumpReadDumpStream to avoid redundant
+    // checks.  If there's a failure (e.g., if the requested stream doesn't exist),
+    // the function returns nullptr and sets *size_out to 0.
+    void *
+    FindDumpStream(unsigned stream_number, size_t *size_out);
+
     // Isolate the data to keep Windows-specific types out of this header.  Can't
     // use the typical pimpl idiom because the implementation of this class also
     // needs access to public and protected members of the base class.
     class Data;
     std::unique_ptr<Data> m_data_up;
 };
 
 #endif  // liblldb_ProcessWinMiniDump_h_

source/Plugins/Process/win-minidump/ProcessWinMiniDump.cpp

 
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Log.h"
+#include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/UnixSignals.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/raw_ostream.h"
 #include "Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h"
 
+#include "../windows/ExceptionRecord.h"  // TODO(amccarth):  move this file to a common location
 #include "ThreadWinMiniDump.h"
 
 using namespace lldb_private;
 
 // Encapsulates the private data for ProcessWinMiniDump.
 // TODO(amccarth):  Determine if we need a mutex for access.
 class ProcessWinMiniDump::Data
 {
 public:
     Data();
     ~Data();
 
     FileSpec m_core_file;
     HANDLE m_dump_file;  // handle to the open minidump file
     HANDLE m_mapping;  // handle to the file mapping for the minidump file
     void * m_base_addr;  // base memory address of the minidump
+    std::shared_ptr<ExceptionRecord> m_exception_sp;
 };
 
 ConstString
 ProcessWinMiniDump::GetPluginNameStatic()
 {
     static ConstString g_name("win-minidump");
     return g_name;
 }
ProcessWinMiniDump::DoLoadCore()
     error = MapMiniDumpIntoMemory(m_data_up->m_core_file.GetCString());
     if (error.Fail())
     {
         return error;
     }
 
     m_target.SetArchitecture(DetermineArchitecture());
     // TODO(amccarth):  Build the module list.
-    // TODO(amccarth):  Read the exeception record.
+
+    ReadExceptionRecord();
 
     return error;
 
 }
 
 DynamicLoader *
 ProcessWinMiniDump::GetDynamicLoader()
 {
     if (m_dyld_ap.get() == NULL)
         m_dyld_ap.reset (DynamicLoader::FindPlugin(this, DynamicLoaderWindowsDYLD::GetPluginNameStatic().GetCString()));
     return m_dyld_ap.get();
 }
 
 bool
 ProcessWinMiniDump::UpdateThreadList(ThreadList &old_thread_list, ThreadList &new_thread_list)
 {
-    assert(m_data_up != nullptr);
-    assert(m_data_up->m_base_addr != 0);
-
-    MINIDUMP_DIRECTORY *dir = nullptr;
-    void *ptr = nullptr;
-    ULONG size = 0;
-    if (::MiniDumpReadDumpStream(m_data_up->m_base_addr, ThreadListStream, &dir, &ptr, &size))
-    {
-        assert(dir->StreamType == ThreadListStream);
-        assert(size == dir->Location.DataSize);
-        assert(ptr == static_cast<void*>(static_cast<char*>(m_data_up->m_base_addr) + dir->Location.Rva));
-        auto thread_list_ptr = static_cast<const MINIDUMP_THREAD_LIST *>(ptr);
+    size_t size = 0;
+    auto thread_list_ptr = static_cast<const MINIDUMP_THREAD_LIST *>(FindDumpStream(ThreadListStream, &size));
+    if (thread_list_ptr)
+    {
         const ULONG32 thread_count = thread_list_ptr->NumberOfThreads;
         assert(thread_count < std::numeric_limits<int>::max());
         for (int i = 0; i < thread_count; ++i) {
             std::shared_ptr<ThreadWinMiniDump> thread_sp(new ThreadWinMiniDump(*this, thread_list_ptr->Threads[i].ThreadId));
             new_thread_list.AddThread(thread_sp);
         }
     }
 
     return new_thread_list.GetSize(false) > 0;
 }
 
 void
 ProcessWinMiniDump::RefreshStateAfterStop()
 {
+    if (m_data_up && m_data_up->m_exception_sp)
+    {
+        auto active_exception = m_data_up->m_exception_sp;
+        std::string desc;
+        llvm::raw_string_ostream desc_stream(desc);
+        desc_stream << "Exception "
+                    << llvm::format_hex(active_exception->GetExceptionCode(), 8)
+                    << " encountered at address "
+                    << llvm::format_hex(active_exception->GetExceptionAddress(), 8);
+        m_thread_list.SetSelectedThreadByID(active_exception->GetThreadID());
+        auto stop_thread = m_thread_list.GetSelectedThread();
+        auto stop_info = StopInfo::CreateStopReasonWithException(*stop_thread, desc_stream.str().c_str());
+        stop_thread->SetStopInfo(stop_info);
+    }
 }
 
 Error
 ProcessWinMiniDump::DoDestroy()
 {
     return Error();
 }
 
ProcessWinMiniDump::MapMiniDumpIntoMemory(const char *file)
 
     return error;
 }
 
 
 ArchSpec
 ProcessWinMiniDump::DetermineArchitecture()
 {
-    assert(m_data_up != nullptr);
-    assert(m_data_up->m_base_addr != 0);
-
-    MINIDUMP_DIRECTORY *dir = nullptr;
-    void *ptr = nullptr;
-    ULONG size = 0;
-    if (::MiniDumpReadDumpStream(m_data_up->m_base_addr, SystemInfoStream, &dir, &ptr, &size))
-    {
-        assert(dir->StreamType == SystemInfoStream);
-        assert(size == dir->Location.DataSize);
-        assert(ptr == static_cast<void*>(static_cast<char*>(m_data_up->m_base_addr) + dir->Location.Rva));
-        auto system_info_ptr = static_cast<const MINIDUMP_SYSTEM_INFO *>(ptr);
+    size_t size = 0;
+    auto system_info_ptr = static_cast<const MINIDUMP_SYSTEM_INFO *>(FindDumpStream(SystemInfoStream, &size));
+    if (system_info_ptr)
+    {
         switch (system_info_ptr->ProcessorArchitecture)
         {
         case PROCESSOR_ARCHITECTURE_INTEL:
             return ArchSpec(eArchTypeCOFF, IMAGE_FILE_MACHINE_I386, LLDB_INVALID_CPUTYPE);
         case PROCESSOR_ARCHITECTURE_AMD64:
             return ArchSpec(eArchTypeCOFF, IMAGE_FILE_MACHINE_AMD64, LLDB_INVALID_CPUTYPE);
         default:
             break;
         }
     }
 
     return ArchSpec();  // invalid or unknown
 }
+
+void
+ProcessWinMiniDump::ReadExceptionRecord() {
+    size_t size = 0;
+    auto exception_stream_ptr = static_cast<MINIDUMP_EXCEPTION_STREAM*>(FindDumpStream(ExceptionStream, &size));
+    if (exception_stream_ptr)
+    {
+        m_data_up->m_exception_sp.reset(new ExceptionRecord(exception_stream_ptr->ExceptionRecord, exception_stream_ptr->ThreadId));
+    }
+}
+
+void *
+ProcessWinMiniDump::FindDumpStream(unsigned stream_number, size_t *size_out) {
+    void *stream = nullptr;
+    *size_out = 0;
+
+    assert(m_data_up != nullptr);
+    assert(m_data_up->m_base_addr != 0);
+
+    MINIDUMP_DIRECTORY *dir = nullptr;
+    if (::MiniDumpReadDumpStream(m_data_up->m_base_addr, stream_number, &dir, nullptr, nullptr) &&
+        dir != nullptr && dir->Location.DataSize > 0)
+    {
+        assert(dir->StreamType == stream_number);
+        *size_out = dir->Location.DataSize;
+        stream = static_cast<void*>(static_cast<char*>(m_data_up->m_base_addr) + dir->Location.Rva);
+    }
+
+    return stream;
+}