[lldbsuite, windows] Don't crash LLDB when we try to retrieve a register on Windows

[stella.stamenova]

Summary

1. When ReadRegister is called with a null register into on Windows, rather than crashing due to an access violation, simply return false. Not all registers and properties will be read or calculated correctly, but that is consistent with other platforms that also return false in that case
2. Update a couple of tests to reference pr37995 as their reason for failure since it is much more accurate. Support for floating point registers doesn't exist on Windows at all, rather than having issues.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/register/intel_avx/TestYMMRegister.py

class TestYMMRegister(TestBase):
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfFreeBSD
     @skipIfiOSSimulator
     @skipIfTargetAndroid()
     @skipIf(archs=no_match(['i386', 'x86_64']))
     @expectedFailureAll(oslist=["linux"], bugnumber="rdar://30523153")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37995")
     def test(self):
         self.build(dictionary={"CFLAGS_EXTRAS": "-march=haswell"})
         self.setTearDownCleanup()
 
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
 
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/register/register_command/TestRegisters.py

def test_register_commands(self):
             substrs=['invalid register set index: 4'],
             error=True)
 
     @skipIfiOSSimulator
     # Writing of mxcsr register fails, presumably due to a kernel/hardware
     # problem
     @skipIfTargetAndroid(archs=["i386"])
     @skipIf(archs=no_match(['amd64', 'arm', 'i386', 'x86_64']))
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37995")
     def test_fp_register_write(self):
         """Test commands that write to registers, in particular floating-point registers."""
         self.build()
         self.fp_register_write()
 
     @skipIfiOSSimulator
     # "register read fstat" always return 0xffff
     @expectedFailureAndroid(archs=["i386"])
     @skipIfFreeBSD  # llvm.org/pr25057
     @skipIf(archs=no_match(['amd64', 'i386', 'x86_64']))
     @skipIfOutOfTreeDebugserver
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37995")
     def test_fp_special_purpose_register_read(self):
         """Test commands that read fpu special purpose registers."""
         self.build()
         self.fp_special_purpose_register_read()
 
     @skipIfiOSSimulator
     @skipIf(archs=no_match(['amd64', 'arm', 'i386', 'x86_64']))
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/trivial_abi/TestTrivialABI.py

 """
 Test that we work properly with classes with the trivial_abi attribute
 """
 
 from __future__ import print_function
 
 
 import os
 import time
 import re
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-from lldbsuite.test import decorators
+from lldbsuite.test import lldbutil
+
 
 class TestTrivialABI(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
-
     NO_DEBUG_INFO_TESTCASE = True
 
-    @decorators.skipUnlessSupportedTypeAttribute("trivial_abi")
+    @skipUnlessSupportedTypeAttribute("trivial_abi")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37995")
     def test_call_trivial(self):
         """Test that we can print a variable & call a function with a trivial ABI class."""
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.cpp")
         self.expr_test(True)
 
-    @decorators.skipUnlessSupportedTypeAttribute("trivial_abi")
-    @decorators.expectedFailureAll(bugnumber="llvm.org/pr36870")
+    @skipUnlessSupportedTypeAttribute("trivial_abi")
+    @expectedFailureAll(bugnumber="llvm.org/pr36870")
     def test_call_nontrivial(self):
         """Test that we can print a variable & call a function on the same class w/o the trivial ABI marker."""
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.cpp")
         self.expr_test(False)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
     def check_value(self, test_var, ivar_value):
         self.assertTrue(test_var.GetError().Success(), "Invalid valobj: %s"%(test_var.GetError().GetCString()))
         ivar = test_var.GetChildMemberWithName("ivar")
         self.assertTrue(test_var.GetError().Success(), "Failed to fetch ivar")
         self.assertEqual(ivar_value, ivar.GetValueAsSigned(), "Got the right value for ivar")
-        
     def check_frame(self, thread):
         frame = thread.frames[0]
         inVal_var = frame.FindVariable("inVal")
         self.check_value(inVal_var, 10)
 
         options = lldb.SBExpressionOptions()
         inVal_expr = frame.EvaluateExpression("inVal", options)
         self.check_value(inVal_expr, 10)
         
         thread.StepOut()
         outVal_ret = thread.GetStopReturnValue()
         self.check_value(outVal_ret, 30)
-        
     def expr_test(self, trivial):
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                    "Set a breakpoint here", self.main_source_file) 
 
         # Stop in a function that takes a trivial value, and try both frame var & expr to get its value:
         if trivial:
             self.check_frame(thread)
             return
 
         # Now continue to the same thing without the trivial_abi and see if we get that right:
         threads = lldbutil.continue_to_breakpoint(process, bkpt)
         self.assertEqual(len(threads), 1, "Hit my breakpoint the second time.")
 
         self.check_frame(threads[0])
-        
-

lldb/trunk/source/Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.cpp

const RegisterSet *RegisterContextWindows_x64::GetRegisterSet(size_t reg_set) {
   return &g_register_sets[reg_set];
 }
 
 bool RegisterContextWindows_x64::ReadRegister(const RegisterInfo *reg_info,
                                               RegisterValue &reg_value) {
   if (!CacheAllRegisterValues())
     return false;
 
+  if (reg_info == nullptr)
+    return false;
+
   switch (reg_info->kinds[eRegisterKindLLDB]) {
   case lldb_rax_x86_64:
     reg_value.SetUInt64(m_context.Rax);
     break;
   case lldb_rbx_x86_64:
     reg_value.SetUInt64(m_context.Rbx);
     break;
   case lldb_rcx_x86_64:

lldb/trunk/source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp

const RegisterSet *RegisterContextWindows_x86::GetRegisterSet(size_t reg_set) {
   return &g_register_sets[reg_set];
 }
 
 bool RegisterContextWindows_x86::ReadRegister(const RegisterInfo *reg_info,
                                               RegisterValue &reg_value) {
   if (!CacheAllRegisterValues())
     return false;
 
+  if (reg_info == nullptr)
+    return false;
+
   uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
   switch (reg) {
   case lldb_eax_i386:
     return ReadRegisterHelper(CONTEXT_INTEGER, "EAX", m_context.Eax, reg_value);
   case lldb_ebx_i386:
     return ReadRegisterHelper(CONTEXT_INTEGER, "EBX", m_context.Ebx, reg_value);
   case lldb_ecx_i386:
     return ReadRegisterHelper(CONTEXT_INTEGER, "ECX", m_context.Ecx, reg_value);