Disable windows-only minidump plugin

[labath]

Summary

This commit disables the windows-only minidump plugin and enables the new
cross-platform plugin for windows minidump files. Test decorators are adjusted to
reflect that: windows minidump tests can now run on all platforms. The exception
is the tests that create minidump files, as that functionality is not available
yet.

I've checked that this works on windows and linux. If it goes well on the bots,
I'll delete the old plugin in a follow-up.

[amccarth]

I started testing the new plugin on Windows yesterday, and it doesn't work (all the tests fail). I'm planning to debug today, and, once I get it working, I'd be happy to switch it over.

[labath]

In D26393#589363, @amccarth wrote:

I started testing the new plugin on Windows yesterday, and it doesn't work (all the tests fail). I'm planning to debug today, and, once I get it working, I'd be happy to switch it over.

Interesting. It seemed to work fine for me. How did you test that?

[amccarth]

In D26393#589421, @labath wrote:

In D26393#589363, @amccarth wrote:

I started testing the new plugin on Windows yesterday, and it doesn't work (all the tests fail). I'm planning to debug today, and, once I get it working, I'd be happy to switch it over.

Interesting. It seemed to work fine for me. How did you test that?

I made changes very similar to this patch and ran check-lldb. The tests for the new minidump plugin passed, but the original Windows ones all failed, apparently because it cannot find any threads in the dumps. I'll have more time to look at it this afternoon.

[amccarth]

Problem was at my end. This patch works fine for me now.

I'm planning to do some more minidump work, so I'd be happy to take over with eliminating the old Windows-specific implementation.

[labath]

Yeah, feel free to take over. I was not planning to do any more work here - just wanted to wrap things up. I am going to commit this then, and leave the rest to you.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump/TestMiniDump.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class MiniDumpTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
-    @skipUnlessWindows  # for now mini-dump debugging is limited to Windows hosts
-    @no_debug_info_test
     def test_process_info_in_mini_dump(self):
         """Test that lldb can read the process information from the minidump."""
         # target create -c fizzbuzz_no_heap.dmp
         self.dbg.CreateTarget("")
         self.target = self.dbg.GetSelectedTarget()
         self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
         self.assertTrue(self.process, PROCESS_IS_VALID)
         self.assertEqual(self.process.GetNumThreads(), 1)
         self.assertEqual(self.process.GetProcessID(), 4440)
 
-    @skipUnlessWindows  # for now mini-dump debugging is limited to Windows hosts
-    @no_debug_info_test
     def test_thread_info_in_mini_dump(self):
         """Test that lldb can read the thread information from the minidump."""
         # target create -c fizzbuzz_no_heap.dmp
         self.dbg.CreateTarget("")
         self.target = self.dbg.GetSelectedTarget()
         self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
         # This process crashed due to an access violation (0xc0000005) in its
         # one and only thread.
         self.assertEqual(self.process.GetNumThreads(), 1)
         thread = self.process.GetThreadAtIndex(0)
         self.assertEqual(thread.GetStopReason(), lldb.eStopReasonException)
         stop_description = thread.GetStopDescription(256)
         self.assertTrue("0xc0000005" in stop_description)
 
-    @skipUnlessWindows  # for now mini-dump debugging is limited to Windows hosts
-    @no_debug_info_test
     def test_stack_info_in_mini_dump(self):
         """Test that we can see a trivial stack in a VS-generate mini dump."""
         # target create -c fizzbuzz_no_heap.dmp
         self.dbg.CreateTarget("")
         self.target = self.dbg.GetSelectedTarget()
         self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
         self.assertEqual(self.process.GetNumThreads(), 1)
         thread = self.process.GetThreadAtIndex(0)
         # The crash is in main, so there should be one frame on the stack.
         self.assertEqual(thread.GetNumFrames(), 1)
         frame = thread.GetFrameAtIndex(0)
         self.assertTrue(frame.IsValid())
         pc = frame.GetPC()
         eip = frame.FindRegister("pc")
         self.assertTrue(eip.IsValid())
         self.assertEqual(pc, eip.GetValueAsUnsigned())
 
-    @skipUnlessWindows
-    @not_remote_testsuite_ready
+    @skipUnlessWindows # Minidump saving works only on windows
     def test_deeper_stack_in_mini_dump(self):
         """Test that we can examine a more interesting stack in a mini dump."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         core = os.path.join(os.getcwd(), "core.dmp")
         try:
             # Set a breakpoint and capture a mini dump.
             target = self.dbg.CreateTarget(exe)
def test_deeper_stack_in_mini_dump(self):
                 self.assertTrue(name in function_name)
 
         finally:
             # Clean up the mini dump file.
             self.assertTrue(self.dbg.DeleteTarget(target))
             if (os.path.isfile(core)):
                 os.unlink(core)
 
-    @skipUnlessWindows
-    @not_remote_testsuite_ready
+    @skipUnlessWindows # Minidump saving works only on windows
     def test_local_variables_in_mini_dump(self):
         """Test that we can examine local variables in a mini dump."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         core = os.path.join(os.getcwd(), "core.dmp")
         try:
             # Set a breakpoint and capture a mini dump.
             target = self.dbg.CreateTarget(exe)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/wow64_minidump/TestWow64MiniDump.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class Wow64MiniDumpTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
-    @skipUnlessWindows  # for now mini-dump debugging is limited to Windows hosts
-    @no_debug_info_test
     def test_wow64_mini_dump(self):
         """Test that lldb can read the process information from the minidump."""
         # target create -c fizzbuzz_wow64.dmp
         target = self.dbg.CreateTarget("")
         process = target.LoadCore("fizzbuzz_wow64.dmp")
         self.assertTrue(process, PROCESS_IS_VALID)
         self.assertEqual(process.GetNumThreads(), 1)
         self.assertEqual(process.GetProcessID(), 0x1E9C)
 
-    @skipUnlessWindows  # for now mini-dump debugging is limited to Windows hosts
-    @no_debug_info_test
     def test_thread_info_in_wow64_mini_dump(self):
         """Test that lldb can read the thread information from the minidump."""
         # target create -c fizzbuzz_wow64.dmp
         target = self.dbg.CreateTarget("")
         process = target.LoadCore("fizzbuzz_wow64.dmp")
         # This process crashed due to an access violation (0xc0000005), but the
         # minidump doesn't have an exception record--perhaps the crash handler
         # ate it.
         # TODO:  See if we can recover the exception information from the TEB,
         # which, according to Windbg, has a pointer to an exception list.
 
         # In the dump, none of the threads are stopped, so we cannot use
         # lldbutil.get_stopped_thread.
         thread = process.GetThreadAtIndex(0)
         self.assertEqual(thread.GetStopReason(), lldb.eStopReasonNone)
 
-    @skipUnlessWindows  # for now mini-dump debugging is limited to Windows hosts
-    @no_debug_info_test
     def test_stack_info_in_wow64_mini_dump(self):
         """Test that we can see a trivial stack in a VS-generate mini dump."""
         # target create -c fizzbuzz_no_heap.dmp
         target = self.dbg.CreateTarget("")
         process = target.LoadCore("fizzbuzz_wow64.dmp")
         self.assertGreaterEqual(process.GetNumThreads(), 1)
         # This process crashed due to an access violation (0xc0000005), but the
         # minidump doesn't have an exception record--perhaps the crash handler

lldb/trunk/source/API/SystemInitializerFull.cpp

 #include "Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.h"
 
 #if defined(__FreeBSD__)
 #include "Plugins/Process/FreeBSD/ProcessFreeBSD.h"
 #endif
 
 #if defined(_MSC_VER)
 #include "Plugins/Process/Windows/Live/ProcessWindowsLive.h"
-#include "Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h"
 #include "lldb/Host/windows/windows.h"
 #endif
 
 #include "llvm/Support/TargetSelect.h"
 
 #include <string>
 
 using namespace lldb_private;
#endif
   ABISysV_mips::Initialize();
   ABISysV_mips64::Initialize();
   ABISysV_s390x::Initialize();
   DisassemblerLLVMC::Initialize();
 
   JITLoaderGDB::Initialize();
   ProcessElfCore::Initialize();
   minidump::ProcessMinidump::Initialize();
-#if defined(_MSC_VER)
-  ProcessWinMiniDump::Initialize();
-#endif
   MemoryHistoryASan::Initialize();
   AddressSanitizerRuntime::Initialize();
   ThreadSanitizerRuntime::Initialize();
 
   SymbolVendorELF::Initialize();
   SymbolFileDWARF::Initialize();
   SymbolFilePDB::Initialize();
   SymbolFileSymtab::Initialize();
void SystemInitializerFull::Terminate() {
   ABISysV_mips::Terminate();
   ABISysV_mips64::Terminate();
   ABISysV_s390x::Terminate();
   DisassemblerLLVMC::Terminate();
 
   JITLoaderGDB::Terminate();
   ProcessElfCore::Terminate();
   minidump::ProcessMinidump::Terminate();
-#if defined(_MSC_VER)
-  ProcessWinMiniDump::Terminate();
-#endif
   MemoryHistoryASan::Terminate();
   AddressSanitizerRuntime::Terminate();
   ThreadSanitizerRuntime::Terminate();
   SymbolVendorELF::Terminate();
   SymbolFileDWARF::Terminate();
   SymbolFilePDB::Terminate();
   SymbolFileSymtab::Terminate();
   UnwindAssembly_x86::Terminate();

lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.cpp

lldb::ProcessSP ProcessMinidump::CreateInstance(lldb::TargetSP target_sp,
   const MinidumpHeader *header = MinidumpHeader::Parse(header_data);
 
   if (data_sp->GetByteSize() != header_size || header == nullptr)
     return nullptr;
 
   lldb::DataBufferSP all_data_sp(crash_file->MemoryMapFileContents());
   auto minidump_parser = MinidumpParser::Create(all_data_sp);
   // check if the parser object is valid
-  // skip if the Minidump file is Windows generated, because we are still
-  // work-in-progress
-  if (!minidump_parser ||
-      minidump_parser->GetArchitecture().GetTriple().getOS() ==
-          llvm::Triple::OSType::Win32)
+  if (!minidump_parser)
     return nullptr;
 
   return std::make_shared<ProcessMinidump>(target_sp, listener_sp, *crash_file,
                                            minidump_parser.getValue());
 }
 
 bool ProcessMinidump::CanDebug(lldb::TargetSP target_sp,
                                bool plugin_specified_by_name) {