[lldb] Add support in Status::AsCString to retrieve win32 system error strings

[aleksandr.urakov]

Otherwise LGTM!

unittests/Utility/StatusTest.cpp

68–74

I'm not sure, can we rely on the fact that messages are the same in different versions of Windows?

[asmith]

unittests/Utility/StatusTest.cpp

68–74

I don't think the errors are different but I don't have old versions of Windows setup to test. Everyone should be on Win10 right :-) I'll keep an eye on the buildbots after I commit.

source/Utility/Status.cpp

 #include <cstdarg>
 #include <string> // for string
 #include <system_error>
 
 #ifdef __APPLE__
 #include <mach/mach.h>
 #endif
 
+#ifdef _WIN32
+#include <windows.h>
+#endif
 #include <stdint.h> // for uint32_t
 
 namespace llvm {
 class raw_ostream;
 }
 
 using namespace lldb;
 using namespace lldb_private;
const Status &Status::operator=(llvm::Error error) {
 
   return *this;
 }
 
 llvm::Error Status::ToError() const {
   if (Success())
     return llvm::Error::success();
   if (m_type == ErrorType::eErrorTypePOSIX)
-    return llvm::errorCodeToError(std::error_code(m_code, std::generic_category()));
+    return llvm::errorCodeToError(
+        std::error_code(m_code, std::generic_category()));
   return llvm::make_error<llvm::StringError>(AsCString(),
                                              llvm::inconvertibleErrorCode());
 }
 
 //----------------------------------------------------------------------
 // Assignment operator
 //----------------------------------------------------------------------
 const Status &Status::operator=(const Status &rhs) {
   if (this != &rhs) {
     m_code = rhs.m_code;
     m_type = rhs.m_type;
     m_string = rhs.m_string;
   }
   return *this;
 }
 
 Status::~Status() = default;
 
+#ifdef _WIN32
+static std::string RetrieveWin32ErrorString(uint32_t error_code) {
+  char *buffer = nullptr;
+  std::string message;
+  // Retrieve win32 system error.
+  if (::FormatMessageA(
+          FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+              FORMAT_MESSAGE_MAX_WIDTH_MASK,
+          NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+          (LPSTR)&buffer, 0, NULL)) {
+    message.assign(buffer);
+    ::LocalFree(buffer);
+  }
+  return message;
+}
+#endif
+
 //----------------------------------------------------------------------
 // Get the error value as a NULL C string. The error string will be fetched and
 // cached on demand. The cached error string value will remain until the error
 // value is changed or cleared.
 //----------------------------------------------------------------------
 const char *Status::AsCString(const char *default_error_str) const {
   if (Success())
     return nullptr;
 
   if (m_string.empty()) {
     switch (m_type) {
     case eErrorTypeMachKernel:
 #if defined(__APPLE__)
       if (const char *s = ::mach_error_string(m_code))
         m_string.assign(s);
 #endif
       break;
 
     case eErrorTypePOSIX:
       m_string = llvm::sys::StrError(m_code);
       break;
 
+    case eErrorTypeWin32:
+#if defined(_WIN32)
+      m_string = RetrieveWin32ErrorString(m_code);
+#endif
+      break;
+
     default:
       break;
     }
   }
   if (m_string.empty()) {
     if (default_error_str)
       m_string.assign(default_error_str);
     else

unittests/Utility/StatusTest.cpp

 //===-- StatusTest.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/Status.h"
 #include "gtest/gtest.h"
 
+#ifdef _WIN32
+#include <winerror.h>
+#endif
+
 using namespace lldb_private;
 using namespace lldb;
 
 TEST(StatusTest, Formatv) {
   EXPECT_EQ("", llvm::formatv("{0}", Status()).str());
   EXPECT_EQ("Hello Status", llvm::formatv("{0}", Status("Hello Status")).str());
   EXPECT_EQ("Hello", llvm::formatv("{0:5}", Status("Hello Error")).str());
 }
TEST(StatusTest, ErrorConversion) {
   std::error_code ec = llvm::errorToErrorCode(std::move(eagain));
   EXPECT_EQ(EAGAIN, ec.value());
   EXPECT_EQ(std::generic_category(), ec.category());
 
   llvm::Error foo = Status("foo").ToError();
   EXPECT_TRUE(bool(foo));
   EXPECT_EQ("foo", llvm::toString(std::move(foo)));
 }
+
+#ifdef _WIN32
+TEST(StatusTest, ErrorWin32) {
+  auto success = Status(NO_ERROR, ErrorType::eErrorTypeWin32);
+  EXPECT_STREQ(NULL, success.AsCString());
+  EXPECT_FALSE(success.ToError());
+  EXPECT_TRUE(success.Success());
+
+  auto s = Status(ERROR_ACCESS_DENIED, ErrorType::eErrorTypeWin32);
+  EXPECT_TRUE(s.Fail());
+  EXPECT_STREQ("Access is denied. ", s.AsCString());
+
+  s.SetError(ERROR_IPSEC_IKE_TIMED_OUT, ErrorType::eErrorTypeWin32);
+  EXPECT_STREQ("Negotiation timed out ", s.AsCString());
+
+  s.SetError(16000, ErrorType::eErrorTypeWin32);
+  EXPECT_STREQ("unknown error", s.AsCString());
+}
+#endif