Implement GetMemoryRegionInfo for mini dumps.

[amccarth]

Summary

Also tweaked process save-core to include the memory info list so that we can see the regions in the list.

There are no commands or SBInterfaces yet that make it possible to test this directly, but I'll look for an opportunity to do so as I continue to work toward working backtraces from mini dumps.

[amccarth]

Ran clang-format and removed initialization of a local variable that was no longer used.

Note that clang-format re-ordered the include because the change added one include.

[zturner]

source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp

312 ↗

(On Diff #41828)

ProcessWindowsLive::GetMemoryRegionInfo already has this same logic built in. Would it be worth putting something in Plugins/Process/Windows/Common that does this conversion and then calling into it from both here and ProcessWindowsLive?

source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h

87–88 ↗

(On Diff #41828)

Oh yea, I forgot to mention. clang-format screws this up currently. You'll have to fix this part manually :(

I keep meaning to go look at clang-format's source and make it support return type on new line, but so far you have to fix these manually.

[amccarth]

Addressed comments.

[amccarth]

Address comments.

Factored the decoding of the page protection bits to share that logic between the live and mini dump debugging.

[amccarth]

After discussion with Zach, we concluded that his original logic for IsPageReadable was better.

lldb/trunk/source/Plugins/ObjectFile/PECOFF/WindowsMiniDump.cpp

#ifdef _WIN32
     wide_name.resize(file_name.size() + 1);
     char * result_ptr = reinterpret_cast<char *>(&wide_name[0]);
     const UTF8 *error_ptr = nullptr;
     if (!llvm::ConvertUTF8toWide(sizeof(wchar_t), file_name, result_ptr, error_ptr)) {
         error.SetErrorString("cannot convert file name");
         return false;
     }
     HANDLE file_handle = ::CreateFileW(wide_name.c_str(), GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
-    const auto result = ::MiniDumpWriteDump(process_handle, process_sp->GetID(), file_handle, MiniDumpNormal, NULL, NULL, NULL);
+    const auto result = ::MiniDumpWriteDump(process_handle, process_sp->GetID(), file_handle,
+                                            MiniDumpWithFullMemoryInfo, NULL, NULL, NULL);
     ::CloseHandle(file_handle);
     ::CloseHandle(process_handle);
     if (!result)
     {
         error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
         return false;
     }
     return true;
 #endif
     return false;
 }
 
 }  // namesapce lldb_private

lldb/trunk/source/Plugins/Process/Windows/Common/ProcessWindows.h

public:
 
     ~ProcessWindows();
 
     size_t GetSTDOUT(char *buf, size_t buf_size, lldb_private::Error &error) override;
     size_t GetSTDERR(char *buf, size_t buf_size, lldb_private::Error &error) override;
     size_t PutSTDIN(const char *buf, size_t buf_size, lldb_private::Error &error) override;
 
     lldb::addr_t GetImageInfoAddress() override;
+
+protected:
+    // These decode the page protection bits.
+    static bool
+    IsPageReadable(uint32_t protect);
+
+    static bool
+    IsPageWritable(uint32_t protect);
+
+    static bool
+    IsPageExecutable(uint32_t protect);
 };
 
 }
 
 #endif  // liblldb_Plugins_Process_Windows_Common_ProcessWindows_H_

lldb/trunk/source/Plugins/Process/Windows/Common/ProcessWindows.cpp

 #include "ProcessWindows.h"
 
 // Other libraries and framework includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/State.h"
+#include "lldb/Host/windows/windows.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace lldb_private
ProcessWindows::GetImageInfoAddress()
     ObjectFile *obj_file = target.GetExecutableModule()->GetObjectFile();
     Address addr = obj_file->GetImageInfoAddress(&target);
     if (addr.IsValid())
         return addr.GetLoadAddress(&target);
     else
         return LLDB_INVALID_ADDRESS;
 }
 
+// The Windows page protection bits are NOT independent masks that can be bitwise-ORed
+// together.  For example, PAGE_EXECUTE_READ is not (PAGE_EXECUTE | PAGE_READ).
+// To test for an access type, it's necessary to test for any of the bits that provide
+// that access type.
+bool
+ProcessWindows::IsPageReadable(uint32_t protect)
+{
+    return (protect & PAGE_NOACCESS) == 0;
+}
+
+bool
+ProcessWindows::IsPageWritable(uint32_t protect)
+{
+    return (protect & (PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY | PAGE_READWRITE | PAGE_WRITECOPY)) != 0;
+}
+
+bool
+ProcessWindows::IsPageExecutable(uint32_t protect)
+{
+    return (protect & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) != 0;
+}
+
 }

lldb/trunk/source/Plugins/Process/Windows/Live/ProcessWindowsLive.cpp

ProcessWindowsLive::GetMemoryRegionInfo(lldb::addr_t vm_addr, MemoryRegionInfo &info)
     if (result == 0)
     {
         error.SetError(::GetLastError(), eErrorTypeWin32);
         WINERR_IFALL(WINDOWS_LOG_MEMORY,
                      "VirtualQueryEx returned error %u while getting memory region info for address 0x%I64x",
                      error.GetError(), vm_addr);
         return error;
     }
-    bool readable = !(mem_info.Protect & PAGE_NOACCESS);
-    bool executable = mem_info.Protect & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY);
-    bool writable = mem_info.Protect & (PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY | PAGE_READWRITE | PAGE_WRITECOPY);
+    const bool readable = IsPageReadable(mem_info.Protect);
+    const bool executable = IsPageExecutable(mem_info.Protect);
+    const bool writable = IsPageWritable(mem_info.Protect);
     info.SetReadable(readable ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
     info.SetExecutable(executable ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
     info.SetWritable(writable ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
+
     error.SetError(::GetLastError(), eErrorTypeWin32);
     WINLOGV_IFALL(WINDOWS_LOG_MEMORY, "Memory region info for address 0x%I64u: readable=%s, executable=%s, writable=%s",
                   BOOL_STR(readable), BOOL_STR(executable), BOOL_STR(writable));
     return error;
 }
 
 bool
 ProcessWindowsLive::CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_name)

lldb/trunk/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h

 #include "lldb/Target/Process.h"
 
 #include "Plugins/Process/Windows/Common/ProcessWindows.h"
 
 struct ThreadData;
 
 class ProcessWinMiniDump : public lldb_private::ProcessWindows
 {
   public:
     static lldb::ProcessSP
     CreateInstance (lldb::TargetSP target_sp,
                     lldb_private::Listener &listener,
                     const lldb_private::FileSpec *crash_file_path);
 
     static void
     Initialize();
 
public:
     ReadMemory(lldb::addr_t addr, void *buf, size_t size, lldb_private::Error &error) override;
 
     size_t
     DoReadMemory(lldb::addr_t addr, void *buf, size_t size, lldb_private::Error &error) override;
 
     lldb_private::ArchSpec
     GetArchitecture();
 
+    lldb_private::Error
+    GetMemoryRegionInfo(lldb::addr_t load_addr, lldb_private::MemoryRegionInfo &range_info) override;
+
   protected:
     void
     Clear();
 
     bool
     UpdateThreadList(lldb_private::ThreadList &old_thread_list,
                      lldb_private::ThreadList &new_thread_list) override;
 
   private:
     // Describes a range of memory captured in the mini dump.
     struct Range {
       lldb::addr_t start;  // virtual address of the beginning of the range
       size_t size;         // size of the range in bytes
       const uint8_t *ptr;  // absolute pointer to the first byte of the range
     };
 
     // If the mini dump has a memory range that contains the desired address, it

lldb/trunk/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp

 #include "lldb/Host/windows/windows.h"
 #include <DbgHelp.h>
 
 #include <assert.h>
 #include <stdlib.h>
 #include <memory>
 #include <mutex>
 
-#include "lldb/Core/PluginManager.h"
+#include "Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h"
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/State.h"
-#include "lldb/Core/DataBufferHeap.h"
-#include "lldb/Core/Log.h"
+#include "lldb/Target/DynamicLoader.h"
+#include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/UnixSignals.h"
+#include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Support/ConvertUTF.h"
-#include "Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h"
 
 #include "ExceptionRecord.h"
 #include "ThreadWinMiniDump.h"
 
 using namespace lldb_private;
 
 namespace
 {
ProcessWinMiniDump::DoReadMemory(lldb::addr_t addr, void *buf, size_t size, Error &error)
     // (addr) and the current range.  Figure out where the overlap begins and
     // how much overlap there is, then copy it to the destination buffer.
     const size_t offset = range.start - addr;
     const size_t overlap = std::min(size, range.size - offset);
     std::memcpy(buf, range.ptr + offset, overlap);
     return overlap;
 }
 
+Error
+ProcessWinMiniDump::GetMemoryRegionInfo(lldb::addr_t load_addr, lldb_private::MemoryRegionInfo &info)
+{
+    Error error;
+    size_t size;
+    const auto list = reinterpret_cast<const MINIDUMP_MEMORY_INFO_LIST *>(FindDumpStream(MemoryInfoListStream, &size));
+    if (list == nullptr || size < sizeof(MINIDUMP_MEMORY_INFO_LIST))
+    {
+        error.SetErrorString("the mini dump contains no memory range information");
+        return error;
+    }
+
+    if (list->SizeOfEntry < sizeof(MINIDUMP_MEMORY_INFO))
+    {
+        error.SetErrorString("the entries in the mini dump memory info list are smaller than expected");
+        return error;
+    }
+
+    if (size < list->SizeOfHeader + list->SizeOfEntry * list->NumberOfEntries)
+    {
+        error.SetErrorString("the mini dump memory info list is incomplete");
+        return error;
+    }
+
+    for (int i = 0; i < list->NumberOfEntries; ++i)
+    {
+        const auto entry = reinterpret_cast<const MINIDUMP_MEMORY_INFO *>(reinterpret_cast<const char *>(list) +
+                                                                          list->SizeOfHeader + i * list->SizeOfEntry);
+        const auto head = entry->BaseAddress;
+        const auto tail = head + entry->RegionSize;
+        if (head <= load_addr && load_addr < tail)
+        {
+            info.SetReadable(IsPageReadable(entry->Protect) ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
+            info.SetWritable(IsPageWritable(entry->Protect) ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
+            info.SetExecutable(IsPageExecutable(entry->Protect) ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
+            return error;
+        }
+    }
+    // Note that the memory info list doesn't seem to contain ranges in kernel space,
+    // so if you're walking a stack that has kernel frames, the stack may appear
+    // truncated.
+    error.SetErrorString("address is not in a known range");
+    return error;
+}
+
 void
 ProcessWinMiniDump::Clear()
 {
     m_thread_list.Clear();
 }
 
 void
 ProcessWinMiniDump::Initialize()