initial attempt to move TCPSocket from LLDB to LLVM

[noajshu]

Summary

We would like to move the IOObject hierarchy from LLDB into LLVM so that we can use it (especially TCPSocket) in other projects. There are several details to be sorted out. We need to pick a different namespace for the IOObjects. We need to select which of the dependencies of the TCPSocket (e.g. Status.h, Log.h) we wish to move over into LLVM, and which ones we should replace.

[phosek]

Rather than introducing llvm/lib/Host and llvm/lib/Utility, I'd prefer moving the classes to llvm/lib/Support which already contains the existing LLVM platform abstractions.

lldb/include/lldb/Host/File.h

 //===-- File.h --------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_HOST_FILE_H
 #define LLDB_HOST_FILE_H
 
 #include "lldb/Host/PosixApi.h"
-#include "lldb/Utility/IOObject.h"
+#include "llvm/Utility/IOObject.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private.h"
 #include "llvm/ADT/BitmaskEnum.h"
 
 #include <cstdarg>
 #include <cstdio>
 #include <mutex>
 #include <sys/types.h>
 
 namespace lldb_private {
 

lldb/include/lldb/Host/MainLoopBase.h

 //===-- MainLoopBase.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_HOST_MAINLOOPBASE_H
 #define LLDB_HOST_MAINLOOPBASE_H
 
-#include "lldb/Utility/IOObject.h"
 #include "lldb/Utility/Status.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Utility/IOObject.h"
 #include <functional>
 
 namespace lldb_private {
 
 // The purpose of this class is to enable multiplexed processing of data from
 // different sources without resorting to multi-threading. Clients can register
 // IOObjects, which will be monitored for readability, and when they become
 // ready, the specified callback will be invoked. Monitoring for writability is

lldb/include/lldb/Host/posix/ConnectionFileDescriptorPosix.h

 //===-- ConnectionFileDescriptorPosix.h -------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_HOST_POSIX_CONNECTIONFILEDESCRIPTORPOSIX_H
 #define LLDB_HOST_POSIX_CONNECTIONFILEDESCRIPTORPOSIX_H
 
 #include <atomic>
 #include <memory>
 #include <mutex>
 
 #include "lldb/lldb-forward.h"
 
 #include "lldb/Host/Pipe.h"
 #include "lldb/Utility/Connection.h"
-#include "lldb/Utility/IOObject.h"
 #include "lldb/Utility/Predicate.h"
+#include "llvm/Utility/IOObject.h"
 
 namespace lldb_private {
 
 class Status;
 class Socket;
 class SocketAddress;
 
 class ConnectionFileDescriptor : public Connection {

lldb/source/Host/common/Socket.cpp

 //===-- Socket.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Socket.h"
 
 #include "lldb/Host/Config.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/SocketAddress.h"
 #include "lldb/Host/StringConvert.h"
-#include "lldb/Host/common/TCPSocket.h"
+#include "llvm/Host/common/TCPSocket.h"
 #include "lldb/Host/common/UDPSocket.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/WindowsError.h"
 
 #if LLDB_ENABLE_POSIX
 #include "lldb/Host/posix/DomainSocket.h"

lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp

 //===-- ConnectionFileDescriptorPosix.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__APPLE__)
 // Enable this special support for Apple builds where we can have unlimited
 // select bounds. We tried switching to poll() and kqueue and we were panicing
 // the kernel, so we have to stick with select for now.
 #define _DARWIN_UNLIMITED_SELECT
 #endif
 
 #include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/SocketAddress.h"
 #include "lldb/Utility/SelectHelper.h"
 #include "lldb/Utility/Timeout.h"
 
 #include <cerrno>
 #include <cstdlib>

 
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/ErrorHandling.h"
 #if defined(__APPLE__)
 #include "llvm/ADT/SmallVector.h"
 #endif
 #include "lldb/Host/Host.h"
 #include "lldb/Host/Socket.h"
-#include "lldb/Host/common/TCPSocket.h"
+#include "llvm/Host/common/TCPSocket.h"
 #include "lldb/Host/common/UDPSocket.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 const char *ConnectionFileDescriptor::LISTEN_SCHEME = "listen";
 const char *ConnectionFileDescriptor::ACCEPT_SCHEME = "accept";
 const char *ConnectionFileDescriptor::UNIX_ACCEPT_SCHEME = "unix-accept";
 const char *ConnectionFileDescriptor::CONNECT_SCHEME = "connect";

lldb/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

 //===-- PlatformAndroidRemoteGDBServer.cpp --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/ConnectionFileDescriptor.h"
-#include "lldb/Host/common/TCPSocket.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/UriParser.h"
+#include "llvm/Host/common/TCPSocket.h"
 
 #include "PlatformAndroidRemoteGDBServer.h"
 
 #include <sstream>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace platform_android;

lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

 //===-- ProcessKDP.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <cerrno>
 #include <cstdlib>
 
 #include <memory>
 #include <mutex>
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/ThreadLauncher.h"
-#include "lldb/Host/common/TCPSocket.h"
+#include "llvm/Host/common/TCPSocket.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionGroupString.h"
 #include "lldb/Interpreter/OptionGroupUInt64.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Symbol/LocateSymbolFile.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StringExtractor.h"
 #include "lldb/Utility/UUID.h"
 
 #include "llvm/Support/Threading.h"
 
 #define USEC_PER_SEC 1000000
 
 #include "Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h"
 #include "Plugins/DynamicLoader/Static/DynamicLoaderStatic.h"
 #include "ProcessKDP.h"

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Host/ProcessLaunchInfo.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/ThreadLauncher.h"
-#include "lldb/Host/common/TCPSocket.h"
+#include "llvm/Host/common/TCPSocket.h"
 #include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 #include "ProcessGDBRemoteLog.h"
 
 #if defined(__APPLE__)
 #define DEBUGSERVER_BASENAME "debugserver"
 #elif defined(_WIN32)
 #define DEBUGSERVER_BASENAME "lldb-server.exe"

lldb/source/Utility/CMakeLists.txt

add_lldb_library(lldbUtility
   DataBufferHeap.cpp
   DataBufferLLVM.cpp
   DataEncoder.cpp
   DataExtractor.cpp
   Environment.cpp
   Event.cpp
   FileSpec.cpp
   GDBRemote.cpp
-  IOObject.cpp
   LLDBAssert.cpp
   Listener.cpp
   Log.cpp
   Logging.cpp
   NameMatches.cpp
   ProcessInfo.cpp
   RegisterValue.cpp
   RegularExpression.cpp

lldb/tools/lldb-server/Acceptor.cpp

 //===-- Acceptor.cpp --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Acceptor.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 #include "lldb/Host/ConnectionFileDescriptor.h"
-#include "lldb/Host/common/TCPSocket.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/UriParser.h"
+#include "llvm/Host/common/TCPSocket.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::lldb_server;
 using namespace llvm;
 
 namespace {
 

lldb/tools/lldb-server/lldb-platform.cpp

 
 #include "Acceptor.h"
 #include "LLDBServerUtilities.h"
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/HostGetOpt.h"
 #include "lldb/Host/OptionParser.h"
-#include "lldb/Host/common/TCPSocket.h"
+#include "llvm/Host/common/TCPSocket.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::lldb_server;
 using namespace lldb_private::process_gdb_remote;
 using namespace llvm;
 
 // option descriptors for getopt_long_only()

lldb/unittests/Host/MainLoopTest.cpp

 //===-- MainLoopTest.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/MainLoop.h"
 #include "TestingSupport/SubsystemRAII.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/PseudoTerminal.h"
-#include "lldb/Host/common/TCPSocket.h"
+#include "llvm/Host/common/TCPSocket.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 #include <future>
 
 using namespace lldb_private;
 
 namespace {
 class MainLoopTest : public testing::Test {

lldb/unittests/Host/SocketTestUtilities.h

 //===--------------------- SocketTestUtilities.h ----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UNITTESTS_HOST_SOCKETTESTUTILITIES_H
 #define LLDB_UNITTESTS_HOST_SOCKETTESTUTILITIES_H
 
 #include <cstdio>
 #include <functional>
 #include <thread>
 
 #include "lldb/Host/Config.h"
 #include "lldb/Host/Socket.h"
-#include "lldb/Host/common/TCPSocket.h"
 #include "lldb/Host/common/UDPSocket.h"
+#include "llvm/Host/common/TCPSocket.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Testing/Support/Error.h"
 
 #if LLDB_ENABLE_POSIX
 #include "lldb/Host/posix/DomainSocket.h"
 #endif
 

lldb/unittests/debugserver/RNBSocketTest.cpp

 //===-- RNBSocketTest.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
 #include <arpa/inet.h>
 #include <sys/sysctl.h>
 #include <unistd.h>
 
 #include "RNBDefs.h"
 #include "RNBSocket.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/StringConvert.h"
-#include "lldb/Host/common/TCPSocket.h"
+#include "llvm/Host/common/TCPSocket.h"
 #include "llvm/Testing/Support/Error.h"
 
 using namespace lldb_private;
 
 std::string hello = "Hello, world!";
 std::string goodbye = "Goodbye!";
 
 static void ServerCallbackv4(const void *baton, in_port_t port) {

lldb/unittests/tools/lldb-server/tests/TestClient.cpp

 //===-- TestClient.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestClient.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Host/common/TCPSocket.h"
 #include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
 #include "lldb/Utility/Args.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Host/common/TCPSocket.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 #include <cstdlib>
 #include <future>
 #include <sstream>
 #include <string>
 

llvm/include/llvm/Host/Socket.h

 //===-- Socket.h ------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_HOST_SOCKET_H
 #define LLDB_HOST_SOCKET_H
 
 #include <memory>
 #include <string>
 
 #include "lldb/lldb-private.h"
 
 #include "lldb/Host/SocketAddress.h"
-#include "lldb/Utility/IOObject.h"
 #include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/Status.h"
+#include "llvm/Utility/IOObject.h"
 
 #ifdef _WIN32
 #include "lldb/Host/windows/windows.h"
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #endif
 
 namespace llvm {

llvm/include/llvm/Host/SocketAddress.h

 //===-- SocketAddress.h -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_HOST_SOCKETADDRESS_H
 #define LLDB_HOST_SOCKETADDRESS_H
 
 #include <cstdint>
 
 #ifdef _WIN32
 #include "lldb/Host/windows/windows.h"
 #include <winsock2.h>
 #include <ws2tcpip.h>
 typedef ADDRESS_FAMILY sa_family_t;
 #else
 #include <netdb.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #endif
 
 #if defined(__FreeBSD__)
 #include <sys/types.h>
 #endif
 
 #include <string>
 #include <vector>
 
 namespace lldb_private {
 
 class SocketAddress {
 public:
   // Static method to get all address information for a host and/or service
   static std::vector<SocketAddress>
   GetAddressInfo(const char *hostname, const char *servname, int ai_family,
                  int ai_socktype, int ai_protocol, int ai_flags = 0);
 
   // Constructors and Destructors
   SocketAddress();
   SocketAddress(const struct addrinfo *addr_info);
   SocketAddress(const struct sockaddr &s);
   SocketAddress(const struct sockaddr_in &s);
   SocketAddress(const struct sockaddr_in6 &s);
   SocketAddress(const struct sockaddr_storage &s);
   ~SocketAddress();
 
   // Operators
   const SocketAddress &operator=(const struct addrinfo *addr_info);
 
   const SocketAddress &operator=(const struct sockaddr &s);
 
   const SocketAddress &operator=(const struct sockaddr_in &s);
 
   const SocketAddress &operator=(const struct sockaddr_in6 &s);
 
   const SocketAddress &operator=(const struct sockaddr_storage &s);
 
   bool operator==(const SocketAddress &rhs) const;
   bool operator!=(const SocketAddress &rhs) const;
 
   // Clear the contents of this socket address
   void Clear();
 
   // Get the length for the current socket address family
   socklen_t GetLength() const;
 
   // Get the max length for the largest socket address supported.
   static socklen_t GetMaxLength();
 
   // Get the socket address family
   sa_family_t GetFamily() const;
 
   // Set the socket address family
   void SetFamily(sa_family_t family);
 
   // Get the address
   std::string GetIPAddress() const;
 
   // Get the port if the socket address for the family has a port
   uint16_t GetPort() const;
 
   // Set the port if the socket address for the family has a port. The family
   // must be set correctly prior to calling this function.
   bool SetPort(uint16_t port);
 
   // Set the socket address according to the first match from a call to
   // getaddrinfo() (or equivalent functions for systems that don't have
   // getaddrinfo(). If "addr_info_ptr" is not NULL, it will get filled in with
   // the match that was used to populate this socket address.
   bool
   getaddrinfo(const char *host,    // Hostname ("foo.bar.com" or "foo" or IP
                                    // address string ("123.234.12.1" or
                                    // "2001:0db8:85a3:0000:0000:8a2e:0370:7334")
               const char *service, // Protocol name ("tcp", "http", etc) or a
                                    // raw port number string ("81")
               int ai_family = PF_UNSPEC, int ai_socktype = 0,
               int ai_protocol = 0, int ai_flags = 0);
 
   // Quick way to set the SocketAddress to localhost given the family. Returns
   // true if successful, false if "family" doesn't support localhost or if
   // "family" is not supported by this class.
   bool SetToLocalhost(sa_family_t family, uint16_t port);
 
   bool SetToAnyAddress(sa_family_t family, uint16_t port);
 
   // Returns true if there is a valid socket address in this object.
   bool IsValid() const;
 
   // Returns true if the socket is INADDR_ANY
   bool IsAnyAddr() const;
 
   // Returns true if the socket is INADDR_LOOPBACK
   bool IsLocalhost() const;
 
   // Direct access to all of the sockaddr structures
   struct sockaddr &sockaddr() {
     return m_socket_addr.sa;
   }
 
   const struct sockaddr &sockaddr() const { return m_socket_addr.sa; }
 
   struct sockaddr_in &sockaddr_in() {
     return m_socket_addr.sa_ipv4;
   }
 
   const struct sockaddr_in &sockaddr_in() const {
     return m_socket_addr.sa_ipv4;
   }
 
   struct sockaddr_in6 &sockaddr_in6() {
     return m_socket_addr.sa_ipv6;
   }
 
   const struct sockaddr_in6 &sockaddr_in6() const {
     return m_socket_addr.sa_ipv6;
   }
 
   struct sockaddr_storage &sockaddr_storage() {
     return m_socket_addr.sa_storage;
   }
 
   const struct sockaddr_storage &sockaddr_storage() const {
     return m_socket_addr.sa_storage;
   }
 
   // Conversion operators to allow getting the contents of this class as a
   // pointer to the appropriate structure. This allows an instance of this
   // class to be used in calls that take one of the sockaddr structure variants
   // without having to manually use the correct accessor function.
 
   operator struct sockaddr *() { return &m_socket_addr.sa; }
 
   operator const struct sockaddr *() const { return &m_socket_addr.sa; }
 
   operator struct sockaddr_in *() { return &m_socket_addr.sa_ipv4; }
 
   operator const struct sockaddr_in *() const { return &m_socket_addr.sa_ipv4; }
 
   operator struct sockaddr_in6 *() { return &m_socket_addr.sa_ipv6; }
 
   operator const struct sockaddr_in6 *() const {
     return &m_socket_addr.sa_ipv6;
   }
 
   operator const struct sockaddr_storage *() const {
     return &m_socket_addr.sa_storage;
   }
 
   operator struct sockaddr_storage *() { return &m_socket_addr.sa_storage; }
 
 protected:
   typedef union sockaddr_tag {
     struct sockaddr sa;
     struct sockaddr_in sa_ipv4;
     struct sockaddr_in6 sa_ipv6;
     struct sockaddr_storage sa_storage;
   } sockaddr_t;
 
   // Classes that inherit from SocketAddress can see and modify these
   sockaddr_t m_socket_addr;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_SOCKETADDRESS_H

llvm/include/llvm/Host/common/TCPSocket.h

 //===-- TCPSocket.h ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_HOST_COMMON_TCPSOCKET_H
 #define LLDB_HOST_COMMON_TCPSOCKET_H
 
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/SocketAddress.h"
 #include <map>
 
 namespace lldb_private {
 class TCPSocket : public Socket {
 public:
   TCPSocket(bool should_close, bool child_processes_inherit);
   TCPSocket(NativeSocket socket, bool should_close,

 
 private:
   TCPSocket(NativeSocket socket, const TCPSocket &listen_socket);
 
   void CloseListenSockets();
 
   std::map<int, SocketAddress> m_listen_sockets;
 };
 }
 
 #endif // LLDB_HOST_COMMON_TCPSOCKET_H

llvm/include/llvm/Utility/IOObject.h

 //===-- IOObject.h ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UTILITY_IOOBJECT_H
 #define LLDB_UTILITY_IOOBJECT_H
 
 #include <cstdarg>
 #include <cstdio>
 #include <sys/types.h>
 
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class IOObject {
 public:
   enum FDType {
     eFDTypeFile,   // Other FD requiring read/write
     eFDTypeSocket, // Socket requiring send/recv

llvm/lib/CMakeLists.txt

 add_subdirectory(Target)
 add_subdirectory(AsmParser)
 add_subdirectory(LineEditor)
 add_subdirectory(ProfileData)
 add_subdirectory(Passes)
 add_subdirectory(TextAPI)
 add_subdirectory(ToolDrivers)
 add_subdirectory(XRay)
+add_subdirectory(Host)
 if (LLVM_INCLUDE_TESTS)
   add_subdirectory(Testing)
 endif()
 add_subdirectory(WindowsManifest)
 
 set(LLVMCONFIGLIBRARYDEPENDENCIESINC "${LLVM_BINARY_DIR}/tools/llvm-config/LibraryDependencies.inc")
 
 # Special components which don't have any source attached but aggregate other

llvm/lib/Host/CMakeLists.txt

+if (APPLE AND LLVM_ENABLE_LOCAL_SUBMODULE_VISIBILITY)
+  # The arpa/inet.h header used in the files here is providing a miscompiled
+  # htonl function on macOS <= 10.15 when local submodule visibility is active.
+  # Disabling modules in this directory until this is is fixed.
+  # See rdar://problem/62886385
+  remove_module_flags()
+endif()
+
+macro(add_host_subdirectory group)
+  list(APPEND HOST_SOURCES ${ARGN})
+  source_group(${group} FILES ${ARGN})
+endmacro()
+
+add_host_subdirectory(common
+  common/TCPSocket.cpp
+)

llvm/lib/Host/common/TCPSocket.cpp

 //===-- TCPSocket.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(_MSC_VER)
 #define _WINSOCK_DEPRECATED_NO_WARNINGS
 #endif
 
-#include "lldb/Host/common/TCPSocket.h"
+#include "llvm/Host/common/TCPSocket.h"
 
 #include "lldb/Host/Config.h"
 #include "lldb/Host/MainLoop.h"
 #include "lldb/Utility/Log.h"
 
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/WindowsError.h"
std::vector<SocketAddress> addresses = SocketAddress::GetAddressInfo(
       host_str.c_str(), nullptr, AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP);
   for (SocketAddress &address : addresses) {
     error = CreateSocket(address.GetFamily());
     if (error.Fail())
       continue;
 
     address.SetPort(port);
 
-    if (-1 == llvm::sys::RetryAfterSignal(-1, ::connect,
-          GetNativeSocket(), &address.sockaddr(), address.GetLength())) {
+    if (-1 == llvm::sys::RetryAfterSignal(-1, ::connect, GetNativeSocket(),
+                                          &address.sockaddr(),
+                                          address.GetLength())) {
       CLOSE_SOCKET(GetNativeSocket());
       continue;
     }
 
     SetOptionNoDelay();
 
     error.Clear();
     return error;
for (SocketAddress &address : addresses) {
     // enable local address reuse
     int option_value = 1;
     set_socket_option_arg_type option_value_p =
         reinterpret_cast<set_socket_option_arg_type>(&option_value);
     ::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, option_value_p,
                  sizeof(option_value));
 
     SocketAddress listen_address = address;
-    if(!listen_address.IsLocalhost())
+    if (!listen_address.IsLocalhost())
       listen_address.SetToAnyAddress(address.GetFamily(), port);
     else
       listen_address.SetPort(port);
 
     int err =
         ::bind(fd, &listen_address.sockaddr(), listen_address.GetLength());
     if (-1 != err)
       err = ::listen(fd, backlog);
Status TCPSocket::Accept(Socket *&conn_socket) {
   lldb_private::SocketAddress AcceptAddr;
   MainLoop accept_loop;
   std::vector<MainLoopBase::ReadHandleUP> handles;
   for (auto socket : m_listen_sockets) {
     auto fd = socket.first;
     auto inherit = this->m_child_processes_inherit;
     auto io_sp = IOObjectSP(new TCPSocket(socket.first, false, inherit));
     handles.emplace_back(accept_loop.RegisterReadObject(
-        io_sp, [fd, inherit, &sock, &AcceptAddr, &error,
-                        &listen_sock](MainLoopBase &loop) {
+        io_sp,
+        [fd, inherit, &sock, &AcceptAddr, &error,
           socklen_t sa_len = AcceptAddr.GetMaxLength();
-          sock = AcceptSocket(fd, &AcceptAddr.sockaddr(), &sa_len, inherit,
-                              error);
+          sock =
+              AcceptSocket(fd, &AcceptAddr.sockaddr(), &sa_len, inherit, error);
           listen_sock = fd;
           loop.RequestTermination();
-        }, error));
+        },
+        error));
     if (error.Fail())
       return error;
   }
 
   bool accept_connection = false;
   std::unique_ptr<TCPSocket> accepted_socket;
   // Loop until we are happy with our connection
   while (!accept_connection) {
     accept_loop.Run();
 
     if (error.Fail())
-        return error;
 
     lldb_private::SocketAddress &AddrIn = m_listen_sockets[listen_sock];
     if (!AddrIn.IsAnyAddr() && AcceptAddr != AddrIn) {
       CLOSE_SOCKET(sock);
       llvm::errs() << llvm::formatv(
           "error: rejecting incoming connection from {0} (expecting {1})",
           AcceptAddr.GetIPAddress(), AddrIn.GetIPAddress());
       continue;

llvm/lib/Utility/IOObject.cpp

 //===-- IOObject.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/Utility/IOObject.h"
+#include "llvm/Utility/IOObject.h"
 
 using namespace lldb_private;
 
 const IOObject::WaitableHandle IOObject::kInvalidHandleValue = -1;
 IOObject::~IOObject() = default;