diff options
| author | Jonas Devlieghere <jonas@devlieghere.com> | 2019-04-10 20:48:55 +0000 |
|---|---|---|
| committer | Jonas Devlieghere <jonas@devlieghere.com> | 2019-04-10 20:48:55 +0000 |
| commit | 8b3af63b8993e45b1783853a3fcf6f36bfbed81b (patch) | |
| tree | 41759d08361beda32b90e345d8033aecd2e15088 /lldb/tools/debugserver | |
| parent | 66b6bb1766b3e5eea56b26fc91d03f1fccbe15e4 (diff) | |
| download | bcm5719-llvm-8b3af63b8993e45b1783853a3fcf6f36bfbed81b.tar.gz bcm5719-llvm-8b3af63b8993e45b1783853a3fcf6f36bfbed81b.zip | |
[NFC] Remove ASCII lines from comments
A lot of comments in LLDB are surrounded by an ASCII line to delimit the
begging and end of the comment.
Its use is not really consistent across the code base, sometimes the
lines are longer, sometimes they are shorter and sometimes they are
omitted. Furthermore, it looks kind of weird with the 80 column limit,
where the comment actually extends past the line, but not by much.
Furthermore, when /// is used for Doxygen comments, it looks
particularly odd. And when // is used, it incorrectly gives the
impression that it's actually a Doxygen comment.
I assume these lines were added to improve distinguishing between
comments and code. However, given that todays editors and IDEs do a
great job at highlighting comments, I think it's worth to drop this for
the sake of consistency. The alternative is fixing all the
inconsistencies, which would create a lot more churn.
Differential revision: https://reviews.llvm.org/D60508
llvm-svn: 358135
Diffstat (limited to 'lldb/tools/debugserver')
37 files changed, 0 insertions, 331 deletions
diff --git a/lldb/tools/debugserver/source/DNB.cpp b/lldb/tools/debugserver/source/DNB.cpp index 6b57d488b2f..cb02ee06807 100644 --- a/lldb/tools/debugserver/source/DNB.cpp +++ b/lldb/tools/debugserver/source/DNB.cpp @@ -62,12 +62,10 @@ static size_t GetAllInfosMatchingName(const char *process_name, std::vector<struct kinfo_proc> &matching_proc_infos); -//---------------------------------------------------------------------- // A Thread safe singleton to get a process map pointer. // // Returns a pointer to the existing process map, or a pointer to a // newly created process map if CAN_CREATE is non-zero. -//---------------------------------------------------------------------- static ProcessMap *GetProcessMap(bool can_create) { static ProcessMap *g_process_map_ptr = NULL; @@ -80,13 +78,11 @@ static ProcessMap *GetProcessMap(bool can_create) { return g_process_map_ptr; } -//---------------------------------------------------------------------- // Add PID to the shared process pointer map. // // Return non-zero value if we succeed in adding the process to the map. // The only time this should fail is if we run out of memory and can't // allocate a ProcessMap. -//---------------------------------------------------------------------- static nub_bool_t AddProcessToMap(nub_process_t pid, MachProcessSP &procSP) { ProcessMap *process_map = GetProcessMap(true); if (process_map) { @@ -96,11 +92,9 @@ static nub_bool_t AddProcessToMap(nub_process_t pid, MachProcessSP &procSP) { return false; } -//---------------------------------------------------------------------- // Remove the shared pointer for PID from the process map. // // Returns the number of items removed from the process map. -//---------------------------------------------------------------------- // static size_t // RemoveProcessFromMap (nub_process_t pid) //{ @@ -112,12 +106,10 @@ static nub_bool_t AddProcessToMap(nub_process_t pid, MachProcessSP &procSP) { // return 0; //} -//---------------------------------------------------------------------- // Get the shared pointer for PID from the existing process map. // // Returns true if we successfully find a shared pointer to a // MachProcess object. -//---------------------------------------------------------------------- static nub_bool_t GetProcessSP(nub_process_t pid, MachProcessSP &procSP) { ProcessMap *process_map = GetProcessMap(false); if (process_map != NULL) { @@ -811,9 +803,7 @@ nub_bool_t DNBProcessIsAlive(nub_process_t pid) { return eStateInvalid; } -//---------------------------------------------------------------------- // Process and Thread state information -//---------------------------------------------------------------------- nub_state_t DNBProcessGetState(nub_process_t pid) { MachProcessSP procSP; if (GetProcessSP(pid, procSP)) { @@ -822,9 +812,7 @@ nub_state_t DNBProcessGetState(nub_process_t pid) { return eStateInvalid; } -//---------------------------------------------------------------------- // Process and Thread state information -//---------------------------------------------------------------------- nub_bool_t DNBProcessGetExitStatus(nub_process_t pid, int *status) { MachProcessSP procSP; if (GetProcessSP(pid, procSP)) { @@ -1031,9 +1019,7 @@ const char *DNBProcessGetArgumentAtIndex(nub_process_t pid, nub_size_t idx) { return NULL; } -//---------------------------------------------------------------------- // Execution control -//---------------------------------------------------------------------- nub_bool_t DNBProcessResume(nub_process_t pid, const DNBThreadResumeAction *actions, size_t num_actions) { @@ -1128,9 +1114,7 @@ nub_bool_t DNBBreakpointClear(nub_process_t pid, nub_addr_t addr) { return false; // Failed } -//---------------------------------------------------------------------- // Watchpoints -//---------------------------------------------------------------------- nub_bool_t DNBWatchpointSet(nub_process_t pid, nub_addr_t addr, nub_size_t size, uint32_t watch_flags, nub_bool_t hardware) { MachProcessSP procSP; @@ -1146,9 +1130,7 @@ nub_bool_t DNBWatchpointClear(nub_process_t pid, nub_addr_t addr) { return false; // Failed } -//---------------------------------------------------------------------- // Return the number of supported hardware watchpoints. -//---------------------------------------------------------------------- uint32_t DNBWatchpointGetNumSupportedHWP(nub_process_t pid) { MachProcessSP procSP; if (GetProcessSP(pid, procSP)) @@ -1156,13 +1138,11 @@ uint32_t DNBWatchpointGetNumSupportedHWP(nub_process_t pid) { return 0; } -//---------------------------------------------------------------------- // Read memory in the address space of process PID. This call will take // care of setting and restoring permissions and breaking up the memory // read into multiple chunks as required. // // RETURNS: number of bytes actually read -//---------------------------------------------------------------------- nub_size_t DNBProcessMemoryRead(nub_process_t pid, nub_addr_t addr, nub_size_t size, void *buf) { MachProcessSP procSP; @@ -1246,13 +1226,11 @@ std::string DNBProcessMemoryReadCStringFixed(nub_process_t pid, nub_addr_t addr, return cstr; } -//---------------------------------------------------------------------- // Write memory to the address space of process PID. This call will take // care of setting and restoring permissions and breaking up the memory // write into multiple chunks as required. // // RETURNS: number of bytes actually written -//---------------------------------------------------------------------- nub_size_t DNBProcessMemoryWrite(nub_process_t pid, nub_addr_t addr, nub_size_t size, const void *buf) { MachProcessSP procSP; @@ -1276,7 +1254,6 @@ nub_bool_t DNBProcessMemoryDeallocate(nub_process_t pid, nub_addr_t addr) { return 0; } -//---------------------------------------------------------------------- // Find attributes of the memory region that contains ADDR for process PID, // if possible, and return a string describing those attributes. // @@ -1289,7 +1266,6 @@ nub_bool_t DNBProcessMemoryDeallocate(nub_process_t pid, nub_addr_t addr) { // Returns -1 if this platform cannot look up information about memory regions // or if we do not yet have a valid launched process. // -//---------------------------------------------------------------------- int DNBProcessMemoryRegionInfo(nub_process_t pid, nub_addr_t addr, DNBRegionInfo *region_info) { MachProcessSP procSP; @@ -1321,9 +1297,7 @@ nub_bool_t DNBProcessSetEnableAsyncProfiling(nub_process_t pid, return false; } -//---------------------------------------------------------------------- // Get the number of threads for the specified process. -//---------------------------------------------------------------------- nub_size_t DNBProcessGetNumThreads(nub_process_t pid) { MachProcessSP procSP; if (GetProcessSP(pid, procSP)) @@ -1331,9 +1305,7 @@ nub_size_t DNBProcessGetNumThreads(nub_process_t pid) { return 0; } -//---------------------------------------------------------------------- // Get the thread ID of the current thread. -//---------------------------------------------------------------------- nub_thread_t DNBProcessGetCurrentThread(nub_process_t pid) { MachProcessSP procSP; if (GetProcessSP(pid, procSP)) @@ -1341,9 +1313,7 @@ nub_thread_t DNBProcessGetCurrentThread(nub_process_t pid) { return 0; } -//---------------------------------------------------------------------- // Get the mach port number of the current thread. -//---------------------------------------------------------------------- nub_thread_t DNBProcessGetCurrentThreadMachPort(nub_process_t pid) { MachProcessSP procSP; if (GetProcessSP(pid, procSP)) @@ -1351,9 +1321,7 @@ nub_thread_t DNBProcessGetCurrentThreadMachPort(nub_process_t pid) { return 0; } -//---------------------------------------------------------------------- // Change the current thread. -//---------------------------------------------------------------------- nub_thread_t DNBProcessSetCurrentThread(nub_process_t pid, nub_thread_t tid) { MachProcessSP procSP; if (GetProcessSP(pid, procSP)) @@ -1361,10 +1329,8 @@ nub_thread_t DNBProcessSetCurrentThread(nub_process_t pid, nub_thread_t tid) { return INVALID_NUB_THREAD; } -//---------------------------------------------------------------------- // Dump a string describing a thread's stop reason to the specified file // handle -//---------------------------------------------------------------------- nub_bool_t DNBThreadGetStopReason(nub_process_t pid, nub_thread_t tid, struct DNBThreadStopInfo *stop_info) { MachProcessSP procSP; @@ -1373,13 +1339,11 @@ nub_bool_t DNBThreadGetStopReason(nub_process_t pid, nub_thread_t tid, return false; } -//---------------------------------------------------------------------- // Return string description for the specified thread. // // RETURNS: NULL if the thread isn't valid, else a NULL terminated C // string from a static buffer that must be copied prior to subsequent // calls. -//---------------------------------------------------------------------- const char *DNBThreadGetInfo(nub_process_t pid, nub_thread_t tid) { MachProcessSP procSP; if (GetProcessSP(pid, procSP)) @@ -1387,9 +1351,7 @@ const char *DNBThreadGetInfo(nub_process_t pid, nub_thread_t tid) { return NULL; } -//---------------------------------------------------------------------- // Get the thread ID given a thread index. -//---------------------------------------------------------------------- nub_thread_t DNBProcessGetThreadAtIndex(nub_process_t pid, size_t thread_idx) { MachProcessSP procSP; if (GetProcessSP(pid, procSP)) @@ -1397,10 +1359,8 @@ nub_thread_t DNBProcessGetThreadAtIndex(nub_process_t pid, size_t thread_idx) { return INVALID_NUB_THREAD; } -//---------------------------------------------------------------------- // Do whatever is needed to sync the thread's register state with it's kernel // values. -//---------------------------------------------------------------------- nub_bool_t DNBProcessSyncThreadState(nub_process_t pid, nub_thread_t tid) { MachProcessSP procSP; if (GetProcessSP(pid, procSP)) @@ -1440,11 +1400,9 @@ const char *DNBGetDeploymentInfo(nub_process_t pid, } -//---------------------------------------------------------------------- // Get the current shared library information for a process. Only return // the shared libraries that have changed since the last shared library // state changed event if only_changed is non-zero. -//---------------------------------------------------------------------- nub_size_t DNBProcessGetSharedLibraryInfo(nub_process_t pid, nub_bool_t only_changed, struct DNBExecutableImageInfo **image_infos) { @@ -1461,16 +1419,12 @@ DNBProcessGetSharedLibraryInfo(nub_process_t pid, nub_bool_t only_changed, uint32_t DNBGetRegisterCPUType() { return DNBArchProtocol::GetRegisterCPUType(); } -//---------------------------------------------------------------------- // Get the register set information for a specific thread. -//---------------------------------------------------------------------- const DNBRegisterSetInfo *DNBGetRegisterSetInfo(nub_size_t *num_reg_sets) { return DNBArchProtocol::GetRegisterSetInfo(num_reg_sets); } -//---------------------------------------------------------------------- // Read a register value by register set and register index. -//---------------------------------------------------------------------- nub_bool_t DNBThreadGetRegisterValueByID(nub_process_t pid, nub_thread_t tid, uint32_t set, uint32_t reg, DNBRegisterValue *value) { @@ -1533,9 +1487,7 @@ nub_bool_t DNBThreadRestoreRegisterState(nub_process_t pid, nub_thread_t tid, return false; } -//---------------------------------------------------------------------- // Read a register value by name. -//---------------------------------------------------------------------- nub_bool_t DNBThreadGetRegisterValueByName(nub_process_t pid, nub_thread_t tid, uint32_t reg_set, const char *reg_name, @@ -1567,9 +1519,7 @@ nub_bool_t DNBThreadGetRegisterValueByName(nub_process_t pid, nub_thread_t tid, return false; } -//---------------------------------------------------------------------- // Read a register set and register number from the register name. -//---------------------------------------------------------------------- nub_bool_t DNBGetRegisterInfoByName(const char *reg_name, DNBRegisterInfo *info) { const struct DNBRegisterSetInfo *set_info; @@ -1604,10 +1554,8 @@ nub_bool_t DNBGetRegisterInfoByName(const char *reg_name, return false; } -//---------------------------------------------------------------------- // Set the name to address callback function that this nub can use // for any name to address lookups that are needed. -//---------------------------------------------------------------------- nub_bool_t DNBProcessSetNameToAddressCallback(nub_process_t pid, DNBCallbackNameToAddress callback, void *baton) { @@ -1619,10 +1567,8 @@ nub_bool_t DNBProcessSetNameToAddressCallback(nub_process_t pid, return false; } -//---------------------------------------------------------------------- // Set the name to address callback function that this nub can use // for any name to address lookups that are needed. -//---------------------------------------------------------------------- nub_bool_t DNBProcessSetSharedLibraryInfoCallback( nub_process_t pid, DNBCallbackCopyExecutableImageInfos callback, void *baton) { diff --git a/lldb/tools/debugserver/source/DNB.h b/lldb/tools/debugserver/source/DNB.h index d32040b4111..074d0aa53f4 100644 --- a/lldb/tools/debugserver/source/DNB.h +++ b/lldb/tools/debugserver/source/DNB.h @@ -34,9 +34,7 @@ void DNBTerminate(); nub_bool_t DNBSetArchitecture(const char *arch); -//---------------------------------------------------------------------- // Process control -//---------------------------------------------------------------------- nub_process_t DNBProcessLaunch( const char *path, char const *argv[], const char *envp[], const char *working_directory, // NULL => don't change, non-NULL => set @@ -102,9 +100,7 @@ DNBProcessSetEnableAsyncProfiling(nub_process_t pid, nub_bool_t enable, DNBProfileDataScanType scan_type) DNB_EXPORT; DarwinLogEventVector DNBProcessGetAvailableDarwinLogEvents(nub_process_t pid); -//---------------------------------------------------------------------- // Process status -//---------------------------------------------------------------------- nub_bool_t DNBProcessIsAlive(nub_process_t pid) DNB_EXPORT; nub_state_t DNBProcessGetState(nub_process_t pid) DNB_EXPORT; nub_bool_t DNBProcessGetExitStatus(nub_process_t pid, int *status) DNB_EXPORT; @@ -149,24 +145,18 @@ nub_size_t DNBProcessGetAvailableProfileData(nub_process_t pid, char *buf, nub_size_t DNBProcessGetStopCount(nub_process_t pid) DNB_EXPORT; uint32_t DNBProcessGetCPUType(nub_process_t pid) DNB_EXPORT; -//---------------------------------------------------------------------- // Process executable and arguments -//---------------------------------------------------------------------- const char *DNBProcessGetExecutablePath(nub_process_t pid); const char *DNBProcessGetArgumentAtIndex(nub_process_t pid, nub_size_t idx); nub_size_t DNBProcessGetArgumentCount(nub_process_t pid); -//---------------------------------------------------------------------- // Process events -//---------------------------------------------------------------------- nub_event_t DNBProcessWaitForEvents(nub_process_t pid, nub_event_t event_mask, bool wait_for_set, struct timespec *timeout); void DNBProcessResetEvents(nub_process_t pid, nub_event_t event_mask); -//---------------------------------------------------------------------- // Thread functions -//---------------------------------------------------------------------- const char *DNBThreadGetName(nub_process_t pid, nub_thread_t tid); nub_bool_t DNBThreadGetIdentifierInfo(nub_process_t pid, nub_thread_t tid, @@ -215,16 +205,12 @@ DNBGetLibrariesInfoForAddresses(nub_process_t pid, JSONGenerator::ObjectSP DNBGetSharedCacheInfo(nub_process_t pid); // -//---------------------------------------------------------------------- // Breakpoint functions -//---------------------------------------------------------------------- nub_bool_t DNBBreakpointSet(nub_process_t pid, nub_addr_t addr, nub_size_t size, nub_bool_t hardware); nub_bool_t DNBBreakpointClear(nub_process_t pid, nub_addr_t addr); -//---------------------------------------------------------------------- // Watchpoint functions -//---------------------------------------------------------------------- nub_bool_t DNBWatchpointSet(nub_process_t pid, nub_addr_t addr, nub_size_t size, uint32_t watch_flags, nub_bool_t hardware); nub_bool_t DNBWatchpointClear(nub_process_t pid, nub_addr_t addr); @@ -235,9 +221,7 @@ const DNBRegisterSetInfo *DNBGetRegisterSetInfo(nub_size_t *num_reg_sets); nub_bool_t DNBGetRegisterInfoByName(const char *reg_name, DNBRegisterInfo *info); -//---------------------------------------------------------------------- // Other static nub information calls. -//---------------------------------------------------------------------- const char *DNBStateAsString(nub_state_t state); nub_bool_t DNBResolveExecutablePath(const char *path, char *resolved_path, size_t resolved_path_size); diff --git a/lldb/tools/debugserver/source/DNBDataRef.cpp b/lldb/tools/debugserver/source/DNBDataRef.cpp index 073591c8afe..f19c913f65d 100644 --- a/lldb/tools/debugserver/source/DNBDataRef.cpp +++ b/lldb/tools/debugserver/source/DNBDataRef.cpp @@ -16,33 +16,25 @@ #include <ctype.h> #include <libkern/OSByteOrder.h> -//---------------------------------------------------------------------- // Constructor -//---------------------------------------------------------------------- DNBDataRef::DNBDataRef() : m_start(NULL), m_end(NULL), m_swap(false), m_ptrSize(0), m_addrPCRelative(INVALID_NUB_ADDRESS), m_addrTEXT(INVALID_NUB_ADDRESS), m_addrDATA(INVALID_NUB_ADDRESS) {} -//---------------------------------------------------------------------- // Constructor -//---------------------------------------------------------------------- DNBDataRef::DNBDataRef(const uint8_t *start, size_t size, bool swap) : m_start(start), m_end(start + size), m_swap(swap), m_ptrSize(0), m_addrPCRelative(INVALID_NUB_ADDRESS), m_addrTEXT(INVALID_NUB_ADDRESS), m_addrDATA(INVALID_NUB_ADDRESS) {} -//---------------------------------------------------------------------- // Destructor -//---------------------------------------------------------------------- DNBDataRef::~DNBDataRef() {} -//---------------------------------------------------------------------- // Get8 -//---------------------------------------------------------------------- uint8_t DNBDataRef::Get8(offset_t *offset_ptr) const { uint8_t val = 0; if (ValidOffsetForDataOfSize(*offset_ptr, sizeof(val))) { @@ -52,9 +44,7 @@ uint8_t DNBDataRef::Get8(offset_t *offset_ptr) const { return val; } -//---------------------------------------------------------------------- // Get16 -//---------------------------------------------------------------------- uint16_t DNBDataRef::Get16(offset_t *offset_ptr) const { uint16_t val = 0; if (ValidOffsetForDataOfSize(*offset_ptr, sizeof(val))) { @@ -70,9 +60,7 @@ uint16_t DNBDataRef::Get16(offset_t *offset_ptr) const { return val; } -//---------------------------------------------------------------------- // Get32 -//---------------------------------------------------------------------- uint32_t DNBDataRef::Get32(offset_t *offset_ptr) const { uint32_t val = 0; if (ValidOffsetForDataOfSize(*offset_ptr, sizeof(val))) { @@ -87,9 +75,7 @@ uint32_t DNBDataRef::Get32(offset_t *offset_ptr) const { return val; } -//---------------------------------------------------------------------- // Get64 -//---------------------------------------------------------------------- uint64_t DNBDataRef::Get64(offset_t *offset_ptr) const { uint64_t val = 0; if (ValidOffsetForDataOfSize(*offset_ptr, sizeof(val))) { @@ -104,12 +90,10 @@ uint64_t DNBDataRef::Get64(offset_t *offset_ptr) const { return val; } -//---------------------------------------------------------------------- // GetMax32 // // Used for calls when the size can vary. Fill in extra cases if they // are ever needed. -//---------------------------------------------------------------------- uint32_t DNBDataRef::GetMax32(offset_t *offset_ptr, uint32_t byte_size) const { switch (byte_size) { case 1: @@ -128,12 +112,10 @@ uint32_t DNBDataRef::GetMax32(offset_t *offset_ptr, uint32_t byte_size) const { return 0; } -//---------------------------------------------------------------------- // GetMax64 // // Used for calls when the size can vary. Fill in extra cases if they // are ever needed. -//---------------------------------------------------------------------- uint64_t DNBDataRef::GetMax64(offset_t *offset_ptr, uint32_t size) const { switch (size) { case 1: @@ -155,20 +137,16 @@ uint64_t DNBDataRef::GetMax64(offset_t *offset_ptr, uint32_t size) const { return 0; } -//---------------------------------------------------------------------- // GetPointer // // Extract a pointer value from the buffer. The pointer size must be // set prior to using this using one of the SetPointerSize functions. -//---------------------------------------------------------------------- uint64_t DNBDataRef::GetPointer(offset_t *offset_ptr) const { // Must set pointer size prior to using this call assert(m_ptrSize != 0); return GetMax64(offset_ptr, m_ptrSize); } -//---------------------------------------------------------------------- // GetCStr -//---------------------------------------------------------------------- const char *DNBDataRef::GetCStr(offset_t *offset_ptr, uint32_t fixed_length) const { const char *s = NULL; @@ -184,9 +162,7 @@ const char *DNBDataRef::GetCStr(offset_t *offset_ptr, return s; } -//---------------------------------------------------------------------- // GetData -//---------------------------------------------------------------------- const uint8_t *DNBDataRef::GetData(offset_t *offset_ptr, uint32_t length) const { const uint8_t *data = NULL; @@ -197,9 +173,7 @@ const uint8_t *DNBDataRef::GetData(offset_t *offset_ptr, return data; } -//---------------------------------------------------------------------- // Get_ULEB128 -//---------------------------------------------------------------------- uint64_t DNBDataRef::Get_ULEB128(offset_t *offset_ptr) const { uint64_t result = 0; if (m_start < m_end) { @@ -222,9 +196,7 @@ uint64_t DNBDataRef::Get_ULEB128(offset_t *offset_ptr) const { return result; } -//---------------------------------------------------------------------- // Get_SLEB128 -//---------------------------------------------------------------------- int64_t DNBDataRef::Get_SLEB128(offset_t *offset_ptr) const { int64_t result = 0; @@ -254,11 +226,9 @@ int64_t DNBDataRef::Get_SLEB128(offset_t *offset_ptr) const { return result; } -//---------------------------------------------------------------------- // Skip_LEB128 // // Skips past ULEB128 and SLEB128 numbers (just updates the offset) -//---------------------------------------------------------------------- void DNBDataRef::Skip_LEB128(offset_t *offset_ptr) const { if (m_start < m_end) { const uint8_t *start = m_start + *offset_ptr; diff --git a/lldb/tools/debugserver/source/DNBDefs.h b/lldb/tools/debugserver/source/DNBDefs.h index 278caadd79d..3ff60d313aa 100644 --- a/lldb/tools/debugserver/source/DNBDefs.h +++ b/lldb/tools/debugserver/source/DNBDefs.h @@ -19,33 +19,25 @@ #include <sys/syslimits.h> #include <unistd.h> -//---------------------------------------------------------------------- // Define nub_addr_t and the invalid address value from the architecture -//---------------------------------------------------------------------- #if defined(__x86_64__) || defined(__ppc64__) || defined(__arm64__) || \ defined(__aarch64__) -//---------------------------------------------------------------------- // 64 bit address architectures -//---------------------------------------------------------------------- typedef uint64_t nub_addr_t; #define INVALID_NUB_ADDRESS ((nub_addr_t)~0ull) #elif defined(__i386__) || defined(__powerpc__) || defined(__ppc__) || \ defined(__arm__) -//---------------------------------------------------------------------- // 32 bit address architectures -//---------------------------------------------------------------------- typedef uint32_t nub_addr_t; #define INVALID_NUB_ADDRESS ((nub_addr_t)~0ul) #else -//---------------------------------------------------------------------- // Default to 64 bit address for unrecognized architectures. -//---------------------------------------------------------------------- #warning undefined architecture, defaulting to 8 byte addresses typedef uint64_t nub_addr_t; @@ -253,11 +245,9 @@ enum DNBMemoryPermissions { #define DNB_THREAD_STOP_INFO_MAX_DESC_LENGTH 256 #define DNB_THREAD_STOP_INFO_MAX_EXC_DATA 8 -//---------------------------------------------------------------------- // DNBThreadStopInfo // // Describes the reason a thread stopped. -//---------------------------------------------------------------------- struct DNBThreadStopInfo { DNBThreadStopType reason; char description[DNB_THREAD_STOP_INFO_MAX_DESC_LENGTH]; diff --git a/lldb/tools/debugserver/source/DNBLog.cpp b/lldb/tools/debugserver/source/DNBLog.cpp index 3d60b59cc99..11b2d0a04b7 100644 --- a/lldb/tools/debugserver/source/DNBLog.cpp +++ b/lldb/tools/debugserver/source/DNBLog.cpp @@ -78,10 +78,8 @@ void _DNBLog(uint32_t flags, const char *format, ...) { va_end(args); } -//---------------------------------------------------------------------- // Print debug strings if and only if the global g_debug is set to // a non-zero value. -//---------------------------------------------------------------------- void _DNBLogDebug(const char *format, ...) { if (DNBLogEnabled() && g_debug) { va_list args; @@ -91,10 +89,8 @@ void _DNBLogDebug(const char *format, ...) { } } -//---------------------------------------------------------------------- // Print debug strings if and only if the global g_debug is set to // a non-zero value. -//---------------------------------------------------------------------- void _DNBLogDebugVerbose(const char *format, ...) { if (DNBLogEnabled() && g_debug && g_verbose) { va_list args; @@ -106,10 +102,8 @@ void _DNBLogDebugVerbose(const char *format, ...) { static uint32_t g_message_id = 0; -//---------------------------------------------------------------------- // Prefix the formatted log string with process and thread IDs and // suffix it with a newline. -//---------------------------------------------------------------------- void _DNBLogThreaded(const char *format, ...) { if (DNBLogEnabled()) { // PTHREAD_MUTEX_LOCKER(locker, GetLogThreadedMutex()); @@ -150,10 +144,8 @@ void _DNBLogThreaded(const char *format, ...) { } } -//---------------------------------------------------------------------- // Prefix the formatted log string with process and thread IDs and // suffix it with a newline. -//---------------------------------------------------------------------- void _DNBLogThreadedIf(uint32_t log_bit, const char *format, ...) { if (DNBLogEnabled() && (log_bit & g_log_bits) == log_bit) { // PTHREAD_MUTEX_LOCKER(locker, GetLogThreadedMutex()); @@ -195,9 +187,7 @@ void _DNBLogThreadedIf(uint32_t log_bit, const char *format, ...) { } } -//---------------------------------------------------------------------- // Printing of errors that are not fatal. -//---------------------------------------------------------------------- void _DNBLogError(const char *format, ...) { if (DNBLogEnabled()) { char *arg_msg = NULL; @@ -213,10 +203,8 @@ void _DNBLogError(const char *format, ...) { } } -//---------------------------------------------------------------------- // Printing of errors that ARE fatal. Exit with ERR exit code // immediately. -//---------------------------------------------------------------------- void _DNBLogFatalError(int err, const char *format, ...) { if (DNBLogEnabled()) { char *arg_msg = NULL; @@ -233,10 +221,8 @@ void _DNBLogFatalError(int err, const char *format, ...) { } } -//---------------------------------------------------------------------- // Printing of warnings that are not fatal only if verbose mode is // enabled. -//---------------------------------------------------------------------- void _DNBLogVerbose(const char *format, ...) { if (DNBLogEnabled() && g_verbose) { va_list args; @@ -246,10 +232,8 @@ void _DNBLogVerbose(const char *format, ...) { } } -//---------------------------------------------------------------------- // Printing of warnings that are not fatal only if verbose mode is // enabled. -//---------------------------------------------------------------------- void _DNBLogWarningVerbose(const char *format, ...) { if (DNBLogEnabled() && g_verbose) { char *arg_msg = NULL; @@ -265,9 +249,7 @@ void _DNBLogWarningVerbose(const char *format, ...) { } } } -//---------------------------------------------------------------------- // Printing of warnings that are not fatal. -//---------------------------------------------------------------------- void _DNBLogWarning(const char *format, ...) { if (DNBLogEnabled()) { char *arg_msg = NULL; diff --git a/lldb/tools/debugserver/source/DNBTimer.h b/lldb/tools/debugserver/source/DNBTimer.h index 9792c9b79ab..21ee2351d69 100644 --- a/lldb/tools/debugserver/source/DNBTimer.h +++ b/lldb/tools/debugserver/source/DNBTimer.h @@ -21,9 +21,7 @@ class DNBTimer { public: - //------------------------------------------------------------------ // Constructors and Destructors - //------------------------------------------------------------------ DNBTimer(bool threadSafe) : m_mutexAP() { if (threadSafe) m_mutexAP.reset(new PThreadMutex(PTHREAD_MUTEX_RECURSIVE)); @@ -50,16 +48,12 @@ public: ~DNBTimer() {} bool IsThreadSafe() const { return m_mutexAP.get() != NULL; } - //------------------------------------------------------------------ // Reset the time value to now - //------------------------------------------------------------------ void Reset() { PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get()); gettimeofday(&m_timeval, NULL); } - //------------------------------------------------------------------ // Get the total mircoseconds since Jan 1, 1970 - //------------------------------------------------------------------ uint64_t TotalMicroSeconds() const { PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get()); return (uint64_t)(m_timeval.tv_sec) * 1000000ull + @@ -71,10 +65,8 @@ public: sec = m_timeval.tv_sec; usec = m_timeval.tv_usec; } - //------------------------------------------------------------------ // Return the number of microseconds elapsed between now and the // m_timeval - //------------------------------------------------------------------ uint64_t ElapsedMicroSeconds(bool update) { PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get()); struct timeval now; @@ -134,9 +126,7 @@ public: } protected: - //------------------------------------------------------------------ // Classes that inherit from DNBTimer can see and modify these - //------------------------------------------------------------------ std::unique_ptr<PThreadMutex> m_mutexAP; struct timeval m_timeval; }; diff --git a/lldb/tools/debugserver/source/JSON.h b/lldb/tools/debugserver/source/JSON.h index e7ffcfb5712..b1c4a4c9db8 100644 --- a/lldb/tools/debugserver/source/JSON.h +++ b/lldb/tools/debugserver/source/JSON.h @@ -203,7 +203,6 @@ public: JSONValue::SP GetObject(const std::string &key) const; - // ------------------------------------------------------------------------- /// Return keyed value as bool /// /// \param[in] key @@ -217,7 +216,6 @@ public: /// true if the key existed as was a bool value; false otherwise. /// Note the return value is *not* the value of the bool, use /// \b value for that. - // ------------------------------------------------------------------------- bool GetObjectAsBool(const std::string &key, bool &value) const; bool GetObjectAsString(const std::string &key, std::string &value) const; diff --git a/lldb/tools/debugserver/source/JSONGenerator.h b/lldb/tools/debugserver/source/JSONGenerator.h index efd8a6c3d35..70708f9a5ac 100644 --- a/lldb/tools/debugserver/source/JSONGenerator.h +++ b/lldb/tools/debugserver/source/JSONGenerator.h @@ -16,7 +16,6 @@ #include <utility> #include <vector> -//---------------------------------------------------------------------- /// \class JSONGenerator JSONGenerator.h /// A class which can construct structured data for the sole purpose /// of printing it in JSON format. @@ -24,7 +23,6 @@ /// A stripped down version of lldb's StructuredData objects which are much /// general purpose. This variant is intended only for assembling information /// and printing it as a JSON string. -//---------------------------------------------------------------------- class JSONGenerator { public: diff --git a/lldb/tools/debugserver/source/MacOSX/CFBundle.cpp b/lldb/tools/debugserver/source/MacOSX/CFBundle.cpp index 6825fb374da..6971c1f4c32 100644 --- a/lldb/tools/debugserver/source/MacOSX/CFBundle.cpp +++ b/lldb/tools/debugserver/source/MacOSX/CFBundle.cpp @@ -13,38 +13,28 @@ #include "CFBundle.h" #include "CFString.h" -//---------------------------------------------------------------------- // CFBundle constructor -//---------------------------------------------------------------------- CFBundle::CFBundle(const char *path) : CFReleaser<CFBundleRef>(), m_bundle_url() { if (path && path[0]) SetPath(path); } -//---------------------------------------------------------------------- // CFBundle copy constructor -//---------------------------------------------------------------------- CFBundle::CFBundle(const CFBundle &rhs) : CFReleaser<CFBundleRef>(rhs), m_bundle_url(rhs.m_bundle_url) {} -//---------------------------------------------------------------------- // CFBundle copy constructor -//---------------------------------------------------------------------- CFBundle &CFBundle::operator=(const CFBundle &rhs) { if (this != &rhs) *this = rhs; return *this; } -//---------------------------------------------------------------------- // Destructor -//---------------------------------------------------------------------- CFBundle::~CFBundle() {} -//---------------------------------------------------------------------- // Set the path for a bundle by supplying a -//---------------------------------------------------------------------- bool CFBundle::SetPath(const char *path) { CFAllocatorRef alloc = kCFAllocatorDefault; // Release our old bundle and ULR diff --git a/lldb/tools/debugserver/source/MacOSX/CFBundle.h b/lldb/tools/debugserver/source/MacOSX/CFBundle.h index c56edee7a03..f49dc30f1f8 100644 --- a/lldb/tools/debugserver/source/MacOSX/CFBundle.h +++ b/lldb/tools/debugserver/source/MacOSX/CFBundle.h @@ -17,9 +17,7 @@ class CFBundle : public CFReleaser<CFBundleRef> { public: - //------------------------------------------------------------------ // Constructors and Destructors - //------------------------------------------------------------------ CFBundle(const char *path = NULL); CFBundle(const CFBundle &rhs); CFBundle &operator=(const CFBundle &rhs); diff --git a/lldb/tools/debugserver/source/MacOSX/CFString.cpp b/lldb/tools/debugserver/source/MacOSX/CFString.cpp index 3061c429b9a..637ba65ae4d 100644 --- a/lldb/tools/debugserver/source/MacOSX/CFString.cpp +++ b/lldb/tools/debugserver/source/MacOSX/CFString.cpp @@ -14,19 +14,13 @@ #include <glob.h> #include <string> -//---------------------------------------------------------------------- // CFString constructor -//---------------------------------------------------------------------- CFString::CFString(CFStringRef s) : CFReleaser<CFStringRef>(s) {} -//---------------------------------------------------------------------- // CFString copy constructor -//---------------------------------------------------------------------- CFString::CFString(const CFString &rhs) : CFReleaser<CFStringRef>(rhs) {} -//---------------------------------------------------------------------- // CFString copy constructor -//---------------------------------------------------------------------- CFString &CFString::operator=(const CFString &rhs) { if (this != &rhs) *this = rhs; @@ -41,9 +35,7 @@ CFString::CFString(const char *cstr, CFStringEncoding cstr_encoding) } } -//---------------------------------------------------------------------- // Destructor -//---------------------------------------------------------------------- CFString::~CFString() {} const char *CFString::GetFileSystemRepresentation(std::string &s) { diff --git a/lldb/tools/debugserver/source/MacOSX/CFString.h b/lldb/tools/debugserver/source/MacOSX/CFString.h index 47db507ce38..d1bd5682689 100644 --- a/lldb/tools/debugserver/source/MacOSX/CFString.h +++ b/lldb/tools/debugserver/source/MacOSX/CFString.h @@ -18,9 +18,7 @@ class CFString : public CFReleaser<CFStringRef> { public: - //------------------------------------------------------------------ // Constructors and Destructors - //------------------------------------------------------------------ CFString(CFStringRef cf_str = NULL); CFString(const char *s, CFStringEncoding encoding = kCFStringEncodingUTF8); CFString(const CFString &rhs); diff --git a/lldb/tools/debugserver/source/MacOSX/CFUtils.h b/lldb/tools/debugserver/source/MacOSX/CFUtils.h index 9dae40670f3..b567524ce63 100644 --- a/lldb/tools/debugserver/source/MacOSX/CFUtils.h +++ b/lldb/tools/debugserver/source/MacOSX/CFUtils.h @@ -17,11 +17,9 @@ #ifdef __cplusplus -//---------------------------------------------------------------------- // Templatized CF helper class that can own any CF pointer and will // call CFRelease() on any valid pointer it owns unless that pointer is // explicitly released using the release() member function. -//---------------------------------------------------------------------- template <class T> class CFReleaser { public: // Type names for the avlue diff --git a/lldb/tools/debugserver/source/MacOSX/DarwinLog/DarwinLogCollector.h b/lldb/tools/debugserver/source/MacOSX/DarwinLog/DarwinLogCollector.h index 334953dcbaf..24ab4230e38 100644 --- a/lldb/tools/debugserver/source/MacOSX/DarwinLog/DarwinLogCollector.h +++ b/lldb/tools/debugserver/source/MacOSX/DarwinLog/DarwinLogCollector.h @@ -29,21 +29,17 @@ class DarwinLogCollector : public std::enable_shared_from_this<DarwinLogCollector>, public ActivityStore { public: - //------------------------------------------------------------------ /// Return whether the os_log and activity tracing SPI is available. /// /// \return \b true if the activity stream support is available, /// \b false otherwise. - //------------------------------------------------------------------ static bool IsSupported(); - //------------------------------------------------------------------ /// Return a log function suitable for DNBLog to use as the internal /// logging function. /// /// \return a DNBLog-style logging function if IsSupported() returns /// true; otherwise, returns nullptr. - //------------------------------------------------------------------ static DNBCallbackLog GetLogFunction(); static bool StartCollectingForProcess(nub_process_t pid, @@ -57,9 +53,7 @@ public: pid_t GetProcessID() const { return m_pid; } - //------------------------------------------------------------------ // ActivityStore API - //------------------------------------------------------------------ const char *GetActivityForID(os_activity_id_t activity_id) const override; std::string diff --git a/lldb/tools/debugserver/source/MacOSX/DarwinLog/LogFilterRegex.cpp b/lldb/tools/debugserver/source/MacOSX/DarwinLog/LogFilterRegex.cpp index 9a09e55edba..489c056fa81 100644 --- a/lldb/tools/debugserver/source/MacOSX/DarwinLog/LogFilterRegex.cpp +++ b/lldb/tools/debugserver/source/MacOSX/DarwinLog/LogFilterRegex.cpp @@ -11,11 +11,9 @@ #include "DNBLog.h" #include "LogMessage.h" -//---------------------------------------------------------------------- // Enable enhanced mode if it is available. This allows for things like // \d for digit, \s for space, and many more, but it isn't available // everywhere. -//---------------------------------------------------------------------- #if defined(REG_ENHANCED) #define DEFAULT_COMPILE_FLAGS (REG_ENHANCED | REG_EXTENDED) #else diff --git a/lldb/tools/debugserver/source/MacOSX/DarwinLog/LogMessageOsLog.h b/lldb/tools/debugserver/source/MacOSX/DarwinLog/LogMessageOsLog.h index 5f50e390aa6..39b6adccb1b 100644 --- a/lldb/tools/debugserver/source/MacOSX/DarwinLog/LogMessageOsLog.h +++ b/lldb/tools/debugserver/source/MacOSX/DarwinLog/LogMessageOsLog.h @@ -16,13 +16,11 @@ using ActivityStreamEntry = struct os_activity_stream_entry_s; -// ----------------------------------------------------------------------------- /// Provides a unified wrapper around os_log()-style log messages. /// /// The lifetime of this class is intended to be very short. The caller /// must ensure that the passed in ActivityStore and ActivityStreamEntry /// outlive this LogMessageOsLog entry. -// ----------------------------------------------------------------------------- class LogMessageOsLog : public LogMessage { public: diff --git a/lldb/tools/debugserver/source/MacOSX/Genealogy.cpp b/lldb/tools/debugserver/source/MacOSX/Genealogy.cpp index 803eb913832..4b664be5488 100644 --- a/lldb/tools/debugserver/source/MacOSX/Genealogy.cpp +++ b/lldb/tools/debugserver/source/MacOSX/Genealogy.cpp @@ -16,9 +16,7 @@ #include "GenealogySPI.h" #include "MachThreadList.h" -//--------------------------- /// Constructor -//--------------------------- Genealogy::Genealogy() : m_os_activity_diagnostic_for_pid(nullptr), diff --git a/lldb/tools/debugserver/source/MacOSX/MachProcess.h b/lldb/tools/debugserver/source/MacOSX/MachProcess.h index 644364be4c9..0b8e1f4d4a5 100644 --- a/lldb/tools/debugserver/source/MacOSX/MachProcess.h +++ b/lldb/tools/debugserver/source/MacOSX/MachProcess.h @@ -40,9 +40,7 @@ class DNBThreadResumeActions; class MachProcess { public: - //---------------------------------------------------------------------- // Constructors and Destructors - //---------------------------------------------------------------------- MachProcess(); ~MachProcess(); @@ -79,9 +77,7 @@ public: : filename(), load_address(INVALID_NUB_ADDRESS), mod_date(0) {} }; - //---------------------------------------------------------------------- // Child process control - //---------------------------------------------------------------------- pid_t AttachForDebug(pid_t pid, char *err_str, size_t err_len); pid_t LaunchForDebug(const char *path, char const *argv[], char const *envp[], const char *working_directory, const char *stdin_path, @@ -160,9 +156,7 @@ public: nub_size_t ReadMemory(nub_addr_t addr, nub_size_t size, void *buf); nub_size_t WriteMemory(nub_addr_t addr, nub_size_t size, const void *buf); - //---------------------------------------------------------------------- // Path and arg accessors - //---------------------------------------------------------------------- const char *Path() const { return m_path.c_str(); } size_t ArgumentCount() const { return m_args.size(); } const char *ArgumentAtIndex(size_t arg_idx) const { @@ -171,9 +165,7 @@ public: return NULL; } - //---------------------------------------------------------------------- // Breakpoint functions - //---------------------------------------------------------------------- DNBBreakpoint *CreateBreakpoint(nub_addr_t addr, nub_size_t length, bool hardware); bool DisableBreakpoint(nub_addr_t addr, bool remove); @@ -182,9 +174,7 @@ public: DNBBreakpointList &Breakpoints() { return m_breakpoints; } const DNBBreakpointList &Breakpoints() const { return m_breakpoints; } - //---------------------------------------------------------------------- // Watchpoint functions - //---------------------------------------------------------------------- DNBBreakpoint *CreateWatchpoint(nub_addr_t addr, nub_size_t length, uint32_t watch_type, bool hardware); bool DisableWatchpoint(nub_addr_t addr, bool remove); @@ -194,9 +184,7 @@ public: DNBBreakpointList &Watchpoints() { return m_watchpoints; } const DNBBreakpointList &Watchpoints() const { return m_watchpoints; } - //---------------------------------------------------------------------- // Exception thread functions - //---------------------------------------------------------------------- bool StartSTDIOThread(); static void *STDIOThread(void *arg); void ExceptionMessageReceived(const MachException::Message &exceptionMessage); @@ -205,9 +193,7 @@ public: nub_size_t CopyImageInfos(struct DNBExecutableImageInfo **image_infos, bool only_changed); - //---------------------------------------------------------------------- // Profile functions - //---------------------------------------------------------------------- void SetEnableAsyncProfiling(bool enable, uint64_t internal_usec, DNBProfileDataScanType scan_type); bool IsProfilingEnabled() { return m_profile_enabled; } @@ -217,9 +203,7 @@ public: void SignalAsyncProfileData(const char *info); size_t GetAsyncProfileData(char *buf, size_t buf_size); - //---------------------------------------------------------------------- // Accessors - //---------------------------------------------------------------------- pid_t ProcessID() const { return m_pid; } bool ProcessIDIsValid() const { return m_pid > 0; } pid_t SetProcessID(pid_t pid); diff --git a/lldb/tools/debugserver/source/MacOSX/MachTask.h b/lldb/tools/debugserver/source/MacOSX/MachTask.h index ad25f0e415f..a933bffc8a0 100644 --- a/lldb/tools/debugserver/source/MacOSX/MachTask.h +++ b/lldb/tools/debugserver/source/MacOSX/MachTask.h @@ -5,7 +5,6 @@ // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// -//---------------------------------------------------------------------- // // MachTask.h // debugserver @@ -45,9 +44,7 @@ struct MachMallocEvent { class MachTask { public: - //------------------------------------------------------------------ // Constructors and Destructors - //------------------------------------------------------------------ MachTask(MachProcess *process); virtual ~MachTask(); diff --git a/lldb/tools/debugserver/source/MacOSX/MachThreadList.cpp b/lldb/tools/debugserver/source/MacOSX/MachThreadList.cpp index be59fb6a0cf..8d2165b0f24 100644 --- a/lldb/tools/debugserver/source/MacOSX/MachThreadList.cpp +++ b/lldb/tools/debugserver/source/MacOSX/MachThreadList.cpp @@ -451,7 +451,6 @@ uint32_t MachThreadList::ProcessDidStop(MachProcess *process) { return num_threads; } -//---------------------------------------------------------------------- // Check each thread in our thread list to see if we should notify our // client of the current halt in execution. // @@ -461,7 +460,6 @@ uint32_t MachThreadList::ProcessDidStop(MachProcess *process) { // RETURNS // true if we should stop and notify our clients // false if we should resume our child process and skip notification -//---------------------------------------------------------------------- bool MachThreadList::ShouldStop(bool &step_more) { PTHREAD_MUTEX_LOCKER(locker, m_threads_mutex); uint32_t should_stop = false; diff --git a/lldb/tools/debugserver/source/MacOSX/OsLogger.cpp b/lldb/tools/debugserver/source/MacOSX/OsLogger.cpp index 5e13819de87..a83afb62b36 100644 --- a/lldb/tools/debugserver/source/MacOSX/OsLogger.cpp +++ b/lldb/tools/debugserver/source/MacOSX/OsLogger.cpp @@ -19,10 +19,8 @@ #define LLDB_OS_LOG_MAX_BUFFER_LENGTH 256 namespace { -//---------------------------------------------------------------------- // Darwin os_log logging callback that can be registered with // DNBLogSetLogCallback -//---------------------------------------------------------------------- void DarwinLogCallback(void *baton, uint32_t flags, const char *format, va_list args) { if (format == nullptr) diff --git a/lldb/tools/debugserver/source/MacOSX/arm/DNBArchImpl.cpp b/lldb/tools/debugserver/source/MacOSX/arm/DNBArchImpl.cpp index 0d2455e123d..45d05d6e0bd 100644 --- a/lldb/tools/debugserver/source/MacOSX/arm/DNBArchImpl.cpp +++ b/lldb/tools/debugserver/source/MacOSX/arm/DNBArchImpl.cpp @@ -1423,9 +1423,7 @@ nub_addr_t DNBArchMachARM::GetWatchAddress(const DBG &debug_state, return bits(debug_state.__wvr[hw_index], 31, 0); } -//---------------------------------------------------------------------- // Register information definitions for 32 bit ARMV7. -//---------------------------------------------------------------------- enum gpr_regnums { gpr_r0 = 0, gpr_r1, @@ -1776,11 +1774,9 @@ const size_t DNBArchMachARM::k_num_exc_registers = const size_t DNBArchMachARM::k_num_all_registers = k_num_gpr_registers + k_num_vfp_registers + k_num_exc_registers; -//---------------------------------------------------------------------- // Register set definitions. The first definitions at register set index // of zero is for all registers, followed by other registers sets. The // register information for the all register set need not be filled in. -//---------------------------------------------------------------------- const DNBRegisterSetInfo DNBArchMachARM::g_reg_sets[] = { {"ARM Registers", NULL, k_num_all_registers}, {"General Purpose Registers", g_gpr_registers, k_num_gpr_registers}, diff --git a/lldb/tools/debugserver/source/MacOSX/arm64/DNBArchImplARM64.cpp b/lldb/tools/debugserver/source/MacOSX/arm64/DNBArchImplARM64.cpp index 8fedb984182..911cbe6b4b3 100644 --- a/lldb/tools/debugserver/source/MacOSX/arm64/DNBArchImplARM64.cpp +++ b/lldb/tools/debugserver/source/MacOSX/arm64/DNBArchImplARM64.cpp @@ -947,9 +947,7 @@ nub_addr_t DNBArchMachARM64::GetWatchAddress(const DBG &debug_state, return bits(debug_state.__wvr[hw_index], 63, 0); } -//---------------------------------------------------------------------- // Register information definitions for 64 bit ARMv8. -//---------------------------------------------------------------------- enum gpr_regnums { gpr_x0 = 0, gpr_x1, @@ -1689,11 +1687,9 @@ const size_t DNBArchMachARM64::k_num_exc_registers = const size_t DNBArchMachARM64::k_num_all_registers = k_num_gpr_registers + k_num_vfp_registers + k_num_exc_registers; -//---------------------------------------------------------------------- // Register set definitions. The first definitions at register set index // of zero is for all registers, followed by other registers sets. The // register information for the all register set need not be filled in. -//---------------------------------------------------------------------- const DNBRegisterSetInfo DNBArchMachARM64::g_reg_sets[] = { {"ARM64 Registers", NULL, k_num_all_registers}, {"General Purpose Registers", g_gpr_registers, k_num_gpr_registers}, diff --git a/lldb/tools/debugserver/source/MacOSX/i386/DNBArchImplI386.cpp b/lldb/tools/debugserver/source/MacOSX/i386/DNBArchImplI386.cpp index 1854a9c831e..7d2d0c2ef1b 100644 --- a/lldb/tools/debugserver/source/MacOSX/i386/DNBArchImplI386.cpp +++ b/lldb/tools/debugserver/source/MacOSX/i386/DNBArchImplI386.cpp @@ -1025,9 +1025,7 @@ kern_return_t DNBArchImplI386::EnableHardwareSingleStep(bool enable) { return m_state.GetError(e_regSetGPR, Read); } -//---------------------------------------------------------------------- // Register information definitions -//---------------------------------------------------------------------- #define DEFINE_GPR_PSEUDO_16(reg16, reg32) \ { \ @@ -1540,11 +1538,9 @@ const size_t DNBArchImplI386::k_num_all_registers_avx = const size_t DNBArchImplI386::k_num_all_registers_avx512f = k_num_gpr_registers + k_num_fpu_registers_avx512f + k_num_exc_registers; -//---------------------------------------------------------------------- // Register set definitions. The first definitions at register set index // of zero is for all registers, followed by other registers sets. The // register information for the all register set need not be filled in. -//---------------------------------------------------------------------- const DNBRegisterSetInfo DNBArchImplI386::g_reg_sets_no_avx[] = { {"i386 Registers", NULL, k_num_all_registers_no_avx}, {"General Purpose Registers", g_gpr_registers, k_num_gpr_registers}, diff --git a/lldb/tools/debugserver/source/MacOSX/ppc/DNBArchImpl.cpp b/lldb/tools/debugserver/source/MacOSX/ppc/DNBArchImpl.cpp index 141b6b72c2a..c6671b5066a 100644 --- a/lldb/tools/debugserver/source/MacOSX/ppc/DNBArchImpl.cpp +++ b/lldb/tools/debugserver/source/MacOSX/ppc/DNBArchImpl.cpp @@ -178,9 +178,7 @@ kern_return_t DNBArchMachPPC::EnableHardwareSingleStep(bool enable) { return m_state.GetError(e_regSetGPR, Read); } -//---------------------------------------------------------------------- // Register information definitions for 32 bit PowerPC. -//---------------------------------------------------------------------- enum gpr_regnums { e_regNumGPR_srr0, @@ -319,11 +317,9 @@ const size_t k_num_vec_registers = const size_t k_num_ppc_registers = k_num_gpr_registers + k_num_fpr_registers + k_num_exc_registers + k_num_vec_registers; -//---------------------------------------------------------------------- // Register set definitions. The first definitions at register set index // of zero is for all registers, followed by other registers sets. The // register information for the all register set need not be filled in. -//---------------------------------------------------------------------- static const DNBRegisterSetInfo g_reg_sets[] = { {"PowerPC Registers", NULL, k_num_ppc_registers}, {"General Purpose Registers", g_gpr_registers, k_num_gpr_registers}, diff --git a/lldb/tools/debugserver/source/MacOSX/x86_64/DNBArchImplX86_64.cpp b/lldb/tools/debugserver/source/MacOSX/x86_64/DNBArchImplX86_64.cpp index 4f32d44e69f..319215e8a7f 100644 --- a/lldb/tools/debugserver/source/MacOSX/x86_64/DNBArchImplX86_64.cpp +++ b/lldb/tools/debugserver/source/MacOSX/x86_64/DNBArchImplX86_64.cpp @@ -980,9 +980,7 @@ kern_return_t DNBArchImplX86_64::EnableHardwareSingleStep(bool enable) { return m_state.GetError(e_regSetGPR, Read); } -//---------------------------------------------------------------------- // Register information definitions -//---------------------------------------------------------------------- enum { gpr_rax = 0, @@ -2062,11 +2060,9 @@ const size_t DNBArchImplX86_64::k_num_fpu_registers_avx512f = const size_t DNBArchImplX86_64::k_num_all_registers_avx512f = k_num_gpr_registers + k_num_fpu_registers_avx512f + k_num_exc_registers; -//---------------------------------------------------------------------- // Register set definitions. The first definitions at register set index // of zero is for all registers, followed by other registers sets. The // register information for the all register set need not be filled in. -//---------------------------------------------------------------------- const DNBRegisterSetInfo DNBArchImplX86_64::g_reg_sets_no_avx[] = { {"x86_64 Registers", NULL, k_num_all_registers_no_avx}, {"General Purpose Registers", g_gpr_registers, k_num_gpr_registers}, diff --git a/lldb/tools/debugserver/source/PThreadEvent.cpp b/lldb/tools/debugserver/source/PThreadEvent.cpp index 9a70b25a880..82d1d227867 100644 --- a/lldb/tools/debugserver/source/PThreadEvent.cpp +++ b/lldb/tools/debugserver/source/PThreadEvent.cpp @@ -105,10 +105,8 @@ void PThreadEvent::ResetEvents(const uint32_t mask) { } } -//---------------------------------------------------------------------- // Wait until 'timeout_abstime' for any events that are set in // 'mask'. If 'timeout_abstime' is NULL, then wait forever. -//---------------------------------------------------------------------- uint32_t PThreadEvent::WaitForSetEvents(const uint32_t mask, const struct timespec *timeout_abstime) const { @@ -149,10 +147,8 @@ PThreadEvent::WaitForSetEvents(const uint32_t mask, return 0; } -//---------------------------------------------------------------------- // Wait until 'timeout_abstime' for any events in 'mask' to reset. // If 'timeout_abstime' is NULL, then wait forever. -//---------------------------------------------------------------------- uint32_t PThreadEvent::WaitForEventsToReset( const uint32_t mask, const struct timespec *timeout_abstime) const { // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x, %p)", this, diff --git a/lldb/tools/debugserver/source/PThreadEvent.h b/lldb/tools/debugserver/source/PThreadEvent.h index 00c8316ef07..5689cbfb9ca 100644 --- a/lldb/tools/debugserver/source/PThreadEvent.h +++ b/lldb/tools/debugserver/source/PThreadEvent.h @@ -44,10 +44,8 @@ public: const struct timespec *timeout_abstime = NULL) const; protected: - //---------------------------------------------------------------------- // pthread condition and mutex variable to control access and allow // blocking between the main thread and the spotlight index thread. - //---------------------------------------------------------------------- mutable PThreadMutex m_mutex; mutable PThreadCondition m_set_condition; mutable PThreadCondition m_reset_condition; diff --git a/lldb/tools/debugserver/source/PseudoTerminal.cpp b/lldb/tools/debugserver/source/PseudoTerminal.cpp index 0a75bc9741f..cac8bda6248 100644 --- a/lldb/tools/debugserver/source/PseudoTerminal.cpp +++ b/lldb/tools/debugserver/source/PseudoTerminal.cpp @@ -15,27 +15,21 @@ #include <sys/ioctl.h> #include <unistd.h> -//---------------------------------------------------------------------- // PseudoTerminal constructor -//---------------------------------------------------------------------- PseudoTerminal::PseudoTerminal() : m_master_fd(invalid_fd), m_slave_fd(invalid_fd) {} -//---------------------------------------------------------------------- // Destructor // The master and slave file descriptors will get closed if they are // valid. Call the ReleaseMasterFD()/ReleaseSlaveFD() member functions // to release any file descriptors that are needed beyond the lifespan // of this object. -//---------------------------------------------------------------------- PseudoTerminal::~PseudoTerminal() { CloseMaster(); CloseSlave(); } -//---------------------------------------------------------------------- // Close the master file descriptor if it is valid. -//---------------------------------------------------------------------- void PseudoTerminal::CloseMaster() { if (m_master_fd > 0) { ::close(m_master_fd); @@ -43,9 +37,7 @@ void PseudoTerminal::CloseMaster() { } } -//---------------------------------------------------------------------- // Close the slave file descriptor if it is valid. -//---------------------------------------------------------------------- void PseudoTerminal::CloseSlave() { if (m_slave_fd > 0) { ::close(m_slave_fd); @@ -53,7 +45,6 @@ void PseudoTerminal::CloseSlave() { } } -//---------------------------------------------------------------------- // Open the first available pseudo terminal with OFLAG as the // permissions. The file descriptor is store in the m_master_fd member // variable and can be accessed via the MasterFD() or ReleaseMasterFD() @@ -63,7 +54,6 @@ void PseudoTerminal::CloseSlave() { // // RETURNS: // Zero when successful, non-zero indicating an error occurred. -//---------------------------------------------------------------------- PseudoTerminal::Status PseudoTerminal::OpenFirstAvailableMaster(int oflag) { // Open the master side of a pseudo terminal m_master_fd = ::posix_openpt(oflag); @@ -86,7 +76,6 @@ PseudoTerminal::Status PseudoTerminal::OpenFirstAvailableMaster(int oflag) { return success; } -//---------------------------------------------------------------------- // Open the slave pseudo terminal for the current master pseudo // terminal. A master pseudo terminal should already be valid prior to // calling this function (see PseudoTerminal::OpenFirstAvailableMaster()). @@ -95,7 +84,6 @@ PseudoTerminal::Status PseudoTerminal::OpenFirstAvailableMaster(int oflag) { // // RETURNS: // Zero when successful, non-zero indicating an error occurred. -//---------------------------------------------------------------------- PseudoTerminal::Status PseudoTerminal::OpenSlave(int oflag) { CloseSlave(); @@ -113,7 +101,6 @@ PseudoTerminal::Status PseudoTerminal::OpenSlave(int oflag) { return success; } -//---------------------------------------------------------------------- // Get the name of the slave pseudo terminal. A master pseudo terminal // should already be valid prior to calling this function (see // PseudoTerminal::OpenFirstAvailableMaster()). @@ -123,14 +110,12 @@ PseudoTerminal::Status PseudoTerminal::OpenSlave(int oflag) { // The name of the slave pseudo terminal as a NULL terminated C string // that comes from static memory, so a copy of the string should be // made as subsequent calls can change this value. -//---------------------------------------------------------------------- const char *PseudoTerminal::SlaveName() const { if (m_master_fd < 0) return NULL; return ::ptsname(m_master_fd); } -//---------------------------------------------------------------------- // Fork a child process that and have its stdio routed to a pseudo // terminal. // @@ -150,7 +135,6 @@ const char *PseudoTerminal::SlaveName() const { // RETURNS: // in the parent process: the pid of the child, or -1 if fork fails // in the child process: zero -//---------------------------------------------------------------------- pid_t PseudoTerminal::Fork(PseudoTerminal::Status &error) { pid_t pid = invalid_pid; diff --git a/lldb/tools/debugserver/source/PseudoTerminal.h b/lldb/tools/debugserver/source/PseudoTerminal.h index c14042a41c4..e4093bd98e9 100644 --- a/lldb/tools/debugserver/source/PseudoTerminal.h +++ b/lldb/tools/debugserver/source/PseudoTerminal.h @@ -35,9 +35,7 @@ public: err_dup2_failed_on_stdout = -11, err_dup2_failed_on_stderr = -12 }; - //------------------------------------------------------------------ // Constructors and Destructors - //------------------------------------------------------------------ PseudoTerminal(); ~PseudoTerminal(); @@ -69,16 +67,12 @@ public: pid_t Fork(Status &error); protected: - //------------------------------------------------------------------ // Classes that inherit from PseudoTerminal can see and modify these - //------------------------------------------------------------------ int m_master_fd; int m_slave_fd; private: - //------------------------------------------------------------------ // Outlaw copy and assignment constructors - //------------------------------------------------------------------ PseudoTerminal(const PseudoTerminal &rhs); PseudoTerminal &operator=(const PseudoTerminal &rhs); }; diff --git a/lldb/tools/debugserver/source/RNBContext.cpp b/lldb/tools/debugserver/source/RNBContext.cpp index 87f24ccf1b9..3f1a37a1175 100644 --- a/lldb/tools/debugserver/source/RNBContext.cpp +++ b/lldb/tools/debugserver/source/RNBContext.cpp @@ -25,14 +25,10 @@ #include "DNBLog.h" #include "RNBRemote.h" -//---------------------------------------------------------------------- // Destructor -//---------------------------------------------------------------------- RNBContext::~RNBContext() { SetProcessID(INVALID_NUB_PROCESS); } -//---------------------------------------------------------------------- // RNBContext constructor -//---------------------------------------------------------------------- const char *RNBContext::EnvironmentAtIndex(size_t index) { if (index < m_env_vec.size()) @@ -134,10 +130,8 @@ void RNBContext::StopProcessStatusThread() { } } -//---------------------------------------------------------------------- // This thread's sole purpose is to watch for any status changes in the // child process. -//---------------------------------------------------------------------- void *RNBContext::ThreadFunctionProcessStatus(void *arg) { RNBRemoteSP remoteSP(g_remoteSP); RNBRemote *remote = remoteSP.get(); diff --git a/lldb/tools/debugserver/source/RNBContext.h b/lldb/tools/debugserver/source/RNBContext.h index c2a0d3374d7..9159057329f 100644 --- a/lldb/tools/debugserver/source/RNBContext.h +++ b/lldb/tools/debugserver/source/RNBContext.h @@ -42,9 +42,7 @@ public: all_event_bits = sticky_event_bits | normal_event_bits } event_t; - //------------------------------------------------------------------ // Constructors and Destructors - //------------------------------------------------------------------ RNBContext() : m_pid(INVALID_NUB_PROCESS), m_pid_stop_count(0), m_events(0, all_event_bits), m_pid_pthread(), m_launch_status(), @@ -127,9 +125,7 @@ public: bool GetDetachOnError() { return m_detach_on_error; } protected: - //------------------------------------------------------------------ // Classes that inherit from RNBContext can see and modify these - //------------------------------------------------------------------ nub_process_t m_pid; std::string m_stdin; std::string m_stdout; @@ -153,9 +149,7 @@ protected: static void *ThreadFunctionProcessStatus(void *arg); private: - //------------------------------------------------------------------ // Outlaw copy and assignment operators - //------------------------------------------------------------------ RNBContext(const RNBContext &rhs); RNBContext &operator=(const RNBContext &rhs); }; diff --git a/lldb/tools/debugserver/source/RNBRemote.cpp b/lldb/tools/debugserver/source/RNBRemote.cpp index d67f5c8d47a..16c15f64c25 100644 --- a/lldb/tools/debugserver/source/RNBRemote.cpp +++ b/lldb/tools/debugserver/source/RNBRemote.cpp @@ -49,18 +49,14 @@ #include <sstream> #include <unordered_set> -//---------------------------------------------------------------------- // constants -//---------------------------------------------------------------------- static const std::string OS_LOG_EVENTS_KEY_NAME("events"); static const std::string JSON_ASYNC_TYPE_KEY_NAME("type"); static const DarwinLogEventVector::size_type DARWIN_LOG_MAX_EVENTS_PER_PACKET = 10; -//---------------------------------------------------------------------- // std::iostream formatting macros -//---------------------------------------------------------------------- #define RAW_HEXBASE std::setfill('0') << std::hex << std::right #define HEXBASE '0' << 'x' << RAW_HEXBASE #define RAWHEX8(x) RAW_HEXBASE << std::setw(2) << ((uint32_t)((uint8_t)x)) @@ -89,16 +85,12 @@ static const DarwinLogEventVector::size_type DARWIN_LOG_MAX_EVENTS_PER_PACKET = std::setfill('\t') << std::setw((iword_idx)) << "" // Class to handle communications via gdb remote protocol. -//---------------------------------------------------------------------- // Prototypes -//---------------------------------------------------------------------- static std::string binary_encode_string(const std::string &s); -//---------------------------------------------------------------------- // Decode a single hex character and return the hex value as a number or // -1 if "ch" is not a hex character. -//---------------------------------------------------------------------- static inline int xdigit_to_sint(char ch) { if (ch >= 'a' && ch <= 'f') return 10 + ch - 'a'; @@ -109,10 +101,8 @@ static inline int xdigit_to_sint(char ch) { return -1; } -//---------------------------------------------------------------------- // Decode a single hex ASCII byte. Return -1 on failure, a value 0-255 // on success. -//---------------------------------------------------------------------- static inline int decoded_hex_ascii_char(const char *p) { const int hi_nibble = xdigit_to_sint(p[0]); if (hi_nibble == -1) @@ -123,9 +113,7 @@ static inline int decoded_hex_ascii_char(const char *p) { return (uint8_t)((hi_nibble << 4) + lo_nibble); } -//---------------------------------------------------------------------- // Decode a hex ASCII string back into a string -//---------------------------------------------------------------------- static std::string decode_hex_ascii_string(const char *p, uint32_t max_length = UINT32_MAX) { std::string arg; @@ -4414,10 +4402,8 @@ rnb_err_t RNBRemote::HandlePacket_C(const char *p) { return rnb_success; } -//---------------------------------------------------------------------- // 'D' packet // Detach from gdb. -//---------------------------------------------------------------------- rnb_err_t RNBRemote::HandlePacket_D(const char *p) { if (m_ctx.HasValidProcessID()) { if (DNBProcessDetach(m_ctx.ProcessID())) @@ -5821,13 +5807,11 @@ static nub_addr_t GetMachHeaderForMainExecutable(const nub_process_t pid, DNBDataRef::offset_t offset = 0; data.SetPointerSize(addr_size); - //---------------------------------------------------------------------- // When we are sitting at __dyld_start, the kernel has placed the // address of the mach header of the main executable on the stack. If we // read the SP and dereference a pointer, we might find the mach header // for the executable. We also just make sure there is only 1 thread // since if we are at __dyld_start we shouldn't have multiple threads. - //---------------------------------------------------------------------- if (DNBProcessGetNumThreads(pid) == 1) { nub_thread_t tid = DNBProcessGetThreadAtIndex(pid, 0); if (tid != INVALID_NUB_THREAD) { @@ -5847,10 +5831,8 @@ static nub_addr_t GetMachHeaderForMainExecutable(const nub_process_t pid, } } - //---------------------------------------------------------------------- // Check the dyld_all_image_info structure for a list of mach header // since it is a very easy thing to check - //---------------------------------------------------------------------- if (shlib_addr != INVALID_NUB_ADDRESS) { bytes_read = DNBProcessMemoryRead(pid, shlib_addr, sizeof(AllImageInfos), bytes); @@ -5880,12 +5862,10 @@ static nub_addr_t GetMachHeaderForMainExecutable(const nub_process_t pid, } } - //---------------------------------------------------------------------- // We failed to find the executable's mach header from the all image // infos and by dereferencing the stack pointer. Now we fall back to // enumerating the memory regions and looking for regions that are // executable. - //---------------------------------------------------------------------- DNBRegionInfo region_info; mach_header_addr = 0; while (DNBProcessMemoryRegionInfo(pid, mach_header_addr, ®ion_info)) { diff --git a/lldb/tools/debugserver/source/StdStringExtractor.cpp b/lldb/tools/debugserver/source/StdStringExtractor.cpp index a52e8aba5d9..cb706a8f50c 100644 --- a/lldb/tools/debugserver/source/StdStringExtractor.cpp +++ b/lldb/tools/debugserver/source/StdStringExtractor.cpp @@ -21,9 +21,7 @@ static inline int xdigit_to_sint(char ch) { return -1; } -//---------------------------------------------------------------------- // StdStringExtractor constructor -//---------------------------------------------------------------------- StdStringExtractor::StdStringExtractor() : m_packet(), m_index(0) {} StdStringExtractor::StdStringExtractor(const char *packet_cstr) @@ -32,15 +30,11 @@ StdStringExtractor::StdStringExtractor(const char *packet_cstr) m_packet.assign(packet_cstr); } -//---------------------------------------------------------------------- // StdStringExtractor copy constructor -//---------------------------------------------------------------------- StdStringExtractor::StdStringExtractor(const StdStringExtractor &rhs) : m_packet(rhs.m_packet), m_index(rhs.m_index) {} -//---------------------------------------------------------------------- // StdStringExtractor assignment operator -//---------------------------------------------------------------------- const StdStringExtractor &StdStringExtractor:: operator=(const StdStringExtractor &rhs) { if (this != &rhs) { @@ -50,9 +44,7 @@ operator=(const StdStringExtractor &rhs) { return *this; } -//---------------------------------------------------------------------- // Destructor -//---------------------------------------------------------------------- StdStringExtractor::~StdStringExtractor() {} char StdStringExtractor::GetChar(char fail_value) { @@ -65,14 +57,12 @@ char StdStringExtractor::GetChar(char fail_value) { return fail_value; } -//---------------------------------------------------------------------- // If a pair of valid hex digits exist at the head of the // StdStringExtractor they are decoded into an unsigned byte and returned // by this function // // If there is not a pair of valid hex digits at the head of the // StdStringExtractor, it is left unchanged and -1 is returned -//---------------------------------------------------------------------- int StdStringExtractor::DecodeHexU8() { SkipSpaces(); if (GetBytesLeft() < 2) { @@ -87,10 +77,8 @@ int StdStringExtractor::DecodeHexU8() { return (uint8_t)((hi_nibble << 4) + lo_nibble); } -//---------------------------------------------------------------------- // Extract an unsigned character from two hex ASCII chars in the packet // string, or return fail_value on failure -//---------------------------------------------------------------------- uint8_t StdStringExtractor::GetHexU8(uint8_t fail_value, bool set_eof_on_fail) { // On success, fail_value will be overwritten with the next // character in the stream @@ -290,12 +278,10 @@ size_t StdStringExtractor::GetHexBytes(void *dst_void, size_t dst_len, return bytes_extracted; } -//---------------------------------------------------------------------- // Decodes all valid hex encoded bytes at the head of the // StdStringExtractor, limited by dst_len. // // Returns the number of bytes successfully decoded -//---------------------------------------------------------------------- size_t StdStringExtractor::GetHexBytesAvail(void *dst_void, size_t dst_len) { uint8_t *dst = (uint8_t *)dst_void; size_t bytes_extracted = 0; diff --git a/lldb/tools/debugserver/source/StdStringExtractor.h b/lldb/tools/debugserver/source/StdStringExtractor.h index cc256f5655f..d3edfb2f461 100644 --- a/lldb/tools/debugserver/source/StdStringExtractor.h +++ b/lldb/tools/debugserver/source/StdStringExtractor.h @@ -18,17 +18,13 @@ class StdStringExtractor { public: enum { BigEndian = 0, LittleEndian = 1 }; - //------------------------------------------------------------------ // Constructors and Destructors - //------------------------------------------------------------------ StdStringExtractor(); StdStringExtractor(const char *packet_cstr); StdStringExtractor(const StdStringExtractor &rhs); virtual ~StdStringExtractor(); - //------------------------------------------------------------------ // Operators - //------------------------------------------------------------------ const StdStringExtractor &operator=(const StdStringExtractor &rhs); // Returns true if the file position is still valid for the data @@ -107,9 +103,7 @@ public: } protected: - //------------------------------------------------------------------ // For StdStringExtractor only - //------------------------------------------------------------------ std::string m_packet; // The string in which to extract data. uint64_t m_index; // When extracting data from a packet, this index // will march along as things get extracted. If set diff --git a/lldb/tools/debugserver/source/debugserver.cpp b/lldb/tools/debugserver/source/debugserver.cpp index c360a46aed5..1463ff906cf 100644 --- a/lldb/tools/debugserver/source/debugserver.cpp +++ b/lldb/tools/debugserver/source/debugserver.cpp @@ -45,9 +45,7 @@ extern "C" int proc_set_wakemon_params(pid_t, int, // Global PID in case we get a signal and need to stop the process... nub_process_t g_pid = INVALID_NUB_PROCESS; -//---------------------------------------------------------------------- // Run loop modes which determine which run loop function will be called -//---------------------------------------------------------------------- typedef enum { eRNBRunLoopModeInvalid = 0, eRNBRunLoopModeGetStartModeFromRemoteProtocol, @@ -58,9 +56,7 @@ typedef enum { eRNBRunLoopModeExit } RNBRunLoopMode; -//---------------------------------------------------------------------- // Global Variables -//---------------------------------------------------------------------- RNBRemoteSP g_remoteSP; static int g_lockdown_opt = 0; static int g_applist_opt = 0; @@ -87,12 +83,10 @@ bool g_detach_on_error = true; } \ } while (0) -//---------------------------------------------------------------------- // Get our program path and arguments from the remote connection. // We will need to start up the remote connection without a PID, get the // arguments, wait for the new process to finish launching and hit its // entry point, and then return the run loop mode that should come next. -//---------------------------------------------------------------------- RNBRunLoopMode RNBRunLoopGetStartModeFromRemote(RNBRemote *remote) { std::string packet; @@ -162,12 +156,10 @@ RNBRunLoopMode RNBRunLoopGetStartModeFromRemote(RNBRemote *remote) { return eRNBRunLoopModeExit; } -//---------------------------------------------------------------------- // This run loop mode will wait for the process to launch and hit its // entry point. It will currently ignore all events except for the // process state changed event, where it watches for the process stopped // or crash process state. -//---------------------------------------------------------------------- RNBRunLoopMode RNBRunLoopLaunchInferior(RNBRemote *remote, const char *stdin_path, const char *stdout_path, @@ -351,12 +343,10 @@ RNBRunLoopMode RNBRunLoopLaunchInferior(RNBRemote *remote, return eRNBRunLoopModeExit; } -//---------------------------------------------------------------------- // This run loop mode will wait for the process to launch and hit its // entry point. It will currently ignore all events except for the // process state changed event, where it watches for the process stopped // or crash process state. -//---------------------------------------------------------------------- RNBRunLoopMode RNBRunLoopLaunchAttaching(RNBRemote *remote, nub_process_t attach_pid, nub_process_t &pid) { @@ -379,11 +369,9 @@ RNBRunLoopMode RNBRunLoopLaunchAttaching(RNBRemote *remote, } } -//---------------------------------------------------------------------- // Watch for signals: // SIGINT: so we can halt our inferior. (disabled for now) // SIGPIPE: in case our child process dies -//---------------------------------------------------------------------- int g_sigint_received = 0; int g_sigpipe_received = 0; void signal_handler(int signo) { @@ -654,10 +642,8 @@ RNBRunLoopMode RNBRunLoopPlatform(RNBRemote *remote) { return eRNBRunLoopModeExit; } -//---------------------------------------------------------------------- // Convenience function to set up the remote listening port // Returns 1 for success 0 for failure. -//---------------------------------------------------------------------- static void PortWasBoundCallbackUnixSocket(const void *baton, in_port_t port) { //::printf ("PortWasBoundCallbackUnixSocket (baton = %p, port = %u)\n", baton, @@ -761,9 +747,7 @@ static int ConnectRemote(RNBRemote *remote, const char *host, int port, return 1; } -//---------------------------------------------------------------------- // ASL Logging callback that can be registered with DNBLogSetLogCallback -//---------------------------------------------------------------------- void ASLLogCallback(void *baton, uint32_t flags, const char *format, va_list args) { if (format == NULL) @@ -792,10 +776,8 @@ void ASLLogCallback(void *baton, uint32_t flags, const char *format, ::asl_vlog(NULL, g_aslmsg, asl_level, format, args); } -//---------------------------------------------------------------------- // FILE based Logging callback that can be registered with // DNBLogSetLogCallback -//---------------------------------------------------------------------- void FileLogCallback(void *baton, uint32_t flags, const char *format, va_list args) { if (baton == NULL || format == NULL) @@ -821,9 +803,7 @@ void show_usage_and_exit(int exit_code) { exit(exit_code); } -//---------------------------------------------------------------------- // option descriptors for getopt_long_only() -//---------------------------------------------------------------------- static struct option g_long_options[] = { {"attach", required_argument, NULL, 'a'}, {"arch", required_argument, NULL, 'A'}, @@ -890,9 +870,7 @@ static struct option g_long_options[] = { // -F localhost:1234 -- /bin/ls" {NULL, 0, NULL, 0}}; -//---------------------------------------------------------------------- // main -//---------------------------------------------------------------------- int main(int argc, char *argv[]) { // If debugserver is launched with DYLD_INSERT_LIBRARIES, unset it so we // don't spawn child processes with this enabled. diff --git a/lldb/tools/debugserver/source/libdebugserver.cpp b/lldb/tools/debugserver/source/libdebugserver.cpp index 450ce41de25..e545caf5ae8 100644 --- a/lldb/tools/debugserver/source/libdebugserver.cpp +++ b/lldb/tools/debugserver/source/libdebugserver.cpp @@ -26,9 +26,7 @@ #include "RNBSocket.h" #include "SysSignal.h" -//---------------------------------------------------------------------- // Run loop modes which determine which run loop function will be called -//---------------------------------------------------------------------- typedef enum { eRNBRunLoopModeInvalid = 0, eRNBRunLoopModeGetStartModeFromRemoteProtocol, @@ -36,9 +34,7 @@ typedef enum { eRNBRunLoopModeExit } RNBRunLoopMode; -//---------------------------------------------------------------------- // Global Variables -//---------------------------------------------------------------------- RNBRemoteSP g_remoteSP; int g_disable_aslr = 0; int g_isatty = 0; @@ -60,12 +56,10 @@ int g_isatty = 0; } \ } while (0) -//---------------------------------------------------------------------- // Get our program path and arguments from the remote connection. // We will need to start up the remote connection without a PID, get the // arguments, wait for the new process to finish launching and hit its // entry point, and then return the run loop mode that should come next. -//---------------------------------------------------------------------- RNBRunLoopMode RNBRunLoopGetStartModeFromRemote(RNBRemoteSP &remoteSP) { std::string packet; @@ -125,11 +119,9 @@ RNBRunLoopMode RNBRunLoopGetStartModeFromRemote(RNBRemoteSP &remoteSP) { return eRNBRunLoopModeExit; } -//---------------------------------------------------------------------- // Watch for signals: // SIGINT: so we can halt our inferior. (disabled for now) // SIGPIPE: in case our child process dies -//---------------------------------------------------------------------- nub_process_t g_pid; int g_sigpipe_received = 0; void signal_handler(int signo) { |
