Clean up lldb-types.h

[labath]

Summary

It defined a couple of types (condition_t) which we don't use anymore,
as we have c++11 goodies now. I remove these definitions.

Also it unnecessarily included a couple of headers which weren't
necessary for it's operation. I remove these, and place the includes in
the relevant files (usually .cpp, usually in Host code) which use them.
This allows us to reduce namespace pollution in most of the lldb files
which don't need the OS-specific definitions.

[krytarowski]

source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.cpp

18 ↗

(On Diff #105603)

Is this needed here?

[labath]

source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.cpp

18 ↗

(On Diff #105603)

good point. I'm pretty sure it isn't.

[labath]

Remove unused include from auxvector.h

[Eugene.Zelenko]

include/lldb/Host/MainLoop.h

16 ↗

(On Diff #105613)

I think will be good idea to include csignal instead. Same in other files. See http://clang.llvm.org/extra/clang-tidy/checks/modernize-deprecated-headers.html.

[labath]

include/lldb/Host/MainLoop.h

16 ↗

(On Diff #105613)

Good idea. I wasn't aware <csignal> existed.

[labath]

Use csignal instead of signal.h

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

 //===-- MainLoop.h ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_MainLoop_h_
 #define lldb_Host_MainLoop_h_
 
 #include "lldb/Host/Config.h"
 #include "lldb/Host/MainLoopBase.h"
-
 #include "llvm/ADT/DenseMap.h"
+#include <csignal>
 
 #if !HAVE_PPOLL && !HAVE_SYS_EVENT_H
 #define SIGNAL_POLLING_UNSUPPORTED 1
 #endif
 
 namespace lldb_private {
 
 // Implementation of the MainLoopBase class. It can monitor file descriptors for

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

 #define liblldb_Host_PosixApi_h
 
 // This file defines platform specific functions, macros, and types necessary
 // to provide a minimum level of compatibility across all platforms to rely
 // on various posix api functionality.
 
 #if defined(_WIN32)
 #include "lldb/Host/windows/PosixApi.h"
+#else
+#include <unistd.h>
 #endif
 
 #endif

lldb/trunk/include/lldb/Utility/DataExtractor.h

 #ifndef LLDB_UTILITY_DATAEXTRACTOR_H
 #define LLDB_UTILITY_DATAEXTRACTOR_H
 
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-enumerations.h" // for ByteOrder
 #include "lldb/lldb-forward.h"      // for DataBufferSP
 #include "lldb/lldb-types.h"
 
+#include <cassert>
 #include <stdint.h>
 #include <string.h>
 
 namespace lldb_private {
 class Log;
 }
 namespace lldb_private {
 class Stream;

lldb/trunk/include/lldb/lldb-types.h

 //===-- lldb-types.h --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_lldb_types_h_
 #define LLDB_lldb_types_h_
 
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 
-#include <assert.h>
-#include <signal.h>
 #include <stdint.h>
 
 //----------------------------------------------------------------------
 // All host systems must define:
-//  lldb::condition_t       The native condition type (or a substitute class)
-//  for conditions on the host system.
-//  lldb::mutex_t           The native mutex type for mutex objects on the host
-//  system.
 //  lldb::thread_t          The native thread type for spawned threads on the
 //  system
 //  lldb::thread_arg_t      The type of the one any only thread creation
 //  argument for the host system
 //  lldb::thread_result_t   The return type that gets returned when a thread
 //  finishes.
 //  lldb::thread_func_t     The function prototype used to spawn a thread on the
 //  host system.
 //  #define LLDB_INVALID_PROCESS_ID ...
 //  #define LLDB_INVALID_THREAD_ID ...
 //  #define LLDB_INVALID_HOST_THREAD ...
-//  #define IS_VALID_LLDB_HOST_THREAD ...
 //----------------------------------------------------------------------
 
 // TODO: Add a bunch of ifdefs to determine the host system and what
 // things should be defined. Currently MacOSX is being assumed by default
 // since that is what lldb was first developed for.
 
-#ifndef _MSC_VER
-#include <stdbool.h>
-#include <unistd.h>
-#endif
-
 #ifdef _WIN32
 
 #include <process.h>
 
 namespace lldb {
-typedef void *mutex_t;
-typedef void *condition_t;
 typedef void *rwlock_t;
 typedef void *process_t;             // Process type is HANDLE
 typedef void *thread_t;              // Host thread type
 typedef void *file_t;                // Host file type
-typedef void *pipe_t;                // Host pipe type
 typedef unsigned int __w64 socket_t; // Host socket type
-typedef uint32_t thread_key_t;
 typedef void *thread_arg_t;                       // Host thread argument type
 typedef unsigned thread_result_t;                 // Host thread result type
 typedef thread_result_t (*thread_func_t)(void *); // Host thread function type
 }
 
 #else
 
 #include <pthread.h>
 
 namespace lldb {
 //----------------------------------------------------------------------
 // MacOSX Types
 //----------------------------------------------------------------------
-typedef ::pthread_mutex_t mutex_t;
-typedef pthread_cond_t condition_t;
 typedef pthread_rwlock_t rwlock_t;
 typedef uint64_t process_t; // Process type is just a pid.
 typedef pthread_t thread_t; // Host thread type
 typedef int file_t;         // Host file type
-typedef int pipe_t;         // Host pipe type
 typedef int socket_t;       // Host socket type
-typedef pthread_key_t thread_key_t;
 typedef void *thread_arg_t;             // Host thread argument type
 typedef void *thread_result_t;          // Host thread result type
 typedef void *(*thread_func_t)(void *); // Host thread function type
 } // namespace lldb
 
 #endif
 
 namespace lldb {
 typedef void (*LogOutputCallback)(const char *, void *baton);
 typedef bool (*CommandOverrideCallback)(void *baton, const char **argv);
 typedef bool (*CommandOverrideCallbackWithResult)(
     void *baton, const char **argv, lldb_private::CommandReturnObject &result);
 typedef bool (*ExpressionCancelCallback)(ExpressionEvaluationPhase phase,
                                          void *baton);
 }
 
 #define LLDB_INVALID_PROCESS ((lldb::process_t)-1)
 #define LLDB_INVALID_HOST_THREAD ((lldb::thread_t)NULL)
-#define IS_VALID_LLDB_HOST_THREAD(t) ((t) != LLDB_INVALID_HOST_THREAD)
-
-#define LLDB_INVALID_HOST_TIME                                                 \
-  { 0, 0 }
 
 namespace lldb {
 typedef uint64_t addr_t;
 typedef uint64_t user_id_t;
 typedef uint64_t pid_t;
 typedef uint64_t tid_t;
 typedef uint64_t offset_t;
 typedef int32_t break_id_t;
 typedef int32_t watch_id_t;
 typedef void *opaque_compiler_type_t;
 typedef uint64_t queue_id_t;
 }
 
 #endif // LLDB_lldb_types_h_

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

 #include <stdio.h>
 
 #ifdef _WIN32
 #include "lldb/Host/windows/windows.h"
 #else
 #include <sys/ioctl.h>
 #include <sys/stat.h>
 #include <termios.h>
+#include <unistd.h>
 #endif
 
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Process.h" // for llvm::sys::Process::FileDescriptorHasColors()
 
 #include "lldb/Host/Config.h"

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

 #include "lldb/Host/posix/DomainSocket.h"
 
 #include <arpa/inet.h>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <sys/socket.h>
 #include <sys/un.h>
+#include <unistd.h>
 #endif
 
 #ifdef __linux__
 #include "lldb/Host/linux/AbstractSocket.h"
 #endif
 
 #ifdef __ANDROID__
 #include <arpa/inet.h>

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

 #if defined(LLVM_ON_WIN32)
 #include <winsock2.h>
 #endif
 
 #ifdef LLVM_ON_WIN32
 #define CLOSE_SOCKET closesocket
 typedef const char *set_socket_option_arg_type;
 #else
+#include <unistd.h>
 #define CLOSE_SOCKET ::close
 typedef const void *set_socket_option_arg_type;
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {

lldb/trunk/source/Host/linux/Host.cpp

 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
+#include <unistd.h>
 
 // C++ Includes
 // Other libraries and framework includes
 #include "llvm/Support/ScopedPrinter.h"
 // Project includes
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"

lldb/trunk/source/Host/linux/HostInfoLinux.cpp

 #include "lldb/Utility/Log.h"
 
 #include "llvm/Support/Threading.h"
 
 #include <limits.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/utsname.h>
+#include <unistd.h>
 
 #include <algorithm>
 #include <mutex> // std::once
 
 using namespace lldb_private;
 
 namespace {
 struct HostInfoLinuxFields {

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

 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 
 #ifndef LLDB_DISABLE_POSIX
 #include <termios.h>
+#include <unistd.h>
 #endif
 
 // C++ Includes
 #include <sstream>
 
 // Other libraries and framework includes
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/ErrorHandling.h"

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

 #include "lldb/Host/FileSystem.h"
 
 // C includes
 #include <dirent.h>
 #include <sys/mount.h>
 #include <sys/param.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <unistd.h>
 #ifdef __linux__
 #include <linux/magic.h>
 #include <sys/mount.h>
 #include <sys/statfs.h>
 #endif
 #if defined(__NetBSD__)
 #include <sys/statvfs.h>
 #endif

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

 //===-- HostProcessPosix.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/Host.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/posix/HostProcessPosix.h"
 
 #include "llvm/ADT/STLExtras.h"
 
+#include <csignal>
 #include <limits.h>
+#include <unistd.h>
 
 using namespace lldb_private;
 
 namespace {
 const int kInvalidPosixProcess = 0;
 }
 
 HostProcessPosix::HostProcessPosix()

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

 //===-- LockFilePosix.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/posix/LockFilePosix.h"
 
 #include <fcntl.h>
+#include <unistd.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 
 Status fileLock(int fd, int cmd, int lock_type, const uint64_t start,
                 const uint64_t len) {

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

 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "llvm/Support/Errno.h"
 
 #include <limits.h>
 #include <sys/ptrace.h>
 #include <sys/wait.h>
+#include <unistd.h>
 
 #include <sstream>
 
 #ifdef __ANDROID__
 #include <android/api-level.h>
 #define PT_TRACE_ME PTRACE_TRACEME
 #endif
 

lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.cpp

 //===-- AuxVector.cpp -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// C Includes
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-// C++ Includes
-// Other libraries and framework includes
+#include "AuxVector.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
 
-#if defined(__linux__) || defined(__FreeBSD__)
-#include "Plugins/Process/elf-core/ProcessElfCore.h"
-#endif
-
-#include "AuxVector.h"
-
 using namespace lldb;
 using namespace lldb_private;
 
 static bool GetMaxU64(DataExtractor &data, lldb::offset_t *offset_ptr,
                       uint64_t *value, unsigned int byte_size) {
   lldb::offset_t saved_offset = *offset_ptr;
   *value = data.GetMaxU64(offset_ptr, byte_size);
   return *offset_ptr != saved_offset;

lldb/trunk/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
+#include "lldb/Host/PosixApi.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/UriParser.h"
 

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.h

 //===-- NativeProcessLinux.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_NativeProcessLinux_H_
 #define liblldb_NativeProcessLinux_H_
 
-// C++ Includes
+#include <csignal>
 #include <unordered_set>
 
 // Other libraries and framework includes
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Host/Debug.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/linux/Support.h"
 #include "lldb/Target/MemoryRegionInfo.h"

lldb/trunk/source/Plugins/Process/Linux/NativeThreadLinux.h

 //===-- NativeThreadLinux.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_NativeThreadLinux_H_
 #define liblldb_NativeThreadLinux_H_
 
 #include "SingleStepCheck.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "lldb/lldb-private-forward.h"
 
+#include <csignal>
 #include <map>
 #include <memory>
 #include <string>
 
 namespace lldb_private {
 namespace process_linux {
 
 class NativeProcessLinux;

lldb/trunk/source/Plugins/Process/Linux/ProcessorTrace.h

 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/TraceOptions.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 
 #include <linux/perf_event.h>
 #include <sys/mman.h>
+#include <unistd.h>
 
 namespace lldb_private {
 
 namespace process_linux {
 
 // ---------------------------------------------------------------------
 // This class keeps track of one tracing instance of
 // Intel(R) Processor Trace on Linux OS. There is a map keeping track

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/State.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Debug.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
+#include "lldb/Host/PosixApi.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeRegisterContext.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/Endian.h"

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 
 // C Includes
 #include <errno.h>
 #include <stdlib.h>
 #ifndef LLDB_DISABLE_POSIX
 #include <netinet/in.h>
 #include <sys/mman.h> // for mmap
 #include <sys/socket.h>
+#include <unistd.h>
 #endif
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <time.h>
 
 // C++ Includes
 #include <algorithm>
 #include <map>
 #include <mutex>
 #include <sstream>
 
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostThread.h"
+#include "lldb/Host/PosixApi.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObject.h"

lldb/trunk/source/Target/Target.cpp

 #include "lldb/Core/Section.h"
 #include "lldb/Core/SourceManager.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Expression/REPL.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/PosixApi.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionGroupWatchpoint.h"
 #include "lldb/Interpreter/OptionValues.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"

lldb/trunk/tools/driver/Driver.cpp

 //===-- Driver.cpp ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 
+#include <csignal>
 #include <fcntl.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 // Includes for pipe()
 #if defined(_WIN32)

lldb/trunk/tools/lldb-mi/MICmnLLDBDebugger.cpp

 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/API/SBThread.h"
 #include "lldb/API/SBType.h"
 #include "lldb/API/SBTypeCategory.h"
 #include "lldb/API/SBTypeNameSpecifier.h"
 #include "lldb/API/SBTypeSummary.h"
+#include <cassert>
 
 // In-house headers:
 #include "MICmnLLDBDebugSessionInfo.h"
 #include "MICmnLLDBDebugger.h"
 #include "MICmnLLDBDebuggerHandleEvents.h"
 #include "MICmnLog.h"
 #include "MICmnResources.h"
 #include "MICmnThreadMgrStd.h"

lldb/trunk/tools/lldb-mi/MIDriver.cpp

 //===-- MIDriver.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Third party headers:
 #include "lldb/API/SBError.h"
+#include <cassert>
+#include <csignal>
 #include <fstream>
 
 // In-house headers:
 #include "MICmdArgValFile.h"
 #include "MICmdArgValString.h"
 #include "MICmdMgr.h"
 #include "MICmnConfig.h"
 #include "MICmnLLDBDebugSessionInfo.h"

lldb/trunk/tools/lldb-mi/MIDriverMain.cpp

 
 #if defined(_MSC_VER)
 #define _INC_SIGNAL // Stop window's signal.h being included -
                     // CODETAG_IOR_SIGNALS
 #endif              // _MSC_VER
 
 // Third party headers:
 #include "lldb/API/SBHostOS.h"
+#include <csignal>
 #include <stdio.h>
 
 // In house headers:
 #include "MICmnConfig.h"
 #include "MICmnResources.h"
 #include "MICmnStreamStdin.h"
 #include "MIDriver.h"
 #include "MIDriverMgr.h"