*** 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, 314 insertions, 346 deletions

diff --git a/lldb/source/Host/common/Socket.cpp b/lldb/source/Host/common/Socket.cpp
index ea049ae6933..d986c2fe6a0 100644
--- a/lldb/source/Host/common/Socket.cpp
+++ b/lldb/source/Host/common/Socket.cpp
@@ -35,15 +35,15 @@
 #endif
 
 #ifdef __ANDROID_NDK__
-#include <linux/tcp.h>
-#include <bits/error_constants.h>
+#include <arpa/inet.h>
 #include <asm-generic/errno-base.h>
+#include <bits/error_constants.h>
 #include <errno.h>
-#include <arpa/inet.h>
+#include <linux/tcp.h>
 #if defined(ANDROID_ARM_BUILD_STATIC) || defined(ANDROID_MIPS_BUILD_STATIC)
-#include <unistd.h>
-#include <sys/syscall.h>
 #include <fcntl.h>
+#include <sys/syscall.h>
+#include <unistd.h>
 #endif // ANDROID_ARM_BUILD_STATIC || ANDROID_MIPS_BUILD_STATIC
 #endif // __ANDROID_NDK__
 
@@ -51,439 +51,407 @@ using namespace lldb;
 using namespace lldb_private;
 
 #if defined(_WIN32)
-typedef const char * set_socket_option_arg_type;
-typedef char * get_socket_option_arg_type;
+typedef const char *set_socket_option_arg_type;
+typedef char *get_socket_option_arg_type;
 const NativeSocket Socket::kInvalidSocketValue = INVALID_SOCKET;
-#else // #if defined(_WIN32)
-typedef const void * set_socket_option_arg_type;
-typedef void * get_socket_option_arg_type;
+#else  // #if defined(_WIN32)
+typedef const void *set_socket_option_arg_type;
+typedef void *get_socket_option_arg_type;
 const NativeSocket Socket::kInvalidSocketValue = -1;
 #endif // #if defined(_WIN32)
 
 namespace {
 
-bool IsInterrupted()
-{
+bool IsInterrupted() {
 #if defined(_WIN32)
-    return ::WSAGetLastError() == WSAEINTR;
+  return ::WSAGetLastError() == WSAEINTR;
 #else
-    return errno == EINTR;
+  return errno == EINTR;
 #endif
 }
-
 }
 
 Socket::Socket(NativeSocket socket, SocketProtocol protocol, bool should_close)
-    : IOObject(eFDTypeSocket, should_close)
-    , m_protocol(protocol)
-    , m_socket(socket)
-{
-
-}
-
-Socket::~Socket()
-{
-    Close();
-}
-
-std::unique_ptr<Socket> Socket::Create(const SocketProtocol protocol, bool child_processes_inherit, Error &error)
-{
-    error.Clear();
-
-    std::unique_ptr<Socket> socket_up;
-    switch (protocol)
-    {
-    case ProtocolTcp:
-        socket_up.reset(new TCPSocket(child_processes_inherit, error));
-        break;
-    case ProtocolUdp:
-        socket_up.reset(new UDPSocket(child_processes_inherit, error));
-        break;
-    case ProtocolUnixDomain:
+    : IOObject(eFDTypeSocket, should_close), m_protocol(protocol),
+      m_socket(socket) {}
+
+Socket::~Socket() { Close(); }
+
+std::unique_ptr<Socket> Socket::Create(const SocketProtocol protocol,
+                                       bool child_processes_inherit,
+                                       Error &error) {
+  error.Clear();
+
+  std::unique_ptr<Socket> socket_up;
+  switch (protocol) {
+  case ProtocolTcp:
+    socket_up.reset(new TCPSocket(child_processes_inherit, error));
+    break;
+  case ProtocolUdp:
+    socket_up.reset(new UDPSocket(child_processes_inherit, error));
+    break;
+  case ProtocolUnixDomain:
 #ifndef LLDB_DISABLE_POSIX
-        socket_up.reset(new DomainSocket(child_processes_inherit, error));
+    socket_up.reset(new DomainSocket(child_processes_inherit, error));
 #else
-        error.SetErrorString("Unix domain sockets are not supported on this platform.");
+    error.SetErrorString(
+        "Unix domain sockets are not supported on this platform.");
 #endif
-        break;
-    case ProtocolUnixAbstract:
+    break;
+  case ProtocolUnixAbstract:
 #ifdef __linux__
-        socket_up.reset(new AbstractSocket(child_processes_inherit, error));
+    socket_up.reset(new AbstractSocket(child_processes_inherit, error));
 #else
-        error.SetErrorString("Abstract domain sockets are not supported on this platform.");
+    error.SetErrorString(
+        "Abstract domain sockets are not supported on this platform.");
 #endif
-        break;
-    }
+    break;
+  }
 
-    if (error.Fail())
-        socket_up.reset();
+  if (error.Fail())
+    socket_up.reset();
 
-    return socket_up;
+  return socket_up;
 }
 
-Error Socket::TcpConnect(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&socket)
-{
-    Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION));
-    if (log)
-        log->Printf ("Socket::%s (host/port = %s)", __FUNCTION__, host_and_port.data());
-
-    Error error;
-    std::unique_ptr<Socket> connect_socket(Create(ProtocolTcp, child_processes_inherit, error));
-    if (error.Fail())
-        return error;
+Error Socket::TcpConnect(llvm::StringRef host_and_port,
+                         bool child_processes_inherit, Socket *&socket) {
+  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_COMMUNICATION));
+  if (log)
+    log->Printf("Socket::%s (host/port = %s)", __FUNCTION__,
+                host_and_port.data());
+
+  Error error;
+  std::unique_ptr<Socket> connect_socket(
+      Create(ProtocolTcp, child_processes_inherit, error));
+  if (error.Fail())
+    return error;
 
-    error = connect_socket->Connect(host_and_port);
-    if (error.Success())
-      socket = connect_socket.release();
+  error = connect_socket->Connect(host_and_port);
+  if (error.Success())
+    socket = connect_socket.release();
 
-    return error;
+  return error;
 }
 
-Error
-Socket::TcpListen (llvm::StringRef host_and_port,
-                   bool child_processes_inherit,
-                   Socket *&socket,
-                   Predicate<uint16_t>* predicate,
-                   int backlog)
-{
-    Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
-    if (log)
-        log->Printf ("Socket::%s (%s)", __FUNCTION__, host_and_port.data());
-
-    Error error;
-    std::string host_str;
-    std::string port_str;
-    int32_t port = INT32_MIN;
-    if (!DecodeHostAndPort (host_and_port, host_str, port_str, port, &error))
-        return error;
-
-    std::unique_ptr<TCPSocket> listen_socket(new TCPSocket(child_processes_inherit, error));
-    if (error.Fail())
-        return error;
-
-    error = listen_socket->Listen(host_and_port, backlog);
-    if (error.Success())
-    {
-        // We were asked to listen on port zero which means we
-        // must now read the actual port that was given to us
-        // as port zero is a special code for "find an open port
-        // for me".
-        if (port == 0)
-            port = listen_socket->GetLocalPortNumber();
-
-        // Set the port predicate since when doing a listen://<host>:<port>
-        // it often needs to accept the incoming connection which is a blocking
-        // system call. Allowing access to the bound port using a predicate allows
-        // us to wait for the port predicate to be set to a non-zero value from
-        // another thread in an efficient manor.
-        if (predicate)
-            predicate->SetValue (port, eBroadcastAlways);
-        socket = listen_socket.release();
-    }
+Error Socket::TcpListen(llvm::StringRef host_and_port,
+                        bool child_processes_inherit, Socket *&socket,
+                        Predicate<uint16_t> *predicate, int backlog) {
+  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
+  if (log)
+    log->Printf("Socket::%s (%s)", __FUNCTION__, host_and_port.data());
+
+  Error error;
+  std::string host_str;
+  std::string port_str;
+  int32_t port = INT32_MIN;
+  if (!DecodeHostAndPort(host_and_port, host_str, port_str, port, &error))
+    return error;
 
+  std::unique_ptr<TCPSocket> listen_socket(
+      new TCPSocket(child_processes_inherit, error));
+  if (error.Fail())
     return error;
+
+  error = listen_socket->Listen(host_and_port, backlog);
+  if (error.Success()) {
+    // We were asked to listen on port zero which means we
+    // must now read the actual port that was given to us
+    // as port zero is a special code for "find an open port
+    // for me".
+    if (port == 0)
+      port = listen_socket->GetLocalPortNumber();
+
+    // Set the port predicate since when doing a listen://<host>:<port>
+    // it often needs to accept the incoming connection which is a blocking
+    // system call. Allowing access to the bound port using a predicate allows
+    // us to wait for the port predicate to be set to a non-zero value from
+    // another thread in an efficient manor.
+    if (predicate)
+      predicate->SetValue(port, eBroadcastAlways);
+    socket = listen_socket.release();
+  }
+
+  return error;
 }
 
-Error Socket::UdpConnect(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&send_socket, Socket *&recv_socket)
-{
-    Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
-    if (log)
-        log->Printf ("Socket::%s (host/port = %s)", __FUNCTION__, host_and_port.data());
+Error Socket::UdpConnect(llvm::StringRef host_and_port,
+                         bool child_processes_inherit, Socket *&send_socket,
+                         Socket *&recv_socket) {
+  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
+  if (log)
+    log->Printf("Socket::%s (host/port = %s)", __FUNCTION__,
+                host_and_port.data());
 
-    return UDPSocket::Connect(host_and_port, child_processes_inherit, send_socket, recv_socket);
+  return UDPSocket::Connect(host_and_port, child_processes_inherit, send_socket,
+                            recv_socket);
 }
 
-Error Socket::UnixDomainConnect(llvm::StringRef name, bool child_processes_inherit, Socket *&socket)
-{
-    Error error;
-    std::unique_ptr<Socket> connect_socket(Create(ProtocolUnixDomain, child_processes_inherit, error));
-    if (error.Fail())
-        return error;
+Error Socket::UnixDomainConnect(llvm::StringRef name,
+                                bool child_processes_inherit, Socket *&socket) {
+  Error error;
+  std::unique_ptr<Socket> connect_socket(
+      Create(ProtocolUnixDomain, child_processes_inherit, error));
+  if (error.Fail())
+    return error;
 
-    error = connect_socket->Connect(name);
-    if (error.Success())
-      socket = connect_socket.release();
+  error = connect_socket->Connect(name);
+  if (error.Success())
+    socket = connect_socket.release();
 
-    return error;
+  return error;
 }
 
-Error Socket::UnixDomainAccept(llvm::StringRef name, bool child_processes_inherit, Socket *&socket)
-{
-    Error error;
-    std::unique_ptr<Socket> listen_socket(Create(ProtocolUnixDomain, child_processes_inherit, error));
-    if (error.Fail())
-        return error;
-
-    error = listen_socket->Listen(name, 5);
-    if (error.Fail())
-        return error;
+Error Socket::UnixDomainAccept(llvm::StringRef name,
+                               bool child_processes_inherit, Socket *&socket) {
+  Error error;
+  std::unique_ptr<Socket> listen_socket(
+      Create(ProtocolUnixDomain, child_processes_inherit, error));
+  if (error.Fail())
+    return error;
 
-    error = listen_socket->Accept(name, child_processes_inherit, socket);
+  error = listen_socket->Listen(name, 5);
+  if (error.Fail())
     return error;
+
+  error = listen_socket->Accept(name, child_processes_inherit, socket);
+  return error;
 }
 
-Error
-Socket::UnixAbstractConnect(llvm::StringRef name, bool child_processes_inherit, Socket *&socket)
-{
-    Error error;
-    std::unique_ptr<Socket> connect_socket(Create(ProtocolUnixAbstract, child_processes_inherit, error));
-    if (error.Fail())
-        return error;
-
-    error = connect_socket->Connect(name);
-    if (error.Success())
-      socket = connect_socket.release();
+Error Socket::UnixAbstractConnect(llvm::StringRef name,
+                                  bool child_processes_inherit,
+                                  Socket *&socket) {
+  Error error;
+  std::unique_ptr<Socket> connect_socket(
+      Create(ProtocolUnixAbstract, child_processes_inherit, error));
+  if (error.Fail())
     return error;
-}
 
-Error
-Socket::UnixAbstractAccept(llvm::StringRef name, bool child_processes_inherit, Socket *&socket)
-{
-    Error error;
-    std::unique_ptr<Socket> listen_socket(Create(ProtocolUnixAbstract,child_processes_inherit, error));
-    if (error.Fail())
-        return error;
+  error = connect_socket->Connect(name);
+  if (error.Success())
+    socket = connect_socket.release();
+  return error;
+}
 
-    error = listen_socket->Listen(name, 5);
-    if (error.Fail())
-        return error;
+Error Socket::UnixAbstractAccept(llvm::StringRef name,
+                                 bool child_processes_inherit,
+                                 Socket *&socket) {
+  Error error;
+  std::unique_ptr<Socket> listen_socket(
+      Create(ProtocolUnixAbstract, child_processes_inherit, error));
+  if (error.Fail())
+    return error;
 
-    error = listen_socket->Accept(name, child_processes_inherit, socket);
+  error = listen_socket->Listen(name, 5);
+  if (error.Fail())
     return error;
-}
 
-bool
-Socket::DecodeHostAndPort(llvm::StringRef host_and_port,
-                          std::string &host_str,
-                          std::string &port_str,
-                          int32_t& port,
-                          Error *error_ptr)
-{
-    static RegularExpression g_regex ("([^:]+):([0-9]+)");
-    RegularExpression::Match regex_match(2);
-    if (g_regex.Execute (host_and_port.data(), &regex_match))
-    {
-        if (regex_match.GetMatchAtIndex (host_and_port.data(), 1, host_str) &&
-            regex_match.GetMatchAtIndex (host_and_port.data(), 2, port_str))
-        {
-            bool ok = false;
-            port = StringConvert::ToUInt32 (port_str.c_str(), UINT32_MAX, 10, &ok);
-            if (ok && port <= UINT16_MAX)
-            {
-                if (error_ptr)
-                    error_ptr->Clear();
-                return true;
-            }
-            // port is too large
-            if (error_ptr)
-                error_ptr->SetErrorStringWithFormat("invalid host:port specification: '%s'", host_and_port.data());
-            return false;
-        }
-    }
+  error = listen_socket->Accept(name, child_processes_inherit, socket);
+  return error;
+}
 
-    // If this was unsuccessful, then check if it's simply a signed 32-bit integer, representing
-    // a port with an empty host.
-    host_str.clear();
-    port_str.clear();
-    bool ok = false;
-    port = StringConvert::ToUInt32 (host_and_port.data(), UINT32_MAX, 10, &ok);
-    if (ok && port < UINT16_MAX)
-    {
-        port_str = host_and_port;
+bool Socket::DecodeHostAndPort(llvm::StringRef host_and_port,
+                               std::string &host_str, std::string &port_str,
+                               int32_t &port, Error *error_ptr) {
+  static RegularExpression g_regex("([^:]+):([0-9]+)");
+  RegularExpression::Match regex_match(2);
+  if (g_regex.Execute(host_and_port.data(), &regex_match)) {
+    if (regex_match.GetMatchAtIndex(host_and_port.data(), 1, host_str) &&
+        regex_match.GetMatchAtIndex(host_and_port.data(), 2, port_str)) {
+      bool ok = false;
+      port = StringConvert::ToUInt32(port_str.c_str(), UINT32_MAX, 10, &ok);
+      if (ok && port <= UINT16_MAX) {
         if (error_ptr)
-            error_ptr->Clear();
+          error_ptr->Clear();
         return true;
+      }
+      // port is too large
+      if (error_ptr)
+        error_ptr->SetErrorStringWithFormat(
+            "invalid host:port specification: '%s'", host_and_port.data());
+      return false;
     }
-
+  }
+
+  // If this was unsuccessful, then check if it's simply a signed 32-bit
+  // integer, representing
+  // a port with an empty host.
+  host_str.clear();
+  port_str.clear();
+  bool ok = false;
+  port = StringConvert::ToUInt32(host_and_port.data(), UINT32_MAX, 10, &ok);
+  if (ok && port < UINT16_MAX) {
+    port_str = host_and_port;
     if (error_ptr)
-        error_ptr->SetErrorStringWithFormat("invalid host:port specification: '%s'", host_and_port.data());
-    return false;
+      error_ptr->Clear();
+    return true;
+  }
+
+  if (error_ptr)
+    error_ptr->SetErrorStringWithFormat("invalid host:port specification: '%s'",
+                                        host_and_port.data());
+  return false;
 }
 
-IOObject::WaitableHandle Socket::GetWaitableHandle()
-{
-    // TODO: On Windows, use WSAEventSelect
-    return m_socket;
+IOObject::WaitableHandle Socket::GetWaitableHandle() {
+  // TODO: On Windows, use WSAEventSelect
+  return m_socket;
 }
 
-Error Socket::Read (void *buf, size_t &num_bytes)
-{
-    Error error;
-    int bytes_received = 0;
-    do
-    {
-        bytes_received = ::recv (m_socket, static_cast<char *>(buf), num_bytes, 0);
-    } while (bytes_received < 0 && IsInterrupted ());
-
-    if (bytes_received < 0)
-    {
-        SetLastError (error);
-        num_bytes = 0;
-    }
-    else
-        num_bytes = bytes_received;
-
-    Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION)); 
-    if (log)
-    {
-        log->Printf ("%p Socket::Read() (socket = %" PRIu64 ", src = %p, src_len = %" PRIu64 ", flags = 0) => %" PRIi64 " (error = %s)",
-                     static_cast<void*>(this), 
-                     static_cast<uint64_t>(m_socket),
-                     buf,
-                     static_cast<uint64_t>(num_bytes),
-                     static_cast<int64_t>(bytes_received),
-                     error.AsCString());
-    }
-
-    return error;
+Error Socket::Read(void *buf, size_t &num_bytes) {
+  Error error;
+  int bytes_received = 0;
+  do {
+    bytes_received = ::recv(m_socket, static_cast<char *>(buf), num_bytes, 0);
+  } while (bytes_received < 0 && IsInterrupted());
+
+  if (bytes_received < 0) {
+    SetLastError(error);
+    num_bytes = 0;
+  } else
+    num_bytes = bytes_received;
+
+  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_COMMUNICATION));
+  if (log) {
+    log->Printf("%p Socket::Read() (socket = %" PRIu64
+                ", src = %p, src_len = %" PRIu64 ", flags = 0) => %" PRIi64
+                " (error = %s)",
+                static_cast<void *>(this), static_cast<uint64_t>(m_socket), buf,
+                static_cast<uint64_t>(num_bytes),
+                static_cast<int64_t>(bytes_received), error.AsCString());
+  }
+
+  return error;
 }
 
-Error Socket::Write (const void *buf, size_t &num_bytes)
-{
-    Error error;
-    int bytes_sent = 0;
-    do
-    {
-        bytes_sent = Send(buf, num_bytes);
-    } while (bytes_sent < 0 && IsInterrupted ());
-
-    if (bytes_sent < 0)
-    {
-        SetLastError (error);
-        num_bytes = 0;
-    }
-    else
-        num_bytes = bytes_sent;
-
-    Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION));
-    if (log)
-    {
-        log->Printf ("%p Socket::Write() (socket = %" PRIu64 ", src = %p, src_len = %" PRIu64 ", flags = 0) => %" PRIi64 " (error = %s)",
-                        static_cast<void*>(this), 
-                        static_cast<uint64_t>(m_socket),
-                        buf,
-                        static_cast<uint64_t>(num_bytes),
-                        static_cast<int64_t>(bytes_sent),
-                        error.AsCString());
-    }
-
-    return error;
+Error Socket::Write(const void *buf, size_t &num_bytes) {
+  Error error;
+  int bytes_sent = 0;
+  do {
+    bytes_sent = Send(buf, num_bytes);
+  } while (bytes_sent < 0 && IsInterrupted());
+
+  if (bytes_sent < 0) {
+    SetLastError(error);
+    num_bytes = 0;
+  } else
+    num_bytes = bytes_sent;
+
+  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_COMMUNICATION));
+  if (log) {
+    log->Printf("%p Socket::Write() (socket = %" PRIu64
+                ", src = %p, src_len = %" PRIu64 ", flags = 0) => %" PRIi64
+                " (error = %s)",
+                static_cast<void *>(this), static_cast<uint64_t>(m_socket), buf,
+                static_cast<uint64_t>(num_bytes),
+                static_cast<int64_t>(bytes_sent), error.AsCString());
+  }
+
+  return error;
 }
 
-Error Socket::PreDisconnect()
-{
-    Error error;
-    return error;
+Error Socket::PreDisconnect() {
+  Error error;
+  return error;
 }
 
-Error Socket::Close()
-{
-    Error error;
-    if (!IsValid() || !m_should_close_fd)
-        return error;
+Error Socket::Close() {
+  Error error;
+  if (!IsValid() || !m_should_close_fd)
+    return error;
 
-    Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
-    if (log)
-        log->Printf ("%p Socket::Close (fd = %i)", static_cast<void*>(this), m_socket);
+  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
+  if (log)
+    log->Printf("%p Socket::Close (fd = %i)", static_cast<void *>(this),
+                m_socket);
 
 #if defined(_WIN32)
-    bool success = !!closesocket(m_socket);
+  bool success = !!closesocket(m_socket);
 #else
-    bool success = !!::close (m_socket);
+  bool success = !!::close(m_socket);
 #endif
-    // A reference to a FD was passed in, set it to an invalid value
-    m_socket = kInvalidSocketValue;
-    if (!success)
-    {
-        SetLastError (error);
-    }
+  // A reference to a FD was passed in, set it to an invalid value
+  m_socket = kInvalidSocketValue;
+  if (!success) {
+    SetLastError(error);
+  }
 
-    return error;
+  return error;
 }
 
-
-int Socket::GetOption(int level, int option_name, int &option_value)
-{
-    get_socket_option_arg_type option_value_p = reinterpret_cast<get_socket_option_arg_type>(&option_value);
-    socklen_t option_value_size = sizeof(int);
-    return ::getsockopt(m_socket, level, option_name, option_value_p, &option_value_size);
+int Socket::GetOption(int level, int option_name, int &option_value) {
+  get_socket_option_arg_type option_value_p =
+      reinterpret_cast<get_socket_option_arg_type>(&option_value);
+  socklen_t option_value_size = sizeof(int);
+  return ::getsockopt(m_socket, level, option_name, option_value_p,
+                      &option_value_size);
 }
 
-int Socket::SetOption(int level, int option_name, int option_value)
-{
-    set_socket_option_arg_type option_value_p = reinterpret_cast<get_socket_option_arg_type>(&option_value);
-    return ::setsockopt(m_socket, level, option_name, option_value_p, sizeof(option_value));
+int Socket::SetOption(int level, int option_name, int option_value) {
+  set_socket_option_arg_type option_value_p =
+      reinterpret_cast<get_socket_option_arg_type>(&option_value);
+  return ::setsockopt(m_socket, level, option_name, option_value_p,
+                      sizeof(option_value));
 }
 
-size_t Socket::Send(const void *buf, const size_t num_bytes)
-{
-    return ::send (m_socket, static_cast<const char *>(buf), num_bytes, 0);
+size_t Socket::Send(const void *buf, const size_t num_bytes) {
+  return ::send(m_socket, static_cast<const char *>(buf), num_bytes, 0);
 }
 
-void Socket::SetLastError(Error &error)
-{
+void Socket::SetLastError(Error &error) {
 #if defined(_WIN32)
-    error.SetError(::WSAGetLastError(), lldb::eErrorTypeWin32);
+  error.SetError(::WSAGetLastError(), lldb::eErrorTypeWin32);
 #else
-    error.SetErrorToErrno();
+  error.SetErrorToErrno();
 #endif
 }
 
-NativeSocket
-Socket::CreateSocket(const int domain,
-                     const int type,
-                     const int protocol,
-                     bool child_processes_inherit,
-                     Error& error)
-{
-    error.Clear();
-    auto socketType = type;
+NativeSocket Socket::CreateSocket(const int domain, const int type,
+                                  const int protocol,
+                                  bool child_processes_inherit, Error &error) {
+  error.Clear();
+  auto socketType = type;
 #ifdef SOCK_CLOEXEC
-    if (!child_processes_inherit)
-        socketType |= SOCK_CLOEXEC;
+  if (!child_processes_inherit)
+    socketType |= SOCK_CLOEXEC;
 #endif
-    auto sock = ::socket (domain, socketType, protocol);
-    if (sock == kInvalidSocketValue)
-        SetLastError(error);
+  auto sock = ::socket(domain, socketType, protocol);
+  if (sock == kInvalidSocketValue)
+    SetLastError(error);
 
-    return sock;
+  return sock;
 }
 
-NativeSocket
-Socket::AcceptSocket(NativeSocket sockfd,
-                     struct sockaddr *addr,
-                     socklen_t *addrlen,
-                     bool child_processes_inherit,
-                     Error& error)
-{
-    error.Clear();
+NativeSocket Socket::AcceptSocket(NativeSocket sockfd, struct sockaddr *addr,
+                                  socklen_t *addrlen,
+                                  bool child_processes_inherit, Error &error) {
+  error.Clear();
 #if defined(ANDROID_ARM_BUILD_STATIC) || defined(ANDROID_MIPS_BUILD_STATIC)
-    // Temporary workaround for statically linking Android lldb-server with the
-    // latest API.
-    int fd = syscall(__NR_accept, sockfd, addr, addrlen);
-    if (fd >= 0 && !child_processes_inherit)
-    {
-        int flags = ::fcntl(fd, F_GETFD);
-        if (flags != -1 && ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC) != -1)
-            return fd;
-        SetLastError(error);
-        close(fd);
-    }
-    return fd;
+  // Temporary workaround for statically linking Android lldb-server with the
+  // latest API.
+  int fd = syscall(__NR_accept, sockfd, addr, addrlen);
+  if (fd >= 0 && !child_processes_inherit) {
+    int flags = ::fcntl(fd, F_GETFD);
+    if (flags != -1 && ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC) != -1)
+      return fd;
+    SetLastError(error);
+    close(fd);
+  }
+  return fd;
 #elif defined(SOCK_CLOEXEC)
-    int flags = 0;
-    if (!child_processes_inherit) {
-        flags |= SOCK_CLOEXEC;
-    }
+  int flags = 0;
+  if (!child_processes_inherit) {
+    flags |= SOCK_CLOEXEC;
+  }
 #if defined(__NetBSD__)
-    NativeSocket fd = ::paccept (sockfd, addr, addrlen, nullptr, flags);
+  NativeSocket fd = ::paccept(sockfd, addr, addrlen, nullptr, flags);
 #else
-    NativeSocket fd = ::accept4 (sockfd, addr, addrlen, flags);
+  NativeSocket fd = ::accept4(sockfd, addr, addrlen, flags);
 #endif
 #else
-    NativeSocket fd = ::accept (sockfd, addr, addrlen);
+  NativeSocket fd = ::accept(sockfd, addr, addrlen);
 #endif
-    if (fd == kInvalidSocketValue)
-        SetLastError(error);
-    return fd;
+  if (fd == kInvalidSocketValue)
+    SetLastError(error);
+  return fd;
 }