*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 217 insertions, 260 deletions

diff --git a/lldb/source/Host/windows/PipeWindows.cpp b/lldb/source/Host/windows/PipeWindows.cpp
index 6ed8d0e83f3..b63f3bc4eed 100644
--- a/lldb/source/Host/windows/PipeWindows.cpp
+++ b/lldb/source/Host/windows/PipeWindows.cpp
@@ -23,316 +23,273 @@
 using namespace lldb;
 using namespace lldb_private;
 
-namespace
-{
+namespace {
 std::atomic<uint32_t> g_pipe_serial(0);
 }
 
-PipeWindows::PipeWindows()
-{
-    m_read = INVALID_HANDLE_VALUE;
-    m_write = INVALID_HANDLE_VALUE;
+PipeWindows::PipeWindows() {
+  m_read = INVALID_HANDLE_VALUE;
+  m_write = INVALID_HANDLE_VALUE;
 
-    m_read_fd = -1;
-    m_write_fd = -1;
-    ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
-    ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
-}
-
-PipeWindows::~PipeWindows()
-{
-    Close();
+  m_read_fd = -1;
+  m_write_fd = -1;
+  ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
+  ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
 }
 
-Error
-PipeWindows::CreateNew(bool child_process_inherit)
-{
-    // Even for anonymous pipes, we open a named pipe.  This is because you cannot get
-    // overlapped i/o on Windows without using a named pipe.  So we synthesize a unique
-    // name.
-    uint32_t serial = g_pipe_serial.fetch_add(1);
-    std::string pipe_name;
-    llvm::raw_string_ostream pipe_name_stream(pipe_name);
-    pipe_name_stream << "lldb.pipe." << ::GetCurrentProcessId() << "." << serial;
-    pipe_name_stream.flush();
-
-    return CreateNew(pipe_name.c_str(), child_process_inherit);
+PipeWindows::~PipeWindows() { Close(); }
+
+Error PipeWindows::CreateNew(bool child_process_inherit) {
+  // Even for anonymous pipes, we open a named pipe.  This is because you cannot
+  // get
+  // overlapped i/o on Windows without using a named pipe.  So we synthesize a
+  // unique
+  // name.
+  uint32_t serial = g_pipe_serial.fetch_add(1);
+  std::string pipe_name;
+  llvm::raw_string_ostream pipe_name_stream(pipe_name);
+  pipe_name_stream << "lldb.pipe." << ::GetCurrentProcessId() << "." << serial;
+  pipe_name_stream.flush();
+
+  return CreateNew(pipe_name.c_str(), child_process_inherit);
 }
 
-Error
-PipeWindows::CreateNew(llvm::StringRef name, bool child_process_inherit)
-{
-    if (name.empty())
-        return Error(ERROR_INVALID_PARAMETER, eErrorTypeWin32);
-
-    if (CanRead() || CanWrite())
-        return Error(ERROR_ALREADY_EXISTS, eErrorTypeWin32);
-
-    std::string pipe_path = "\\\\.\\Pipe\\";
-    pipe_path.append(name);
-
-    // Always open for overlapped i/o.  We implement blocking manually in Read and Write.
-    DWORD read_mode = FILE_FLAG_OVERLAPPED;
-    m_read = ::CreateNamedPipeA(pipe_path.c_str(), PIPE_ACCESS_INBOUND | read_mode, PIPE_TYPE_BYTE | PIPE_WAIT, 1, 1024,
-                                1024, 120 * 1000, NULL);
-    if (INVALID_HANDLE_VALUE == m_read)
-        return Error(::GetLastError(), eErrorTypeWin32);
-    m_read_fd = _open_osfhandle((intptr_t)m_read, _O_RDONLY);
-    ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
-    m_read_overlapped.hEvent = ::CreateEvent(nullptr, TRUE, FALSE, nullptr);
-
-    // Open the write end of the pipe.
-    Error result = OpenNamedPipe(name, child_process_inherit, false);
-    if (!result.Success())
-    {
-        CloseReadFileDescriptor();
-        return result;
-    }
-
+Error PipeWindows::CreateNew(llvm::StringRef name, bool child_process_inherit) {
+  if (name.empty())
+    return Error(ERROR_INVALID_PARAMETER, eErrorTypeWin32);
+
+  if (CanRead() || CanWrite())
+    return Error(ERROR_ALREADY_EXISTS, eErrorTypeWin32);
+
+  std::string pipe_path = "\\\\.\\Pipe\\";
+  pipe_path.append(name);
+
+  // Always open for overlapped i/o.  We implement blocking manually in Read and
+  // Write.
+  DWORD read_mode = FILE_FLAG_OVERLAPPED;
+  m_read = ::CreateNamedPipeA(
+      pipe_path.c_str(), PIPE_ACCESS_INBOUND | read_mode,
+      PIPE_TYPE_BYTE | PIPE_WAIT, 1, 1024, 1024, 120 * 1000, NULL);
+  if (INVALID_HANDLE_VALUE == m_read)
+    return Error(::GetLastError(), eErrorTypeWin32);
+  m_read_fd = _open_osfhandle((intptr_t)m_read, _O_RDONLY);
+  ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
+  m_read_overlapped.hEvent = ::CreateEvent(nullptr, TRUE, FALSE, nullptr);
+
+  // Open the write end of the pipe.
+  Error result = OpenNamedPipe(name, child_process_inherit, false);
+  if (!result.Success()) {
+    CloseReadFileDescriptor();
     return result;
+  }
+
+  return result;
 }
 
-Error
-PipeWindows::CreateWithUniqueName(llvm::StringRef prefix, bool child_process_inherit, llvm::SmallVectorImpl<char>& name)
-{
-    llvm::SmallString<128> pipe_name;
-    Error error;
-    ::UUID unique_id;
-    RPC_CSTR unique_string;
-    RPC_STATUS status = ::UuidCreate(&unique_id);
-    if (status == RPC_S_OK || status == RPC_S_UUID_LOCAL_ONLY)
-        status = ::UuidToStringA(&unique_id, &unique_string);
-    if (status == RPC_S_OK)
-    {
-        pipe_name = prefix;
-        pipe_name += "-";
-        pipe_name += reinterpret_cast<char *>(unique_string);
-        ::RpcStringFreeA(&unique_string);
-        error = CreateNew(pipe_name, child_process_inherit);
-    }
-    else
-    {
-        error.SetError(status, eErrorTypeWin32);
-    }
-    if (error.Success())
-        name = pipe_name;
-    return error;
+Error PipeWindows::CreateWithUniqueName(llvm::StringRef prefix,
+                                        bool child_process_inherit,
+                                        llvm::SmallVectorImpl<char> &name) {
+  llvm::SmallString<128> pipe_name;
+  Error error;
+  ::UUID unique_id;
+  RPC_CSTR unique_string;
+  RPC_STATUS status = ::UuidCreate(&unique_id);
+  if (status == RPC_S_OK || status == RPC_S_UUID_LOCAL_ONLY)
+    status = ::UuidToStringA(&unique_id, &unique_string);
+  if (status == RPC_S_OK) {
+    pipe_name = prefix;
+    pipe_name += "-";
+    pipe_name += reinterpret_cast<char *>(unique_string);
+    ::RpcStringFreeA(&unique_string);
+    error = CreateNew(pipe_name, child_process_inherit);
+  } else {
+    error.SetError(status, eErrorTypeWin32);
+  }
+  if (error.Success())
+    name = pipe_name;
+  return error;
 }
 
-Error
-PipeWindows::OpenAsReader(llvm::StringRef name, bool child_process_inherit)
-{
-    if (CanRead() || CanWrite())
-        return Error(ERROR_ALREADY_EXISTS, eErrorTypeWin32);
+Error PipeWindows::OpenAsReader(llvm::StringRef name,
+                                bool child_process_inherit) {
+  if (CanRead() || CanWrite())
+    return Error(ERROR_ALREADY_EXISTS, eErrorTypeWin32);
 
-    return OpenNamedPipe(name, child_process_inherit, true);
+  return OpenNamedPipe(name, child_process_inherit, true);
 }
 
-Error
-PipeWindows::OpenAsWriterWithTimeout(llvm::StringRef name, bool child_process_inherit, const std::chrono::microseconds &timeout)
-{
-    if (CanRead() || CanWrite())
-        return Error(ERROR_ALREADY_EXISTS, eErrorTypeWin32);
+Error PipeWindows::OpenAsWriterWithTimeout(
+    llvm::StringRef name, bool child_process_inherit,
+    const std::chrono::microseconds &timeout) {
+  if (CanRead() || CanWrite())
+    return Error(ERROR_ALREADY_EXISTS, eErrorTypeWin32);
 
-    return OpenNamedPipe(name, child_process_inherit, false);
+  return OpenNamedPipe(name, child_process_inherit, false);
 }
 
-Error
-PipeWindows::OpenNamedPipe(llvm::StringRef name, bool child_process_inherit, bool is_read)
-{
-    if (name.empty())
-        return Error(ERROR_INVALID_PARAMETER, eErrorTypeWin32);
+Error PipeWindows::OpenNamedPipe(llvm::StringRef name,
+                                 bool child_process_inherit, bool is_read) {
+  if (name.empty())
+    return Error(ERROR_INVALID_PARAMETER, eErrorTypeWin32);
 
-    assert(is_read ? !CanRead() : !CanWrite());
+  assert(is_read ? !CanRead() : !CanWrite());
 
-    SECURITY_ATTRIBUTES attributes = {0};
-    attributes.bInheritHandle = child_process_inherit;
+  SECURITY_ATTRIBUTES attributes = {0};
+  attributes.bInheritHandle = child_process_inherit;
 
-    std::string pipe_path = "\\\\.\\Pipe\\";
-    pipe_path.append(name);
+  std::string pipe_path = "\\\\.\\Pipe\\";
+  pipe_path.append(name);
 
-    if (is_read)
-    {
-        m_read =
-            ::CreateFileA(pipe_path.c_str(), GENERIC_READ, 0, &attributes, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
-        if (INVALID_HANDLE_VALUE == m_read)
-            return Error(::GetLastError(), eErrorTypeWin32);
+  if (is_read) {
+    m_read = ::CreateFileA(pipe_path.c_str(), GENERIC_READ, 0, &attributes,
+                           OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
+    if (INVALID_HANDLE_VALUE == m_read)
+      return Error(::GetLastError(), eErrorTypeWin32);
 
-        m_read_fd = _open_osfhandle((intptr_t)m_read, _O_RDONLY);
+    m_read_fd = _open_osfhandle((intptr_t)m_read, _O_RDONLY);
 
-        ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
-        m_read_overlapped.hEvent = ::CreateEvent(nullptr, TRUE, FALSE, nullptr);
-    }
-    else
-    {
-        m_write =
-            ::CreateFileA(pipe_path.c_str(), GENERIC_WRITE, 0, &attributes, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
-        if (INVALID_HANDLE_VALUE == m_write)
-            return Error(::GetLastError(), eErrorTypeWin32);
+    ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
+    m_read_overlapped.hEvent = ::CreateEvent(nullptr, TRUE, FALSE, nullptr);
+  } else {
+    m_write = ::CreateFileA(pipe_path.c_str(), GENERIC_WRITE, 0, &attributes,
+                            OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
+    if (INVALID_HANDLE_VALUE == m_write)
+      return Error(::GetLastError(), eErrorTypeWin32);
 
-        m_write_fd = _open_osfhandle((intptr_t)m_write, _O_WRONLY);
+    m_write_fd = _open_osfhandle((intptr_t)m_write, _O_WRONLY);
 
-        ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
-    }
+    ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
+  }
 
-    return Error();
+  return Error();
 }
 
-int
-PipeWindows::GetReadFileDescriptor() const
-{
-    return m_read_fd;
-}
+int PipeWindows::GetReadFileDescriptor() const { return m_read_fd; }
 
-int
-PipeWindows::GetWriteFileDescriptor() const
-{
-    return m_write_fd;
-}
+int PipeWindows::GetWriteFileDescriptor() const { return m_write_fd; }
 
-int
-PipeWindows::ReleaseReadFileDescriptor()
-{
-    if (!CanRead())
-        return -1;
-    int result = m_read_fd;
-    m_read_fd = -1;
-    if (m_read_overlapped.hEvent)
-        ::CloseHandle(m_read_overlapped.hEvent);
-    m_read = INVALID_HANDLE_VALUE;
-    ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
-    return result;
+int PipeWindows::ReleaseReadFileDescriptor() {
+  if (!CanRead())
+    return -1;
+  int result = m_read_fd;
+  m_read_fd = -1;
+  if (m_read_overlapped.hEvent)
+    ::CloseHandle(m_read_overlapped.hEvent);
+  m_read = INVALID_HANDLE_VALUE;
+  ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
+  return result;
 }
 
-int
-PipeWindows::ReleaseWriteFileDescriptor()
-{
-    if (!CanWrite())
-        return -1;
-    int result = m_write_fd;
-    m_write_fd = -1;
-    m_write = INVALID_HANDLE_VALUE;
-    ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
-    return result;
+int PipeWindows::ReleaseWriteFileDescriptor() {
+  if (!CanWrite())
+    return -1;
+  int result = m_write_fd;
+  m_write_fd = -1;
+  m_write = INVALID_HANDLE_VALUE;
+  ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
+  return result;
 }
 
-void
-PipeWindows::CloseReadFileDescriptor()
-{
-    if (!CanRead())
-        return;
-
-    if (m_read_overlapped.hEvent)
-        ::CloseHandle(m_read_overlapped.hEvent);
-    _close(m_read_fd);
-    m_read = INVALID_HANDLE_VALUE;
-    m_read_fd = -1;
-    ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
+void PipeWindows::CloseReadFileDescriptor() {
+  if (!CanRead())
+    return;
+
+  if (m_read_overlapped.hEvent)
+    ::CloseHandle(m_read_overlapped.hEvent);
+  _close(m_read_fd);
+  m_read = INVALID_HANDLE_VALUE;
+  m_read_fd = -1;
+  ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
 }
 
-void
-PipeWindows::CloseWriteFileDescriptor()
-{
-    if (!CanWrite())
-        return;
+void PipeWindows::CloseWriteFileDescriptor() {
+  if (!CanWrite())
+    return;
 
-    _close(m_write_fd);
-    m_write = INVALID_HANDLE_VALUE;
-    m_write_fd = -1;
-    ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
+  _close(m_write_fd);
+  m_write = INVALID_HANDLE_VALUE;
+  m_write_fd = -1;
+  ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
 }
 
-void
-PipeWindows::Close()
-{
-    CloseReadFileDescriptor();
-    CloseWriteFileDescriptor();
+void PipeWindows::Close() {
+  CloseReadFileDescriptor();
+  CloseWriteFileDescriptor();
 }
 
-Error
-PipeWindows::Delete(llvm::StringRef name)
-{
-    return Error();
-}
+Error PipeWindows::Delete(llvm::StringRef name) { return Error(); }
 
-bool
-PipeWindows::CanRead() const
-{
-    return (m_read != INVALID_HANDLE_VALUE);
-}
+bool PipeWindows::CanRead() const { return (m_read != INVALID_HANDLE_VALUE); }
 
-bool
-PipeWindows::CanWrite() const
-{
-    return (m_write != INVALID_HANDLE_VALUE);
-}
+bool PipeWindows::CanWrite() const { return (m_write != INVALID_HANDLE_VALUE); }
 
 HANDLE
-PipeWindows::GetReadNativeHandle()
-{
-    return m_read;
-}
+PipeWindows::GetReadNativeHandle() { return m_read; }
 
 HANDLE
-PipeWindows::GetWriteNativeHandle()
-{
-    return m_write;
-}
-
-Error
-PipeWindows::ReadWithTimeout(void *buf, size_t size, const std::chrono::microseconds &duration, size_t &bytes_read)
-{
-    if (!CanRead())
-        return Error(ERROR_INVALID_HANDLE, eErrorTypeWin32);
-
-    bytes_read = 0;
-    DWORD sys_bytes_read = size;
-    BOOL result = ::ReadFile(m_read, buf, sys_bytes_read, &sys_bytes_read, &m_read_overlapped);
-    if (!result && GetLastError() != ERROR_IO_PENDING)
-        return Error(::GetLastError(), eErrorTypeWin32);
-
-    DWORD timeout = (duration == std::chrono::microseconds::zero()) ? INFINITE : duration.count() * 1000;
-    DWORD wait_result = ::WaitForSingleObject(m_read_overlapped.hEvent, timeout);
-    if (wait_result != WAIT_OBJECT_0)
-    {
-        // The operation probably failed.  However, if it timed out, we need to cancel the I/O.
-        // Between the time we returned from WaitForSingleObject and the time we call CancelIoEx,
-        // the operation may complete.  If that hapens, CancelIoEx will fail and return ERROR_NOT_FOUND.
-        // If that happens, the original operation should be considered to have been successful.
-        bool failed = true;
-        DWORD failure_error = ::GetLastError();
-        if (wait_result == WAIT_TIMEOUT)
-        {
-            BOOL cancel_result = CancelIoEx(m_read, &m_read_overlapped);
-            if (!cancel_result && GetLastError() == ERROR_NOT_FOUND)
-                failed = false;
-        }
-        if (failed)
-            return Error(failure_error, eErrorTypeWin32);
+PipeWindows::GetWriteNativeHandle() { return m_write; }
+
+Error PipeWindows::ReadWithTimeout(void *buf, size_t size,
+                                   const std::chrono::microseconds &duration,
+                                   size_t &bytes_read) {
+  if (!CanRead())
+    return Error(ERROR_INVALID_HANDLE, eErrorTypeWin32);
+
+  bytes_read = 0;
+  DWORD sys_bytes_read = size;
+  BOOL result = ::ReadFile(m_read, buf, sys_bytes_read, &sys_bytes_read,
+                           &m_read_overlapped);
+  if (!result && GetLastError() != ERROR_IO_PENDING)
+    return Error(::GetLastError(), eErrorTypeWin32);
+
+  DWORD timeout = (duration == std::chrono::microseconds::zero())
+                      ? INFINITE
+                      : duration.count() * 1000;
+  DWORD wait_result = ::WaitForSingleObject(m_read_overlapped.hEvent, timeout);
+  if (wait_result != WAIT_OBJECT_0) {
+    // The operation probably failed.  However, if it timed out, we need to
+    // cancel the I/O.
+    // Between the time we returned from WaitForSingleObject and the time we
+    // call CancelIoEx,
+    // the operation may complete.  If that hapens, CancelIoEx will fail and
+    // return ERROR_NOT_FOUND.
+    // If that happens, the original operation should be considered to have been
+    // successful.
+    bool failed = true;
+    DWORD failure_error = ::GetLastError();
+    if (wait_result == WAIT_TIMEOUT) {
+      BOOL cancel_result = CancelIoEx(m_read, &m_read_overlapped);
+      if (!cancel_result && GetLastError() == ERROR_NOT_FOUND)
+        failed = false;
     }
-
-    // Now we call GetOverlappedResult setting bWait to false, since we've already waited
-    // as long as we're willing to.
-    if (!GetOverlappedResult(m_read, &m_read_overlapped, &sys_bytes_read, FALSE))
-        return Error(::GetLastError(), eErrorTypeWin32);
-
-    bytes_read = sys_bytes_read;
-    return Error();
+    if (failed)
+      return Error(failure_error, eErrorTypeWin32);
+  }
+
+  // Now we call GetOverlappedResult setting bWait to false, since we've already
+  // waited
+  // as long as we're willing to.
+  if (!GetOverlappedResult(m_read, &m_read_overlapped, &sys_bytes_read, FALSE))
+    return Error(::GetLastError(), eErrorTypeWin32);
+
+  bytes_read = sys_bytes_read;
+  return Error();
 }
 
-Error
-PipeWindows::Write(const void *buf, size_t num_bytes, size_t &bytes_written)
-{
-    if (!CanWrite())
-        return Error(ERROR_INVALID_HANDLE, eErrorTypeWin32);
-
-    DWORD sys_bytes_written = 0;
-    BOOL write_result = ::WriteFile(m_write, buf, num_bytes, &sys_bytes_written, &m_write_overlapped);
-    if (!write_result && GetLastError() != ERROR_IO_PENDING)
-        return Error(::GetLastError(), eErrorTypeWin32);
-
-    BOOL result = GetOverlappedResult(m_write, &m_write_overlapped, &sys_bytes_written, TRUE);
-    if (!result)
-        return Error(::GetLastError(), eErrorTypeWin32);
-    return Error();
+Error PipeWindows::Write(const void *buf, size_t num_bytes,
+                         size_t &bytes_written) {
+  if (!CanWrite())
+    return Error(ERROR_INVALID_HANDLE, eErrorTypeWin32);
+
+  DWORD sys_bytes_written = 0;
+  BOOL write_result = ::WriteFile(m_write, buf, num_bytes, &sys_bytes_written,
+                                  &m_write_overlapped);
+  if (!write_result && GetLastError() != ERROR_IO_PENDING)
+    return Error(::GetLastError(), eErrorTypeWin32);
+
+  BOOL result = GetOverlappedResult(m_write, &m_write_overlapped,
+                                    &sys_bytes_written, TRUE);
+  if (!result)
+    return Error(::GetLastError(), eErrorTypeWin32);
+  return Error();
 }