*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 199 insertions, 219 deletions

diff --git a/lldb/source/Host/freebsd/Host.cpp b/lldb/source/Host/freebsd/Host.cpp
index cf53cda40b1..5b1576260f3 100644
--- a/lldb/source/Host/freebsd/Host.cpp
+++ b/lldb/source/Host/freebsd/Host.cpp
@@ -1,4 +1,5 @@
-//===-- source/Host/freebsd/Host.cpp ------------------------------*- C++ -*-===//
+//===-- source/Host/freebsd/Host.cpp ------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -8,32 +9,32 @@
 //===----------------------------------------------------------------------===//
 
 // C Includes
-#include <stdio.h>
 #include <dlfcn.h>
 #include <execinfo.h>
+#include <stdio.h>
+#include <sys/proc.h>
+#include <sys/sysctl.h>
 #include <sys/types.h>
 #include <sys/user.h>
-#include <sys/sysctl.h>
-#include <sys/proc.h>
 
-#include <sys/ptrace.h>
-#include <sys/exec.h>
 #include <machine/elf.h>
+#include <sys/exec.h>
+#include <sys/ptrace.h>
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
+#include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Error.h"
-#include "lldb/Host/Endian.h"
-#include "lldb/Host/Host.h"
-#include "lldb/Host/HostInfo.h"
+#include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StreamString.h"
-#include "lldb/Core/Log.h"
-#include "lldb/Target/Process.h"
+#include "lldb/Host/Endian.h"
+#include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Platform.h"
+#include "lldb/Target/Process.h"
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataExtractor.h"
@@ -43,241 +44,220 @@
 #include "llvm/Support/Host.h"
 
 extern "C" {
-    extern char **environ;
+extern char **environ;
 }
 
 using namespace lldb;
 using namespace lldb_private;
 
-size_t
-Host::GetEnvironment (StringList &env)
-{
-    char *v;
-    char **var = environ;
-    for (; var != NULL && *var != NULL; ++var)
-    {
-        v = strchr(*var, (int)'-');
-        if (v == NULL)
-            continue;
-        env.AppendString(v);
-    }
-    return env.GetSize();
+size_t Host::GetEnvironment(StringList &env) {
+  char *v;
+  char **var = environ;
+  for (; var != NULL && *var != NULL; ++var) {
+    v = strchr(*var, (int)'-');
+    if (v == NULL)
+      continue;
+    env.AppendString(v);
+  }
+  return env.GetSize();
 }
 
 static bool
-GetFreeBSDProcessArgs (const ProcessInstanceInfoMatch *match_info_ptr,
-                      ProcessInstanceInfo &process_info)
-{
-    if (process_info.ProcessIDIsValid())
-    {
-        int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_ARGS, (int)process_info.GetProcessID() };
-
-        char arg_data[8192];
-        size_t arg_data_size = sizeof(arg_data);
-        if (::sysctl (mib, 4, arg_data, &arg_data_size , NULL, 0) == 0)
-        {
-            DataExtractor data (arg_data, arg_data_size, endian::InlHostByteOrder(), sizeof(void *));
-            lldb::offset_t offset = 0;
-            const char *cstr;
-
-            cstr = data.GetCStr (&offset);
-            if (cstr)
-            {
-                process_info.GetExecutableFile().SetFile(cstr, false);
-
-                if (!(match_info_ptr == NULL ||
-                    NameMatches (process_info.GetExecutableFile().GetFilename().GetCString(),
-                                 match_info_ptr->GetNameMatchType(),
-                                 match_info_ptr->GetProcessInfo().GetName())))
-                    return false;
-
-                Args &proc_args = process_info.GetArguments();
-                while (1)
-                {
-                    const uint8_t *p = data.PeekData(offset, 1);
-                    while ((p != NULL) && (*p == '\0') && offset < arg_data_size)
-                    {
-                        ++offset;
-                        p = data.PeekData(offset, 1);
-                    }
-                    if (p == NULL || offset >= arg_data_size)
-                        return true;
-
-                    cstr = data.GetCStr(&offset);
-                    if (cstr)
-                        proc_args.AppendArgument(cstr);
-                    else
-                        return true;
-                }
-            }
+GetFreeBSDProcessArgs(const ProcessInstanceInfoMatch *match_info_ptr,
+                      ProcessInstanceInfo &process_info) {
+  if (process_info.ProcessIDIsValid()) {
+    int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_ARGS,
+                  (int)process_info.GetProcessID()};
+
+    char arg_data[8192];
+    size_t arg_data_size = sizeof(arg_data);
+    if (::sysctl(mib, 4, arg_data, &arg_data_size, NULL, 0) == 0) {
+      DataExtractor data(arg_data, arg_data_size, endian::InlHostByteOrder(),
+                         sizeof(void *));
+      lldb::offset_t offset = 0;
+      const char *cstr;
+
+      cstr = data.GetCStr(&offset);
+      if (cstr) {
+        process_info.GetExecutableFile().SetFile(cstr, false);
+
+        if (!(match_info_ptr == NULL ||
+              NameMatches(
+                  process_info.GetExecutableFile().GetFilename().GetCString(),
+                  match_info_ptr->GetNameMatchType(),
+                  match_info_ptr->GetProcessInfo().GetName())))
+          return false;
+
+        Args &proc_args = process_info.GetArguments();
+        while (1) {
+          const uint8_t *p = data.PeekData(offset, 1);
+          while ((p != NULL) && (*p == '\0') && offset < arg_data_size) {
+            ++offset;
+            p = data.PeekData(offset, 1);
+          }
+          if (p == NULL || offset >= arg_data_size)
+            return true;
+
+          cstr = data.GetCStr(&offset);
+          if (cstr)
+            proc_args.AppendArgument(cstr);
+          else
+            return true;
         }
+      }
     }
-    return false;
+  }
+  return false;
 }
 
-static bool
-GetFreeBSDProcessCPUType (ProcessInstanceInfo &process_info)
-{
-    if (process_info.ProcessIDIsValid())
-    {
-        process_info.GetArchitecture() = HostInfo::GetArchitecture(HostInfo::eArchKindDefault);
-        return true;
-    }
-    process_info.GetArchitecture().Clear();
-    return false;
+static bool GetFreeBSDProcessCPUType(ProcessInstanceInfo &process_info) {
+  if (process_info.ProcessIDIsValid()) {
+    process_info.GetArchitecture() =
+        HostInfo::GetArchitecture(HostInfo::eArchKindDefault);
+    return true;
+  }
+  process_info.GetArchitecture().Clear();
+  return false;
 }
 
-static bool
-GetFreeBSDProcessUserAndGroup(ProcessInstanceInfo &process_info)
-{
-    struct kinfo_proc proc_kinfo;
-    size_t proc_kinfo_size;
-
-    if (process_info.ProcessIDIsValid())
-    {
-        int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID,
-            (int)process_info.GetProcessID() };
-        proc_kinfo_size = sizeof(struct kinfo_proc);
-
-        if (::sysctl (mib, 4, &proc_kinfo, &proc_kinfo_size, NULL, 0) == 0)
-        {
-            if (proc_kinfo_size > 0)
-            {
-                process_info.SetParentProcessID (proc_kinfo.ki_ppid);
-                process_info.SetUserID (proc_kinfo.ki_ruid);
-                process_info.SetGroupID (proc_kinfo.ki_rgid);
-                process_info.SetEffectiveUserID (proc_kinfo.ki_uid);
-                if (proc_kinfo.ki_ngroups > 0)
-                    process_info.SetEffectiveGroupID (proc_kinfo.ki_groups[0]);
-                else
-                    process_info.SetEffectiveGroupID (UINT32_MAX);
-                return true;
-            }
-        }
+static bool GetFreeBSDProcessUserAndGroup(ProcessInstanceInfo &process_info) {
+  struct kinfo_proc proc_kinfo;
+  size_t proc_kinfo_size;
+
+  if (process_info.ProcessIDIsValid()) {
+    int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID,
+                  (int)process_info.GetProcessID()};
+    proc_kinfo_size = sizeof(struct kinfo_proc);
+
+    if (::sysctl(mib, 4, &proc_kinfo, &proc_kinfo_size, NULL, 0) == 0) {
+      if (proc_kinfo_size > 0) {
+        process_info.SetParentProcessID(proc_kinfo.ki_ppid);
+        process_info.SetUserID(proc_kinfo.ki_ruid);
+        process_info.SetGroupID(proc_kinfo.ki_rgid);
+        process_info.SetEffectiveUserID(proc_kinfo.ki_uid);
+        if (proc_kinfo.ki_ngroups > 0)
+          process_info.SetEffectiveGroupID(proc_kinfo.ki_groups[0]);
+        else
+          process_info.SetEffectiveGroupID(UINT32_MAX);
+        return true;
+      }
     }
-    process_info.SetParentProcessID (LLDB_INVALID_PROCESS_ID);
-    process_info.SetUserID (UINT32_MAX);
-    process_info.SetGroupID (UINT32_MAX);
-    process_info.SetEffectiveUserID (UINT32_MAX);
-    process_info.SetEffectiveGroupID (UINT32_MAX);
-    return false;
+  }
+  process_info.SetParentProcessID(LLDB_INVALID_PROCESS_ID);
+  process_info.SetUserID(UINT32_MAX);
+  process_info.SetGroupID(UINT32_MAX);
+  process_info.SetEffectiveUserID(UINT32_MAX);
+  process_info.SetEffectiveGroupID(UINT32_MAX);
+  return false;
 }
 
-uint32_t
-Host::FindProcesses (const ProcessInstanceInfoMatch &match_info, ProcessInstanceInfoList &process_infos)
-{
-    std::vector<struct kinfo_proc> kinfos;
-
-    int mib[3] = { CTL_KERN, KERN_PROC, KERN_PROC_ALL };
-
-    size_t pid_data_size = 0;
-    if (::sysctl (mib, 3, NULL, &pid_data_size, NULL, 0) != 0)
-        return 0;
-
-    // Add a few extra in case a few more show up
-    const size_t estimated_pid_count = (pid_data_size / sizeof(struct kinfo_proc)) + 10;
-
-    kinfos.resize (estimated_pid_count);
-    pid_data_size = kinfos.size() * sizeof(struct kinfo_proc);
-
-    if (::sysctl (mib, 3, &kinfos[0], &pid_data_size, NULL, 0) != 0)
-        return 0;
-
-    const size_t actual_pid_count = (pid_data_size / sizeof(struct kinfo_proc));
-
-    bool all_users = match_info.GetMatchAllUsers();
-    const ::pid_t our_pid = getpid();
-    const uid_t our_uid = getuid();
-    for (size_t i = 0; i < actual_pid_count; i++)
-    {
-        const struct kinfo_proc &kinfo = kinfos[i];
-        const bool kinfo_user_matches = (all_users ||
-                                         (kinfo.ki_ruid == our_uid) ||
-                                         // Special case, if lldb is being run as root we can attach to anything.
-                                         (our_uid == 0)
-                                         );
-
-        if (kinfo_user_matches == false      || // Make sure the user is acceptable
-            kinfo.ki_pid == our_pid          || // Skip this process
-            kinfo.ki_pid == 0                || // Skip kernel (kernel pid is zero)
-            kinfo.ki_stat == SZOMB    || // Zombies are bad, they like brains...
-            kinfo.ki_flag & P_TRACED  || // Being debugged?
-            kinfo.ki_flag & P_WEXIT)     // Working on exiting
-            continue;
-
-        // Every thread is a process in FreeBSD, but all the threads of a single process
-        // have the same pid. Do not store the process info in the result list if a process
-        // with given identifier is already registered there.
-        bool already_registered = false;
-        for (uint32_t pi = 0;
-             !already_registered &&
-             (const int)kinfo.ki_numthreads > 1 &&
-             pi < (const uint32_t)process_infos.GetSize(); pi++)
-            already_registered = (process_infos.GetProcessIDAtIndex(pi) == (uint32_t)kinfo.ki_pid);
-
-        if (already_registered)
-            continue;
-
-        ProcessInstanceInfo process_info;
-        process_info.SetProcessID (kinfo.ki_pid);
-        process_info.SetParentProcessID (kinfo.ki_ppid);
-        process_info.SetUserID (kinfo.ki_ruid);
-        process_info.SetGroupID (kinfo.ki_rgid);
-        process_info.SetEffectiveUserID (kinfo.ki_svuid);
-        process_info.SetEffectiveGroupID (kinfo.ki_svgid);
-
-        // Make sure our info matches before we go fetch the name and cpu type
-        if (match_info.Matches (process_info) &&
-            GetFreeBSDProcessArgs (&match_info, process_info))
-        {
-            GetFreeBSDProcessCPUType (process_info);
-            if (match_info.Matches (process_info))
-                process_infos.Append (process_info);
-        }
+uint32_t Host::FindProcesses(const ProcessInstanceInfoMatch &match_info,
+                             ProcessInstanceInfoList &process_infos) {
+  std::vector<struct kinfo_proc> kinfos;
+
+  int mib[3] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL};
+
+  size_t pid_data_size = 0;
+  if (::sysctl(mib, 3, NULL, &pid_data_size, NULL, 0) != 0)
+    return 0;
+
+  // Add a few extra in case a few more show up
+  const size_t estimated_pid_count =
+      (pid_data_size / sizeof(struct kinfo_proc)) + 10;
+
+  kinfos.resize(estimated_pid_count);
+  pid_data_size = kinfos.size() * sizeof(struct kinfo_proc);
+
+  if (::sysctl(mib, 3, &kinfos[0], &pid_data_size, NULL, 0) != 0)
+    return 0;
+
+  const size_t actual_pid_count = (pid_data_size / sizeof(struct kinfo_proc));
+
+  bool all_users = match_info.GetMatchAllUsers();
+  const ::pid_t our_pid = getpid();
+  const uid_t our_uid = getuid();
+  for (size_t i = 0; i < actual_pid_count; i++) {
+    const struct kinfo_proc &kinfo = kinfos[i];
+    const bool kinfo_user_matches = (all_users || (kinfo.ki_ruid == our_uid) ||
+                                     // Special case, if lldb is being run as
+                                     // root we can attach to anything.
+                                     (our_uid == 0));
+
+    if (kinfo_user_matches == false || // Make sure the user is acceptable
+        kinfo.ki_pid == our_pid ||     // Skip this process
+        kinfo.ki_pid == 0 ||           // Skip kernel (kernel pid is zero)
+        kinfo.ki_stat == SZOMB ||      // Zombies are bad, they like brains...
+        kinfo.ki_flag & P_TRACED ||    // Being debugged?
+        kinfo.ki_flag & P_WEXIT)       // Working on exiting
+      continue;
+
+    // Every thread is a process in FreeBSD, but all the threads of a single
+    // process
+    // have the same pid. Do not store the process info in the result list if a
+    // process
+    // with given identifier is already registered there.
+    bool already_registered = false;
+    for (uint32_t pi = 0;
+         !already_registered && (const int)kinfo.ki_numthreads > 1 &&
+         pi < (const uint32_t)process_infos.GetSize();
+         pi++)
+      already_registered =
+          (process_infos.GetProcessIDAtIndex(pi) == (uint32_t)kinfo.ki_pid);
+
+    if (already_registered)
+      continue;
+
+    ProcessInstanceInfo process_info;
+    process_info.SetProcessID(kinfo.ki_pid);
+    process_info.SetParentProcessID(kinfo.ki_ppid);
+    process_info.SetUserID(kinfo.ki_ruid);
+    process_info.SetGroupID(kinfo.ki_rgid);
+    process_info.SetEffectiveUserID(kinfo.ki_svuid);
+    process_info.SetEffectiveGroupID(kinfo.ki_svgid);
+
+    // Make sure our info matches before we go fetch the name and cpu type
+    if (match_info.Matches(process_info) &&
+        GetFreeBSDProcessArgs(&match_info, process_info)) {
+      GetFreeBSDProcessCPUType(process_info);
+      if (match_info.Matches(process_info))
+        process_infos.Append(process_info);
     }
+  }
 
-    return process_infos.GetSize();
+  return process_infos.GetSize();
 }
 
-bool
-Host::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info)
-{
-    process_info.SetProcessID(pid);
+bool Host::GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &process_info) {
+  process_info.SetProcessID(pid);
 
-    if (GetFreeBSDProcessArgs(NULL, process_info))
-    {
-        // should use libprocstat instead of going right into sysctl?
-        GetFreeBSDProcessCPUType(process_info);
-        GetFreeBSDProcessUserAndGroup(process_info);
-        return true;
-    }
+  if (GetFreeBSDProcessArgs(NULL, process_info)) {
+    // should use libprocstat instead of going right into sysctl?
+    GetFreeBSDProcessCPUType(process_info);
+    GetFreeBSDProcessUserAndGroup(process_info);
+    return true;
+  }
 
-    process_info.Clear();
-    return false;
+  process_info.Clear();
+  return false;
 }
 
-lldb::DataBufferSP
-Host::GetAuxvData(lldb_private::Process *process)
-{
-   int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_AUXV, 0 };
-   size_t auxv_size = AT_COUNT * sizeof(Elf_Auxinfo);
-   DataBufferSP buf_sp;
+lldb::DataBufferSP Host::GetAuxvData(lldb_private::Process *process) {
+  int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_AUXV, 0};
+  size_t auxv_size = AT_COUNT * sizeof(Elf_Auxinfo);
+  DataBufferSP buf_sp;
 
-   std::unique_ptr<DataBufferHeap> buf_ap(new DataBufferHeap(auxv_size, 0));
+  std::unique_ptr<DataBufferHeap> buf_ap(new DataBufferHeap(auxv_size, 0));
 
-   mib[3] = process->GetID();
-   if (::sysctl(mib, 4, buf_ap->GetBytes(), &auxv_size, NULL, 0) == 0) {
-           buf_sp.reset(buf_ap.release());
-   } else {
-           perror("sysctl failed on auxv");
-   }
+  mib[3] = process->GetID();
+  if (::sysctl(mib, 4, buf_ap->GetBytes(), &auxv_size, NULL, 0) == 0) {
+    buf_sp.reset(buf_ap.release());
+  } else {
+    perror("sysctl failed on auxv");
+  }
 
-   return buf_sp;
+  return buf_sp;
 }
 
-Error
-Host::ShellExpandArguments (ProcessLaunchInfo &launch_info)
-{
-    return Error("unimplemented");
+Error Host::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
+  return Error("unimplemented");
 }
-