This is an archive of the discontinued LLVM Phabricator instance.

Differential D34400

Move Connection from Core to Host
ClosedPublic

Authored by labath on Jun 20 2017, 5:56 AM.

Details

Reviewers
jingham
zturner
Commits
rG4ccd99541bfc: Move Connection and IOObject interfaces to Utility module
rLLDB306391: Move Connection and IOObject interfaces to Utility module
rL306391: Move Connection and IOObject interfaces to Utility module
Summary

All implementations of the connection interface live in the Host module
already, so it makes sense for the interface itself to be defined there.

Diff Detail

Repository
rL LLVM

Event Timeline

labath created this revision.Jun 20 2017, 5:56 AM
Herald added a subscriber: mgorny. · View Herald TranscriptJun 20 2017, 5:56 AM
labath updated this revision to Diff 103971.Jun 26 2017, 9:04 AM

This is how things would look like if we move Connection to Utility instead. I
needed to do two things to make this happen:

  • Keep Connection::CreateDefaultConnection in Host (now known as Host::CreateDefaultConnection), because this actually creates concrete instances).
  • Move IOObject to Utility as well. Connection interface was depending on this class. Although theoretically a forward declaration could suffice, we still shouldn't depend on stuff forward-declared in another module. The same rationale can apply to this class as well -- it's an abstract interface, which can live in Utility, and all concrete instances can (hopefully) stay in Host.
zturner accepted this revision.Jun 26 2017, 10:09 AM

Nice, yea this will be a big help I think.

This revision is now accepted and ready to land.Jun 26 2017, 10:09 AM
Closed by commit rL306391: Move Connection and IOObject interfaces to Utility module (authored by labath). · Explain WhyJun 27 2017, 3:33 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lldb/
trunk/
include/
lldb/
Core/
214 lines
Host/
2 lines
3 lines
56 lines
8 lines
2 lines
posix/
4 lines
windows/
2 lines
Utility/
212 lines
56 lines
source/
API/
3 lines
Core/
1 line
2 lines
32 lines
Host/
1 line
common/
10 lines
14 lines
posix/
3 lines
Utility/
2 lines
14 lines
15 lines
tools/
lldb-server/
2 lines

Diff 104125

lldb/trunk/include/lldb/Core/Connection.h

//===-- Connection.h --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Connection_h_
#define liblldb_Connection_h_
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for ConnectionStatus
#include "lldb/lldb-forward.h" // for IOObjectSP
#include "llvm/ADT/StringRef.h" // for StringRef
#include <ratio> // for micro
#include <string>
#include <stddef.h> // for size_t
namespace lldb_private {
class Status;
}
namespace lldb_private {
template <typename Ratio> class Timeout;
}
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Connection Connection.h "lldb/Core/Connection.h"
/// @brief A communication connection class.
///
/// A class that implements that actual communication functions for
/// connecting/disconnecting, reading/writing, and waiting for bytes
/// to become available from a two way communication connection.
///
/// This class is designed to only do very simple communication
/// functions. Instances can be instantiated and given to a
/// Communication class to perform communications where clients can
/// listen for broadcasts, and perform other higher level communications.
//----------------------------------------------------------------------
class Connection {
public:
//------------------------------------------------------------------
/// Default constructor
//------------------------------------------------------------------
Connection();
//------------------------------------------------------------------
/// Virtual destructor since this class gets subclassed and handed
/// to a Communication object.
//------------------------------------------------------------------
virtual ~Connection();
static Connection *CreateDefaultConnection(const char *url);
//------------------------------------------------------------------
/// Connect using the connect string \a url.
///
/// @param[in] url
/// A string that contains all information needed by the
/// subclass to connect to another client.
///
/// @param[out] error_ptr
/// A pointer to an error object that should be given an
/// appropriate error value if this method returns false. This
/// value can be NULL if the error value should be ignored.
///
/// @return
/// \b True if the connect succeeded, \b false otherwise. The
/// internal error object should be filled in with an
/// appropriate value based on the result of this function.
///
/// @see Status& Communication::GetError ();
//------------------------------------------------------------------
virtual lldb::ConnectionStatus Connect(llvm::StringRef url,
Status *error_ptr) = 0;
//------------------------------------------------------------------
/// Disconnect the communications connection if one is currently
/// connected.
///
/// @param[out] error_ptr
/// A pointer to an error object that should be given an
/// appropriate error value if this method returns false. This
/// value can be NULL if the error value should be ignored.
///
/// @return
/// \b True if the disconnect succeeded, \b false otherwise. The
/// internal error object should be filled in with an
/// appropriate value based on the result of this function.
///
/// @see Status& Communication::GetError ();
//------------------------------------------------------------------
virtual lldb::ConnectionStatus Disconnect(Status *error_ptr) = 0;
//------------------------------------------------------------------
/// Check if the connection is valid.
///
/// @return
/// \b True if this object is currently connected, \b false
/// otherwise.
//------------------------------------------------------------------
virtual bool IsConnected() const = 0;
//------------------------------------------------------------------
/// The read function that attempts to read from the connection.
///
/// @param[in] dst
/// A destination buffer that must be at least \a dst_len bytes
/// long.
///
/// @param[in] dst_len
/// The number of bytes to attempt to read, and also the max
/// number of bytes that can be placed into \a dst.
///
/// @param[in] timeout
/// The number of microseconds to wait for the data.
///
/// @param[out] status
/// On return, indicates whether the call was successful or terminated
/// due to some error condition.
///
/// @param[out] error_ptr
/// A pointer to an error object that should be given an
/// appropriate error value if this method returns zero. This
/// value can be NULL if the error value should be ignored.
///
/// @return
/// The number of bytes actually read.
///
/// @see size_t Communication::Read (void *, size_t, uint32_t);
//------------------------------------------------------------------
virtual size_t Read(void *dst, size_t dst_len,
const Timeout<std::micro> &timeout,
lldb::ConnectionStatus &status, Status *error_ptr) = 0;
//------------------------------------------------------------------
/// The actual write function that attempts to write to the
/// communications protocol.
///
/// Subclasses must override this function.
///
/// @param[in] dst
/// A desination buffer that must be at least \a dst_len bytes
/// long.
///
/// @param[in] dst_len
/// The number of bytes to attempt to write, and also the
/// number of bytes are currently available in \a dst.
///
/// @param[out] error_ptr
/// A pointer to an error object that should be given an
/// appropriate error value if this method returns zero. This
/// value can be NULL if the error value should be ignored.
///
/// @return
/// The number of bytes actually Written.
//------------------------------------------------------------------
virtual size_t Write(const void *dst, size_t dst_len,
lldb::ConnectionStatus &status, Status *error_ptr) = 0;
//------------------------------------------------------------------
/// Returns a URI that describes this connection object
///
/// Subclasses may override this function.
///
/// @return
/// Returns URI or an empty string if disconnecteds
//------------------------------------------------------------------
virtual std::string GetURI() = 0;
//------------------------------------------------------------------
/// Interrupts an ongoing Read() operation.
///
/// If there is an ongoing read operation in another thread, this operation
/// return with status == eConnectionStatusInterrupted. Note that if there
/// data waiting to be read and an interrupt request is issued, the Read()
/// function will return the data immediately without processing the
/// interrupt request (which will remain queued for the next Read()
/// operation).
///
/// @return
/// Returns true is the interrupt request was successful.
//------------------------------------------------------------------
virtual bool InterruptRead() = 0;
//------------------------------------------------------------------
/// Returns the underlying IOObject used by the Connection.
///
/// The IOObject can be used to wait for data to become available
/// on the connection. If the Connection does not use IOObjects (and
/// hence does not support waiting) this function should return a
/// null pointer.
///
/// @return
/// The underlying IOObject used for reading.
//------------------------------------------------------------------
virtual lldb::IOObjectSP GetReadObject() { return lldb::IOObjectSP(); }
private:
//------------------------------------------------------------------
// For Connection only
//------------------------------------------------------------------
DISALLOW_COPY_AND_ASSIGN(Connection);
};
} // namespace lldb_private
#endif // liblldb_Connection_h_

lldb/trunk/include/lldb/Host/File.h

//===-- File.h --------------------------------------------------*- C++ -*-===// //===-- File.h --------------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_File_h_ #ifndef liblldb_File_h_
#define liblldb_File_h_ #define liblldb_File_h_
#include "lldb/Host/IOObject.h"
#include "lldb/Host/PosixApi.h" #include "lldb/Host/PosixApi.h"
#include "lldb/Utility/IOObject.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include <sys/types.h> #include <sys/types.h>
namespace lldb_private { namespace lldb_private {
▲ Show 20 Lines • Show All 467 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Host/Host.h

Show First 20 Lines • Show All 232 Lines • ▼ Show 20 Lines static Status RunShellCommand(
*command_output, // Pass NULL if you don't want the command output *command_output, // Pass NULL if you don't want the command output
uint32_t timeout_sec, uint32_t timeout_sec,
bool run_in_default_shell = true); bool run_in_default_shell = true);
static bool OpenFileInExternalEditor(const FileSpec &file_spec, static bool OpenFileInExternalEditor(const FileSpec &file_spec,
uint32_t line_no); uint32_t line_no);
static size_t GetEnvironment(StringList &env); static size_t GetEnvironment(StringList &env);
static std::unique_ptr<Connection>
CreateDefaultConnection(llvm::StringRef url);
}; };
} // namespace lldb_private } // namespace lldb_private
namespace llvm { namespace llvm {
template <> struct format_provider<lldb_private::WaitStatus> { template <> struct format_provider<lldb_private::WaitStatus> {
/// Options = "" gives a human readable description of the status /// Options = "" gives a human readable description of the status
/// Options = "g" gives a gdb-remote protocol status (e.g., X09) /// Options = "g" gives a gdb-remote protocol status (e.g., X09)
static void format(const lldb_private::WaitStatus &WS, raw_ostream &OS, static void format(const lldb_private::WaitStatus &WS, raw_ostream &OS,
llvm::StringRef Options); llvm::StringRef Options);
}; };
} // namespace llvm } // namespace llvm
#endif // #if defined(__cplusplus) #endif // #if defined(__cplusplus)
#endif // liblldb_Host_h_ #endif // liblldb_Host_h_

lldb/trunk/include/lldb/Host/IOObject.h

//===-- IOObject.h ----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Host_Common_IOObject_h_
#define liblldb_Host_Common_IOObject_h_
#include <stdarg.h>
#include <stdio.h>
#include <sys/types.h>
#include "lldb/lldb-private.h"
namespace lldb_private {
class IOObject {
public:
typedef enum {
eFDTypeFile, // Other FD requiring read/write
eFDTypeSocket, // Socket requiring send/recv
} FDType;
// TODO: On Windows this should be a HANDLE, and wait should use
// WaitForMultipleObjects
typedef int WaitableHandle;
static const WaitableHandle kInvalidHandleValue;
IOObject(FDType type, bool should_close)
: m_fd_type(type), m_should_close_fd(should_close) {}
virtual ~IOObject() {}
virtual Status Read(void *buf, size_t &num_bytes) = 0;
virtual Status Write(const void *buf, size_t &num_bytes) = 0;
virtual bool IsValid() const = 0;
virtual Status Close() = 0;
FDType GetFdType() const { return m_fd_type; }
virtual WaitableHandle GetWaitableHandle() = 0;
protected:
FDType m_fd_type;
bool m_should_close_fd; // True if this class should close the file descriptor
// when it goes away.
private:
DISALLOW_COPY_AND_ASSIGN(IOObject);
};
}
#endif

lldb/trunk/include/lldb/Host/MainLoopBase.h

//===-- MainLoopBase.h ------------------------------------------*- C++ -*-===// //===-- MainLoopBase.h ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef lldb_Host_posix_MainLoopBase_h_ #ifndef lldb_Host_posix_MainLoopBase_h_
#define lldb_Host_posix_MainLoopBase_h_ #define lldb_Host_posix_MainLoopBase_h_
#include <functional> #include "lldb/Utility/IOObject.h"
#include "llvm/Support/ErrorHandling.h"
#include "lldb/Host/IOObject.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "llvm/Support/ErrorHandling.h"
#include <functional>
namespace lldb_private { namespace lldb_private {
// The purpose of this class is to enable multiplexed processing of data from // The purpose of this class is to enable multiplexed processing of data from
// different sources // different sources
// without resorting to multi-threading. Clients can register IOObjects, which // without resorting to multi-threading. Clients can register IOObjects, which
// will be monitored // will be monitored
// for readability, and when they become ready, the specified callback will be // for readability, and when they become ready, the specified callback will be
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Host/Socket.h

Show All 9 Lines
#ifndef liblldb_Host_Socket_h_ #ifndef liblldb_Host_Socket_h_
#define liblldb_Host_Socket_h_ #define liblldb_Host_Socket_h_
#include <memory> #include <memory>
#include <string> #include <string>
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "lldb/Host/IOObject.h"
#include "lldb/Host/Predicate.h" #include "lldb/Host/Predicate.h"
#include "lldb/Host/SocketAddress.h" #include "lldb/Host/SocketAddress.h"
#include "lldb/Utility/IOObject.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#ifdef _WIN32 #ifdef _WIN32
#include "lldb/Host/windows/windows.h" #include "lldb/Host/windows/windows.h"
#include <winsock2.h> #include <winsock2.h>
#include <ws2tcpip.h> #include <ws2tcpip.h>
#endif #endif
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

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

Show All 13 Lines
#include <atomic> #include <atomic>
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Connection.h"
#include "lldb/Host/IOObject.h"
#include "lldb/Host/Pipe.h" #include "lldb/Host/Pipe.h"
#include "lldb/Host/Predicate.h" #include "lldb/Host/Predicate.h"
#include "lldb/Utility/Connection.h"
#include "lldb/Utility/IOObject.h"
namespace lldb_private { namespace lldb_private {
class Status; class Status;
class Socket; class Socket;
class SocketAddress; class SocketAddress;
class ConnectionFileDescriptor : public Connection { class ConnectionFileDescriptor : public Connection {
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Host/windows/ConnectionGenericFileWindows.h

//===-- ConnectionGenericFileWindows.h --------------------------*- C++ -*-===// //===-- ConnectionGenericFileWindows.h --------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_Host_windows_ConnectionGenericFileWindows_h_ #ifndef liblldb_Host_windows_ConnectionGenericFileWindows_h_
#define liblldb_Host_windows_ConnectionGenericFileWindows_h_ #define liblldb_Host_windows_ConnectionGenericFileWindows_h_
#include "lldb/Core/Connection.h" #include "lldb/Host/Connection.h"
#include "lldb/Host/windows/windows.h" #include "lldb/Host/windows/windows.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
namespace lldb_private { namespace lldb_private {
class Status; class Status;
class ConnectionGenericFile : public lldb_private::Connection { class ConnectionGenericFile : public lldb_private::Connection {
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Utility/Connection.h

//===-- Connection.h --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Connection_h_
#define liblldb_Connection_h_
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for ConnectionStatus
#include "lldb/lldb-forward.h" // for IOObjectSP
#include "llvm/ADT/StringRef.h" // for StringRef
#include <ratio> // for micro
#include <string>
#include <stddef.h> // for size_t
namespace lldb_private {
class Status;
}
namespace lldb_private {
template <typename Ratio> class Timeout;
}
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Connection Connection.h "lldb/Utility/Connection.h"
/// @brief A communication connection class.
///
/// A class that implements that actual communication functions for
/// connecting/disconnecting, reading/writing, and waiting for bytes
/// to become available from a two way communication connection.
///
/// This class is designed to only do very simple communication
/// functions. Instances can be instantiated and given to a
/// Communication class to perform communications where clients can
/// listen for broadcasts, and perform other higher level communications.
//----------------------------------------------------------------------
class Connection {
public:
//------------------------------------------------------------------
/// Default constructor
//------------------------------------------------------------------
Connection() = default;
//------------------------------------------------------------------
/// Virtual destructor since this class gets subclassed and handed
/// to a Communication object.
//------------------------------------------------------------------
virtual ~Connection();
//------------------------------------------------------------------
/// Connect using the connect string \a url.
///
/// @param[in] url
/// A string that contains all information needed by the
/// subclass to connect to another client.
///
/// @param[out] error_ptr
/// A pointer to an error object that should be given an
/// appropriate error value if this method returns false. This
/// value can be NULL if the error value should be ignored.
///
/// @return
/// \b True if the connect succeeded, \b false otherwise. The
/// internal error object should be filled in with an
/// appropriate value based on the result of this function.
///
/// @see Status& Communication::GetError ();
//------------------------------------------------------------------
virtual lldb::ConnectionStatus Connect(llvm::StringRef url,
Status *error_ptr) = 0;
//------------------------------------------------------------------
/// Disconnect the communications connection if one is currently
/// connected.
///
/// @param[out] error_ptr
/// A pointer to an error object that should be given an
/// appropriate error value if this method returns false. This
/// value can be NULL if the error value should be ignored.
///
/// @return
/// \b True if the disconnect succeeded, \b false otherwise. The
/// internal error object should be filled in with an
/// appropriate value based on the result of this function.
///
/// @see Status& Communication::GetError ();
//------------------------------------------------------------------
virtual lldb::ConnectionStatus Disconnect(Status *error_ptr) = 0;
//------------------------------------------------------------------
/// Check if the connection is valid.
///
/// @return
/// \b True if this object is currently connected, \b false
/// otherwise.
//------------------------------------------------------------------
virtual bool IsConnected() const = 0;
//------------------------------------------------------------------
/// The read function that attempts to read from the connection.
///
/// @param[in] dst
/// A destination buffer that must be at least \a dst_len bytes
/// long.
///
/// @param[in] dst_len
/// The number of bytes to attempt to read, and also the max
/// number of bytes that can be placed into \a dst.
///
/// @param[in] timeout
/// The number of microseconds to wait for the data.
///
/// @param[out] status
/// On return, indicates whether the call was successful or terminated
/// due to some error condition.
///
/// @param[out] error_ptr
/// A pointer to an error object that should be given an
/// appropriate error value if this method returns zero. This
/// value can be NULL if the error value should be ignored.
///
/// @return
/// The number of bytes actually read.
///
/// @see size_t Communication::Read (void *, size_t, uint32_t);
//------------------------------------------------------------------
virtual size_t Read(void *dst, size_t dst_len,
const Timeout<std::micro> &timeout,
lldb::ConnectionStatus &status, Status *error_ptr) = 0;
//------------------------------------------------------------------
/// The actual write function that attempts to write to the
/// communications protocol.
///
/// Subclasses must override this function.
///
/// @param[in] dst
/// A desination buffer that must be at least \a dst_len bytes
/// long.
///
/// @param[in] dst_len
/// The number of bytes to attempt to write, and also the
/// number of bytes are currently available in \a dst.
///
/// @param[out] error_ptr
/// A pointer to an error object that should be given an
/// appropriate error value if this method returns zero. This
/// value can be NULL if the error value should be ignored.
///
/// @return
/// The number of bytes actually Written.
//------------------------------------------------------------------
virtual size_t Write(const void *dst, size_t dst_len,
lldb::ConnectionStatus &status, Status *error_ptr) = 0;
//------------------------------------------------------------------
/// Returns a URI that describes this connection object
///
/// Subclasses may override this function.
///
/// @return
/// Returns URI or an empty string if disconnecteds
//------------------------------------------------------------------
virtual std::string GetURI() = 0;
//------------------------------------------------------------------
/// Interrupts an ongoing Read() operation.
///
/// If there is an ongoing read operation in another thread, this operation
/// return with status == eConnectionStatusInterrupted. Note that if there
/// data waiting to be read and an interrupt request is issued, the Read()
/// function will return the data immediately without processing the
/// interrupt request (which will remain queued for the next Read()
/// operation).
///
/// @return
/// Returns true is the interrupt request was successful.
//------------------------------------------------------------------
virtual bool InterruptRead() = 0;
//------------------------------------------------------------------
/// Returns the underlying IOObject used by the Connection.
///
/// The IOObject can be used to wait for data to become available
/// on the connection. If the Connection does not use IOObjects (and
/// hence does not support waiting) this function should return a
/// null pointer.
///
/// @return
/// The underlying IOObject used for reading.
//------------------------------------------------------------------
virtual lldb::IOObjectSP GetReadObject() { return lldb::IOObjectSP(); }
private:
//------------------------------------------------------------------
// For Connection only
//------------------------------------------------------------------
DISALLOW_COPY_AND_ASSIGN(Connection);
};
} // namespace lldb_private
#endif // liblldb_Connection_h_

lldb/trunk/include/lldb/Utility/IOObject.h

//===-- IOObject.h ----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Host_Common_IOObject_h_
#define liblldb_Host_Common_IOObject_h_
#include <stdarg.h>
#include <stdio.h>
#include <sys/types.h>
#include "lldb/lldb-private.h"
namespace lldb_private {
class IOObject {
public:
typedef enum {
eFDTypeFile, // Other FD requiring read/write
eFDTypeSocket, // Socket requiring send/recv
} FDType;
// TODO: On Windows this should be a HANDLE, and wait should use
// WaitForMultipleObjects
typedef int WaitableHandle;
static const WaitableHandle kInvalidHandleValue;
IOObject(FDType type, bool should_close)
: m_fd_type(type), m_should_close_fd(should_close) {}
virtual ~IOObject();
virtual Status Read(void *buf, size_t &num_bytes) = 0;
virtual Status Write(const void *buf, size_t &num_bytes) = 0;
virtual bool IsValid() const = 0;
virtual Status Close() = 0;
FDType GetFdType() const { return m_fd_type; }
virtual WaitableHandle GetWaitableHandle() = 0;
protected:
FDType m_fd_type;
bool m_should_close_fd; // True if this class should close the file descriptor
// when it goes away.
private:
DISALLOW_COPY_AND_ASSIGN(IOObject);
};
} // namespace lldb_private
#endif

lldb/trunk/source/API/SBCommunication.cpp

//===-- SBCommunication.cpp -------------------------------------*- C++ -*-===// //===-- SBCommunication.cpp -------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/API/SBCommunication.h" #include "lldb/API/SBCommunication.h"
#include "lldb/API/SBBroadcaster.h" #include "lldb/API/SBBroadcaster.h"
#include "lldb/Core/Communication.h" #include "lldb/Core/Communication.h"
#include "lldb/Host/ConnectionFileDescriptor.h" #include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/Host.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
SBCommunication::SBCommunication() : m_opaque(NULL), m_opaque_owned(false) {} SBCommunication::SBCommunication() : m_opaque(NULL), m_opaque_owned(false) {}
SBCommunication::SBCommunication(const char *broadcaster_name) SBCommunication::SBCommunication(const char *broadcaster_name)
Show All 24 Lines
void SBCommunication::SetCloseOnEOF(bool b) { void SBCommunication::SetCloseOnEOF(bool b) {
if (m_opaque) if (m_opaque)
m_opaque->SetCloseOnEOF(b); m_opaque->SetCloseOnEOF(b);
} }
ConnectionStatus SBCommunication::Connect(const char *url) { ConnectionStatus SBCommunication::Connect(const char *url) {
if (m_opaque) { if (m_opaque) {
if (!m_opaque->HasConnection()) if (!m_opaque->HasConnection())
m_opaque->SetConnection(Connection::CreateDefaultConnection(url)); m_opaque->SetConnection(Host::CreateDefaultConnection(url).release());
return m_opaque->Connect(url, NULL); return m_opaque->Connect(url, NULL);
} }
return eConnectionStatusNoConnection; return eConnectionStatusNoConnection;
} }
ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) { ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
▲ Show 20 Lines • Show All 192 Lines • Show Last 20 Lines

lldb/trunk/source/Core/CMakeLists.txt

add_lldb_library(lldbCore add_lldb_library(lldbCore
Address.cpp Address.cpp
AddressRange.cpp AddressRange.cpp
AddressResolver.cpp AddressResolver.cpp
AddressResolverFileLine.cpp AddressResolverFileLine.cpp
AddressResolverName.cpp AddressResolverName.cpp
ArchSpec.cpp ArchSpec.cpp
Broadcaster.cpp Broadcaster.cpp
Communication.cpp Communication.cpp
Connection.cpp
Debugger.cpp Debugger.cpp
Disassembler.cpp Disassembler.cpp
DumpDataExtractor.cpp DumpDataExtractor.cpp
DynamicLoader.cpp DynamicLoader.cpp
EmulateInstruction.cpp EmulateInstruction.cpp
Event.cpp Event.cpp
FileLineResolver.cpp FileLineResolver.cpp
FileSpecList.cpp FileSpecList.cpp
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Communication.cpp

//===-- Communication.cpp ---------------------------------------*- C++ -*-===// //===-- Communication.cpp ---------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/Communication.h" #include "lldb/Core/Communication.h"
#include "lldb/Core/Connection.h"
#include "lldb/Core/Event.h" #include "lldb/Core/Event.h"
#include "lldb/Core/Listener.h" #include "lldb/Core/Listener.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Host/ThreadLauncher.h" #include "lldb/Host/ThreadLauncher.h"
#include "lldb/Utility/Connection.h"
#include "lldb/Utility/ConstString.h" // for ConstString #include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/Logging.h" // for LogIfAnyCategoriesSet, LIBLLDB... #include "lldb/Utility/Logging.h" // for LogIfAnyCategoriesSet, LIBLLDB...
#include "lldb/Utility/Status.h" // for Status #include "lldb/Utility/Status.h" // for Status
#include "llvm/ADT/None.h" // for None #include "llvm/ADT/None.h" // for None
#include "llvm/ADT/Optional.h" // for Optional #include "llvm/ADT/Optional.h" // for Optional
#include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH #include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH
▲ Show 20 Lines • Show All 399 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Connection.cpp

//===-- Connection.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/Core/Connection.h"
#if defined(_WIN32)
#include "lldb/Host/windows/ConnectionGenericFileWindows.h"
#endif
#include "lldb/Host/ConnectionFileDescriptor.h"
#include <string.h> // for strstr
using namespace lldb_private;
Connection::Connection() {}
Connection::~Connection() {}
Connection *Connection::CreateDefaultConnection(const char *url) {
#if defined(_WIN32)
if (strstr(url, "file://") == url)
return new ConnectionGenericFile();
#endif
return new ConnectionFileDescriptor();
}

lldb/trunk/source/Host/CMakeLists.txt

macro(add_host_subdirectory group) macro(add_host_subdirectory group)
list(APPEND HOST_SOURCES ${ARGN}) list(APPEND HOST_SOURCES ${ARGN})
source_group(${group} FILES ${ARGN}) source_group(${group} FILES ${ARGN})
endmacro() endmacro()
add_host_subdirectory(common add_host_subdirectory(common
common/File.cpp common/File.cpp
common/FileCache.cpp common/FileCache.cpp
common/FileSystem.cpp common/FileSystem.cpp
common/GetOptInc.cpp common/GetOptInc.cpp
common/Host.cpp common/Host.cpp
common/HostInfoBase.cpp common/HostInfoBase.cpp
common/HostNativeThreadBase.cpp common/HostNativeThreadBase.cpp
common/HostProcess.cpp common/HostProcess.cpp
common/HostThread.cpp common/HostThread.cpp
common/IOObject.cpp
common/LockFileBase.cpp common/LockFileBase.cpp
common/MainLoop.cpp common/MainLoop.cpp
common/MonitoringProcessLauncher.cpp common/MonitoringProcessLauncher.cpp
common/NativeBreakpoint.cpp common/NativeBreakpoint.cpp
common/NativeBreakpointList.cpp common/NativeBreakpointList.cpp
common/NativeWatchpointList.cpp common/NativeWatchpointList.cpp
common/NativeProcessProtocol.cpp common/NativeProcessProtocol.cpp
common/NativeRegisterContext.cpp common/NativeRegisterContext.cpp
▲ Show 20 Lines • Show All 150 Lines • Show Last 20 Lines

lldb/trunk/source/Host/common/Host.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Host/HostProcess.h" #include "lldb/Host/HostProcess.h"
#include "lldb/Host/MonitoringProcessLauncher.h" #include "lldb/Host/MonitoringProcessLauncher.h"
#include "lldb/Host/Predicate.h" #include "lldb/Host/Predicate.h"
#include "lldb/Host/ProcessLauncher.h" #include "lldb/Host/ProcessLauncher.h"
#include "lldb/Host/ThreadLauncher.h" #include "lldb/Host/ThreadLauncher.h"
#include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
#include "lldb/Target/FileAction.h" #include "lldb/Target/FileAction.h"
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Target/UnixSignals.h" #include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/CleanUp.h" #include "lldb/Utility/CleanUp.h"
#include "lldb/Utility/DataBufferLLVM.h" #include "lldb/Utility/DataBufferLLVM.h"
#include "lldb/Utility/FileSpec.h" #include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "lldb/lldb-private-forward.h" #include "lldb/lldb-private-forward.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/Errno.h" #include "llvm/Support/Errno.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#if defined(_WIN32) #if defined(_WIN32)
#include "lldb/Host/windows/ConnectionGenericFileWindows.h"
#include "lldb/Host/windows/ProcessLauncherWindows.h" #include "lldb/Host/windows/ProcessLauncherWindows.h"
#else #else
#include "lldb/Host/posix/ProcessLauncherPosixFork.h" #include "lldb/Host/posix/ProcessLauncherPosixFork.h"
#endif #endif
#if defined(__APPLE__) #if defined(__APPLE__)
#ifndef _POSIX_SPAWN_DISABLE_ASLR #ifndef _POSIX_SPAWN_DISABLE_ASLR
#define _POSIX_SPAWN_DISABLE_ASLR 0x0100 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
▲ Show 20 Lines • Show All 535 Lines • ▼ Show 20 Lines
#endif #endif
const UnixSignalsSP &Host::GetUnixSignals() { const UnixSignalsSP &Host::GetUnixSignals() {
static const auto s_unix_signals_sp = static const auto s_unix_signals_sp =
UnixSignals::Create(HostInfo::GetArchitecture()); UnixSignals::Create(HostInfo::GetArchitecture());
return s_unix_signals_sp; return s_unix_signals_sp;
} }
std::unique_ptr<Connection> Host::CreateDefaultConnection(llvm::StringRef url) {
#if defined(_WIN32)
if (url.startswith("file://"))
return std::unique_ptr<Connection>(new ConnectionGenericFile());
#endif
return std::unique_ptr<Connection>(new ConnectionFileDescriptor());
}
#if defined(LLVM_ON_UNIX) #if defined(LLVM_ON_UNIX)
WaitStatus WaitStatus::Decode(int wstatus) { WaitStatus WaitStatus::Decode(int wstatus) {
if (WIFEXITED(wstatus)) if (WIFEXITED(wstatus))
return {Exit, uint8_t(WEXITSTATUS(wstatus))}; return {Exit, uint8_t(WEXITSTATUS(wstatus))};
else if (WIFSIGNALED(wstatus)) else if (WIFSIGNALED(wstatus))
return {Signal, uint8_t(WTERMSIG(wstatus))}; return {Signal, uint8_t(WTERMSIG(wstatus))};
else if (WIFSTOPPED(wstatus)) else if (WIFSTOPPED(wstatus))
return {Stop, uint8_t(WSTOPSIG(wstatus))}; return {Stop, uint8_t(WSTOPSIG(wstatus))};
Show All 39 Lines

lldb/trunk/source/Host/common/IOObject.cpp

//===-- IOObject.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/Host/IOObject.h"
using namespace lldb_private;
const IOObject::WaitableHandle IOObject::kInvalidHandleValue = -1;

lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp

Show All 10 Lines
// Enable this special support for Apple builds where we can have unlimited // 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 // select bounds. We tried switching to poll() and kqueue and we were panicing
// the kernel, so we have to stick with select for now. // the kernel, so we have to stick with select for now.
#define _DARWIN_UNLIMITED_SELECT #define _DARWIN_UNLIMITED_SELECT
#endif #endif
#include "lldb/Host/posix/ConnectionFileDescriptorPosix.h" #include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
#include "lldb/Host/Config.h" #include "lldb/Host/Config.h"
#include "lldb/Host/IOObject.h"
#include "lldb/Host/Socket.h" #include "lldb/Host/Socket.h"
#include "lldb/Host/SocketAddress.h" #include "lldb/Host/SocketAddress.h"
#include "lldb/Utility/SelectHelper.h" #include "lldb/Utility/SelectHelper.h"
#include "lldb/Utility/Timeout.h"
// C Includes // C Includes
#include <errno.h> #include <errno.h>
#include <fcntl.h> #include <fcntl.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <sys/types.h> #include <sys/types.h>
#ifndef LLDB_DISABLE_POSIX #ifndef LLDB_DISABLE_POSIX
#include <termios.h> #include <termios.h>
#endif #endif
// C++ Includes // C++ Includes
#include <sstream> #include <sstream>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/Support/Errno.h" #include "llvm/Support/Errno.h"
#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorHandling.h"
#if defined(__APPLE__) #if defined(__APPLE__)
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#endif #endif
// Project includes // Project includes
#include "lldb/Core/Communication.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/Socket.h" #include "lldb/Host/Socket.h"
#include "lldb/Host/common/TCPSocket.h" #include "lldb/Host/common/TCPSocket.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
▲ Show 20 Lines • Show All 739 Lines • Show Last 20 Lines

lldb/trunk/source/Utility/CMakeLists.txt

add_lldb_library(lldbUtility add_lldb_library(lldbUtility
Baton.cpp Baton.cpp
Connection.cpp
ConstString.cpp ConstString.cpp
DataBufferHeap.cpp DataBufferHeap.cpp
DataBufferLLVM.cpp DataBufferLLVM.cpp
DataEncoder.cpp DataEncoder.cpp
DataExtractor.cpp DataExtractor.cpp
FastDemangle.cpp FastDemangle.cpp
FileSpec.cpp FileSpec.cpp
History.cpp History.cpp
IOObject.cpp
JSON.cpp JSON.cpp
LLDBAssert.cpp LLDBAssert.cpp
Log.cpp Log.cpp
Logging.cpp Logging.cpp
NameMatches.cpp NameMatches.cpp
Range.cpp Range.cpp
RegularExpression.cpp RegularExpression.cpp
SelectHelper.cpp SelectHelper.cpp
Show All 25 Lines

lldb/trunk/source/Utility/Connection.cpp

//===-- Connection.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/Connection.h"
using namespace lldb_private;
Connection::~Connection() = default;

lldb/trunk/source/Utility/IOObject.cpp

//===-- IOObject.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/IOObject.h"
using namespace lldb_private;
const IOObject::WaitableHandle IOObject::kInvalidHandleValue = -1;
IOObject::~IOObject() = default;

lldb/trunk/tools/lldb-server/Acceptor.h

//===-- Acceptor.h ----------------------------------------------*- C++ -*-===// //===-- Acceptor.h ----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef lldb_server_Acceptor_h_ #ifndef lldb_server_Acceptor_h_
#define lldb_server_Acceptor_h_ #define lldb_server_Acceptor_h_
#include "lldb/Core/Connection.h"
#include "lldb/Host/Socket.h" #include "lldb/Host/Socket.h"
#include "lldb/Utility/Connection.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <string> #include <string>
namespace llvm { namespace llvm {
class StringRef; class StringRef;
Show All 40 Lines
lldb/trunk/source/Host/common/Host.cpp